mirror of
https://gitee.com/vant-contrib/vant.git
synced 2025-04-05 19:41:42 +08:00
17760 lines
608 KiB
JavaScript
17760 lines
608 KiB
JavaScript
/******/ (function(modules) { // webpackBootstrap
|
|
/******/ // install a JSONP callback for chunk loading
|
|
/******/ var parentJsonpFunction = window["webpackJsonp"];
|
|
/******/ window["webpackJsonp"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {
|
|
/******/ // add "moreModules" to the modules object,
|
|
/******/ // then flag all "chunkIds" as loaded and fire callback
|
|
/******/ var moduleId, chunkId, i = 0, resolves = [], result;
|
|
/******/ for(;i < chunkIds.length; i++) {
|
|
/******/ chunkId = chunkIds[i];
|
|
/******/ if(installedChunks[chunkId])
|
|
/******/ resolves.push(installedChunks[chunkId][0]);
|
|
/******/ installedChunks[chunkId] = 0;
|
|
/******/ }
|
|
/******/ for(moduleId in moreModules) {
|
|
/******/ if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
|
|
/******/ modules[moduleId] = moreModules[moduleId];
|
|
/******/ }
|
|
/******/ }
|
|
/******/ if(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);
|
|
/******/ while(resolves.length)
|
|
/******/ resolves.shift()();
|
|
/******/
|
|
/******/ };
|
|
/******/
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // objects to store loaded and loading chunks
|
|
/******/ var installedChunks = {
|
|
/******/ 1: 0
|
|
/******/ };
|
|
/******/
|
|
/******/ // 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;
|
|
/******/ }
|
|
/******/
|
|
/******/ // This file contains only the entry chunk.
|
|
/******/ // The chunk loading function for additional chunks
|
|
/******/ __webpack_require__.e = function requireEnsure(chunkId) {
|
|
/******/ if(installedChunks[chunkId] === 0)
|
|
/******/ return Promise.resolve();
|
|
/******/
|
|
/******/ // an Promise means "currently loading".
|
|
/******/ if(installedChunks[chunkId]) {
|
|
/******/ return installedChunks[chunkId][2];
|
|
/******/ }
|
|
/******/ // start chunk loading
|
|
/******/ var head = document.getElementsByTagName('head')[0];
|
|
/******/ var script = document.createElement('script');
|
|
/******/ script.type = 'text/javascript';
|
|
/******/ script.charset = 'utf-8';
|
|
/******/ script.async = true;
|
|
/******/ script.timeout = 120000;
|
|
/******/
|
|
/******/ if (__webpack_require__.nc) {
|
|
/******/ script.setAttribute("nonce", __webpack_require__.nc);
|
|
/******/ }
|
|
/******/ script.src = __webpack_require__.p + "" + chunkId + ".js";
|
|
/******/ var timeout = setTimeout(onScriptComplete, 120000);
|
|
/******/ script.onerror = script.onload = onScriptComplete;
|
|
/******/ function onScriptComplete() {
|
|
/******/ // avoid mem leaks in IE.
|
|
/******/ script.onerror = script.onload = null;
|
|
/******/ clearTimeout(timeout);
|
|
/******/ var chunk = installedChunks[chunkId];
|
|
/******/ if(chunk !== 0) {
|
|
/******/ if(chunk) chunk[1](new Error('Loading chunk ' + chunkId + ' failed.'));
|
|
/******/ installedChunks[chunkId] = undefined;
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ var promise = new Promise(function(resolve, reject) {
|
|
/******/ installedChunks[chunkId] = [resolve, reject];
|
|
/******/ });
|
|
/******/ installedChunks[chunkId][2] = promise;
|
|
/******/
|
|
/******/ head.appendChild(script);
|
|
/******/ return promise;
|
|
/******/ };
|
|
/******/
|
|
/******/ // 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 = "docs/build";
|
|
/******/
|
|
/******/ // on error function for async loading
|
|
/******/ __webpack_require__.oe = function(err) { console.error(err); throw err; };
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 211);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var bind = __webpack_require__(34);
|
|
|
|
/*global toString:true*/
|
|
|
|
// utils is a library of generic helper functions non-specific to axios
|
|
|
|
var toString = Object.prototype.toString;
|
|
|
|
/**
|
|
* Determine if a value is an Array
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is an Array, otherwise false
|
|
*/
|
|
function isArray(val) {
|
|
return toString.call(val) === '[object Array]';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is an ArrayBuffer
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is an ArrayBuffer, otherwise false
|
|
*/
|
|
function isArrayBuffer(val) {
|
|
return toString.call(val) === '[object ArrayBuffer]';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a FormData
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is an FormData, otherwise false
|
|
*/
|
|
function isFormData(val) {
|
|
return (typeof FormData !== 'undefined') && (val instanceof FormData);
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a view on an ArrayBuffer
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
|
|
*/
|
|
function isArrayBufferView(val) {
|
|
var result;
|
|
if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
|
|
result = ArrayBuffer.isView(val);
|
|
} else {
|
|
result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a String
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a String, otherwise false
|
|
*/
|
|
function isString(val) {
|
|
return typeof val === 'string';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a Number
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a Number, otherwise false
|
|
*/
|
|
function isNumber(val) {
|
|
return typeof val === 'number';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is undefined
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if the value is undefined, otherwise false
|
|
*/
|
|
function isUndefined(val) {
|
|
return typeof val === 'undefined';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is an Object
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is an Object, otherwise false
|
|
*/
|
|
function isObject(val) {
|
|
return val !== null && typeof val === 'object';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a Date
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a Date, otherwise false
|
|
*/
|
|
function isDate(val) {
|
|
return toString.call(val) === '[object Date]';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a File
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a File, otherwise false
|
|
*/
|
|
function isFile(val) {
|
|
return toString.call(val) === '[object File]';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a Blob
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a Blob, otherwise false
|
|
*/
|
|
function isBlob(val) {
|
|
return toString.call(val) === '[object Blob]';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a Function
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a Function, otherwise false
|
|
*/
|
|
function isFunction(val) {
|
|
return toString.call(val) === '[object Function]';
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a Stream
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a Stream, otherwise false
|
|
*/
|
|
function isStream(val) {
|
|
return isObject(val) && isFunction(val.pipe);
|
|
}
|
|
|
|
/**
|
|
* Determine if a value is a URLSearchParams object
|
|
*
|
|
* @param {Object} val The value to test
|
|
* @returns {boolean} True if value is a URLSearchParams object, otherwise false
|
|
*/
|
|
function isURLSearchParams(val) {
|
|
return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
|
|
}
|
|
|
|
/**
|
|
* Trim excess whitespace off the beginning and end of a string
|
|
*
|
|
* @param {String} str The String to trim
|
|
* @returns {String} The String freed of excess whitespace
|
|
*/
|
|
function trim(str) {
|
|
return str.replace(/^\s*/, '').replace(/\s*$/, '');
|
|
}
|
|
|
|
/**
|
|
* Determine if we're running in a standard browser environment
|
|
*
|
|
* This allows axios to run in a web worker, and react-native.
|
|
* Both environments support XMLHttpRequest, but not fully standard globals.
|
|
*
|
|
* web workers:
|
|
* typeof window -> undefined
|
|
* typeof document -> undefined
|
|
*
|
|
* react-native:
|
|
* typeof document.createElement -> undefined
|
|
*/
|
|
function isStandardBrowserEnv() {
|
|
return (
|
|
typeof window !== 'undefined' &&
|
|
typeof document !== 'undefined' &&
|
|
typeof document.createElement === 'function'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Iterate over an Array or an Object invoking a function for each item.
|
|
*
|
|
* If `obj` is an Array callback will be called passing
|
|
* the value, index, and complete array for each item.
|
|
*
|
|
* If 'obj' is an Object callback will be called passing
|
|
* the value, key, and complete object for each property.
|
|
*
|
|
* @param {Object|Array} obj The object to iterate
|
|
* @param {Function} fn The callback to invoke for each item
|
|
*/
|
|
function forEach(obj, fn) {
|
|
// Don't bother if no value provided
|
|
if (obj === null || typeof obj === 'undefined') {
|
|
return;
|
|
}
|
|
|
|
// Force an array if not already something iterable
|
|
if (typeof obj !== 'object' && !isArray(obj)) {
|
|
/*eslint no-param-reassign:0*/
|
|
obj = [obj];
|
|
}
|
|
|
|
if (isArray(obj)) {
|
|
// Iterate over array values
|
|
for (var i = 0, l = obj.length; i < l; i++) {
|
|
fn.call(null, obj[i], i, obj);
|
|
}
|
|
} else {
|
|
// Iterate over object keys
|
|
for (var key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
fn.call(null, obj[key], key, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Accepts varargs expecting each argument to be an object, then
|
|
* immutably merges the properties of each object and returns result.
|
|
*
|
|
* When multiple objects contain the same key the later object in
|
|
* the arguments list will take precedence.
|
|
*
|
|
* Example:
|
|
*
|
|
* ```js
|
|
* var result = merge({foo: 123}, {foo: 456});
|
|
* console.log(result.foo); // outputs 456
|
|
* ```
|
|
*
|
|
* @param {Object} obj1 Object to merge
|
|
* @returns {Object} Result of all merge properties
|
|
*/
|
|
function merge(/* obj1, obj2, obj3, ... */) {
|
|
var result = {};
|
|
function assignValue(val, key) {
|
|
if (typeof result[key] === 'object' && typeof val === 'object') {
|
|
result[key] = merge(result[key], val);
|
|
} else {
|
|
result[key] = val;
|
|
}
|
|
}
|
|
|
|
for (var i = 0, l = arguments.length; i < l; i++) {
|
|
forEach(arguments[i], assignValue);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Extends object a by mutably adding to it the properties of object b.
|
|
*
|
|
* @param {Object} a The object to be extended
|
|
* @param {Object} b The object to copy properties from
|
|
* @param {Object} thisArg The object to bind function to
|
|
* @return {Object} The resulting value of object a
|
|
*/
|
|
function extend(a, b, thisArg) {
|
|
forEach(b, function assignValue(val, key) {
|
|
if (thisArg && typeof val === 'function') {
|
|
a[key] = bind(val, thisArg);
|
|
} else {
|
|
a[key] = val;
|
|
}
|
|
});
|
|
return a;
|
|
}
|
|
|
|
module.exports = {
|
|
isArray: isArray,
|
|
isArrayBuffer: isArrayBuffer,
|
|
isFormData: isFormData,
|
|
isArrayBufferView: isArrayBufferView,
|
|
isString: isString,
|
|
isNumber: isNumber,
|
|
isObject: isObject,
|
|
isUndefined: isUndefined,
|
|
isDate: isDate,
|
|
isFile: isFile,
|
|
isBlob: isBlob,
|
|
isFunction: isFunction,
|
|
isStream: isStream,
|
|
isURLSearchParams: isURLSearchParams,
|
|
isStandardBrowserEnv: isStandardBrowserEnv,
|
|
forEach: forEach,
|
|
merge: merge,
|
|
extend: extend,
|
|
trim: trim
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var freeGlobal = __webpack_require__(42);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = function normalizeComponent (
|
|
rawScriptExports,
|
|
compiledTemplate,
|
|
scopeId,
|
|
cssModules
|
|
) {
|
|
var esModule
|
|
var scriptExports = rawScriptExports = rawScriptExports || {}
|
|
|
|
// ES6 modules interop
|
|
var type = typeof rawScriptExports.default
|
|
if (type === 'object' || type === 'function') {
|
|
esModule = rawScriptExports
|
|
scriptExports = rawScriptExports.default
|
|
}
|
|
|
|
// Vue.extend constructor export interop
|
|
var options = typeof scriptExports === 'function'
|
|
? scriptExports.options
|
|
: scriptExports
|
|
|
|
// render functions
|
|
if (compiledTemplate) {
|
|
options.render = compiledTemplate.render
|
|
options.staticRenderFns = compiledTemplate.staticRenderFns
|
|
}
|
|
|
|
// scopedId
|
|
if (scopeId) {
|
|
options._scopeId = scopeId
|
|
}
|
|
|
|
// inject cssModules
|
|
if (cssModules) {
|
|
var computed = options.computed || (options.computed = {})
|
|
Object.keys(cssModules).forEach(function (key) {
|
|
var module = cssModules[key]
|
|
computed[key] = function () { return module }
|
|
})
|
|
}
|
|
|
|
return {
|
|
esModule: esModule,
|
|
exports: scriptExports,
|
|
options: options
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/*
|
|
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() {
|
|
var list = [];
|
|
|
|
// return the list of modules as css string
|
|
list.toString = function toString() {
|
|
var result = [];
|
|
for(var i = 0; i < this.length; i++) {
|
|
var item = this[i];
|
|
if(item[2]) {
|
|
result.push("@media " + item[2] + "{" + item[1] + "}");
|
|
} else {
|
|
result.push(item[1]);
|
|
}
|
|
}
|
|
return result.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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIsNative = __webpack_require__(118),
|
|
getValue = __webpack_require__(142);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Symbol = __webpack_require__(10),
|
|
getRawTag = __webpack_require__(139),
|
|
objectToString = __webpack_require__(166);
|
|
|
|
/** `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;
|
|
|
|
|
|
/***/ }),
|
|
/* 7 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 8 */
|
|
/***/ (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 defaultSetTimout() {
|
|
throw new Error('setTimeout has not been defined');
|
|
}
|
|
function defaultClearTimeout () {
|
|
throw new Error('clearTimeout has not been defined');
|
|
}
|
|
(function () {
|
|
try {
|
|
if (typeof setTimeout === 'function') {
|
|
cachedSetTimeout = setTimeout;
|
|
} else {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
} catch (e) {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
try {
|
|
if (typeof clearTimeout === 'function') {
|
|
cachedClearTimeout = clearTimeout;
|
|
} else {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} catch (e) {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} ())
|
|
function runTimeout(fun) {
|
|
if (cachedSetTimeout === setTimeout) {
|
|
//normal enviroments in sane situations
|
|
return setTimeout(fun, 0);
|
|
}
|
|
// if setTimeout wasn't available but was latter defined
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
cachedSetTimeout = setTimeout;
|
|
return setTimeout(fun, 0);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedSetTimeout(fun, 0);
|
|
} 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 cachedSetTimeout.call(null, fun, 0);
|
|
} 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
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
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 cleanUpNextTick() {
|
|
if (!draining || !currentQueue) {
|
|
return;
|
|
}
|
|
draining = false;
|
|
if (currentQueue.length) {
|
|
queue = currentQueue.concat(queue);
|
|
} else {
|
|
queueIndex = -1;
|
|
}
|
|
if (queue.length) {
|
|
drainQueue();
|
|
}
|
|
}
|
|
|
|
function drainQueue() {
|
|
if (draining) {
|
|
return;
|
|
}
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
draining = true;
|
|
|
|
var len = queue.length;
|
|
while(len) {
|
|
currentQueue = queue;
|
|
queue = [];
|
|
while (++queueIndex < len) {
|
|
if (currentQueue) {
|
|
currentQueue[queueIndex].run();
|
|
}
|
|
}
|
|
queueIndex = -1;
|
|
len = queue.length;
|
|
}
|
|
currentQueue = null;
|
|
draining = false;
|
|
runClearTimeout(timeout);
|
|
}
|
|
|
|
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.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; };
|
|
|
|
|
|
/***/ }),
|
|
/* 9 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var listCacheClear = __webpack_require__(152),
|
|
listCacheDelete = __webpack_require__(153),
|
|
listCacheGet = __webpack_require__(154),
|
|
listCacheHas = __webpack_require__(155),
|
|
listCacheSet = __webpack_require__(156);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 10 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var root = __webpack_require__(2);
|
|
|
|
/** Built-in value references. */
|
|
var Symbol = root.Symbol;
|
|
|
|
module.exports = Symbol;
|
|
|
|
|
|
/***/ }),
|
|
/* 11 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var eq = __webpack_require__(47);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 12 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseMatches = __webpack_require__(122),
|
|
baseMatchesProperty = __webpack_require__(123),
|
|
identity = __webpack_require__(48),
|
|
isArray = __webpack_require__(1),
|
|
property = __webpack_require__(185);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 13 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isKeyable = __webpack_require__(149);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 14 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getNative = __webpack_require__(5);
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
var nativeCreate = getNative(Object, 'create');
|
|
|
|
module.exports = nativeCreate;
|
|
|
|
|
|
/***/ }),
|
|
/* 15 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isSymbol = __webpack_require__(18);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 16 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isFunction = __webpack_require__(51),
|
|
isLength = __webpack_require__(26);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 17 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 18 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
isObjectLike = __webpack_require__(7);
|
|
|
|
/** `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;
|
|
|
|
|
|
/***/ }),
|
|
/* 19 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var arrayLikeKeys = __webpack_require__(106),
|
|
baseKeys = __webpack_require__(120),
|
|
isArrayLike = __webpack_require__(16);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 20 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
Modified by Evan You @yyx990803
|
|
*/
|
|
|
|
var hasDocument = typeof document !== 'undefined'
|
|
|
|
if (typeof DEBUG !== 'undefined' && DEBUG) {
|
|
if (!hasDocument) {
|
|
throw new Error(
|
|
'vue-style-loader cannot be used in a non-browser environment. ' +
|
|
"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment."
|
|
) }
|
|
}
|
|
|
|
var listToStyles = __webpack_require__(209)
|
|
|
|
/*
|
|
type StyleObject = {
|
|
id: number;
|
|
parts: Array<StyleObjectPart>
|
|
}
|
|
|
|
type StyleObjectPart = {
|
|
css: string;
|
|
media: string;
|
|
sourceMap: ?string
|
|
}
|
|
*/
|
|
|
|
var stylesInDom = {/*
|
|
[id: number]: {
|
|
id: number,
|
|
refs: number,
|
|
parts: Array<(obj?: StyleObjectPart) => void>
|
|
}
|
|
*/}
|
|
|
|
var head = hasDocument && (document.head || document.getElementsByTagName('head')[0])
|
|
var singletonElement = null
|
|
var singletonCounter = 0
|
|
var isProduction = false
|
|
var noop = function () {}
|
|
|
|
// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
|
|
// tags it will allow on a page
|
|
var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\b/.test(navigator.userAgent.toLowerCase())
|
|
|
|
module.exports = function (parentId, list, _isProduction) {
|
|
isProduction = _isProduction
|
|
|
|
var styles = listToStyles(parentId, list)
|
|
addStylesToDom(styles)
|
|
|
|
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) {
|
|
styles = listToStyles(parentId, newList)
|
|
addStylesToDom(styles)
|
|
} else {
|
|
styles = []
|
|
}
|
|
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 addStylesToDom (styles /* Array<StyleObject> */) {
|
|
for (var i = 0; i < styles.length; i++) {
|
|
var item = styles[i]
|
|
var domStyle = stylesInDom[item.id]
|
|
if (domStyle) {
|
|
domStyle.refs++
|
|
for (var j = 0; j < domStyle.parts.length; j++) {
|
|
domStyle.parts[j](item.parts[j])
|
|
}
|
|
for (; j < item.parts.length; j++) {
|
|
domStyle.parts.push(addStyle(item.parts[j]))
|
|
}
|
|
if (domStyle.parts.length > item.parts.length) {
|
|
domStyle.parts.length = item.parts.length
|
|
}
|
|
} else {
|
|
var parts = []
|
|
for (var j = 0; j < item.parts.length; j++) {
|
|
parts.push(addStyle(item.parts[j]))
|
|
}
|
|
stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }
|
|
}
|
|
}
|
|
}
|
|
|
|
function listToStyles (parentId, list) {
|
|
var styles = []
|
|
var newStyles = {}
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
var id = item[0]
|
|
var css = item[1]
|
|
var media = item[2]
|
|
var sourceMap = item[3]
|
|
var part = { css: css, media: media, sourceMap: sourceMap }
|
|
if (!newStyles[id]) {
|
|
part.id = parentId + ':0'
|
|
styles.push(newStyles[id] = { id: id, parts: [part] })
|
|
} else {
|
|
part.id = parentId + ':' + newStyles[id].parts.length
|
|
newStyles[id].parts.push(part)
|
|
}
|
|
}
|
|
return styles
|
|
}
|
|
|
|
function createStyleElement () {
|
|
var styleElement = document.createElement('style')
|
|
styleElement.type = 'text/css'
|
|
head.appendChild(styleElement)
|
|
return styleElement
|
|
}
|
|
|
|
function addStyle (obj /* StyleObjectPart */) {
|
|
var update, remove
|
|
var styleElement = document.querySelector('style[data-vue-ssr-id~="' + obj.id + '"]')
|
|
var hasSSR = styleElement != null
|
|
|
|
// if in production mode and style is already provided by SSR,
|
|
// simply do nothing.
|
|
if (hasSSR && isProduction) {
|
|
return noop
|
|
}
|
|
|
|
if (isOldIE) {
|
|
// use singleton mode for IE9.
|
|
var styleIndex = singletonCounter++
|
|
styleElement = singletonElement || (singletonElement = createStyleElement())
|
|
update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)
|
|
remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)
|
|
} else {
|
|
// use multi-style-tag mode in all other cases
|
|
styleElement = styleElement || createStyleElement()
|
|
update = applyToTag.bind(null, styleElement)
|
|
remove = function () {
|
|
styleElement.parentNode.removeChild(styleElement)
|
|
}
|
|
}
|
|
|
|
if (!hasSSR) {
|
|
update(obj)
|
|
}
|
|
|
|
return function updateStyle (newObj /* StyleObjectPart */) {
|
|
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
|
|
var sourceMap = obj.sourceMap
|
|
|
|
if (media) {
|
|
styleElement.setAttribute('media', media)
|
|
}
|
|
|
|
if (sourceMap) {
|
|
// https://developer.chrome.com/devtools/docs/javascript-debugging
|
|
// this makes source maps inside style tags work properly in Chrome
|
|
css += '\n/*# sourceURL=' + sourceMap.sources[0] + ' */'
|
|
// http://stackoverflow.com/a/26603875
|
|
css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'
|
|
}
|
|
|
|
if (styleElement.styleSheet) {
|
|
styleElement.styleSheet.cssText = css
|
|
} else {
|
|
while (styleElement.firstChild) {
|
|
styleElement.removeChild(styleElement.firstChild)
|
|
}
|
|
styleElement.appendChild(document.createTextNode(css))
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 21 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* WEBPACK VAR INJECTION */(function(process) {
|
|
|
|
var utils = __webpack_require__(0);
|
|
var normalizeHeaderName = __webpack_require__(78);
|
|
|
|
var PROTECTION_PREFIX = /^\)\]\}',?\n/;
|
|
var DEFAULT_CONTENT_TYPE = {
|
|
'Content-Type': 'application/x-www-form-urlencoded'
|
|
};
|
|
|
|
function setContentTypeIfUnset(headers, value) {
|
|
if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
|
|
headers['Content-Type'] = value;
|
|
}
|
|
}
|
|
|
|
function getDefaultAdapter() {
|
|
var adapter;
|
|
if (typeof XMLHttpRequest !== 'undefined') {
|
|
// For browsers use XHR adapter
|
|
adapter = __webpack_require__(30);
|
|
} else if (typeof process !== 'undefined') {
|
|
// For node use HTTP adapter
|
|
adapter = __webpack_require__(30);
|
|
}
|
|
return adapter;
|
|
}
|
|
|
|
var defaults = {
|
|
adapter: getDefaultAdapter(),
|
|
|
|
transformRequest: [function transformRequest(data, headers) {
|
|
normalizeHeaderName(headers, 'Content-Type');
|
|
if (utils.isFormData(data) ||
|
|
utils.isArrayBuffer(data) ||
|
|
utils.isStream(data) ||
|
|
utils.isFile(data) ||
|
|
utils.isBlob(data)
|
|
) {
|
|
return data;
|
|
}
|
|
if (utils.isArrayBufferView(data)) {
|
|
return data.buffer;
|
|
}
|
|
if (utils.isURLSearchParams(data)) {
|
|
setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
|
|
return data.toString();
|
|
}
|
|
if (utils.isObject(data)) {
|
|
setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
|
|
return JSON.stringify(data);
|
|
}
|
|
return data;
|
|
}],
|
|
|
|
transformResponse: [function transformResponse(data) {
|
|
/*eslint no-param-reassign:0*/
|
|
if (typeof data === 'string') {
|
|
data = data.replace(PROTECTION_PREFIX, '');
|
|
try {
|
|
data = JSON.parse(data);
|
|
} catch (e) { /* Ignore */ }
|
|
}
|
|
return data;
|
|
}],
|
|
|
|
timeout: 0,
|
|
|
|
xsrfCookieName: 'XSRF-TOKEN',
|
|
xsrfHeaderName: 'X-XSRF-TOKEN',
|
|
|
|
maxContentLength: -1,
|
|
|
|
validateStatus: function validateStatus(status) {
|
|
return status >= 200 && status < 300;
|
|
}
|
|
};
|
|
|
|
defaults.headers = {
|
|
common: {
|
|
'Accept': 'application/json, text/plain, */*'
|
|
}
|
|
};
|
|
|
|
utils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {
|
|
defaults.headers[method] = {};
|
|
});
|
|
|
|
utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
|
|
defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
|
|
});
|
|
|
|
module.exports = defaults;
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))
|
|
|
|
/***/ }),
|
|
/* 22 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getNative = __webpack_require__(5),
|
|
root = __webpack_require__(2);
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
var Map = getNative(root, 'Map');
|
|
|
|
module.exports = Map;
|
|
|
|
|
|
/***/ }),
|
|
/* 23 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var mapCacheClear = __webpack_require__(157),
|
|
mapCacheDelete = __webpack_require__(158),
|
|
mapCacheGet = __webpack_require__(159),
|
|
mapCacheHas = __webpack_require__(160),
|
|
mapCacheSet = __webpack_require__(161);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 24 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseForOwn = __webpack_require__(112),
|
|
createBaseEach = __webpack_require__(132);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 25 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isArray = __webpack_require__(1),
|
|
isSymbol = __webpack_require__(18);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 26 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 27 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/*
|
|
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() {
|
|
return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
|
|
}),
|
|
getHeadElement = memoize(function () {
|
|
return document.head || document.getElementsByTagName("head")[0];
|
|
}),
|
|
singletonElement = null,
|
|
singletonCounter = 0,
|
|
styleElementsInsertedAtTop = [];
|
|
|
|
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 || {};
|
|
// 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 bottom of <head>.
|
|
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 addStylesToDom(styles, options) {
|
|
for(var i = 0; i < styles.length; i++) {
|
|
var item = styles[i];
|
|
var domStyle = stylesInDom[item.id];
|
|
if(domStyle) {
|
|
domStyle.refs++;
|
|
for(var j = 0; j < domStyle.parts.length; j++) {
|
|
domStyle.parts[j](item.parts[j]);
|
|
}
|
|
for(; j < item.parts.length; j++) {
|
|
domStyle.parts.push(addStyle(item.parts[j], options));
|
|
}
|
|
} else {
|
|
var parts = [];
|
|
for(var j = 0; j < item.parts.length; j++) {
|
|
parts.push(addStyle(item.parts[j], options));
|
|
}
|
|
stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
|
|
}
|
|
}
|
|
}
|
|
|
|
function listToStyles(list) {
|
|
var styles = [];
|
|
var newStyles = {};
|
|
for(var i = 0; i < list.length; i++) {
|
|
var item = list[i];
|
|
var id = item[0];
|
|
var css = item[1];
|
|
var media = item[2];
|
|
var sourceMap = item[3];
|
|
var part = {css: css, media: media, sourceMap: sourceMap};
|
|
if(!newStyles[id])
|
|
styles.push(newStyles[id] = {id: id, parts: [part]});
|
|
else
|
|
newStyles[id].parts.push(part);
|
|
}
|
|
return styles;
|
|
}
|
|
|
|
function insertStyleElement(options, styleElement) {
|
|
var head = getHeadElement();
|
|
var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
|
|
if (options.insertAt === "top") {
|
|
if(!lastStyleElementInsertedAtTop) {
|
|
head.insertBefore(styleElement, head.firstChild);
|
|
} else if(lastStyleElementInsertedAtTop.nextSibling) {
|
|
head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
|
|
} else {
|
|
head.appendChild(styleElement);
|
|
}
|
|
styleElementsInsertedAtTop.push(styleElement);
|
|
} else if (options.insertAt === "bottom") {
|
|
head.appendChild(styleElement);
|
|
} else {
|
|
throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
|
|
}
|
|
}
|
|
|
|
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");
|
|
styleElement.type = "text/css";
|
|
insertStyleElement(options, styleElement);
|
|
return styleElement;
|
|
}
|
|
|
|
function createLinkElement(options) {
|
|
var linkElement = document.createElement("link");
|
|
linkElement.rel = "stylesheet";
|
|
insertStyleElement(options, linkElement);
|
|
return linkElement;
|
|
}
|
|
|
|
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);
|
|
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, obj) {
|
|
var css = obj.css;
|
|
var sourceMap = obj.sourceMap;
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 28 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 29 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = {
|
|
"zh-CN": [
|
|
{
|
|
"name": "基础组件",
|
|
"groups": [
|
|
{
|
|
"groupName": "Basic",
|
|
"list": [
|
|
{
|
|
"path": "/sample",
|
|
"title": "Sample组件"
|
|
},
|
|
{
|
|
"path": "/button",
|
|
"title": "Button组件"
|
|
},
|
|
{
|
|
"path": "/switch",
|
|
"title": "Switch组件"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
|
|
/***/ }),
|
|
/* 30 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* WEBPACK VAR INJECTION */(function(process) {
|
|
|
|
var utils = __webpack_require__(0);
|
|
var settle = __webpack_require__(70);
|
|
var buildURL = __webpack_require__(73);
|
|
var parseHeaders = __webpack_require__(79);
|
|
var isURLSameOrigin = __webpack_require__(77);
|
|
var createError = __webpack_require__(33);
|
|
var btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || __webpack_require__(72);
|
|
|
|
module.exports = function xhrAdapter(config) {
|
|
return new Promise(function dispatchXhrRequest(resolve, reject) {
|
|
var requestData = config.data;
|
|
var requestHeaders = config.headers;
|
|
|
|
if (utils.isFormData(requestData)) {
|
|
delete requestHeaders['Content-Type']; // Let the browser set it
|
|
}
|
|
|
|
var request = new XMLHttpRequest();
|
|
var loadEvent = 'onreadystatechange';
|
|
var xDomain = false;
|
|
|
|
// For IE 8/9 CORS support
|
|
// Only supports POST and GET calls and doesn't returns the response headers.
|
|
// DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.
|
|
if (process.env.NODE_ENV !== 'test' &&
|
|
typeof window !== 'undefined' &&
|
|
window.XDomainRequest && !('withCredentials' in request) &&
|
|
!isURLSameOrigin(config.url)) {
|
|
request = new window.XDomainRequest();
|
|
loadEvent = 'onload';
|
|
xDomain = true;
|
|
request.onprogress = function handleProgress() {};
|
|
request.ontimeout = function handleTimeout() {};
|
|
}
|
|
|
|
// HTTP basic authentication
|
|
if (config.auth) {
|
|
var username = config.auth.username || '';
|
|
var password = config.auth.password || '';
|
|
requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
|
|
}
|
|
|
|
request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);
|
|
|
|
// Set the request timeout in MS
|
|
request.timeout = config.timeout;
|
|
|
|
// Listen for ready state
|
|
request[loadEvent] = function handleLoad() {
|
|
if (!request || (request.readyState !== 4 && !xDomain)) {
|
|
return;
|
|
}
|
|
|
|
// The request errored out and we didn't get a response, this will be
|
|
// handled by onerror instead
|
|
// With one exception: request that using file: protocol, most browsers
|
|
// will return status as 0 even though it's a successful request
|
|
if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
|
|
return;
|
|
}
|
|
|
|
// Prepare the response
|
|
var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
|
|
var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
|
|
var response = {
|
|
data: responseData,
|
|
// IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)
|
|
status: request.status === 1223 ? 204 : request.status,
|
|
statusText: request.status === 1223 ? 'No Content' : request.statusText,
|
|
headers: responseHeaders,
|
|
config: config,
|
|
request: request
|
|
};
|
|
|
|
settle(resolve, reject, response);
|
|
|
|
// Clean up request
|
|
request = null;
|
|
};
|
|
|
|
// Handle low level network errors
|
|
request.onerror = function handleError() {
|
|
// Real errors are hidden from us by the browser
|
|
// onerror should only fire if it's a network error
|
|
reject(createError('Network Error', config));
|
|
|
|
// Clean up request
|
|
request = null;
|
|
};
|
|
|
|
// Handle timeout
|
|
request.ontimeout = function handleTimeout() {
|
|
reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));
|
|
|
|
// Clean up request
|
|
request = null;
|
|
};
|
|
|
|
// Add xsrf header
|
|
// This is only done if running in a standard browser environment.
|
|
// Specifically not if we're in a web worker, or react-native.
|
|
if (utils.isStandardBrowserEnv()) {
|
|
var cookies = __webpack_require__(75);
|
|
|
|
// Add xsrf header
|
|
var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?
|
|
cookies.read(config.xsrfCookieName) :
|
|
undefined;
|
|
|
|
if (xsrfValue) {
|
|
requestHeaders[config.xsrfHeaderName] = xsrfValue;
|
|
}
|
|
}
|
|
|
|
// Add headers to the request
|
|
if ('setRequestHeader' in request) {
|
|
utils.forEach(requestHeaders, function setRequestHeader(val, key) {
|
|
if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
|
|
// Remove Content-Type if data is undefined
|
|
delete requestHeaders[key];
|
|
} else {
|
|
// Otherwise add header to the request
|
|
request.setRequestHeader(key, val);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Add withCredentials to request if needed
|
|
if (config.withCredentials) {
|
|
request.withCredentials = true;
|
|
}
|
|
|
|
// Add responseType to request if needed
|
|
if (config.responseType) {
|
|
try {
|
|
request.responseType = config.responseType;
|
|
} catch (e) {
|
|
if (request.responseType !== 'json') {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle progress if needed
|
|
if (typeof config.onDownloadProgress === 'function') {
|
|
request.addEventListener('progress', config.onDownloadProgress);
|
|
}
|
|
|
|
// Not all browsers support upload events
|
|
if (typeof config.onUploadProgress === 'function' && request.upload) {
|
|
request.upload.addEventListener('progress', config.onUploadProgress);
|
|
}
|
|
|
|
if (config.cancelToken) {
|
|
// Handle cancellation
|
|
config.cancelToken.promise.then(function onCanceled(cancel) {
|
|
if (!request) {
|
|
return;
|
|
}
|
|
|
|
request.abort();
|
|
reject(cancel);
|
|
// Clean up request
|
|
request = null;
|
|
});
|
|
}
|
|
|
|
if (requestData === undefined) {
|
|
requestData = null;
|
|
}
|
|
|
|
// Send the request
|
|
request.send(requestData);
|
|
});
|
|
};
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))
|
|
|
|
/***/ }),
|
|
/* 31 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/**
|
|
* A `Cancel` is an object that is thrown when an operation is canceled.
|
|
*
|
|
* @class
|
|
* @param {string=} message The message.
|
|
*/
|
|
function Cancel(message) {
|
|
this.message = message;
|
|
}
|
|
|
|
Cancel.prototype.toString = function toString() {
|
|
return 'Cancel' + (this.message ? ': ' + this.message : '');
|
|
};
|
|
|
|
Cancel.prototype.__CANCEL__ = true;
|
|
|
|
module.exports = Cancel;
|
|
|
|
|
|
/***/ }),
|
|
/* 32 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function isCancel(value) {
|
|
return !!(value && value.__CANCEL__);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 33 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var enhanceError = __webpack_require__(69);
|
|
|
|
/**
|
|
* Create an Error with the specified message, config, error code, and response.
|
|
*
|
|
* @param {string} message The error message.
|
|
* @param {Object} config The config.
|
|
* @param {string} [code] The error code (for example, 'ECONNABORTED').
|
|
@ @param {Object} [response] The response.
|
|
* @returns {Error} The created error.
|
|
*/
|
|
module.exports = function createError(message, config, code, response) {
|
|
var error = new Error(message);
|
|
return enhanceError(error, config, code, response);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 34 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function bind(fn, thisArg) {
|
|
return function wrap() {
|
|
var args = new Array(arguments.length);
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
return fn.apply(thisArg, args);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 35 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var ListCache = __webpack_require__(9),
|
|
stackClear = __webpack_require__(171),
|
|
stackDelete = __webpack_require__(172),
|
|
stackGet = __webpack_require__(173),
|
|
stackHas = __webpack_require__(174),
|
|
stackSet = __webpack_require__(175);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 36 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 37 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 38 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var castPath = __webpack_require__(40),
|
|
toKey = __webpack_require__(15);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 39 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIsEqualDeep = __webpack_require__(116),
|
|
isObjectLike = __webpack_require__(7);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 40 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isArray = __webpack_require__(1),
|
|
isKey = __webpack_require__(25),
|
|
stringToPath = __webpack_require__(176),
|
|
toString = __webpack_require__(191);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 41 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var SetCache = __webpack_require__(102),
|
|
arraySome = __webpack_require__(108),
|
|
cacheHas = __webpack_require__(129);
|
|
|
|
/** 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;
|
|
}
|
|
// Assume cyclic values are equal.
|
|
var stacked = stack.get(array);
|
|
if (stacked && stack.get(other)) {
|
|
return stacked == other;
|
|
}
|
|
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;
|
|
|
|
|
|
/***/ }),
|
|
/* 42 */
|
|
/***/ (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__(28)))
|
|
|
|
/***/ }),
|
|
/* 43 */
|
|
/***/ (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) {
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return !!length &&
|
|
(typeof value == 'number' || reIsUint.test(value)) &&
|
|
(value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
|
|
module.exports = isIndex;
|
|
|
|
|
|
/***/ }),
|
|
/* 44 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isObject = __webpack_require__(17);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 45 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 46 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 47 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 48 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 49 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIsArguments = __webpack_require__(115),
|
|
isObjectLike = __webpack_require__(7);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 50 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(2),
|
|
stubFalse = __webpack_require__(187);
|
|
|
|
/** 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__(54)(module)))
|
|
|
|
/***/ }),
|
|
/* 51 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
isObject = __webpack_require__(17);
|
|
|
|
/** `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;
|
|
|
|
|
|
/***/ }),
|
|
/* 52 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIsTypedArray = __webpack_require__(119),
|
|
baseUnary = __webpack_require__(128),
|
|
nodeUtil = __webpack_require__(165);
|
|
|
|
/* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 53 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = "data:application/vnd.ms-fontobject;base64,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"
|
|
|
|
/***/ }),
|
|
/* 54 */
|
|
/***/ (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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 55 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _navConfig = __webpack_require__(29);
|
|
|
|
var _navConfig2 = _interopRequireDefault(_navConfig);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var registerRoute = function registerRoute(navConfig) {
|
|
var route = [];
|
|
var navs = navConfig['zh-CN'];
|
|
navs.forEach(function (nav) {
|
|
if (nav.groups) {
|
|
nav.groups.forEach(function (group) {
|
|
group.list.forEach(function (nav) {
|
|
addRoute(nav);
|
|
});
|
|
});
|
|
} else if (nav.children) {
|
|
nav.children.forEach(function (nav) {
|
|
addRoute(nav);
|
|
});
|
|
} else {
|
|
addRoute(nav);
|
|
}
|
|
});
|
|
|
|
function addRoute(page) {
|
|
route.push({
|
|
path: '/component' + page.path,
|
|
component: function component(resolve) {
|
|
__webpack_require__.e/* require */(0).then(function() { var __WEBPACK_AMD_REQUIRE_ARRAY__ = [__webpack_require__(212)("./examples" + page.path + '.md')]; (resolve.apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__));}.bind(this)).catch(__webpack_require__.oe);
|
|
}
|
|
});
|
|
}
|
|
|
|
return route;
|
|
};
|
|
|
|
var route = registerRoute(_navConfig2.default);
|
|
|
|
exports.default = route;
|
|
|
|
/***/ }),
|
|
/* 56 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _index = __webpack_require__(88);
|
|
|
|
var _index2 = _interopRequireDefault(_index);
|
|
|
|
var _index3 = __webpack_require__(87);
|
|
|
|
var _index4 = _interopRequireDefault(_index3);
|
|
|
|
var _index5 = __webpack_require__(89);
|
|
|
|
var _index6 = _interopRequireDefault(_index5);
|
|
|
|
__webpack_require__(96);
|
|
|
|
var _axios = __webpack_require__(63);
|
|
|
|
var _axios2 = _interopRequireDefault(_axios);
|
|
|
|
var _foreach = __webpack_require__(180);
|
|
|
|
var _foreach2 = _interopRequireDefault(_foreach);
|
|
|
|
var _filter = __webpack_require__(177);
|
|
|
|
var _filter2 = _interopRequireDefault(_filter);
|
|
|
|
var _find = __webpack_require__(178);
|
|
|
|
var _find2 = _interopRequireDefault(_find);
|
|
|
|
var _map = __webpack_require__(183);
|
|
|
|
var _map2 = _interopRequireDefault(_map);
|
|
|
|
__webpack_require__(192);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var install = function install(Vue) {
|
|
if (install.installed) return;
|
|
|
|
Vue.component(_index2.default.name, _index2.default);
|
|
Vue.component(_index4.default.name, _index4.default);
|
|
Vue.component(_index6.default.name, _index6.default);
|
|
};
|
|
|
|
// auto install
|
|
|
|
// zenui
|
|
if (typeof window !== 'undefined' && window.Vue) {
|
|
install(window.Vue);
|
|
};
|
|
|
|
module.exports = {
|
|
install: install,
|
|
version: '0.0.1',
|
|
axios: _axios2.default,
|
|
_: {
|
|
foreach: _foreach2.default,
|
|
filter: _filter2.default,
|
|
find: _find2.default,
|
|
map: _map2.default
|
|
},
|
|
Sample: _index2.default,
|
|
Button: _index4.default,
|
|
Switch: _index6.default
|
|
};
|
|
|
|
/***/ }),
|
|
/* 57 */
|
|
/***/ (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__(90);
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
// add the styles to the DOM
|
|
var update = __webpack_require__(27)(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!./../../node_modules/less-loader/index.js!./docs.less", function() {
|
|
var newContent = require("!!./../../node_modules/css-loader/index.js!./../../node_modules/less-loader/index.js!./docs.less");
|
|
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
|
|
update(newContent);
|
|
});
|
|
}
|
|
// When the module is disposed, remove the <style> tags
|
|
module.hot.dispose(function() { update(); });
|
|
}
|
|
|
|
/***/ }),
|
|
/* 58 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* styles */
|
|
__webpack_require__(207)
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(81),
|
|
/* template */
|
|
__webpack_require__(202),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ }),
|
|
/* 59 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* styles */
|
|
__webpack_require__(208)
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(82),
|
|
/* template */
|
|
__webpack_require__(203),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ }),
|
|
/* 60 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
/* styles */
|
|
__webpack_require__(206)
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(83),
|
|
/* template */
|
|
__webpack_require__(201),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ }),
|
|
/* 61 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* WEBPACK VAR INJECTION */(function(process) {/**
|
|
* vue-router v2.2.0
|
|
* (c) 2017 Evan You
|
|
* @license MIT
|
|
*/
|
|
|
|
|
|
/* */
|
|
|
|
function assert (condition, message) {
|
|
if (!condition) {
|
|
throw new Error(("[vue-router] " + message))
|
|
}
|
|
}
|
|
|
|
function warn (condition, message) {
|
|
if (!condition) {
|
|
typeof console !== 'undefined' && console.warn(("[vue-router] " + message));
|
|
}
|
|
}
|
|
|
|
var View = {
|
|
name: 'router-view',
|
|
functional: true,
|
|
props: {
|
|
name: {
|
|
type: String,
|
|
default: 'default'
|
|
}
|
|
},
|
|
render: function render (h, ref) {
|
|
var props = ref.props;
|
|
var children = ref.children;
|
|
var parent = ref.parent;
|
|
var data = ref.data;
|
|
|
|
data.routerView = true;
|
|
|
|
var name = props.name;
|
|
var route = parent.$route;
|
|
var cache = parent._routerViewCache || (parent._routerViewCache = {});
|
|
|
|
// determine current view depth, also check to see if the tree
|
|
// has been toggled inactive but kept-alive.
|
|
var depth = 0;
|
|
var inactive = false;
|
|
while (parent) {
|
|
if (parent.$vnode && parent.$vnode.data.routerView) {
|
|
depth++;
|
|
}
|
|
if (parent._inactive) {
|
|
inactive = true;
|
|
}
|
|
parent = parent.$parent;
|
|
}
|
|
data.routerViewDepth = depth;
|
|
|
|
// render previous view if the tree is inactive and kept-alive
|
|
if (inactive) {
|
|
return h(cache[name], data, children)
|
|
}
|
|
|
|
var matched = route.matched[depth];
|
|
// render empty node if no matched route
|
|
if (!matched) {
|
|
cache[name] = null;
|
|
return h()
|
|
}
|
|
|
|
var component = cache[name] = matched.components[name];
|
|
|
|
// inject instance registration hooks
|
|
var hooks = data.hook || (data.hook = {});
|
|
hooks.init = function (vnode) {
|
|
matched.instances[name] = vnode.child;
|
|
};
|
|
hooks.prepatch = function (oldVnode, vnode) {
|
|
matched.instances[name] = vnode.child;
|
|
};
|
|
hooks.destroy = function (vnode) {
|
|
if (matched.instances[name] === vnode.child) {
|
|
matched.instances[name] = undefined;
|
|
}
|
|
};
|
|
|
|
// resolve props
|
|
data.props = resolveProps(route, matched.props && matched.props[name]);
|
|
|
|
return h(component, data, children)
|
|
}
|
|
};
|
|
|
|
function resolveProps (route, config) {
|
|
switch (typeof config) {
|
|
case 'undefined':
|
|
return
|
|
case 'object':
|
|
return config
|
|
case 'function':
|
|
return config(route)
|
|
case 'boolean':
|
|
return config ? route.params : undefined
|
|
default:
|
|
warn(false, ("props in \"" + (route.path) + "\" is a " + (typeof config) + ", expecting an object, function or boolean."));
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var encodeReserveRE = /[!'()*]/g;
|
|
var encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };
|
|
var commaRE = /%2C/g;
|
|
|
|
// fixed encodeURIComponent which is more comformant to RFC3986:
|
|
// - escapes [!'()*]
|
|
// - preserve commas
|
|
var encode = function (str) { return encodeURIComponent(str)
|
|
.replace(encodeReserveRE, encodeReserveReplacer)
|
|
.replace(commaRE, ','); };
|
|
|
|
var decode = decodeURIComponent;
|
|
|
|
function resolveQuery (
|
|
query,
|
|
extraQuery
|
|
) {
|
|
if ( extraQuery === void 0 ) extraQuery = {};
|
|
|
|
if (query) {
|
|
var parsedQuery;
|
|
try {
|
|
parsedQuery = parseQuery(query);
|
|
} catch (e) {
|
|
process.env.NODE_ENV !== 'production' && warn(false, e.message);
|
|
parsedQuery = {};
|
|
}
|
|
for (var key in extraQuery) {
|
|
parsedQuery[key] = extraQuery[key];
|
|
}
|
|
return parsedQuery
|
|
} else {
|
|
return extraQuery
|
|
}
|
|
}
|
|
|
|
function parseQuery (query) {
|
|
var res = {};
|
|
|
|
query = query.trim().replace(/^(\?|#|&)/, '');
|
|
|
|
if (!query) {
|
|
return res
|
|
}
|
|
|
|
query.split('&').forEach(function (param) {
|
|
var parts = param.replace(/\+/g, ' ').split('=');
|
|
var key = decode(parts.shift());
|
|
var val = parts.length > 0
|
|
? decode(parts.join('='))
|
|
: null;
|
|
|
|
if (res[key] === undefined) {
|
|
res[key] = val;
|
|
} else if (Array.isArray(res[key])) {
|
|
res[key].push(val);
|
|
} else {
|
|
res[key] = [res[key], val];
|
|
}
|
|
});
|
|
|
|
return res
|
|
}
|
|
|
|
function stringifyQuery (obj) {
|
|
var res = obj ? Object.keys(obj).map(function (key) {
|
|
var val = obj[key];
|
|
|
|
if (val === undefined) {
|
|
return ''
|
|
}
|
|
|
|
if (val === null) {
|
|
return encode(key)
|
|
}
|
|
|
|
if (Array.isArray(val)) {
|
|
var result = [];
|
|
val.slice().forEach(function (val2) {
|
|
if (val2 === undefined) {
|
|
return
|
|
}
|
|
if (val2 === null) {
|
|
result.push(encode(key));
|
|
} else {
|
|
result.push(encode(key) + '=' + encode(val2));
|
|
}
|
|
});
|
|
return result.join('&')
|
|
}
|
|
|
|
return encode(key) + '=' + encode(val)
|
|
}).filter(function (x) { return x.length > 0; }).join('&') : null;
|
|
return res ? ("?" + res) : ''
|
|
}
|
|
|
|
/* */
|
|
|
|
var trailingSlashRE = /\/?$/;
|
|
|
|
function createRoute (
|
|
record,
|
|
location,
|
|
redirectedFrom
|
|
) {
|
|
var route = {
|
|
name: location.name || (record && record.name),
|
|
meta: (record && record.meta) || {},
|
|
path: location.path || '/',
|
|
hash: location.hash || '',
|
|
query: location.query || {},
|
|
params: location.params || {},
|
|
fullPath: getFullPath(location),
|
|
matched: record ? formatMatch(record) : []
|
|
};
|
|
if (redirectedFrom) {
|
|
route.redirectedFrom = getFullPath(redirectedFrom);
|
|
}
|
|
return Object.freeze(route)
|
|
}
|
|
|
|
// the starting route that represents the initial state
|
|
var START = createRoute(null, {
|
|
path: '/'
|
|
});
|
|
|
|
function formatMatch (record) {
|
|
var res = [];
|
|
while (record) {
|
|
res.unshift(record);
|
|
record = record.parent;
|
|
}
|
|
return res
|
|
}
|
|
|
|
function getFullPath (ref) {
|
|
var path = ref.path;
|
|
var query = ref.query; if ( query === void 0 ) query = {};
|
|
var hash = ref.hash; if ( hash === void 0 ) hash = '';
|
|
|
|
return (path || '/') + stringifyQuery(query) + hash
|
|
}
|
|
|
|
function isSameRoute (a, b) {
|
|
if (b === START) {
|
|
return a === b
|
|
} else if (!b) {
|
|
return false
|
|
} else if (a.path && b.path) {
|
|
return (
|
|
a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&
|
|
a.hash === b.hash &&
|
|
isObjectEqual(a.query, b.query)
|
|
)
|
|
} else if (a.name && b.name) {
|
|
return (
|
|
a.name === b.name &&
|
|
a.hash === b.hash &&
|
|
isObjectEqual(a.query, b.query) &&
|
|
isObjectEqual(a.params, b.params)
|
|
)
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
function isObjectEqual (a, b) {
|
|
if ( a === void 0 ) a = {};
|
|
if ( b === void 0 ) b = {};
|
|
|
|
var aKeys = Object.keys(a);
|
|
var bKeys = Object.keys(b);
|
|
if (aKeys.length !== bKeys.length) {
|
|
return false
|
|
}
|
|
return aKeys.every(function (key) { return String(a[key]) === String(b[key]); })
|
|
}
|
|
|
|
function isIncludedRoute (current, target) {
|
|
return (
|
|
current.path.replace(trailingSlashRE, '/').indexOf(
|
|
target.path.replace(trailingSlashRE, '/')
|
|
) === 0 &&
|
|
(!target.hash || current.hash === target.hash) &&
|
|
queryIncludes(current.query, target.query)
|
|
)
|
|
}
|
|
|
|
function queryIncludes (current, target) {
|
|
for (var key in target) {
|
|
if (!(key in current)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
/* */
|
|
|
|
// work around weird flow bug
|
|
var toTypes = [String, Object];
|
|
var eventTypes = [String, Array];
|
|
|
|
var Link = {
|
|
name: 'router-link',
|
|
props: {
|
|
to: {
|
|
type: toTypes,
|
|
required: true
|
|
},
|
|
tag: {
|
|
type: String,
|
|
default: 'a'
|
|
},
|
|
exact: Boolean,
|
|
append: Boolean,
|
|
replace: Boolean,
|
|
activeClass: String,
|
|
event: {
|
|
type: eventTypes,
|
|
default: 'click'
|
|
}
|
|
},
|
|
render: function render (h) {
|
|
var this$1 = this;
|
|
|
|
var router = this.$router;
|
|
var current = this.$route;
|
|
var ref = router.resolve(this.to, current, this.append);
|
|
var location = ref.location;
|
|
var route = ref.route;
|
|
var href = ref.href;
|
|
var classes = {};
|
|
var activeClass = this.activeClass || router.options.linkActiveClass || 'router-link-active';
|
|
var compareTarget = location.path ? createRoute(null, location) : route;
|
|
classes[activeClass] = this.exact
|
|
? isSameRoute(current, compareTarget)
|
|
: isIncludedRoute(current, compareTarget);
|
|
|
|
var handler = function (e) {
|
|
if (guardEvent(e)) {
|
|
if (this$1.replace) {
|
|
router.replace(location);
|
|
} else {
|
|
router.push(location);
|
|
}
|
|
}
|
|
};
|
|
|
|
var on = { click: guardEvent };
|
|
if (Array.isArray(this.event)) {
|
|
this.event.forEach(function (e) { on[e] = handler; });
|
|
} else {
|
|
on[this.event] = handler;
|
|
}
|
|
|
|
var data = {
|
|
class: classes
|
|
};
|
|
|
|
if (this.tag === 'a') {
|
|
data.on = on;
|
|
data.attrs = { href: href };
|
|
} else {
|
|
// find the first <a> child and apply listener and href
|
|
var a = findAnchor(this.$slots.default);
|
|
if (a) {
|
|
// in case the <a> is a static node
|
|
a.isStatic = false;
|
|
var extend = _Vue.util.extend;
|
|
var aData = a.data = extend({}, a.data);
|
|
aData.on = on;
|
|
var aAttrs = a.data.attrs = extend({}, a.data.attrs);
|
|
aAttrs.href = href;
|
|
} else {
|
|
// doesn't have <a> child, apply listener to self
|
|
data.on = on;
|
|
}
|
|
}
|
|
|
|
return h(this.tag, data, this.$slots.default)
|
|
}
|
|
};
|
|
|
|
function guardEvent (e) {
|
|
// don't redirect with control keys
|
|
if (e.metaKey || e.ctrlKey || e.shiftKey) { return }
|
|
// don't redirect when preventDefault called
|
|
if (e.defaultPrevented) { return }
|
|
// don't redirect on right click
|
|
if (e.button !== undefined && e.button !== 0) { return }
|
|
// don't redirect if `target="_blank"`
|
|
if (e.target && e.target.getAttribute) {
|
|
var target = e.target.getAttribute('target');
|
|
if (/\b_blank\b/i.test(target)) { return }
|
|
}
|
|
// this may be a Weex event which doesn't have this method
|
|
if (e.preventDefault) {
|
|
e.preventDefault();
|
|
}
|
|
return true
|
|
}
|
|
|
|
function findAnchor (children) {
|
|
if (children) {
|
|
var child;
|
|
for (var i = 0; i < children.length; i++) {
|
|
child = children[i];
|
|
if (child.tag === 'a') {
|
|
return child
|
|
}
|
|
if (child.children && (child = findAnchor(child.children))) {
|
|
return child
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var _Vue;
|
|
|
|
function install (Vue) {
|
|
if (install.installed) { return }
|
|
install.installed = true;
|
|
|
|
_Vue = Vue;
|
|
|
|
Object.defineProperty(Vue.prototype, '$router', {
|
|
get: function get () { return this.$root._router }
|
|
});
|
|
|
|
Object.defineProperty(Vue.prototype, '$route', {
|
|
get: function get () { return this.$root._route }
|
|
});
|
|
|
|
Vue.mixin({
|
|
beforeCreate: function beforeCreate () {
|
|
if (this.$options.router) {
|
|
this._router = this.$options.router;
|
|
this._router.init(this);
|
|
Vue.util.defineReactive(this, '_route', this._router.history.current);
|
|
}
|
|
}
|
|
});
|
|
|
|
Vue.component('router-view', View);
|
|
Vue.component('router-link', Link);
|
|
|
|
var strats = Vue.config.optionMergeStrategies;
|
|
// use the same hook merging strategy for route hooks
|
|
strats.beforeRouteEnter = strats.beforeRouteLeave = strats.created;
|
|
}
|
|
|
|
/* */
|
|
|
|
var inBrowser = typeof window !== 'undefined';
|
|
|
|
/* */
|
|
|
|
function resolvePath (
|
|
relative,
|
|
base,
|
|
append
|
|
) {
|
|
if (relative.charAt(0) === '/') {
|
|
return relative
|
|
}
|
|
|
|
if (relative.charAt(0) === '?' || relative.charAt(0) === '#') {
|
|
return base + relative
|
|
}
|
|
|
|
var stack = base.split('/');
|
|
|
|
// remove trailing segment if:
|
|
// - not appending
|
|
// - appending to trailing slash (last segment is empty)
|
|
if (!append || !stack[stack.length - 1]) {
|
|
stack.pop();
|
|
}
|
|
|
|
// resolve relative path
|
|
var segments = relative.replace(/^\//, '').split('/');
|
|
for (var i = 0; i < segments.length; i++) {
|
|
var segment = segments[i];
|
|
if (segment === '.') {
|
|
continue
|
|
} else if (segment === '..') {
|
|
stack.pop();
|
|
} else {
|
|
stack.push(segment);
|
|
}
|
|
}
|
|
|
|
// ensure leading slash
|
|
if (stack[0] !== '') {
|
|
stack.unshift('');
|
|
}
|
|
|
|
return stack.join('/')
|
|
}
|
|
|
|
function parsePath (path) {
|
|
var hash = '';
|
|
var query = '';
|
|
|
|
var hashIndex = path.indexOf('#');
|
|
if (hashIndex >= 0) {
|
|
hash = path.slice(hashIndex);
|
|
path = path.slice(0, hashIndex);
|
|
}
|
|
|
|
var queryIndex = path.indexOf('?');
|
|
if (queryIndex >= 0) {
|
|
query = path.slice(queryIndex + 1);
|
|
path = path.slice(0, queryIndex);
|
|
}
|
|
|
|
return {
|
|
path: path,
|
|
query: query,
|
|
hash: hash
|
|
}
|
|
}
|
|
|
|
function cleanPath (path) {
|
|
return path.replace(/\/\//g, '/')
|
|
}
|
|
|
|
/* */
|
|
|
|
function createRouteMap (
|
|
routes,
|
|
oldPathMap,
|
|
oldNameMap
|
|
) {
|
|
var pathMap = oldPathMap || Object.create(null);
|
|
var nameMap = oldNameMap || Object.create(null);
|
|
|
|
routes.forEach(function (route) {
|
|
addRouteRecord(pathMap, nameMap, route);
|
|
});
|
|
|
|
return {
|
|
pathMap: pathMap,
|
|
nameMap: nameMap
|
|
}
|
|
}
|
|
|
|
function addRouteRecord (
|
|
pathMap,
|
|
nameMap,
|
|
route,
|
|
parent,
|
|
matchAs
|
|
) {
|
|
var path = route.path;
|
|
var name = route.name;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(path != null, "\"path\" is required in a route configuration.");
|
|
assert(
|
|
typeof route.component !== 'string',
|
|
"route config \"component\" for path: " + (String(path || name)) + " cannot be a " +
|
|
"string id. Use an actual component instead."
|
|
);
|
|
}
|
|
|
|
var record = {
|
|
path: normalizePath(path, parent),
|
|
components: route.components || { default: route.component },
|
|
instances: {},
|
|
name: name,
|
|
parent: parent,
|
|
matchAs: matchAs,
|
|
redirect: route.redirect,
|
|
beforeEnter: route.beforeEnter,
|
|
meta: route.meta || {},
|
|
props: route.props == null
|
|
? {}
|
|
: route.components
|
|
? route.props
|
|
: { default: route.props }
|
|
};
|
|
|
|
if (route.children) {
|
|
// Warn if route is named and has a default child route.
|
|
// If users navigate to this route by name, the default child will
|
|
// not be rendered (GH Issue #629)
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (route.name && route.children.some(function (child) { return /^\/?$/.test(child.path); })) {
|
|
warn(
|
|
false,
|
|
"Named Route '" + (route.name) + "' has a default child route. " +
|
|
"When navigating to this named route (:to=\"{name: '" + (route.name) + "'\"), " +
|
|
"the default child route will not be rendered. Remove the name from " +
|
|
"this route and use the name of the default child route for named " +
|
|
"links instead."
|
|
);
|
|
}
|
|
}
|
|
route.children.forEach(function (child) {
|
|
var childMatchAs = matchAs
|
|
? cleanPath((matchAs + "/" + (child.path)))
|
|
: undefined;
|
|
addRouteRecord(pathMap, nameMap, child, record, childMatchAs);
|
|
});
|
|
}
|
|
|
|
if (route.alias !== undefined) {
|
|
if (Array.isArray(route.alias)) {
|
|
route.alias.forEach(function (alias) {
|
|
var aliasRoute = {
|
|
path: alias,
|
|
children: route.children
|
|
};
|
|
addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);
|
|
});
|
|
} else {
|
|
var aliasRoute = {
|
|
path: route.alias,
|
|
children: route.children
|
|
};
|
|
addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);
|
|
}
|
|
}
|
|
|
|
if (!pathMap[record.path]) {
|
|
pathMap[record.path] = record;
|
|
}
|
|
|
|
if (name) {
|
|
if (!nameMap[name]) {
|
|
nameMap[name] = record;
|
|
} else if (process.env.NODE_ENV !== 'production' && !matchAs) {
|
|
warn(
|
|
false,
|
|
"Duplicate named routes definition: " +
|
|
"{ name: \"" + name + "\", path: \"" + (record.path) + "\" }"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
function normalizePath (path, parent) {
|
|
path = path.replace(/\/$/, '');
|
|
if (path[0] === '/') { return path }
|
|
if (parent == null) { return path }
|
|
return cleanPath(((parent.path) + "/" + path))
|
|
}
|
|
|
|
var index$1 = Array.isArray || function (arr) {
|
|
return Object.prototype.toString.call(arr) == '[object Array]';
|
|
};
|
|
|
|
var isarray = index$1;
|
|
|
|
/**
|
|
* Expose `pathToRegexp`.
|
|
*/
|
|
var index = pathToRegexp;
|
|
var parse_1 = parse;
|
|
var compile_1 = compile;
|
|
var tokensToFunction_1 = tokensToFunction;
|
|
var tokensToRegExp_1 = tokensToRegExp;
|
|
|
|
/**
|
|
* The main path matching regexp utility.
|
|
*
|
|
* @type {RegExp}
|
|
*/
|
|
var PATH_REGEXP = new RegExp([
|
|
// Match escaped characters that would otherwise appear in future matches.
|
|
// This allows the user to escape special characters that won't transform.
|
|
'(\\\\.)',
|
|
// Match Express-style parameters and un-named parameters with a prefix
|
|
// and optional suffixes. Matches appear as:
|
|
//
|
|
// "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
|
|
// "/route(\\d+)" => [undefined, undefined, undefined, "\d+", undefined, undefined]
|
|
// "/*" => ["/", undefined, undefined, undefined, undefined, "*"]
|
|
'([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'
|
|
].join('|'), 'g');
|
|
|
|
/**
|
|
* Parse a string for the raw tokens.
|
|
*
|
|
* @param {string} str
|
|
* @param {Object=} options
|
|
* @return {!Array}
|
|
*/
|
|
function parse (str, options) {
|
|
var tokens = [];
|
|
var key = 0;
|
|
var index = 0;
|
|
var path = '';
|
|
var defaultDelimiter = options && options.delimiter || '/';
|
|
var res;
|
|
|
|
while ((res = PATH_REGEXP.exec(str)) != null) {
|
|
var m = res[0];
|
|
var escaped = res[1];
|
|
var offset = res.index;
|
|
path += str.slice(index, offset);
|
|
index = offset + m.length;
|
|
|
|
// Ignore already escaped sequences.
|
|
if (escaped) {
|
|
path += escaped[1];
|
|
continue
|
|
}
|
|
|
|
var next = str[index];
|
|
var prefix = res[2];
|
|
var name = res[3];
|
|
var capture = res[4];
|
|
var group = res[5];
|
|
var modifier = res[6];
|
|
var asterisk = res[7];
|
|
|
|
// Push the current path onto the tokens.
|
|
if (path) {
|
|
tokens.push(path);
|
|
path = '';
|
|
}
|
|
|
|
var partial = prefix != null && next != null && next !== prefix;
|
|
var repeat = modifier === '+' || modifier === '*';
|
|
var optional = modifier === '?' || modifier === '*';
|
|
var delimiter = res[2] || defaultDelimiter;
|
|
var pattern = capture || group;
|
|
|
|
tokens.push({
|
|
name: name || key++,
|
|
prefix: prefix || '',
|
|
delimiter: delimiter,
|
|
optional: optional,
|
|
repeat: repeat,
|
|
partial: partial,
|
|
asterisk: !!asterisk,
|
|
pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')
|
|
});
|
|
}
|
|
|
|
// Match any characters still remaining.
|
|
if (index < str.length) {
|
|
path += str.substr(index);
|
|
}
|
|
|
|
// If the path exists, push it onto the end.
|
|
if (path) {
|
|
tokens.push(path);
|
|
}
|
|
|
|
return tokens
|
|
}
|
|
|
|
/**
|
|
* Compile a string to a template function for the path.
|
|
*
|
|
* @param {string} str
|
|
* @param {Object=} options
|
|
* @return {!function(Object=, Object=)}
|
|
*/
|
|
function compile (str, options) {
|
|
return tokensToFunction(parse(str, options))
|
|
}
|
|
|
|
/**
|
|
* Prettier encoding of URI path segments.
|
|
*
|
|
* @param {string}
|
|
* @return {string}
|
|
*/
|
|
function encodeURIComponentPretty (str) {
|
|
return encodeURI(str).replace(/[\/?#]/g, function (c) {
|
|
return '%' + c.charCodeAt(0).toString(16).toUpperCase()
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Encode the asterisk parameter. Similar to `pretty`, but allows slashes.
|
|
*
|
|
* @param {string}
|
|
* @return {string}
|
|
*/
|
|
function encodeAsterisk (str) {
|
|
return encodeURI(str).replace(/[?#]/g, function (c) {
|
|
return '%' + c.charCodeAt(0).toString(16).toUpperCase()
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Expose a method for transforming tokens into the path function.
|
|
*/
|
|
function tokensToFunction (tokens) {
|
|
// Compile all the tokens into regexps.
|
|
var matches = new Array(tokens.length);
|
|
|
|
// Compile all the patterns before compilation.
|
|
for (var i = 0; i < tokens.length; i++) {
|
|
if (typeof tokens[i] === 'object') {
|
|
matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');
|
|
}
|
|
}
|
|
|
|
return function (obj, opts) {
|
|
var path = '';
|
|
var data = obj || {};
|
|
var options = opts || {};
|
|
var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;
|
|
|
|
for (var i = 0; i < tokens.length; i++) {
|
|
var token = tokens[i];
|
|
|
|
if (typeof token === 'string') {
|
|
path += token;
|
|
|
|
continue
|
|
}
|
|
|
|
var value = data[token.name];
|
|
var segment;
|
|
|
|
if (value == null) {
|
|
if (token.optional) {
|
|
// Prepend partial segment prefixes.
|
|
if (token.partial) {
|
|
path += token.prefix;
|
|
}
|
|
|
|
continue
|
|
} else {
|
|
throw new TypeError('Expected "' + token.name + '" to be defined')
|
|
}
|
|
}
|
|
|
|
if (isarray(value)) {
|
|
if (!token.repeat) {
|
|
throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`')
|
|
}
|
|
|
|
if (value.length === 0) {
|
|
if (token.optional) {
|
|
continue
|
|
} else {
|
|
throw new TypeError('Expected "' + token.name + '" to not be empty')
|
|
}
|
|
}
|
|
|
|
for (var j = 0; j < value.length; j++) {
|
|
segment = encode(value[j]);
|
|
|
|
if (!matches[i].test(segment)) {
|
|
throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`')
|
|
}
|
|
|
|
path += (j === 0 ? token.prefix : token.delimiter) + segment;
|
|
}
|
|
|
|
continue
|
|
}
|
|
|
|
segment = token.asterisk ? encodeAsterisk(value) : encode(value);
|
|
|
|
if (!matches[i].test(segment)) {
|
|
throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"')
|
|
}
|
|
|
|
path += token.prefix + segment;
|
|
}
|
|
|
|
return path
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Escape a regular expression string.
|
|
*
|
|
* @param {string} str
|
|
* @return {string}
|
|
*/
|
|
function escapeString (str) {
|
|
return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1')
|
|
}
|
|
|
|
/**
|
|
* Escape the capturing group by escaping special characters and meaning.
|
|
*
|
|
* @param {string} group
|
|
* @return {string}
|
|
*/
|
|
function escapeGroup (group) {
|
|
return group.replace(/([=!:$\/()])/g, '\\$1')
|
|
}
|
|
|
|
/**
|
|
* Attach the keys as a property of the regexp.
|
|
*
|
|
* @param {!RegExp} re
|
|
* @param {Array} keys
|
|
* @return {!RegExp}
|
|
*/
|
|
function attachKeys (re, keys) {
|
|
re.keys = keys;
|
|
return re
|
|
}
|
|
|
|
/**
|
|
* Get the flags for a regexp from the options.
|
|
*
|
|
* @param {Object} options
|
|
* @return {string}
|
|
*/
|
|
function flags (options) {
|
|
return options.sensitive ? '' : 'i'
|
|
}
|
|
|
|
/**
|
|
* Pull out keys from a regexp.
|
|
*
|
|
* @param {!RegExp} path
|
|
* @param {!Array} keys
|
|
* @return {!RegExp}
|
|
*/
|
|
function regexpToRegexp (path, keys) {
|
|
// Use a negative lookahead to match only capturing groups.
|
|
var groups = path.source.match(/\((?!\?)/g);
|
|
|
|
if (groups) {
|
|
for (var i = 0; i < groups.length; i++) {
|
|
keys.push({
|
|
name: i,
|
|
prefix: null,
|
|
delimiter: null,
|
|
optional: false,
|
|
repeat: false,
|
|
partial: false,
|
|
asterisk: false,
|
|
pattern: null
|
|
});
|
|
}
|
|
}
|
|
|
|
return attachKeys(path, keys)
|
|
}
|
|
|
|
/**
|
|
* Transform an array into a regexp.
|
|
*
|
|
* @param {!Array} path
|
|
* @param {Array} keys
|
|
* @param {!Object} options
|
|
* @return {!RegExp}
|
|
*/
|
|
function arrayToRegexp (path, keys, options) {
|
|
var parts = [];
|
|
|
|
for (var i = 0; i < path.length; i++) {
|
|
parts.push(pathToRegexp(path[i], keys, options).source);
|
|
}
|
|
|
|
var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
|
|
|
|
return attachKeys(regexp, keys)
|
|
}
|
|
|
|
/**
|
|
* Create a path regexp from string input.
|
|
*
|
|
* @param {string} path
|
|
* @param {!Array} keys
|
|
* @param {!Object} options
|
|
* @return {!RegExp}
|
|
*/
|
|
function stringToRegexp (path, keys, options) {
|
|
return tokensToRegExp(parse(path, options), keys, options)
|
|
}
|
|
|
|
/**
|
|
* Expose a function for taking tokens and returning a RegExp.
|
|
*
|
|
* @param {!Array} tokens
|
|
* @param {(Array|Object)=} keys
|
|
* @param {Object=} options
|
|
* @return {!RegExp}
|
|
*/
|
|
function tokensToRegExp (tokens, keys, options) {
|
|
if (!isarray(keys)) {
|
|
options = /** @type {!Object} */ (keys || options);
|
|
keys = [];
|
|
}
|
|
|
|
options = options || {};
|
|
|
|
var strict = options.strict;
|
|
var end = options.end !== false;
|
|
var route = '';
|
|
|
|
// Iterate over the tokens and create our regexp string.
|
|
for (var i = 0; i < tokens.length; i++) {
|
|
var token = tokens[i];
|
|
|
|
if (typeof token === 'string') {
|
|
route += escapeString(token);
|
|
} else {
|
|
var prefix = escapeString(token.prefix);
|
|
var capture = '(?:' + token.pattern + ')';
|
|
|
|
keys.push(token);
|
|
|
|
if (token.repeat) {
|
|
capture += '(?:' + prefix + capture + ')*';
|
|
}
|
|
|
|
if (token.optional) {
|
|
if (!token.partial) {
|
|
capture = '(?:' + prefix + '(' + capture + '))?';
|
|
} else {
|
|
capture = prefix + '(' + capture + ')?';
|
|
}
|
|
} else {
|
|
capture = prefix + '(' + capture + ')';
|
|
}
|
|
|
|
route += capture;
|
|
}
|
|
}
|
|
|
|
var delimiter = escapeString(options.delimiter || '/');
|
|
var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
|
|
|
|
// In non-strict mode we allow a slash at the end of match. If the path to
|
|
// match already ends with a slash, we remove it for consistency. The slash
|
|
// is valid at the end of a path match, not in the middle. This is important
|
|
// in non-ending mode, where "/test/" shouldn't match "/test//route".
|
|
if (!strict) {
|
|
route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';
|
|
}
|
|
|
|
if (end) {
|
|
route += '$';
|
|
} else {
|
|
// In non-ending mode, we need the capturing groups to match as much as
|
|
// possible by using a positive lookahead to the end or next path segment.
|
|
route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
|
|
}
|
|
|
|
return attachKeys(new RegExp('^' + route, flags(options)), keys)
|
|
}
|
|
|
|
/**
|
|
* Normalize the given path string, returning a regular expression.
|
|
*
|
|
* An empty array can be passed in for the keys, which will hold the
|
|
* placeholder key descriptions. For example, using `/user/:id`, `keys` will
|
|
* contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
|
|
*
|
|
* @param {(string|RegExp|Array)} path
|
|
* @param {(Array|Object)=} keys
|
|
* @param {Object=} options
|
|
* @return {!RegExp}
|
|
*/
|
|
function pathToRegexp (path, keys, options) {
|
|
if (!isarray(keys)) {
|
|
options = /** @type {!Object} */ (keys || options);
|
|
keys = [];
|
|
}
|
|
|
|
options = options || {};
|
|
|
|
if (path instanceof RegExp) {
|
|
return regexpToRegexp(path, /** @type {!Array} */ (keys))
|
|
}
|
|
|
|
if (isarray(path)) {
|
|
return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)
|
|
}
|
|
|
|
return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)
|
|
}
|
|
|
|
index.parse = parse_1;
|
|
index.compile = compile_1;
|
|
index.tokensToFunction = tokensToFunction_1;
|
|
index.tokensToRegExp = tokensToRegExp_1;
|
|
|
|
/* */
|
|
|
|
var regexpCache = Object.create(null);
|
|
|
|
function getRouteRegex (path) {
|
|
var hit = regexpCache[path];
|
|
var keys, regexp;
|
|
|
|
if (hit) {
|
|
keys = hit.keys;
|
|
regexp = hit.regexp;
|
|
} else {
|
|
keys = [];
|
|
regexp = index(path, keys);
|
|
regexpCache[path] = { keys: keys, regexp: regexp };
|
|
}
|
|
|
|
return { keys: keys, regexp: regexp }
|
|
}
|
|
|
|
var regexpCompileCache = Object.create(null);
|
|
|
|
function fillParams (
|
|
path,
|
|
params,
|
|
routeMsg
|
|
) {
|
|
try {
|
|
var filler =
|
|
regexpCompileCache[path] ||
|
|
(regexpCompileCache[path] = index.compile(path));
|
|
return filler(params || {}, { pretty: true })
|
|
} catch (e) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
warn(false, ("missing param for " + routeMsg + ": " + (e.message)));
|
|
}
|
|
return ''
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
function normalizeLocation (
|
|
raw,
|
|
current,
|
|
append
|
|
) {
|
|
var next = typeof raw === 'string' ? { path: raw } : raw;
|
|
// named target
|
|
if (next.name || next._normalized) {
|
|
return next
|
|
}
|
|
|
|
// relative params
|
|
if (!next.path && next.params && current) {
|
|
next = assign({}, next);
|
|
next._normalized = true;
|
|
var params = assign(assign({}, current.params), next.params);
|
|
if (current.name) {
|
|
next.name = current.name;
|
|
next.params = params;
|
|
} else if (current.matched) {
|
|
var rawPath = current.matched[current.matched.length - 1].path;
|
|
next.path = fillParams(rawPath, params, ("path " + (current.path)));
|
|
} else if (process.env.NODE_ENV !== 'production') {
|
|
warn(false, "relative params navigation requires a current route.");
|
|
}
|
|
return next
|
|
}
|
|
|
|
var parsedPath = parsePath(next.path || '');
|
|
var basePath = (current && current.path) || '/';
|
|
var path = parsedPath.path
|
|
? resolvePath(parsedPath.path, basePath, append || next.append)
|
|
: (current && current.path) || '/';
|
|
var query = resolveQuery(parsedPath.query, next.query);
|
|
var hash = next.hash || parsedPath.hash;
|
|
if (hash && hash.charAt(0) !== '#') {
|
|
hash = "#" + hash;
|
|
}
|
|
|
|
return {
|
|
_normalized: true,
|
|
path: path,
|
|
query: query,
|
|
hash: hash
|
|
}
|
|
}
|
|
|
|
function assign (a, b) {
|
|
for (var key in b) {
|
|
a[key] = b[key];
|
|
}
|
|
return a
|
|
}
|
|
|
|
/* */
|
|
|
|
function createMatcher (routes) {
|
|
var ref = createRouteMap(routes);
|
|
var pathMap = ref.pathMap;
|
|
var nameMap = ref.nameMap;
|
|
|
|
function addRoutes (routes) {
|
|
createRouteMap(routes, pathMap, nameMap);
|
|
}
|
|
|
|
function match (
|
|
raw,
|
|
currentRoute,
|
|
redirectedFrom
|
|
) {
|
|
var location = normalizeLocation(raw, currentRoute);
|
|
var name = location.name;
|
|
|
|
if (name) {
|
|
var record = nameMap[name];
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
warn(record, ("Route with name '" + name + "' does not exist"));
|
|
}
|
|
var paramNames = getRouteRegex(record.path).keys
|
|
.filter(function (key) { return !key.optional; })
|
|
.map(function (key) { return key.name; });
|
|
|
|
if (typeof location.params !== 'object') {
|
|
location.params = {};
|
|
}
|
|
|
|
if (currentRoute && typeof currentRoute.params === 'object') {
|
|
for (var key in currentRoute.params) {
|
|
if (!(key in location.params) && paramNames.indexOf(key) > -1) {
|
|
location.params[key] = currentRoute.params[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (record) {
|
|
location.path = fillParams(record.path, location.params, ("named route \"" + name + "\""));
|
|
return _createRoute(record, location, redirectedFrom)
|
|
}
|
|
} else if (location.path) {
|
|
location.params = {};
|
|
for (var path in pathMap) {
|
|
if (matchRoute(path, location.params, location.path)) {
|
|
return _createRoute(pathMap[path], location, redirectedFrom)
|
|
}
|
|
}
|
|
}
|
|
// no match
|
|
return _createRoute(null, location)
|
|
}
|
|
|
|
function redirect (
|
|
record,
|
|
location
|
|
) {
|
|
var originalRedirect = record.redirect;
|
|
var redirect = typeof originalRedirect === 'function'
|
|
? originalRedirect(createRoute(record, location))
|
|
: originalRedirect;
|
|
|
|
if (typeof redirect === 'string') {
|
|
redirect = { path: redirect };
|
|
}
|
|
|
|
if (!redirect || typeof redirect !== 'object') {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
false, ("invalid redirect option: " + (JSON.stringify(redirect)))
|
|
);
|
|
return _createRoute(null, location)
|
|
}
|
|
|
|
var re = redirect;
|
|
var name = re.name;
|
|
var path = re.path;
|
|
var query = location.query;
|
|
var hash = location.hash;
|
|
var params = location.params;
|
|
query = re.hasOwnProperty('query') ? re.query : query;
|
|
hash = re.hasOwnProperty('hash') ? re.hash : hash;
|
|
params = re.hasOwnProperty('params') ? re.params : params;
|
|
|
|
if (name) {
|
|
// resolved named direct
|
|
var targetRecord = nameMap[name];
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(targetRecord, ("redirect failed: named route \"" + name + "\" not found."));
|
|
}
|
|
return match({
|
|
_normalized: true,
|
|
name: name,
|
|
query: query,
|
|
hash: hash,
|
|
params: params
|
|
}, undefined, location)
|
|
} else if (path) {
|
|
// 1. resolve relative redirect
|
|
var rawPath = resolveRecordPath(path, record);
|
|
// 2. resolve params
|
|
var resolvedPath = fillParams(rawPath, params, ("redirect route with path \"" + rawPath + "\""));
|
|
// 3. rematch with existing query and hash
|
|
return match({
|
|
_normalized: true,
|
|
path: resolvedPath,
|
|
query: query,
|
|
hash: hash
|
|
}, undefined, location)
|
|
} else {
|
|
warn(false, ("invalid redirect option: " + (JSON.stringify(redirect))));
|
|
return _createRoute(null, location)
|
|
}
|
|
}
|
|
|
|
function alias (
|
|
record,
|
|
location,
|
|
matchAs
|
|
) {
|
|
var aliasedPath = fillParams(matchAs, location.params, ("aliased route with path \"" + matchAs + "\""));
|
|
var aliasedMatch = match({
|
|
_normalized: true,
|
|
path: aliasedPath
|
|
});
|
|
if (aliasedMatch) {
|
|
var matched = aliasedMatch.matched;
|
|
var aliasedRecord = matched[matched.length - 1];
|
|
location.params = aliasedMatch.params;
|
|
return _createRoute(aliasedRecord, location)
|
|
}
|
|
return _createRoute(null, location)
|
|
}
|
|
|
|
function _createRoute (
|
|
record,
|
|
location,
|
|
redirectedFrom
|
|
) {
|
|
if (record && record.redirect) {
|
|
return redirect(record, redirectedFrom || location)
|
|
}
|
|
if (record && record.matchAs) {
|
|
return alias(record, location, record.matchAs)
|
|
}
|
|
return createRoute(record, location, redirectedFrom)
|
|
}
|
|
|
|
return {
|
|
match: match,
|
|
addRoutes: addRoutes
|
|
}
|
|
}
|
|
|
|
function matchRoute (
|
|
path,
|
|
params,
|
|
pathname
|
|
) {
|
|
var ref = getRouteRegex(path);
|
|
var regexp = ref.regexp;
|
|
var keys = ref.keys;
|
|
var m = pathname.match(regexp);
|
|
|
|
if (!m) {
|
|
return false
|
|
} else if (!params) {
|
|
return true
|
|
}
|
|
|
|
for (var i = 1, len = m.length; i < len; ++i) {
|
|
var key = keys[i - 1];
|
|
var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];
|
|
if (key) { params[key.name] = val; }
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
function resolveRecordPath (path, record) {
|
|
return resolvePath(path, record.parent ? record.parent.path : '/', true)
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var positionStore = Object.create(null);
|
|
|
|
function setupScroll () {
|
|
window.addEventListener('popstate', function (e) {
|
|
if (e.state && e.state.key) {
|
|
setStateKey(e.state.key);
|
|
}
|
|
});
|
|
|
|
window.addEventListener('scroll', saveScrollPosition);
|
|
}
|
|
|
|
function handleScroll (
|
|
router,
|
|
to,
|
|
from,
|
|
isPop
|
|
) {
|
|
if (!router.app) {
|
|
return
|
|
}
|
|
|
|
var behavior = router.options.scrollBehavior;
|
|
if (!behavior) {
|
|
return
|
|
}
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(typeof behavior === 'function', "scrollBehavior must be a function");
|
|
}
|
|
|
|
// wait until re-render finishes before scrolling
|
|
router.app.$nextTick(function () {
|
|
var position = getScrollPosition();
|
|
var shouldScroll = behavior(to, from, isPop ? position : null);
|
|
if (!shouldScroll) {
|
|
return
|
|
}
|
|
var isObject = typeof shouldScroll === 'object';
|
|
if (isObject && typeof shouldScroll.selector === 'string') {
|
|
var el = document.querySelector(shouldScroll.selector);
|
|
if (el) {
|
|
position = getElementPosition(el);
|
|
} else if (isValidPosition(shouldScroll)) {
|
|
position = normalizePosition(shouldScroll);
|
|
}
|
|
} else if (isObject && isValidPosition(shouldScroll)) {
|
|
position = normalizePosition(shouldScroll);
|
|
}
|
|
|
|
if (position) {
|
|
window.scrollTo(position.x, position.y);
|
|
}
|
|
});
|
|
}
|
|
|
|
function saveScrollPosition () {
|
|
var key = getStateKey();
|
|
if (key) {
|
|
positionStore[key] = {
|
|
x: window.pageXOffset,
|
|
y: window.pageYOffset
|
|
};
|
|
}
|
|
}
|
|
|
|
function getScrollPosition () {
|
|
var key = getStateKey();
|
|
if (key) {
|
|
return positionStore[key]
|
|
}
|
|
}
|
|
|
|
function getElementPosition (el) {
|
|
var docRect = document.documentElement.getBoundingClientRect();
|
|
var elRect = el.getBoundingClientRect();
|
|
return {
|
|
x: elRect.left - docRect.left,
|
|
y: elRect.top - docRect.top
|
|
}
|
|
}
|
|
|
|
function isValidPosition (obj) {
|
|
return isNumber(obj.x) || isNumber(obj.y)
|
|
}
|
|
|
|
function normalizePosition (obj) {
|
|
return {
|
|
x: isNumber(obj.x) ? obj.x : window.pageXOffset,
|
|
y: isNumber(obj.y) ? obj.y : window.pageYOffset
|
|
}
|
|
}
|
|
|
|
function isNumber (v) {
|
|
return typeof v === 'number'
|
|
}
|
|
|
|
/* */
|
|
|
|
var supportsPushState = inBrowser && (function () {
|
|
var ua = window.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
|
|
})();
|
|
|
|
// use User Timing api (if present) for more accurate key precision
|
|
var Time = inBrowser && window.performance && window.performance.now
|
|
? window.performance
|
|
: Date;
|
|
|
|
var _key = genKey();
|
|
|
|
function genKey () {
|
|
return Time.now().toFixed(3)
|
|
}
|
|
|
|
function getStateKey () {
|
|
return _key
|
|
}
|
|
|
|
function setStateKey (key) {
|
|
_key = key;
|
|
}
|
|
|
|
function pushState (url, replace) {
|
|
// try...catch the pushState call to get around Safari
|
|
// DOM Exception 18 where it limits to 100 pushState calls
|
|
var history = window.history;
|
|
try {
|
|
if (replace) {
|
|
history.replaceState({ key: _key }, '', url);
|
|
} else {
|
|
_key = genKey();
|
|
history.pushState({ key: _key }, '', url);
|
|
}
|
|
saveScrollPosition();
|
|
} catch (e) {
|
|
window.location[replace ? 'replace' : 'assign'](url);
|
|
}
|
|
}
|
|
|
|
function replaceState (url) {
|
|
pushState(url, true);
|
|
}
|
|
|
|
/* */
|
|
|
|
function runQueue (queue, fn, cb) {
|
|
var step = function (index) {
|
|
if (index >= queue.length) {
|
|
cb();
|
|
} else {
|
|
if (queue[index]) {
|
|
fn(queue[index], function () {
|
|
step(index + 1);
|
|
});
|
|
} else {
|
|
step(index + 1);
|
|
}
|
|
}
|
|
};
|
|
step(0);
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var History = function History (router, base) {
|
|
this.router = router;
|
|
this.base = normalizeBase(base);
|
|
// start with a route object that stands for "nowhere"
|
|
this.current = START;
|
|
this.pending = null;
|
|
this.ready = false;
|
|
this.readyCbs = [];
|
|
};
|
|
|
|
History.prototype.listen = function listen (cb) {
|
|
this.cb = cb;
|
|
};
|
|
|
|
History.prototype.onReady = function onReady (cb) {
|
|
if (this.ready) {
|
|
cb();
|
|
} else {
|
|
this.readyCbs.push(cb);
|
|
}
|
|
};
|
|
|
|
History.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {
|
|
var this$1 = this;
|
|
|
|
var route = this.router.match(location, this.current);
|
|
this.confirmTransition(route, function () {
|
|
this$1.updateRoute(route);
|
|
onComplete && onComplete(route);
|
|
this$1.ensureURL();
|
|
|
|
// fire ready cbs once
|
|
if (!this$1.ready) {
|
|
this$1.ready = true;
|
|
this$1.readyCbs.forEach(function (cb) {
|
|
cb(route);
|
|
});
|
|
}
|
|
}, onAbort);
|
|
};
|
|
|
|
History.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {
|
|
var this$1 = this;
|
|
|
|
var current = this.current;
|
|
var abort = function () { onAbort && onAbort(); };
|
|
if (
|
|
isSameRoute(route, current) &&
|
|
// in the case the route map has been dynamically appended to
|
|
route.matched.length === current.matched.length
|
|
) {
|
|
this.ensureURL();
|
|
return abort()
|
|
}
|
|
|
|
var ref = resolveQueue(this.current.matched, route.matched);
|
|
var updated = ref.updated;
|
|
var deactivated = ref.deactivated;
|
|
var activated = ref.activated;
|
|
|
|
var queue = [].concat(
|
|
// in-component leave guards
|
|
extractLeaveGuards(deactivated),
|
|
// global before hooks
|
|
this.router.beforeHooks,
|
|
// in-component update hooks
|
|
extractUpdateHooks(updated),
|
|
// in-config enter guards
|
|
activated.map(function (m) { return m.beforeEnter; }),
|
|
// async components
|
|
resolveAsyncComponents(activated)
|
|
);
|
|
|
|
this.pending = route;
|
|
var iterator = function (hook, next) {
|
|
if (this$1.pending !== route) {
|
|
return abort()
|
|
}
|
|
hook(route, current, function (to) {
|
|
if (to === false) {
|
|
// next(false) -> abort navigation, ensure current URL
|
|
this$1.ensureURL(true);
|
|
abort();
|
|
} else if (typeof to === 'string' || typeof to === 'object') {
|
|
// next('/') or next({ path: '/' }) -> redirect
|
|
(typeof to === 'object' && to.replace) ? this$1.replace(to) : this$1.push(to);
|
|
abort();
|
|
} else {
|
|
// confirm transition and pass on the value
|
|
next(to);
|
|
}
|
|
});
|
|
};
|
|
|
|
runQueue(queue, iterator, function () {
|
|
var postEnterCbs = [];
|
|
var isValid = function () { return this$1.current === route; };
|
|
var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);
|
|
// wait until async components are resolved before
|
|
// extracting in-component enter guards
|
|
runQueue(enterGuards, iterator, function () {
|
|
if (this$1.pending !== route) {
|
|
return abort()
|
|
}
|
|
this$1.pending = null;
|
|
onComplete(route);
|
|
if (this$1.router.app) {
|
|
this$1.router.app.$nextTick(function () {
|
|
postEnterCbs.forEach(function (cb) { return cb(); });
|
|
});
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
History.prototype.updateRoute = function updateRoute (route) {
|
|
var prev = this.current;
|
|
this.current = route;
|
|
this.cb && this.cb(route);
|
|
this.router.afterHooks.forEach(function (hook) {
|
|
hook && hook(route, prev);
|
|
});
|
|
};
|
|
|
|
function normalizeBase (base) {
|
|
if (!base) {
|
|
if (inBrowser) {
|
|
// respect <base> tag
|
|
var baseEl = document.querySelector('base');
|
|
base = baseEl ? baseEl.getAttribute('href') : '/';
|
|
} else {
|
|
base = '/';
|
|
}
|
|
}
|
|
// make sure there's the starting slash
|
|
if (base.charAt(0) !== '/') {
|
|
base = '/' + base;
|
|
}
|
|
// remove trailing slash
|
|
return base.replace(/\/$/, '')
|
|
}
|
|
|
|
function resolveQueue (
|
|
current,
|
|
next
|
|
) {
|
|
var i;
|
|
var max = Math.max(current.length, next.length);
|
|
for (i = 0; i < max; i++) {
|
|
if (current[i] !== next[i]) {
|
|
break
|
|
}
|
|
}
|
|
return {
|
|
updated: next.slice(0, i),
|
|
activated: next.slice(i),
|
|
deactivated: current.slice(i)
|
|
}
|
|
}
|
|
|
|
function extractGuards (
|
|
records,
|
|
name,
|
|
bind,
|
|
reverse
|
|
) {
|
|
var guards = flatMapComponents(records, function (def, instance, match, key) {
|
|
var guard = extractGuard(def, name);
|
|
if (guard) {
|
|
return Array.isArray(guard)
|
|
? guard.map(function (guard) { return bind(guard, instance, match, key); })
|
|
: bind(guard, instance, match, key)
|
|
}
|
|
});
|
|
return flatten(reverse ? guards.reverse() : guards)
|
|
}
|
|
|
|
function extractGuard (
|
|
def,
|
|
key
|
|
) {
|
|
if (typeof def !== 'function') {
|
|
// extend now so that global mixins are applied.
|
|
def = _Vue.extend(def);
|
|
}
|
|
return def.options[key]
|
|
}
|
|
|
|
function extractLeaveGuards (deactivated) {
|
|
return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)
|
|
}
|
|
|
|
function extractUpdateHooks (updated) {
|
|
return extractGuards(updated, 'beforeRouteUpdate', bindGuard)
|
|
}
|
|
|
|
function bindGuard (guard, instance) {
|
|
return function boundRouteGuard () {
|
|
return guard.apply(instance, arguments)
|
|
}
|
|
}
|
|
|
|
function extractEnterGuards (
|
|
activated,
|
|
cbs,
|
|
isValid
|
|
) {
|
|
return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {
|
|
return bindEnterGuard(guard, match, key, cbs, isValid)
|
|
})
|
|
}
|
|
|
|
function bindEnterGuard (
|
|
guard,
|
|
match,
|
|
key,
|
|
cbs,
|
|
isValid
|
|
) {
|
|
return function routeEnterGuard (to, from, next) {
|
|
return guard(to, from, function (cb) {
|
|
next(cb);
|
|
if (typeof cb === 'function') {
|
|
cbs.push(function () {
|
|
// #750
|
|
// if a router-view is wrapped with an out-in transition,
|
|
// the instance may not have been registered at this time.
|
|
// we will need to poll for registration until current route
|
|
// is no longer valid.
|
|
poll(cb, match.instances, key, isValid);
|
|
});
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
function poll (
|
|
cb, // somehow flow cannot infer this is a function
|
|
instances,
|
|
key,
|
|
isValid
|
|
) {
|
|
if (instances[key]) {
|
|
cb(instances[key]);
|
|
} else if (isValid()) {
|
|
setTimeout(function () {
|
|
poll(cb, instances, key, isValid);
|
|
}, 16);
|
|
}
|
|
}
|
|
|
|
function resolveAsyncComponents (matched) {
|
|
return flatMapComponents(matched, function (def, _, match, key) {
|
|
// if it's a function and doesn't have Vue options attached,
|
|
// assume it's an async component resolve function.
|
|
// we are not using Vue's default async resolving mechanism because
|
|
// we want to halt the navigation until the incoming component has been
|
|
// resolved.
|
|
if (typeof def === 'function' && !def.options) {
|
|
return function (to, from, next) {
|
|
var resolve = once(function (resolvedDef) {
|
|
match.components[key] = resolvedDef;
|
|
next();
|
|
});
|
|
|
|
var reject = once(function (reason) {
|
|
warn(false, ("Failed to resolve async component " + key + ": " + reason));
|
|
next(false);
|
|
});
|
|
|
|
var res = def(resolve, reject);
|
|
if (res && typeof res.then === 'function') {
|
|
res.then(resolve, reject);
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
function flatMapComponents (
|
|
matched,
|
|
fn
|
|
) {
|
|
return flatten(matched.map(function (m) {
|
|
return Object.keys(m.components).map(function (key) { return fn(
|
|
m.components[key],
|
|
m.instances[key],
|
|
m, key
|
|
); })
|
|
}))
|
|
}
|
|
|
|
function flatten (arr) {
|
|
return Array.prototype.concat.apply([], arr)
|
|
}
|
|
|
|
// in Webpack 2, require.ensure now also returns a Promise
|
|
// so the resolve/reject functions may get called an extra time
|
|
// if the user uses an arrow function shorthand that happens to
|
|
// return that Promise.
|
|
function once (fn) {
|
|
var called = false;
|
|
return function () {
|
|
if (called) { return }
|
|
called = true;
|
|
return fn.apply(this, arguments)
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var HTML5History = (function (History$$1) {
|
|
function HTML5History (router, base) {
|
|
var this$1 = this;
|
|
|
|
History$$1.call(this, router, base);
|
|
|
|
var expectScroll = router.options.scrollBehavior;
|
|
|
|
if (expectScroll) {
|
|
setupScroll();
|
|
}
|
|
|
|
window.addEventListener('popstate', function (e) {
|
|
this$1.transitionTo(getLocation(this$1.base), function (route) {
|
|
if (expectScroll) {
|
|
handleScroll(router, route, this$1.current, true);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
if ( History$$1 ) HTML5History.__proto__ = History$$1;
|
|
HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );
|
|
HTML5History.prototype.constructor = HTML5History;
|
|
|
|
HTML5History.prototype.go = function go (n) {
|
|
window.history.go(n);
|
|
};
|
|
|
|
HTML5History.prototype.push = function push (location, onComplete, onAbort) {
|
|
var this$1 = this;
|
|
|
|
this.transitionTo(location, function (route) {
|
|
pushState(cleanPath(this$1.base + route.fullPath));
|
|
handleScroll(this$1.router, route, this$1.current, false);
|
|
onComplete && onComplete(route);
|
|
}, onAbort);
|
|
};
|
|
|
|
HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {
|
|
var this$1 = this;
|
|
|
|
this.transitionTo(location, function (route) {
|
|
replaceState(cleanPath(this$1.base + route.fullPath));
|
|
handleScroll(this$1.router, route, this$1.current, false);
|
|
onComplete && onComplete(route);
|
|
}, onAbort);
|
|
};
|
|
|
|
HTML5History.prototype.ensureURL = function ensureURL (push) {
|
|
if (getLocation(this.base) !== this.current.fullPath) {
|
|
var current = cleanPath(this.base + this.current.fullPath);
|
|
push ? pushState(current) : replaceState(current);
|
|
}
|
|
};
|
|
|
|
HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {
|
|
return getLocation(this.base)
|
|
};
|
|
|
|
return HTML5History;
|
|
}(History));
|
|
|
|
function getLocation (base) {
|
|
var path = window.location.pathname;
|
|
if (base && path.indexOf(base) === 0) {
|
|
path = path.slice(base.length);
|
|
}
|
|
return (path || '/') + window.location.search + window.location.hash
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var HashHistory = (function (History$$1) {
|
|
function HashHistory (router, base, fallback) {
|
|
History$$1.call(this, router, base);
|
|
// check history fallback deeplinking
|
|
if (fallback && checkFallback(this.base)) {
|
|
return
|
|
}
|
|
ensureSlash();
|
|
}
|
|
|
|
if ( History$$1 ) HashHistory.__proto__ = History$$1;
|
|
HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );
|
|
HashHistory.prototype.constructor = HashHistory;
|
|
|
|
// this is delayed until the app mounts
|
|
// to avoid the hashchange listener being fired too early
|
|
HashHistory.prototype.setupListeners = function setupListeners () {
|
|
var this$1 = this;
|
|
|
|
window.addEventListener('hashchange', function () {
|
|
if (!ensureSlash()) {
|
|
return
|
|
}
|
|
this$1.transitionTo(getHash(), function (route) {
|
|
replaceHash(route.fullPath);
|
|
});
|
|
});
|
|
};
|
|
|
|
HashHistory.prototype.push = function push (location, onComplete, onAbort) {
|
|
this.transitionTo(location, function (route) {
|
|
pushHash(route.fullPath);
|
|
onComplete && onComplete(route);
|
|
}, onAbort);
|
|
};
|
|
|
|
HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {
|
|
this.transitionTo(location, function (route) {
|
|
replaceHash(route.fullPath);
|
|
onComplete && onComplete(route);
|
|
}, onAbort);
|
|
};
|
|
|
|
HashHistory.prototype.go = function go (n) {
|
|
window.history.go(n);
|
|
};
|
|
|
|
HashHistory.prototype.ensureURL = function ensureURL (push) {
|
|
var current = this.current.fullPath;
|
|
if (getHash() !== current) {
|
|
push ? pushHash(current) : replaceHash(current);
|
|
}
|
|
};
|
|
|
|
HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {
|
|
return getHash()
|
|
};
|
|
|
|
return HashHistory;
|
|
}(History));
|
|
|
|
function checkFallback (base) {
|
|
var location = getLocation(base);
|
|
if (!/^\/#/.test(location)) {
|
|
window.location.replace(
|
|
cleanPath(base + '/#' + location)
|
|
);
|
|
return true
|
|
}
|
|
}
|
|
|
|
function ensureSlash () {
|
|
var path = getHash();
|
|
if (path.charAt(0) === '/') {
|
|
return true
|
|
}
|
|
replaceHash('/' + path);
|
|
return false
|
|
}
|
|
|
|
function getHash () {
|
|
// We can't use window.location.hash here because it's not
|
|
// consistent across browsers - Firefox will pre-decode it!
|
|
var href = window.location.href;
|
|
var index = href.indexOf('#');
|
|
return index === -1 ? '' : href.slice(index + 1)
|
|
}
|
|
|
|
function pushHash (path) {
|
|
window.location.hash = path;
|
|
}
|
|
|
|
function replaceHash (path) {
|
|
var i = window.location.href.indexOf('#');
|
|
window.location.replace(
|
|
window.location.href.slice(0, i >= 0 ? i : 0) + '#' + path
|
|
);
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var AbstractHistory = (function (History$$1) {
|
|
function AbstractHistory (router, base) {
|
|
History$$1.call(this, router, base);
|
|
this.stack = [];
|
|
this.index = -1;
|
|
}
|
|
|
|
if ( History$$1 ) AbstractHistory.__proto__ = History$$1;
|
|
AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );
|
|
AbstractHistory.prototype.constructor = AbstractHistory;
|
|
|
|
AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {
|
|
var this$1 = this;
|
|
|
|
this.transitionTo(location, function (route) {
|
|
this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);
|
|
this$1.index++;
|
|
onComplete && onComplete(route);
|
|
}, onAbort);
|
|
};
|
|
|
|
AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {
|
|
var this$1 = this;
|
|
|
|
this.transitionTo(location, function (route) {
|
|
this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);
|
|
onComplete && onComplete(route);
|
|
}, onAbort);
|
|
};
|
|
|
|
AbstractHistory.prototype.go = function go (n) {
|
|
var this$1 = this;
|
|
|
|
var targetIndex = this.index + n;
|
|
if (targetIndex < 0 || targetIndex >= this.stack.length) {
|
|
return
|
|
}
|
|
var route = this.stack[targetIndex];
|
|
this.confirmTransition(route, function () {
|
|
this$1.index = targetIndex;
|
|
this$1.updateRoute(route);
|
|
});
|
|
};
|
|
|
|
AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {
|
|
var current = this.stack[this.stack.length - 1];
|
|
return current ? current.fullPath : '/'
|
|
};
|
|
|
|
AbstractHistory.prototype.ensureURL = function ensureURL () {
|
|
// noop
|
|
};
|
|
|
|
return AbstractHistory;
|
|
}(History));
|
|
|
|
/* */
|
|
|
|
var VueRouter = function VueRouter (options) {
|
|
if ( options === void 0 ) options = {};
|
|
|
|
this.app = null;
|
|
this.apps = [];
|
|
this.options = options;
|
|
this.beforeHooks = [];
|
|
this.afterHooks = [];
|
|
this.matcher = createMatcher(options.routes || []);
|
|
|
|
var mode = options.mode || 'hash';
|
|
this.fallback = mode === 'history' && !supportsPushState;
|
|
if (this.fallback) {
|
|
mode = 'hash';
|
|
}
|
|
if (!inBrowser) {
|
|
mode = 'abstract';
|
|
}
|
|
this.mode = mode;
|
|
|
|
switch (mode) {
|
|
case 'history':
|
|
this.history = new HTML5History(this, options.base);
|
|
break
|
|
case 'hash':
|
|
this.history = new HashHistory(this, options.base, this.fallback);
|
|
break
|
|
case 'abstract':
|
|
this.history = new AbstractHistory(this, options.base);
|
|
break
|
|
default:
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(false, ("invalid mode: " + mode));
|
|
}
|
|
}
|
|
};
|
|
|
|
var prototypeAccessors = { currentRoute: {} };
|
|
|
|
VueRouter.prototype.match = function match (
|
|
raw,
|
|
current,
|
|
redirectedFrom
|
|
) {
|
|
return this.matcher.match(raw, current, redirectedFrom)
|
|
};
|
|
|
|
prototypeAccessors.currentRoute.get = function () {
|
|
return this.history && this.history.current
|
|
};
|
|
|
|
VueRouter.prototype.init = function init (app /* Vue component instance */) {
|
|
var this$1 = this;
|
|
|
|
process.env.NODE_ENV !== 'production' && assert(
|
|
install.installed,
|
|
"not installed. Make sure to call `Vue.use(VueRouter)` " +
|
|
"before creating root instance."
|
|
);
|
|
|
|
this.apps.push(app);
|
|
|
|
// main app already initialized.
|
|
if (this.app) {
|
|
return
|
|
}
|
|
|
|
this.app = app;
|
|
|
|
var history = this.history;
|
|
|
|
if (history instanceof HTML5History) {
|
|
history.transitionTo(history.getCurrentLocation());
|
|
} else if (history instanceof HashHistory) {
|
|
var setupHashListener = function () {
|
|
history.setupListeners();
|
|
};
|
|
history.transitionTo(
|
|
history.getCurrentLocation(),
|
|
setupHashListener,
|
|
setupHashListener
|
|
);
|
|
}
|
|
|
|
history.listen(function (route) {
|
|
this$1.apps.forEach(function (app) {
|
|
app._route = route;
|
|
});
|
|
});
|
|
};
|
|
|
|
VueRouter.prototype.beforeEach = function beforeEach (fn) {
|
|
this.beforeHooks.push(fn);
|
|
};
|
|
|
|
VueRouter.prototype.afterEach = function afterEach (fn) {
|
|
this.afterHooks.push(fn);
|
|
};
|
|
|
|
VueRouter.prototype.onReady = function onReady (cb) {
|
|
this.history.onReady(cb);
|
|
};
|
|
|
|
VueRouter.prototype.push = function push (location, onComplete, onAbort) {
|
|
this.history.push(location, onComplete, onAbort);
|
|
};
|
|
|
|
VueRouter.prototype.replace = function replace (location, onComplete, onAbort) {
|
|
this.history.replace(location, onComplete, onAbort);
|
|
};
|
|
|
|
VueRouter.prototype.go = function go (n) {
|
|
this.history.go(n);
|
|
};
|
|
|
|
VueRouter.prototype.back = function back () {
|
|
this.go(-1);
|
|
};
|
|
|
|
VueRouter.prototype.forward = function forward () {
|
|
this.go(1);
|
|
};
|
|
|
|
VueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {
|
|
var route = to
|
|
? this.resolve(to).route
|
|
: this.currentRoute;
|
|
if (!route) {
|
|
return []
|
|
}
|
|
return [].concat.apply([], route.matched.map(function (m) {
|
|
return Object.keys(m.components).map(function (key) {
|
|
return m.components[key]
|
|
})
|
|
}))
|
|
};
|
|
|
|
VueRouter.prototype.resolve = function resolve (
|
|
to,
|
|
current,
|
|
append
|
|
) {
|
|
var location = normalizeLocation(to, current || this.history.current, append);
|
|
var route = this.match(location, current);
|
|
var fullPath = route.redirectedFrom || route.fullPath;
|
|
var base = this.history.base;
|
|
var href = createHref(base, fullPath, this.mode);
|
|
return {
|
|
location: location,
|
|
route: route,
|
|
href: href,
|
|
// for backwards compat
|
|
normalizedTo: location,
|
|
resolved: route
|
|
}
|
|
};
|
|
|
|
VueRouter.prototype.addRoutes = function addRoutes (routes) {
|
|
this.matcher.addRoutes(routes);
|
|
if (this.history.current !== START) {
|
|
this.history.transitionTo(this.history.getCurrentLocation());
|
|
}
|
|
};
|
|
|
|
Object.defineProperties( VueRouter.prototype, prototypeAccessors );
|
|
|
|
function createHref (base, fullPath, mode) {
|
|
var path = mode === 'hash' ? '#' + fullPath : fullPath;
|
|
return base ? cleanPath(base + '/' + path) : path
|
|
}
|
|
|
|
VueRouter.install = install;
|
|
VueRouter.version = '2.2.0';
|
|
|
|
if (inBrowser && window.Vue) {
|
|
window.Vue.use(VueRouter);
|
|
}
|
|
|
|
module.exports = VueRouter;
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))
|
|
|
|
/***/ }),
|
|
/* 62 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* WEBPACK VAR INJECTION */(function(process, global) {/*!
|
|
* Vue.js v2.1.8
|
|
* (c) 2014-2016 Evan You
|
|
* Released under the MIT License.
|
|
*/
|
|
|
|
|
|
/* */
|
|
|
|
/**
|
|
* Convert a value to a string that is actually rendered.
|
|
*/
|
|
function _toString (val) {
|
|
return val == null
|
|
? ''
|
|
: typeof val === 'object'
|
|
? JSON.stringify(val, null, 2)
|
|
: String(val)
|
|
}
|
|
|
|
/**
|
|
* Convert a input value to a number for persistence.
|
|
* If the conversion fails, return original string.
|
|
*/
|
|
function toNumber (val) {
|
|
var n = parseFloat(val, 10);
|
|
return (n || n === 0) ? n : val
|
|
}
|
|
|
|
/**
|
|
* Make a map and return a function for checking if a key
|
|
* is in that map.
|
|
*/
|
|
function makeMap (
|
|
str,
|
|
expectsLowerCase
|
|
) {
|
|
var map = Object.create(null);
|
|
var list = str.split(',');
|
|
for (var i = 0; i < list.length; i++) {
|
|
map[list[i]] = true;
|
|
}
|
|
return expectsLowerCase
|
|
? function (val) { return map[val.toLowerCase()]; }
|
|
: function (val) { return map[val]; }
|
|
}
|
|
|
|
/**
|
|
* Check if a tag is a built-in tag.
|
|
*/
|
|
var isBuiltInTag = makeMap('slot,component', true);
|
|
|
|
/**
|
|
* Remove an item from an array
|
|
*/
|
|
function remove$1 (arr, item) {
|
|
if (arr.length) {
|
|
var index = arr.indexOf(item);
|
|
if (index > -1) {
|
|
return arr.splice(index, 1)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check whether the object has the property.
|
|
*/
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function hasOwn (obj, key) {
|
|
return hasOwnProperty.call(obj, key)
|
|
}
|
|
|
|
/**
|
|
* Check if value is primitive
|
|
*/
|
|
function isPrimitive (value) {
|
|
return typeof value === 'string' || typeof value === 'number'
|
|
}
|
|
|
|
/**
|
|
* Create a cached version of a pure function.
|
|
*/
|
|
function cached (fn) {
|
|
var cache = Object.create(null);
|
|
return (function cachedFn (str) {
|
|
var hit = cache[str];
|
|
return hit || (cache[str] = fn(str))
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Camelize a hyphen-delmited string.
|
|
*/
|
|
var camelizeRE = /-(\w)/g;
|
|
var camelize = cached(function (str) {
|
|
return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
|
|
});
|
|
|
|
/**
|
|
* Capitalize a string.
|
|
*/
|
|
var capitalize = cached(function (str) {
|
|
return str.charAt(0).toUpperCase() + str.slice(1)
|
|
});
|
|
|
|
/**
|
|
* Hyphenate a camelCase string.
|
|
*/
|
|
var hyphenateRE = /([^-])([A-Z])/g;
|
|
var hyphenate = cached(function (str) {
|
|
return str
|
|
.replace(hyphenateRE, '$1-$2')
|
|
.replace(hyphenateRE, '$1-$2')
|
|
.toLowerCase()
|
|
});
|
|
|
|
/**
|
|
* Simple bind, faster than native
|
|
*/
|
|
function bind$1 (fn, ctx) {
|
|
function boundFn (a) {
|
|
var l = arguments.length;
|
|
return l
|
|
? l > 1
|
|
? fn.apply(ctx, arguments)
|
|
: fn.call(ctx, a)
|
|
: fn.call(ctx)
|
|
}
|
|
// record original fn length
|
|
boundFn._length = fn.length;
|
|
return boundFn
|
|
}
|
|
|
|
/**
|
|
* Convert an Array-like object to a real Array.
|
|
*/
|
|
function toArray (list, start) {
|
|
start = start || 0;
|
|
var i = list.length - start;
|
|
var ret = new Array(i);
|
|
while (i--) {
|
|
ret[i] = list[i + start];
|
|
}
|
|
return ret
|
|
}
|
|
|
|
/**
|
|
* Mix properties into target object.
|
|
*/
|
|
function extend (to, _from) {
|
|
for (var key in _from) {
|
|
to[key] = _from[key];
|
|
}
|
|
return to
|
|
}
|
|
|
|
/**
|
|
* Quick object check - this is primarily used to tell
|
|
* Objects from primitive values when we know the value
|
|
* is a JSON-compliant type.
|
|
*/
|
|
function isObject (obj) {
|
|
return obj !== null && typeof obj === 'object'
|
|
}
|
|
|
|
/**
|
|
* Strict object type check. Only returns true
|
|
* for plain JavaScript objects.
|
|
*/
|
|
var toString = Object.prototype.toString;
|
|
var OBJECT_STRING = '[object Object]';
|
|
function isPlainObject (obj) {
|
|
return toString.call(obj) === OBJECT_STRING
|
|
}
|
|
|
|
/**
|
|
* Merge an Array of Objects into a single Object.
|
|
*/
|
|
function toObject (arr) {
|
|
var res = {};
|
|
for (var i = 0; i < arr.length; i++) {
|
|
if (arr[i]) {
|
|
extend(res, arr[i]);
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
/**
|
|
* Perform no operation.
|
|
*/
|
|
function noop () {}
|
|
|
|
/**
|
|
* Always return false.
|
|
*/
|
|
var no = function () { return false; };
|
|
|
|
/**
|
|
* Return same value
|
|
*/
|
|
var identity = function (_) { return _; };
|
|
|
|
/**
|
|
* Generate a static keys string from compiler modules.
|
|
*/
|
|
function genStaticKeys (modules) {
|
|
return modules.reduce(function (keys, m) {
|
|
return keys.concat(m.staticKeys || [])
|
|
}, []).join(',')
|
|
}
|
|
|
|
/**
|
|
* Check if two values are loosely equal - that is,
|
|
* if they are plain objects, do they have the same shape?
|
|
*/
|
|
function looseEqual (a, b) {
|
|
var isObjectA = isObject(a);
|
|
var isObjectB = isObject(b);
|
|
if (isObjectA && isObjectB) {
|
|
return JSON.stringify(a) === JSON.stringify(b)
|
|
} else if (!isObjectA && !isObjectB) {
|
|
return String(a) === String(b)
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
function looseIndexOf (arr, val) {
|
|
for (var i = 0; i < arr.length; i++) {
|
|
if (looseEqual(arr[i], val)) { return i }
|
|
}
|
|
return -1
|
|
}
|
|
|
|
/* */
|
|
|
|
var config = {
|
|
/**
|
|
* Option merge strategies (used in core/util/options)
|
|
*/
|
|
optionMergeStrategies: Object.create(null),
|
|
|
|
/**
|
|
* Whether to suppress warnings.
|
|
*/
|
|
silent: false,
|
|
|
|
/**
|
|
* Whether to enable devtools
|
|
*/
|
|
devtools: process.env.NODE_ENV !== 'production',
|
|
|
|
/**
|
|
* Error handler for watcher errors
|
|
*/
|
|
errorHandler: null,
|
|
|
|
/**
|
|
* Ignore certain custom elements
|
|
*/
|
|
ignoredElements: [],
|
|
|
|
/**
|
|
* Custom user key aliases for v-on
|
|
*/
|
|
keyCodes: Object.create(null),
|
|
|
|
/**
|
|
* Check if a tag is reserved so that it cannot be registered as a
|
|
* component. This is platform-dependent and may be overwritten.
|
|
*/
|
|
isReservedTag: no,
|
|
|
|
/**
|
|
* Check if a tag is an unknown element.
|
|
* Platform-dependent.
|
|
*/
|
|
isUnknownElement: no,
|
|
|
|
/**
|
|
* Get the namespace of an element
|
|
*/
|
|
getTagNamespace: noop,
|
|
|
|
/**
|
|
* Parse the real tag name for the specific platform.
|
|
*/
|
|
parsePlatformTagName: identity,
|
|
|
|
/**
|
|
* Check if an attribute must be bound using property, e.g. value
|
|
* Platform-dependent.
|
|
*/
|
|
mustUseProp: no,
|
|
|
|
/**
|
|
* List of asset types that a component can own.
|
|
*/
|
|
_assetTypes: [
|
|
'component',
|
|
'directive',
|
|
'filter'
|
|
],
|
|
|
|
/**
|
|
* List of lifecycle hooks.
|
|
*/
|
|
_lifecycleHooks: [
|
|
'beforeCreate',
|
|
'created',
|
|
'beforeMount',
|
|
'mounted',
|
|
'beforeUpdate',
|
|
'updated',
|
|
'beforeDestroy',
|
|
'destroyed',
|
|
'activated',
|
|
'deactivated'
|
|
],
|
|
|
|
/**
|
|
* Max circular updates allowed in a scheduler flush cycle.
|
|
*/
|
|
_maxUpdateCount: 100
|
|
};
|
|
|
|
/* */
|
|
|
|
/**
|
|
* Check if a string starts with $ or _
|
|
*/
|
|
function isReserved (str) {
|
|
var c = (str + '').charCodeAt(0);
|
|
return c === 0x24 || c === 0x5F
|
|
}
|
|
|
|
/**
|
|
* Define a property.
|
|
*/
|
|
function def (obj, key, val, enumerable) {
|
|
Object.defineProperty(obj, key, {
|
|
value: val,
|
|
enumerable: !!enumerable,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse simple path.
|
|
*/
|
|
var bailRE = /[^\w.$]/;
|
|
function parsePath (path) {
|
|
if (bailRE.test(path)) {
|
|
return
|
|
} else {
|
|
var segments = path.split('.');
|
|
return function (obj) {
|
|
for (var i = 0; i < segments.length; i++) {
|
|
if (!obj) { return }
|
|
obj = obj[segments[i]];
|
|
}
|
|
return obj
|
|
}
|
|
}
|
|
}
|
|
|
|
/* */
|
|
/* globals MutationObserver */
|
|
|
|
// can we use __proto__?
|
|
var hasProto = '__proto__' in {};
|
|
|
|
// Browser environment sniffing
|
|
var inBrowser = typeof window !== 'undefined';
|
|
var UA = inBrowser && window.navigator.userAgent.toLowerCase();
|
|
var isIE = UA && /msie|trident/.test(UA);
|
|
var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
|
|
var isEdge = UA && UA.indexOf('edge/') > 0;
|
|
var isAndroid = UA && UA.indexOf('android') > 0;
|
|
var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);
|
|
|
|
// this needs to be lazy-evaled because vue may be required before
|
|
// vue-server-renderer can set VUE_ENV
|
|
var _isServer;
|
|
var isServerRendering = function () {
|
|
if (_isServer === undefined) {
|
|
/* istanbul ignore if */
|
|
if (!inBrowser && typeof global !== 'undefined') {
|
|
// detect presence of vue-server-renderer and avoid
|
|
// Webpack shimming the process
|
|
_isServer = global['process'].env.VUE_ENV === 'server';
|
|
} else {
|
|
_isServer = false;
|
|
}
|
|
}
|
|
return _isServer
|
|
};
|
|
|
|
// detect devtools
|
|
var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
|
|
|
|
/* istanbul ignore next */
|
|
function isNative (Ctor) {
|
|
return /native code/.test(Ctor.toString())
|
|
}
|
|
|
|
/**
|
|
* Defer a task to execute it asynchronously.
|
|
*/
|
|
var nextTick = (function () {
|
|
var callbacks = [];
|
|
var pending = false;
|
|
var timerFunc;
|
|
|
|
function nextTickHandler () {
|
|
pending = false;
|
|
var copies = callbacks.slice(0);
|
|
callbacks.length = 0;
|
|
for (var i = 0; i < copies.length; i++) {
|
|
copies[i]();
|
|
}
|
|
}
|
|
|
|
// the nextTick behavior leverages the microtask queue, which can be accessed
|
|
// via either native Promise.then or MutationObserver.
|
|
// MutationObserver has wider support, however it is seriously bugged in
|
|
// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
|
|
// completely stops working after triggering a few times... so, if native
|
|
// Promise is available, we will use it:
|
|
/* istanbul ignore if */
|
|
if (typeof Promise !== 'undefined' && isNative(Promise)) {
|
|
var p = Promise.resolve();
|
|
var logError = function (err) { console.error(err); };
|
|
timerFunc = function () {
|
|
p.then(nextTickHandler).catch(logError);
|
|
// in problematic UIWebViews, Promise.then doesn't completely break, but
|
|
// it can get stuck in a weird state where callbacks are pushed into the
|
|
// microtask queue but the queue isn't being flushed, until the browser
|
|
// needs to do some other work, e.g. handle a timer. Therefore we can
|
|
// "force" the microtask queue to be flushed by adding an empty timer.
|
|
if (isIOS) { setTimeout(noop); }
|
|
};
|
|
} else if (typeof MutationObserver !== 'undefined' && (
|
|
isNative(MutationObserver) ||
|
|
// PhantomJS and iOS 7.x
|
|
MutationObserver.toString() === '[object MutationObserverConstructor]'
|
|
)) {
|
|
// use MutationObserver where native Promise is not available,
|
|
// e.g. PhantomJS IE11, iOS7, Android 4.4
|
|
var counter = 1;
|
|
var observer = new MutationObserver(nextTickHandler);
|
|
var textNode = document.createTextNode(String(counter));
|
|
observer.observe(textNode, {
|
|
characterData: true
|
|
});
|
|
timerFunc = function () {
|
|
counter = (counter + 1) % 2;
|
|
textNode.data = String(counter);
|
|
};
|
|
} else {
|
|
// fallback to setTimeout
|
|
/* istanbul ignore next */
|
|
timerFunc = function () {
|
|
setTimeout(nextTickHandler, 0);
|
|
};
|
|
}
|
|
|
|
return function queueNextTick (cb, ctx) {
|
|
var _resolve;
|
|
callbacks.push(function () {
|
|
if (cb) { cb.call(ctx); }
|
|
if (_resolve) { _resolve(ctx); }
|
|
});
|
|
if (!pending) {
|
|
pending = true;
|
|
timerFunc();
|
|
}
|
|
if (!cb && typeof Promise !== 'undefined') {
|
|
return new Promise(function (resolve) {
|
|
_resolve = resolve;
|
|
})
|
|
}
|
|
}
|
|
})();
|
|
|
|
var _Set;
|
|
/* istanbul ignore if */
|
|
if (typeof Set !== 'undefined' && isNative(Set)) {
|
|
// use native Set when available.
|
|
_Set = Set;
|
|
} else {
|
|
// a non-standard Set polyfill that only works with primitive keys.
|
|
_Set = (function () {
|
|
function Set () {
|
|
this.set = Object.create(null);
|
|
}
|
|
Set.prototype.has = function has (key) {
|
|
return this.set[key] === true
|
|
};
|
|
Set.prototype.add = function add (key) {
|
|
this.set[key] = true;
|
|
};
|
|
Set.prototype.clear = function clear () {
|
|
this.set = Object.create(null);
|
|
};
|
|
|
|
return Set;
|
|
}());
|
|
}
|
|
|
|
var warn = noop;
|
|
var formatComponentName;
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
var hasConsole = typeof console !== 'undefined';
|
|
|
|
warn = function (msg, vm) {
|
|
if (hasConsole && (!config.silent)) {
|
|
console.error("[Vue warn]: " + msg + " " + (
|
|
vm ? formatLocation(formatComponentName(vm)) : ''
|
|
));
|
|
}
|
|
};
|
|
|
|
formatComponentName = function (vm) {
|
|
if (vm.$root === vm) {
|
|
return 'root instance'
|
|
}
|
|
var name = vm._isVue
|
|
? vm.$options.name || vm.$options._componentTag
|
|
: vm.name;
|
|
return (
|
|
(name ? ("component <" + name + ">") : "anonymous component") +
|
|
(vm._isVue && vm.$options.__file ? (" at " + (vm.$options.__file)) : '')
|
|
)
|
|
};
|
|
|
|
var formatLocation = function (str) {
|
|
if (str === 'anonymous component') {
|
|
str += " - use the \"name\" option for better debugging messages.";
|
|
}
|
|
return ("\n(found in " + str + ")")
|
|
};
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var uid$1 = 0;
|
|
|
|
/**
|
|
* A dep is an observable that can have multiple
|
|
* directives subscribing to it.
|
|
*/
|
|
var Dep = function Dep () {
|
|
this.id = uid$1++;
|
|
this.subs = [];
|
|
};
|
|
|
|
Dep.prototype.addSub = function addSub (sub) {
|
|
this.subs.push(sub);
|
|
};
|
|
|
|
Dep.prototype.removeSub = function removeSub (sub) {
|
|
remove$1(this.subs, sub);
|
|
};
|
|
|
|
Dep.prototype.depend = function depend () {
|
|
if (Dep.target) {
|
|
Dep.target.addDep(this);
|
|
}
|
|
};
|
|
|
|
Dep.prototype.notify = function notify () {
|
|
// stablize the subscriber list first
|
|
var subs = this.subs.slice();
|
|
for (var i = 0, l = subs.length; i < l; i++) {
|
|
subs[i].update();
|
|
}
|
|
};
|
|
|
|
// the current target watcher being evaluated.
|
|
// this is globally unique because there could be only one
|
|
// watcher being evaluated at any time.
|
|
Dep.target = null;
|
|
var targetStack = [];
|
|
|
|
function pushTarget (_target) {
|
|
if (Dep.target) { targetStack.push(Dep.target); }
|
|
Dep.target = _target;
|
|
}
|
|
|
|
function popTarget () {
|
|
Dep.target = targetStack.pop();
|
|
}
|
|
|
|
/*
|
|
* not type checking this file because flow doesn't play well with
|
|
* dynamically accessing methods on Array prototype
|
|
*/
|
|
|
|
var arrayProto = Array.prototype;
|
|
var arrayMethods = Object.create(arrayProto);[
|
|
'push',
|
|
'pop',
|
|
'shift',
|
|
'unshift',
|
|
'splice',
|
|
'sort',
|
|
'reverse'
|
|
]
|
|
.forEach(function (method) {
|
|
// cache original method
|
|
var original = arrayProto[method];
|
|
def(arrayMethods, method, function mutator () {
|
|
var arguments$1 = arguments;
|
|
|
|
// avoid leaking arguments:
|
|
// http://jsperf.com/closure-with-arguments
|
|
var i = arguments.length;
|
|
var args = new Array(i);
|
|
while (i--) {
|
|
args[i] = arguments$1[i];
|
|
}
|
|
var result = original.apply(this, args);
|
|
var ob = this.__ob__;
|
|
var inserted;
|
|
switch (method) {
|
|
case 'push':
|
|
inserted = args;
|
|
break
|
|
case 'unshift':
|
|
inserted = args;
|
|
break
|
|
case 'splice':
|
|
inserted = args.slice(2);
|
|
break
|
|
}
|
|
if (inserted) { ob.observeArray(inserted); }
|
|
// notify change
|
|
ob.dep.notify();
|
|
return result
|
|
});
|
|
});
|
|
|
|
/* */
|
|
|
|
var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
|
|
|
|
/**
|
|
* By default, when a reactive property is set, the new value is
|
|
* also converted to become reactive. However when passing down props,
|
|
* we don't want to force conversion because the value may be a nested value
|
|
* under a frozen data structure. Converting it would defeat the optimization.
|
|
*/
|
|
var observerState = {
|
|
shouldConvert: true,
|
|
isSettingProps: false
|
|
};
|
|
|
|
/**
|
|
* Observer class that are attached to each observed
|
|
* object. Once attached, the observer converts target
|
|
* object's property keys into getter/setters that
|
|
* collect dependencies and dispatches updates.
|
|
*/
|
|
var Observer = function Observer (value) {
|
|
this.value = value;
|
|
this.dep = new Dep();
|
|
this.vmCount = 0;
|
|
def(value, '__ob__', this);
|
|
if (Array.isArray(value)) {
|
|
var augment = hasProto
|
|
? protoAugment
|
|
: copyAugment;
|
|
augment(value, arrayMethods, arrayKeys);
|
|
this.observeArray(value);
|
|
} else {
|
|
this.walk(value);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Walk through each property and convert them into
|
|
* getter/setters. This method should only be called when
|
|
* value type is Object.
|
|
*/
|
|
Observer.prototype.walk = function walk (obj) {
|
|
var keys = Object.keys(obj);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
defineReactive$$1(obj, keys[i], obj[keys[i]]);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Observe a list of Array items.
|
|
*/
|
|
Observer.prototype.observeArray = function observeArray (items) {
|
|
for (var i = 0, l = items.length; i < l; i++) {
|
|
observe(items[i]);
|
|
}
|
|
};
|
|
|
|
// helpers
|
|
|
|
/**
|
|
* Augment an target Object or Array by intercepting
|
|
* the prototype chain using __proto__
|
|
*/
|
|
function protoAugment (target, src) {
|
|
/* eslint-disable no-proto */
|
|
target.__proto__ = src;
|
|
/* eslint-enable no-proto */
|
|
}
|
|
|
|
/**
|
|
* Augment an target Object or Array by defining
|
|
* hidden properties.
|
|
*/
|
|
/* istanbul ignore next */
|
|
function copyAugment (target, src, keys) {
|
|
for (var i = 0, l = keys.length; i < l; i++) {
|
|
var key = keys[i];
|
|
def(target, key, src[key]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempt to create an observer instance for a value,
|
|
* returns the new observer if successfully observed,
|
|
* or the existing observer if the value already has one.
|
|
*/
|
|
function observe (value, asRootData) {
|
|
if (!isObject(value)) {
|
|
return
|
|
}
|
|
var ob;
|
|
if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
|
|
ob = value.__ob__;
|
|
} else if (
|
|
observerState.shouldConvert &&
|
|
!isServerRendering() &&
|
|
(Array.isArray(value) || isPlainObject(value)) &&
|
|
Object.isExtensible(value) &&
|
|
!value._isVue
|
|
) {
|
|
ob = new Observer(value);
|
|
}
|
|
if (asRootData && ob) {
|
|
ob.vmCount++;
|
|
}
|
|
return ob
|
|
}
|
|
|
|
/**
|
|
* Define a reactive property on an Object.
|
|
*/
|
|
function defineReactive$$1 (
|
|
obj,
|
|
key,
|
|
val,
|
|
customSetter
|
|
) {
|
|
var dep = new Dep();
|
|
|
|
var property = Object.getOwnPropertyDescriptor(obj, key);
|
|
if (property && property.configurable === false) {
|
|
return
|
|
}
|
|
|
|
// cater for pre-defined getter/setters
|
|
var getter = property && property.get;
|
|
var setter = property && property.set;
|
|
|
|
var childOb = observe(val);
|
|
Object.defineProperty(obj, key, {
|
|
enumerable: true,
|
|
configurable: true,
|
|
get: function reactiveGetter () {
|
|
var value = getter ? getter.call(obj) : val;
|
|
if (Dep.target) {
|
|
dep.depend();
|
|
if (childOb) {
|
|
childOb.dep.depend();
|
|
}
|
|
if (Array.isArray(value)) {
|
|
dependArray(value);
|
|
}
|
|
}
|
|
return value
|
|
},
|
|
set: function reactiveSetter (newVal) {
|
|
var value = getter ? getter.call(obj) : val;
|
|
/* eslint-disable no-self-compare */
|
|
if (newVal === value || (newVal !== newVal && value !== value)) {
|
|
return
|
|
}
|
|
/* eslint-enable no-self-compare */
|
|
if (process.env.NODE_ENV !== 'production' && customSetter) {
|
|
customSetter();
|
|
}
|
|
if (setter) {
|
|
setter.call(obj, newVal);
|
|
} else {
|
|
val = newVal;
|
|
}
|
|
childOb = observe(newVal);
|
|
dep.notify();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Set a property on an object. Adds the new property and
|
|
* triggers change notification if the property doesn't
|
|
* already exist.
|
|
*/
|
|
function set$1 (obj, key, val) {
|
|
if (Array.isArray(obj)) {
|
|
obj.length = Math.max(obj.length, key);
|
|
obj.splice(key, 1, val);
|
|
return val
|
|
}
|
|
if (hasOwn(obj, key)) {
|
|
obj[key] = val;
|
|
return
|
|
}
|
|
var ob = obj.__ob__;
|
|
if (obj._isVue || (ob && ob.vmCount)) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'Avoid adding reactive properties to a Vue instance or its root $data ' +
|
|
'at runtime - declare it upfront in the data option.'
|
|
);
|
|
return
|
|
}
|
|
if (!ob) {
|
|
obj[key] = val;
|
|
return
|
|
}
|
|
defineReactive$$1(ob.value, key, val);
|
|
ob.dep.notify();
|
|
return val
|
|
}
|
|
|
|
/**
|
|
* Delete a property and trigger change if necessary.
|
|
*/
|
|
function del (obj, key) {
|
|
var ob = obj.__ob__;
|
|
if (obj._isVue || (ob && ob.vmCount)) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'Avoid deleting properties on a Vue instance or its root $data ' +
|
|
'- just set it to null.'
|
|
);
|
|
return
|
|
}
|
|
if (!hasOwn(obj, key)) {
|
|
return
|
|
}
|
|
delete obj[key];
|
|
if (!ob) {
|
|
return
|
|
}
|
|
ob.dep.notify();
|
|
}
|
|
|
|
/**
|
|
* Collect dependencies on array elements when the array is touched, since
|
|
* we cannot intercept array element access like property getters.
|
|
*/
|
|
function dependArray (value) {
|
|
for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
|
|
e = value[i];
|
|
e && e.__ob__ && e.__ob__.dep.depend();
|
|
if (Array.isArray(e)) {
|
|
dependArray(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
/**
|
|
* Option overwriting strategies are functions that handle
|
|
* how to merge a parent option value and a child option
|
|
* value into the final value.
|
|
*/
|
|
var strats = config.optionMergeStrategies;
|
|
|
|
/**
|
|
* Options with restrictions
|
|
*/
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
strats.el = strats.propsData = function (parent, child, vm, key) {
|
|
if (!vm) {
|
|
warn(
|
|
"option \"" + key + "\" can only be used during instance " +
|
|
'creation with the `new` keyword.'
|
|
);
|
|
}
|
|
return defaultStrat(parent, child)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Helper that recursively merges two data objects together.
|
|
*/
|
|
function mergeData (to, from) {
|
|
if (!from) { return to }
|
|
var key, toVal, fromVal;
|
|
var keys = Object.keys(from);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
key = keys[i];
|
|
toVal = to[key];
|
|
fromVal = from[key];
|
|
if (!hasOwn(to, key)) {
|
|
set$1(to, key, fromVal);
|
|
} else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
|
|
mergeData(toVal, fromVal);
|
|
}
|
|
}
|
|
return to
|
|
}
|
|
|
|
/**
|
|
* Data
|
|
*/
|
|
strats.data = function (
|
|
parentVal,
|
|
childVal,
|
|
vm
|
|
) {
|
|
if (!vm) {
|
|
// in a Vue.extend merge, both should be functions
|
|
if (!childVal) {
|
|
return parentVal
|
|
}
|
|
if (typeof childVal !== 'function') {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'The "data" option should be a function ' +
|
|
'that returns a per-instance value in component ' +
|
|
'definitions.',
|
|
vm
|
|
);
|
|
return parentVal
|
|
}
|
|
if (!parentVal) {
|
|
return childVal
|
|
}
|
|
// when parentVal & childVal are both present,
|
|
// we need to return a function that returns the
|
|
// merged result of both functions... no need to
|
|
// check if parentVal is a function here because
|
|
// it has to be a function to pass previous merges.
|
|
return function mergedDataFn () {
|
|
return mergeData(
|
|
childVal.call(this),
|
|
parentVal.call(this)
|
|
)
|
|
}
|
|
} else if (parentVal || childVal) {
|
|
return function mergedInstanceDataFn () {
|
|
// instance merge
|
|
var instanceData = typeof childVal === 'function'
|
|
? childVal.call(vm)
|
|
: childVal;
|
|
var defaultData = typeof parentVal === 'function'
|
|
? parentVal.call(vm)
|
|
: undefined;
|
|
if (instanceData) {
|
|
return mergeData(instanceData, defaultData)
|
|
} else {
|
|
return defaultData
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Hooks and param attributes are merged as arrays.
|
|
*/
|
|
function mergeHook (
|
|
parentVal,
|
|
childVal
|
|
) {
|
|
return childVal
|
|
? parentVal
|
|
? parentVal.concat(childVal)
|
|
: Array.isArray(childVal)
|
|
? childVal
|
|
: [childVal]
|
|
: parentVal
|
|
}
|
|
|
|
config._lifecycleHooks.forEach(function (hook) {
|
|
strats[hook] = mergeHook;
|
|
});
|
|
|
|
/**
|
|
* Assets
|
|
*
|
|
* When a vm is present (instance creation), we need to do
|
|
* a three-way merge between constructor options, instance
|
|
* options and parent options.
|
|
*/
|
|
function mergeAssets (parentVal, childVal) {
|
|
var res = Object.create(parentVal || null);
|
|
return childVal
|
|
? extend(res, childVal)
|
|
: res
|
|
}
|
|
|
|
config._assetTypes.forEach(function (type) {
|
|
strats[type + 's'] = mergeAssets;
|
|
});
|
|
|
|
/**
|
|
* Watchers.
|
|
*
|
|
* Watchers hashes should not overwrite one
|
|
* another, so we merge them as arrays.
|
|
*/
|
|
strats.watch = function (parentVal, childVal) {
|
|
/* istanbul ignore if */
|
|
if (!childVal) { return parentVal }
|
|
if (!parentVal) { return childVal }
|
|
var ret = {};
|
|
extend(ret, parentVal);
|
|
for (var key in childVal) {
|
|
var parent = ret[key];
|
|
var child = childVal[key];
|
|
if (parent && !Array.isArray(parent)) {
|
|
parent = [parent];
|
|
}
|
|
ret[key] = parent
|
|
? parent.concat(child)
|
|
: [child];
|
|
}
|
|
return ret
|
|
};
|
|
|
|
/**
|
|
* Other object hashes.
|
|
*/
|
|
strats.props =
|
|
strats.methods =
|
|
strats.computed = function (parentVal, childVal) {
|
|
if (!childVal) { return parentVal }
|
|
if (!parentVal) { return childVal }
|
|
var ret = Object.create(null);
|
|
extend(ret, parentVal);
|
|
extend(ret, childVal);
|
|
return ret
|
|
};
|
|
|
|
/**
|
|
* Default strategy.
|
|
*/
|
|
var defaultStrat = function (parentVal, childVal) {
|
|
return childVal === undefined
|
|
? parentVal
|
|
: childVal
|
|
};
|
|
|
|
/**
|
|
* Validate component names
|
|
*/
|
|
function checkComponents (options) {
|
|
for (var key in options.components) {
|
|
var lower = key.toLowerCase();
|
|
if (isBuiltInTag(lower) || config.isReservedTag(lower)) {
|
|
warn(
|
|
'Do not use built-in or reserved HTML elements as component ' +
|
|
'id: ' + key
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ensure all props option syntax are normalized into the
|
|
* Object-based format.
|
|
*/
|
|
function normalizeProps (options) {
|
|
var props = options.props;
|
|
if (!props) { return }
|
|
var res = {};
|
|
var i, val, name;
|
|
if (Array.isArray(props)) {
|
|
i = props.length;
|
|
while (i--) {
|
|
val = props[i];
|
|
if (typeof val === 'string') {
|
|
name = camelize(val);
|
|
res[name] = { type: null };
|
|
} else if (process.env.NODE_ENV !== 'production') {
|
|
warn('props must be strings when using array syntax.');
|
|
}
|
|
}
|
|
} else if (isPlainObject(props)) {
|
|
for (var key in props) {
|
|
val = props[key];
|
|
name = camelize(key);
|
|
res[name] = isPlainObject(val)
|
|
? val
|
|
: { type: val };
|
|
}
|
|
}
|
|
options.props = res;
|
|
}
|
|
|
|
/**
|
|
* Normalize raw function directives into object format.
|
|
*/
|
|
function normalizeDirectives (options) {
|
|
var dirs = options.directives;
|
|
if (dirs) {
|
|
for (var key in dirs) {
|
|
var def = dirs[key];
|
|
if (typeof def === 'function') {
|
|
dirs[key] = { bind: def, update: def };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge two option objects into a new one.
|
|
* Core utility used in both instantiation and inheritance.
|
|
*/
|
|
function mergeOptions (
|
|
parent,
|
|
child,
|
|
vm
|
|
) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
checkComponents(child);
|
|
}
|
|
normalizeProps(child);
|
|
normalizeDirectives(child);
|
|
var extendsFrom = child.extends;
|
|
if (extendsFrom) {
|
|
parent = typeof extendsFrom === 'function'
|
|
? mergeOptions(parent, extendsFrom.options, vm)
|
|
: mergeOptions(parent, extendsFrom, vm);
|
|
}
|
|
if (child.mixins) {
|
|
for (var i = 0, l = child.mixins.length; i < l; i++) {
|
|
var mixin = child.mixins[i];
|
|
if (mixin.prototype instanceof Vue$2) {
|
|
mixin = mixin.options;
|
|
}
|
|
parent = mergeOptions(parent, mixin, vm);
|
|
}
|
|
}
|
|
var options = {};
|
|
var key;
|
|
for (key in parent) {
|
|
mergeField(key);
|
|
}
|
|
for (key in child) {
|
|
if (!hasOwn(parent, key)) {
|
|
mergeField(key);
|
|
}
|
|
}
|
|
function mergeField (key) {
|
|
var strat = strats[key] || defaultStrat;
|
|
options[key] = strat(parent[key], child[key], vm, key);
|
|
}
|
|
return options
|
|
}
|
|
|
|
/**
|
|
* Resolve an asset.
|
|
* This function is used because child instances need access
|
|
* to assets defined in its ancestor chain.
|
|
*/
|
|
function resolveAsset (
|
|
options,
|
|
type,
|
|
id,
|
|
warnMissing
|
|
) {
|
|
/* istanbul ignore if */
|
|
if (typeof id !== 'string') {
|
|
return
|
|
}
|
|
var assets = options[type];
|
|
// check local registration variations first
|
|
if (hasOwn(assets, id)) { return assets[id] }
|
|
var camelizedId = camelize(id);
|
|
if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
|
|
var PascalCaseId = capitalize(camelizedId);
|
|
if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
|
|
// fallback to prototype chain
|
|
var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
|
|
if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
|
|
warn(
|
|
'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
|
|
options
|
|
);
|
|
}
|
|
return res
|
|
}
|
|
|
|
/* */
|
|
|
|
function validateProp (
|
|
key,
|
|
propOptions,
|
|
propsData,
|
|
vm
|
|
) {
|
|
var prop = propOptions[key];
|
|
var absent = !hasOwn(propsData, key);
|
|
var value = propsData[key];
|
|
// handle boolean props
|
|
if (isType(Boolean, prop.type)) {
|
|
if (absent && !hasOwn(prop, 'default')) {
|
|
value = false;
|
|
} else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
|
|
value = true;
|
|
}
|
|
}
|
|
// check default value
|
|
if (value === undefined) {
|
|
value = getPropDefaultValue(vm, prop, key);
|
|
// since the default value is a fresh copy,
|
|
// make sure to observe it.
|
|
var prevShouldConvert = observerState.shouldConvert;
|
|
observerState.shouldConvert = true;
|
|
observe(value);
|
|
observerState.shouldConvert = prevShouldConvert;
|
|
}
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assertProp(prop, key, value, vm, absent);
|
|
}
|
|
return value
|
|
}
|
|
|
|
/**
|
|
* Get the default value of a prop.
|
|
*/
|
|
function getPropDefaultValue (vm, prop, key) {
|
|
// no default, return undefined
|
|
if (!hasOwn(prop, 'default')) {
|
|
return undefined
|
|
}
|
|
var def = prop.default;
|
|
// warn against non-factory defaults for Object & Array
|
|
if (isObject(def)) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'Invalid default value for prop "' + key + '": ' +
|
|
'Props with type Object/Array must use a factory function ' +
|
|
'to return the default value.',
|
|
vm
|
|
);
|
|
}
|
|
// the raw prop value was also undefined from previous render,
|
|
// return previous default value to avoid unnecessary watcher trigger
|
|
if (vm && vm.$options.propsData &&
|
|
vm.$options.propsData[key] === undefined &&
|
|
vm[key] !== undefined) {
|
|
return vm[key]
|
|
}
|
|
// call factory function for non-Function types
|
|
return typeof def === 'function' && prop.type !== Function
|
|
? def.call(vm)
|
|
: def
|
|
}
|
|
|
|
/**
|
|
* Assert whether a prop is valid.
|
|
*/
|
|
function assertProp (
|
|
prop,
|
|
name,
|
|
value,
|
|
vm,
|
|
absent
|
|
) {
|
|
if (prop.required && absent) {
|
|
warn(
|
|
'Missing required prop: "' + name + '"',
|
|
vm
|
|
);
|
|
return
|
|
}
|
|
if (value == null && !prop.required) {
|
|
return
|
|
}
|
|
var type = prop.type;
|
|
var valid = !type || type === true;
|
|
var expectedTypes = [];
|
|
if (type) {
|
|
if (!Array.isArray(type)) {
|
|
type = [type];
|
|
}
|
|
for (var i = 0; i < type.length && !valid; i++) {
|
|
var assertedType = assertType(value, type[i]);
|
|
expectedTypes.push(assertedType.expectedType || '');
|
|
valid = assertedType.valid;
|
|
}
|
|
}
|
|
if (!valid) {
|
|
warn(
|
|
'Invalid prop: type check failed for prop "' + name + '".' +
|
|
' Expected ' + expectedTypes.map(capitalize).join(', ') +
|
|
', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',
|
|
vm
|
|
);
|
|
return
|
|
}
|
|
var validator = prop.validator;
|
|
if (validator) {
|
|
if (!validator(value)) {
|
|
warn(
|
|
'Invalid prop: custom validator check failed for prop "' + name + '".',
|
|
vm
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assert the type of a value
|
|
*/
|
|
function assertType (value, type) {
|
|
var valid;
|
|
var expectedType = getType(type);
|
|
if (expectedType === 'String') {
|
|
valid = typeof value === (expectedType = 'string');
|
|
} else if (expectedType === 'Number') {
|
|
valid = typeof value === (expectedType = 'number');
|
|
} else if (expectedType === 'Boolean') {
|
|
valid = typeof value === (expectedType = 'boolean');
|
|
} else if (expectedType === 'Function') {
|
|
valid = typeof value === (expectedType = 'function');
|
|
} else if (expectedType === 'Object') {
|
|
valid = isPlainObject(value);
|
|
} else if (expectedType === 'Array') {
|
|
valid = Array.isArray(value);
|
|
} else {
|
|
valid = value instanceof type;
|
|
}
|
|
return {
|
|
valid: valid,
|
|
expectedType: expectedType
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Use function string name to check built-in types,
|
|
* because a simple equality check will fail when running
|
|
* across different vms / iframes.
|
|
*/
|
|
function getType (fn) {
|
|
var match = fn && fn.toString().match(/^\s*function (\w+)/);
|
|
return match && match[1]
|
|
}
|
|
|
|
function isType (type, fn) {
|
|
if (!Array.isArray(fn)) {
|
|
return getType(fn) === getType(type)
|
|
}
|
|
for (var i = 0, len = fn.length; i < len; i++) {
|
|
if (getType(fn[i]) === getType(type)) {
|
|
return true
|
|
}
|
|
}
|
|
/* istanbul ignore next */
|
|
return false
|
|
}
|
|
|
|
|
|
|
|
var util = Object.freeze({
|
|
defineReactive: defineReactive$$1,
|
|
_toString: _toString,
|
|
toNumber: toNumber,
|
|
makeMap: makeMap,
|
|
isBuiltInTag: isBuiltInTag,
|
|
remove: remove$1,
|
|
hasOwn: hasOwn,
|
|
isPrimitive: isPrimitive,
|
|
cached: cached,
|
|
camelize: camelize,
|
|
capitalize: capitalize,
|
|
hyphenate: hyphenate,
|
|
bind: bind$1,
|
|
toArray: toArray,
|
|
extend: extend,
|
|
isObject: isObject,
|
|
isPlainObject: isPlainObject,
|
|
toObject: toObject,
|
|
noop: noop,
|
|
no: no,
|
|
identity: identity,
|
|
genStaticKeys: genStaticKeys,
|
|
looseEqual: looseEqual,
|
|
looseIndexOf: looseIndexOf,
|
|
isReserved: isReserved,
|
|
def: def,
|
|
parsePath: parsePath,
|
|
hasProto: hasProto,
|
|
inBrowser: inBrowser,
|
|
UA: UA,
|
|
isIE: isIE,
|
|
isIE9: isIE9,
|
|
isEdge: isEdge,
|
|
isAndroid: isAndroid,
|
|
isIOS: isIOS,
|
|
isServerRendering: isServerRendering,
|
|
devtools: devtools,
|
|
nextTick: nextTick,
|
|
get _Set () { return _Set; },
|
|
mergeOptions: mergeOptions,
|
|
resolveAsset: resolveAsset,
|
|
get warn () { return warn; },
|
|
get formatComponentName () { return formatComponentName; },
|
|
validateProp: validateProp
|
|
});
|
|
|
|
/* not type checking this file because flow doesn't play well with Proxy */
|
|
|
|
var initProxy;
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
var allowedGlobals = makeMap(
|
|
'Infinity,undefined,NaN,isFinite,isNaN,' +
|
|
'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
|
|
'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
|
|
'require' // for Webpack/Browserify
|
|
);
|
|
|
|
var warnNonPresent = function (target, key) {
|
|
warn(
|
|
"Property or method \"" + key + "\" is not defined on the instance but " +
|
|
"referenced during render. Make sure to declare reactive data " +
|
|
"properties in the data option.",
|
|
target
|
|
);
|
|
};
|
|
|
|
var hasProxy =
|
|
typeof Proxy !== 'undefined' &&
|
|
Proxy.toString().match(/native code/);
|
|
|
|
if (hasProxy) {
|
|
var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');
|
|
config.keyCodes = new Proxy(config.keyCodes, {
|
|
set: function set (target, key, value) {
|
|
if (isBuiltInModifier(key)) {
|
|
warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
|
|
return false
|
|
} else {
|
|
target[key] = value;
|
|
return true
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
var hasHandler = {
|
|
has: function has (target, key) {
|
|
var has = key in target;
|
|
var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
|
|
if (!has && !isAllowed) {
|
|
warnNonPresent(target, key);
|
|
}
|
|
return has || !isAllowed
|
|
}
|
|
};
|
|
|
|
var getHandler = {
|
|
get: function get (target, key) {
|
|
if (typeof key === 'string' && !(key in target)) {
|
|
warnNonPresent(target, key);
|
|
}
|
|
return target[key]
|
|
}
|
|
};
|
|
|
|
initProxy = function initProxy (vm) {
|
|
if (hasProxy) {
|
|
// determine which proxy handler to use
|
|
var options = vm.$options;
|
|
var handlers = options.render && options.render._withStripped
|
|
? getHandler
|
|
: hasHandler;
|
|
vm._renderProxy = new Proxy(vm, handlers);
|
|
} else {
|
|
vm._renderProxy = vm;
|
|
}
|
|
};
|
|
}
|
|
|
|
/* */
|
|
|
|
|
|
var queue = [];
|
|
var has$1 = {};
|
|
var circular = {};
|
|
var waiting = false;
|
|
var flushing = false;
|
|
var index = 0;
|
|
|
|
/**
|
|
* Reset the scheduler's state.
|
|
*/
|
|
function resetSchedulerState () {
|
|
queue.length = 0;
|
|
has$1 = {};
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
circular = {};
|
|
}
|
|
waiting = flushing = false;
|
|
}
|
|
|
|
/**
|
|
* Flush both queues and run the watchers.
|
|
*/
|
|
function flushSchedulerQueue () {
|
|
flushing = true;
|
|
|
|
// Sort queue before flush.
|
|
// This ensures that:
|
|
// 1. Components are updated from parent to child. (because parent is always
|
|
// created before the child)
|
|
// 2. A component's user watchers are run before its render watcher (because
|
|
// user watchers are created before the render watcher)
|
|
// 3. If a component is destroyed during a parent component's watcher run,
|
|
// its watchers can be skipped.
|
|
queue.sort(function (a, b) { return a.id - b.id; });
|
|
|
|
// do not cache length because more watchers might be pushed
|
|
// as we run existing watchers
|
|
for (index = 0; index < queue.length; index++) {
|
|
var watcher = queue[index];
|
|
var id = watcher.id;
|
|
has$1[id] = null;
|
|
watcher.run();
|
|
// in dev build, check and stop circular updates.
|
|
if (process.env.NODE_ENV !== 'production' && has$1[id] != null) {
|
|
circular[id] = (circular[id] || 0) + 1;
|
|
if (circular[id] > config._maxUpdateCount) {
|
|
warn(
|
|
'You may have an infinite update loop ' + (
|
|
watcher.user
|
|
? ("in watcher with expression \"" + (watcher.expression) + "\"")
|
|
: "in a component render function."
|
|
),
|
|
watcher.vm
|
|
);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// devtool hook
|
|
/* istanbul ignore if */
|
|
if (devtools && config.devtools) {
|
|
devtools.emit('flush');
|
|
}
|
|
|
|
resetSchedulerState();
|
|
}
|
|
|
|
/**
|
|
* Push a watcher into the watcher queue.
|
|
* Jobs with duplicate IDs will be skipped unless it's
|
|
* pushed when the queue is being flushed.
|
|
*/
|
|
function queueWatcher (watcher) {
|
|
var id = watcher.id;
|
|
if (has$1[id] == null) {
|
|
has$1[id] = true;
|
|
if (!flushing) {
|
|
queue.push(watcher);
|
|
} else {
|
|
// if already flushing, splice the watcher based on its id
|
|
// if already past its id, it will be run next immediately.
|
|
var i = queue.length - 1;
|
|
while (i >= 0 && queue[i].id > watcher.id) {
|
|
i--;
|
|
}
|
|
queue.splice(Math.max(i, index) + 1, 0, watcher);
|
|
}
|
|
// queue the flush
|
|
if (!waiting) {
|
|
waiting = true;
|
|
nextTick(flushSchedulerQueue);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var uid$2 = 0;
|
|
|
|
/**
|
|
* A watcher parses an expression, collects dependencies,
|
|
* and fires callback when the expression value changes.
|
|
* This is used for both the $watch() api and directives.
|
|
*/
|
|
var Watcher = function Watcher (
|
|
vm,
|
|
expOrFn,
|
|
cb,
|
|
options
|
|
) {
|
|
this.vm = vm;
|
|
vm._watchers.push(this);
|
|
// options
|
|
if (options) {
|
|
this.deep = !!options.deep;
|
|
this.user = !!options.user;
|
|
this.lazy = !!options.lazy;
|
|
this.sync = !!options.sync;
|
|
} else {
|
|
this.deep = this.user = this.lazy = this.sync = false;
|
|
}
|
|
this.cb = cb;
|
|
this.id = ++uid$2; // uid for batching
|
|
this.active = true;
|
|
this.dirty = this.lazy; // for lazy watchers
|
|
this.deps = [];
|
|
this.newDeps = [];
|
|
this.depIds = new _Set();
|
|
this.newDepIds = new _Set();
|
|
this.expression = process.env.NODE_ENV !== 'production'
|
|
? expOrFn.toString()
|
|
: '';
|
|
// parse expression for getter
|
|
if (typeof expOrFn === 'function') {
|
|
this.getter = expOrFn;
|
|
} else {
|
|
this.getter = parsePath(expOrFn);
|
|
if (!this.getter) {
|
|
this.getter = function () {};
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
"Failed watching path: \"" + expOrFn + "\" " +
|
|
'Watcher only accepts simple dot-delimited paths. ' +
|
|
'For full control, use a function instead.',
|
|
vm
|
|
);
|
|
}
|
|
}
|
|
this.value = this.lazy
|
|
? undefined
|
|
: this.get();
|
|
};
|
|
|
|
/**
|
|
* Evaluate the getter, and re-collect dependencies.
|
|
*/
|
|
Watcher.prototype.get = function get () {
|
|
pushTarget(this);
|
|
var value = this.getter.call(this.vm, this.vm);
|
|
// "touch" every property so they are all tracked as
|
|
// dependencies for deep watching
|
|
if (this.deep) {
|
|
traverse(value);
|
|
}
|
|
popTarget();
|
|
this.cleanupDeps();
|
|
return value
|
|
};
|
|
|
|
/**
|
|
* Add a dependency to this directive.
|
|
*/
|
|
Watcher.prototype.addDep = function addDep (dep) {
|
|
var id = dep.id;
|
|
if (!this.newDepIds.has(id)) {
|
|
this.newDepIds.add(id);
|
|
this.newDeps.push(dep);
|
|
if (!this.depIds.has(id)) {
|
|
dep.addSub(this);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Clean up for dependency collection.
|
|
*/
|
|
Watcher.prototype.cleanupDeps = function cleanupDeps () {
|
|
var this$1 = this;
|
|
|
|
var i = this.deps.length;
|
|
while (i--) {
|
|
var dep = this$1.deps[i];
|
|
if (!this$1.newDepIds.has(dep.id)) {
|
|
dep.removeSub(this$1);
|
|
}
|
|
}
|
|
var tmp = this.depIds;
|
|
this.depIds = this.newDepIds;
|
|
this.newDepIds = tmp;
|
|
this.newDepIds.clear();
|
|
tmp = this.deps;
|
|
this.deps = this.newDeps;
|
|
this.newDeps = tmp;
|
|
this.newDeps.length = 0;
|
|
};
|
|
|
|
/**
|
|
* Subscriber interface.
|
|
* Will be called when a dependency changes.
|
|
*/
|
|
Watcher.prototype.update = function update () {
|
|
/* istanbul ignore else */
|
|
if (this.lazy) {
|
|
this.dirty = true;
|
|
} else if (this.sync) {
|
|
this.run();
|
|
} else {
|
|
queueWatcher(this);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Scheduler job interface.
|
|
* Will be called by the scheduler.
|
|
*/
|
|
Watcher.prototype.run = function run () {
|
|
if (this.active) {
|
|
var value = this.get();
|
|
if (
|
|
value !== this.value ||
|
|
// Deep watchers and watchers on Object/Arrays should fire even
|
|
// when the value is the same, because the value may
|
|
// have mutated.
|
|
isObject(value) ||
|
|
this.deep
|
|
) {
|
|
// set new value
|
|
var oldValue = this.value;
|
|
this.value = value;
|
|
if (this.user) {
|
|
try {
|
|
this.cb.call(this.vm, value, oldValue);
|
|
} catch (e) {
|
|
/* istanbul ignore else */
|
|
if (config.errorHandler) {
|
|
config.errorHandler.call(null, e, this.vm);
|
|
} else {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
("Error in watcher \"" + (this.expression) + "\""),
|
|
this.vm
|
|
);
|
|
throw e
|
|
}
|
|
}
|
|
} else {
|
|
this.cb.call(this.vm, value, oldValue);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Evaluate the value of the watcher.
|
|
* This only gets called for lazy watchers.
|
|
*/
|
|
Watcher.prototype.evaluate = function evaluate () {
|
|
this.value = this.get();
|
|
this.dirty = false;
|
|
};
|
|
|
|
/**
|
|
* Depend on all deps collected by this watcher.
|
|
*/
|
|
Watcher.prototype.depend = function depend () {
|
|
var this$1 = this;
|
|
|
|
var i = this.deps.length;
|
|
while (i--) {
|
|
this$1.deps[i].depend();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Remove self from all dependencies' subscriber list.
|
|
*/
|
|
Watcher.prototype.teardown = function teardown () {
|
|
var this$1 = this;
|
|
|
|
if (this.active) {
|
|
// remove self from vm's watcher list
|
|
// this is a somewhat expensive operation so we skip it
|
|
// if the vm is being destroyed.
|
|
if (!this.vm._isBeingDestroyed) {
|
|
remove$1(this.vm._watchers, this);
|
|
}
|
|
var i = this.deps.length;
|
|
while (i--) {
|
|
this$1.deps[i].removeSub(this$1);
|
|
}
|
|
this.active = false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recursively traverse an object to evoke all converted
|
|
* getters, so that every nested property inside the object
|
|
* is collected as a "deep" dependency.
|
|
*/
|
|
var seenObjects = new _Set();
|
|
function traverse (val) {
|
|
seenObjects.clear();
|
|
_traverse(val, seenObjects);
|
|
}
|
|
|
|
function _traverse (val, seen) {
|
|
var i, keys;
|
|
var isA = Array.isArray(val);
|
|
if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {
|
|
return
|
|
}
|
|
if (val.__ob__) {
|
|
var depId = val.__ob__.dep.id;
|
|
if (seen.has(depId)) {
|
|
return
|
|
}
|
|
seen.add(depId);
|
|
}
|
|
if (isA) {
|
|
i = val.length;
|
|
while (i--) { _traverse(val[i], seen); }
|
|
} else {
|
|
keys = Object.keys(val);
|
|
i = keys.length;
|
|
while (i--) { _traverse(val[keys[i]], seen); }
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
function initState (vm) {
|
|
vm._watchers = [];
|
|
var opts = vm.$options;
|
|
if (opts.props) { initProps(vm, opts.props); }
|
|
if (opts.methods) { initMethods(vm, opts.methods); }
|
|
if (opts.data) {
|
|
initData(vm);
|
|
} else {
|
|
observe(vm._data = {}, true /* asRootData */);
|
|
}
|
|
if (opts.computed) { initComputed(vm, opts.computed); }
|
|
if (opts.watch) { initWatch(vm, opts.watch); }
|
|
}
|
|
|
|
var isReservedProp = { key: 1, ref: 1, slot: 1 };
|
|
|
|
function initProps (vm, props) {
|
|
var propsData = vm.$options.propsData || {};
|
|
var keys = vm.$options._propKeys = Object.keys(props);
|
|
var isRoot = !vm.$parent;
|
|
// root instance props should be converted
|
|
observerState.shouldConvert = isRoot;
|
|
var loop = function ( i ) {
|
|
var key = keys[i];
|
|
/* istanbul ignore else */
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (isReservedProp[key]) {
|
|
warn(
|
|
("\"" + key + "\" is a reserved attribute and cannot be used as component prop."),
|
|
vm
|
|
);
|
|
}
|
|
defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {
|
|
if (vm.$parent && !observerState.isSettingProps) {
|
|
warn(
|
|
"Avoid mutating a prop directly since the value will be " +
|
|
"overwritten whenever the parent component re-renders. " +
|
|
"Instead, use a data or computed property based on the prop's " +
|
|
"value. Prop being mutated: \"" + key + "\"",
|
|
vm
|
|
);
|
|
}
|
|
});
|
|
} else {
|
|
defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));
|
|
}
|
|
};
|
|
|
|
for (var i = 0; i < keys.length; i++) loop( i );
|
|
observerState.shouldConvert = true;
|
|
}
|
|
|
|
function initData (vm) {
|
|
var data = vm.$options.data;
|
|
data = vm._data = typeof data === 'function'
|
|
? data.call(vm)
|
|
: data || {};
|
|
if (!isPlainObject(data)) {
|
|
data = {};
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'data functions should return an object:\n' +
|
|
'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
|
|
vm
|
|
);
|
|
}
|
|
// proxy data on instance
|
|
var keys = Object.keys(data);
|
|
var props = vm.$options.props;
|
|
var i = keys.length;
|
|
while (i--) {
|
|
if (props && hasOwn(props, keys[i])) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
"The data property \"" + (keys[i]) + "\" is already declared as a prop. " +
|
|
"Use prop default value instead.",
|
|
vm
|
|
);
|
|
} else {
|
|
proxy(vm, keys[i]);
|
|
}
|
|
}
|
|
// observe data
|
|
observe(data, true /* asRootData */);
|
|
}
|
|
|
|
var computedSharedDefinition = {
|
|
enumerable: true,
|
|
configurable: true,
|
|
get: noop,
|
|
set: noop
|
|
};
|
|
|
|
function initComputed (vm, computed) {
|
|
for (var key in computed) {
|
|
/* istanbul ignore if */
|
|
if (process.env.NODE_ENV !== 'production' && key in vm) {
|
|
warn(
|
|
"existing instance property \"" + key + "\" will be " +
|
|
"overwritten by a computed property with the same name.",
|
|
vm
|
|
);
|
|
}
|
|
var userDef = computed[key];
|
|
if (typeof userDef === 'function') {
|
|
computedSharedDefinition.get = makeComputedGetter(userDef, vm);
|
|
computedSharedDefinition.set = noop;
|
|
} else {
|
|
computedSharedDefinition.get = userDef.get
|
|
? userDef.cache !== false
|
|
? makeComputedGetter(userDef.get, vm)
|
|
: bind$1(userDef.get, vm)
|
|
: noop;
|
|
computedSharedDefinition.set = userDef.set
|
|
? bind$1(userDef.set, vm)
|
|
: noop;
|
|
}
|
|
Object.defineProperty(vm, key, computedSharedDefinition);
|
|
}
|
|
}
|
|
|
|
function makeComputedGetter (getter, owner) {
|
|
var watcher = new Watcher(owner, getter, noop, {
|
|
lazy: true
|
|
});
|
|
return function computedGetter () {
|
|
if (watcher.dirty) {
|
|
watcher.evaluate();
|
|
}
|
|
if (Dep.target) {
|
|
watcher.depend();
|
|
}
|
|
return watcher.value
|
|
}
|
|
}
|
|
|
|
function initMethods (vm, methods) {
|
|
for (var key in methods) {
|
|
vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);
|
|
if (process.env.NODE_ENV !== 'production' && methods[key] == null) {
|
|
warn(
|
|
"method \"" + key + "\" has an undefined value in the component definition. " +
|
|
"Did you reference the function correctly?",
|
|
vm
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
function initWatch (vm, watch) {
|
|
for (var key in watch) {
|
|
var handler = watch[key];
|
|
if (Array.isArray(handler)) {
|
|
for (var i = 0; i < handler.length; i++) {
|
|
createWatcher(vm, key, handler[i]);
|
|
}
|
|
} else {
|
|
createWatcher(vm, key, handler);
|
|
}
|
|
}
|
|
}
|
|
|
|
function createWatcher (vm, key, handler) {
|
|
var options;
|
|
if (isPlainObject(handler)) {
|
|
options = handler;
|
|
handler = handler.handler;
|
|
}
|
|
if (typeof handler === 'string') {
|
|
handler = vm[handler];
|
|
}
|
|
vm.$watch(key, handler, options);
|
|
}
|
|
|
|
function stateMixin (Vue) {
|
|
// flow somehow has problems with directly declared definition object
|
|
// when using Object.defineProperty, so we have to procedurally build up
|
|
// the object here.
|
|
var dataDef = {};
|
|
dataDef.get = function () {
|
|
return this._data
|
|
};
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
dataDef.set = function (newData) {
|
|
warn(
|
|
'Avoid replacing instance root $data. ' +
|
|
'Use nested data properties instead.',
|
|
this
|
|
);
|
|
};
|
|
}
|
|
Object.defineProperty(Vue.prototype, '$data', dataDef);
|
|
|
|
Vue.prototype.$set = set$1;
|
|
Vue.prototype.$delete = del;
|
|
|
|
Vue.prototype.$watch = function (
|
|
expOrFn,
|
|
cb,
|
|
options
|
|
) {
|
|
var vm = this;
|
|
options = options || {};
|
|
options.user = true;
|
|
var watcher = new Watcher(vm, expOrFn, cb, options);
|
|
if (options.immediate) {
|
|
cb.call(vm, watcher.value);
|
|
}
|
|
return function unwatchFn () {
|
|
watcher.teardown();
|
|
}
|
|
};
|
|
}
|
|
|
|
function proxy (vm, key) {
|
|
if (!isReserved(key)) {
|
|
Object.defineProperty(vm, key, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function proxyGetter () {
|
|
return vm._data[key]
|
|
},
|
|
set: function proxySetter (val) {
|
|
vm._data[key] = val;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var VNode = function VNode (
|
|
tag,
|
|
data,
|
|
children,
|
|
text,
|
|
elm,
|
|
context,
|
|
componentOptions
|
|
) {
|
|
this.tag = tag;
|
|
this.data = data;
|
|
this.children = children;
|
|
this.text = text;
|
|
this.elm = elm;
|
|
this.ns = undefined;
|
|
this.context = context;
|
|
this.functionalContext = undefined;
|
|
this.key = data && data.key;
|
|
this.componentOptions = componentOptions;
|
|
this.child = undefined;
|
|
this.parent = undefined;
|
|
this.raw = false;
|
|
this.isStatic = false;
|
|
this.isRootInsert = true;
|
|
this.isComment = false;
|
|
this.isCloned = false;
|
|
this.isOnce = false;
|
|
};
|
|
|
|
var createEmptyVNode = function () {
|
|
var node = new VNode();
|
|
node.text = '';
|
|
node.isComment = true;
|
|
return node
|
|
};
|
|
|
|
function createTextVNode (val) {
|
|
return new VNode(undefined, undefined, undefined, String(val))
|
|
}
|
|
|
|
// optimized shallow clone
|
|
// used for static nodes and slot nodes because they may be reused across
|
|
// multiple renders, cloning them avoids errors when DOM manipulations rely
|
|
// on their elm reference.
|
|
function cloneVNode (vnode) {
|
|
var cloned = new VNode(
|
|
vnode.tag,
|
|
vnode.data,
|
|
vnode.children,
|
|
vnode.text,
|
|
vnode.elm,
|
|
vnode.context,
|
|
vnode.componentOptions
|
|
);
|
|
cloned.ns = vnode.ns;
|
|
cloned.isStatic = vnode.isStatic;
|
|
cloned.key = vnode.key;
|
|
cloned.isCloned = true;
|
|
return cloned
|
|
}
|
|
|
|
function cloneVNodes (vnodes) {
|
|
var res = new Array(vnodes.length);
|
|
for (var i = 0; i < vnodes.length; i++) {
|
|
res[i] = cloneVNode(vnodes[i]);
|
|
}
|
|
return res
|
|
}
|
|
|
|
/* */
|
|
|
|
function mergeVNodeHook (def, hookKey, hook, key) {
|
|
key = key + hookKey;
|
|
var injectedHash = def.__injected || (def.__injected = {});
|
|
if (!injectedHash[key]) {
|
|
injectedHash[key] = true;
|
|
var oldHook = def[hookKey];
|
|
if (oldHook) {
|
|
def[hookKey] = function () {
|
|
oldHook.apply(this, arguments);
|
|
hook.apply(this, arguments);
|
|
};
|
|
} else {
|
|
def[hookKey] = hook;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
function updateListeners (
|
|
on,
|
|
oldOn,
|
|
add,
|
|
remove$$1,
|
|
vm
|
|
) {
|
|
var name, cur, old, fn, event, capture, once;
|
|
for (name in on) {
|
|
cur = on[name];
|
|
old = oldOn[name];
|
|
if (!cur) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
"Invalid handler for event \"" + name + "\": got " + String(cur),
|
|
vm
|
|
);
|
|
} else if (!old) {
|
|
once = name.charAt(0) === '~'; // Prefixed last, checked first
|
|
event = once ? name.slice(1) : name;
|
|
capture = event.charAt(0) === '!';
|
|
event = capture ? event.slice(1) : event;
|
|
if (Array.isArray(cur)) {
|
|
add(event, (cur.invoker = arrInvoker(cur)), once, capture);
|
|
} else {
|
|
if (!cur.invoker) {
|
|
fn = cur;
|
|
cur = on[name] = {};
|
|
cur.fn = fn;
|
|
cur.invoker = fnInvoker(cur);
|
|
}
|
|
add(event, cur.invoker, once, capture);
|
|
}
|
|
} else if (cur !== old) {
|
|
if (Array.isArray(old)) {
|
|
old.length = cur.length;
|
|
for (var i = 0; i < old.length; i++) { old[i] = cur[i]; }
|
|
on[name] = old;
|
|
} else {
|
|
old.fn = cur;
|
|
on[name] = old;
|
|
}
|
|
}
|
|
}
|
|
for (name in oldOn) {
|
|
if (!on[name]) {
|
|
once = name.charAt(0) === '~'; // Prefixed last, checked first
|
|
event = once ? name.slice(1) : name;
|
|
capture = event.charAt(0) === '!';
|
|
event = capture ? event.slice(1) : event;
|
|
remove$$1(event, oldOn[name].invoker, capture);
|
|
}
|
|
}
|
|
}
|
|
|
|
function arrInvoker (arr) {
|
|
return function (ev) {
|
|
var arguments$1 = arguments;
|
|
|
|
var single = arguments.length === 1;
|
|
for (var i = 0; i < arr.length; i++) {
|
|
single ? arr[i](ev) : arr[i].apply(null, arguments$1);
|
|
}
|
|
}
|
|
}
|
|
|
|
function fnInvoker (o) {
|
|
return function (ev) {
|
|
var single = arguments.length === 1;
|
|
single ? o.fn(ev) : o.fn.apply(null, arguments);
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
// The template compiler attempts to minimize the need for normalization by
|
|
// statically analyzing the template at compile time.
|
|
//
|
|
// For plain HTML markup, normalization can be completely skipped because the
|
|
// generated render function is guaranteed to return Array<VNode>. There are
|
|
// two cases where extra normalization is needed:
|
|
|
|
// 1. When the children contains components - because a functional component
|
|
// may return an Array instead of a single root. In this case, just a simple
|
|
// nomralization is needed - if any child is an Array, we flatten the whole
|
|
// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
|
|
// because functional components already normalize their own children.
|
|
function simpleNormalizeChildren (children) {
|
|
for (var i = 0; i < children.length; i++) {
|
|
if (Array.isArray(children[i])) {
|
|
return Array.prototype.concat.apply([], children)
|
|
}
|
|
}
|
|
return children
|
|
}
|
|
|
|
// 2. When the children contains constrcuts that always generated nested Arrays,
|
|
// e.g. <template>, <slot>, v-for, or when the children is provided by user
|
|
// with hand-written render functions / JSX. In such cases a full normalization
|
|
// is needed to cater to all possible types of children values.
|
|
function normalizeChildren (children) {
|
|
return isPrimitive(children)
|
|
? [createTextVNode(children)]
|
|
: Array.isArray(children)
|
|
? normalizeArrayChildren(children)
|
|
: undefined
|
|
}
|
|
|
|
function normalizeArrayChildren (children, nestedIndex) {
|
|
var res = [];
|
|
var i, c, last;
|
|
for (i = 0; i < children.length; i++) {
|
|
c = children[i];
|
|
if (c == null || typeof c === 'boolean') { continue }
|
|
last = res[res.length - 1];
|
|
// nested
|
|
if (Array.isArray(c)) {
|
|
res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i)));
|
|
} else if (isPrimitive(c)) {
|
|
if (last && last.text) {
|
|
last.text += String(c);
|
|
} else if (c !== '') {
|
|
// convert primitive to vnode
|
|
res.push(createTextVNode(c));
|
|
}
|
|
} else {
|
|
if (c.text && last && last.text) {
|
|
res[res.length - 1] = createTextVNode(last.text + c.text);
|
|
} else {
|
|
// default key for nested array children (likely generated by v-for)
|
|
if (c.tag && c.key == null && nestedIndex != null) {
|
|
c.key = "__vlist" + nestedIndex + "_" + i + "__";
|
|
}
|
|
res.push(c);
|
|
}
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
/* */
|
|
|
|
function getFirstComponentChild (children) {
|
|
return children && children.filter(function (c) { return c && c.componentOptions; })[0]
|
|
}
|
|
|
|
/* */
|
|
|
|
function initEvents (vm) {
|
|
vm._events = Object.create(null);
|
|
vm._hasHookEvent = false;
|
|
// init parent attached events
|
|
var listeners = vm.$options._parentListeners;
|
|
if (listeners) {
|
|
updateComponentListeners(vm, listeners);
|
|
}
|
|
}
|
|
|
|
var target;
|
|
|
|
function add$1 (event, fn, once) {
|
|
if (once) {
|
|
target.$once(event, fn);
|
|
} else {
|
|
target.$on(event, fn);
|
|
}
|
|
}
|
|
|
|
function remove$2 (event, fn) {
|
|
target.$off(event, fn);
|
|
}
|
|
|
|
function updateComponentListeners (
|
|
vm,
|
|
listeners,
|
|
oldListeners
|
|
) {
|
|
target = vm;
|
|
updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);
|
|
}
|
|
|
|
function eventsMixin (Vue) {
|
|
var hookRE = /^hook:/;
|
|
Vue.prototype.$on = function (event, fn) {
|
|
var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);
|
|
// optimize hook:event cost by using a boolean flag marked at registration
|
|
// instead of a hash lookup
|
|
if (hookRE.test(event)) {
|
|
vm._hasHookEvent = true;
|
|
}
|
|
return vm
|
|
};
|
|
|
|
Vue.prototype.$once = function (event, fn) {
|
|
var vm = this;
|
|
function on () {
|
|
vm.$off(event, on);
|
|
fn.apply(vm, arguments);
|
|
}
|
|
on.fn = fn;
|
|
vm.$on(event, on);
|
|
return vm
|
|
};
|
|
|
|
Vue.prototype.$off = function (event, fn) {
|
|
var vm = this;
|
|
// all
|
|
if (!arguments.length) {
|
|
vm._events = Object.create(null);
|
|
return vm
|
|
}
|
|
// specific event
|
|
var cbs = vm._events[event];
|
|
if (!cbs) {
|
|
return vm
|
|
}
|
|
if (arguments.length === 1) {
|
|
vm._events[event] = null;
|
|
return vm
|
|
}
|
|
// specific handler
|
|
var cb;
|
|
var i = cbs.length;
|
|
while (i--) {
|
|
cb = cbs[i];
|
|
if (cb === fn || cb.fn === fn) {
|
|
cbs.splice(i, 1);
|
|
break
|
|
}
|
|
}
|
|
return vm
|
|
};
|
|
|
|
Vue.prototype.$emit = function (event) {
|
|
var vm = this;
|
|
var cbs = vm._events[event];
|
|
if (cbs) {
|
|
cbs = cbs.length > 1 ? toArray(cbs) : cbs;
|
|
var args = toArray(arguments, 1);
|
|
for (var i = 0, l = cbs.length; i < l; i++) {
|
|
cbs[i].apply(vm, args);
|
|
}
|
|
}
|
|
return vm
|
|
};
|
|
}
|
|
|
|
/* */
|
|
|
|
var activeInstance = null;
|
|
|
|
function initLifecycle (vm) {
|
|
var options = vm.$options;
|
|
|
|
// locate first non-abstract parent
|
|
var parent = options.parent;
|
|
if (parent && !options.abstract) {
|
|
while (parent.$options.abstract && parent.$parent) {
|
|
parent = parent.$parent;
|
|
}
|
|
parent.$children.push(vm);
|
|
}
|
|
|
|
vm.$parent = parent;
|
|
vm.$root = parent ? parent.$root : vm;
|
|
|
|
vm.$children = [];
|
|
vm.$refs = {};
|
|
|
|
vm._watcher = null;
|
|
vm._inactive = false;
|
|
vm._isMounted = false;
|
|
vm._isDestroyed = false;
|
|
vm._isBeingDestroyed = false;
|
|
}
|
|
|
|
function lifecycleMixin (Vue) {
|
|
Vue.prototype._mount = function (
|
|
el,
|
|
hydrating
|
|
) {
|
|
var vm = this;
|
|
vm.$el = el;
|
|
if (!vm.$options.render) {
|
|
vm.$options.render = createEmptyVNode;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
/* istanbul ignore if */
|
|
if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {
|
|
warn(
|
|
'You are using the runtime-only build of Vue where the template ' +
|
|
'option is not available. Either pre-compile the templates into ' +
|
|
'render functions, or use the compiler-included build.',
|
|
vm
|
|
);
|
|
} else {
|
|
warn(
|
|
'Failed to mount component: template or render function not defined.',
|
|
vm
|
|
);
|
|
}
|
|
}
|
|
}
|
|
callHook(vm, 'beforeMount');
|
|
vm._watcher = new Watcher(vm, function () {
|
|
vm._update(vm._render(), hydrating);
|
|
}, noop);
|
|
hydrating = false;
|
|
// manually mounted instance, call mounted on self
|
|
// mounted is called for render-created child components in its inserted hook
|
|
if (vm.$vnode == null) {
|
|
vm._isMounted = true;
|
|
callHook(vm, 'mounted');
|
|
}
|
|
return vm
|
|
};
|
|
|
|
Vue.prototype._update = function (vnode, hydrating) {
|
|
var vm = this;
|
|
if (vm._isMounted) {
|
|
callHook(vm, 'beforeUpdate');
|
|
}
|
|
var prevEl = vm.$el;
|
|
var prevVnode = vm._vnode;
|
|
var prevActiveInstance = activeInstance;
|
|
activeInstance = vm;
|
|
vm._vnode = vnode;
|
|
// Vue.prototype.__patch__ is injected in entry points
|
|
// based on the rendering backend used.
|
|
if (!prevVnode) {
|
|
// initial render
|
|
vm.$el = vm.__patch__(
|
|
vm.$el, vnode, hydrating, false /* removeOnly */,
|
|
vm.$options._parentElm,
|
|
vm.$options._refElm
|
|
);
|
|
} else {
|
|
// updates
|
|
vm.$el = vm.__patch__(prevVnode, vnode);
|
|
}
|
|
activeInstance = prevActiveInstance;
|
|
// update __vue__ reference
|
|
if (prevEl) {
|
|
prevEl.__vue__ = null;
|
|
}
|
|
if (vm.$el) {
|
|
vm.$el.__vue__ = vm;
|
|
}
|
|
// if parent is an HOC, update its $el as well
|
|
if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
|
|
vm.$parent.$el = vm.$el;
|
|
}
|
|
if (vm._isMounted) {
|
|
callHook(vm, 'updated');
|
|
}
|
|
};
|
|
|
|
Vue.prototype._updateFromParent = function (
|
|
propsData,
|
|
listeners,
|
|
parentVnode,
|
|
renderChildren
|
|
) {
|
|
var vm = this;
|
|
var hasChildren = !!(vm.$options._renderChildren || renderChildren);
|
|
vm.$options._parentVnode = parentVnode;
|
|
vm.$vnode = parentVnode; // update vm's placeholder node without re-render
|
|
if (vm._vnode) { // update child tree's parent
|
|
vm._vnode.parent = parentVnode;
|
|
}
|
|
vm.$options._renderChildren = renderChildren;
|
|
// update props
|
|
if (propsData && vm.$options.props) {
|
|
observerState.shouldConvert = false;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
observerState.isSettingProps = true;
|
|
}
|
|
var propKeys = vm.$options._propKeys || [];
|
|
for (var i = 0; i < propKeys.length; i++) {
|
|
var key = propKeys[i];
|
|
vm[key] = validateProp(key, vm.$options.props, propsData, vm);
|
|
}
|
|
observerState.shouldConvert = true;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
observerState.isSettingProps = false;
|
|
}
|
|
vm.$options.propsData = propsData;
|
|
}
|
|
// update listeners
|
|
if (listeners) {
|
|
var oldListeners = vm.$options._parentListeners;
|
|
vm.$options._parentListeners = listeners;
|
|
updateComponentListeners(vm, listeners, oldListeners);
|
|
}
|
|
// resolve slots + force update if has children
|
|
if (hasChildren) {
|
|
vm.$slots = resolveSlots(renderChildren, parentVnode.context);
|
|
vm.$forceUpdate();
|
|
}
|
|
};
|
|
|
|
Vue.prototype.$forceUpdate = function () {
|
|
var vm = this;
|
|
if (vm._watcher) {
|
|
vm._watcher.update();
|
|
}
|
|
};
|
|
|
|
Vue.prototype.$destroy = function () {
|
|
var vm = this;
|
|
if (vm._isBeingDestroyed) {
|
|
return
|
|
}
|
|
callHook(vm, 'beforeDestroy');
|
|
vm._isBeingDestroyed = true;
|
|
// remove self from parent
|
|
var parent = vm.$parent;
|
|
if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
|
|
remove$1(parent.$children, vm);
|
|
}
|
|
// teardown watchers
|
|
if (vm._watcher) {
|
|
vm._watcher.teardown();
|
|
}
|
|
var i = vm._watchers.length;
|
|
while (i--) {
|
|
vm._watchers[i].teardown();
|
|
}
|
|
// remove reference from data ob
|
|
// frozen object may not have observer.
|
|
if (vm._data.__ob__) {
|
|
vm._data.__ob__.vmCount--;
|
|
}
|
|
// call the last hook...
|
|
vm._isDestroyed = true;
|
|
callHook(vm, 'destroyed');
|
|
// turn off all instance listeners.
|
|
vm.$off();
|
|
// remove __vue__ reference
|
|
if (vm.$el) {
|
|
vm.$el.__vue__ = null;
|
|
}
|
|
// invoke destroy hooks on current rendered tree
|
|
vm.__patch__(vm._vnode, null);
|
|
};
|
|
}
|
|
|
|
function callHook (vm, hook) {
|
|
var handlers = vm.$options[hook];
|
|
if (handlers) {
|
|
for (var i = 0, j = handlers.length; i < j; i++) {
|
|
handlers[i].call(vm);
|
|
}
|
|
}
|
|
if (vm._hasHookEvent) {
|
|
vm.$emit('hook:' + hook);
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };
|
|
var hooksToMerge = Object.keys(hooks);
|
|
|
|
function createComponent (
|
|
Ctor,
|
|
data,
|
|
context,
|
|
children,
|
|
tag
|
|
) {
|
|
if (!Ctor) {
|
|
return
|
|
}
|
|
|
|
var baseCtor = context.$options._base;
|
|
if (isObject(Ctor)) {
|
|
Ctor = baseCtor.extend(Ctor);
|
|
}
|
|
|
|
if (typeof Ctor !== 'function') {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
warn(("Invalid Component definition: " + (String(Ctor))), context);
|
|
}
|
|
return
|
|
}
|
|
|
|
// async component
|
|
if (!Ctor.cid) {
|
|
if (Ctor.resolved) {
|
|
Ctor = Ctor.resolved;
|
|
} else {
|
|
Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {
|
|
// it's ok to queue this on every render because
|
|
// $forceUpdate is buffered by the scheduler.
|
|
context.$forceUpdate();
|
|
});
|
|
if (!Ctor) {
|
|
// return nothing if this is indeed an async component
|
|
// wait for the callback to trigger parent update.
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// resolve constructor options in case global mixins are applied after
|
|
// component constructor creation
|
|
resolveConstructorOptions(Ctor);
|
|
|
|
data = data || {};
|
|
|
|
// extract props
|
|
var propsData = extractProps(data, Ctor);
|
|
|
|
// functional component
|
|
if (Ctor.options.functional) {
|
|
return createFunctionalComponent(Ctor, propsData, data, context, children)
|
|
}
|
|
|
|
// extract listeners, since these needs to be treated as
|
|
// child component listeners instead of DOM listeners
|
|
var listeners = data.on;
|
|
// replace with listeners with .native modifier
|
|
data.on = data.nativeOn;
|
|
|
|
if (Ctor.options.abstract) {
|
|
// abstract components do not keep anything
|
|
// other than props & listeners
|
|
data = {};
|
|
}
|
|
|
|
// merge component management hooks onto the placeholder node
|
|
mergeHooks(data);
|
|
|
|
// return a placeholder vnode
|
|
var name = Ctor.options.name || tag;
|
|
var vnode = new VNode(
|
|
("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
|
|
data, undefined, undefined, undefined, context,
|
|
{ Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }
|
|
);
|
|
return vnode
|
|
}
|
|
|
|
function createFunctionalComponent (
|
|
Ctor,
|
|
propsData,
|
|
data,
|
|
context,
|
|
children
|
|
) {
|
|
var props = {};
|
|
var propOptions = Ctor.options.props;
|
|
if (propOptions) {
|
|
for (var key in propOptions) {
|
|
props[key] = validateProp(key, propOptions, propsData);
|
|
}
|
|
}
|
|
// ensure the createElement function in functional components
|
|
// gets a unique context - this is necessary for correct named slot check
|
|
var _context = Object.create(context);
|
|
var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };
|
|
var vnode = Ctor.options.render.call(null, h, {
|
|
props: props,
|
|
data: data,
|
|
parent: context,
|
|
children: children,
|
|
slots: function () { return resolveSlots(children, context); }
|
|
});
|
|
if (vnode instanceof VNode) {
|
|
vnode.functionalContext = context;
|
|
if (data.slot) {
|
|
(vnode.data || (vnode.data = {})).slot = data.slot;
|
|
}
|
|
}
|
|
return vnode
|
|
}
|
|
|
|
function createComponentInstanceForVnode (
|
|
vnode, // we know it's MountedComponentVNode but flow doesn't
|
|
parent, // activeInstance in lifecycle state
|
|
parentElm,
|
|
refElm
|
|
) {
|
|
var vnodeComponentOptions = vnode.componentOptions;
|
|
var options = {
|
|
_isComponent: true,
|
|
parent: parent,
|
|
propsData: vnodeComponentOptions.propsData,
|
|
_componentTag: vnodeComponentOptions.tag,
|
|
_parentVnode: vnode,
|
|
_parentListeners: vnodeComponentOptions.listeners,
|
|
_renderChildren: vnodeComponentOptions.children,
|
|
_parentElm: parentElm || null,
|
|
_refElm: refElm || null
|
|
};
|
|
// check inline-template render functions
|
|
var inlineTemplate = vnode.data.inlineTemplate;
|
|
if (inlineTemplate) {
|
|
options.render = inlineTemplate.render;
|
|
options.staticRenderFns = inlineTemplate.staticRenderFns;
|
|
}
|
|
return new vnodeComponentOptions.Ctor(options)
|
|
}
|
|
|
|
function init (
|
|
vnode,
|
|
hydrating,
|
|
parentElm,
|
|
refElm
|
|
) {
|
|
if (!vnode.child || vnode.child._isDestroyed) {
|
|
var child = vnode.child = createComponentInstanceForVnode(
|
|
vnode,
|
|
activeInstance,
|
|
parentElm,
|
|
refElm
|
|
);
|
|
child.$mount(hydrating ? vnode.elm : undefined, hydrating);
|
|
} else if (vnode.data.keepAlive) {
|
|
// kept-alive components, treat as a patch
|
|
var mountedNode = vnode; // work around flow
|
|
prepatch(mountedNode, mountedNode);
|
|
}
|
|
}
|
|
|
|
function prepatch (
|
|
oldVnode,
|
|
vnode
|
|
) {
|
|
var options = vnode.componentOptions;
|
|
var child = vnode.child = oldVnode.child;
|
|
child._updateFromParent(
|
|
options.propsData, // updated props
|
|
options.listeners, // updated listeners
|
|
vnode, // new parent vnode
|
|
options.children // new children
|
|
);
|
|
}
|
|
|
|
function insert (vnode) {
|
|
if (!vnode.child._isMounted) {
|
|
vnode.child._isMounted = true;
|
|
callHook(vnode.child, 'mounted');
|
|
}
|
|
if (vnode.data.keepAlive) {
|
|
vnode.child._inactive = false;
|
|
callHook(vnode.child, 'activated');
|
|
}
|
|
}
|
|
|
|
function destroy$1 (vnode) {
|
|
if (!vnode.child._isDestroyed) {
|
|
if (!vnode.data.keepAlive) {
|
|
vnode.child.$destroy();
|
|
} else {
|
|
vnode.child._inactive = true;
|
|
callHook(vnode.child, 'deactivated');
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolveAsyncComponent (
|
|
factory,
|
|
baseCtor,
|
|
cb
|
|
) {
|
|
if (factory.requested) {
|
|
// pool callbacks
|
|
factory.pendingCallbacks.push(cb);
|
|
} else {
|
|
factory.requested = true;
|
|
var cbs = factory.pendingCallbacks = [cb];
|
|
var sync = true;
|
|
|
|
var resolve = function (res) {
|
|
if (isObject(res)) {
|
|
res = baseCtor.extend(res);
|
|
}
|
|
// cache resolved
|
|
factory.resolved = res;
|
|
// invoke callbacks only if this is not a synchronous resolve
|
|
// (async resolves are shimmed as synchronous during SSR)
|
|
if (!sync) {
|
|
for (var i = 0, l = cbs.length; i < l; i++) {
|
|
cbs[i](res);
|
|
}
|
|
}
|
|
};
|
|
|
|
var reject = function (reason) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
"Failed to resolve async component: " + (String(factory)) +
|
|
(reason ? ("\nReason: " + reason) : '')
|
|
);
|
|
};
|
|
|
|
var res = factory(resolve, reject);
|
|
|
|
// handle promise
|
|
if (res && typeof res.then === 'function' && !factory.resolved) {
|
|
res.then(resolve, reject);
|
|
}
|
|
|
|
sync = false;
|
|
// return in case resolved synchronously
|
|
return factory.resolved
|
|
}
|
|
}
|
|
|
|
function extractProps (data, Ctor) {
|
|
// we are only extracting raw values here.
|
|
// validation and default values are handled in the child
|
|
// component itself.
|
|
var propOptions = Ctor.options.props;
|
|
if (!propOptions) {
|
|
return
|
|
}
|
|
var res = {};
|
|
var attrs = data.attrs;
|
|
var props = data.props;
|
|
var domProps = data.domProps;
|
|
if (attrs || props || domProps) {
|
|
for (var key in propOptions) {
|
|
var altKey = hyphenate(key);
|
|
checkProp(res, props, key, altKey, true) ||
|
|
checkProp(res, attrs, key, altKey) ||
|
|
checkProp(res, domProps, key, altKey);
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
function checkProp (
|
|
res,
|
|
hash,
|
|
key,
|
|
altKey,
|
|
preserve
|
|
) {
|
|
if (hash) {
|
|
if (hasOwn(hash, key)) {
|
|
res[key] = hash[key];
|
|
if (!preserve) {
|
|
delete hash[key];
|
|
}
|
|
return true
|
|
} else if (hasOwn(hash, altKey)) {
|
|
res[key] = hash[altKey];
|
|
if (!preserve) {
|
|
delete hash[altKey];
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
function mergeHooks (data) {
|
|
if (!data.hook) {
|
|
data.hook = {};
|
|
}
|
|
for (var i = 0; i < hooksToMerge.length; i++) {
|
|
var key = hooksToMerge[i];
|
|
var fromParent = data.hook[key];
|
|
var ours = hooks[key];
|
|
data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;
|
|
}
|
|
}
|
|
|
|
function mergeHook$1 (one, two) {
|
|
return function (a, b, c, d) {
|
|
one(a, b, c, d);
|
|
two(a, b, c, d);
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var SIMPLE_NORMALIZE = 1;
|
|
var ALWAYS_NORMALIZE = 2;
|
|
|
|
// wrapper function for providing a more flexible interface
|
|
// without getting yelled at by flow
|
|
function createElement (
|
|
context,
|
|
tag,
|
|
data,
|
|
children,
|
|
normalizationType,
|
|
alwaysNormalize
|
|
) {
|
|
if (Array.isArray(data) || isPrimitive(data)) {
|
|
normalizationType = children;
|
|
children = data;
|
|
data = undefined;
|
|
}
|
|
if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }
|
|
return _createElement(context, tag, data, children, normalizationType)
|
|
}
|
|
|
|
function _createElement (
|
|
context,
|
|
tag,
|
|
data,
|
|
children,
|
|
normalizationType
|
|
) {
|
|
if (data && data.__ob__) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
"Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
|
|
'Always create fresh vnode data objects in each render!',
|
|
context
|
|
);
|
|
return createEmptyVNode()
|
|
}
|
|
if (!tag) {
|
|
// in case of component :is set to falsy value
|
|
return createEmptyVNode()
|
|
}
|
|
// support single function children as default scoped slot
|
|
if (Array.isArray(children) &&
|
|
typeof children[0] === 'function') {
|
|
data = data || {};
|
|
data.scopedSlots = { default: children[0] };
|
|
children.length = 0;
|
|
}
|
|
if (normalizationType === ALWAYS_NORMALIZE) {
|
|
children = normalizeChildren(children);
|
|
} else if (normalizationType === SIMPLE_NORMALIZE) {
|
|
children = simpleNormalizeChildren(children);
|
|
}
|
|
var vnode, ns;
|
|
if (typeof tag === 'string') {
|
|
var Ctor;
|
|
ns = config.getTagNamespace(tag);
|
|
if (config.isReservedTag(tag)) {
|
|
// platform built-in elements
|
|
vnode = new VNode(
|
|
config.parsePlatformTagName(tag), data, children,
|
|
undefined, undefined, context
|
|
);
|
|
} else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {
|
|
// component
|
|
vnode = createComponent(Ctor, data, context, children, tag);
|
|
} else {
|
|
// unknown or unlisted namespaced elements
|
|
// check at runtime because it may get assigned a namespace when its
|
|
// parent normalizes children
|
|
vnode = new VNode(
|
|
tag, data, children,
|
|
undefined, undefined, context
|
|
);
|
|
}
|
|
} else {
|
|
// direct component options / constructor
|
|
vnode = createComponent(tag, data, context, children);
|
|
}
|
|
if (vnode) {
|
|
if (ns) { applyNS(vnode, ns); }
|
|
return vnode
|
|
} else {
|
|
return createEmptyVNode()
|
|
}
|
|
}
|
|
|
|
function applyNS (vnode, ns) {
|
|
vnode.ns = ns;
|
|
if (vnode.tag === 'foreignObject') {
|
|
// use default namespace inside foreignObject
|
|
return
|
|
}
|
|
if (vnode.children) {
|
|
for (var i = 0, l = vnode.children.length; i < l; i++) {
|
|
var child = vnode.children[i];
|
|
if (child.tag && !child.ns) {
|
|
applyNS(child, ns);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
function initRender (vm) {
|
|
vm.$vnode = null; // the placeholder node in parent tree
|
|
vm._vnode = null; // the root of the child tree
|
|
vm._staticTrees = null;
|
|
var parentVnode = vm.$options._parentVnode;
|
|
var renderContext = parentVnode && parentVnode.context;
|
|
vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);
|
|
vm.$scopedSlots = {};
|
|
// bind the createElement fn to this instance
|
|
// so that we get proper render context inside it.
|
|
// args order: tag, data, children, normalizationType, alwaysNormalize
|
|
// internal version is used by render functions compiled from templates
|
|
vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
|
|
// normalization is always applied for the public version, used in
|
|
// user-written render functions.
|
|
vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
|
|
if (vm.$options.el) {
|
|
vm.$mount(vm.$options.el);
|
|
}
|
|
}
|
|
|
|
function renderMixin (Vue) {
|
|
Vue.prototype.$nextTick = function (fn) {
|
|
return nextTick(fn, this)
|
|
};
|
|
|
|
Vue.prototype._render = function () {
|
|
var vm = this;
|
|
var ref = vm.$options;
|
|
var render = ref.render;
|
|
var staticRenderFns = ref.staticRenderFns;
|
|
var _parentVnode = ref._parentVnode;
|
|
|
|
if (vm._isMounted) {
|
|
// clone slot nodes on re-renders
|
|
for (var key in vm.$slots) {
|
|
vm.$slots[key] = cloneVNodes(vm.$slots[key]);
|
|
}
|
|
}
|
|
|
|
if (_parentVnode && _parentVnode.data.scopedSlots) {
|
|
vm.$scopedSlots = _parentVnode.data.scopedSlots;
|
|
}
|
|
|
|
if (staticRenderFns && !vm._staticTrees) {
|
|
vm._staticTrees = [];
|
|
}
|
|
// set parent vnode. this allows render functions to have access
|
|
// to the data on the placeholder node.
|
|
vm.$vnode = _parentVnode;
|
|
// render self
|
|
var vnode;
|
|
try {
|
|
vnode = render.call(vm._renderProxy, vm.$createElement);
|
|
} catch (e) {
|
|
/* istanbul ignore else */
|
|
if (config.errorHandler) {
|
|
config.errorHandler.call(null, e, vm);
|
|
} else {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
warn(("Error when rendering " + (formatComponentName(vm)) + ":"));
|
|
}
|
|
throw e
|
|
}
|
|
// return previous vnode to prevent render error causing blank component
|
|
vnode = vm._vnode;
|
|
}
|
|
// return empty vnode in case the render function errored out
|
|
if (!(vnode instanceof VNode)) {
|
|
if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
|
|
warn(
|
|
'Multiple root nodes returned from render function. Render function ' +
|
|
'should return a single root node.',
|
|
vm
|
|
);
|
|
}
|
|
vnode = createEmptyVNode();
|
|
}
|
|
// set parent
|
|
vnode.parent = _parentVnode;
|
|
return vnode
|
|
};
|
|
|
|
// toString for mustaches
|
|
Vue.prototype._s = _toString;
|
|
// convert text to vnode
|
|
Vue.prototype._v = createTextVNode;
|
|
// number conversion
|
|
Vue.prototype._n = toNumber;
|
|
// empty vnode
|
|
Vue.prototype._e = createEmptyVNode;
|
|
// loose equal
|
|
Vue.prototype._q = looseEqual;
|
|
// loose indexOf
|
|
Vue.prototype._i = looseIndexOf;
|
|
|
|
// render static tree by index
|
|
Vue.prototype._m = function renderStatic (
|
|
index,
|
|
isInFor
|
|
) {
|
|
var tree = this._staticTrees[index];
|
|
// if has already-rendered static tree and not inside v-for,
|
|
// we can reuse the same tree by doing a shallow clone.
|
|
if (tree && !isInFor) {
|
|
return Array.isArray(tree)
|
|
? cloneVNodes(tree)
|
|
: cloneVNode(tree)
|
|
}
|
|
// otherwise, render a fresh tree.
|
|
tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);
|
|
markStatic(tree, ("__static__" + index), false);
|
|
return tree
|
|
};
|
|
|
|
// mark node as static (v-once)
|
|
Vue.prototype._o = function markOnce (
|
|
tree,
|
|
index,
|
|
key
|
|
) {
|
|
markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
|
|
return tree
|
|
};
|
|
|
|
function markStatic (tree, key, isOnce) {
|
|
if (Array.isArray(tree)) {
|
|
for (var i = 0; i < tree.length; i++) {
|
|
if (tree[i] && typeof tree[i] !== 'string') {
|
|
markStaticNode(tree[i], (key + "_" + i), isOnce);
|
|
}
|
|
}
|
|
} else {
|
|
markStaticNode(tree, key, isOnce);
|
|
}
|
|
}
|
|
|
|
function markStaticNode (node, key, isOnce) {
|
|
node.isStatic = true;
|
|
node.key = key;
|
|
node.isOnce = isOnce;
|
|
}
|
|
|
|
// filter resolution helper
|
|
Vue.prototype._f = function resolveFilter (id) {
|
|
return resolveAsset(this.$options, 'filters', id, true) || identity
|
|
};
|
|
|
|
// render v-for
|
|
Vue.prototype._l = function renderList (
|
|
val,
|
|
render
|
|
) {
|
|
var ret, i, l, keys, key;
|
|
if (Array.isArray(val) || typeof val === 'string') {
|
|
ret = new Array(val.length);
|
|
for (i = 0, l = val.length; i < l; i++) {
|
|
ret[i] = render(val[i], i);
|
|
}
|
|
} else if (typeof val === 'number') {
|
|
ret = new Array(val);
|
|
for (i = 0; i < val; i++) {
|
|
ret[i] = render(i + 1, i);
|
|
}
|
|
} else if (isObject(val)) {
|
|
keys = Object.keys(val);
|
|
ret = new Array(keys.length);
|
|
for (i = 0, l = keys.length; i < l; i++) {
|
|
key = keys[i];
|
|
ret[i] = render(val[key], key, i);
|
|
}
|
|
}
|
|
return ret
|
|
};
|
|
|
|
// renderSlot
|
|
Vue.prototype._t = function (
|
|
name,
|
|
fallback,
|
|
props,
|
|
bindObject
|
|
) {
|
|
var scopedSlotFn = this.$scopedSlots[name];
|
|
if (scopedSlotFn) { // scoped slot
|
|
props = props || {};
|
|
if (bindObject) {
|
|
extend(props, bindObject);
|
|
}
|
|
return scopedSlotFn(props) || fallback
|
|
} else {
|
|
var slotNodes = this.$slots[name];
|
|
// warn duplicate slot usage
|
|
if (slotNodes && process.env.NODE_ENV !== 'production') {
|
|
slotNodes._rendered && warn(
|
|
"Duplicate presence of slot \"" + name + "\" found in the same render tree " +
|
|
"- this will likely cause render errors.",
|
|
this
|
|
);
|
|
slotNodes._rendered = true;
|
|
}
|
|
return slotNodes || fallback
|
|
}
|
|
};
|
|
|
|
// apply v-bind object
|
|
Vue.prototype._b = function bindProps (
|
|
data,
|
|
tag,
|
|
value,
|
|
asProp
|
|
) {
|
|
if (value) {
|
|
if (!isObject(value)) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'v-bind without argument expects an Object or Array value',
|
|
this
|
|
);
|
|
} else {
|
|
if (Array.isArray(value)) {
|
|
value = toObject(value);
|
|
}
|
|
for (var key in value) {
|
|
if (key === 'class' || key === 'style') {
|
|
data[key] = value[key];
|
|
} else {
|
|
var hash = asProp || config.mustUseProp(tag, key)
|
|
? data.domProps || (data.domProps = {})
|
|
: data.attrs || (data.attrs = {});
|
|
hash[key] = value[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return data
|
|
};
|
|
|
|
// check v-on keyCodes
|
|
Vue.prototype._k = function checkKeyCodes (
|
|
eventKeyCode,
|
|
key,
|
|
builtInAlias
|
|
) {
|
|
var keyCodes = config.keyCodes[key] || builtInAlias;
|
|
if (Array.isArray(keyCodes)) {
|
|
return keyCodes.indexOf(eventKeyCode) === -1
|
|
} else {
|
|
return keyCodes !== eventKeyCode
|
|
}
|
|
};
|
|
}
|
|
|
|
function resolveSlots (
|
|
children,
|
|
context
|
|
) {
|
|
var slots = {};
|
|
if (!children) {
|
|
return slots
|
|
}
|
|
var defaultSlot = [];
|
|
var name, child;
|
|
for (var i = 0, l = children.length; i < l; i++) {
|
|
child = children[i];
|
|
// named slots should only be respected if the vnode was rendered in the
|
|
// same context.
|
|
if ((child.context === context || child.functionalContext === context) &&
|
|
child.data && (name = child.data.slot)) {
|
|
var slot = (slots[name] || (slots[name] = []));
|
|
if (child.tag === 'template') {
|
|
slot.push.apply(slot, child.children);
|
|
} else {
|
|
slot.push(child);
|
|
}
|
|
} else {
|
|
defaultSlot.push(child);
|
|
}
|
|
}
|
|
// ignore single whitespace
|
|
if (defaultSlot.length && !(
|
|
defaultSlot.length === 1 &&
|
|
(defaultSlot[0].text === ' ' || defaultSlot[0].isComment)
|
|
)) {
|
|
slots.default = defaultSlot;
|
|
}
|
|
return slots
|
|
}
|
|
|
|
/* */
|
|
|
|
var uid = 0;
|
|
|
|
function initMixin (Vue) {
|
|
Vue.prototype._init = function (options) {
|
|
var vm = this;
|
|
// a uid
|
|
vm._uid = uid++;
|
|
// a flag to avoid this being observed
|
|
vm._isVue = true;
|
|
// merge options
|
|
if (options && options._isComponent) {
|
|
// optimize internal component instantiation
|
|
// since dynamic options merging is pretty slow, and none of the
|
|
// internal component options needs special treatment.
|
|
initInternalComponent(vm, options);
|
|
} else {
|
|
vm.$options = mergeOptions(
|
|
resolveConstructorOptions(vm.constructor),
|
|
options || {},
|
|
vm
|
|
);
|
|
}
|
|
/* istanbul ignore else */
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
initProxy(vm);
|
|
} else {
|
|
vm._renderProxy = vm;
|
|
}
|
|
// expose real self
|
|
vm._self = vm;
|
|
initLifecycle(vm);
|
|
initEvents(vm);
|
|
callHook(vm, 'beforeCreate');
|
|
initState(vm);
|
|
callHook(vm, 'created');
|
|
initRender(vm);
|
|
};
|
|
}
|
|
|
|
function initInternalComponent (vm, options) {
|
|
var opts = vm.$options = Object.create(vm.constructor.options);
|
|
// doing this because it's faster than dynamic enumeration.
|
|
opts.parent = options.parent;
|
|
opts.propsData = options.propsData;
|
|
opts._parentVnode = options._parentVnode;
|
|
opts._parentListeners = options._parentListeners;
|
|
opts._renderChildren = options._renderChildren;
|
|
opts._componentTag = options._componentTag;
|
|
opts._parentElm = options._parentElm;
|
|
opts._refElm = options._refElm;
|
|
if (options.render) {
|
|
opts.render = options.render;
|
|
opts.staticRenderFns = options.staticRenderFns;
|
|
}
|
|
}
|
|
|
|
function resolveConstructorOptions (Ctor) {
|
|
var options = Ctor.options;
|
|
if (Ctor.super) {
|
|
var superOptions = Ctor.super.options;
|
|
var cachedSuperOptions = Ctor.superOptions;
|
|
var extendOptions = Ctor.extendOptions;
|
|
if (superOptions !== cachedSuperOptions) {
|
|
// super option changed
|
|
Ctor.superOptions = superOptions;
|
|
extendOptions.render = options.render;
|
|
extendOptions.staticRenderFns = options.staticRenderFns;
|
|
extendOptions._scopeId = options._scopeId;
|
|
options = Ctor.options = mergeOptions(superOptions, extendOptions);
|
|
if (options.name) {
|
|
options.components[options.name] = Ctor;
|
|
}
|
|
}
|
|
}
|
|
return options
|
|
}
|
|
|
|
function Vue$2 (options) {
|
|
if (process.env.NODE_ENV !== 'production' &&
|
|
!(this instanceof Vue$2)) {
|
|
warn('Vue is a constructor and should be called with the `new` keyword');
|
|
}
|
|
this._init(options);
|
|
}
|
|
|
|
initMixin(Vue$2);
|
|
stateMixin(Vue$2);
|
|
eventsMixin(Vue$2);
|
|
lifecycleMixin(Vue$2);
|
|
renderMixin(Vue$2);
|
|
|
|
/* */
|
|
|
|
function initUse (Vue) {
|
|
Vue.use = function (plugin) {
|
|
/* istanbul ignore if */
|
|
if (plugin.installed) {
|
|
return
|
|
}
|
|
// additional parameters
|
|
var args = toArray(arguments, 1);
|
|
args.unshift(this);
|
|
if (typeof plugin.install === 'function') {
|
|
plugin.install.apply(plugin, args);
|
|
} else {
|
|
plugin.apply(null, args);
|
|
}
|
|
plugin.installed = true;
|
|
return this
|
|
};
|
|
}
|
|
|
|
/* */
|
|
|
|
function initMixin$1 (Vue) {
|
|
Vue.mixin = function (mixin) {
|
|
this.options = mergeOptions(this.options, mixin);
|
|
};
|
|
}
|
|
|
|
/* */
|
|
|
|
function initExtend (Vue) {
|
|
/**
|
|
* Each instance constructor, including Vue, has a unique
|
|
* cid. This enables us to create wrapped "child
|
|
* constructors" for prototypal inheritance and cache them.
|
|
*/
|
|
Vue.cid = 0;
|
|
var cid = 1;
|
|
|
|
/**
|
|
* Class inheritance
|
|
*/
|
|
Vue.extend = function (extendOptions) {
|
|
extendOptions = extendOptions || {};
|
|
var Super = this;
|
|
var SuperId = Super.cid;
|
|
var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
|
|
if (cachedCtors[SuperId]) {
|
|
return cachedCtors[SuperId]
|
|
}
|
|
var name = extendOptions.name || Super.options.name;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (!/^[a-zA-Z][\w-]*$/.test(name)) {
|
|
warn(
|
|
'Invalid component name: "' + name + '". Component names ' +
|
|
'can only contain alphanumeric characters and the hyphen, ' +
|
|
'and must start with a letter.'
|
|
);
|
|
}
|
|
}
|
|
var Sub = function VueComponent (options) {
|
|
this._init(options);
|
|
};
|
|
Sub.prototype = Object.create(Super.prototype);
|
|
Sub.prototype.constructor = Sub;
|
|
Sub.cid = cid++;
|
|
Sub.options = mergeOptions(
|
|
Super.options,
|
|
extendOptions
|
|
);
|
|
Sub['super'] = Super;
|
|
// allow further extension/mixin/plugin usage
|
|
Sub.extend = Super.extend;
|
|
Sub.mixin = Super.mixin;
|
|
Sub.use = Super.use;
|
|
// create asset registers, so extended classes
|
|
// can have their private assets too.
|
|
config._assetTypes.forEach(function (type) {
|
|
Sub[type] = Super[type];
|
|
});
|
|
// enable recursive self-lookup
|
|
if (name) {
|
|
Sub.options.components[name] = Sub;
|
|
}
|
|
// keep a reference to the super options at extension time.
|
|
// later at instantiation we can check if Super's options have
|
|
// been updated.
|
|
Sub.superOptions = Super.options;
|
|
Sub.extendOptions = extendOptions;
|
|
// cache constructor
|
|
cachedCtors[SuperId] = Sub;
|
|
return Sub
|
|
};
|
|
}
|
|
|
|
/* */
|
|
|
|
function initAssetRegisters (Vue) {
|
|
/**
|
|
* Create asset registration methods.
|
|
*/
|
|
config._assetTypes.forEach(function (type) {
|
|
Vue[type] = function (
|
|
id,
|
|
definition
|
|
) {
|
|
if (!definition) {
|
|
return this.options[type + 's'][id]
|
|
} else {
|
|
/* istanbul ignore if */
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (type === 'component' && config.isReservedTag(id)) {
|
|
warn(
|
|
'Do not use built-in or reserved HTML elements as component ' +
|
|
'id: ' + id
|
|
);
|
|
}
|
|
}
|
|
if (type === 'component' && isPlainObject(definition)) {
|
|
definition.name = definition.name || id;
|
|
definition = this.options._base.extend(definition);
|
|
}
|
|
if (type === 'directive' && typeof definition === 'function') {
|
|
definition = { bind: definition, update: definition };
|
|
}
|
|
this.options[type + 's'][id] = definition;
|
|
return definition
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
/* */
|
|
|
|
var patternTypes = [String, RegExp];
|
|
|
|
function matches (pattern, name) {
|
|
if (typeof pattern === 'string') {
|
|
return pattern.split(',').indexOf(name) > -1
|
|
} else {
|
|
return pattern.test(name)
|
|
}
|
|
}
|
|
|
|
var KeepAlive = {
|
|
name: 'keep-alive',
|
|
abstract: true,
|
|
props: {
|
|
include: patternTypes,
|
|
exclude: patternTypes
|
|
},
|
|
created: function created () {
|
|
this.cache = Object.create(null);
|
|
},
|
|
render: function render () {
|
|
var vnode = getFirstComponentChild(this.$slots.default);
|
|
if (vnode && vnode.componentOptions) {
|
|
var opts = vnode.componentOptions;
|
|
// check pattern
|
|
var name = opts.Ctor.options.name || opts.tag;
|
|
if (name && (
|
|
(this.include && !matches(this.include, name)) ||
|
|
(this.exclude && matches(this.exclude, name))
|
|
)) {
|
|
return vnode
|
|
}
|
|
var key = vnode.key == null
|
|
// same constructor may get registered as different local components
|
|
// so cid alone is not enough (#3269)
|
|
? opts.Ctor.cid + (opts.tag ? ("::" + (opts.tag)) : '')
|
|
: vnode.key;
|
|
if (this.cache[key]) {
|
|
vnode.child = this.cache[key].child;
|
|
} else {
|
|
this.cache[key] = vnode;
|
|
}
|
|
vnode.data.keepAlive = true;
|
|
}
|
|
return vnode
|
|
},
|
|
destroyed: function destroyed () {
|
|
var this$1 = this;
|
|
|
|
for (var key in this.cache) {
|
|
var vnode = this$1.cache[key];
|
|
callHook(vnode.child, 'deactivated');
|
|
vnode.child.$destroy();
|
|
}
|
|
}
|
|
};
|
|
|
|
var builtInComponents = {
|
|
KeepAlive: KeepAlive
|
|
};
|
|
|
|
/* */
|
|
|
|
function initGlobalAPI (Vue) {
|
|
// config
|
|
var configDef = {};
|
|
configDef.get = function () { return config; };
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
configDef.set = function () {
|
|
warn(
|
|
'Do not replace the Vue.config object, set individual fields instead.'
|
|
);
|
|
};
|
|
}
|
|
Object.defineProperty(Vue, 'config', configDef);
|
|
Vue.util = util;
|
|
Vue.set = set$1;
|
|
Vue.delete = del;
|
|
Vue.nextTick = nextTick;
|
|
|
|
Vue.options = Object.create(null);
|
|
config._assetTypes.forEach(function (type) {
|
|
Vue.options[type + 's'] = Object.create(null);
|
|
});
|
|
|
|
// this is used to identify the "base" constructor to extend all plain-object
|
|
// components with in Weex's multi-instance scenarios.
|
|
Vue.options._base = Vue;
|
|
|
|
extend(Vue.options.components, builtInComponents);
|
|
|
|
initUse(Vue);
|
|
initMixin$1(Vue);
|
|
initExtend(Vue);
|
|
initAssetRegisters(Vue);
|
|
}
|
|
|
|
initGlobalAPI(Vue$2);
|
|
|
|
Object.defineProperty(Vue$2.prototype, '$isServer', {
|
|
get: isServerRendering
|
|
});
|
|
|
|
Vue$2.version = '2.1.8';
|
|
|
|
/* */
|
|
|
|
// attributes that should be using props for binding
|
|
var acceptValue = makeMap('input,textarea,option,select');
|
|
var mustUseProp = function (tag, attr) {
|
|
return (
|
|
(attr === 'value' && acceptValue(tag)) ||
|
|
(attr === 'selected' && tag === 'option') ||
|
|
(attr === 'checked' && tag === 'input') ||
|
|
(attr === 'muted' && tag === 'video')
|
|
)
|
|
};
|
|
|
|
var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
|
|
|
|
var isBooleanAttr = makeMap(
|
|
'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
|
|
'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
|
|
'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
|
|
'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
|
|
'required,reversed,scoped,seamless,selected,sortable,translate,' +
|
|
'truespeed,typemustmatch,visible'
|
|
);
|
|
|
|
var xlinkNS = 'http://www.w3.org/1999/xlink';
|
|
|
|
var isXlink = function (name) {
|
|
return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
|
|
};
|
|
|
|
var getXlinkProp = function (name) {
|
|
return isXlink(name) ? name.slice(6, name.length) : ''
|
|
};
|
|
|
|
var isFalsyAttrValue = function (val) {
|
|
return val == null || val === false
|
|
};
|
|
|
|
/* */
|
|
|
|
function genClassForVnode (vnode) {
|
|
var data = vnode.data;
|
|
var parentNode = vnode;
|
|
var childNode = vnode;
|
|
while (childNode.child) {
|
|
childNode = childNode.child._vnode;
|
|
if (childNode.data) {
|
|
data = mergeClassData(childNode.data, data);
|
|
}
|
|
}
|
|
while ((parentNode = parentNode.parent)) {
|
|
if (parentNode.data) {
|
|
data = mergeClassData(data, parentNode.data);
|
|
}
|
|
}
|
|
return genClassFromData(data)
|
|
}
|
|
|
|
function mergeClassData (child, parent) {
|
|
return {
|
|
staticClass: concat(child.staticClass, parent.staticClass),
|
|
class: child.class
|
|
? [child.class, parent.class]
|
|
: parent.class
|
|
}
|
|
}
|
|
|
|
function genClassFromData (data) {
|
|
var dynamicClass = data.class;
|
|
var staticClass = data.staticClass;
|
|
if (staticClass || dynamicClass) {
|
|
return concat(staticClass, stringifyClass(dynamicClass))
|
|
}
|
|
/* istanbul ignore next */
|
|
return ''
|
|
}
|
|
|
|
function concat (a, b) {
|
|
return a ? b ? (a + ' ' + b) : a : (b || '')
|
|
}
|
|
|
|
function stringifyClass (value) {
|
|
var res = '';
|
|
if (!value) {
|
|
return res
|
|
}
|
|
if (typeof value === 'string') {
|
|
return value
|
|
}
|
|
if (Array.isArray(value)) {
|
|
var stringified;
|
|
for (var i = 0, l = value.length; i < l; i++) {
|
|
if (value[i]) {
|
|
if ((stringified = stringifyClass(value[i]))) {
|
|
res += stringified + ' ';
|
|
}
|
|
}
|
|
}
|
|
return res.slice(0, -1)
|
|
}
|
|
if (isObject(value)) {
|
|
for (var key in value) {
|
|
if (value[key]) { res += key + ' '; }
|
|
}
|
|
return res.slice(0, -1)
|
|
}
|
|
/* istanbul ignore next */
|
|
return res
|
|
}
|
|
|
|
/* */
|
|
|
|
var namespaceMap = {
|
|
svg: 'http://www.w3.org/2000/svg',
|
|
math: 'http://www.w3.org/1998/Math/MathML'
|
|
};
|
|
|
|
var isHTMLTag = makeMap(
|
|
'html,body,base,head,link,meta,style,title,' +
|
|
'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
|
|
'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +
|
|
'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
|
|
's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
|
|
'embed,object,param,source,canvas,script,noscript,del,ins,' +
|
|
'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
|
|
'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
|
|
'output,progress,select,textarea,' +
|
|
'details,dialog,menu,menuitem,summary,' +
|
|
'content,element,shadow,template'
|
|
);
|
|
|
|
// this map is intentionally selective, only covering SVG elements that may
|
|
// contain child elements.
|
|
var isSVG = makeMap(
|
|
'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +
|
|
'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
|
|
'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
|
|
true
|
|
);
|
|
|
|
|
|
|
|
var isReservedTag = function (tag) {
|
|
return isHTMLTag(tag) || isSVG(tag)
|
|
};
|
|
|
|
function getTagNamespace (tag) {
|
|
if (isSVG(tag)) {
|
|
return 'svg'
|
|
}
|
|
// basic support for MathML
|
|
// note it doesn't support other MathML elements being component roots
|
|
if (tag === 'math') {
|
|
return 'math'
|
|
}
|
|
}
|
|
|
|
var unknownElementCache = Object.create(null);
|
|
function isUnknownElement (tag) {
|
|
/* istanbul ignore if */
|
|
if (!inBrowser) {
|
|
return true
|
|
}
|
|
if (isReservedTag(tag)) {
|
|
return false
|
|
}
|
|
tag = tag.toLowerCase();
|
|
/* istanbul ignore if */
|
|
if (unknownElementCache[tag] != null) {
|
|
return unknownElementCache[tag]
|
|
}
|
|
var el = document.createElement(tag);
|
|
if (tag.indexOf('-') > -1) {
|
|
// http://stackoverflow.com/a/28210364/1070244
|
|
return (unknownElementCache[tag] = (
|
|
el.constructor === window.HTMLUnknownElement ||
|
|
el.constructor === window.HTMLElement
|
|
))
|
|
} else {
|
|
return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
/**
|
|
* Query an element selector if it's not an element already.
|
|
*/
|
|
function query (el) {
|
|
if (typeof el === 'string') {
|
|
var selector = el;
|
|
el = document.querySelector(el);
|
|
if (!el) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
'Cannot find element: ' + selector
|
|
);
|
|
return document.createElement('div')
|
|
}
|
|
}
|
|
return el
|
|
}
|
|
|
|
/* */
|
|
|
|
function createElement$1 (tagName, vnode) {
|
|
var elm = document.createElement(tagName);
|
|
if (tagName !== 'select') {
|
|
return elm
|
|
}
|
|
if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {
|
|
elm.setAttribute('multiple', 'multiple');
|
|
}
|
|
return elm
|
|
}
|
|
|
|
function createElementNS (namespace, tagName) {
|
|
return document.createElementNS(namespaceMap[namespace], tagName)
|
|
}
|
|
|
|
function createTextNode (text) {
|
|
return document.createTextNode(text)
|
|
}
|
|
|
|
function createComment (text) {
|
|
return document.createComment(text)
|
|
}
|
|
|
|
function insertBefore (parentNode, newNode, referenceNode) {
|
|
parentNode.insertBefore(newNode, referenceNode);
|
|
}
|
|
|
|
function removeChild (node, child) {
|
|
node.removeChild(child);
|
|
}
|
|
|
|
function appendChild (node, child) {
|
|
node.appendChild(child);
|
|
}
|
|
|
|
function parentNode (node) {
|
|
return node.parentNode
|
|
}
|
|
|
|
function nextSibling (node) {
|
|
return node.nextSibling
|
|
}
|
|
|
|
function tagName (node) {
|
|
return node.tagName
|
|
}
|
|
|
|
function setTextContent (node, text) {
|
|
node.textContent = text;
|
|
}
|
|
|
|
function setAttribute (node, key, val) {
|
|
node.setAttribute(key, val);
|
|
}
|
|
|
|
|
|
var nodeOps = Object.freeze({
|
|
createElement: createElement$1,
|
|
createElementNS: createElementNS,
|
|
createTextNode: createTextNode,
|
|
createComment: createComment,
|
|
insertBefore: insertBefore,
|
|
removeChild: removeChild,
|
|
appendChild: appendChild,
|
|
parentNode: parentNode,
|
|
nextSibling: nextSibling,
|
|
tagName: tagName,
|
|
setTextContent: setTextContent,
|
|
setAttribute: setAttribute
|
|
});
|
|
|
|
/* */
|
|
|
|
var ref = {
|
|
create: function create (_, vnode) {
|
|
registerRef(vnode);
|
|
},
|
|
update: function update (oldVnode, vnode) {
|
|
if (oldVnode.data.ref !== vnode.data.ref) {
|
|
registerRef(oldVnode, true);
|
|
registerRef(vnode);
|
|
}
|
|
},
|
|
destroy: function destroy (vnode) {
|
|
registerRef(vnode, true);
|
|
}
|
|
};
|
|
|
|
function registerRef (vnode, isRemoval) {
|
|
var key = vnode.data.ref;
|
|
if (!key) { return }
|
|
|
|
var vm = vnode.context;
|
|
var ref = vnode.child || vnode.elm;
|
|
var refs = vm.$refs;
|
|
if (isRemoval) {
|
|
if (Array.isArray(refs[key])) {
|
|
remove$1(refs[key], ref);
|
|
} else if (refs[key] === ref) {
|
|
refs[key] = undefined;
|
|
}
|
|
} else {
|
|
if (vnode.data.refInFor) {
|
|
if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {
|
|
refs[key].push(ref);
|
|
} else {
|
|
refs[key] = [ref];
|
|
}
|
|
} else {
|
|
refs[key] = ref;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Virtual DOM patching algorithm based on Snabbdom by
|
|
* Simon Friis Vindum (@paldepind)
|
|
* Licensed under the MIT License
|
|
* https://github.com/paldepind/snabbdom/blob/master/LICENSE
|
|
*
|
|
* modified by Evan You (@yyx990803)
|
|
*
|
|
|
|
/*
|
|
* Not type-checking this because this file is perf-critical and the cost
|
|
* of making flow understand it is not worth it.
|
|
*/
|
|
|
|
var emptyNode = new VNode('', {}, []);
|
|
|
|
var hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];
|
|
|
|
function isUndef (s) {
|
|
return s == null
|
|
}
|
|
|
|
function isDef (s) {
|
|
return s != null
|
|
}
|
|
|
|
function sameVnode (vnode1, vnode2) {
|
|
return (
|
|
vnode1.key === vnode2.key &&
|
|
vnode1.tag === vnode2.tag &&
|
|
vnode1.isComment === vnode2.isComment &&
|
|
!vnode1.data === !vnode2.data
|
|
)
|
|
}
|
|
|
|
function createKeyToOldIdx (children, beginIdx, endIdx) {
|
|
var i, key;
|
|
var map = {};
|
|
for (i = beginIdx; i <= endIdx; ++i) {
|
|
key = children[i].key;
|
|
if (isDef(key)) { map[key] = i; }
|
|
}
|
|
return map
|
|
}
|
|
|
|
function createPatchFunction (backend) {
|
|
var i, j;
|
|
var cbs = {};
|
|
|
|
var modules = backend.modules;
|
|
var nodeOps = backend.nodeOps;
|
|
|
|
for (i = 0; i < hooks$1.length; ++i) {
|
|
cbs[hooks$1[i]] = [];
|
|
for (j = 0; j < modules.length; ++j) {
|
|
if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }
|
|
}
|
|
}
|
|
|
|
function emptyNodeAt (elm) {
|
|
return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
|
|
}
|
|
|
|
function createRmCb (childElm, listeners) {
|
|
function remove$$1 () {
|
|
if (--remove$$1.listeners === 0) {
|
|
removeNode(childElm);
|
|
}
|
|
}
|
|
remove$$1.listeners = listeners;
|
|
return remove$$1
|
|
}
|
|
|
|
function removeNode (el) {
|
|
var parent = nodeOps.parentNode(el);
|
|
// element may have already been removed due to v-html / v-text
|
|
if (parent) {
|
|
nodeOps.removeChild(parent, el);
|
|
}
|
|
}
|
|
|
|
var inPre = 0;
|
|
function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {
|
|
vnode.isRootInsert = !nested; // for transition enter check
|
|
if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
|
|
return
|
|
}
|
|
|
|
var data = vnode.data;
|
|
var children = vnode.children;
|
|
var tag = vnode.tag;
|
|
if (isDef(tag)) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (data && data.pre) {
|
|
inPre++;
|
|
}
|
|
if (
|
|
!inPre &&
|
|
!vnode.ns &&
|
|
!(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&
|
|
config.isUnknownElement(tag)
|
|
) {
|
|
warn(
|
|
'Unknown custom element: <' + tag + '> - did you ' +
|
|
'register the component correctly? For recursive components, ' +
|
|
'make sure to provide the "name" option.',
|
|
vnode.context
|
|
);
|
|
}
|
|
}
|
|
vnode.elm = vnode.ns
|
|
? nodeOps.createElementNS(vnode.ns, tag)
|
|
: nodeOps.createElement(tag, vnode);
|
|
setScope(vnode);
|
|
|
|
/* istanbul ignore if */
|
|
{
|
|
createChildren(vnode, children, insertedVnodeQueue);
|
|
if (isDef(data)) {
|
|
invokeCreateHooks(vnode, insertedVnodeQueue);
|
|
}
|
|
insert(parentElm, vnode.elm, refElm);
|
|
}
|
|
|
|
if (process.env.NODE_ENV !== 'production' && data && data.pre) {
|
|
inPre--;
|
|
}
|
|
} else if (vnode.isComment) {
|
|
vnode.elm = nodeOps.createComment(vnode.text);
|
|
insert(parentElm, vnode.elm, refElm);
|
|
} else {
|
|
vnode.elm = nodeOps.createTextNode(vnode.text);
|
|
insert(parentElm, vnode.elm, refElm);
|
|
}
|
|
}
|
|
|
|
function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
|
|
var i = vnode.data;
|
|
if (isDef(i)) {
|
|
var isReactivated = isDef(vnode.child) && i.keepAlive;
|
|
if (isDef(i = i.hook) && isDef(i = i.init)) {
|
|
i(vnode, false /* hydrating */, parentElm, refElm);
|
|
}
|
|
// after calling the init hook, if the vnode is a child component
|
|
// it should've created a child instance and mounted it. the child
|
|
// component also has set the placeholder vnode's elm.
|
|
// in that case we can just return the element and be done.
|
|
if (isDef(vnode.child)) {
|
|
initComponent(vnode, insertedVnodeQueue);
|
|
if (isReactivated) {
|
|
reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
|
|
var i;
|
|
// hack for #4339: a reactivated component with inner transition
|
|
// does not trigger because the inner node's created hooks are not called
|
|
// again. It's not ideal to involve module-specific logic in here but
|
|
// there doesn't seem to be a better way to do it.
|
|
var innerNode = vnode;
|
|
while (innerNode.child) {
|
|
innerNode = innerNode.child._vnode;
|
|
if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
|
|
for (i = 0; i < cbs.activate.length; ++i) {
|
|
cbs.activate[i](emptyNode, innerNode);
|
|
}
|
|
insertedVnodeQueue.push(innerNode);
|
|
break
|
|
}
|
|
}
|
|
// unlike a newly created component,
|
|
// a reactivated keep-alive component doesn't insert itself
|
|
insert(parentElm, vnode.elm, refElm);
|
|
}
|
|
|
|
function insert (parent, elm, ref) {
|
|
if (parent) {
|
|
if (ref) {
|
|
nodeOps.insertBefore(parent, elm, ref);
|
|
} else {
|
|
nodeOps.appendChild(parent, elm);
|
|
}
|
|
}
|
|
}
|
|
|
|
function createChildren (vnode, children, insertedVnodeQueue) {
|
|
if (Array.isArray(children)) {
|
|
for (var i = 0; i < children.length; ++i) {
|
|
createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);
|
|
}
|
|
} else if (isPrimitive(vnode.text)) {
|
|
nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));
|
|
}
|
|
}
|
|
|
|
function isPatchable (vnode) {
|
|
while (vnode.child) {
|
|
vnode = vnode.child._vnode;
|
|
}
|
|
return isDef(vnode.tag)
|
|
}
|
|
|
|
function invokeCreateHooks (vnode, insertedVnodeQueue) {
|
|
for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
|
|
cbs.create[i$1](emptyNode, vnode);
|
|
}
|
|
i = vnode.data.hook; // Reuse variable
|
|
if (isDef(i)) {
|
|
if (i.create) { i.create(emptyNode, vnode); }
|
|
if (i.insert) { insertedVnodeQueue.push(vnode); }
|
|
}
|
|
}
|
|
|
|
function initComponent (vnode, insertedVnodeQueue) {
|
|
if (vnode.data.pendingInsert) {
|
|
insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
|
|
}
|
|
vnode.elm = vnode.child.$el;
|
|
if (isPatchable(vnode)) {
|
|
invokeCreateHooks(vnode, insertedVnodeQueue);
|
|
setScope(vnode);
|
|
} else {
|
|
// empty component root.
|
|
// skip all element-related modules except for ref (#3455)
|
|
registerRef(vnode);
|
|
// make sure to invoke the insert hook
|
|
insertedVnodeQueue.push(vnode);
|
|
}
|
|
}
|
|
|
|
// set scope id attribute for scoped CSS.
|
|
// this is implemented as a special case to avoid the overhead
|
|
// of going through the normal attribute patching process.
|
|
function setScope (vnode) {
|
|
var i;
|
|
if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {
|
|
nodeOps.setAttribute(vnode.elm, i, '');
|
|
}
|
|
if (isDef(i = activeInstance) &&
|
|
i !== vnode.context &&
|
|
isDef(i = i.$options._scopeId)) {
|
|
nodeOps.setAttribute(vnode.elm, i, '');
|
|
}
|
|
}
|
|
|
|
function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
|
|
for (; startIdx <= endIdx; ++startIdx) {
|
|
createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);
|
|
}
|
|
}
|
|
|
|
function invokeDestroyHook (vnode) {
|
|
var i, j;
|
|
var data = vnode.data;
|
|
if (isDef(data)) {
|
|
if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
|
|
for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
|
|
}
|
|
if (isDef(i = vnode.children)) {
|
|
for (j = 0; j < vnode.children.length; ++j) {
|
|
invokeDestroyHook(vnode.children[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
|
|
for (; startIdx <= endIdx; ++startIdx) {
|
|
var ch = vnodes[startIdx];
|
|
if (isDef(ch)) {
|
|
if (isDef(ch.tag)) {
|
|
removeAndInvokeRemoveHook(ch);
|
|
invokeDestroyHook(ch);
|
|
} else { // Text node
|
|
removeNode(ch.elm);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function removeAndInvokeRemoveHook (vnode, rm) {
|
|
if (rm || isDef(vnode.data)) {
|
|
var listeners = cbs.remove.length + 1;
|
|
if (!rm) {
|
|
// directly removing
|
|
rm = createRmCb(vnode.elm, listeners);
|
|
} else {
|
|
// we have a recursively passed down rm callback
|
|
// increase the listeners count
|
|
rm.listeners += listeners;
|
|
}
|
|
// recursively invoke hooks on child component root node
|
|
if (isDef(i = vnode.child) && isDef(i = i._vnode) && isDef(i.data)) {
|
|
removeAndInvokeRemoveHook(i, rm);
|
|
}
|
|
for (i = 0; i < cbs.remove.length; ++i) {
|
|
cbs.remove[i](vnode, rm);
|
|
}
|
|
if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
|
|
i(vnode, rm);
|
|
} else {
|
|
rm();
|
|
}
|
|
} else {
|
|
removeNode(vnode.elm);
|
|
}
|
|
}
|
|
|
|
function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
|
|
var oldStartIdx = 0;
|
|
var newStartIdx = 0;
|
|
var oldEndIdx = oldCh.length - 1;
|
|
var oldStartVnode = oldCh[0];
|
|
var oldEndVnode = oldCh[oldEndIdx];
|
|
var newEndIdx = newCh.length - 1;
|
|
var newStartVnode = newCh[0];
|
|
var newEndVnode = newCh[newEndIdx];
|
|
var oldKeyToIdx, idxInOld, elmToMove, refElm;
|
|
|
|
// removeOnly is a special flag used only by <transition-group>
|
|
// to ensure removed elements stay in correct relative positions
|
|
// during leaving transitions
|
|
var canMove = !removeOnly;
|
|
|
|
while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
|
|
if (isUndef(oldStartVnode)) {
|
|
oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
|
|
} else if (isUndef(oldEndVnode)) {
|
|
oldEndVnode = oldCh[--oldEndIdx];
|
|
} else if (sameVnode(oldStartVnode, newStartVnode)) {
|
|
patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
|
|
oldStartVnode = oldCh[++oldStartIdx];
|
|
newStartVnode = newCh[++newStartIdx];
|
|
} else if (sameVnode(oldEndVnode, newEndVnode)) {
|
|
patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
|
|
oldEndVnode = oldCh[--oldEndIdx];
|
|
newEndVnode = newCh[--newEndIdx];
|
|
} else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
|
|
patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
|
|
canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
|
|
oldStartVnode = oldCh[++oldStartIdx];
|
|
newEndVnode = newCh[--newEndIdx];
|
|
} else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
|
|
patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
|
|
canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
|
|
oldEndVnode = oldCh[--oldEndIdx];
|
|
newStartVnode = newCh[++newStartIdx];
|
|
} else {
|
|
if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
|
|
idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;
|
|
if (isUndef(idxInOld)) { // New element
|
|
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
|
|
newStartVnode = newCh[++newStartIdx];
|
|
} else {
|
|
elmToMove = oldCh[idxInOld];
|
|
/* istanbul ignore if */
|
|
if (process.env.NODE_ENV !== 'production' && !elmToMove) {
|
|
warn(
|
|
'It seems there are duplicate keys that is causing an update error. ' +
|
|
'Make sure each v-for item has a unique key.'
|
|
);
|
|
}
|
|
if (sameVnode(elmToMove, newStartVnode)) {
|
|
patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
|
|
oldCh[idxInOld] = undefined;
|
|
canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);
|
|
newStartVnode = newCh[++newStartIdx];
|
|
} else {
|
|
// same key but different element. treat as new element
|
|
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
|
|
newStartVnode = newCh[++newStartIdx];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (oldStartIdx > oldEndIdx) {
|
|
refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
|
|
addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
|
|
} else if (newStartIdx > newEndIdx) {
|
|
removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
|
|
}
|
|
}
|
|
|
|
function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
|
|
if (oldVnode === vnode) {
|
|
return
|
|
}
|
|
// reuse element for static trees.
|
|
// note we only do this if the vnode is cloned -
|
|
// if the new node is not cloned it means the render functions have been
|
|
// reset by the hot-reload-api and we need to do a proper re-render.
|
|
if (vnode.isStatic &&
|
|
oldVnode.isStatic &&
|
|
vnode.key === oldVnode.key &&
|
|
(vnode.isCloned || vnode.isOnce)) {
|
|
vnode.elm = oldVnode.elm;
|
|
vnode.child = oldVnode.child;
|
|
return
|
|
}
|
|
var i;
|
|
var data = vnode.data;
|
|
var hasData = isDef(data);
|
|
if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {
|
|
i(oldVnode, vnode);
|
|
}
|
|
var elm = vnode.elm = oldVnode.elm;
|
|
var oldCh = oldVnode.children;
|
|
var ch = vnode.children;
|
|
if (hasData && isPatchable(vnode)) {
|
|
for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
|
|
if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
|
|
}
|
|
if (isUndef(vnode.text)) {
|
|
if (isDef(oldCh) && isDef(ch)) {
|
|
if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
|
|
} else if (isDef(ch)) {
|
|
if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
|
|
addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
|
|
} else if (isDef(oldCh)) {
|
|
removeVnodes(elm, oldCh, 0, oldCh.length - 1);
|
|
} else if (isDef(oldVnode.text)) {
|
|
nodeOps.setTextContent(elm, '');
|
|
}
|
|
} else if (oldVnode.text !== vnode.text) {
|
|
nodeOps.setTextContent(elm, vnode.text);
|
|
}
|
|
if (hasData) {
|
|
if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
|
|
}
|
|
}
|
|
|
|
function invokeInsertHook (vnode, queue, initial) {
|
|
// delay insert hooks for component root nodes, invoke them after the
|
|
// element is really inserted
|
|
if (initial && vnode.parent) {
|
|
vnode.parent.data.pendingInsert = queue;
|
|
} else {
|
|
for (var i = 0; i < queue.length; ++i) {
|
|
queue[i].data.hook.insert(queue[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
var bailed = false;
|
|
// list of modules that can skip create hook during hydration because they
|
|
// are already rendered on the client or has no need for initialization
|
|
var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');
|
|
|
|
// Note: this is a browser-only function so we can assume elms are DOM nodes.
|
|
function hydrate (elm, vnode, insertedVnodeQueue) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (!assertNodeMatch(elm, vnode)) {
|
|
return false
|
|
}
|
|
}
|
|
vnode.elm = elm;
|
|
var tag = vnode.tag;
|
|
var data = vnode.data;
|
|
var children = vnode.children;
|
|
if (isDef(data)) {
|
|
if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
|
|
if (isDef(i = vnode.child)) {
|
|
// child component. it should have hydrated its own tree.
|
|
initComponent(vnode, insertedVnodeQueue);
|
|
return true
|
|
}
|
|
}
|
|
if (isDef(tag)) {
|
|
if (isDef(children)) {
|
|
// empty element, allow client to pick up and populate children
|
|
if (!elm.hasChildNodes()) {
|
|
createChildren(vnode, children, insertedVnodeQueue);
|
|
} else {
|
|
var childrenMatch = true;
|
|
var childNode = elm.firstChild;
|
|
for (var i$1 = 0; i$1 < children.length; i$1++) {
|
|
if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {
|
|
childrenMatch = false;
|
|
break
|
|
}
|
|
childNode = childNode.nextSibling;
|
|
}
|
|
// if childNode is not null, it means the actual childNodes list is
|
|
// longer than the virtual children list.
|
|
if (!childrenMatch || childNode) {
|
|
if (process.env.NODE_ENV !== 'production' &&
|
|
typeof console !== 'undefined' &&
|
|
!bailed) {
|
|
bailed = true;
|
|
console.warn('Parent: ', elm);
|
|
console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
if (isDef(data)) {
|
|
for (var key in data) {
|
|
if (!isRenderedModule(key)) {
|
|
invokeCreateHooks(vnode, insertedVnodeQueue);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else if (elm.data !== vnode.text) {
|
|
elm.data = vnode.text;
|
|
}
|
|
return true
|
|
}
|
|
|
|
function assertNodeMatch (node, vnode) {
|
|
if (vnode.tag) {
|
|
return (
|
|
vnode.tag.indexOf('vue-component') === 0 ||
|
|
vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
|
|
)
|
|
} else {
|
|
return node.nodeType === (vnode.isComment ? 8 : 3)
|
|
}
|
|
}
|
|
|
|
return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
|
|
if (!vnode) {
|
|
if (oldVnode) { invokeDestroyHook(oldVnode); }
|
|
return
|
|
}
|
|
|
|
var elm, parent;
|
|
var isInitialPatch = false;
|
|
var insertedVnodeQueue = [];
|
|
|
|
if (!oldVnode) {
|
|
// empty mount (likely as component), create new root element
|
|
isInitialPatch = true;
|
|
createElm(vnode, insertedVnodeQueue, parentElm, refElm);
|
|
} else {
|
|
var isRealElement = isDef(oldVnode.nodeType);
|
|
if (!isRealElement && sameVnode(oldVnode, vnode)) {
|
|
// patch existing root node
|
|
patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);
|
|
} else {
|
|
if (isRealElement) {
|
|
// mounting to a real element
|
|
// check if this is server-rendered content and if we can perform
|
|
// a successful hydration.
|
|
if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {
|
|
oldVnode.removeAttribute('server-rendered');
|
|
hydrating = true;
|
|
}
|
|
if (hydrating) {
|
|
if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
|
|
invokeInsertHook(vnode, insertedVnodeQueue, true);
|
|
return oldVnode
|
|
} else if (process.env.NODE_ENV !== 'production') {
|
|
warn(
|
|
'The client-side rendered virtual DOM tree is not matching ' +
|
|
'server-rendered content. This is likely caused by incorrect ' +
|
|
'HTML markup, for example nesting block-level elements inside ' +
|
|
'<p>, or missing <tbody>. Bailing hydration and performing ' +
|
|
'full client-side render.'
|
|
);
|
|
}
|
|
}
|
|
// either not server-rendered, or hydration failed.
|
|
// create an empty node and replace it
|
|
oldVnode = emptyNodeAt(oldVnode);
|
|
}
|
|
// replacing existing element
|
|
elm = oldVnode.elm;
|
|
parent = nodeOps.parentNode(elm);
|
|
createElm(vnode, insertedVnodeQueue, parent, nodeOps.nextSibling(elm));
|
|
|
|
if (vnode.parent) {
|
|
// component root element replaced.
|
|
// update parent placeholder node element, recursively
|
|
var ancestor = vnode.parent;
|
|
while (ancestor) {
|
|
ancestor.elm = vnode.elm;
|
|
ancestor = ancestor.parent;
|
|
}
|
|
if (isPatchable(vnode)) {
|
|
for (var i = 0; i < cbs.create.length; ++i) {
|
|
cbs.create[i](emptyNode, vnode.parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (parent !== null) {
|
|
removeVnodes(parent, [oldVnode], 0, 0);
|
|
} else if (isDef(oldVnode.tag)) {
|
|
invokeDestroyHook(oldVnode);
|
|
}
|
|
}
|
|
}
|
|
|
|
invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
|
|
return vnode.elm
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var directives = {
|
|
create: updateDirectives,
|
|
update: updateDirectives,
|
|
destroy: function unbindDirectives (vnode) {
|
|
updateDirectives(vnode, emptyNode);
|
|
}
|
|
};
|
|
|
|
function updateDirectives (oldVnode, vnode) {
|
|
if (oldVnode.data.directives || vnode.data.directives) {
|
|
_update(oldVnode, vnode);
|
|
}
|
|
}
|
|
|
|
function _update (oldVnode, vnode) {
|
|
var isCreate = oldVnode === emptyNode;
|
|
var isDestroy = vnode === emptyNode;
|
|
var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
|
|
var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
|
|
|
|
var dirsWithInsert = [];
|
|
var dirsWithPostpatch = [];
|
|
|
|
var key, oldDir, dir;
|
|
for (key in newDirs) {
|
|
oldDir = oldDirs[key];
|
|
dir = newDirs[key];
|
|
if (!oldDir) {
|
|
// new directive, bind
|
|
callHook$1(dir, 'bind', vnode, oldVnode);
|
|
if (dir.def && dir.def.inserted) {
|
|
dirsWithInsert.push(dir);
|
|
}
|
|
} else {
|
|
// existing directive, update
|
|
dir.oldValue = oldDir.value;
|
|
callHook$1(dir, 'update', vnode, oldVnode);
|
|
if (dir.def && dir.def.componentUpdated) {
|
|
dirsWithPostpatch.push(dir);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dirsWithInsert.length) {
|
|
var callInsert = function () {
|
|
for (var i = 0; i < dirsWithInsert.length; i++) {
|
|
callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
|
|
}
|
|
};
|
|
if (isCreate) {
|
|
mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');
|
|
} else {
|
|
callInsert();
|
|
}
|
|
}
|
|
|
|
if (dirsWithPostpatch.length) {
|
|
mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {
|
|
for (var i = 0; i < dirsWithPostpatch.length; i++) {
|
|
callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
|
|
}
|
|
}, 'dir-postpatch');
|
|
}
|
|
|
|
if (!isCreate) {
|
|
for (key in oldDirs) {
|
|
if (!newDirs[key]) {
|
|
// no longer present, unbind
|
|
callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var emptyModifiers = Object.create(null);
|
|
|
|
function normalizeDirectives$1 (
|
|
dirs,
|
|
vm
|
|
) {
|
|
var res = Object.create(null);
|
|
if (!dirs) {
|
|
return res
|
|
}
|
|
var i, dir;
|
|
for (i = 0; i < dirs.length; i++) {
|
|
dir = dirs[i];
|
|
if (!dir.modifiers) {
|
|
dir.modifiers = emptyModifiers;
|
|
}
|
|
res[getRawDirName(dir)] = dir;
|
|
dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
|
|
}
|
|
return res
|
|
}
|
|
|
|
function getRawDirName (dir) {
|
|
return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
|
|
}
|
|
|
|
function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
|
|
var fn = dir.def && dir.def[hook];
|
|
if (fn) {
|
|
fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
|
|
}
|
|
}
|
|
|
|
var baseModules = [
|
|
ref,
|
|
directives
|
|
];
|
|
|
|
/* */
|
|
|
|
function updateAttrs (oldVnode, vnode) {
|
|
if (!oldVnode.data.attrs && !vnode.data.attrs) {
|
|
return
|
|
}
|
|
var key, cur, old;
|
|
var elm = vnode.elm;
|
|
var oldAttrs = oldVnode.data.attrs || {};
|
|
var attrs = vnode.data.attrs || {};
|
|
// clone observed objects, as the user probably wants to mutate it
|
|
if (attrs.__ob__) {
|
|
attrs = vnode.data.attrs = extend({}, attrs);
|
|
}
|
|
|
|
for (key in attrs) {
|
|
cur = attrs[key];
|
|
old = oldAttrs[key];
|
|
if (old !== cur) {
|
|
setAttr(elm, key, cur);
|
|
}
|
|
}
|
|
// #4391: in IE9, setting type can reset value for input[type=radio]
|
|
/* istanbul ignore if */
|
|
if (isIE9 && attrs.value !== oldAttrs.value) {
|
|
setAttr(elm, 'value', attrs.value);
|
|
}
|
|
for (key in oldAttrs) {
|
|
if (attrs[key] == null) {
|
|
if (isXlink(key)) {
|
|
elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
|
|
} else if (!isEnumeratedAttr(key)) {
|
|
elm.removeAttribute(key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function setAttr (el, key, value) {
|
|
if (isBooleanAttr(key)) {
|
|
// set attribute for blank value
|
|
// e.g. <option disabled>Select one</option>
|
|
if (isFalsyAttrValue(value)) {
|
|
el.removeAttribute(key);
|
|
} else {
|
|
el.setAttribute(key, key);
|
|
}
|
|
} else if (isEnumeratedAttr(key)) {
|
|
el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');
|
|
} else if (isXlink(key)) {
|
|
if (isFalsyAttrValue(value)) {
|
|
el.removeAttributeNS(xlinkNS, getXlinkProp(key));
|
|
} else {
|
|
el.setAttributeNS(xlinkNS, key, value);
|
|
}
|
|
} else {
|
|
if (isFalsyAttrValue(value)) {
|
|
el.removeAttribute(key);
|
|
} else {
|
|
el.setAttribute(key, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
var attrs = {
|
|
create: updateAttrs,
|
|
update: updateAttrs
|
|
};
|
|
|
|
/* */
|
|
|
|
function updateClass (oldVnode, vnode) {
|
|
var el = vnode.elm;
|
|
var data = vnode.data;
|
|
var oldData = oldVnode.data;
|
|
if (!data.staticClass && !data.class &&
|
|
(!oldData || (!oldData.staticClass && !oldData.class))) {
|
|
return
|
|
}
|
|
|
|
var cls = genClassForVnode(vnode);
|
|
|
|
// handle transition classes
|
|
var transitionClass = el._transitionClasses;
|
|
if (transitionClass) {
|
|
cls = concat(cls, stringifyClass(transitionClass));
|
|
}
|
|
|
|
// set the class
|
|
if (cls !== el._prevClass) {
|
|
el.setAttribute('class', cls);
|
|
el._prevClass = cls;
|
|
}
|
|
}
|
|
|
|
var klass = {
|
|
create: updateClass,
|
|
update: updateClass
|
|
};
|
|
|
|
/* */
|
|
|
|
var target$1;
|
|
|
|
function add$2 (event, handler, once, capture) {
|
|
if (once) {
|
|
var oldHandler = handler;
|
|
handler = function (ev) {
|
|
remove$3(event, handler, capture);
|
|
arguments.length === 1
|
|
? oldHandler(ev)
|
|
: oldHandler.apply(null, arguments);
|
|
};
|
|
}
|
|
target$1.addEventListener(event, handler, capture);
|
|
}
|
|
|
|
function remove$3 (event, handler, capture) {
|
|
target$1.removeEventListener(event, handler, capture);
|
|
}
|
|
|
|
function updateDOMListeners (oldVnode, vnode) {
|
|
if (!oldVnode.data.on && !vnode.data.on) {
|
|
return
|
|
}
|
|
var on = vnode.data.on || {};
|
|
var oldOn = oldVnode.data.on || {};
|
|
target$1 = vnode.elm;
|
|
updateListeners(on, oldOn, add$2, remove$3, vnode.context);
|
|
}
|
|
|
|
var events = {
|
|
create: updateDOMListeners,
|
|
update: updateDOMListeners
|
|
};
|
|
|
|
/* */
|
|
|
|
function updateDOMProps (oldVnode, vnode) {
|
|
if (!oldVnode.data.domProps && !vnode.data.domProps) {
|
|
return
|
|
}
|
|
var key, cur;
|
|
var elm = vnode.elm;
|
|
var oldProps = oldVnode.data.domProps || {};
|
|
var props = vnode.data.domProps || {};
|
|
// clone observed objects, as the user probably wants to mutate it
|
|
if (props.__ob__) {
|
|
props = vnode.data.domProps = extend({}, props);
|
|
}
|
|
|
|
for (key in oldProps) {
|
|
if (props[key] == null) {
|
|
elm[key] = '';
|
|
}
|
|
}
|
|
for (key in props) {
|
|
cur = props[key];
|
|
// ignore children if the node has textContent or innerHTML,
|
|
// as these will throw away existing DOM nodes and cause removal errors
|
|
// on subsequent patches (#3360)
|
|
if (key === 'textContent' || key === 'innerHTML') {
|
|
if (vnode.children) { vnode.children.length = 0; }
|
|
if (cur === oldProps[key]) { continue }
|
|
}
|
|
// #4521: if a click event triggers update before the change event is
|
|
// dispatched on a checkbox/radio input, the input's checked state will
|
|
// be reset and fail to trigger another update.
|
|
/* istanbul ignore next */
|
|
if (key === 'checked' && !isDirty(elm, cur)) {
|
|
continue
|
|
}
|
|
if (key === 'value') {
|
|
// store value as _value as well since
|
|
// non-string values will be stringified
|
|
elm._value = cur;
|
|
// avoid resetting cursor position when value is the same
|
|
var strCur = cur == null ? '' : String(cur);
|
|
if (shouldUpdateValue(elm, vnode, strCur)) {
|
|
elm.value = strCur;
|
|
}
|
|
} else {
|
|
elm[key] = cur;
|
|
}
|
|
}
|
|
}
|
|
|
|
// check platforms/web/util/attrs.js acceptValue
|
|
|
|
|
|
function shouldUpdateValue (
|
|
elm,
|
|
vnode,
|
|
checkVal
|
|
) {
|
|
if (!elm.composing && (
|
|
vnode.tag === 'option' ||
|
|
isDirty(elm, checkVal) ||
|
|
isInputChanged(vnode, checkVal)
|
|
)) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
function isDirty (elm, checkVal) {
|
|
return document.activeElement !== elm && elm.value !== checkVal
|
|
}
|
|
|
|
function isInputChanged (vnode, newVal) {
|
|
var value = vnode.elm.value;
|
|
var modifiers = vnode.elm._vModifiers; // injected by v-model runtime
|
|
if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {
|
|
return toNumber(value) !== toNumber(newVal)
|
|
}
|
|
if (modifiers && modifiers.trim) {
|
|
return value.trim() !== newVal.trim()
|
|
}
|
|
return value !== newVal
|
|
}
|
|
|
|
var domProps = {
|
|
create: updateDOMProps,
|
|
update: updateDOMProps
|
|
};
|
|
|
|
/* */
|
|
|
|
var parseStyleText = cached(function (cssText) {
|
|
var res = {};
|
|
var listDelimiter = /;(?![^(]*\))/g;
|
|
var propertyDelimiter = /:(.+)/;
|
|
cssText.split(listDelimiter).forEach(function (item) {
|
|
if (item) {
|
|
var tmp = item.split(propertyDelimiter);
|
|
tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
|
|
}
|
|
});
|
|
return res
|
|
});
|
|
|
|
// merge static and dynamic style data on the same vnode
|
|
function normalizeStyleData (data) {
|
|
var style = normalizeStyleBinding(data.style);
|
|
// static style is pre-processed into an object during compilation
|
|
// and is always a fresh object, so it's safe to merge into it
|
|
return data.staticStyle
|
|
? extend(data.staticStyle, style)
|
|
: style
|
|
}
|
|
|
|
// normalize possible array / string values into Object
|
|
function normalizeStyleBinding (bindingStyle) {
|
|
if (Array.isArray(bindingStyle)) {
|
|
return toObject(bindingStyle)
|
|
}
|
|
if (typeof bindingStyle === 'string') {
|
|
return parseStyleText(bindingStyle)
|
|
}
|
|
return bindingStyle
|
|
}
|
|
|
|
/**
|
|
* parent component style should be after child's
|
|
* so that parent component's style could override it
|
|
*/
|
|
function getStyle (vnode, checkChild) {
|
|
var res = {};
|
|
var styleData;
|
|
|
|
if (checkChild) {
|
|
var childNode = vnode;
|
|
while (childNode.child) {
|
|
childNode = childNode.child._vnode;
|
|
if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {
|
|
extend(res, styleData);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((styleData = normalizeStyleData(vnode.data))) {
|
|
extend(res, styleData);
|
|
}
|
|
|
|
var parentNode = vnode;
|
|
while ((parentNode = parentNode.parent)) {
|
|
if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
|
|
extend(res, styleData);
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
/* */
|
|
|
|
var cssVarRE = /^--/;
|
|
var importantRE = /\s*!important$/;
|
|
var setProp = function (el, name, val) {
|
|
/* istanbul ignore if */
|
|
if (cssVarRE.test(name)) {
|
|
el.style.setProperty(name, val);
|
|
} else if (importantRE.test(val)) {
|
|
el.style.setProperty(name, val.replace(importantRE, ''), 'important');
|
|
} else {
|
|
el.style[normalize(name)] = val;
|
|
}
|
|
};
|
|
|
|
var prefixes = ['Webkit', 'Moz', 'ms'];
|
|
|
|
var testEl;
|
|
var normalize = cached(function (prop) {
|
|
testEl = testEl || document.createElement('div');
|
|
prop = camelize(prop);
|
|
if (prop !== 'filter' && (prop in testEl.style)) {
|
|
return prop
|
|
}
|
|
var upper = prop.charAt(0).toUpperCase() + prop.slice(1);
|
|
for (var i = 0; i < prefixes.length; i++) {
|
|
var prefixed = prefixes[i] + upper;
|
|
if (prefixed in testEl.style) {
|
|
return prefixed
|
|
}
|
|
}
|
|
});
|
|
|
|
function updateStyle (oldVnode, vnode) {
|
|
var data = vnode.data;
|
|
var oldData = oldVnode.data;
|
|
|
|
if (!data.staticStyle && !data.style &&
|
|
!oldData.staticStyle && !oldData.style) {
|
|
return
|
|
}
|
|
|
|
var cur, name;
|
|
var el = vnode.elm;
|
|
var oldStaticStyle = oldVnode.data.staticStyle;
|
|
var oldStyleBinding = oldVnode.data.style || {};
|
|
|
|
// if static style exists, stylebinding already merged into it when doing normalizeStyleData
|
|
var oldStyle = oldStaticStyle || oldStyleBinding;
|
|
|
|
var style = normalizeStyleBinding(vnode.data.style) || {};
|
|
|
|
vnode.data.style = style.__ob__ ? extend({}, style) : style;
|
|
|
|
var newStyle = getStyle(vnode, true);
|
|
|
|
for (name in oldStyle) {
|
|
if (newStyle[name] == null) {
|
|
setProp(el, name, '');
|
|
}
|
|
}
|
|
for (name in newStyle) {
|
|
cur = newStyle[name];
|
|
if (cur !== oldStyle[name]) {
|
|
// ie9 setting to null has no effect, must use empty string
|
|
setProp(el, name, cur == null ? '' : cur);
|
|
}
|
|
}
|
|
}
|
|
|
|
var style = {
|
|
create: updateStyle,
|
|
update: updateStyle
|
|
};
|
|
|
|
/* */
|
|
|
|
/**
|
|
* Add class with compatibility for SVG since classList is not supported on
|
|
* SVG elements in IE
|
|
*/
|
|
function addClass (el, cls) {
|
|
/* istanbul ignore if */
|
|
if (!cls || !cls.trim()) {
|
|
return
|
|
}
|
|
|
|
/* istanbul ignore else */
|
|
if (el.classList) {
|
|
if (cls.indexOf(' ') > -1) {
|
|
cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); });
|
|
} else {
|
|
el.classList.add(cls);
|
|
}
|
|
} else {
|
|
var cur = ' ' + el.getAttribute('class') + ' ';
|
|
if (cur.indexOf(' ' + cls + ' ') < 0) {
|
|
el.setAttribute('class', (cur + cls).trim());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove class with compatibility for SVG since classList is not supported on
|
|
* SVG elements in IE
|
|
*/
|
|
function removeClass (el, cls) {
|
|
/* istanbul ignore if */
|
|
if (!cls || !cls.trim()) {
|
|
return
|
|
}
|
|
|
|
/* istanbul ignore else */
|
|
if (el.classList) {
|
|
if (cls.indexOf(' ') > -1) {
|
|
cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); });
|
|
} else {
|
|
el.classList.remove(cls);
|
|
}
|
|
} else {
|
|
var cur = ' ' + el.getAttribute('class') + ' ';
|
|
var tar = ' ' + cls + ' ';
|
|
while (cur.indexOf(tar) >= 0) {
|
|
cur = cur.replace(tar, ' ');
|
|
}
|
|
el.setAttribute('class', cur.trim());
|
|
}
|
|
}
|
|
|
|
/* */
|
|
|
|
var hasTransition = inBrowser && !isIE9;
|
|
var TRANSITION = 'transition';
|
|
var ANIMATION = 'animation';
|
|
|
|
// Transition property/event sniffing
|
|
var transitionProp = 'transition';
|
|
var transitionEndEvent = 'transitionend';
|
|
var animationProp = 'animation';
|
|
var animationEndEvent = 'animationend';
|
|
if (hasTransition) {
|
|
/* istanbul ignore if */
|
|
if (window.ontransitionend === undefined &&
|
|
window.onwebkittransitionend !== undefined) {
|
|
transitionProp = 'WebkitTransition';
|
|
transitionEndEvent = 'webkitTransitionEnd';
|
|
}
|
|
if (window.onanimationend === undefined &&
|
|
window.onwebkitanimationend !== undefined) {
|
|
animationProp = 'WebkitAnimation';
|
|
animationEndEvent = 'webkitAnimationEnd';
|
|
}
|
|
}
|
|
|
|
var raf = (inBrowser && window.requestAnimationFrame) || setTimeout;
|
|
function nextFrame (fn) {
|
|
raf(function () {
|
|
raf(fn);
|
|
});
|
|
}
|
|
|
|
function addTransitionClass (el, cls) {
|
|
(el._transitionClasses || (el._transitionClasses = [])).push(cls);
|
|
addClass(el, cls);
|
|
}
|
|
|
|
function removeTransitionClass (el, cls) {
|
|
if (el._transitionClasses) {
|
|
remove$1(el._transitionClasses, cls);
|
|
}
|
|
removeClass(el, cls);
|
|
}
|
|
|
|
function whenTransitionEnds (
|
|
el,
|
|
expectedType,
|
|
cb
|
|
) {
|
|
var ref = getTransitionInfo(el, expectedType);
|
|
var type = ref.type;
|
|
var timeout = ref.timeout;
|
|
var propCount = ref.propCount;
|
|
if (!type) { return cb() }
|
|
var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
|
|
var ended = 0;
|
|
var end = function () {
|
|
el.removeEventListener(event, onEnd);
|
|
cb();
|
|
};
|
|
var onEnd = function (e) {
|
|
if (e.target === el) {
|
|
if (++ended >= propCount) {
|
|
end();
|
|
}
|
|
}
|
|
};
|
|
setTimeout(function () {
|
|
if (ended < propCount) {
|
|
end();
|
|
}
|
|
}, timeout + 1);
|
|
el.addEventListener(event, onEnd);
|
|
}
|
|
|
|
var transformRE = /\b(transform|all)(,|$)/;
|
|
|
|
function getTransitionInfo (el, expectedType) {
|
|
var styles = window.getComputedStyle(el);
|
|
var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');
|
|
var transitionDurations = styles[transitionProp + 'Duration'].split(', ');
|
|
var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);
|
|
var animationDelays = styles[animationProp + 'Delay'].split(', ');
|
|
var animationDurations = styles[animationProp + 'Duration'].split(', ');
|
|
var animationTimeout = getTimeout(animationDelays, animationDurations);
|
|
|
|
var type;
|
|
var timeout = 0;
|
|
var propCount = 0;
|
|
/* istanbul ignore if */
|
|
if (expectedType === TRANSITION) {
|
|
if (transitionTimeout > 0) {
|
|
type = TRANSITION;
|
|
timeout = transitionTimeout;
|
|
propCount = transitionDurations.length;
|
|
}
|
|
} else if (expectedType === ANIMATION) {
|
|
if (animationTimeout > 0) {
|
|
type = ANIMATION;
|
|
timeout = animationTimeout;
|
|
propCount = animationDurations.length;
|
|
}
|
|
} else {
|
|
timeout = Math.max(transitionTimeout, animationTimeout);
|
|
type = timeout > 0
|
|
? transitionTimeout > animationTimeout
|
|
? TRANSITION
|
|
: ANIMATION
|
|
: null;
|
|
propCount = type
|
|
? type === TRANSITION
|
|
? transitionDurations.length
|
|
: animationDurations.length
|
|
: 0;
|
|
}
|
|
var hasTransform =
|
|
type === TRANSITION &&
|
|
transformRE.test(styles[transitionProp + 'Property']);
|
|
return {
|
|
type: type,
|
|
timeout: timeout,
|
|
propCount: propCount,
|
|
hasTransform: hasTransform
|
|
}
|
|
}
|
|
|
|
function getTimeout (delays, durations) {
|
|
/* istanbul ignore next */
|
|
while (delays.length < durations.length) {
|
|
delays = delays.concat(delays);
|
|
}
|
|
|
|
return Math.max.apply(null, durations.map(function (d, i) {
|
|
return toMs(d) + toMs(delays[i])
|
|
}))
|
|
}
|
|
|
|
function toMs (s) {
|
|
return Number(s.slice(0, -1)) * 1000
|
|
}
|
|
|
|
/* */
|
|
|
|
function enter (vnode, toggleDisplay) {
|
|
var el = vnode.elm;
|
|
|
|
// call leave callback now
|
|
if (el._leaveCb) {
|
|
el._leaveCb.cancelled = true;
|
|
el._leaveCb();
|
|
}
|
|
|
|
var data = resolveTransition(vnode.data.transition);
|
|
if (!data) {
|
|
return
|
|
}
|
|
|
|
/* istanbul ignore if */
|
|
if (el._enterCb || el.nodeType !== 1) {
|
|
return
|
|
}
|
|
|
|
var css = data.css;
|
|
var type = data.type;
|
|
var enterClass = data.enterClass;
|
|
var enterToClass = data.enterToClass;
|
|
var enterActiveClass = data.enterActiveClass;
|
|
var appearClass = data.appearClass;
|
|
var appearToClass = data.appearToClass;
|
|
var appearActiveClass = data.appearActiveClass;
|
|
var beforeEnter = data.beforeEnter;
|
|
var enter = data.enter;
|
|
var afterEnter = data.afterEnter;
|
|
var enterCancelled = data.enterCancelled;
|
|
var beforeAppear = data.beforeAppear;
|
|
var appear = data.appear;
|
|
var afterAppear = data.afterAppear;
|
|
var appearCancelled = data.appearCancelled;
|
|
|
|
// activeInstance will always be the <transition> component managing this
|
|
// transition. One edge case to check is when the <transition> is placed
|
|
// as the root node of a child component. In that case we need to check
|
|
// <transition>'s parent for appear check.
|
|
var context = activeInstance;
|
|
var transitionNode = activeInstance.$vnode;
|
|
while (transitionNode && transitionNode.parent) {
|
|
transitionNode = transitionNode.parent;
|
|
context = transitionNode.context;
|
|
}
|
|
|
|
var isAppear = !context._isMounted || !vnode.isRootInsert;
|
|
|
|
if (isAppear && !appear && appear !== '') {
|
|
return
|
|
}
|
|
|
|
var startClass = isAppear ? appearClass : enterClass;
|
|
var activeClass = isAppear ? appearActiveClass : enterActiveClass;
|
|
var toClass = isAppear ? appearToClass : enterToClass;
|
|
var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;
|
|
var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;
|
|
var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;
|
|
var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;
|
|
|
|
var expectsCSS = css !== false && !isIE9;
|
|
var userWantsControl =
|
|
enterHook &&
|
|
// enterHook may be a bound method which exposes
|
|
// the length of original fn as _length
|
|
(enterHook._length || enterHook.length) > 1;
|
|
|
|
var cb = el._enterCb = once(function () {
|
|
if (expectsCSS) {
|
|
removeTransitionClass(el, toClass);
|
|
removeTransitionClass(el, activeClass);
|
|
}
|
|
if (cb.cancelled) {
|
|
if (expectsCSS) {
|
|
removeTransitionClass(el, startClass);
|
|
}
|
|
enterCancelledHook && enterCancelledHook(el);
|
|
} else {
|
|
afterEnterHook && afterEnterHook(el);
|
|
}
|
|
el._enterCb = null;
|
|
});
|
|
|
|
if (!vnode.data.show) {
|
|
// remove pending leave element on enter by injecting an insert hook
|
|
mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {
|
|
var parent = el.parentNode;
|
|
var pendingNode = parent && parent._pending && parent._pending[vnode.key];
|
|
if (pendingNode &&
|
|
pendingNode.context === vnode.context &&
|
|
pendingNode.tag === vnode.tag &&
|
|
pendingNode.elm._leaveCb) {
|
|
pendingNode.elm._leaveCb();
|
|
}
|
|
enterHook && enterHook(el, cb);
|
|
}, 'transition-insert');
|
|
}
|
|
|
|
// start enter transition
|
|
beforeEnterHook && beforeEnterHook(el);
|
|
if (expectsCSS) {
|
|
addTransitionClass(el, startClass);
|
|
addTransitionClass(el, activeClass);
|
|
nextFrame(function () {
|
|
addTransitionClass(el, toClass);
|
|
removeTransitionClass(el, startClass);
|
|
if (!cb.cancelled && !userWantsControl) {
|
|
whenTransitionEnds(el, type, cb);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (vnode.data.show) {
|
|
toggleDisplay && toggleDisplay();
|
|
enterHook && enterHook(el, cb);
|
|
}
|
|
|
|
if (!expectsCSS && !userWantsControl) {
|
|
cb();
|
|
}
|
|
}
|
|
|
|
function leave (vnode, rm) {
|
|
var el = vnode.elm;
|
|
|
|
// call enter callback now
|
|
if (el._enterCb) {
|
|
el._enterCb.cancelled = true;
|
|
el._enterCb();
|
|
}
|
|
|
|
var data = resolveTransition(vnode.data.transition);
|
|
if (!data) {
|
|
return rm()
|
|
}
|
|
|
|
/* istanbul ignore if */
|
|
if (el._leaveCb || el.nodeType !== 1) {
|
|
return
|
|
}
|
|
|
|
var css = data.css;
|
|
var type = data.type;
|
|
var leaveClass = data.leaveClass;
|
|
var leaveToClass = data.leaveToClass;
|
|
var leaveActiveClass = data.leaveActiveClass;
|
|
var beforeLeave = data.beforeLeave;
|
|
var leave = data.leave;
|
|
var afterLeave = data.afterLeave;
|
|
var leaveCancelled = data.leaveCancelled;
|
|
var delayLeave = data.delayLeave;
|
|
|
|
var expectsCSS = css !== false && !isIE9;
|
|
var userWantsControl =
|
|
leave &&
|
|
// leave hook may be a bound method which exposes
|
|
// the length of original fn as _length
|
|
(leave._length || leave.length) > 1;
|
|
|
|
var cb = el._leaveCb = once(function () {
|
|
if (el.parentNode && el.parentNode._pending) {
|
|
el.parentNode._pending[vnode.key] = null;
|
|
}
|
|
if (expectsCSS) {
|
|
removeTransitionClass(el, leaveToClass);
|
|
removeTransitionClass(el, leaveActiveClass);
|
|
}
|
|
if (cb.cancelled) {
|
|
if (expectsCSS) {
|
|
removeTransitionClass(el, leaveClass);
|
|
}
|
|
leaveCancelled && leaveCancelled(el);
|
|
} else {
|
|
rm();
|
|
afterLeave && afterLeave(el);
|
|
}
|
|
el._leaveCb = null;
|
|
});
|
|
|
|
if (delayLeave) {
|
|
delayLeave(performLeave);
|
|
} else {
|
|
performLeave();
|
|
}
|
|
|
|
function performLeave () {
|
|
// the delayed leave may have already been cancelled
|
|
if (cb.cancelled) {
|
|
return
|
|
}
|
|
// record leaving element
|
|
if (!vnode.data.show) {
|
|
(el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
|
|
}
|
|
beforeLeave && beforeLeave(el);
|
|
if (expectsCSS) {
|
|
addTransitionClass(el, leaveClass);
|
|
addTransitionClass(el, leaveActiveClass);
|
|
nextFrame(function () {
|
|
addTransitionClass(el, leaveToClass);
|
|
removeTransitionClass(el, leaveClass);
|
|
if (!cb.cancelled && !userWantsControl) {
|
|
whenTransitionEnds(el, type, cb);
|
|
}
|
|
});
|
|
}
|
|
leave && leave(el, cb);
|
|
if (!expectsCSS && !userWantsControl) {
|
|
cb();
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolveTransition (def$$1) {
|
|
if (!def$$1) {
|
|
return
|
|
}
|
|
/* istanbul ignore else */
|
|
if (typeof def$$1 === 'object') {
|
|
var res = {};
|
|
if (def$$1.css !== false) {
|
|
extend(res, autoCssTransition(def$$1.name || 'v'));
|
|
}
|
|
extend(res, def$$1);
|
|
return res
|
|
} else if (typeof def$$1 === 'string') {
|
|
return autoCssTransition(def$$1)
|
|
}
|
|
}
|
|
|
|
var autoCssTransition = cached(function (name) {
|
|
return {
|
|
enterClass: (name + "-enter"),
|
|
leaveClass: (name + "-leave"),
|
|
appearClass: (name + "-enter"),
|
|
enterToClass: (name + "-enter-to"),
|
|
leaveToClass: (name + "-leave-to"),
|
|
appearToClass: (name + "-enter-to"),
|
|
enterActiveClass: (name + "-enter-active"),
|
|
leaveActiveClass: (name + "-leave-active"),
|
|
appearActiveClass: (name + "-enter-active")
|
|
}
|
|
});
|
|
|
|
function once (fn) {
|
|
var called = false;
|
|
return function () {
|
|
if (!called) {
|
|
called = true;
|
|
fn();
|
|
}
|
|
}
|
|
}
|
|
|
|
function _enter (_, vnode) {
|
|
if (!vnode.data.show) {
|
|
enter(vnode);
|
|
}
|
|
}
|
|
|
|
var transition = inBrowser ? {
|
|
create: _enter,
|
|
activate: _enter,
|
|
remove: function remove (vnode, rm) {
|
|
/* istanbul ignore else */
|
|
if (!vnode.data.show) {
|
|
leave(vnode, rm);
|
|
} else {
|
|
rm();
|
|
}
|
|
}
|
|
} : {};
|
|
|
|
var platformModules = [
|
|
attrs,
|
|
klass,
|
|
events,
|
|
domProps,
|
|
style,
|
|
transition
|
|
];
|
|
|
|
/* */
|
|
|
|
// the directive module should be applied last, after all
|
|
// built-in modules have been applied.
|
|
var modules = platformModules.concat(baseModules);
|
|
|
|
var patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });
|
|
|
|
/**
|
|
* Not type checking this file because flow doesn't like attaching
|
|
* properties to Elements.
|
|
*/
|
|
|
|
var modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;
|
|
|
|
/* istanbul ignore if */
|
|
if (isIE9) {
|
|
// http://www.matts411.com/post/internet-explorer-9-oninput/
|
|
document.addEventListener('selectionchange', function () {
|
|
var el = document.activeElement;
|
|
if (el && el.vmodel) {
|
|
trigger(el, 'input');
|
|
}
|
|
});
|
|
}
|
|
|
|
var model = {
|
|
inserted: function inserted (el, binding, vnode) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (!modelableTagRE.test(vnode.tag)) {
|
|
warn(
|
|
"v-model is not supported on element type: <" + (vnode.tag) + ">. " +
|
|
'If you are working with contenteditable, it\'s recommended to ' +
|
|
'wrap a library dedicated for that purpose inside a custom component.',
|
|
vnode.context
|
|
);
|
|
}
|
|
}
|
|
if (vnode.tag === 'select') {
|
|
var cb = function () {
|
|
setSelected(el, binding, vnode.context);
|
|
};
|
|
cb();
|
|
/* istanbul ignore if */
|
|
if (isIE || isEdge) {
|
|
setTimeout(cb, 0);
|
|
}
|
|
} else if (vnode.tag === 'textarea' || el.type === 'text') {
|
|
el._vModifiers = binding.modifiers;
|
|
if (!binding.modifiers.lazy) {
|
|
if (!isAndroid) {
|
|
el.addEventListener('compositionstart', onCompositionStart);
|
|
el.addEventListener('compositionend', onCompositionEnd);
|
|
}
|
|
/* istanbul ignore if */
|
|
if (isIE9) {
|
|
el.vmodel = true;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
componentUpdated: function componentUpdated (el, binding, vnode) {
|
|
if (vnode.tag === 'select') {
|
|
setSelected(el, binding, vnode.context);
|
|
// in case the options rendered by v-for have changed,
|
|
// it's possible that the value is out-of-sync with the rendered options.
|
|
// detect such cases and filter out values that no longer has a matching
|
|
// option in the DOM.
|
|
var needReset = el.multiple
|
|
? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })
|
|
: binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);
|
|
if (needReset) {
|
|
trigger(el, 'change');
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
function setSelected (el, binding, vm) {
|
|
var value = binding.value;
|
|
var isMultiple = el.multiple;
|
|
if (isMultiple && !Array.isArray(value)) {
|
|
process.env.NODE_ENV !== 'production' && warn(
|
|
"<select multiple v-model=\"" + (binding.expression) + "\"> " +
|
|
"expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
|
|
vm
|
|
);
|
|
return
|
|
}
|
|
var selected, option;
|
|
for (var i = 0, l = el.options.length; i < l; i++) {
|
|
option = el.options[i];
|
|
if (isMultiple) {
|
|
selected = looseIndexOf(value, getValue(option)) > -1;
|
|
if (option.selected !== selected) {
|
|
option.selected = selected;
|
|
}
|
|
} else {
|
|
if (looseEqual(getValue(option), value)) {
|
|
if (el.selectedIndex !== i) {
|
|
el.selectedIndex = i;
|
|
}
|
|
return
|
|
}
|
|
}
|
|
}
|
|
if (!isMultiple) {
|
|
el.selectedIndex = -1;
|
|
}
|
|
}
|
|
|
|
function hasNoMatchingOption (value, options) {
|
|
for (var i = 0, l = options.length; i < l; i++) {
|
|
if (looseEqual(getValue(options[i]), value)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
function getValue (option) {
|
|
return '_value' in option
|
|
? option._value
|
|
: option.value
|
|
}
|
|
|
|
function onCompositionStart (e) {
|
|
e.target.composing = true;
|
|
}
|
|
|
|
function onCompositionEnd (e) {
|
|
e.target.composing = false;
|
|
trigger(e.target, 'input');
|
|
}
|
|
|
|
function trigger (el, type) {
|
|
var e = document.createEvent('HTMLEvents');
|
|
e.initEvent(type, true, true);
|
|
el.dispatchEvent(e);
|
|
}
|
|
|
|
/* */
|
|
|
|
// recursively search for possible transition defined inside the component root
|
|
function locateNode (vnode) {
|
|
return vnode.child && (!vnode.data || !vnode.data.transition)
|
|
? locateNode(vnode.child._vnode)
|
|
: vnode
|
|
}
|
|
|
|
var show = {
|
|
bind: function bind (el, ref, vnode) {
|
|
var value = ref.value;
|
|
|
|
vnode = locateNode(vnode);
|
|
var transition = vnode.data && vnode.data.transition;
|
|
var originalDisplay = el.__vOriginalDisplay =
|
|
el.style.display === 'none' ? '' : el.style.display;
|
|
if (value && transition && !isIE9) {
|
|
vnode.data.show = true;
|
|
enter(vnode, function () {
|
|
el.style.display = originalDisplay;
|
|
});
|
|
} else {
|
|
el.style.display = value ? originalDisplay : 'none';
|
|
}
|
|
},
|
|
|
|
update: function update (el, ref, vnode) {
|
|
var value = ref.value;
|
|
var oldValue = ref.oldValue;
|
|
|
|
/* istanbul ignore if */
|
|
if (value === oldValue) { return }
|
|
vnode = locateNode(vnode);
|
|
var transition = vnode.data && vnode.data.transition;
|
|
if (transition && !isIE9) {
|
|
vnode.data.show = true;
|
|
if (value) {
|
|
enter(vnode, function () {
|
|
el.style.display = el.__vOriginalDisplay;
|
|
});
|
|
} else {
|
|
leave(vnode, function () {
|
|
el.style.display = 'none';
|
|
});
|
|
}
|
|
} else {
|
|
el.style.display = value ? el.__vOriginalDisplay : 'none';
|
|
}
|
|
},
|
|
|
|
unbind: function unbind (
|
|
el,
|
|
binding,
|
|
vnode,
|
|
oldVnode,
|
|
isDestroy
|
|
) {
|
|
if (!isDestroy) {
|
|
el.style.display = el.__vOriginalDisplay;
|
|
}
|
|
}
|
|
};
|
|
|
|
var platformDirectives = {
|
|
model: model,
|
|
show: show
|
|
};
|
|
|
|
/* */
|
|
|
|
// Provides transition support for a single element/component.
|
|
// supports transition mode (out-in / in-out)
|
|
|
|
var transitionProps = {
|
|
name: String,
|
|
appear: Boolean,
|
|
css: Boolean,
|
|
mode: String,
|
|
type: String,
|
|
enterClass: String,
|
|
leaveClass: String,
|
|
enterToClass: String,
|
|
leaveToClass: String,
|
|
enterActiveClass: String,
|
|
leaveActiveClass: String,
|
|
appearClass: String,
|
|
appearActiveClass: String,
|
|
appearToClass: String
|
|
};
|
|
|
|
// in case the child is also an abstract component, e.g. <keep-alive>
|
|
// we want to recursively retrieve the real component to be rendered
|
|
function getRealChild (vnode) {
|
|
var compOptions = vnode && vnode.componentOptions;
|
|
if (compOptions && compOptions.Ctor.options.abstract) {
|
|
return getRealChild(getFirstComponentChild(compOptions.children))
|
|
} else {
|
|
return vnode
|
|
}
|
|
}
|
|
|
|
function extractTransitionData (comp) {
|
|
var data = {};
|
|
var options = comp.$options;
|
|
// props
|
|
for (var key in options.propsData) {
|
|
data[key] = comp[key];
|
|
}
|
|
// events.
|
|
// extract listeners and pass them directly to the transition methods
|
|
var listeners = options._parentListeners;
|
|
for (var key$1 in listeners) {
|
|
data[camelize(key$1)] = listeners[key$1].fn;
|
|
}
|
|
return data
|
|
}
|
|
|
|
function placeholder (h, rawChild) {
|
|
return /\d-keep-alive$/.test(rawChild.tag)
|
|
? h('keep-alive')
|
|
: null
|
|
}
|
|
|
|
function hasParentTransition (vnode) {
|
|
while ((vnode = vnode.parent)) {
|
|
if (vnode.data.transition) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
function isSameChild (child, oldChild) {
|
|
return oldChild.key === child.key && oldChild.tag === child.tag
|
|
}
|
|
|
|
var Transition = {
|
|
name: 'transition',
|
|
props: transitionProps,
|
|
abstract: true,
|
|
render: function render (h) {
|
|
var this$1 = this;
|
|
|
|
var children = this.$slots.default;
|
|
if (!children) {
|
|
return
|
|
}
|
|
|
|
// filter out text nodes (possible whitespaces)
|
|
children = children.filter(function (c) { return c.tag; });
|
|
/* istanbul ignore if */
|
|
if (!children.length) {
|
|
return
|
|
}
|
|
|
|
// warn multiple elements
|
|
if (process.env.NODE_ENV !== 'production' && children.length > 1) {
|
|
warn(
|
|
'<transition> can only be used on a single element. Use ' +
|
|
'<transition-group> for lists.',
|
|
this.$parent
|
|
);
|
|
}
|
|
|
|
var mode = this.mode;
|
|
|
|
// warn invalid mode
|
|
if (process.env.NODE_ENV !== 'production' &&
|
|
mode && mode !== 'in-out' && mode !== 'out-in') {
|
|
warn(
|
|
'invalid <transition> mode: ' + mode,
|
|
this.$parent
|
|
);
|
|
}
|
|
|
|
var rawChild = children[0];
|
|
|
|
// if this is a component root node and the component's
|
|
// parent container node also has transition, skip.
|
|
if (hasParentTransition(this.$vnode)) {
|
|
return rawChild
|
|
}
|
|
|
|
// apply transition data to child
|
|
// use getRealChild() to ignore abstract components e.g. keep-alive
|
|
var child = getRealChild(rawChild);
|
|
/* istanbul ignore if */
|
|
if (!child) {
|
|
return rawChild
|
|
}
|
|
|
|
if (this._leaving) {
|
|
return placeholder(h, rawChild)
|
|
}
|
|
|
|
var key = child.key = child.key == null || child.isStatic
|
|
? ("__v" + (child.tag + this._uid) + "__")
|
|
: child.key;
|
|
var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
|
|
var oldRawChild = this._vnode;
|
|
var oldChild = getRealChild(oldRawChild);
|
|
|
|
// mark v-show
|
|
// so that the transition module can hand over the control to the directive
|
|
if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {
|
|
child.data.show = true;
|
|
}
|
|
|
|
if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {
|
|
// replace old child transition data with fresh one
|
|
// important for dynamic transitions!
|
|
var oldData = oldChild && (oldChild.data.transition = extend({}, data));
|
|
// handle transition mode
|
|
if (mode === 'out-in') {
|
|
// return placeholder node and queue update when leave finishes
|
|
this._leaving = true;
|
|
mergeVNodeHook(oldData, 'afterLeave', function () {
|
|
this$1._leaving = false;
|
|
this$1.$forceUpdate();
|
|
}, key);
|
|
return placeholder(h, rawChild)
|
|
} else if (mode === 'in-out') {
|
|
var delayedLeave;
|
|
var performLeave = function () { delayedLeave(); };
|
|
mergeVNodeHook(data, 'afterEnter', performLeave, key);
|
|
mergeVNodeHook(data, 'enterCancelled', performLeave, key);
|
|
mergeVNodeHook(oldData, 'delayLeave', function (leave) {
|
|
delayedLeave = leave;
|
|
}, key);
|
|
}
|
|
}
|
|
|
|
return rawChild
|
|
}
|
|
};
|
|
|
|
/* */
|
|
|
|
// Provides transition support for list items.
|
|
// supports move transitions using the FLIP technique.
|
|
|
|
// Because the vdom's children update algorithm is "unstable" - i.e.
|
|
// it doesn't guarantee the relative positioning of removed elements,
|
|
// we force transition-group to update its children into two passes:
|
|
// in the first pass, we remove all nodes that need to be removed,
|
|
// triggering their leaving transition; in the second pass, we insert/move
|
|
// into the final disired state. This way in the second pass removed
|
|
// nodes will remain where they should be.
|
|
|
|
var props = extend({
|
|
tag: String,
|
|
moveClass: String
|
|
}, transitionProps);
|
|
|
|
delete props.mode;
|
|
|
|
var TransitionGroup = {
|
|
props: props,
|
|
|
|
render: function render (h) {
|
|
var tag = this.tag || this.$vnode.data.tag || 'span';
|
|
var map = Object.create(null);
|
|
var prevChildren = this.prevChildren = this.children;
|
|
var rawChildren = this.$slots.default || [];
|
|
var children = this.children = [];
|
|
var transitionData = extractTransitionData(this);
|
|
|
|
for (var i = 0; i < rawChildren.length; i++) {
|
|
var c = rawChildren[i];
|
|
if (c.tag) {
|
|
if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
|
|
children.push(c);
|
|
map[c.key] = c
|
|
;(c.data || (c.data = {})).transition = transitionData;
|
|
} else if (process.env.NODE_ENV !== 'production') {
|
|
var opts = c.componentOptions;
|
|
var name = opts
|
|
? (opts.Ctor.options.name || opts.tag)
|
|
: c.tag;
|
|
warn(("<transition-group> children must be keyed: <" + name + ">"));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prevChildren) {
|
|
var kept = [];
|
|
var removed = [];
|
|
for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
|
|
var c$1 = prevChildren[i$1];
|
|
c$1.data.transition = transitionData;
|
|
c$1.data.pos = c$1.elm.getBoundingClientRect();
|
|
if (map[c$1.key]) {
|
|
kept.push(c$1);
|
|
} else {
|
|
removed.push(c$1);
|
|
}
|
|
}
|
|
this.kept = h(tag, null, kept);
|
|
this.removed = removed;
|
|
}
|
|
|
|
return h(tag, null, children)
|
|
},
|
|
|
|
beforeUpdate: function beforeUpdate () {
|
|
// force removing pass
|
|
this.__patch__(
|
|
this._vnode,
|
|
this.kept,
|
|
false, // hydrating
|
|
true // removeOnly (!important, avoids unnecessary moves)
|
|
);
|
|
this._vnode = this.kept;
|
|
},
|
|
|
|
updated: function updated () {
|
|
var children = this.prevChildren;
|
|
var moveClass = this.moveClass || ((this.name || 'v') + '-move');
|
|
if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
|
|
return
|
|
}
|
|
|
|
// we divide the work into three loops to avoid mixing DOM reads and writes
|
|
// in each iteration - which helps prevent layout thrashing.
|
|
children.forEach(callPendingCbs);
|
|
children.forEach(recordPosition);
|
|
children.forEach(applyTranslation);
|
|
|
|
// force reflow to put everything in position
|
|
var f = document.body.offsetHeight; // eslint-disable-line
|
|
|
|
children.forEach(function (c) {
|
|
if (c.data.moved) {
|
|
var el = c.elm;
|
|
var s = el.style;
|
|
addTransitionClass(el, moveClass);
|
|
s.transform = s.WebkitTransform = s.transitionDuration = '';
|
|
el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
|
|
if (!e || /transform$/.test(e.propertyName)) {
|
|
el.removeEventListener(transitionEndEvent, cb);
|
|
el._moveCb = null;
|
|
removeTransitionClass(el, moveClass);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
methods: {
|
|
hasMove: function hasMove (el, moveClass) {
|
|
/* istanbul ignore if */
|
|
if (!hasTransition) {
|
|
return false
|
|
}
|
|
if (this._hasMove != null) {
|
|
return this._hasMove
|
|
}
|
|
addTransitionClass(el, moveClass);
|
|
var info = getTransitionInfo(el);
|
|
removeTransitionClass(el, moveClass);
|
|
return (this._hasMove = info.hasTransform)
|
|
}
|
|
}
|
|
};
|
|
|
|
function callPendingCbs (c) {
|
|
/* istanbul ignore if */
|
|
if (c.elm._moveCb) {
|
|
c.elm._moveCb();
|
|
}
|
|
/* istanbul ignore if */
|
|
if (c.elm._enterCb) {
|
|
c.elm._enterCb();
|
|
}
|
|
}
|
|
|
|
function recordPosition (c) {
|
|
c.data.newPos = c.elm.getBoundingClientRect();
|
|
}
|
|
|
|
function applyTranslation (c) {
|
|
var oldPos = c.data.pos;
|
|
var newPos = c.data.newPos;
|
|
var dx = oldPos.left - newPos.left;
|
|
var dy = oldPos.top - newPos.top;
|
|
if (dx || dy) {
|
|
c.data.moved = true;
|
|
var s = c.elm.style;
|
|
s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
|
|
s.transitionDuration = '0s';
|
|
}
|
|
}
|
|
|
|
var platformComponents = {
|
|
Transition: Transition,
|
|
TransitionGroup: TransitionGroup
|
|
};
|
|
|
|
/* */
|
|
|
|
// install platform specific utils
|
|
Vue$2.config.isUnknownElement = isUnknownElement;
|
|
Vue$2.config.isReservedTag = isReservedTag;
|
|
Vue$2.config.getTagNamespace = getTagNamespace;
|
|
Vue$2.config.mustUseProp = mustUseProp;
|
|
|
|
// install platform runtime directives & components
|
|
extend(Vue$2.options.directives, platformDirectives);
|
|
extend(Vue$2.options.components, platformComponents);
|
|
|
|
// install platform patch function
|
|
Vue$2.prototype.__patch__ = inBrowser ? patch$1 : noop;
|
|
|
|
// wrap mount
|
|
Vue$2.prototype.$mount = function (
|
|
el,
|
|
hydrating
|
|
) {
|
|
el = el && inBrowser ? query(el) : undefined;
|
|
return this._mount(el, hydrating)
|
|
};
|
|
|
|
if (process.env.NODE_ENV !== 'production' &&
|
|
inBrowser && typeof console !== 'undefined') {
|
|
console[console.info ? 'info' : 'log'](
|
|
"You are running Vue in development mode.\n" +
|
|
"Make sure to turn on production mode when deploying for production.\n" +
|
|
"See more tips at https://vuejs.org/guide/deployment.html"
|
|
);
|
|
}
|
|
|
|
// devtools global hook
|
|
/* istanbul ignore next */
|
|
setTimeout(function () {
|
|
if (config.devtools) {
|
|
if (devtools) {
|
|
devtools.emit('init', Vue$2);
|
|
} else if (
|
|
process.env.NODE_ENV !== 'production' &&
|
|
inBrowser && !isEdge && /Chrome\/\d+/.test(window.navigator.userAgent)
|
|
) {
|
|
console[console.info ? 'info' : 'log'](
|
|
'Download the Vue Devtools extension for a better development experience:\n' +
|
|
'https://github.com/vuejs/vue-devtools'
|
|
);
|
|
}
|
|
}
|
|
}, 0);
|
|
|
|
module.exports = Vue$2;
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8), __webpack_require__(28)))
|
|
|
|
/***/ }),
|
|
/* 63 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(64);
|
|
|
|
/***/ }),
|
|
/* 64 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
var bind = __webpack_require__(34);
|
|
var Axios = __webpack_require__(66);
|
|
var defaults = __webpack_require__(21);
|
|
|
|
/**
|
|
* Create an instance of Axios
|
|
*
|
|
* @param {Object} defaultConfig The default config for the instance
|
|
* @return {Axios} A new instance of Axios
|
|
*/
|
|
function createInstance(defaultConfig) {
|
|
var context = new Axios(defaultConfig);
|
|
var instance = bind(Axios.prototype.request, context);
|
|
|
|
// Copy axios.prototype to instance
|
|
utils.extend(instance, Axios.prototype, context);
|
|
|
|
// Copy context to instance
|
|
utils.extend(instance, context);
|
|
|
|
return instance;
|
|
}
|
|
|
|
// Create the default instance to be exported
|
|
var axios = createInstance(defaults);
|
|
|
|
// Expose Axios class to allow class inheritance
|
|
axios.Axios = Axios;
|
|
|
|
// Factory for creating new instances
|
|
axios.create = function create(instanceConfig) {
|
|
return createInstance(utils.merge(defaults, instanceConfig));
|
|
};
|
|
|
|
// Expose Cancel & CancelToken
|
|
axios.Cancel = __webpack_require__(31);
|
|
axios.CancelToken = __webpack_require__(65);
|
|
axios.isCancel = __webpack_require__(32);
|
|
|
|
// Expose all/spread
|
|
axios.all = function all(promises) {
|
|
return Promise.all(promises);
|
|
};
|
|
axios.spread = __webpack_require__(80);
|
|
|
|
module.exports = axios;
|
|
|
|
// Allow use of default import syntax in TypeScript
|
|
module.exports.default = axios;
|
|
|
|
|
|
/***/ }),
|
|
/* 65 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var Cancel = __webpack_require__(31);
|
|
|
|
/**
|
|
* A `CancelToken` is an object that can be used to request cancellation of an operation.
|
|
*
|
|
* @class
|
|
* @param {Function} executor The executor function.
|
|
*/
|
|
function CancelToken(executor) {
|
|
if (typeof executor !== 'function') {
|
|
throw new TypeError('executor must be a function.');
|
|
}
|
|
|
|
var resolvePromise;
|
|
this.promise = new Promise(function promiseExecutor(resolve) {
|
|
resolvePromise = resolve;
|
|
});
|
|
|
|
var token = this;
|
|
executor(function cancel(message) {
|
|
if (token.reason) {
|
|
// Cancellation has already been requested
|
|
return;
|
|
}
|
|
|
|
token.reason = new Cancel(message);
|
|
resolvePromise(token.reason);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Throws a `Cancel` if cancellation has been requested.
|
|
*/
|
|
CancelToken.prototype.throwIfRequested = function throwIfRequested() {
|
|
if (this.reason) {
|
|
throw this.reason;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns an object that contains a new `CancelToken` and a function that, when called,
|
|
* cancels the `CancelToken`.
|
|
*/
|
|
CancelToken.source = function source() {
|
|
var cancel;
|
|
var token = new CancelToken(function executor(c) {
|
|
cancel = c;
|
|
});
|
|
return {
|
|
token: token,
|
|
cancel: cancel
|
|
};
|
|
};
|
|
|
|
module.exports = CancelToken;
|
|
|
|
|
|
/***/ }),
|
|
/* 66 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var defaults = __webpack_require__(21);
|
|
var utils = __webpack_require__(0);
|
|
var InterceptorManager = __webpack_require__(67);
|
|
var dispatchRequest = __webpack_require__(68);
|
|
var isAbsoluteURL = __webpack_require__(76);
|
|
var combineURLs = __webpack_require__(74);
|
|
|
|
/**
|
|
* Create a new instance of Axios
|
|
*
|
|
* @param {Object} instanceConfig The default config for the instance
|
|
*/
|
|
function Axios(instanceConfig) {
|
|
this.defaults = instanceConfig;
|
|
this.interceptors = {
|
|
request: new InterceptorManager(),
|
|
response: new InterceptorManager()
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Dispatch a request
|
|
*
|
|
* @param {Object} config The config specific for this request (merged with this.defaults)
|
|
*/
|
|
Axios.prototype.request = function request(config) {
|
|
/*eslint no-param-reassign:0*/
|
|
// Allow for axios('example/url'[, config]) a la fetch API
|
|
if (typeof config === 'string') {
|
|
config = utils.merge({
|
|
url: arguments[0]
|
|
}, arguments[1]);
|
|
}
|
|
|
|
config = utils.merge(defaults, this.defaults, { method: 'get' }, config);
|
|
|
|
// Support baseURL config
|
|
if (config.baseURL && !isAbsoluteURL(config.url)) {
|
|
config.url = combineURLs(config.baseURL, config.url);
|
|
}
|
|
|
|
// Hook up interceptors middleware
|
|
var chain = [dispatchRequest, undefined];
|
|
var promise = Promise.resolve(config);
|
|
|
|
this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
|
|
chain.unshift(interceptor.fulfilled, interceptor.rejected);
|
|
});
|
|
|
|
this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
|
|
chain.push(interceptor.fulfilled, interceptor.rejected);
|
|
});
|
|
|
|
while (chain.length) {
|
|
promise = promise.then(chain.shift(), chain.shift());
|
|
}
|
|
|
|
return promise;
|
|
};
|
|
|
|
// Provide aliases for supported request methods
|
|
utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
|
|
/*eslint func-names:0*/
|
|
Axios.prototype[method] = function(url, config) {
|
|
return this.request(utils.merge(config || {}, {
|
|
method: method,
|
|
url: url
|
|
}));
|
|
};
|
|
});
|
|
|
|
utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
|
|
/*eslint func-names:0*/
|
|
Axios.prototype[method] = function(url, data, config) {
|
|
return this.request(utils.merge(config || {}, {
|
|
method: method,
|
|
url: url,
|
|
data: data
|
|
}));
|
|
};
|
|
});
|
|
|
|
module.exports = Axios;
|
|
|
|
|
|
/***/ }),
|
|
/* 67 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
function InterceptorManager() {
|
|
this.handlers = [];
|
|
}
|
|
|
|
/**
|
|
* Add a new interceptor to the stack
|
|
*
|
|
* @param {Function} fulfilled The function to handle `then` for a `Promise`
|
|
* @param {Function} rejected The function to handle `reject` for a `Promise`
|
|
*
|
|
* @return {Number} An ID used to remove interceptor later
|
|
*/
|
|
InterceptorManager.prototype.use = function use(fulfilled, rejected) {
|
|
this.handlers.push({
|
|
fulfilled: fulfilled,
|
|
rejected: rejected
|
|
});
|
|
return this.handlers.length - 1;
|
|
};
|
|
|
|
/**
|
|
* Remove an interceptor from the stack
|
|
*
|
|
* @param {Number} id The ID that was returned by `use`
|
|
*/
|
|
InterceptorManager.prototype.eject = function eject(id) {
|
|
if (this.handlers[id]) {
|
|
this.handlers[id] = null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Iterate over all the registered interceptors
|
|
*
|
|
* This method is particularly useful for skipping over any
|
|
* interceptors that may have become `null` calling `eject`.
|
|
*
|
|
* @param {Function} fn The function to call for each interceptor
|
|
*/
|
|
InterceptorManager.prototype.forEach = function forEach(fn) {
|
|
utils.forEach(this.handlers, function forEachHandler(h) {
|
|
if (h !== null) {
|
|
fn(h);
|
|
}
|
|
});
|
|
};
|
|
|
|
module.exports = InterceptorManager;
|
|
|
|
|
|
/***/ }),
|
|
/* 68 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
var transformData = __webpack_require__(71);
|
|
var isCancel = __webpack_require__(32);
|
|
var defaults = __webpack_require__(21);
|
|
|
|
/**
|
|
* Throws a `Cancel` if cancellation has been requested.
|
|
*/
|
|
function throwIfCancellationRequested(config) {
|
|
if (config.cancelToken) {
|
|
config.cancelToken.throwIfRequested();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dispatch a request to the server using the configured adapter.
|
|
*
|
|
* @param {object} config The config that is to be used for the request
|
|
* @returns {Promise} The Promise to be fulfilled
|
|
*/
|
|
module.exports = function dispatchRequest(config) {
|
|
throwIfCancellationRequested(config);
|
|
|
|
// Ensure headers exist
|
|
config.headers = config.headers || {};
|
|
|
|
// Transform request data
|
|
config.data = transformData(
|
|
config.data,
|
|
config.headers,
|
|
config.transformRequest
|
|
);
|
|
|
|
// Flatten headers
|
|
config.headers = utils.merge(
|
|
config.headers.common || {},
|
|
config.headers[config.method] || {},
|
|
config.headers || {}
|
|
);
|
|
|
|
utils.forEach(
|
|
['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
|
|
function cleanHeaderConfig(method) {
|
|
delete config.headers[method];
|
|
}
|
|
);
|
|
|
|
var adapter = config.adapter || defaults.adapter;
|
|
|
|
return adapter(config).then(function onAdapterResolution(response) {
|
|
throwIfCancellationRequested(config);
|
|
|
|
// Transform response data
|
|
response.data = transformData(
|
|
response.data,
|
|
response.headers,
|
|
config.transformResponse
|
|
);
|
|
|
|
return response;
|
|
}, function onAdapterRejection(reason) {
|
|
if (!isCancel(reason)) {
|
|
throwIfCancellationRequested(config);
|
|
|
|
// Transform response data
|
|
if (reason && reason.response) {
|
|
reason.response.data = transformData(
|
|
reason.response.data,
|
|
reason.response.headers,
|
|
config.transformResponse
|
|
);
|
|
}
|
|
}
|
|
|
|
return Promise.reject(reason);
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 69 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/**
|
|
* Update an Error with the specified config, error code, and response.
|
|
*
|
|
* @param {Error} error The error to update.
|
|
* @param {Object} config The config.
|
|
* @param {string} [code] The error code (for example, 'ECONNABORTED').
|
|
@ @param {Object} [response] The response.
|
|
* @returns {Error} The error.
|
|
*/
|
|
module.exports = function enhanceError(error, config, code, response) {
|
|
error.config = config;
|
|
if (code) {
|
|
error.code = code;
|
|
}
|
|
error.response = response;
|
|
return error;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 70 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var createError = __webpack_require__(33);
|
|
|
|
/**
|
|
* Resolve or reject a Promise based on response status.
|
|
*
|
|
* @param {Function} resolve A function that resolves the promise.
|
|
* @param {Function} reject A function that rejects the promise.
|
|
* @param {object} response The response.
|
|
*/
|
|
module.exports = function settle(resolve, reject, response) {
|
|
var validateStatus = response.config.validateStatus;
|
|
// Note: status is not exposed by XDomainRequest
|
|
if (!response.status || !validateStatus || validateStatus(response.status)) {
|
|
resolve(response);
|
|
} else {
|
|
reject(createError(
|
|
'Request failed with status code ' + response.status,
|
|
response.config,
|
|
null,
|
|
response
|
|
));
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 71 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
/**
|
|
* Transform the data for a request or a response
|
|
*
|
|
* @param {Object|String} data The data to be transformed
|
|
* @param {Array} headers The headers for the request or response
|
|
* @param {Array|Function} fns A single function or Array of functions
|
|
* @returns {*} The resulting transformed data
|
|
*/
|
|
module.exports = function transformData(data, headers, fns) {
|
|
/*eslint no-param-reassign:0*/
|
|
utils.forEach(fns, function transform(fn) {
|
|
data = fn(data, headers);
|
|
});
|
|
|
|
return data;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 72 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js
|
|
|
|
var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
|
|
|
function E() {
|
|
this.message = 'String contains an invalid character';
|
|
}
|
|
E.prototype = new Error;
|
|
E.prototype.code = 5;
|
|
E.prototype.name = 'InvalidCharacterError';
|
|
|
|
function btoa(input) {
|
|
var str = String(input);
|
|
var output = '';
|
|
for (
|
|
// initialize result and counter
|
|
var block, charCode, idx = 0, map = chars;
|
|
// if the next str index does not exist:
|
|
// change the mapping table to "="
|
|
// check if d has no fractional digits
|
|
str.charAt(idx | 0) || (map = '=', idx % 1);
|
|
// "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
|
|
output += map.charAt(63 & block >> 8 - idx % 1 * 8)
|
|
) {
|
|
charCode = str.charCodeAt(idx += 3 / 4);
|
|
if (charCode > 0xFF) {
|
|
throw new E();
|
|
}
|
|
block = block << 8 | charCode;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
module.exports = btoa;
|
|
|
|
|
|
/***/ }),
|
|
/* 73 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
function encode(val) {
|
|
return encodeURIComponent(val).
|
|
replace(/%40/gi, '@').
|
|
replace(/%3A/gi, ':').
|
|
replace(/%24/g, '$').
|
|
replace(/%2C/gi, ',').
|
|
replace(/%20/g, '+').
|
|
replace(/%5B/gi, '[').
|
|
replace(/%5D/gi, ']');
|
|
}
|
|
|
|
/**
|
|
* Build a URL by appending params to the end
|
|
*
|
|
* @param {string} url The base of the url (e.g., http://www.google.com)
|
|
* @param {object} [params] The params to be appended
|
|
* @returns {string} The formatted url
|
|
*/
|
|
module.exports = function buildURL(url, params, paramsSerializer) {
|
|
/*eslint no-param-reassign:0*/
|
|
if (!params) {
|
|
return url;
|
|
}
|
|
|
|
var serializedParams;
|
|
if (paramsSerializer) {
|
|
serializedParams = paramsSerializer(params);
|
|
} else if (utils.isURLSearchParams(params)) {
|
|
serializedParams = params.toString();
|
|
} else {
|
|
var parts = [];
|
|
|
|
utils.forEach(params, function serialize(val, key) {
|
|
if (val === null || typeof val === 'undefined') {
|
|
return;
|
|
}
|
|
|
|
if (utils.isArray(val)) {
|
|
key = key + '[]';
|
|
}
|
|
|
|
if (!utils.isArray(val)) {
|
|
val = [val];
|
|
}
|
|
|
|
utils.forEach(val, function parseValue(v) {
|
|
if (utils.isDate(v)) {
|
|
v = v.toISOString();
|
|
} else if (utils.isObject(v)) {
|
|
v = JSON.stringify(v);
|
|
}
|
|
parts.push(encode(key) + '=' + encode(v));
|
|
});
|
|
});
|
|
|
|
serializedParams = parts.join('&');
|
|
}
|
|
|
|
if (serializedParams) {
|
|
url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
|
|
}
|
|
|
|
return url;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 74 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/**
|
|
* Creates a new URL by combining the specified URLs
|
|
*
|
|
* @param {string} baseURL The base URL
|
|
* @param {string} relativeURL The relative URL
|
|
* @returns {string} The combined URL
|
|
*/
|
|
module.exports = function combineURLs(baseURL, relativeURL) {
|
|
return baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 75 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
module.exports = (
|
|
utils.isStandardBrowserEnv() ?
|
|
|
|
// Standard browser envs support document.cookie
|
|
(function standardBrowserEnv() {
|
|
return {
|
|
write: function write(name, value, expires, path, domain, secure) {
|
|
var cookie = [];
|
|
cookie.push(name + '=' + encodeURIComponent(value));
|
|
|
|
if (utils.isNumber(expires)) {
|
|
cookie.push('expires=' + new Date(expires).toGMTString());
|
|
}
|
|
|
|
if (utils.isString(path)) {
|
|
cookie.push('path=' + path);
|
|
}
|
|
|
|
if (utils.isString(domain)) {
|
|
cookie.push('domain=' + domain);
|
|
}
|
|
|
|
if (secure === true) {
|
|
cookie.push('secure');
|
|
}
|
|
|
|
document.cookie = cookie.join('; ');
|
|
},
|
|
|
|
read: function read(name) {
|
|
var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
|
|
return (match ? decodeURIComponent(match[3]) : null);
|
|
},
|
|
|
|
remove: function remove(name) {
|
|
this.write(name, '', Date.now() - 86400000);
|
|
}
|
|
};
|
|
})() :
|
|
|
|
// Non standard browser env (web workers, react-native) lack needed support.
|
|
(function nonStandardBrowserEnv() {
|
|
return {
|
|
write: function write() {},
|
|
read: function read() { return null; },
|
|
remove: function remove() {}
|
|
};
|
|
})()
|
|
);
|
|
|
|
|
|
/***/ }),
|
|
/* 76 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/**
|
|
* Determines whether the specified URL is absolute
|
|
*
|
|
* @param {string} url The URL to test
|
|
* @returns {boolean} True if the specified URL is absolute, otherwise false
|
|
*/
|
|
module.exports = function isAbsoluteURL(url) {
|
|
// A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
|
|
// RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
|
|
// by any combination of letters, digits, plus, period, or hyphen.
|
|
return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 77 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
module.exports = (
|
|
utils.isStandardBrowserEnv() ?
|
|
|
|
// Standard browser envs have full support of the APIs needed to test
|
|
// whether the request URL is of the same origin as current location.
|
|
(function standardBrowserEnv() {
|
|
var msie = /(msie|trident)/i.test(navigator.userAgent);
|
|
var urlParsingNode = document.createElement('a');
|
|
var originURL;
|
|
|
|
/**
|
|
* Parse a URL to discover it's components
|
|
*
|
|
* @param {String} url The URL to be parsed
|
|
* @returns {Object}
|
|
*/
|
|
function resolveURL(url) {
|
|
var href = url;
|
|
|
|
if (msie) {
|
|
// IE needs attribute set twice to normalize properties
|
|
urlParsingNode.setAttribute('href', href);
|
|
href = urlParsingNode.href;
|
|
}
|
|
|
|
urlParsingNode.setAttribute('href', href);
|
|
|
|
// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
|
|
return {
|
|
href: urlParsingNode.href,
|
|
protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
|
|
host: urlParsingNode.host,
|
|
search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
|
|
hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
|
|
hostname: urlParsingNode.hostname,
|
|
port: urlParsingNode.port,
|
|
pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
|
|
urlParsingNode.pathname :
|
|
'/' + urlParsingNode.pathname
|
|
};
|
|
}
|
|
|
|
originURL = resolveURL(window.location.href);
|
|
|
|
/**
|
|
* Determine if a URL shares the same origin as the current location
|
|
*
|
|
* @param {String} requestURL The URL to test
|
|
* @returns {boolean} True if URL shares the same origin, otherwise false
|
|
*/
|
|
return function isURLSameOrigin(requestURL) {
|
|
var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
|
|
return (parsed.protocol === originURL.protocol &&
|
|
parsed.host === originURL.host);
|
|
};
|
|
})() :
|
|
|
|
// Non standard browser envs (web workers, react-native) lack needed support.
|
|
(function nonStandardBrowserEnv() {
|
|
return function isURLSameOrigin() {
|
|
return true;
|
|
};
|
|
})()
|
|
);
|
|
|
|
|
|
/***/ }),
|
|
/* 78 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
module.exports = function normalizeHeaderName(headers, normalizedName) {
|
|
utils.forEach(headers, function processHeader(value, name) {
|
|
if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
|
|
headers[normalizedName] = value;
|
|
delete headers[name];
|
|
}
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 79 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var utils = __webpack_require__(0);
|
|
|
|
/**
|
|
* Parse headers into an object
|
|
*
|
|
* ```
|
|
* Date: Wed, 27 Aug 2014 08:58:49 GMT
|
|
* Content-Type: application/json
|
|
* Connection: keep-alive
|
|
* Transfer-Encoding: chunked
|
|
* ```
|
|
*
|
|
* @param {String} headers Headers needing to be parsed
|
|
* @returns {Object} Headers parsed into an object
|
|
*/
|
|
module.exports = function parseHeaders(headers) {
|
|
var parsed = {};
|
|
var key;
|
|
var val;
|
|
var i;
|
|
|
|
if (!headers) { return parsed; }
|
|
|
|
utils.forEach(headers.split('\n'), function parser(line) {
|
|
i = line.indexOf(':');
|
|
key = utils.trim(line.substr(0, i)).toLowerCase();
|
|
val = utils.trim(line.substr(i + 1));
|
|
|
|
if (key) {
|
|
parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
|
|
}
|
|
});
|
|
|
|
return parsed;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 80 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/**
|
|
* Syntactic sugar for invoking a function and expanding an array for arguments.
|
|
*
|
|
* Common use case would be to use `Function.prototype.apply`.
|
|
*
|
|
* ```js
|
|
* function f(x, y, z) {}
|
|
* var args = [1, 2, 3];
|
|
* f.apply(null, args);
|
|
* ```
|
|
*
|
|
* With `spread` this example can be re-written.
|
|
*
|
|
* ```js
|
|
* spread(function(x, y, z) {})([1, 2, 3]);
|
|
* ```
|
|
*
|
|
* @param {Function} callback
|
|
* @returns {Function}
|
|
*/
|
|
module.exports = function spread(callback) {
|
|
return function wrap(arr) {
|
|
return callback.apply(null, arr);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 81 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
__webpack_require__(193);
|
|
|
|
var _navConfig = __webpack_require__(29);
|
|
|
|
var _navConfig2 = _interopRequireDefault(_navConfig);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
data: function data() {
|
|
return {
|
|
navConfig: _navConfig2.default
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 82 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
data: function data() {
|
|
return {
|
|
hovering: false,
|
|
isExpanded: false
|
|
};
|
|
},
|
|
|
|
|
|
computed: {
|
|
blockClass: function blockClass() {
|
|
return 'demo-' + this.$route.path.split('/').pop();
|
|
},
|
|
controlText: function controlText() {
|
|
return this.isExpanded ? '隐藏代码' : '显示代码';
|
|
},
|
|
codeArea: function codeArea() {
|
|
return this.$el.getElementsByClassName('meta')[0];
|
|
},
|
|
codeAreaHeight: function codeAreaHeight() {
|
|
if (this.$el.getElementsByClassName('description').length > 0) {
|
|
return Math.max(this.$el.getElementsByClassName('description')[0].clientHeight, this.$el.getElementsByClassName('highlight')[0].clientHeight);
|
|
}
|
|
return this.$el.getElementsByClassName('highlight')[0].clientHeight;
|
|
}
|
|
},
|
|
|
|
watch: {
|
|
isExpanded: function isExpanded(val) {
|
|
this.codeArea.style.height = val ? this.codeAreaHeight + 1 + 'px' : '0';
|
|
}
|
|
},
|
|
|
|
mounted: function mounted() {
|
|
var _this = this;
|
|
|
|
this.$nextTick(function () {
|
|
var highlight = _this.$el.getElementsByClassName('highlight')[0];
|
|
if (_this.$el.getElementsByClassName('description').length === 0) {
|
|
highlight.style.width = '100%';
|
|
highlight.borderRight = 'none';
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 83 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
props: {
|
|
data: Array,
|
|
base: {
|
|
type: String,
|
|
default: ''
|
|
}
|
|
},
|
|
data: function data() {
|
|
return {
|
|
highlights: [],
|
|
navState: []
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 84 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
/**
|
|
* o2-header
|
|
* @module components/button
|
|
* @desc 按钮
|
|
* @param {string} [type=default] - 显示类型，接受 default, primary, danger
|
|
* @param {boolean} [disabled=false] - 禁用
|
|
* @param {string} [size=normal] - 尺寸，接受 normal, mini, small, large
|
|
* @param {string} [native-type] - 原生 type 属性
|
|
* @param {slot} - 显示文本
|
|
*
|
|
* @example
|
|
* <o2-button size="large" type="primary">按钮</o2-button>
|
|
*/
|
|
exports.default = {
|
|
name: 'o2-button',
|
|
|
|
methods: {
|
|
handleClick: function handleClick(e) {
|
|
this.$emit('click', e);
|
|
}
|
|
},
|
|
|
|
props: {
|
|
disabled: Boolean,
|
|
loading: Boolean,
|
|
nativeType: String,
|
|
type: {
|
|
type: String,
|
|
default: 'default',
|
|
validator: function validator(value) {
|
|
return ['default', 'danger', 'primary'].indexOf(value) > -1;
|
|
}
|
|
},
|
|
size: {
|
|
type: String,
|
|
default: 'normal',
|
|
validator: function validator(value) {
|
|
return ['mini', 'small', 'normal', 'large'].indexOf(value) > -1;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 85 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
name: 'Sample',
|
|
props: ['author'],
|
|
data: function data() {
|
|
return {
|
|
name: 'World'
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 86 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
/**
|
|
* o2-switch
|
|
* @module components/switch
|
|
* @desc 开关
|
|
* @param {boolean} [checked=false] - 开关状态
|
|
* @param {boolean} [disabled=false] - 禁用
|
|
* @param {boolean} [loading=false] - loading状态
|
|
* @param {callback} [onChange] - 开关状态改变回调函数。
|
|
*
|
|
* @example
|
|
* <o2-switch checked="true" disabled="false"></o2-switch>
|
|
*/
|
|
exports.default = {
|
|
name: 'o2-switch',
|
|
props: {
|
|
checked: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
disabled: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
loading: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
onChange: {
|
|
type: Function,
|
|
default: function _default() {}
|
|
}
|
|
},
|
|
computed: {
|
|
switchState: function switchState() {
|
|
if (this.disabled) {
|
|
return 'disabled';
|
|
} else if (this.loading) {
|
|
return 'loading';
|
|
} else if (this.checked) {
|
|
return 'on';
|
|
} else {
|
|
return 'off';
|
|
}
|
|
}
|
|
},
|
|
methods: {
|
|
/*
|
|
* 开关状态交互。
|
|
*/
|
|
toggleState: function toggleState() {
|
|
if (this.disabled || this.loading) return;
|
|
this.onChange(!this.checked);
|
|
},
|
|
|
|
/*
|
|
*
|
|
*/
|
|
getState: function getState() {
|
|
return this.checked;
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 87 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _button = __webpack_require__(197);
|
|
|
|
var _button2 = _interopRequireDefault(_button);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = _button2.default;
|
|
|
|
/***/ }),
|
|
/* 88 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _main = __webpack_require__(198);
|
|
|
|
var _main2 = _interopRequireDefault(_main);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = _main2.default;
|
|
|
|
/***/ }),
|
|
/* 89 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _switch = __webpack_require__(199);
|
|
|
|
var _switch2 = _interopRequireDefault(_switch);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = _switch2.default;
|
|
|
|
/***/ }),
|
|
/* 90 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(4)();
|
|
// imports
|
|
|
|
|
|
// module
|
|
exports.push([module.i, "a,abbr,acronym,address,applet,article,aside,audio,b,big,blockquote,body,canvas,caption,center,cite,code,dd,del,details,dfn,div,dl,dt,em,embed,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,header,hgroup,html,i,iframe,img,ins,kbd,label,legend,li,mark,menu,nav,object,ol,output,p,pre,q,ruby,s,samp,section,small,span,strike,strong,sub,summary,sup,table,tbody,td,tfoot,th,thead,time,tr,tt,u,ul,var,video{margin:0;padding:0;border:0;font-size:100%;vertical-align:baseline}body{font-family:Helvetica Neue,Helvetica,PingFang SC,Hiragino Sans GB,Microsoft YaHei,SimSun,sans-serif;overflow:auto;font-weight:400;-webkit-font-smoothing:antialiased}a{color:#4078c0;text-decoration:none}button,input,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit;color:inherit}ul{list-style:none}.hljs{line-height:1.8;font-family:Menlo,Monaco,Consolas,Courier,monospace;font-size:12px;padding:18px 24px;background-color:#f9fafc;border:1px solid #eaeefb;margin-bottom:25px;border-radius:4px;-webkit-font-smoothing:auto}@font-face{font-family:handle;src:url(" + __webpack_require__(53) + ");src:url(" + __webpack_require__(53) + "?#iefix) format(\"embedded-opentype\"),url(" + __webpack_require__(196) + ") format(\"woff\"),url(" + __webpack_require__(195) + ") format(\"truetype\"),url(" + __webpack_require__(194) + "#iconfont) format(\"svg\")}.iconhandle{font-family:handle;font-size:16px;font-style:normal}", ""]);
|
|
|
|
// exports
|
|
|
|
|
|
/***/ }),
|
|
/* 91 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(4)();
|
|
// imports
|
|
|
|
|
|
// module
|
|
exports.push([module.i, ".o2-button{position:relative;display:block;height:45px;border-radius:4px;border:0;box-sizing:border-box;font-size:16px;text-align:center;-webkit-appearance:none;-moz-appearance:none;appearance:none;outline:0;overflow:hidden}.o2-button:after{content:\" \";top:0;right:0;bottom:0;left:0;position:absolute;background-color:#000;opacity:0}.o2-button:not(.is-disabled):active:after{opacity:.3}.o2-button.is-disabled{opacity:.6}.o2-button--default{color:#fff;background-color:#4b0}.o2-button--primary{color:#333;background-color:#fff}.o2-button--danger{color:#fff;background-color:#f44}.o2-button--large{display:block;width:100%}.o2-button--normal,.o2-button--small{display:inline-block;padding:0 12px}.o2-button--small{font-size:14px;height:33px}.o2-switch{height:29px;width:49px;display:inline-block;border-radius:16px;position:relative;border:1px solid}.o2-switch.is-disabled{background-color:#f2f2f2;border-color:rgba(0,0,0,.1)}.o2-switch.is-off{background-color:#fff;border-color:rgba(0,0,0,.1)}.o2-switch.is-on{background-color:#44db5e;border-color:#44db5e}.o2-switch-node{width:27px;height:27px;border-radius:100%;background-color:#fff;border:.5px solid rgba(0,0,0,.1);position:absolute;box-shadow:0 3px 1px 0 rgba(0,0,0,.05),0 2px 2px 0 rgba(0,0,0,.1),0 3px 3px 0 rgba(0,0,0,.05)}.o2-switch-node.is-off{right:0}.o2-switch-node.is-on{left:0}", ""]);
|
|
|
|
// exports
|
|
|
|
|
|
/***/ }),
|
|
/* 92 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(4)();
|
|
// imports
|
|
|
|
|
|
// module
|
|
exports.push([module.i, ".side-nav{width:25%;box-sizing:border-box;padding-right:30px;float:left}.side-nav li{list-style:none}.side-nav ul{padding:0;margin:0;overflow:hidden}.side-nav .nav-item a{font-size:16px;color:#5e6d82;line-height:40px;height:40px;margin:0;padding:0;text-decoration:none;display:block;position:relative;-webkit-transition:all .3s;transition:all .3s}.side-nav .nav-item a.active{color:#20a0ff}.side-nav .nav-item .nav-item a{display:block;height:40px;line-height:40px;font-size:13px;padding-left:24px}.side-nav .nav-item .nav-item a:hover{color:#20a0ff}.side-nav .nav-group__title{font-size:12px;color:#99a9bf;padding-left:8px;line-height:26px;margin-top:10px}", ""]);
|
|
|
|
// exports
|
|
|
|
|
|
/***/ }),
|
|
/* 93 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(4)();
|
|
// imports
|
|
|
|
|
|
// module
|
|
exports.push([module.i, ".page-container{width:1140px;padding:0 30px;margin:0 auto}.page-container h2{font-size:28px;color:#1f2d3d;margin:20px 0;line-height:40px}.page-container h3{font-size:22px;margin:23px 0}.page-container h2,.page-container h3,.page-container h4,.page-container h5{font-weight:400;color:#1f2f3d}.page-container h2:hover a,.page-container h3:hover a,.page-container h4:hover a,.page-container h5:hover a{opacity:.4}.page-container h2 a,.page-container h3 a,.page-container h4 a,.page-container h5 a{float:left;margin-left:-20px;opacity:0;cursor:pointer}.page-container h2 a:hover,.page-container h3 a:hover,.page-container h4 a:hover,.page-container h5 a:hover{opacity:.4}.page-container p{font-size:14px;color:#5e6d82;margin:14px 0}.page-content{width:75%;float:left}.table{border-collapse:collapse;width:100%;background-color:#fff;color:#5e6d82;font-size:14px;margin-bottom:45px}.table th:first-child{padding-left:10px}.table th{text-align:left;border-top:1px solid #eaeefb;background-color:#eff2f7}.table td,.table th{border-bottom:1px solid #eaeefb;padding:10px}", ""]);
|
|
|
|
// exports
|
|
|
|
|
|
/***/ }),
|
|
/* 94 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(4)();
|
|
// imports
|
|
|
|
|
|
// module
|
|
exports.push([module.i, ".demo-block{border:1px solid #eaeefb;border-radius:4px;-webkit-transition:.2s;transition:.2s}.demo-block.hover{box-shadow:0 0 8px 0 rgba(232,237,250,.6),0 2px 4px 0 rgba(232,237,250,.5)}.demo-block code{font-family:Menlo,Monaco,Consolas,Courier,monospace}.demo-block p{margin:0}.demo-block .demo-button{float:right}.demo-block .source{padding:24px}.demo-block .meta{background-color:#f9fafc;border-top:1px solid #eaeefb;clear:both;overflow:hidden;height:0;-webkit-transition:height .2s;transition:height .2s}.demo-block .description{padding:18px 24px;width:40%;box-sizing:border-box;border-left:1px solid #eaeefb;float:right;font-size:14px;line-height:1.8;color:#5e6d82;word-break:break-word}.demo-block .description p{margin:0 0 12px}.demo-block .description code{color:#5e6d82;background-color:#e6effb;margin:0 4px;-webkit-transform:translateY(-2px);transform:translateY(-2px);display:inline-block;padding:1px 5px;font-size:12px;border-radius:3px}.demo-block .highlight{width:60%;border-right:1px solid #eaeefb}.demo-block .highlight pre{margin:0}.demo-block .highlight code.hljs{margin:0;border:none;max-height:none;border-radius:0}.demo-block .highlight code.hljs:before{content:none}.demo-block .demo-block-control{border-top:1px solid #eaeefb;height:36px;box-sizing:border-box;background-color:#fff;border-bottom-left-radius:4px;border-bottom-right-radius:4px;text-align:center;margin-top:-1px;color:#d3dce6;cursor:pointer;-webkit-transition:.2s;transition:.2s;position:relative}.demo-block .demo-block-control i{font-size:12px;line-height:36px;-webkit-transition:.3s;transition:.3s}.demo-block .demo-block-control i.hovering{-webkit-transform:translateX(-40px);transform:translateX(-40px)}.demo-block .demo-block-control span{position:absolute;-webkit-transform:translateX(-30px);transform:translateX(-30px);font-size:14px;line-height:36px;-webkit-transition:.3s;transition:.3s;display:inline-block}.demo-block .demo-block-control:hover{color:#20a0ff;background-color:#f9fafc}.demo-block .demo-block-control .text-slide-enter,.demo-block .demo-block-control .text-slide-leave-active{opacity:0;-webkit-transform:translateX(10px);transform:translateX(10px)}", ""]);
|
|
|
|
// exports
|
|
|
|
|
|
/***/ }),
|
|
/* 95 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(4)();
|
|
// imports
|
|
|
|
|
|
// module
|
|
exports.push([module.i, ".hljs{display:block;overflow-x:auto;padding:.5em;background:#fff}.hljs,.hljs-subst{color:#000}.hljs-addition,.hljs-meta,.hljs-string,.hljs-symbol,.hljs-template-tag,.hljs-template-variable{color:#756bb1}.hljs-comment,.hljs-quote{color:#636363}.hljs-bullet,.hljs-link,.hljs-literal,.hljs-number,.hljs-regexp{color:#31a354}.hljs-deletion,.hljs-variable{color:#88f}.hljs-built_in,.hljs-doctag,.hljs-keyword,.hljs-name,.hljs-section,.hljs-selector-class,.hljs-selector-id,.hljs-selector-tag,.hljs-strong,.hljs-tag,.hljs-title,.hljs-type{color:#3182bd}.hljs-emphasis{font-style:italic}.hljs-attribute{color:#e6550d}", ""]);
|
|
|
|
// exports
|
|
|
|
|
|
/***/ }),
|
|
/* 96 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
// This file can be required in Browserify and Node.js for automatic polyfill
|
|
// To use it: require('es6-promise/auto');
|
|
|
|
module.exports = __webpack_require__(97).polyfill();
|
|
|
|
|
|
/***/ }),
|
|
/* 97 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(process, global) {var require;/*!
|
|
* @overview es6-promise - a tiny implementation of Promises/A+.
|
|
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
|
|
* @license Licensed under MIT license
|
|
* See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
|
|
* @version 4.0.5
|
|
*/
|
|
|
|
(function (global, factory) {
|
|
true ? module.exports = factory() :
|
|
typeof define === 'function' && define.amd ? define(factory) :
|
|
(global.ES6Promise = factory());
|
|
}(this, (function () { 'use strict';
|
|
|
|
function objectOrFunction(x) {
|
|
return typeof x === 'function' || typeof x === 'object' && x !== null;
|
|
}
|
|
|
|
function isFunction(x) {
|
|
return typeof x === 'function';
|
|
}
|
|
|
|
var _isArray = undefined;
|
|
if (!Array.isArray) {
|
|
_isArray = function (x) {
|
|
return Object.prototype.toString.call(x) === '[object Array]';
|
|
};
|
|
} else {
|
|
_isArray = Array.isArray;
|
|
}
|
|
|
|
var isArray = _isArray;
|
|
|
|
var len = 0;
|
|
var vertxNext = undefined;
|
|
var customSchedulerFn = undefined;
|
|
|
|
var asap = function asap(callback, arg) {
|
|
queue[len] = callback;
|
|
queue[len + 1] = arg;
|
|
len += 2;
|
|
if (len === 2) {
|
|
// If len is 2, that means that we need to schedule an async flush.
|
|
// If additional callbacks are queued before the queue is flushed, they
|
|
// will be processed by this flush that we are scheduling.
|
|
if (customSchedulerFn) {
|
|
customSchedulerFn(flush);
|
|
} else {
|
|
scheduleFlush();
|
|
}
|
|
}
|
|
};
|
|
|
|
function setScheduler(scheduleFn) {
|
|
customSchedulerFn = scheduleFn;
|
|
}
|
|
|
|
function setAsap(asapFn) {
|
|
asap = asapFn;
|
|
}
|
|
|
|
var browserWindow = typeof window !== 'undefined' ? window : undefined;
|
|
var browserGlobal = browserWindow || {};
|
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
|
var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && ({}).toString.call(process) === '[object process]';
|
|
|
|
// test for web worker but not in IE10
|
|
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
|
|
|
|
// node
|
|
function useNextTick() {
|
|
// node version 0.10.x displays a deprecation warning when nextTick is used recursively
|
|
// see https://github.com/cujojs/when/issues/410 for details
|
|
return function () {
|
|
return process.nextTick(flush);
|
|
};
|
|
}
|
|
|
|
// vertx
|
|
function useVertxTimer() {
|
|
if (typeof vertxNext !== 'undefined') {
|
|
return function () {
|
|
vertxNext(flush);
|
|
};
|
|
}
|
|
|
|
return useSetTimeout();
|
|
}
|
|
|
|
function useMutationObserver() {
|
|
var iterations = 0;
|
|
var observer = new BrowserMutationObserver(flush);
|
|
var node = document.createTextNode('');
|
|
observer.observe(node, { characterData: true });
|
|
|
|
return function () {
|
|
node.data = iterations = ++iterations % 2;
|
|
};
|
|
}
|
|
|
|
// web worker
|
|
function useMessageChannel() {
|
|
var channel = new MessageChannel();
|
|
channel.port1.onmessage = flush;
|
|
return function () {
|
|
return channel.port2.postMessage(0);
|
|
};
|
|
}
|
|
|
|
function useSetTimeout() {
|
|
// Store setTimeout reference so es6-promise will be unaffected by
|
|
// other code modifying setTimeout (like sinon.useFakeTimers())
|
|
var globalSetTimeout = setTimeout;
|
|
return function () {
|
|
return globalSetTimeout(flush, 1);
|
|
};
|
|
}
|
|
|
|
var queue = new Array(1000);
|
|
function flush() {
|
|
for (var i = 0; i < len; i += 2) {
|
|
var callback = queue[i];
|
|
var arg = queue[i + 1];
|
|
|
|
callback(arg);
|
|
|
|
queue[i] = undefined;
|
|
queue[i + 1] = undefined;
|
|
}
|
|
|
|
len = 0;
|
|
}
|
|
|
|
function attemptVertx() {
|
|
try {
|
|
var r = require;
|
|
var vertx = __webpack_require__(210);
|
|
vertxNext = vertx.runOnLoop || vertx.runOnContext;
|
|
return useVertxTimer();
|
|
} catch (e) {
|
|
return useSetTimeout();
|
|
}
|
|
}
|
|
|
|
var scheduleFlush = undefined;
|
|
// Decide what async method to use to triggering processing of queued callbacks:
|
|
if (isNode) {
|
|
scheduleFlush = useNextTick();
|
|
} else if (BrowserMutationObserver) {
|
|
scheduleFlush = useMutationObserver();
|
|
} else if (isWorker) {
|
|
scheduleFlush = useMessageChannel();
|
|
} else if (browserWindow === undefined && "function" === 'function') {
|
|
scheduleFlush = attemptVertx();
|
|
} else {
|
|
scheduleFlush = useSetTimeout();
|
|
}
|
|
|
|
function then(onFulfillment, onRejection) {
|
|
var _arguments = arguments;
|
|
|
|
var parent = this;
|
|
|
|
var child = new this.constructor(noop);
|
|
|
|
if (child[PROMISE_ID] === undefined) {
|
|
makePromise(child);
|
|
}
|
|
|
|
var _state = parent._state;
|
|
|
|
if (_state) {
|
|
(function () {
|
|
var callback = _arguments[_state - 1];
|
|
asap(function () {
|
|
return invokeCallback(_state, child, callback, parent._result);
|
|
});
|
|
})();
|
|
} else {
|
|
subscribe(parent, child, onFulfillment, onRejection);
|
|
}
|
|
|
|
return child;
|
|
}
|
|
|
|
/**
|
|
`Promise.resolve` returns a promise that will become resolved with the
|
|
passed `value`. It is shorthand for the following:
|
|
|
|
```javascript
|
|
let promise = new Promise(function(resolve, reject){
|
|
resolve(1);
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
let promise = Promise.resolve(1);
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
@method resolve
|
|
@static
|
|
@param {Any} value value that the returned promise will be resolved with
|
|
Useful for tooling.
|
|
@return {Promise} a promise that will become fulfilled with the given
|
|
`value`
|
|
*/
|
|
function resolve(object) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
if (object && typeof object === 'object' && object.constructor === Constructor) {
|
|
return object;
|
|
}
|
|
|
|
var promise = new Constructor(noop);
|
|
_resolve(promise, object);
|
|
return promise;
|
|
}
|
|
|
|
var PROMISE_ID = Math.random().toString(36).substring(16);
|
|
|
|
function noop() {}
|
|
|
|
var PENDING = void 0;
|
|
var FULFILLED = 1;
|
|
var REJECTED = 2;
|
|
|
|
var GET_THEN_ERROR = new ErrorObject();
|
|
|
|
function selfFulfillment() {
|
|
return new TypeError("You cannot resolve a promise with itself");
|
|
}
|
|
|
|
function cannotReturnOwn() {
|
|
return new TypeError('A promises callback cannot return that same promise.');
|
|
}
|
|
|
|
function getThen(promise) {
|
|
try {
|
|
return promise.then;
|
|
} catch (error) {
|
|
GET_THEN_ERROR.error = error;
|
|
return GET_THEN_ERROR;
|
|
}
|
|
}
|
|
|
|
function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
|
|
try {
|
|
then.call(value, fulfillmentHandler, rejectionHandler);
|
|
} catch (e) {
|
|
return e;
|
|
}
|
|
}
|
|
|
|
function handleForeignThenable(promise, thenable, then) {
|
|
asap(function (promise) {
|
|
var sealed = false;
|
|
var error = tryThen(then, thenable, function (value) {
|
|
if (sealed) {
|
|
return;
|
|
}
|
|
sealed = true;
|
|
if (thenable !== value) {
|
|
_resolve(promise, value);
|
|
} else {
|
|
fulfill(promise, value);
|
|
}
|
|
}, function (reason) {
|
|
if (sealed) {
|
|
return;
|
|
}
|
|
sealed = true;
|
|
|
|
_reject(promise, reason);
|
|
}, 'Settle: ' + (promise._label || ' unknown promise'));
|
|
|
|
if (!sealed && error) {
|
|
sealed = true;
|
|
_reject(promise, error);
|
|
}
|
|
}, promise);
|
|
}
|
|
|
|
function handleOwnThenable(promise, thenable) {
|
|
if (thenable._state === FULFILLED) {
|
|
fulfill(promise, thenable._result);
|
|
} else if (thenable._state === REJECTED) {
|
|
_reject(promise, thenable._result);
|
|
} else {
|
|
subscribe(thenable, undefined, function (value) {
|
|
return _resolve(promise, value);
|
|
}, function (reason) {
|
|
return _reject(promise, reason);
|
|
});
|
|
}
|
|
}
|
|
|
|
function handleMaybeThenable(promise, maybeThenable, then$$) {
|
|
if (maybeThenable.constructor === promise.constructor && then$$ === then && maybeThenable.constructor.resolve === resolve) {
|
|
handleOwnThenable(promise, maybeThenable);
|
|
} else {
|
|
if (then$$ === GET_THEN_ERROR) {
|
|
_reject(promise, GET_THEN_ERROR.error);
|
|
} else if (then$$ === undefined) {
|
|
fulfill(promise, maybeThenable);
|
|
} else if (isFunction(then$$)) {
|
|
handleForeignThenable(promise, maybeThenable, then$$);
|
|
} else {
|
|
fulfill(promise, maybeThenable);
|
|
}
|
|
}
|
|
}
|
|
|
|
function _resolve(promise, value) {
|
|
if (promise === value) {
|
|
_reject(promise, selfFulfillment());
|
|
} else if (objectOrFunction(value)) {
|
|
handleMaybeThenable(promise, value, getThen(value));
|
|
} else {
|
|
fulfill(promise, value);
|
|
}
|
|
}
|
|
|
|
function publishRejection(promise) {
|
|
if (promise._onerror) {
|
|
promise._onerror(promise._result);
|
|
}
|
|
|
|
publish(promise);
|
|
}
|
|
|
|
function fulfill(promise, value) {
|
|
if (promise._state !== PENDING) {
|
|
return;
|
|
}
|
|
|
|
promise._result = value;
|
|
promise._state = FULFILLED;
|
|
|
|
if (promise._subscribers.length !== 0) {
|
|
asap(publish, promise);
|
|
}
|
|
}
|
|
|
|
function _reject(promise, reason) {
|
|
if (promise._state !== PENDING) {
|
|
return;
|
|
}
|
|
promise._state = REJECTED;
|
|
promise._result = reason;
|
|
|
|
asap(publishRejection, promise);
|
|
}
|
|
|
|
function subscribe(parent, child, onFulfillment, onRejection) {
|
|
var _subscribers = parent._subscribers;
|
|
var length = _subscribers.length;
|
|
|
|
parent._onerror = null;
|
|
|
|
_subscribers[length] = child;
|
|
_subscribers[length + FULFILLED] = onFulfillment;
|
|
_subscribers[length + REJECTED] = onRejection;
|
|
|
|
if (length === 0 && parent._state) {
|
|
asap(publish, parent);
|
|
}
|
|
}
|
|
|
|
function publish(promise) {
|
|
var subscribers = promise._subscribers;
|
|
var settled = promise._state;
|
|
|
|
if (subscribers.length === 0) {
|
|
return;
|
|
}
|
|
|
|
var child = undefined,
|
|
callback = undefined,
|
|
detail = promise._result;
|
|
|
|
for (var i = 0; i < subscribers.length; i += 3) {
|
|
child = subscribers[i];
|
|
callback = subscribers[i + settled];
|
|
|
|
if (child) {
|
|
invokeCallback(settled, child, callback, detail);
|
|
} else {
|
|
callback(detail);
|
|
}
|
|
}
|
|
|
|
promise._subscribers.length = 0;
|
|
}
|
|
|
|
function ErrorObject() {
|
|
this.error = null;
|
|
}
|
|
|
|
var TRY_CATCH_ERROR = new ErrorObject();
|
|
|
|
function tryCatch(callback, detail) {
|
|
try {
|
|
return callback(detail);
|
|
} catch (e) {
|
|
TRY_CATCH_ERROR.error = e;
|
|
return TRY_CATCH_ERROR;
|
|
}
|
|
}
|
|
|
|
function invokeCallback(settled, promise, callback, detail) {
|
|
var hasCallback = isFunction(callback),
|
|
value = undefined,
|
|
error = undefined,
|
|
succeeded = undefined,
|
|
failed = undefined;
|
|
|
|
if (hasCallback) {
|
|
value = tryCatch(callback, detail);
|
|
|
|
if (value === TRY_CATCH_ERROR) {
|
|
failed = true;
|
|
error = value.error;
|
|
value = null;
|
|
} else {
|
|
succeeded = true;
|
|
}
|
|
|
|
if (promise === value) {
|
|
_reject(promise, cannotReturnOwn());
|
|
return;
|
|
}
|
|
} else {
|
|
value = detail;
|
|
succeeded = true;
|
|
}
|
|
|
|
if (promise._state !== PENDING) {
|
|
// noop
|
|
} else if (hasCallback && succeeded) {
|
|
_resolve(promise, value);
|
|
} else if (failed) {
|
|
_reject(promise, error);
|
|
} else if (settled === FULFILLED) {
|
|
fulfill(promise, value);
|
|
} else if (settled === REJECTED) {
|
|
_reject(promise, value);
|
|
}
|
|
}
|
|
|
|
function initializePromise(promise, resolver) {
|
|
try {
|
|
resolver(function resolvePromise(value) {
|
|
_resolve(promise, value);
|
|
}, function rejectPromise(reason) {
|
|
_reject(promise, reason);
|
|
});
|
|
} catch (e) {
|
|
_reject(promise, e);
|
|
}
|
|
}
|
|
|
|
var id = 0;
|
|
function nextId() {
|
|
return id++;
|
|
}
|
|
|
|
function makePromise(promise) {
|
|
promise[PROMISE_ID] = id++;
|
|
promise._state = undefined;
|
|
promise._result = undefined;
|
|
promise._subscribers = [];
|
|
}
|
|
|
|
function Enumerator(Constructor, input) {
|
|
this._instanceConstructor = Constructor;
|
|
this.promise = new Constructor(noop);
|
|
|
|
if (!this.promise[PROMISE_ID]) {
|
|
makePromise(this.promise);
|
|
}
|
|
|
|
if (isArray(input)) {
|
|
this._input = input;
|
|
this.length = input.length;
|
|
this._remaining = input.length;
|
|
|
|
this._result = new Array(this.length);
|
|
|
|
if (this.length === 0) {
|
|
fulfill(this.promise, this._result);
|
|
} else {
|
|
this.length = this.length || 0;
|
|
this._enumerate();
|
|
if (this._remaining === 0) {
|
|
fulfill(this.promise, this._result);
|
|
}
|
|
}
|
|
} else {
|
|
_reject(this.promise, validationError());
|
|
}
|
|
}
|
|
|
|
function validationError() {
|
|
return new Error('Array Methods must be provided an Array');
|
|
};
|
|
|
|
Enumerator.prototype._enumerate = function () {
|
|
var length = this.length;
|
|
var _input = this._input;
|
|
|
|
for (var i = 0; this._state === PENDING && i < length; i++) {
|
|
this._eachEntry(_input[i], i);
|
|
}
|
|
};
|
|
|
|
Enumerator.prototype._eachEntry = function (entry, i) {
|
|
var c = this._instanceConstructor;
|
|
var resolve$$ = c.resolve;
|
|
|
|
if (resolve$$ === resolve) {
|
|
var _then = getThen(entry);
|
|
|
|
if (_then === then && entry._state !== PENDING) {
|
|
this._settledAt(entry._state, i, entry._result);
|
|
} else if (typeof _then !== 'function') {
|
|
this._remaining--;
|
|
this._result[i] = entry;
|
|
} else if (c === Promise) {
|
|
var promise = new c(noop);
|
|
handleMaybeThenable(promise, entry, _then);
|
|
this._willSettleAt(promise, i);
|
|
} else {
|
|
this._willSettleAt(new c(function (resolve$$) {
|
|
return resolve$$(entry);
|
|
}), i);
|
|
}
|
|
} else {
|
|
this._willSettleAt(resolve$$(entry), i);
|
|
}
|
|
};
|
|
|
|
Enumerator.prototype._settledAt = function (state, i, value) {
|
|
var promise = this.promise;
|
|
|
|
if (promise._state === PENDING) {
|
|
this._remaining--;
|
|
|
|
if (state === REJECTED) {
|
|
_reject(promise, value);
|
|
} else {
|
|
this._result[i] = value;
|
|
}
|
|
}
|
|
|
|
if (this._remaining === 0) {
|
|
fulfill(promise, this._result);
|
|
}
|
|
};
|
|
|
|
Enumerator.prototype._willSettleAt = function (promise, i) {
|
|
var enumerator = this;
|
|
|
|
subscribe(promise, undefined, function (value) {
|
|
return enumerator._settledAt(FULFILLED, i, value);
|
|
}, function (reason) {
|
|
return enumerator._settledAt(REJECTED, i, reason);
|
|
});
|
|
};
|
|
|
|
/**
|
|
`Promise.all` accepts an array of promises, and returns a new promise which
|
|
is fulfilled with an array of fulfillment values for the passed promises, or
|
|
rejected with the reason of the first passed promise to be rejected. It casts all
|
|
elements of the passed iterable to promises as it runs this algorithm.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = resolve(1);
|
|
let promise2 = resolve(2);
|
|
let promise3 = resolve(3);
|
|
let promises = [ promise1, promise2, promise3 ];
|
|
|
|
Promise.all(promises).then(function(array){
|
|
// The array here would be [ 1, 2, 3 ];
|
|
});
|
|
```
|
|
|
|
If any of the `promises` given to `all` are rejected, the first promise
|
|
that is rejected will be given as an argument to the returned promises's
|
|
rejection handler. For example:
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = resolve(1);
|
|
let promise2 = reject(new Error("2"));
|
|
let promise3 = reject(new Error("3"));
|
|
let promises = [ promise1, promise2, promise3 ];
|
|
|
|
Promise.all(promises).then(function(array){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(error) {
|
|
// error.message === "2"
|
|
});
|
|
```
|
|
|
|
@method all
|
|
@static
|
|
@param {Array} entries array of promises
|
|
@param {String} label optional string for labeling the promise.
|
|
Useful for tooling.
|
|
@return {Promise} promise that is fulfilled when all `promises` have been
|
|
fulfilled, or rejected if any of them become rejected.
|
|
@static
|
|
*/
|
|
function all(entries) {
|
|
return new Enumerator(this, entries).promise;
|
|
}
|
|
|
|
/**
|
|
`Promise.race` returns a new promise which is settled in the same way as the
|
|
first passed promise to settle.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 1');
|
|
}, 200);
|
|
});
|
|
|
|
let promise2 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 2');
|
|
}, 100);
|
|
});
|
|
|
|
Promise.race([promise1, promise2]).then(function(result){
|
|
// result === 'promise 2' because it was resolved before promise1
|
|
// was resolved.
|
|
});
|
|
```
|
|
|
|
`Promise.race` is deterministic in that only the state of the first
|
|
settled promise matters. For example, even if other promises given to the
|
|
`promises` array argument are resolved, but the first settled promise has
|
|
become rejected before the other promises became fulfilled, the returned
|
|
promise will become rejected:
|
|
|
|
```javascript
|
|
let promise1 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 1');
|
|
}, 200);
|
|
});
|
|
|
|
let promise2 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
reject(new Error('promise 2'));
|
|
}, 100);
|
|
});
|
|
|
|
Promise.race([promise1, promise2]).then(function(result){
|
|
// Code here never runs
|
|
}, function(reason){
|
|
// reason.message === 'promise 2' because promise 2 became rejected before
|
|
// promise 1 became fulfilled
|
|
});
|
|
```
|
|
|
|
An example real-world use case is implementing timeouts:
|
|
|
|
```javascript
|
|
Promise.race([ajax('foo.json'), timeout(5000)])
|
|
```
|
|
|
|
@method race
|
|
@static
|
|
@param {Array} promises array of promises to observe
|
|
Useful for tooling.
|
|
@return {Promise} a promise which settles in the same way as the first passed
|
|
promise to settle.
|
|
*/
|
|
function race(entries) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
if (!isArray(entries)) {
|
|
return new Constructor(function (_, reject) {
|
|
return reject(new TypeError('You must pass an array to race.'));
|
|
});
|
|
} else {
|
|
return new Constructor(function (resolve, reject) {
|
|
var length = entries.length;
|
|
for (var i = 0; i < length; i++) {
|
|
Constructor.resolve(entries[i]).then(resolve, reject);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
`Promise.reject` returns a promise rejected with the passed `reason`.
|
|
It is shorthand for the following:
|
|
|
|
```javascript
|
|
let promise = new Promise(function(resolve, reject){
|
|
reject(new Error('WHOOPS'));
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
let promise = Promise.reject(new Error('WHOOPS'));
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
@method reject
|
|
@static
|
|
@param {Any} reason value that the returned promise will be rejected with.
|
|
Useful for tooling.
|
|
@return {Promise} a promise rejected with the given `reason`.
|
|
*/
|
|
function reject(reason) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
var promise = new Constructor(noop);
|
|
_reject(promise, reason);
|
|
return promise;
|
|
}
|
|
|
|
function needsResolver() {
|
|
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
|
|
}
|
|
|
|
function needsNew() {
|
|
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
|
|
}
|
|
|
|
/**
|
|
Promise objects represent the eventual result of an asynchronous operation. The
|
|
primary way of interacting with a promise is through its `then` method, which
|
|
registers callbacks to receive either a promise's eventual value or the reason
|
|
why the promise cannot be fulfilled.
|
|
|
|
Terminology
|
|
-----------
|
|
|
|
- `promise` is an object or function with a `then` method whose behavior conforms to this specification.
|
|
- `thenable` is an object or function that defines a `then` method.
|
|
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
|
|
- `exception` is a value that is thrown using the throw statement.
|
|
- `reason` is a value that indicates why a promise was rejected.
|
|
- `settled` the final resting state of a promise, fulfilled or rejected.
|
|
|
|
A promise can be in one of three states: pending, fulfilled, or rejected.
|
|
|
|
Promises that are fulfilled have a fulfillment value and are in the fulfilled
|
|
state. Promises that are rejected have a rejection reason and are in the
|
|
rejected state. A fulfillment value is never a thenable.
|
|
|
|
Promises can also be said to *resolve* a value. If this value is also a
|
|
promise, then the original promise's settled state will match the value's
|
|
settled state. So a promise that *resolves* a promise that rejects will
|
|
itself reject, and a promise that *resolves* a promise that fulfills will
|
|
itself fulfill.
|
|
|
|
|
|
Basic Usage:
|
|
------------
|
|
|
|
```js
|
|
let promise = new Promise(function(resolve, reject) {
|
|
// on success
|
|
resolve(value);
|
|
|
|
// on failure
|
|
reject(reason);
|
|
});
|
|
|
|
promise.then(function(value) {
|
|
// on fulfillment
|
|
}, function(reason) {
|
|
// on rejection
|
|
});
|
|
```
|
|
|
|
Advanced Usage:
|
|
---------------
|
|
|
|
Promises shine when abstracting away asynchronous interactions such as
|
|
`XMLHttpRequest`s.
|
|
|
|
```js
|
|
function getJSON(url) {
|
|
return new Promise(function(resolve, reject){
|
|
let xhr = new XMLHttpRequest();
|
|
|
|
xhr.open('GET', url);
|
|
xhr.onreadystatechange = handler;
|
|
xhr.responseType = 'json';
|
|
xhr.setRequestHeader('Accept', 'application/json');
|
|
xhr.send();
|
|
|
|
function handler() {
|
|
if (this.readyState === this.DONE) {
|
|
if (this.status === 200) {
|
|
resolve(this.response);
|
|
} else {
|
|
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
|
|
}
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
getJSON('/posts.json').then(function(json) {
|
|
// on fulfillment
|
|
}, function(reason) {
|
|
// on rejection
|
|
});
|
|
```
|
|
|
|
Unlike callbacks, promises are great composable primitives.
|
|
|
|
```js
|
|
Promise.all([
|
|
getJSON('/posts'),
|
|
getJSON('/comments')
|
|
]).then(function(values){
|
|
values[0] // => postsJSON
|
|
values[1] // => commentsJSON
|
|
|
|
return values;
|
|
});
|
|
```
|
|
|
|
@class Promise
|
|
@param {function} resolver
|
|
Useful for tooling.
|
|
@constructor
|
|
*/
|
|
function Promise(resolver) {
|
|
this[PROMISE_ID] = nextId();
|
|
this._result = this._state = undefined;
|
|
this._subscribers = [];
|
|
|
|
if (noop !== resolver) {
|
|
typeof resolver !== 'function' && needsResolver();
|
|
this instanceof Promise ? initializePromise(this, resolver) : needsNew();
|
|
}
|
|
}
|
|
|
|
Promise.all = all;
|
|
Promise.race = race;
|
|
Promise.resolve = resolve;
|
|
Promise.reject = reject;
|
|
Promise._setScheduler = setScheduler;
|
|
Promise._setAsap = setAsap;
|
|
Promise._asap = asap;
|
|
|
|
Promise.prototype = {
|
|
constructor: Promise,
|
|
|
|
/**
|
|
The primary way of interacting with a promise is through its `then` method,
|
|
which registers callbacks to receive either a promise's eventual value or the
|
|
reason why the promise cannot be fulfilled.
|
|
|
|
```js
|
|
findUser().then(function(user){
|
|
// user is available
|
|
}, function(reason){
|
|
// user is unavailable, and you are given the reason why
|
|
});
|
|
```
|
|
|
|
Chaining
|
|
--------
|
|
|
|
The return value of `then` is itself a promise. This second, 'downstream'
|
|
promise is resolved with the return value of the first promise's fulfillment
|
|
or rejection handler, or rejected if the handler throws an exception.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
return user.name;
|
|
}, function (reason) {
|
|
return 'default name';
|
|
}).then(function (userName) {
|
|
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
|
|
// will be `'default name'`
|
|
});
|
|
|
|
findUser().then(function (user) {
|
|
throw new Error('Found user, but still unhappy');
|
|
}, function (reason) {
|
|
throw new Error('`findUser` rejected and we're unhappy');
|
|
}).then(function (value) {
|
|
// never reached
|
|
}, function (reason) {
|
|
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
|
|
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
|
|
});
|
|
```
|
|
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
throw new PedagogicalException('Upstream error');
|
|
}).then(function (value) {
|
|
// never reached
|
|
}).then(function (value) {
|
|
// never reached
|
|
}, function (reason) {
|
|
// The `PedgagocialException` is propagated all the way down to here
|
|
});
|
|
```
|
|
|
|
Assimilation
|
|
------------
|
|
|
|
Sometimes the value you want to propagate to a downstream promise can only be
|
|
retrieved asynchronously. This can be achieved by returning a promise in the
|
|
fulfillment or rejection handler. The downstream promise will then be pending
|
|
until the returned promise is settled. This is called *assimilation*.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
return findCommentsByAuthor(user);
|
|
}).then(function (comments) {
|
|
// The user's comments are now available
|
|
});
|
|
```
|
|
|
|
If the assimliated promise rejects, then the downstream promise will also reject.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
return findCommentsByAuthor(user);
|
|
}).then(function (comments) {
|
|
// If `findCommentsByAuthor` fulfills, we'll have the value here
|
|
}, function (reason) {
|
|
// If `findCommentsByAuthor` rejects, we'll have the reason here
|
|
});
|
|
```
|
|
|
|
Simple Example
|
|
--------------
|
|
|
|
Synchronous Example
|
|
|
|
```javascript
|
|
let result;
|
|
|
|
try {
|
|
result = findResult();
|
|
// success
|
|
} catch(reason) {
|
|
// failure
|
|
}
|
|
```
|
|
|
|
Errback Example
|
|
|
|
```js
|
|
findResult(function(result, err){
|
|
if (err) {
|
|
// failure
|
|
} else {
|
|
// success
|
|
}
|
|
});
|
|
```
|
|
|
|
Promise Example;
|
|
|
|
```javascript
|
|
findResult().then(function(result){
|
|
// success
|
|
}, function(reason){
|
|
// failure
|
|
});
|
|
```
|
|
|
|
Advanced Example
|
|
--------------
|
|
|
|
Synchronous Example
|
|
|
|
```javascript
|
|
let author, books;
|
|
|
|
try {
|
|
author = findAuthor();
|
|
books = findBooksByAuthor(author);
|
|
// success
|
|
} catch(reason) {
|
|
// failure
|
|
}
|
|
```
|
|
|
|
Errback Example
|
|
|
|
```js
|
|
|
|
function foundBooks(books) {
|
|
|
|
}
|
|
|
|
function failure(reason) {
|
|
|
|
}
|
|
|
|
findAuthor(function(author, err){
|
|
if (err) {
|
|
failure(err);
|
|
// failure
|
|
} else {
|
|
try {
|
|
findBoooksByAuthor(author, function(books, err) {
|
|
if (err) {
|
|
failure(err);
|
|
} else {
|
|
try {
|
|
foundBooks(books);
|
|
} catch(reason) {
|
|
failure(reason);
|
|
}
|
|
}
|
|
});
|
|
} catch(error) {
|
|
failure(err);
|
|
}
|
|
// success
|
|
}
|
|
});
|
|
```
|
|
|
|
Promise Example;
|
|
|
|
```javascript
|
|
findAuthor().
|
|
then(findBooksByAuthor).
|
|
then(function(books){
|
|
// found books
|
|
}).catch(function(reason){
|
|
// something went wrong
|
|
});
|
|
```
|
|
|
|
@method then
|
|
@param {Function} onFulfilled
|
|
@param {Function} onRejected
|
|
Useful for tooling.
|
|
@return {Promise}
|
|
*/
|
|
then: then,
|
|
|
|
/**
|
|
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
|
|
as the catch block of a try/catch statement.
|
|
|
|
```js
|
|
function findAuthor(){
|
|
throw new Error('couldn't find that author');
|
|
}
|
|
|
|
// synchronous
|
|
try {
|
|
findAuthor();
|
|
} catch(reason) {
|
|
// something went wrong
|
|
}
|
|
|
|
// async with promises
|
|
findAuthor().catch(function(reason){
|
|
// something went wrong
|
|
});
|
|
```
|
|
|
|
@method catch
|
|
@param {Function} onRejection
|
|
Useful for tooling.
|
|
@return {Promise}
|
|
*/
|
|
'catch': function _catch(onRejection) {
|
|
return this.then(null, onRejection);
|
|
}
|
|
};
|
|
|
|
function polyfill() {
|
|
var local = undefined;
|
|
|
|
if (typeof global !== 'undefined') {
|
|
local = global;
|
|
} else if (typeof self !== 'undefined') {
|
|
local = self;
|
|
} else {
|
|
try {
|
|
local = Function('return this')();
|
|
} catch (e) {
|
|
throw new Error('polyfill failed because global object is unavailable in this environment');
|
|
}
|
|
}
|
|
|
|
var P = local.Promise;
|
|
|
|
if (P) {
|
|
var promiseToString = null;
|
|
try {
|
|
promiseToString = Object.prototype.toString.call(P.resolve());
|
|
} catch (e) {
|
|
// silently ignored
|
|
}
|
|
|
|
if (promiseToString === '[object Promise]' && !P.cast) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
local.Promise = Promise;
|
|
}
|
|
|
|
// Strange compat..
|
|
Promise.polyfill = polyfill;
|
|
Promise.Promise = Promise;
|
|
|
|
return Promise;
|
|
|
|
})));
|
|
//# sourceMappingURL=es6-promise.map
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8), __webpack_require__(28)))
|
|
|
|
/***/ }),
|
|
/* 98 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getNative = __webpack_require__(5),
|
|
root = __webpack_require__(2);
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
var DataView = getNative(root, 'DataView');
|
|
|
|
module.exports = DataView;
|
|
|
|
|
|
/***/ }),
|
|
/* 99 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var hashClear = __webpack_require__(144),
|
|
hashDelete = __webpack_require__(145),
|
|
hashGet = __webpack_require__(146),
|
|
hashHas = __webpack_require__(147),
|
|
hashSet = __webpack_require__(148);
|
|
|
|
/**
|
|
* 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]);
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 100 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getNative = __webpack_require__(5),
|
|
root = __webpack_require__(2);
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
var Promise = getNative(root, 'Promise');
|
|
|
|
module.exports = Promise;
|
|
|
|
|
|
/***/ }),
|
|
/* 101 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getNative = __webpack_require__(5),
|
|
root = __webpack_require__(2);
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
var Set = getNative(root, 'Set');
|
|
|
|
module.exports = Set;
|
|
|
|
|
|
/***/ }),
|
|
/* 102 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var MapCache = __webpack_require__(23),
|
|
setCacheAdd = __webpack_require__(168),
|
|
setCacheHas = __webpack_require__(169);
|
|
|
|
/**
|
|
*
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 103 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var root = __webpack_require__(2);
|
|
|
|
/** Built-in value references. */
|
|
var Uint8Array = root.Uint8Array;
|
|
|
|
module.exports = Uint8Array;
|
|
|
|
|
|
/***/ }),
|
|
/* 104 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getNative = __webpack_require__(5),
|
|
root = __webpack_require__(2);
|
|
|
|
/* Built-in method references that are verified to be native. */
|
|
var WeakMap = getNative(root, 'WeakMap');
|
|
|
|
module.exports = WeakMap;
|
|
|
|
|
|
/***/ }),
|
|
/* 105 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 106 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseTimes = __webpack_require__(126),
|
|
isArguments = __webpack_require__(49),
|
|
isArray = __webpack_require__(1),
|
|
isBuffer = __webpack_require__(50),
|
|
isIndex = __webpack_require__(43),
|
|
isTypedArray = __webpack_require__(52);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 107 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 108 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 109 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseEach = __webpack_require__(24);
|
|
|
|
/**
|
|
* The base implementation of `_.filter` without support for iteratee shorthands.
|
|
*
|
|
* @private
|
|
* @param {Array|Object} collection The collection to iterate over.
|
|
* @param {Function} predicate The function invoked per iteration.
|
|
* @returns {Array} Returns the new filtered array.
|
|
*/
|
|
function baseFilter(collection, predicate) {
|
|
var result = [];
|
|
baseEach(collection, function(value, index, collection) {
|
|
if (predicate(value, index, collection)) {
|
|
result.push(value);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
module.exports = baseFilter;
|
|
|
|
|
|
/***/ }),
|
|
/* 110 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = baseFindIndex;
|
|
|
|
|
|
/***/ }),
|
|
/* 111 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var createBaseFor = __webpack_require__(133);
|
|
|
|
/**
|
|
* 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();
|
|
|
|
module.exports = baseFor;
|
|
|
|
|
|
/***/ }),
|
|
/* 112 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseFor = __webpack_require__(111),
|
|
keys = __webpack_require__(19);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 113 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var arrayPush = __webpack_require__(107),
|
|
isArray = __webpack_require__(1);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 114 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 115 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
isObjectLike = __webpack_require__(7);
|
|
|
|
/** `Object#toString` result references. */
|
|
var argsTag = '[object Arguments]';
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = baseIsArguments;
|
|
|
|
|
|
/***/ }),
|
|
/* 116 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Stack = __webpack_require__(35),
|
|
equalArrays = __webpack_require__(41),
|
|
equalByTag = __webpack_require__(135),
|
|
equalObjects = __webpack_require__(136),
|
|
getTag = __webpack_require__(141),
|
|
isArray = __webpack_require__(1),
|
|
isBuffer = __webpack_require__(50),
|
|
isTypedArray = __webpack_require__(52);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 117 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Stack = __webpack_require__(35),
|
|
baseIsEqual = __webpack_require__(39);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 118 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isFunction = __webpack_require__(51),
|
|
isMasked = __webpack_require__(150),
|
|
isObject = __webpack_require__(17),
|
|
toSource = __webpack_require__(46);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/** Used to detect if a method is native. */
|
|
var reIsNative = RegExp('^' +
|
|
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
|
);
|
|
|
|
/**
|
|
* 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));
|
|
}
|
|
|
|
module.exports = baseIsNative;
|
|
|
|
|
|
/***/ }),
|
|
/* 119 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGetTag = __webpack_require__(6),
|
|
isLength = __webpack_require__(26),
|
|
isObjectLike = __webpack_require__(7);
|
|
|
|
/** `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]',
|
|
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 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;
|
|
|
|
/**
|
|
* 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)];
|
|
}
|
|
|
|
module.exports = baseIsTypedArray;
|
|
|
|
|
|
/***/ }),
|
|
/* 120 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isPrototype = __webpack_require__(151),
|
|
nativeKeys = __webpack_require__(164);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 121 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseEach = __webpack_require__(24),
|
|
isArrayLike = __webpack_require__(16);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 122 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIsMatch = __webpack_require__(117),
|
|
getMatchData = __webpack_require__(138),
|
|
matchesStrictComparable = __webpack_require__(45);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 123 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIsEqual = __webpack_require__(39),
|
|
get = __webpack_require__(181),
|
|
hasIn = __webpack_require__(182),
|
|
isKey = __webpack_require__(25),
|
|
isStrictComparable = __webpack_require__(44),
|
|
matchesStrictComparable = __webpack_require__(45),
|
|
toKey = __webpack_require__(15);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 124 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 125 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGet = __webpack_require__(38);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 126 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = baseTimes;
|
|
|
|
|
|
/***/ }),
|
|
/* 127 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Symbol = __webpack_require__(10),
|
|
arrayMap = __webpack_require__(37),
|
|
isArray = __webpack_require__(1),
|
|
isSymbol = __webpack_require__(18);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 128 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 129 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 130 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var identity = __webpack_require__(48);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 131 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var root = __webpack_require__(2);
|
|
|
|
/** Used to detect overreaching core-js shims. */
|
|
var coreJsData = root['__core-js_shared__'];
|
|
|
|
module.exports = coreJsData;
|
|
|
|
|
|
/***/ }),
|
|
/* 132 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isArrayLike = __webpack_require__(16);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 133 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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;
|
|
};
|
|
}
|
|
|
|
module.exports = createBaseFor;
|
|
|
|
|
|
/***/ }),
|
|
/* 134 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseIteratee = __webpack_require__(12),
|
|
isArrayLike = __webpack_require__(16),
|
|
keys = __webpack_require__(19);
|
|
|
|
/**
|
|
* Creates a `_.find` or `_.findLast` function.
|
|
*
|
|
* @private
|
|
* @param {Function} findIndexFunc The function to find the collection index.
|
|
* @returns {Function} Returns the new find function.
|
|
*/
|
|
function createFind(findIndexFunc) {
|
|
return function(collection, predicate, fromIndex) {
|
|
var iterable = Object(collection);
|
|
if (!isArrayLike(collection)) {
|
|
var iteratee = baseIteratee(predicate, 3);
|
|
collection = keys(collection);
|
|
predicate = function(key) { return iteratee(iterable[key], key, iterable); };
|
|
}
|
|
var index = findIndexFunc(collection, predicate, fromIndex);
|
|
return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
|
|
};
|
|
}
|
|
|
|
module.exports = createFind;
|
|
|
|
|
|
/***/ }),
|
|
/* 135 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Symbol = __webpack_require__(10),
|
|
Uint8Array = __webpack_require__(103),
|
|
eq = __webpack_require__(47),
|
|
equalArrays = __webpack_require__(41),
|
|
mapToArray = __webpack_require__(162),
|
|
setToArray = __webpack_require__(170);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 136 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getAllKeys = __webpack_require__(137);
|
|
|
|
/** 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;
|
|
}
|
|
}
|
|
// Assume cyclic values are equal.
|
|
var stacked = stack.get(object);
|
|
if (stacked && stack.get(other)) {
|
|
return stacked == other;
|
|
}
|
|
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;
|
|
|
|
|
|
/***/ }),
|
|
/* 137 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGetAllKeys = __webpack_require__(113),
|
|
getSymbols = __webpack_require__(140),
|
|
keys = __webpack_require__(19);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 138 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isStrictComparable = __webpack_require__(44),
|
|
keys = __webpack_require__(19);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 139 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Symbol = __webpack_require__(10);
|
|
|
|
/** 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;
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = getRawTag;
|
|
|
|
|
|
/***/ }),
|
|
/* 140 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var arrayFilter = __webpack_require__(36),
|
|
stubArray = __webpack_require__(186);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 141 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var DataView = __webpack_require__(98),
|
|
Map = __webpack_require__(22),
|
|
Promise = __webpack_require__(100),
|
|
Set = __webpack_require__(101),
|
|
WeakMap = __webpack_require__(104),
|
|
baseGetTag = __webpack_require__(6),
|
|
toSource = __webpack_require__(46);
|
|
|
|
/** `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;
|
|
|
|
|
|
/***/ }),
|
|
/* 142 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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];
|
|
}
|
|
|
|
module.exports = getValue;
|
|
|
|
|
|
/***/ }),
|
|
/* 143 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var castPath = __webpack_require__(40),
|
|
isArguments = __webpack_require__(49),
|
|
isArray = __webpack_require__(1),
|
|
isIndex = __webpack_require__(43),
|
|
isLength = __webpack_require__(26),
|
|
toKey = __webpack_require__(15);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 144 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var nativeCreate = __webpack_require__(14);
|
|
|
|
/**
|
|
* Removes all key-value entries from the hash.
|
|
*
|
|
* @private
|
|
* @name clear
|
|
* @memberOf Hash
|
|
*/
|
|
function hashClear() {
|
|
this.__data__ = nativeCreate ? nativeCreate(null) : {};
|
|
this.size = 0;
|
|
}
|
|
|
|
module.exports = hashClear;
|
|
|
|
|
|
/***/ }),
|
|
/* 145 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = hashDelete;
|
|
|
|
|
|
/***/ }),
|
|
/* 146 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var nativeCreate = __webpack_require__(14);
|
|
|
|
/** 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;
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = hashGet;
|
|
|
|
|
|
/***/ }),
|
|
/* 147 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var nativeCreate = __webpack_require__(14);
|
|
|
|
/** Used for built-in method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = hashHas;
|
|
|
|
|
|
/***/ }),
|
|
/* 148 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var nativeCreate = __webpack_require__(14);
|
|
|
|
/** Used to stand-in for `undefined` hash values. */
|
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = hashSet;
|
|
|
|
|
|
/***/ }),
|
|
/* 149 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = isKeyable;
|
|
|
|
|
|
/***/ }),
|
|
/* 150 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var coreJsData = __webpack_require__(131);
|
|
|
|
/** 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) : '';
|
|
}());
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = isMasked;
|
|
|
|
|
|
/***/ }),
|
|
/* 151 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 152 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 153 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var assocIndexOf = __webpack_require__(11);
|
|
|
|
/** Used for built-in method references. */
|
|
var arrayProto = Array.prototype;
|
|
|
|
/** Built-in value references. */
|
|
var splice = arrayProto.splice;
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = listCacheDelete;
|
|
|
|
|
|
/***/ }),
|
|
/* 154 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var assocIndexOf = __webpack_require__(11);
|
|
|
|
/**
|
|
* 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];
|
|
}
|
|
|
|
module.exports = listCacheGet;
|
|
|
|
|
|
/***/ }),
|
|
/* 155 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var assocIndexOf = __webpack_require__(11);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = listCacheHas;
|
|
|
|
|
|
/***/ }),
|
|
/* 156 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var assocIndexOf = __webpack_require__(11);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = listCacheSet;
|
|
|
|
|
|
/***/ }),
|
|
/* 157 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Hash = __webpack_require__(99),
|
|
ListCache = __webpack_require__(9),
|
|
Map = __webpack_require__(22);
|
|
|
|
/**
|
|
* 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
|
|
};
|
|
}
|
|
|
|
module.exports = mapCacheClear;
|
|
|
|
|
|
/***/ }),
|
|
/* 158 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getMapData = __webpack_require__(13);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = mapCacheDelete;
|
|
|
|
|
|
/***/ }),
|
|
/* 159 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getMapData = __webpack_require__(13);
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = mapCacheGet;
|
|
|
|
|
|
/***/ }),
|
|
/* 160 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getMapData = __webpack_require__(13);
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = mapCacheHas;
|
|
|
|
|
|
/***/ }),
|
|
/* 161 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getMapData = __webpack_require__(13);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = mapCacheSet;
|
|
|
|
|
|
/***/ }),
|
|
/* 162 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 163 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var memoize = __webpack_require__(184);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 164 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var overArg = __webpack_require__(167);
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
var nativeKeys = overArg(Object.keys, Object);
|
|
|
|
module.exports = nativeKeys;
|
|
|
|
|
|
/***/ }),
|
|
/* 165 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__(42);
|
|
|
|
/** 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) {}
|
|
}());
|
|
|
|
module.exports = nodeUtil;
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(54)(module)))
|
|
|
|
/***/ }),
|
|
/* 166 */
|
|
/***/ (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;
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = objectToString;
|
|
|
|
|
|
/***/ }),
|
|
/* 167 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 168 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/** Used to stand-in for `undefined` hash values. */
|
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = setCacheAdd;
|
|
|
|
|
|
/***/ }),
|
|
/* 169 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = setCacheHas;
|
|
|
|
|
|
/***/ }),
|
|
/* 170 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 171 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var ListCache = __webpack_require__(9);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 172 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = stackDelete;
|
|
|
|
|
|
/***/ }),
|
|
/* 173 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = stackGet;
|
|
|
|
|
|
/***/ }),
|
|
/* 174 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
module.exports = stackHas;
|
|
|
|
|
|
/***/ }),
|
|
/* 175 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var ListCache = __webpack_require__(9),
|
|
Map = __webpack_require__(22),
|
|
MapCache = __webpack_require__(23);
|
|
|
|
/** Used as the size to enable large array optimizations. */
|
|
var LARGE_ARRAY_SIZE = 200;
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
module.exports = stackSet;
|
|
|
|
|
|
/***/ }),
|
|
/* 176 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var memoizeCapped = __webpack_require__(163);
|
|
|
|
/** Used to match property names within property paths. */
|
|
var reLeadingDot = /^\./,
|
|
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 (reLeadingDot.test(string)) {
|
|
result.push('');
|
|
}
|
|
string.replace(rePropName, function(match, number, quote, string) {
|
|
result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
|
|
});
|
|
return result;
|
|
});
|
|
|
|
module.exports = stringToPath;
|
|
|
|
|
|
/***/ }),
|
|
/* 177 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var arrayFilter = __webpack_require__(36),
|
|
baseFilter = __webpack_require__(109),
|
|
baseIteratee = __webpack_require__(12),
|
|
isArray = __webpack_require__(1);
|
|
|
|
/**
|
|
* Iterates over elements of `collection`, returning an array of all elements
|
|
* `predicate` returns truthy for. The predicate is invoked with three
|
|
* arguments: (value, index|key, collection).
|
|
*
|
|
* **Note:** Unlike `_.remove`, this method returns a new array.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 0.1.0
|
|
* @category Collection
|
|
* @param {Array|Object} collection The collection to iterate over.
|
|
* @param {Function} [predicate=_.identity] The function invoked per iteration.
|
|
* @returns {Array} Returns the new filtered array.
|
|
* @see _.reject
|
|
* @example
|
|
*
|
|
* var users = [
|
|
* { 'user': 'barney', 'age': 36, 'active': true },
|
|
* { 'user': 'fred', 'age': 40, 'active': false }
|
|
* ];
|
|
*
|
|
* _.filter(users, function(o) { return !o.active; });
|
|
* // => objects for ['fred']
|
|
*
|
|
* // The `_.matches` iteratee shorthand.
|
|
* _.filter(users, { 'age': 36, 'active': true });
|
|
* // => objects for ['barney']
|
|
*
|
|
* // The `_.matchesProperty` iteratee shorthand.
|
|
* _.filter(users, ['active', false]);
|
|
* // => objects for ['fred']
|
|
*
|
|
* // The `_.property` iteratee shorthand.
|
|
* _.filter(users, 'active');
|
|
* // => objects for ['barney']
|
|
*/
|
|
function filter(collection, predicate) {
|
|
var func = isArray(collection) ? arrayFilter : baseFilter;
|
|
return func(collection, baseIteratee(predicate, 3));
|
|
}
|
|
|
|
module.exports = filter;
|
|
|
|
|
|
/***/ }),
|
|
/* 178 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var createFind = __webpack_require__(134),
|
|
findIndex = __webpack_require__(179);
|
|
|
|
/**
|
|
* Iterates over elements of `collection`, returning the first element
|
|
* `predicate` returns truthy for. The predicate is invoked with three
|
|
* arguments: (value, index|key, collection).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 0.1.0
|
|
* @category Collection
|
|
* @param {Array|Object} collection The collection to inspect.
|
|
* @param {Function} [predicate=_.identity] The function invoked per iteration.
|
|
* @param {number} [fromIndex=0] The index to search from.
|
|
* @returns {*} Returns the matched element, else `undefined`.
|
|
* @example
|
|
*
|
|
* var users = [
|
|
* { 'user': 'barney', 'age': 36, 'active': true },
|
|
* { 'user': 'fred', 'age': 40, 'active': false },
|
|
* { 'user': 'pebbles', 'age': 1, 'active': true }
|
|
* ];
|
|
*
|
|
* _.find(users, function(o) { return o.age < 40; });
|
|
* // => object for 'barney'
|
|
*
|
|
* // The `_.matches` iteratee shorthand.
|
|
* _.find(users, { 'age': 1, 'active': true });
|
|
* // => object for 'pebbles'
|
|
*
|
|
* // The `_.matchesProperty` iteratee shorthand.
|
|
* _.find(users, ['active', false]);
|
|
* // => object for 'fred'
|
|
*
|
|
* // The `_.property` iteratee shorthand.
|
|
* _.find(users, 'active');
|
|
* // => object for 'barney'
|
|
*/
|
|
var find = createFind(findIndex);
|
|
|
|
module.exports = find;
|
|
|
|
|
|
/***/ }),
|
|
/* 179 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseFindIndex = __webpack_require__(110),
|
|
baseIteratee = __webpack_require__(12),
|
|
toInteger = __webpack_require__(189);
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
var nativeMax = Math.max;
|
|
|
|
/**
|
|
* This method is like `_.find` except that it returns the index of the first
|
|
* element `predicate` returns truthy for instead of the element itself.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 1.1.0
|
|
* @category Array
|
|
* @param {Array} array The array to inspect.
|
|
* @param {Function} [predicate=_.identity] The function invoked per iteration.
|
|
* @param {number} [fromIndex=0] The index to search from.
|
|
* @returns {number} Returns the index of the found element, else `-1`.
|
|
* @example
|
|
*
|
|
* var users = [
|
|
* { 'user': 'barney', 'active': false },
|
|
* { 'user': 'fred', 'active': false },
|
|
* { 'user': 'pebbles', 'active': true }
|
|
* ];
|
|
*
|
|
* _.findIndex(users, function(o) { return o.user == 'barney'; });
|
|
* // => 0
|
|
*
|
|
* // The `_.matches` iteratee shorthand.
|
|
* _.findIndex(users, { 'user': 'fred', 'active': false });
|
|
* // => 1
|
|
*
|
|
* // The `_.matchesProperty` iteratee shorthand.
|
|
* _.findIndex(users, ['active', false]);
|
|
* // => 0
|
|
*
|
|
* // The `_.property` iteratee shorthand.
|
|
* _.findIndex(users, 'active');
|
|
* // => 2
|
|
*/
|
|
function findIndex(array, predicate, fromIndex) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = fromIndex == null ? 0 : toInteger(fromIndex);
|
|
if (index < 0) {
|
|
index = nativeMax(length + index, 0);
|
|
}
|
|
return baseFindIndex(array, baseIteratee(predicate, 3), index);
|
|
}
|
|
|
|
module.exports = findIndex;
|
|
|
|
|
|
/***/ }),
|
|
/* 180 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var arrayEach = __webpack_require__(105),
|
|
baseEach = __webpack_require__(24),
|
|
castFunction = __webpack_require__(130),
|
|
isArray = __webpack_require__(1);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 181 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseGet = __webpack_require__(38);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 182 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseHasIn = __webpack_require__(114),
|
|
hasPath = __webpack_require__(143);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 183 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var arrayMap = __webpack_require__(37),
|
|
baseIteratee = __webpack_require__(12),
|
|
baseMap = __webpack_require__(121),
|
|
isArray = __webpack_require__(1);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 184 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var MapCache = __webpack_require__(23);
|
|
|
|
/** 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 185 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseProperty = __webpack_require__(124),
|
|
basePropertyDeep = __webpack_require__(125),
|
|
isKey = __webpack_require__(25),
|
|
toKey = __webpack_require__(15);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 186 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ }),
|
|
/* 187 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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 = stubFalse;
|
|
|
|
|
|
/***/ }),
|
|
/* 188 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toNumber = __webpack_require__(190);
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
var INFINITY = 1 / 0,
|
|
MAX_INTEGER = 1.7976931348623157e+308;
|
|
|
|
/**
|
|
* Converts `value` to a finite number.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.12.0
|
|
* @category Lang
|
|
* @param {*} value The value to convert.
|
|
* @returns {number} Returns the converted number.
|
|
* @example
|
|
*
|
|
* _.toFinite(3.2);
|
|
* // => 3.2
|
|
*
|
|
* _.toFinite(Number.MIN_VALUE);
|
|
* // => 5e-324
|
|
*
|
|
* _.toFinite(Infinity);
|
|
* // => 1.7976931348623157e+308
|
|
*
|
|
* _.toFinite('3.2');
|
|
* // => 3.2
|
|
*/
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber(value);
|
|
if (value === INFINITY || value === -INFINITY) {
|
|
var sign = (value < 0 ? -1 : 1);
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
|
|
module.exports = toFinite;
|
|
|
|
|
|
/***/ }),
|
|
/* 189 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toFinite = __webpack_require__(188);
|
|
|
|
/**
|
|
* Converts `value` to an integer.
|
|
*
|
|
* **Note:** This method is loosely based on
|
|
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to convert.
|
|
* @returns {number} Returns the converted integer.
|
|
* @example
|
|
*
|
|
* _.toInteger(3.2);
|
|
* // => 3
|
|
*
|
|
* _.toInteger(Number.MIN_VALUE);
|
|
* // => 0
|
|
*
|
|
* _.toInteger(Infinity);
|
|
* // => 1.7976931348623157e+308
|
|
*
|
|
* _.toInteger('3.2');
|
|
* // => 3
|
|
*/
|
|
function toInteger(value) {
|
|
var result = toFinite(value),
|
|
remainder = result % 1;
|
|
|
|
return result === result ? (remainder ? result - remainder : result) : 0;
|
|
}
|
|
|
|
module.exports = toInteger;
|
|
|
|
|
|
/***/ }),
|
|
/* 190 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isObject = __webpack_require__(17),
|
|
isSymbol = __webpack_require__(18);
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
var NAN = 0 / 0;
|
|
|
|
/** 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;
|
|
|
|
/**
|
|
* 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 = toNumber;
|
|
|
|
|
|
/***/ }),
|
|
/* 191 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var baseToString = __webpack_require__(127);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
|
|
/***/ }),
|
|
/* 192 */
|
|
/***/ (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__(91);
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
// add the styles to the DOM
|
|
var update = __webpack_require__(27)(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!./../../../node_modules/postcss-loader/index.js!./index.pcss", function() {
|
|
var newContent = require("!!./../../../node_modules/css-loader/index.js!./../../../node_modules/postcss-loader/index.js!./index.pcss");
|
|
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
|
|
update(newContent);
|
|
});
|
|
}
|
|
// When the module is disposed, remove the <style> tags
|
|
module.hot.dispose(function() { update(); });
|
|
}
|
|
|
|
/***/ }),
|
|
/* 193 */
|
|
/***/ (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__(95);
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
// add the styles to the DOM
|
|
var update = __webpack_require__(27)(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("!!./../../css-loader/index.js?root=./docs!./color-brewer.css", function() {
|
|
var newContent = require("!!./../../css-loader/index.js?root=./docs!./color-brewer.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(); });
|
|
}
|
|
|
|
/***/ }),
|
|
/* 194 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = "data:image/svg+xml;base64,<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg">
<metadata>
Created by FontForge 20120731 at Fri Sep 23 11:54:25 2016
 By admin
</metadata>
<defs>
<font id="iconfont" horiz-adv-x="1024" >
  <font-face 
    font-family="iconfont"
    font-weight="500"
    font-stretch="normal"
    units-per-em="1024"
    panose-1="2 0 6 3 0 0 0 0 0 0"
    ascent="896"
    descent="-128"
    x-height="792"
    bbox="-0.446043 -209 1107 933"
    underline-thickness="50"
    underline-position="-100"
    unicode-range="U+0078-E656"
  />
<missing-glyph horiz-adv-x="374" 
d="M34 0v682h272v-682h-272zM68 34h204v614h-204v-614z" />
    <glyph glyph-name=".notdef" horiz-adv-x="374" 
d="M34 0v682h272v-682h-272zM68 34h204v614h-204v-614z" />
    <glyph glyph-name=".null" horiz-adv-x="0" 
 />
    <glyph glyph-name="nonmarkingreturn" horiz-adv-x="341" 
 />
    <glyph glyph-name="x" unicode="x" horiz-adv-x="1001" 
d="M281 543q-27 -1 -53 -1h-83q-18 0 -36.5 -6t-32.5 -18.5t-23 -32t-9 -45.5v-76h912v41q0 16 -0.5 30t-0.5 18q0 13 -5 29t-17 29.5t-31.5 22.5t-49.5 9h-133v-97h-438v97zM955 310v-52q0 -23 0.5 -52t0.5 -58t-10.5 -47.5t-26 -30t-33 -16t-31.5 -4.5q-14 -1 -29.5 -0.5
t-29.5 0.5h-32l-45 128h-439l-44 -128h-29h-34q-20 0 -45 1q-25 0 -41 9.5t-25.5 23t-13.5 29.5t-4 30v167h911zM163 247q-12 0 -21 -8.5t-9 -21.5t9 -21.5t21 -8.5q13 0 22 8.5t9 21.5t-9 21.5t-22 8.5zM316 123q-8 -26 -14 -48q-5 -19 -10.5 -37t-7.5 -25t-3 -15t1 -14.5
t9.5 -10.5t21.5 -4h37h67h81h80h64h36q23 0 34 12t2 38q-5 13 -9.5 30.5t-9.5 34.5q-5 19 -11 39h-368zM336 498v228q0 11 2.5 23t10 21.5t20.5 15.5t34 6h188q31 0 51.5 -14.5t20.5 -52.5v-227h-327z" />
    <glyph glyph-name="uniE600" unicode="&#xe600;" 
d="M0 768q0 53 37.5 90.5t90.5 37.5h768q53 0 90.5 -37.5t37.5 -90.5v-768q0 -53 -37.5 -90.5t-90.5 -37.5h-768q-53 0 -90.5 37.5t-37.5 90.5v768zM523 745q-113 0 -179 -64t-66 -178h116q0 66 26 100q28 42 96 42q53 0 82 -29q29 -30 29 -79q0 -39 -28 -73l-12 -14
q-101 -90 -120 -131q-21 -39 -21 -100v-14h118v14q0 36 16 67q14 29 41 51q71 63 88 81q37 50 37 126q0 93 -61 147q-60 54 -162 54zM505 155q-33 0 -56 -22q-23 -21 -23 -55t23 -55q24 -23 56 -23q33 0 56 22q24 21 24 56q0 33 -23 55t-57 22z" />
    <glyph glyph-name="uniE601" unicode="&#xe601;" 
d="M768 328v-320h-640v704h320q27 0 45.5 18.5t18.5 45t-18.5 45.5t-45.5 19h-320q-53 0 -90.5 -37.5t-37.5 -90.5v-704q0 -53 37.5 -90.5t90.5 -37.5h640q53 0 90.5 37.5t37.5 90.5v320q0 26 -18.5 45t-45.5 19t-45.5 -19t-18.5 -45zM748 873q17 21 43.5 23t47.5 -15
l97 -82q20 -17 22.5 -43.5t-14.5 -46.5l-41 -49l-196 164zM311 154l222 64l-196 165zM666 775l196 -164l-288 -344l-196 165z" />
    <glyph glyph-name="uniE602" unicode="&#xe602;" 
d="M0 768q0 53 37.5 90.5t90.5 37.5h768q53 0 90.5 -37.5t37.5 -90.5v-768q0 -53 -37.5 -90.5t-90.5 -37.5h-768q-53 0 -90.5 37.5t-37.5 90.5v768zM827 382q-7 43 -49 50h-216v222q-7 43 -49 50q-56 -7 -56 -57v-215h-209q-56 -7 -56 -50q0 -58 56 -58h209v-207
q0 -58 56 -58q49 -7 49 50v215h209q49 0 56 58z" />
    <glyph glyph-name="uniE603" unicode="&#xe603;" 
d="M829 896h-640q-54 0 -92.5 -36t-38.5 -88v-767q0 -54 39 -93.5t92 -39.5h386q26 0 45 18.5t19 45.5t-19 45.5t-45 18.5h-386l-1 2l-2 3v767l3 -4h640h-1h-2v-190q0 -27 18.5 -45.5t45 -18.5t45.5 18.5t19 45.5v194q0 53 -36 88.5t-89 35.5zM781 175q48 67 48 149
q0 106 -75 181t-181 75t-181 -75t-75 -181t75 -181t181 -75q57 0 109 25l159 -159q18 -19 44.5 -18.5t45.5 18.5q19 19 19 45.5t-19 44.5zM573 196q-53 0 -90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5z" />
    <glyph glyph-name="uniE604" unicode="&#xe604;" 
d="M1002 629l-245 245q-17 17 -41 17t-41 -17l-245 -245q-17 -17 -17 -41t17 -41l41 -40l245 245l164 -164l-246 -245l41 -41q17 -17 41 -17t41 17l245 245q17 17 17 41t-17 41zM553 261l-245 -245l-164 164l245 245l-40 41q-17 17 -41 17t-41 -17l-245 -245
q-17 -17 -17 -41t17 -41l245 -245q17 -17 41 -17t41 17l245 245q17 17 17 41t-17 41zM349 221q17 -17 40.5 -17t40.5 17l245 245q17 17 17 40.5t-17 40.5t-40.5 17t-40.5 -17l-245 -245q-17 -17 -17 -40.5t17 -40.5z" />
    <glyph glyph-name="uniE605" unicode="&#xe605;" 
d="M509 -122q-104 0 -198 40.5t-162 108.5t-108.5 162.5t-40.5 198t40.5 197.5t108.5 162t162 108.5t197.5 40.5t198 -40.5t162.5 -108.5t108.5 -162t40.5 -197.5t-40.5 -198t-108.5 -162.5t-162.5 -108.5t-197.5 -40.5zM745 625q-18 18 -43 18t-43 -18l-151 -151l-150 149
q-17 18 -42.5 18t-42.5 -18h-1q-17 -17 -17 -42.5t17 -42.5l150 -150l-151 -151q-18 -18 -18 -43t18 -43t43 -18t43 18l151 151l151 -151q18 -18 43 -18t43 18t18 43t-18 43l-151 151l151 151q18 18 18 43t-18 43z" />
    <glyph glyph-name="uniE606" unicode="&#xe606;" 
d="M723 573q53 0 65 27t-25 64l-205 212q-18 19 -44 19t-45 -19l-212 -212q-37 -38 -26 -64.5t64 -26.5h138v-421q0 -22 15 -37.5t36 -15.5h50q21 0 36 15.5t15 37.5v421h138zM158 -128q-39 0 -66.5 28.5t-27.5 68.5v388q0 41 27.5 69.5t66.5 28.5h100q26 0 44.5 -19
t18.5 -46v-33h-70q-38 0 -65.5 -28t-27.5 -69v-194q0 -40 27.5 -68.5t65.5 -28.5h516q39 0 66 28.5t27 68.5v194q0 41 -27 69t-66 28h-71v33q0 27 19 46t45 19h100q39 0 66.5 -28.5t27.5 -69.5v-388q0 -40 -27.5 -68.5t-66.5 -28.5h-702z" />
    <glyph glyph-name="uniE607" unicode="&#xe607;" horiz-adv-x="1025" 
d="M706 383q27 0 33.5 -14.5t-10.5 -35.5l-174 -211q-17 -20 -41 -20t-41 20l-178 212q-17 20 -10 34.5t34 14.5h132v449q0 26 18.5 45t45.5 19h-3q26 0 45 -19t19 -45v-449h130zM73 -127q-42 0 -57.5 14t-15.5 54v693q0 40 15.5 54.5t57.5 14.5h119q27 0 45.5 -19t18.5 -45
v-62h-65q-18 0 -31 -6.5t-19 -15.5t-9.5 -18t-3.5 -15l-1 -6v-456q0 -23 16.5 -42.5t47.5 -19.5h640q28 0 47 18.5t19 43.5v456q-1 0 0 6t-2.5 15.5t-9 18t-20 15t-34.5 6.5h-62v62q0 26 19 45t45 19h132q39 0 49 -13t10 -56v-693q0 -43 -10 -55.5t-49 -12.5h-892z" />
    <glyph glyph-name="uniE608" unicode="&#xe608;" horiz-adv-x="1025" 
d="M291 477h349q80 0 136 -56.5t56 -135.5q0 -80 -56 -136t-135 -56h-381h-3q-27 0 -45.5 -19t-18.5 -45.5t18.5 -45t45.5 -18.5h3h381q132 0 225.5 93.5t93.5 226.5q0 86 -42.5 160t-116.5 117t-161 43h-349v128q0 26 -14.5 33t-35.5 -9l-220 -176q-21 -17 -21 -40.5
t21 -39.5l220 -176q21 -17 35.5 -10t14.5 33v129z" />
    <glyph glyph-name="uniE609" unicode="&#xe609;" 
d="M650 384l345 345q29 29 29 69.5t-28.5 69t-69 28.5t-69.5 -29l-345 -345l-345 345q-29 29 -69.5 29t-68.5 -29q-29 -28 -29 -68.5t29 -69.5l345 -345l-345 -345q-29 -29 -29 -69.5t29 -68.5q28 -29 68.5 -29t69.5 29l345 345l345 -345q29 -29 69.5 -29t69 28.5t28.5 69
t-29 69.5z" />
    <glyph glyph-name="uniE60A" unicode="&#xe60a;" horiz-adv-x="1025" 
d="M804 133l-490 582q79 47 170 53.5t176.5 -29t146.5 -107.5q92 -110 90.5 -251.5t-93.5 -247.5zM217 136q-92 110 -90.5 251.5t93.5 247.5l490 -582q-79 -47 -170 -53.5t-176.5 29t-146.5 107.5zM182 775q-106 -89 -152 -217.5t-22.5 -263t113 -240.5t218 -152t263 -22.5
t240.5 113t152 218t22.5 263t-113 240.5t-218 152t-263 22.5t-240.5 -113.5z" />
    <glyph glyph-name="uniE60B" unicode="&#xe60b;" 
d="M617 547l-73 130q-13 23 -32 23t-32 -23l-73 -130l-152 -28q-26 -5 -31.5 -21.5t12.5 -36.5l105 -109l-19 -147q-3 -27 11.5 -37.5t38.5 0.5l140 64l140 -64q24 -11 38.5 0t11.5 37l-19 147l105 109q18 19 12.5 36t-31.5 22zM0 162v171v145v333q0 35 29.5 60t70.5 25h824
q41 0 70.5 -25t29.5 -60v-333v-145v-171q0 -49 -28 -91.5t-73.5 -71t-100 -52t-109 -37t-100 -22.5t-73.5 -12l-28 -4q-7 1 -18 2t-46 7t-69 13t-80 20t-85.5 28t-80 38t-69 48.5t-46.5 60.5t-18 73z" />
    <glyph glyph-name="uniE60C" unicode="&#xe60c;" horiz-adv-x="1093" 
d="M562 406l-145 145q-30 29 -72.5 29t-72.5 -29q-30 -31 -30 -73t30 -72l145 -145l-145 -145q-30 -30 -30 -72.5t30 -72.5t72.5 -30t72.5 30l145 145l145 -145q30 -30 72 -30t73 30q30 30 30 72.5t-30 72.5l-145 145l145 145q29 30 29 72t-29 73q-31 30 -73 30t-72 -30z
M0 793q0 43 30 73t73 30h887q42 0 72 -30t30 -73t-30 -73t-72 -30h-887q-43 0 -73 30t-30 73z" />
    <glyph glyph-name="uniE60D" unicode="&#xe60d;" horiz-adv-x="1026" 
d="M220 432h147v-149h-147v149zM442 283h147v149h-147v-149zM664 283h146v149h-146v-149zM220 65h147v149h-147v-149zM442 65h147v149h-147v-149zM664 65h146v149h-146v-149zM865 734q0 -19 -13.5 -32.5t-32 -13.5t-32 13.5t-13.5 32.5v116q0 19 13.5 32.5t32 13.5t32 -13.5
t13.5 -32.5v-116zM254 850q0 19 -13.5 32.5t-32 13.5t-32 -13.5t-13.5 -32.5v-116q0 -19 13.5 -32.5t32 -13.5t32 13.5t13.5 32.5v116zM920 783v-48q0 -42 -29.5 -71.5t-71 -29.5t-70.5 29.5t-29 71.5v48h-412v-47q0 -42 -29 -72t-70.5 -30t-70.5 30t-29 72v47h-109v-911
h1026v911h-106zM100 538h826v-565h-826v565z" />
    <glyph glyph-name="uniE60E" unicode="&#xe60e;" 
d="M869.5 135q-9.5 11 -35.5 11h-336v271h287q25 0 34 11.5t9 33.5t-10.5 33.5t-34.5 11.5h-285v189q0 26 -11.5 35t-34.5 9q-24 0 -34.5 -9t-10.5 -35v-550h-210q-25 0 -35 -11t-10 -35q0 -21 10.5 -32.5t34.5 -11.5h637q24 0 34.5 11.5t10.5 32.5q0 24 -9.5 35zM949 -128
h-874q-31 0 -53 22t-22 53v874q0 31 22 53t53 22h874q31 0 53 -22t22 -53v-874q0 -31 -22 -53t-53 -22z" />
    <glyph glyph-name="uniE60F" unicode="&#xe60f;" horiz-adv-x="1025" 
d="M1018 385q0 -103 -40.5 -197.5t-108.5 -162.5t-162 -108t-197 -40q-104 0 -198.5 40.5t-163 109t-108.5 163t-40 198.5t41 198.5t110 162.5t164 107.5t200 39.5q102 0 195 -41t160.5 -109.5t107.5 -162.5t40 -198zM400 255q-100 106 -108 113q-25 25 -55.5 25t-53.5 -23
q-21 -23 -19.5 -50.5t27.5 -52.5q49 -51 137 -139q40 -39 73.5 -39t73.5 40q173 172 215 214q119 119 141.5 142.5t22.5 52.5t-21 50q-20 20 -50.5 19.5t-54.5 -22.5q-8 -7 -31 -30q-50 -51 -297 -300z" />
    <glyph glyph-name="uniE610" unicode="&#xe610;" 
d="M349 30q28 -30 67.5 -30t67.5 31l512 559q28 31 28 74t-28 73.5t-67.5 30.5t-67.5 -31l-512 -559h135l-321 346q-28 31 -68 30.5t-67.5 -31t-27.5 -74t28 -73.5z" />
    <glyph glyph-name="uniE611" unicode="&#xe611;" 
d="M429 128h-210q-39 0 -67.5 -28t-28.5 -68t28 -68t68 -28h577q39 0 67 28t28 68t-28 68t-67 28h-205v271l58 -58q17 -17 49 -19t49 14t17 45.5t-17 46.5l-191 187q-3 5 -7 9q-16 16 -40 16t-41 -16q-4 -4 -7 -9l-191 -187q-16 -17 -14 -43.5t19 -43.5q18 -16 50 -12.5
t49 20.5l55 50v-271zM0 799.5q0 40.5 28 68.5t68 28h832q40 0 68 -28t28 -68.5t-28 -68.5t-68 -28h-832q-40 0 -68 28t-28 68.5z" />
    <glyph glyph-name="uniE612" unicode="&#xe612;" 
d="M214 431q-22 -23 -22 -52t22 -52l416 -426q25 -25 65 -28.5t70.5 18t34.5 54.5t-22 59l-416 426v-103l434 436q26 26 22.5 59.5t-34 55t-70 18.5t-65.5 -29z" />
    <glyph glyph-name="uniE613" unicode="&#xe613;" 
d="M628 732q29 25 49 16t20 -48v-585q0 -39 -21 -49t-51 15l-311 254q-29 24 -30 59.5t28 60.5z" />
    <glyph glyph-name="uniE614" unicode="&#xe614;" 
d="M139 442q0 130 92 222t222 92t222 -92t92 -222t-92 -222t-222 -92t-222 92t-92 222zM1000 11l-174 175q80 116 80 256q0 93 -36 177t-96.5 144.5t-144.5 96.5t-176 36t-176 -36t-144.5 -96.5t-96.5 -144.5t-36 -176.5t36 -176.5t96.5 -144.5t144.5 -96.5t176 -36
q141 0 258 81l174 -174q24 -24 57.5 -24t57.5 24t24 58t-24 57z" />
    <glyph glyph-name="uniE615" unicode="&#xe615;" horiz-adv-x="1025" 
d="M514 201q-3 -3 -2 0q-12 -8 -24.5 -9t-20.5 6l-204 192q-9 9 -6.5 23t14.5 26l20 19q13 11 28 13.5t23 -5.5l147 -138l2 2l191 240q8 8 23 5.5t28 -14.5l20 -19q12 -12 14.5 -26t-6.5 -22zM866 533l-1 1q-13 32 -34 63q0 1 -3 4q-19 28 -21 31q-4 5 -12 12.5t-10 9.5
l-4 3q-25 25 -53 44l-3 2q-30 21 -62 34q-1 0 -1 1h-1q-82 35 -175 29.5t-172 -52.5l2 -2q-53 -32 -94 -80l-2 2q-7 -7 -26 -36l-1 -1q-54 -80 -63.5 -177t28.5 -186l1 -1q13 -32 33 -63q1 0 2 -1.5t2 -2.5q20 -29 21 -31q4 -5 12 -12.5t10 -8.5q2 -3 4 -4q25 -25 53 -44
q2 -1 3 -2q30 -20 62 -34q1 -1 2 -1q82 -35 175 -29.5t172 52.5l-2 2q53 32 94 80l2 -2q7 7 26 36l1 1q54 80 63.5 177t-28.5 186zM842 -8q-106 -89 -240.5 -112.5t-263 22.5t-218 152t-113 240.5t22.5 263t152 218t240.5 113t263 -22.5t218 -152t113 -240.5t-22.5 -263
t-152 -218.5z" />
    <glyph glyph-name="uniE616" unicode="&#xe616;" 
d="M865 686.5q-9 11.5 -34 11.5h-629q-26 0 -35 -11.5t-9 -32.5t9 -32.5t35 -11.5h250v-538q0 -27 11.5 -35.5t34.5 -8.5q20 0 32.5 8.5t12.5 35.5v346q48 -34 94 -69q47 -35 83 -67q15 -12 25.5 -19t19 -8.5t16.5 2.5t17 12q21 21 18.5 38.5t-32.5 43.5q-26 21 -55 44
q-30 23 -62 46q-32 24 -63 46q-32 22 -61 40v83h288q25 0 34 11.5t9 32.5t-9 32.5zM139 -128q-32 0 -57.5 10.5t-40 26t-24.5 35.5t-13.5 36.5t-3.5 30.5v746q0 19 1 31t8 35t20.5 37t41.5 25t68 11h746q19 0 31 -1t35 -8t37 -20.5t25 -41.5t11 -68v-746q0 -19 -1 -31
t-8 -35t-20.5 -37t-41.5 -25t-68 -11h-746z" />
    <glyph glyph-name="uniE617" unicode="&#xe617;" 
d="M164 280q-27 -28 -18 -48t47 -20h637q38 0 47.5 20.5t-15.5 49.5l-275 315q-25 29 -61.5 30t-62.5 -27z" />
    <glyph glyph-name="uniE618" unicode="&#xe618;" 
d="M164 455q-27 28 -18 47.5t47 19.5h637q38 0 47.5 -20.5t-15.5 -49.5l-275 -315q-25 -29 -61.5 -29.5t-62.5 27.5z" />
    <glyph glyph-name="uniE619" unicode="&#xe619;" 
d="M362 867l434 -437q23 -22 23 -51t-22 -52l-416 -426q-26 -25 -65.5 -28.5t-70 18t-34.5 54.5t21 59l417 426v-103l-435 436q-25 26 -21.5 59t34 54.5t70 19t65.5 -28.5z" />
    <glyph glyph-name="uniE61A" unicode="&#xe61a;" 
d="M396 732q-29 25 -49 16t-20 -48v-585q0 -39 21 -49t51 15l311 254q29 24 30 59.5t-28 60.5z" />
    <glyph glyph-name="uniE61B" unicode="&#xe61b;" 
d="M508.5 -119q-101.5 0 -194 39.5t-159.5 106.5t-106.5 159.5t-39.5 194t39.5 194t106.5 159t159.5 106t194 39.5t194 -39.5t159 -106t106.5 -159t40 -194t-40 -194t-106.5 -159.5t-159 -106.5t-194 -39.5zM758 443h-187v187q0 26 -18.5 44t-44 18t-44 -18t-18.5 -44v-187
h-187q-26 0 -44.5 -18.5t-18.5 -44.5t18.5 -44t44.5 -18h187v-187q0 -26 18.5 -44.5t44 -18.5t44 18.5t18.5 44.5v187h187q26 0 44 18t18 44t-18 44.5t-44 18.5z" />
    <glyph glyph-name="uniE61C" unicode="&#xe61c;" 
d="M0 640q0 27 18.5 45.5t45.5 18.5h896q27 0 45.5 -18.5t18.5 -45.5t-18.5 -45.5t-45.5 -18.5h-896q-27 0 -45.5 18.5t-18.5 45.5zM0 384q0 27 18.5 45.5t45.5 18.5h896q27 0 45.5 -18.5t18.5 -45.5t-18.5 -45.5t-45.5 -18.5h-896q-27 0 -45.5 18.5t-18.5 45.5zM0 128
q0 27 18.5 45.5t45.5 18.5h896q27 0 45.5 -18.5t18.5 -45.5t-18.5 -45.5t-45.5 -18.5h-896q-27 0 -45.5 18.5t-18.5 45.5z" />
    <glyph glyph-name="uniE61D" unicode="&#xe61d;" 
d="M102 734q0 22 15.5 37t37.5 15h263v52q0 22 15.5 37.5t37.5 15.5h105q22 0 37.5 -15.5t15.5 -37.5v-52h263q22 0 37 -15.5t15 -36.5v-53h-842v53zM892 577v-644q0 -22 -15.5 -37.5t-37.5 -15.5h-631q-22 0 -37.5 15.5t-15.5 37.5v696h737v-52zM366 473q0 21 -15.5 36.5
t-37.5 15.5t-37.5 -15.5t-15.5 -36.5v-436q0 -22 15.5 -37t37.5 -15t37.5 15t15.5 37v436zM576 473q0 21 -15.5 36.5t-37 15.5t-37 -15.5t-15.5 -36.5v-436q0 -22 15.5 -37t37 -15t37 15t15.5 37v436zM786 473q0 21 -15 36.5t-37 15.5t-37.5 -15.5t-15.5 -36.5v-436
q0 -22 15.5 -37t37.5 -15t37 15t15 37v436z" />
    <glyph glyph-name="uniE61E" unicode="&#xe61e;" 
d="M516 716q-74 0 -142.5 -20t-118 -52t-92.5 -71t-70.5 -77.5t-47.5 -70.5t-29 -52l-9 -20q3 -8 9 -21t28.5 -51t48.5 -72t70 -76t93 -72.5t117.5 -51t142.5 -20.5t142.5 20.5t117.5 51t93 72t70.5 76t48.5 72.5t28 51t9 21q-3 7 -9 20t-28 51t-48.5 72.5t-70.5 76.5
t-93 72t-117.5 50.5t-142.5 20.5zM516 134q-90 0 -154 64t-64 154.5t64 154.5t154 64t154 -64t64 -154.5t-64 -154.5t-154 -64zM625 352.5q0 -45.5 -32 -77.5t-77 -32t-77 32t-32 77.5t32 77.5t77 32t77 -32t32 -77.5z" />
    <glyph glyph-name="uniE61F" unicode="&#xe61f;" 
d="M512 892q105 0 197.5 -40t161.5 -109q69 -68 109 -161t40 -198.5t-40 -198t-109 -161.5t-161.5 -109t-198 -40t-198.5 40t-161.5 109t-109 161t-40.5 198t40.5 199t109 161.5t161.5 108.5t199 40zM573 453q0 28 -17.5 46.5t-43.5 18.5t-44.5 -18.5t-18.5 -46.5v-380
q0 -27 18.5 -43.5t44.5 -16.5t44 17t18 44zM512 594q33 0 56 23.5t23 56t-23 56t-56 23.5t-57 -23.5t-24 -56t24 -56t57 -23.5zM512 594z" />
    <glyph glyph-name="uniE620" unicode="&#xe620;" 
d="M461 32q0 22 15 37.5t36 15.5t36 -15.5t15 -37.5t-15 -37.5t-36 -15.5t-36 15.5t-15 37.5zM302 789h420q18 0 31.5 -13.5t13.5 -33.5v-524q0 -20 -13.5 -33.5t-31.5 -13.5h-420q-18 0 -31.5 13.5t-13.5 33.5v524q0 20 13.5 33.5t31.5 13.5zM156 -43q0 -35 23.5 -60
t57.5 -25h550q34 0 57.5 25t23.5 60v854q0 35 -23.5 60t-57.5 25h-550q-34 0 -57.5 -25t-23.5 -60v-854zM156 -43z" />
    <glyph glyph-name="uniE621" unicode="&#xe621;" 
d="M426 128h1v594h-150q-73 0 -127 -48t-63 -120h-87l86 342h852l86 -342h-87q-9 72 -63 120t-127 48h-150v-594h1q-1 -6 -1 -13q0 -72 50 -123t121 -51v-69h-213h-86h-213v69q71 0 121 51t50 123q0 7 -1 13z" />
    <glyph glyph-name="uniE622" unicode="&#xe622;" 
d="M427 896q127 0 189.5 -10t111.5 -42.5t82 -86t33 -119.5q0 -72 -40 -132t-109 -90q97 -27 149.5 -92.5t52.5 -154.5q0 -70 -34 -135.5t-92.5 -105t-144.5 -48.5q-55 -6 -261 -7h-364v1023h427zM192 512h152q136 0 168 4q60 7 94 39.5t34 86.5q0 51 -29.5 83t-87.5 39
q-34 4 -198 4h-133v-256zM192 64h224q131 0 166 6q54 8 88 38t34 81q0 43 -26 73.5t-75.5 44t-215.5 13.5h-195v-256z" />
    <glyph glyph-name="uniE623" unicode="&#xe623;" 
d="M939 896h-857q-34 0 -58 -23t-24 -57v-797q0 -34 24 -58.5t58 -24.5h864q33 0 55.5 24t22.5 59v797q0 34 -25.5 57t-59.5 23zM330 778q52 0 88.5 -37t36.5 -90t-36.5 -90t-88.5 -37t-89 37t-37 90t37 90t89 37zM115 37q-15 0 -26 10q-13 11 -14.5 28t9.5 30l188 287
q11 13 27 14.5t29 -7.5l166 -125l297 342q7 8 15.5 17t25 20t31.5 14t32 -7t29 -37v-19v-63v-77v-97v-314v-12v-2v-1v-1h-807h-2z" />
    <glyph glyph-name="uniE624" unicode="&#xe624;" 
d="M554 244q1 -63 35 -107.5t82 -44.5h236q48 0 82.5 46t34.5 110v235q0 65 -34 111t-83 46h-236q-48 0 -82.5 -46t-34.5 -111h317v-239h-317zM470 244q-1 -63 -35.5 -107.5t-81.5 -44.5h-236q-49 0 -83 45.5t-34 110.5v235q0 65 34.5 111t82.5 46h236q49 0 83 -46t34 -111
h-313v-239h313zM313 365q0 15 11 26.5t27 11.5h316q16 0 27 -11.5t11 -26.5q0 -16 -11 -27t-27 -11h-316q-16 0 -27 11t-11 27z" />
    <glyph glyph-name="uniE625" unicode="&#xe625;" horiz-adv-x="1107" 
d="M784 143l-73 170h-332l-73 -170h-188l342 790h170l342 -790h-188zM546 698l-100 -230h198z" />
    <glyph glyph-name="uniE626" unicode="&#xe626;" 
d="M341 811q0 35 25.5 60t60.5 25h512q35 0 60 -25t25 -60q0 -36 -25 -61t-60 -25h-512q-36 0 -61 25t-25 61zM341 384q0 35 25.5 60t60.5 25h512q35 0 60 -24.5t25 -60.5q0 -35 -25 -60t-60 -25h-512q-36 0 -61 24.5t-25 60.5zM341 -43q0 36 25.5 61t60.5 25h512
q35 0 60 -25t25 -61q0 -35 -25 -60t-60 -25h-512q-36 0 -61 25t-25 60zM85.5 729q35.5 0 60.5 24.5t25 59t-25 59t-60.5 24.5t-60.5 -24.5t-25 -59t25 -59t60.5 -24.5zM85.5 299q35.5 0 60.5 24.5t25 59t-25 59t-60.5 24.5t-60.5 -24.5t-25 -59t25 -59t60.5 -24.5z
M85.5 -128q35.5 0 60.5 24.5t25 59t-25 59t-60.5 24.5t-60.5 -24.5t-25 -59t25 -59t60.5 -24.5z" />
    <glyph glyph-name="uniE627" unicode="&#xe627;" 
d="M256 810.5q0 35.5 25 60.5t60 25h598q35 0 60 -25t25 -60.5t-25 -60.5t-60 -25h-598q-35 0 -60 25t-25 60.5zM85 896h86v-85h-86v85zM256 383.5q0 35.5 25 60.5t60 25h598q35 0 60 -24.5t25 -60t-25 -60.5t-60 -25h-598q-35 0 -60 24.5t-25 60zM256 -42.5q0 35.5 25 60.5
t60 25h598q35 0 60 -25t25 -60.5t-25 -60.5t-60 -25h-598q-35 0 -60 25t-25 60.5zM0 896h85v-85h-85v85zM85 725h86v-85h-86v85zM85 811h86v-86h-86v86zM0 555h85v-86h-85v86zM85 555h86v-86h-86v86zM85 469h86v-85h-86v85zM0 384h85v-85h-85v85zM0 299h85v-86h-85v86z
M85 299h86v-86h-86v86zM0 128h85v-85h-85v85zM85 128h86v-85h-86v85zM85 43h86v-86h-86v86zM85 -43h86v-85h-86v85zM0 -43h85v-85h-85v85z" />
    <glyph glyph-name="uniE628" unicode="&#xe628;" 
d="M427 488v267q0 10 7.5 17.5t17.5 7.5h71q10 0 17 -7.5t7 -17.5v-267l231 133q9 5 19 2.5t15 -10.5l35 -62q5 -9 2.5 -18.5t-11.5 -14.5l-231 -134l231 -133q9 -5 11.5 -15t-2.5 -19l-35 -61q-5 -9 -15 -11.5t-19 2.5l-231 134v-267q0 -11 -7 -18t-17 -7h-71
q-10 0 -17.5 7.5t-7.5 17.5v267l-231 -134q-9 -5 -18.5 -2.5t-14.5 11.5l-36 61q-5 9 -2 19t11 15l232 133l-232 134q-8 5 -11 15t2 18l36 62q5 8 15 10.5t18 -2.5z" />
    <glyph glyph-name="uniE629" unicode="&#xe629;" horiz-adv-x="1025" 
d="M1018 385q0 -103 -40.5 -197.5t-108.5 -162.5t-162 -108t-197 -40q-104 0 -198.5 40.5t-163 109t-108.5 163t-40 198.5t41 198.5t110 162.5t164 107.5t200 39.5q102 0 195 -41t160.5 -109.5t107.5 -162.5t40 -198zM400 255q-100 106 -108 113q-25 25 -55.5 25t-53.5 -23
q-21 -23 -19.5 -50.5t27.5 -52.5q49 -51 137 -139q40 -39 73.5 -39t73.5 40q173 172 215 214q119 119 141.5 142.5t22.5 52.5t-21 50q-20 20 -50.5 19.5t-54.5 -22.5q-8 -7 -31 -30q-50 -51 -297 -300z" />
    <glyph glyph-name="uniE62A" unicode="&#xe62a;" 
d="M511.5 894q-103.5 0 -198 -40.5t-162.5 -108.5t-108.5 -162.5t-40.5 -198t40.5 -198t108.5 -162.5t162.5 -108.5t198 -40.5t197.5 40.5t162.5 108.5t108.5 162.5t40 198t-40 198t-108.5 162.5t-162.5 108.5t-197.5 40.5zM509 67q-27 1 -46 20t-20 46q-1 29 20 50t50 20
q27 -1 46 -20t20 -46q1 -29 -20 -50t-50 -20zM580 324q0 -27 -17 -45.5t-41 -18.5h-20q-24 0 -40.5 18.5t-16.5 45.5l-25 315q0 26 17 44.5t41 18.5h67q24 0 40.5 -18.5t16.5 -44.5z" />
    <glyph glyph-name="uniE62B" unicode="&#xe62b;" 
d="M512 895q-104 0 -198.5 -40.5t-163 -109t-109 -163t-40.5 -198.5t40.5 -198.5t109 -163t163 -109t198.5 -40.5t198.5 40.5t163 109t109 163t40.5 198.5t-40.5 198.5t-109 163t-163 109t-198.5 40.5zM731 176q-18 -20 -45 -21.5t-47 16.5l-168 151q-23 20 -22 51v2v226
q0 27 19 46t46 19t46 -19t19 -46v-202l147 -131q20 -18 21.5 -45t-16.5 -47z" />
    <glyph glyph-name="uniE62C" unicode="&#xe62c;" 
d="M450 400h-105q-26 0 -45 -19t-19 -46t19 -45.5t45 -18.5h105v-100q0 -27 18.5 -45.5t45.5 -18.5t45.5 18.5t18.5 45.5v100h101q26 0 45 19t19 45.5t-19 45.5t-45 19h-101v104q0 26 -18.5 45t-45.5 19t-45.5 -19t-18.5 -45v-104zM269 3q-5 0 -15 1.5t-38 9t-53 19
t-56.5 34.5t-53.5 53.5t-37.5 78t-15.5 104.5q0 104 63 184.5t160 105.5q51 80 134.5 127t181.5 47q137 0 241 -88.5t129 -221.5q53 -34 84 -89t31 -120q0 -146 -114 -221q-27 -18 -48 -24h-593z" />
    <glyph glyph-name="uniE62D" unicode="&#xe62d;" 
d="M576 512h-384v-192h384v-448h192v1024h-192v-384zM832 384h64v-128h-64v128zM896 384h128v-512h-128v512zM0 896h192v-1024h-192v1024z" />
    <glyph glyph-name="uniE62E" unicode="&#xe62e;" 
d="M426 128h1v594h-150q-73 0 -127 -48t-63 -120h-87l86 342h852l86 -342h-87q-9 72 -63 120t-127 48h-150v-594h1q-1 -6 -1 -13q0 -72 50 -123t121 -51v-69h-213h-86h-213v69q71 0 121 51t50 123q0 7 -1 13z" />
    <glyph glyph-name="uniE62F" unicode="&#xe62f;" 
d="M3 700q0 80 56 136t136 56h637q79 0 135 -56t56 -136v-636q0 -80 -56 -136t-135 -56h-637q-79 0 -135.5 56t-56.5 136v636zM510 595q33 0 56 23.5t23 56t-23 55.5t-56 23t-56.5 -23t-23.5 -56t23.5 -56t56.5 -23v0zM571 455q0 27 -17.5 46t-43.5 19t-44 -19t-18 -46v-378
q0 -27 18 -43.5t44 -16.5t44 17t18 44z" />
    <glyph glyph-name="uniE630" unicode="&#xe630;" 
d="M638 8v-11q0 -4 0.5 -10t0.5 -12q-1 -19 -10.5 -41.5t-36.5 -32.5q-11 -4 -28 -11.5t-52 -7.5q-30 0 -49.5 7t-30.5 9q-14 3 -22.5 12.5t-13 21.5t-5.5 24.5t-1 22.5v30zM854 659q26 -61 30 -114.5t-6 -99t-29 -81t-39.5 -62.5t-38.5 -44.5t-25 -23.5q-10 -9 -18 -13.5
t-14.5 -7.5t-12.5 -7t-12 -13q-13 -19 -20 -36.5t-12 -34.5q-5 -14 -11 -23t-13 -16q-8 -8 -16 -13h-219q-8 5 -14 13q-7 7 -14 18t-12 28q-10 29 -24.5 46t-37.5 34q-16 12 -36.5 32t-40 47t-37.5 60t-29 73t-13 85t9 95q17 80 58.5 134t93.5 86.5t107 47t100 14.5
q47 0 97.5 -13t97.5 -40t86.5 -69.5t64.5 -101.5zM753 456q43 174 -111 265q-26 16 -60 25t-70 9t-71.5 -9t-62.5 -28q-68 -46 -92 -101t-22 -115q1 -34 11.5 -61t25 -49t29.5 -38q16 -17 28 -29q25 -27 43 -46q19 -19 30 -49q11 -29 34.5 -35.5t43.5 -6.5q26 0 49.5 11.5
t33.5 35.5q5 14 20.5 34t46.5 56q16 18 30.5 32t27 28t21.5 30.5t15 40.5zM753 456z" />
    <glyph glyph-name="uniE631" unicode="&#xe631;" 
d="M0 768q0 53 37.5 90.5t90.5 37.5h768q53 0 90.5 -37.5t37.5 -90.5v-768q0 -53 -37.5 -90.5t-90.5 -37.5h-768q-53 0 -90.5 37.5t-37.5 90.5v768zM377 411q-45 -18 -68 -27v154h74v85h-74v145h-86v-145h-84v-85h84v-180q-42 -12 -95 -21l21 -84q43 11 74 21v-166
q0 -30 -28 -30q-24 0 -59 6v-86h89q84 0 84 87v217q23 9 68 27v82zM492 443h103v85h-103v236h-86v-632q0 -39 -37 -50l22 -81q123 29 211 64l-16 81q-41 -20 -94 -36v333zM784 2q48 0 71 26q25 28 35 175l-79 26q-4 -104 -15 -125q-10 -20 -28 -20h-33q-25 0 -25 28v335h180
v86h-180v232h-86v-672q0 -91 84 -91h76z" />
    <glyph glyph-name="uniE632" unicode="&#xe632;" 
d="M1002 420l-166 113q-22 15 -37.5 6.5t-15.5 -34.5v-57h-218v207h57q26 0 34 15.5t-6 37.5l-113 166q-15 22 -36 22t-36 -22l-113 -166q-15 -22 -6.5 -37.5t34.5 -15.5h57v-207h-196v57q0 26 -15.5 34.5t-37.5 -6.5l-166 -113q-22 -15 -22 -36t22 -36l166 -113
q22 -15 37.5 -6.5t15.5 34.5v57h196v-207h-57q-26 0 -34.5 -15.5t6.5 -37.5l113 -166q15 -22 36 -22t36 22l113 166q14 22 6 37.5t-34 15.5h-57v207h218v-57q0 -26 15.5 -34.5t37.5 6.5l166 113q22 15 22 36t-22 36z" />
    <glyph glyph-name="uniE633" unicode="&#xe633;" 
d="M448 384h-320q-26 0 -45 -18.5t-19 -45.5v-64h384v-128h128v128h384v64q0 27 -19 45.5t-45 18.5h-320v128h-128v-128zM320 833q0 26 18.5 44.5t44.5 18.5h258q26 0 44.5 -18.5t18.5 -44.5v-258q0 -26 -18.5 -44.5t-44.5 -18.5h-258q-26 0 -44.5 18.5t-18.5 44.5v258z
M64 256h128v-128h-128v128zM832 256h128v-128h-128v128zM384 63q0 27 19 46t46 19h126q27 0 46 -19t19 -46v-126q0 -27 -19 -46t-46 -19h-126q-27 0 -46 19t-19 46v126zM0 63q0 27 19 46t46 19h126q27 0 46 -19t19 -46v-126q0 -27 -19 -46t-46 -19h-126q-27 0 -46 19t-19 46
v126zM768 63q0 27 19 46t46 19h126q27 0 46 -19t19 -46v-126q0 -27 -19 -46t-46 -19h-126q-27 0 -46 19t-19 46v126z" />
    <glyph glyph-name="uniE634" unicode="&#xe634;" horiz-adv-x="1025" 
d="M829 448h-447v-128h448l1 -122q0 -10 5.5 -12.5t12.5 5.5l168 175q7 7 7 17.5t-7 17.5l-171 170q-7 7 -12 4.5t-5 -13.5v-114zM717 192q-51 -87 -139.5 -139.5t-193.5 -52.5q-159 0 -271.5 112.5t-112.5 271.5t112.5 271.5t271.5 112.5q85 0 161 -35q110 -51 171 -157
h-165q-72 64 -168 64q-106 0 -180.5 -75t-74.5 -181t74.5 -181t180.5 -75q97 0 169 64h165z" />
    <glyph glyph-name="uniE635" unicode="&#xe635;" 
d="M32 64q0 -79 60.5 -135.5t145.5 -56.5h548q85 0 145.5 56.5t60.5 135.5v640q0 79 -60.5 135.5t-145.5 56.5h-548q-85 0 -145.5 -56.5t-60.5 -135.5v-640zM160 704q0 26 21 45t50 19h562q29 0 50 -19t21 -45v-640q0 -26 -21 -45t-50 -19h-562q-29 0 -50 19t-21 45v640z
M224 576q0 27 18.5 45.5t45.5 18.5h448q27 0 45.5 -18.5t18.5 -45.5t-18.5 -45.5t-45.5 -18.5h-448q-27 0 -45.5 18.5t-18.5 45.5zM224 384q0 27 18.5 45.5t45.5 18.5h448q27 0 45.5 -18.5t18.5 -45.5t-18.5 -45.5t-45.5 -18.5h-448q-27 0 -45.5 18.5t-18.5 45.5zM224 192
q0 27 18.5 45.5t45.5 18.5h448q27 0 45.5 -18.5t18.5 -45.5t-18.5 -45.5t-45.5 -18.5h-448q-27 0 -45.5 18.5t-18.5 45.5z" />
    <glyph glyph-name="uniE636" unicode="&#xe636;" 
d="M36 565v-1l436 -215v1q20 -12 39.5 -12t40.5 12v-1l436 215v1q33 19 33 51.5t-33 51.5v1l-436 215v-1q-17 10 -40 10q-20 0 -40 -12v1l-436 -213v-1q-33 -19 -33 -51.5t33 -51.5zM948 446q-13 0 -23 -3.5t-14 -6.5l-3 -3l-396 -189l-397 192q-10 6 -39 10
q-35 4 -54 -15.5t-19 -48.5q0 -33 33 -52l436 -216v1q20 -11 40 -11t40 11v-1l436 210q14 9 23.5 24.5t9.5 31.5q0 27 -21.5 46.5t-51.5 19.5zM948 217q-13 0 -23 -3t-14 -6l-3 -4l-396 -189l-397 192q-10 7 -39 10q-35 4 -54 -15t-19 -49q0 -32 33 -51l436 -216v1
q20 -12 40 -12t40 12v-1l436 210q14 8 23.5 23.5t9.5 31.5q0 27 -21.5 46.5t-51.5 19.5zM948 217z" />
    <glyph glyph-name="uniE637" unicode="&#xe637;" 
d="M68 549q0 34 11 49q11 14 49 14h109v-631q1 0 -108 1q-34 -1 -47.5 11.5t-13.5 48.5v181q0 14 4.5 21t17.5 10q5 0 14 4q8 4 17 12t15 21q6 14 6 32q0 29 -15 46q-16 16 -33 19q-14 2 -20 8t-6 20v133v0zM195 669v15v2v1v15q0 25 19 46.5t42 21.5h96v-101h-157v0z
M959 395q-10 -3 -14 -11t-4 -18q0 -9 4 -19t14 -14t16 -15q5 -11 6 -24q0 -12 -3 -24q-4 -11 -11 -16q-25 -15 -25 -34q0 -20 25 -38q4 -4 9 -14q4 -10 4 -20q0 -11 -5 -18q-5 -8 -17 -8h-67q-7 0 -7 2q-1 1 1 4t6 7t7 9q6 18 0 30q-7 13 -21 22q-11 5 -15 16q-4 10 -3 22
q0 11 4 20t11 13q10 3 15 14q5 9 5 21q0 10 -4 21q-4 10 -11 13q-10 5 -15 15q-6 10 -6 23t5 24q5 13 16 20q7 5 12 14q5 8 6 19q1 9 -4 19q-4 10 -15 16q-13 6 -18 18q-6 13 -6 25t6 24q5 12 15 18q21 11 23 31t-3 36q-4 12 -15 23q-11 10 -28 10h-425v99h527q9 0 15 -6
t8 -15t-1 -18q-3 -10 -12 -16q-8 -7 -13 -17q-5 -9 -6 -21q-1 -10 3 -21t14 -16q13 -7 20 -20.5t7 -26.5t-7 -25q-7 -11 -19 -16q-14 -5 -20 -14.5t-7 -20.5q0 -12 5 -22q6 -12 18 -19q13 -7 18 -20q5 -12 5 -25q-1 -13 -6 -24q-6 -10 -17 -12v0zM799 414q-15 -4 -23 -14
q-8 -11 -9 -22q0 -12 6 -23q8 -12 21 -17q12 -5 18 -15q7 -10 7 -21q1 -12 -4 -22t-15 -15q-31 -15 -32 -37q-1 -21 23 -34q12 -5 18 -15q7 -11 8 -23q0 -12 -5 -22q-4 -9 -16 -13q-14 -4 -23 -14q-7 -10 -8 -21.5t6 -22.5t22 -19q9 -5 13.5 -15.5t3.5 -21.5q-2 -10 -7 -18
t-15 -8h-478v631h485q10 0 16 -8q5 -8 6 -18q0 -10 -5 -20t-16 -14t-18 -13q-6 -8 -8 -19q-1 -11 5 -21q7 -10 21 -15q12 -6 18 -15q7 -11 8 -21q0 -11 -5 -21q-6 -9 -18 -13v0zM622 329q-6 0 -13 2q-6 1 -3 7q11 16 12 18q11 16 23 32q3 4 11.5 15.5t13.5 16.5q11 17 13 20
q6 9 -7 23q-3 3 -10 8t-14 8q-10 3 -14 1q-5 -3 -10 -12q-9 -12 -13 -18q-3 -5 -21 -31q-9 -13 -20 -29q-10 -14 -11 -16q-2 -5 -9 -4t-9 6q-3 4 -11 15q-11 13 -21 27q-7 10 -22 28q-10 13 -14 19q-11 21 -24 14q-8 -5 -15 -11q-6 -5 -13 -10q-12 -8 -4 -22q22 -27 37 -47
q18 -23 26 -34q12 -16 15 -19q3 -5 -5 -5h-15q-7 0 -17 -1q-13 0 -22 1q-10 0 -16 -5t-4 -13q1 -5 1 -15v-15q0 -7 4 -7.5t9 -0.5h71q15 0 15 -6v-24q0 -6 -2 -6h-7h-12h-25h-24h-15q-7 1 -10 -4q-2 -5 -4 -12q-1 -6 0 -11t1 -10q0 -16 17 -16h74q6 0 7 -2t1 -8q2 -7 1 -23
q-1 -20 -1 -22q0 -14 16 -14h40q10 0 10 7v9v41q0 13 11 13h11q10 0 19 1h20h16q18 0 18 13v28q0 11 -12 11h-72q-13 -3 -13 5v10q-1 4 -1 10q0 5 4 8q5 2 10 2h73q12 0 12 9v30q0 5 -4.5 10t-10.5 5h-42v0zM622 329z" />
    <glyph glyph-name="uniE638" unicode="&#xe638;" 
d="M1024 -6q0 -53 -34.5 -87.5t-87.5 -34.5h-780q-53 0 -87.5 34.5t-34.5 87.5v614q0 25 10 48q-10 24 -10 45v73q0 53 34.5 87.5t87.5 34.5h780q53 0 87.5 -34.5t34.5 -87.5v-73q0 -22 -10 -45q10 -23 10 -48v-614zM975 774q0 27 -23.5 50t-49.5 23h-780q-27 0 -50 -23
t-23 -50v-73q0 -26 23 -49.5t50 -23.5h780q26 0 49.5 23.5t23.5 49.5v73v0zM975 603q-42 -24 -73 -24h-780q-32 0 -73 24v-609q0 -26 23 -49.5t50 -23.5h780q26 0 49.5 23.5t23.5 49.5v609v0zM878 433h-49q-12 -121 -105.5 -207t-211.5 -86t-211.5 86t-105.5 207h-49
q-13 0 -18.5 5.5t-5.5 18.5q0 26 24 25h147q13 0 18.5 -5.5t5.5 -19t-5.5 -19t-18.5 -5.5h-49q12 -99 87 -171.5t181 -72.5t181 72.5t87 171.5h-49q-13 0 -18.5 5.5t-5.5 19t5.5 19t18.5 5.5h147q8 0 16 -6.5t8 -18.5q0 -13 -5.5 -18.5t-18.5 -5.5v0z" />
    <glyph glyph-name="uniE639" unicode="&#xe639;" 
d="M853 896h-682q-71 0 -121 -50t-50 -121v-682q0 -71 50 -121t121 -50h682q71 0 121 50t50 121v682q0 71 -50 121t-121 50v0zM960 51q0 -48 -34 -82t-82 -34h-664q-48 0 -82 34t-34 82v665q0 48 34 82t82 34h664q48 0 82 -34t34 -82v-665v0zM865 319h-73q-13 0 -21 -6
t-14 -23l-40 -82l-64 486q-4 32 -41 32q-33 0 -39 -33l-99 -499l-79 393q-6 29 -43 29q-3 0 -9 -1.5t-15.5 -7.5t-11.5 -17l-84 -271h-71q-16 0 -25.5 -8.5t-9.5 -23.5t9.5 -23.5t25.5 -8.5h79l4 -1q3 0 6 0.5t8 1t9 2t8.5 4.5t8 8t6.5 12l59 202l85 -427q0 -13 8 -23
t21 -13q15 -3 27.5 5.5t15.5 23.5l106 483l44 -418q4 -30 41 -32q28 -1 40 21l79 152h49q32 0 32 31.5t-32 31.5v0z" />
    <glyph glyph-name="uniE63A" unicode="&#xe63a;" 
d="M1006 574h-874q-55 0 -93.5 -35.5t-38.5 -85.5v-459q0 -51 38.5 -86.5t93.5 -35.5h876q-10 25 -11 39q0 14 27 43v43q-27 28 -27 42q0 7 7 17.5t13 18.5l7 7v43q-27 29 -27 43q0 6 7 17t13 18l7 8v43q-27 28 -27 43q0 6 7 17t13 18l7 8v42q-27 29 -27 43q0 7 7 17.5
t13 18.5l7 7v43q-27 28 -27 43q0 6 2.5 11.5t4.5 6.5l2 2v0zM952 519v-51q-27 -28 -27 -43q0 -6 6.5 -17t13.5 -18l7 -8v-42q-27 -29 -27 -43q0 -7 6.5 -17.5t13.5 -18.5l7 -7v-43q-27 -29 -27 -43q0 -6 6.5 -17t13.5 -18l7 -8v-43q-27 -28 -27 -43q0 -6 6.5 -16.5
t13.5 -18.5t7 -7v-45l-9 -24h-819q-22 0 -43 25t-21 57v458q1 15 16.5 33t31.5 18h844v0zM519 136v1h-103v63h103v0q10 0 16.5 6.5t6.5 16t-6.5 16t-16.5 6.5v0h-88l97 179q6 8 6 17q0 12 -8.5 20.5t-20.5 8.5q-21 0 -28 -19q-84 -164 -88 -175h-1l-92 175v0q-7 19 -27 19
q-12 0 -20 -8.5t-8 -19.5q0 -9 4 -17l97 -180h-90q-10 0 -16.5 -6.5t-6.5 -16t6.5 -16t16.5 -6.5h107v-63h-107v-1q-10 0 -16.5 -6.5t-6.5 -15.5t6.5 -16t16.5 -7h107v-91v-6q0 -11 8 -19.5t20 -8.5t20 8.5t8 19.5v6h1v91h103v0q10 0 16.5 7t6.5 16t-6.5 15.5t-16.5 6.5v0z
M703 455q0 10 9 17.5t22 7.5q12 0 21.5 -7.5t9.5 -17.5v-39q0 -10 -9.5 -17.5t-21.5 -7.5q-13 0 -22 7.5t-9 17.5v39v0zM703 314q0 11 9 18.5t22 7.5q12 0 21.5 -7.5t9.5 -18.5v-38q0 -10 -9.5 -17.5t-21.5 -7.5q-13 0 -22 7.5t-9 17.5v38v0zM703 174q0 10 9 17.5t22 7.5
q12 0 21.5 -7.5t9.5 -17.5v-38q0 -11 -9.5 -18.5t-21.5 -7.5q-13 0 -22 7.5t-9 18.5v38v0zM703 34q0 10 9 17.5t22 7.5q12 0 21.5 -7.5t9.5 -17.5v-39q0 -10 -9.5 -17.5t-21.5 -7.5q-13 0 -22 7.5t-9 17.5v39v0zM213 613l26 69q6 13 25 20.5t35 1.5l239 -91h179l-380 145
q-51 19 -100 -0.5t-67 -66.5l-29 -78h72v0zM423 769l47 55q11 10 31 11t34 -10l202 -174l101 -38h41l-291 249q-41 36 -93.5 34t-85.5 -40l-53 -62l67 -25v0z" />
    <glyph glyph-name="uniE63B" unicode="&#xe63b;" 
d="M995 37l-169 169q71 111 71 241q0 91 -35.5 174t-95.5 143t-143 95.5t-174 35.5t-174 -35.5t-143 -95.5t-95.5 -143t-35.5 -174t35.5 -174t95.5 -143t143 -95.5t174 -35.5q129 0 241 71l169 -169q28 -28 68 -28t68 28t28 68t-28 68zM449 127q-87 0 -160.5 43
t-116.5 116.5t-43 160.5t43 160.5t116.5 116.5t160.5 43t160.5 -43t116.5 -116.5t43 -160.5t-43 -160.5t-116.5 -116.5t-160.5 -43zM577 511h-64v64q0 27 -19 45.5t-45.5 18.5t-45 -18.5t-18.5 -45.5v-64h-64q-27 0 -45.5 -18.5t-18.5 -45t18.5 -45.5t45.5 -19h64v-64
q0 -26 18.5 -45t45 -19t45.5 19t19 45v64h64q26 0 45 19t19 45.5t-19 45t-45 18.5z" />
    <glyph glyph-name="uniE63C" unicode="&#xe63c;" 
d="M320 576q0 80 56 136t136 56t136 -56t56 -136q0 -31 -12 -64h140v64q0 133 -93.5 226.5t-226.5 93.5t-226.5 -93.5t-93.5 -226.5v-64h140q-12 33 -12 64zM878 512h-732q-60 0 -103 -37.5t-43 -90.5v-384q0 -53 43 -90.5t103 -37.5h732q60 0 103 37.5t43 90.5v384
q0 53 -43 90.5t-103 37.5zM573 146v-82q0 -26 -18.5 -45t-45 -19t-45.5 19t-19 45v82q-29 17 -46.5 46t-17.5 64q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5q0 -35 -17 -64t-47 -46z" />
    <glyph glyph-name="uniE63D" unicode="&#xe63d;" 
d="M511.5 -209q-103.5 0 -197.5 40.5t-162 108.5t-108.5 162t-40.5 197.5t40.5 198t108.5 162.5t162 108.5t197.5 40.5t198 -40.5t162.5 -108.5t108.5 -162.5t40.5 -198t-40.5 -197.5t-108.5 -162t-162.5 -108.5t-198 -40.5zM512 -63q109 0 201 60l-504 504
q-60 -92 -60 -201q0 -99 48.5 -182.5t132 -132t182.5 -48.5zM512 663q-109 0 -201 -60l504 -504q60 92 60 201q0 99 -48.5 182.5t-132 132t-182.5 48.5z" />
    <glyph glyph-name="uniE63E" unicode="&#xe63e;" 
d="M872 743q-72 72 -165 110.5t-195 38.5t-194.5 -38.5t-164.5 -110.5t-110.5 -164.5t-38.5 -194.5t38.5 -194.5t110.5 -164.5t164.5 -110.5t194.5 -38.5t195 38.5t165 110.5q97 97 131.5 228t0 262t-131.5 228v0zM825 72q-63 -63 -143.5 -96.5t-169 -33.5t-169.5 33.5
t-143.5 96t-96 143.5t-33.5 169.5t33.5 169t96 143t143.5 96t169.5 33.5t169 -33.5t143.5 -95.5q85 -85 115 -199t0 -227.5t-115 -198.5v0zM684 549q-25 0 -42.5 -17.5t-17.5 -42t17.5 -42t42.5 -17.5t42 17.5t17 42t-17 42t-42 17.5v0zM367 430q25 0 42.5 17.5t17.5 42
t-17.5 42t-42.5 17.5t-42.5 -17.5t-17.5 -42t17.5 -42t42.5 -17.5v0zM513 298q-62 0 -114.5 -29.5t-85.5 -80.5q-10 -15 -1.5 -31.5t26.5 -16.5h2q16 0 25 13q25 37 64 58.5t84 21.5t84 -21.5t64 -58.5q8 -13 24 -13h2q18 0 26.5 16.5t-1.5 31.5q-33 51 -85.5 80.5
t-113.5 29.5v0zM513 298z" />
    <glyph glyph-name="uniE63F" unicode="&#xe63f;" 
d="M896 832q29 0 46.5 -17.5t17.5 -46.5v-768q0 -29 -17.5 -46.5t-46.5 -17.5h-768q-29 0 -46.5 17.5t-17.5 46.5v768q0 29 17.5 46.5t46.5 17.5h768zM896 896h-768q-53 0 -90.5 -37.5t-37.5 -90.5v-768q0 -53 37.5 -90.5t90.5 -37.5h768q53 0 90.5 37.5t37.5 90.5v768
q0 53 -37.5 90.5t-90.5 37.5v0zM339 416q-13 -13 -13 -32t13 -32l1 -1l1 -1l1 -1h1v-1l1 -1h1v-1l1 -1l1 -1h1v-1l1 -1l1 -1l1 -1l1 -1l1 -1l1 -1h1l1 -1l1 -1l1 -2l263 -263q14 -14 31.5 -14t32 14.5t14.5 32t-14 31.5l-250 250l250 250q14 14 14 31.5t-14.5 32t-32 14.5
t-31.5 -14l-282 -282v0z" />
    <glyph glyph-name="uniE640" unicode="&#xe640;" 
d="M128 832q-29 0 -46.5 -17.5t-17.5 -46.5v-768q0 -29 17.5 -46.5t46.5 -17.5h768q29 0 46.5 17.5t17.5 46.5v768q0 29 -17.5 46.5t-46.5 17.5h-768zM128 896h768q53 0 90.5 -37.5t37.5 -90.5v-768q0 -53 -37.5 -90.5t-90.5 -37.5h-768q-53 0 -90.5 37.5t-37.5 90.5v768
q0 53 37.5 90.5t90.5 37.5v0zM685 416q13 -13 13 -32t-13 -32l-1 -1l-1 -1l-1 -1h-1v-1l-1 -1h-1v-1l-1 -1l-1 -1h-1v-1l-1 -1l-1 -1l-1 -1l-1 -1l-1 -1l-1 -1h-1l-1 -1l-1 -1l-1 -2l-263 -263q-14 -14 -31.5 -14t-32 14.5t-14.5 32t14 31.5l250 250l-250 250
q-14 14 -14 31.5t14.5 32t32 14.5t31.5 -14l282 -282v0z" />
    <glyph glyph-name="uniE641" unicode="&#xe641;" 
d="M0 703q0 80 56 136.5t137 56.5h638q80 0 136.5 -56t56.5 -137v-638q0 -80 -56 -136.5t-137 -56.5h-638q-80 0 -136.5 56t-56.5 137v638zM509 22q33 0 56 23.5t23 56t-23 56t-56 23.5t-57 -23.5t-24 -56t24 -56t57 -23.5v0zM570 714q0 27 -17.5 45.5t-43.5 18.5
t-44.5 -18.5t-18.5 -45.5v-380q0 -27 18.5 -43.5t44.5 -16.5t44 17t18 44z" />
    <glyph glyph-name="uniE642" unicode="&#xe642;" 
d="M849 604l-155 1q-17 0 -29 12t-12 28v81q0 33 -23.5 56.5t-56.5 23.5q-27 0 -48 -16l-405 -334q-30 -29 -30 -71t30 -71l405 -334q21 -16 48 -16q33 0 56.5 23.5t23.5 56.5v80q0 17 12 28.5t29 11.5l155 1q33 0 56.5 23.5t23.5 56.5v280q0 33 -23.5 56t-56.5 23z" />
    <glyph glyph-name="uniE643" unicode="&#xe643;" 
d="M170 604l155 1q17 0 28.5 12t11.5 28v81q0 33 23.5 56.5t57.5 23.5q26 0 48 -16l405 -334q30 -29 30 -71t-30 -71l-405 -334q-22 -16 -48 -16q-34 0 -57.5 23.5t-23.5 56.5v80q0 17 -11.5 28.5t-28.5 11.5l-155 1q-33 0 -56.5 23.5t-23.5 56.5v280q0 33 23.5 56t56.5 23z
" />
    <glyph glyph-name="uniE644" unicode="&#xe644;" 
d="M448 226l-173 -60l5 251l-152 200l241 73l143 206l143 -206l241 -73l-152 -200l5 -251l-173 60v-290q0 -27 -18.5 -45.5t-45.5 -18.5t-45.5 18.5t-18.5 45.5v290z" />
    <glyph glyph-name="uniE645" unicode="&#xe645;" 
d="M804 539q-11 4 -48.5 5.5t-76 3t-86 14t-80.5 37.5q-170 148 -325 135q-20 -1 -38.5 -8.5t-31 -17t-22 -19t-13.5 -15.5l-4 -7q-16 -27 -7 -58l224 -719q8 -27 32.5 -40t50 -4t38 34.5t3.5 53.5l-59 191q17 13 39 19.5t39.5 7.5t40 -3t34.5 -7.5t31 -10t20 -6.5
q5 -2 32.5 -15t60.5 -27t75 -30t80.5 -22.5t71 -4.5t52 23.5t19.5 62.5q0 92 -26 191t-61.5 162.5t-64.5 73.5zM500 253q-2 1 -15 4.5t-22 5.5t-25 5t-29.5 3t-29.5 -1.5t-30.5 -7t-26.5 -14.5l-115 372q85 9 259 -108q33 -18 90 -30.5t111 -18.5t61 -8q36 -10 73.5 -92
t37.5 -167q0 -33 -32 -40t-80.5 7.5t-95 33t-87 37t-44.5 19.5z" />
    <glyph glyph-name="uniE646" unicode="&#xe646;" 
d="M949 545v2q0 3 -1 5l-76 175q-10 28 -36 45t-59 17h-531q-33 0 -58 -16t-34 -45l-81 -178q-1 -1 -2 -4q-8 -27 -8 -56q0 -49 25 -91t69 -65v0v0q36 -19 83 -19q83 0 136 63q52 -62 135 -63q81 1 134 63q53 -62 136 -62q48 0 85 20q42 23 67 64.5t25 90.5q0 28 -9 54v0z
M859 289q-14 0 -23 -9.5t-9 -22.5v-194q0 -7 -5.5 -12.5t-13.5 -5.5h-607q-8 0 -13 5.5t-5 12.5v190q0 13 -9.5 22.5t-23.5 9.5q-13 0 -22.5 -9.5t-9.5 -22.5v-190q0 -34 24.5 -58t58.5 -24h608q34 0 58 24t24 58v194q0 13 -9.5 22.5t-22.5 9.5v0zM784 510h-546
q-13 0 -24 13t-11 28t11 28t24 13h546q14 0 25 -13t11 -28t-11 -28t-25 -13v0zM784 510z" />
    <glyph glyph-name="uniE647" unicode="&#xe647;" 
d="M512 896q-139 0 -257 -68.5t-186.5 -186.5t-68.5 -257t68.5 -257t186.5 -186.5t257 -68.5t257 68.5t186.5 186.5t68.5 257t-68.5 257t-186.5 186.5t-257 68.5zM270 289q-39 0 -67 28t-28 67t28 67t67.5 28t67 -28t27.5 -67t-27.5 -67t-67.5 -28zM512 289q-39 0 -67 28
t-28 67t28 67t67 28t67 -28t28 -67t-28 -67t-67 -28zM754 289q-40 0 -67.5 28t-27.5 67t27.5 67t67 28t67.5 -28t28 -67t-28 -67t-67 -28z" />
    <glyph glyph-name="uniE648" unicode="&#xe648;" 
d="M832 30q0 -33 -23 -56t-55 -23h-469q-33 0 -55.5 23t-22.5 56v708q0 33 22.5 56t55.5 23h284q11 -2 17 -9t8 -20t2.5 -21.5t0.5 -26.5v-120q0 -16 11.5 -27.5t27.5 -11.5h118q19 0 29 -1t23.5 -4t19.5 -11.5t6 -22.5v-512zM803 730l-29 29l-29 29q-58 60 -88.5 84
t-59.5 24h-312q-65 0 -111 -46t-46 -112v-708q0 -66 46 -112t111 -46h469q64 0 110 46t46 112v551q0 29 -24 60t-83 89zM363 463h-78v-79h78v79zM363 305h-78v-79h78v79zM363 148h-78v-79h78v79zM754 463h-313v-79h313v79zM754 305h-313v-79h313v79zM754 148h-313v-79h313
v79zM324 699q-16 0 -27.5 -11.5t-11.5 -27.5v-40q0 -16 11.5 -27.5t27.5 -11.5h206q-11 19 -11 39v79h-195z" />
    <glyph glyph-name="uniE649" unicode="&#xe649;" 
d="M512 891q-103 0 -197.5 -40.5t-162.5 -108.5t-108.5 -162.5t-40.5 -198t40.5 -198t108.5 -162.5t162.5 -108.5t198 -40.5t197.5 40.5t162.5 108.5t108.5 162.5t40 198t-40 198t-108.5 162.5t-162.5 108.5t-198 40.5zM542 116q-17 -16 -40 -16t-40 15t-17 43
q0 23 16.5 39.5t40.5 16.5t40.5 -16.5t16.5 -39.5q0 -27 -17 -42zM682 466q-13 -24 -31 -41.5t-64 -59.5q-13 -12 -20.5 -20.5t-11.5 -16t-6 -15t-6 -25.5q-7 -39 -45 -39q-20 0 -33 12.5t-13 37.5q0 32 9.5 55.5t26 41t43.5 41.5q25 21 35.5 31.5t18 24t7.5 28.5
q0 30 -22.5 51t-58.5 21q-41 0 -60.5 -21t-33.5 -62q-13 -42 -49 -42q-21 0 -35.5 15t-14.5 32q0 36 23 72.5t67 61t103 24.5q55 0 97 -20.5t64.5 -55t22.5 -75.5q0 -32 -13 -56z" />
    <glyph glyph-name="uniE64A" unicode="&#xe64a;" 
d="M640 -64q27 0 45.5 18.5t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM384 -64q27 0 45.5 18.5t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM640 192q27 0 45.5 18.5
t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM384 192q27 0 45.5 18.5t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM640 448q27 0 45.5 18.5t18.5 45.5t-18.5 45.5
t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM384 448q27 0 45.5 18.5t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM640 704q27 0 45.5 18.5t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5
t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0zM384 704q27 0 45.5 18.5t18.5 45.5t-18.5 45.5t-45.5 18.5t-45.5 -18.5t-18.5 -45.5t18.5 -45.5t45.5 -18.5v0v0v0v0v0v0z" />
    <glyph glyph-name="uniE64B" unicode="&#xe64b;" 
d="M842 341q3 25 3 43t-3 43l94 74q14 11 5 28l-89 154q-10 16 -27 9l-111 -44q-35 27 -75 44l-16 117q-2 8 -8 13.5t-14 5.5h-178q-8 0 -14 -5.5t-8 -13.5l-16 -117q-41 -17 -75 -44l-111 44q-18 7 -27 -9l-89 -154q-9 -16 5 -28l94 -74q-3 -25 -3 -43t3 -43l-94 -74
q-14 -11 -5 -28l89 -154q10 -16 27 -9l111 44q35 -27 75 -44l16 -117q2 -8 8 -13.5t14 -5.5h178q8 0 14 5.5t8 13.5l16 117q41 17 75 44l111 -44q17 -7 27 9l89 154q9 16 -6 28zM511.5 229q-64.5 0 -109.5 45.5t-45 109.5t45 109.5t109.5 45.5t110 -45.5t45.5 -109.5
t-45.5 -109.5t-110 -45.5z" />
    <glyph glyph-name="uniE64C" unicode="&#xe64c;" 
d="M512 832q-185 0 -316.5 -131.5t-131.5 -316.5t131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5t-131.5 316.5t-316.5 131.5zM641 320q13 0 22.5 -9.5t9.5 -22.5t-9.5 -22.5t-22.5 -9.5h-97v-95q0 -13 -9.5 -22.5t-22.5 -9.5t-22.5 9.5t-9.5 22.5v95h-95
q-13 0 -22.5 9.5t-9.5 22.5t9.5 22.5t22.5 9.5h95v64h-95q-13 0 -22.5 9.5t-9.5 22.5t9.5 22.5t22.5 9.5h95v20l-118 118q-10 10 -9.5 23t9.5 22.5t22.5 9.5t22.5 -9l108 -108l101 107q10 10 23 10t22.5 -9t10 -22t-9.5 -23l-118 -124v-15h97q13 0 22.5 -9.5t9.5 -22.5
t-9.5 -22.5t-22.5 -9.5h-97v-64h97z" />
    <glyph glyph-name="uniE64D" unicode="&#xe64d;" 
d="M828 312q-23 114 -111 189t-205 75q-92 0 -167.5 -48t-114.5 -128q-99 -13 -164.5 -87.5t-65.5 -176.5q0 -109 75 -186.5t181 -77.5h555q89 0 151 64t62 156q0 85 -58 149t-138 71zM576 64q0 -27 -18.5 -45.5t-45.5 -18.5h-64q-27 0 -45.5 19t-18.5 45v125l-96 2
q-26 0 -32 13.5t13 32.5l166 166q19 19 45 19t45 -19l166 -166q19 -19 13 -32t-32 -13h-96v-128z" />
    <glyph glyph-name="uniE64E" unicode="&#xe64e;" horiz-adv-x="1025" 
d="M512 -127q103 0 196.5 39.5t162 106t109.5 159t44 194.5q-3 -119 -59 -219t-151 -158t-206 -58q-113 0 -208.5 60t-151 163t-55.5 224q0 40 -28.5 68t-68 28t-67.5 -28t-28 -68q0 -104 40.5 -198.5t109 -163t163 -109t198.5 -40.5zM512 896q-102 0 -195.5 -39.5
t-162 -106t-110 -159t-43.5 -195.5q3 119 59 219.5t150.5 158.5t206.5 58t208 -60t151.5 -163t55.5 -225q0 -39 28 -67t68 -28t68 28t28 67q0 105 -40.5 199.5t-109 163t-163 109t-199.5 40.5z" />
    <glyph glyph-name="uniE64F" unicode="&#xe64f;" 
d="M944 -120h-288q-30 0 -51 21.5t-21 50.5v288q0 30 21 51t51 21h288q29 0 50.5 -21t21.5 -51v-288q0 -29 -21.5 -50.5t-50.5 -21.5zM944 456h-288q-30 0 -51 21t-21 51v288q0 29 21 50.5t51 21.5h288q29 0 50.5 -21.5t21.5 -50.5v-288q0 -30 -21.5 -51t-50.5 -21z
M368 -120h-288q-29 0 -50.5 21.5t-21.5 50.5v288q0 30 21.5 51t50.5 21h288q30 0 51 -21t21 -51v-288q0 -29 -21 -50.5t-51 -21.5zM368 456h-288q-29 0 -50.5 21t-21.5 51v288q0 29 21.5 50.5t50.5 21.5h288q30 0 51 -21.5t21 -50.5v-288q0 -30 -21 -51t-51 -21z" />
    <glyph glyph-name="uniE650" unicode="&#xe650;" horiz-adv-x="1025" 
d="M1023 -128h-1022q0 2 -0.5 8t-0.5 10q0 104 40.5 199t109 163.5t163.5 109t199 40.5t199 -40.5t163.5 -109t109 -163.5t40.5 -199q0 -4 -0.5 -10t-0.5 -8zM695.5 215.5q-10.5 9.5 -25.5 9.5t-26 -10l-169 -158l-24 23q-24 22 -49 44l-24 23q-10 10 -25 9.5t-26 -10
t-10.5 -23.5t10.5 -24l122 -111q11 -10 26 -10t26 10l194 180q11 10 11 24t-10.5 23.5z" />
    <glyph glyph-name="uniE651" unicode="&#xe651;" 
d="M822 513h-80q0 97 -65 163t-160 66t-160 -66t-65 -163h-81q0 78 40.5 149t112 115.5t153 44.5t153 -44.5t112 -115.5t40.5 -149zM870 381q0 33 -23.5 57t-57.5 24h-538q-33 0 -56.5 -24t-23.5 -57v-382q0 -34 23.5 -57.5t56.5 -23.5h538q34 0 57.5 23.5t23.5 57.5v382z
M585 82q0 -25 -17.5 -42.5t-42.5 -17.5h-9q-25 0 -42.5 17.5t-17.5 42.5v164q0 25 17.5 42.5t42.5 17.5h9q25 0 42.5 -17.5t17.5 -42.5v-164z" />
    <glyph glyph-name="uniE652" unicode="&#xe652;" 
d="M923 -128h-324h-1h-504q-18 0 -30.5 12.5t-12.5 30.5v938q0 18 12.5 30.5t30.5 12.5h504q17 0 29.5 -12.5t12.5 -30.5v-341h283q21 0 35.5 -11t14.5 -26v-566q0 -15 -14.5 -26t-35.5 -11zM512 691h-333v-77h333v77zM512 486h-333v-76h333v76zM512 282h-333v-77h333v77z
M845 358h-179v-153h179v153z" />
    <glyph glyph-name="uniE653" unicode="&#xe653;" 
d="M617 -128h-216q-60 0 -90 0.5t-77.5 2.5t-71 6.5t-49.5 12.5t-36.5 21.5t-10.5 31.5v21q0 90 45 166.5t122 120.5t168 44h217q91 0 168.5 -44t122 -120.5t44.5 -166.5v-21q0 -14 -6 -24.5t-20.5 -18t-30 -13t-42 -9t-49 -6t-58 -3t-62 -1t-68.5 -0.5zM498.5 384
q-107.5 0 -183.5 75t-76 181t76 181t183.5 75t183.5 -75t76 -181t-76 -181t-183.5 -75z" />
    <glyph glyph-name="uniE654" unicode="&#xe654;" horiz-adv-x="1025" 
d="M104 553q33 31 56 20t23 -57v-198q0 -47 -23.5 -59t-57.5 18l-68 60q-33 30 -34 73t32 74zM920 553q-33 31 -55.5 20t-22.5 -57v-198q0 -47 23.5 -59t56.5 18l68 60q33 30 34 73t-32 74zM183 485h658v-148h-658v148z" />
    <glyph glyph-name="uniE655" unicode="&#xe655;" 
d="M846 179h-93v-46h93q14 0 23.5 -10t9.5 -23.5t-9.5 -23t-23.5 -9.5h-93v-47q0 -14 -9.5 -23.5t-23 -9.5t-23 9.5t-9.5 23.5v47h-93q-14 0 -23.5 9.5t-9.5 23t9.5 23.5t23.5 10h93v46h-93q-14 0 -23.5 10t-9.5 23.5t9.5 23t23.5 9.5h42l-52 52q-9 10 -9 23.5t9.5 23
t23 9.5t23.5 -9l86 -87l87 87q10 9 23.5 9t23 -9.5t9.5 -23t-10 -23.5l-52 -52h47q14 0 23.5 -9.5t9.5 -23t-9.5 -23.5t-23.5 -10zM949 275q-19 45 -54 80t-80 54q-47 20 -98 20t-97 -20q-45 -19 -80 -54t-54 -80q-20 -47 -20 -98t20 -98q19 -45 54 -79.5t80 -54.5
q46 -19 97 -19t98 19q45 20 80 54.5t54 79.5q19 47 19 98t-19 98zM668 716h-259q-22 0 -37.5 -15.5t-15.5 -38t15.5 -38t37.5 -15.5h259q22 0 37.5 15.5t15.5 38t-15.5 38t-37.5 15.5zM230 716h-71q-23 0 -38.5 -15.5t-15.5 -38t15.5 -38t38.5 -15.5h71q23 0 38.5 15.5
t15.5 38t-15.5 38t-38.5 15.5zM161 393h341q42 42 97 65q52 23 109 24q-16 19 -40 19h-507q-22 0 -38 -16t-16 -38.5t16 -38t38 -15.5zM161 177h252q0 56 19 108h-271q-22 0 -38 -15.5t-16 -38t16 -38.5t38 -16zM998 58q-23 -54 -65 -96.5t-97 -65.5q-57 -24 -119 -24
t-118 24q-30 13 -56 31h-470q-30 0 -51.5 21t-21.5 51v825q0 30 21 51t51 21h601q153 0 153 -137v-297l10 -4q55 -23 97 -65t65 -97q24 -57 24 -119t-24 -119z" />
    <glyph glyph-name="uniE656" unicode="&#xe656;" horiz-adv-x="1107" 
d="M864 -119l-95 221h-429l-95 -221h-243l442 1023h221l442 -1023h-243zM555 600l-128 -297h256z" />
  </font>
</defs></svg>
"
|
|
|
|
/***/ }),
|
|
/* 195 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = "data:application/x-font-ttf;base64,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"
|
|
|
|
/***/ }),
|
|
/* 196 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = "data:application/font-woff;base64,d09GRgABAAAAAEZYABAAAAAAdmQAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRlRNAAABbAAAABsAAAAcdFJSr0dERUYAAAGIAAAAHQAAACAAiAAET1MvMgAAAagAAABNAAAAYFfAXSljbWFwAAAB+AAAAE4AAAFKy/Ihr2N2dCAAAAJIAAAAGAAAACQNr/5SZnBnbQAAAmAAAAT8AAAJljD3npVnYXNwAAAHXAAAAAgAAAAIAAAAEGdseWYAAAdkAAA6CQAAYKRXVuwTaGVhZAAAQXAAAAAvAAAANgua87NoaGVhAABBoAAAAB4AAAAkCFcD3WhtdHgAAEHAAAAAmwAAAWxjqw4mbG9jYQAAQlwAAAC4AAAAuPR+CrhtYXhwAABDFAAAACAAAAAgAlEEAG5hbWUAAEM0AAABRQAAAkA1g+4ecG9zdAAARHwAAAFDAAADkEEe4C5wcmVwAABFwAAAAJUAAACVpbm+ZnicY2BgYGQAgjO2i86D6Ctc4e+h9AcASQYGxQB4nGNgZGBg4ANiCQYQYGJgBMIoIGYB8xgACCgAjQAAAHicY2BhYWL8wsDKwMA0k+kMAwNDP4RmfM1gzMgJFGVgY2aAAUYBBgQISHNNYTjAUPEsjLnhfwNDDPNShosgNSA5ZgmwEgUGRgCbXw2SAAAAeJxjYGBgZoBgGQZGBhBwAfIYwXwWBg0gzQakGRmYGCqehf3/D+RXPGP4//9/txQLVD0QMLIxwDmMTECCiQEVMDLQDDDTzmiSAAB7VwmJAAB4nGNgQANGDEbMEv8fMi/9rw+jAURCCAd4nJ1VaXfTRhSVvGRP2pLEUETbMROnNBqZsAUDLgQpsgvp4kBoJegiJzFd+AN87Gf9mqfQntOP/LTeO14SWnpO2xxL776ZO2/TexNxjKjseSCuUUdKXveksv5UKvGzpK7rXp4o6fWSumynnpIWUStNlczF/SO5RHUuVrJJsEnG616inqs874PSSzKsKEsi2iLayrwsTVNPHD9NtTi9ZJCmgZSMgp1Ko48QqlEvkaoOZUqHXr2eipsFUjYa8aijonoQKu4czzmljTpgpHKVw1yxWW3ke0nW8/qP0kSn2Nt+nGDDY/QjV4FUjMzA9jQeh08k09FeIjORf+y4TpSFUhtcAK9qsMegSvGhuPFBthPI1HjN8XVRqTQyFee6z7LZLB2PlRDlwd/YoZQbur+Ds9OmqFZjcfvAMwY5KZQoekgWgA5Tmaf2CNo8tEBmjfqj4hzwdQgvshBlKs+ULOhQBzJndveTYtrdSddkcaBfBjJvdveS3cfDRa+O9WW7vmAKZzF6khSLixHchzLrp0y71AhHGRdzwMU8XuLWtELIyAKMSiPMUVv4ntmoa5wdY290Ho/VU2TSRfzdTH49OKlY4TjLekfcSJy7x67rwlUgiwinGu8njizqUGWw+vvSkussOGGYZ8VCxZcXvncR+S8xbj+Qd0zhUr5rihLle6YoU54xRYVyGYWlXDHFFOWqKaYpa6aYoTxrilnKc0am/X/p+334Pocz5+Gb0oNvygvwTfkBfFN+CN+UH8E3pYJvyjp8U16Eb0pt4G0pUxGqmLF0+O0lWrWhajkzuMA+D2TNiPZFbwTSMEp11Ukpdb+lVf4k+euix2Prk5K6NWlsiLu6abP4+HTGb25dMuqGnatPjCPloT109dg0oVP7zeHfzl3dKi65q4hqw6g2IpgEgDbotwLxTfNsOxDzll18/EMwAtTPqTVUU3Xt1JUaD/K8q7sYnuTA44hjoI3rrq7ASxNTVkPz4WcpMhX7g7yplWrnsHX5ZFs1hzakwtsi9pVknKbtveRVSZWV96q0Xj6fhiF6ehbXhLZs3cmkEqFRM87x8K4qRdmRlnLUP0Lnl6K+B5xxdkHrwzHuRN1BtTXsdPj5ZiNrCyaGprS9E6BkLF0VY1HlWZxjdA1rHW/cEp6upycW8Sk2mY/CSnV9lI9uI80rdllm0ahKdXSX9lnsqzb9MjtoWB1nP2mqNu7qYVuNKlI9Vb4GtAd2Vt34UA8rPuqgUVU12+jayGM0LmvGfwzIYlz560arJtPv4JZqp81izV1Bc9+YLPdOL2+9yX4r56aRpv9Woy0jl/0cjvltEeDfOSh2U9ZAvTVpiHEB2QsYLtVE5w7N3cYg4jr7H53T/W/NwiA5q22N2Tz14erpKJI7THmcZZtZ1vUozVG0k8Q+RWKrw4nBTY3hWG7KBgbk7j+s38M94K4siw+8bSSAuM/axKie6uDuHlcjNOwruQ8YmWPHuQ2wA+ASxObYtSsdALvSJecOwGfkEDwgh+AhOQS75NwE+Jwcgi/IIfiSHIKvyLkF0COHYI8cgkfkEDwmpw2wTw7BE3IIviaH4BtyWgAJOQQpOQRPySF4ZmRzUuZvqch1oO8sugH0ve0aKFtQfjByZcLOqFh23yKyDywi9dDI1Qn1iIqlDiwi9blFpP5o5NqE+hMVS/3ZIlJ/sYjUF8aXmYGU13oveUcHfwIrvqx+AAEAAf//AA94nO18CXRcV5nmXd5e21uq6tVeqipVlaSyVFKVSiVZ25NtyYusSLItyWU7jp0o8pKEOGSns4gkhjidhg4hTiDMAN0hAacJgYQlK+5AszVLA+kOMIQDExoYJtDDNJnT0Nbz/PdVyZKdhA7LmTNzzkhV99333n237rv3X77/v/+9iKA0QrhETiCKRNRq5RBClCA6hwjGZBwRgic5yOH1CIkCz0ExqvG+QllLafmylklj9Zdf/So5sTSbJgvwLI/WnP4RfZqGUBB1orVoG9qLrx1/1JjaaW0hGHm8HuRdQNSLvXQvwpKE96hYlhRB3qtht8AJ7r3IxbkO+bCEBLck7ESKyBPOpXA1HXu9nmnk8SjeddHxR02ocfx31CjJysLvWWUIqtz6xqrkFt5QndZ551SHF6A+L5bm/7AKa7Wa1bJ9e39/qcs0t+/dvnf3zv5t/dvG11crXWtLa81Os3Na6wppLQHLCBawUMBpL4njVKU7V+nuIAUcSPEBf9DvJRkhV8D5lAgl8ukOMojNtOAPlks93TlTEL00gfuFUk++A+dzeVzpHiL9uBSMYxyORrbr2ZhO/xIroXziqL2F/BUOJDNeb9Lb1G5vXhNP+8PhJkO61q3rbo+u3ykJvIsjnM+bXT89ZTWbQZmXeV6wH+B9kcDTyVaSxO5wPrK1VY1xnqaovv/2bnPt2qwpY7y4iI1ok/ehYS2iweeGSNBo9qoeKRTxZDTDj6/9sStkuOO5l4BmETq9CNS5iHyohEbQVmsz4gglHIWe5wnl5xGSMOEQqSFexoLIC7uQiLE4gUQRb0NYxGPdZU3t7yuPdI/kspFQwK+WtFKlpKgFrbunnCoFA5pfyKTSuQpOi0Kg3F3tKZfMYMDvg+qEOC5X4Ar7r3TncxSK+E3o0PrpeIWiyvh4ZQlS4rpi3bqrIrENlXg85r7YCFyjeqMbtezgwHUp0zRDTSkzZJor5ccr5L9Z1pvXpdviia582rurNT/o9TYn48FhvbT1/J6epU8EAxsC0JJMKhgEHuSgL26nn4W+iKBmlEcFNGT1tzQTTAqtGcrhtnwuyyGOWojDCHNoARE4EFyDbqRonEmAbYzPxwKVckrjjQIGZk8x0oC3F6AXgtAbPRWtO5cW6BBO4gT24Tyu5rGJ8xQtLWIrms1G7ZNO2xcr49merF+rBPb7ea318/ZVP/g83vx5+4efx5vsk+RktgK9s2SxstiK5HJEDHDaNq3i73pg6ULrQ/j2B+wPfwhauDK+edRn9QT9hCAVmk0sAVJgFh7kD3WGeA7xGPMTiOfZyPJ4LKNngoFKSQy8eihz+Uwll4fhywgBfz8O+MvBQVwurR4w2i+2fUds6/1mL3y6vtm1emjwTQXxBwVRLL0gFtZ+Y63Y9wKjxbWnF+mT0NYmVEb9aMlSDUzRmhQRZV0jRKTW+KMuEDYjMAgC5YQFxAuKwCsLSIJBkvCCC0MtHJPCAlJkQakhGYlEFmsI7pIJJpWnEQjlUZBaQaio5/eogD03gzhO4UA+/fEtAIkUI6ivt9Jd7Ci05rLRiBkAlvAoImoiTW5vAa+iGUZBnUWsmSkQRf5gqWcQd+cocEiuLn2qZhD4pzvfnM5195SCfjq4tNgzcV4F3wKEEbFvwsDRi5gAyWy6uPP488ePH+7rfr9eMQzD/sbh8fHD43RxU/cS7pkEioOip7lnGSE+V9m4VFy/7fBxeCL8fgPrRkX/m3FWno0Vf/oo/Xf6Z8gAuiozueFSCI9kTHjTDX3hxxwOBgjleAuUG0E8qDkOU8wEC8EUugIxHgLmIYROg+6kowHTjER1wQ8CNpcG4eBP4qopmsHSMO7pxmK+euZy/VK+uX50rtKfv6J1aq9oWusrD/yvVidrd7zywCst9auNm/Zv00U4Ogm5unG9BYq1Oln7g2eyyw9paTgUWeLw0tvob4E+VdSBNltja7KJAMdz2AL2gdcloIw4HnP8vIB54B80DyON8ATCGE2LIDLQKEYt+Uw6Eg6Zhi5LwIeq5C3woEhAU5QSBBSMzt4GXlTMsBcFYcjeEfqgp7uIqz146eDTt09P3/70N55hh2fubS7p9x7XyhrWtOP36uzsXr3UzNK3wO1vrBQm34Wr9+g6lD2+XKReHN7LcvjuZhRAw+hz448qwBpFaC4+SBQYOR7tQVQQRbpXxrwEXe3oAI5zdAC3zYU5kRuL1lmz81WPCVRc+F3Prf4ldPANPAGckzCDGPX1lLvWtDank7HgsDmk+9zAiCiAA4x3Sj1F7JBFsB8DD4ESBrmLQW6BHKtr5EwaZFeduxgzFUBZO3ccCUe+XQllv6Z3G89ng5U7EoFSIGHP5KvV/HwkO5arVnOEy/f05DfmIvPsKhnsyT5vGM/nKvbuYDIZxB9aWt/Xgm9r7ctFU72tz7X09bU819qbiub6Wu0bWvqA9BktvdWRywE0ii61DrVgRcJWK1bwMMgW7iBSJCQpaIF4gIQkhOfdWHRhSRGlGg9CEcsUWEcWBHkCybKwzYsFWRhj3TI80Fctl4prnI4ZNTfomqaqZzrHxzonCB2Thg6CF2ZyPcPe+pzO8ZKAeEZhpXsYBjqrg56LerRHgD0+oXmjt2WjNJKz5bZksu3aaHZEj7hFnEqSxVgOE9EV9w/lIrfl/f48vjke+Lbf/7w/jv/WEUzDNom1kE+2xHORIcA8gmD3mvlsGH/JbWieoUguUlgaL4QRExXQXy/Sk8QGzRyzwgy3QC/UgLXINEgQF1mXXb+hidNBbEITmZLKMNHYj9kLdHfgDMNyDeHRU8EZfP7UkSOT9q2UCTqKb7ztqZl3z9l/HQ98PwCfOH7xismpI7lK9qmjs++eXYx41Ue1Iny9kUZb6jo1jrJW2vSJAJkQtoDNQbdOwAGRaRAJiIz6I34/NEp2pJQoA00yeAM4CjBOqSpjxtd5cgeuxfum4/ZD9kPx6Vg8jmuQicemIQN3pvvieLF+tB+CI7txdlF4lvURWCKn305/Q68Hi8SHYkj5dDTgdQEgyRWyeAgHzSDhc3oVe3GOCkQPcs09Osk1c7TZDk5+6uHBPXSptofuwT+Hk32H9xQfwxh7noejfdr+16NkrOjZuOlN9j8feBOOHl56Es7IF2vs1vMrRVfhjRCqoqQV6/D7FA4Nsk5rSELWgaOphE58dUFPvJgJuiATcz1MyAFyHsRnAAdwqZfz4Q6JHNrsyXk23xdx6YcMGg/deWcoTo1Duity6nR/K+1t7e/dfdllu2MxMTi2Yc/kdF8zydximrfE+JT/srujAZdluYKRuy8z0rx9/8N34YlMqZSxH7vr4a6ZvmJUB4BH3N5IoqM81uDPv+M2wHskAQfutuSQKjmwrwFBEiDpgUl5sNz2UMzea4KyV9wG5h/CINXiywX4g69xv/bpcnfEH1lWdmJD1psNYV+tS/tudqu53hEO7iKluxIziUTirrsgmWGHHUl2Fo8ndySWBgcK9Nq2gYG2U8cK+Hj94l2v9cAXZwcGZgeQ4owVgXdkNqwLaMZAJsqgIlqPNuJ7xx91w4tOMzvsIHL7VBUMQhSkQQS2HQHwvxd5kc/t9YGlpYLVqgZ3gmCCTgTlPueSiahIRDBFMMlM5Df920MBg2qaojGLkZm1215dMUCDP7ZmZotuf72aCRYX/tCqrR1navW51YU/UbXMMG3v7Nw4Nrqhc33n+nUj1vBAf2+1u9y+Jp9LNQEoBGFmgAiv/6lhs2CUA5l+XMmY5UoGbCfnyL6GX0jnQJUB/gukGDBk6g2EXzZQv5FqHDNglPBgl3z/7rt/AJ93vcvesJz7cjQbhc/Sf6ofyXv7t6+159duX3sZR05dSNee+gJ+9B74s+9i6T1EMqJR4yqWnMl0dbb197d1FhkZFk9dQd/5ytLfowY/1eVCArDToLUWEQqdA3a9CNhPpCDJgbt4DCKdFwTHBhGmAQHwwmgq2ZpLdqQ6ujOZTCol+wvNgIaX7SqQ6hmGk1nSUFdmqq7Klu0VerkRsR/FybAeCNkvgaEY+FbYHwiRG0OBsVPHk2vWJOlhSG8IYp+5xnwmouuRpe8FQ4BGAz9u3Euycs47HHXwn4HaUdFa42dvYLGWHwQNANwO2PkgU010glmE25hIHgObtKWZGYPMewBIjzkFyoD1+JzD+CCVHYavDmFgdwA/AH9+C5jtwMFnjk1tu+PZQwtPvn1q6fi8FB40AzTStbNlfctH265tD/gHQ5JZwm898MztU9PHnjl48JnbJ7cde/rnh8WwaVbD5Z35lr9pu7a4NuDHQdEs1/UWM3KhfRraXRdjBmhRaDygb2g8gsYjdEHDNgozoxBe0LFyCWBZhA6AHFMw8MJrPVarfVLXAxpouyy8T13h4TLOebHfxOfHJsHaifVOxmz0dvuzsalqLJFIkmJydjC59E28K4kH5xLLdHLSoZMW1I3WWtUWFWwI6GRe4KGTBSowA0KAlxBojdQFK3EEK0ORY+WhFqO5uwkM1uwqimDwTjMT2BGr0O0Z6HeGDUHfDGO0Sr7ij34r39fbQkbyvb35r63VLOC5z1JODYU0jn5W5TTd0qr29t4WarX09racOtmy2NvCci292LdW41S1X3uKhwPHP6VVNFXUSvjgdG/vdG8dw5wEnF2Gd9OQ8JhPwLmCATIfJ0A553EA93RgQfynYBB/IDw1KEXsffgTEXFwMoI/Zq417dmwWFgXwScO4Mcj6wsCABGMY2gdeYK8DLJbeEzAUB/ucUg+n+3AVXJVvKUtYX85TuLk+2E9v/TpvD9shzaGz+ZHETTcjKXI0JMRGFUCCi4Cwx9iKPQQKweDz3AWM9Koi65zVNtZtyh1NDsrgOlo7VNGPmToQPG62tMUVIUmPs8gGAFM6U8Qx1gF3v3zz2DuM5+xT5EPPTK16foPf+bD12+Cw56/uPqR0PpO3Fu/+ZmrP3bVnefXbz0Bh+lHQp0bVuGcENqHLmNU0tOcihOeol2bxyhHieVQJbwRZRYFB1RaV8b8BTM7tm9bN9LVWexoXyN4C1mh6sUMCQ9j5pDpBHMyyPwyYrUzn8sDQzJPHsuyb7qSAQY1BTEviJ2iF5udwLslxsAJbAaX/8tgiud7qmZPtRN4Gui1OUf0nmYuqBOwdLE7LH1V5t1+T0K6m3xWSnj8bl4+hD0BahBOJVw4RhNNGG97cpJUWolo4B4jhz1+YEWwqFWoIhwj+NwSQ4ftf7VPP1bc8zz2YAzHL1MqEfGkHHMbLl66g/wPiXcb7piUx01JTGOU9xEaNkjAgzOuImnqJGIcTz1Xg7sUQ0f6gBDCBgaRddZ9e6C28hPPs59cRUetYMf0W71ZjQDEAYsYO3JjgUEkMIXBzOc4x//BbWN+J26s0NbX0zZa2NCSy2S6RK2AHC+Zv26wlZnZ4fQs6WGAcPm/AuyM0x0U5PsQBbZNUCB3L83Qw3p46c+Z6P6tafrDnR3FZl9AU+UAn4jEE01NyaY4bgrrS6mmctwvEm8UmPznRqgjFqzn/9o028yln0Q1LYp3pTOZJreXSlIgEwkwz2IwqG83l8RAsiXlXf3YUtDJ13n7Xeh5+iZyJfCiafnPhbv+ElGB2R1xlMcdWHwgqufIjTkjbP8ivDmCQ7GW1jjuj5NYo65LoC6lUZcj5Nj1aSbjGnXlHKklApjPn1PXF2P51rj9d3EcO0fmqJbH7SKAxUFaayr2glkS9LMaQFiA+MmBiYAP40+YQXtfZHJQCuMP2hNhEED0Ins8eI4EWlfgoVkbQf78+Cz5k3N8VtUsk2h3MvmDq68jf+TTx+j/oJcD6iygEWuIk4A7eEr4BRHzzPCfh7aDegVkICAkTCBBYApVQGOaCiSTTsYdV3NBK5iqrBa4VT4UTDOVOgBq2IANl5njpScX/v0Tb5ucfNsTf//E0ampo9mnsuXsU5FsNlLPNDdfW783OXkUDm/DL7FrcLO7uV6quTtbt7UQsjhETrIxAsxcsFqQIw+ZQwtEDoF2czzPTSCO46cRz/GjZfZXAsSvrtI4wuvkwShdZKbpKSd9zTy5uCeb7cn+l1Upm0daOH07fdTxyyVQG+pB69DBOpLPOkS5B/EMjIq8UGPAFHEiN8PAyjTTogoT782OP+Y/KFazNGt4bV93ORAwjG4jU067AZqyF6gsOxFSTsIve4y1FM8GhZEHMLfxOvmFZBCLyeAhkMJiMHHqUzSYDC4dCybJj5b+Z3JNEj7fShaS8PlWgp0lyA+CiW7mc+lOBioHl25gWfKZ9wWSyYC9NZhIBPHjr51v2MuvAEj/KrPjAdE98SlTIhy/bOI1IR5UB78XoB3h9rDyPKLMXcmwBnZhZm6wfk2tlINxn3/tgkylpusFmZfwdUta+dcthBv+423MfzwGlsOnjYCRSKhAUSjNTOSEUBriqx08aXiBcwzwQ46c9+5jF81WW2SZutu7d1547N3HLtxZWeOm1L2msvPC6x9fXHx88TJrl2XtIl9tsc6bsPx+KbJ1w47B1tbB7aNbI5IY2Tq6Y2DppcVPLi5+8vbdlrXbcqAkOX0rPUVvQDrQWg7lmfzPAxoeFoBIeA7xNVYG3qIGyAA7oJjJMIpHMWrONCVj0WDApSAd66LjlgI96hdAsdZ5eTVZEMa6wMwmQYeeGB2dmhodfeLbTx6bnj725EOZ7ixw5wXrOjrWdU7TG6ZGNzz5bafMHZ95/sljU/bmWDYbs2+LptJRIhVHivBhbX8fyMV5kIsSoIgW0F6AIlqh7Q7UxCCKWKOXnUwc5whzbhpxmBt1yblMImqocsgV8uuiWmh2jC7obbp6igRMELoy5VOfAsJfS7QlEm3P4Af0aFS390C6WEyTXLpYTC99L11UgKiDwSRti/qXfu2PRv3E7Y+eOsk8FXSWpadOrPY/JdGA1cfMTCZ5FqDXRfjMA8EArVBck7EoSeIEHERpEkmitD4W7fJraU3TU6piFrJsIloQM0bKyHRgwMhlBzIHCqTCUDM+gY9vvlSem6U7ZufkSzcfx3h+4z/O/uPG+UWybd8mPGuf2LRv6RFB3LQwOrqwSWzIxdNvpYuOjdSE1rD2SZgHK4mRBJsgZ+KR5wgjDehQJh4ZSXCMJNa0ZVJNiaBfV5GBDYckEgS6VUyABPdiMI1SmgH4cQiDeM8zTN84YW3HD99844Xrpkb3H9pw9Wz16/a7T953e9PAhv616QeO/vDWTM+G7ose/Bxd9I9csm7TdYnorbWxWydlAdPT9iInjvSULZFbsgRpoFwYjDbe42Rj3sxEZbTBGmkFYyiNHXRJCWPOBZ55+igiNQE7LyMwQtnG3mYsHCIoVA6XAn5NVUTkIz7x7CkdRhMcE/bAojQNMLNqMASKh2jQjFMtTlP04VMPpTs703Rfqr28tPng5s0Ht9R8Lg91Pe1q8jyIW0UtlUi7T32XLnakT72U7urM0Hi645oth7dsObx0seJKe3DSQ+Ub8aykBwV/1Bie2G9/wc08UI7+2gPMyXBBBnWhn4w/6gMR1c+m/cCmEySJ7FUwlUWZ7mXccgg0i0B4YQ74RaaSvMuFmV9+HA4iYwuRY3NqKlQx8BpViAtvtA5r8MzjApEWft/nazUrqusIdba35vSMnkmnkjHTD++o6ZWSWytkE5jNBdQ9/jAYqUDKC8RTd5w43u1UoNpwHdTZmLThDZ0vd45u6IIED9qX49Hiy10bRjshsb/4vqCKB9RgULU/rwZ/PVzbY/33kT17Rv5luLZ7pJ673meaPtWZXyboGvRO+lX6IbC5FFSyihKbPQZbhSMHAfkAEx9ic9DcODAFmmJvvAF0rQylRbBDBWh9PiVmcBn4uUzVzfbjm5/GsyeADWfnv/DOEydo8NTPSeEnDCMtywcPioJk60J9aASdZ42zmg4ihVcOncEqAvSkIDuYRXIwi4thFgmB1eCqrWCX4aH+tdUew9C72V8JdD0+q5e033GGGrJbP+eIZ8oZghwnLGouvV7efnFjqXT2hxbYzeZSyb4+U+pqhq99PZxBpkTzXaNdXaN2qn5odg5MLuln+oT5OaPO7H4R+LqK+tEw83eicTSJtqM5tBtdgN8+/mgUSHkeMCmSMXWz+VxA417FNQe4WcM+zuub0zGHDD9nzCF/APNBP18L4WAYm5GgORfDkTiOCpHoXBo3ZVJEbBK3g9mE3ZPI7VZGElgQkpMomXQlGThog9+6cPVvuaGs4obh+aN/9Kxfsg79KX8EqkbJJiHJfk0Um8bh0CRO1n93PTDiyAV7z9+ze1dt59wss7qnpybPm9g6vmXzJubtdFydQ4MD/Wv7elmoR7lUt8kLbRqDyRqI9mazsNo3ky8HMvpqX/hqvw3cM+Fbga8I3yp8u0CP4frROV913fmy+jAqZYijV5dOZF6cnX141WlpVd7++szMzCz8zaw6stzyuZOjokOeD8/YXRtL8LHf7pxzaGZ25uHZE06h5TrgC3r8xtOv0G0wGhXgTld7c1SXkVCfY2B40QV0q4ycgZBtzqW6SYkcN5x6rmlYqz2eSpTZxIq2PFlXZQ6NoODDJos2Yc4OwCcFZ7ZPFHJ11wdoH+b/MPHDPmWj4v2p7OczPC//9KcyDxm//FMvXPb9VDb4Zl6QfvYzSYCMX8I/wy7F51PsV47yvDQEt992FEoPwlNvs19xeX0Kdr0N6hmE+o6+DR4Ykni+4Xv6f9mPShu49yZHkhQYxmnOOIYDWoG9LIQKcIGD2uGwHPahqa25VMIMqFEtaqqAHVHdLVYaIgBjMIsb63HcSYLRGCbaGElyoDHn/42nj01NHbO/F81h3BZ30rZ0yB9KhdOh9aEUvYmVaRR95valIM5F4224nhJmO+J+ZsmyccCA1U7Tm+E9mpgFm2Co0Trjmcf4gBPZxAiMOfcQHQ2FTJXTz240cTxo1frUQxyaTg7+wzMMmj9TP/Q29/g/bAKh5e7205vPXGaHpeMtVL/XnyT/NZrLRb9yK4tFcOJnyGno2W42T+DMCvAIL4AFQXgMBpEIMECEPiaC4BhEwjYJC0QYi8cKrbHuOBijGSPTJPsLr2X+s2lsZlbQdAcPlipQS9mxOwJ+oBj83CE2LX0ILOmLWeZiyHyS9/eWhtckb9pffujCY/8Qrgy9ORrAf5nryc6zvpzPVXIHnblsF/WZHYMX9B38YHhq78ePpt808q5xXUCNuLJlX2t9lm3UWgf6lh5ESOIkBLYeZmEk/AIiIjkE2leUxgFLIl7k+DkGKsVJ0PmcuH7VTBDAdwzoRQMIjx3Jxo5ahlj2Il48eRIjy7IWF09BlqCTtsUhGy0u2tCWU2h5Pv3/XhuCgm12GuxKHwozy9xqa0TX1qCdYJ4x60HA2HEKMb4S8GjAgD8nUs04N1KtATeCZXOVQUmPTJEbJ48cmVy6dfIK/O8pMB6LxdRgpru5ubuZPD115MjU0m0sJUZxBG523Mko1H4bsyLrY3rn6TvoVfRKGM0RdBGaZ704j1kwELSfAxu+xsKewPSBAWR+FxjQM95AhHbt3Dg2NNDaAk8braKvkIU+C4CJ4wWazeU76CDGCeylIvuwq0CcGccXzT58dYgyyUdZnGmaGcxmgjTczwlG5kDVUKRKbsLYiLrSmUTe5dVkgv8hIvlzrc2ionrcgsfL824Y2/8iQQ28EjfV1nxzkHNp2w++qb148d7JrYX3RjZs2hjd0ElwIO5T3WHdcLmK/khR4ZNJNR7WBcnFuQWjXeF8XkKNUFhJkDsGL9m9sScjyLIgyUZG8+oiSH1JDGrxtOZu6Vk3tas0delIPNIzY//2kd2qrhsdbxpI96xRNXfUMBJxjxnytjTrsVgqdBbv+Ni8IdqOW63k+nWD/R1r0k3JuK66PXIVi561vUQSqZXHHjxcd99sYjOwIITJAlhfCvEpC4CliSLPI6S64Dri5rxYRh5R9jA5DTxHxJrmJhLG0gQ7SsyUk/BYw82z7kx9PqwQVtPC713Tn65RgK+Sw0N1SLV5bGj78LY6hEq3MOkQrJR089Uxm4JYKVcylUwgEygHBNHsqQb8mXQ+UC4NYoABzj3Nz67nBZFnyhSOTAtVtMa98ur4Tnx9u7lly+yOHW2VQCEZC2VqO8z2Kw8cmM0G/2yn2lrBzZ1mWJnkXIqeCj/++OyOswJA79fl987cddfM4255h0t5MCHMzn1X1t888/LS7XnXdDwz7VcvjcTujhwM+GN4cvZnS/t2nyW3+hnHMaUAXIYW2FSxyAsiCy4UyQRoDRnzAuLnQEGI00gk4mh3udmfimuQBJjwBJAQx4AYV4eKBTKrooQGmVxNC41oQ6Y5ysClLOCQ/vzBYPJ7fRHVe4WvzXeFT4v0fT4ZfDAIn+Tn+yKaz7nsVSN932OX8QNOkW8sF/nGmSKveRm0xPI7aigF8q8V7LfNqIaO1yPzKg2VuBeBxgKLmK8pEqUAEoHD5TnV66bE4yETToZ4pjUf8RAPWNY9Z1Tp7/VgzYrP7ZjcunHD8EC1u7imtSWfyzYbFRD7mmY06abj1YiDLipXnNn4VCVDzyU86MgsfPll13AD2mT/g3N80j4ZybFw9kVQsCcXF7MRTBh2se1I9jToM8p0mpWL3sSEMyT24kqeopU8XsxGQRta0ewiHlmuANK/XVxcHGmUee2kMVfamDf3oRx6ri5eekDIM7C34Exv4XmERR6L8xKIal4U5lmALEeZngKAwvQU2QaAhYw1Jtc7/4OnBVZ4FvG8M+uq8AD2/8AfBEHhU1U1p8LIGJkimxNzgINZJ+Uim7GhjtpRnbB8M5PLNIKK6aA9gk9il/hhUXxYVI6UP37o/T/60ftntr5p8EOb9h2+557D+zfhk4tvUXjpY2JAPCHyLvsdc4d+hId+lCkfto4/f5yF/jaBLv+hI79ZJFUVbO1jdTqGF2Lh53uRDFQo7wXWJqDemdp0ph2ADSRZlGrn2gFRqxctx63Dk5LMgnDe2KM1y7PeYuZlBf5KIASq5/hny+cQrv4GZmqarp8hzTPXXz+z9P2Z6xfb4qQUb2uLL3093mYB1D7pRPQ7cf2vmbcmr7hikiyylKHIpUWW4n92ZnPuX5U2SBDsjiV6IwqhEtoKuPwa60oWH+TzetyyhJGb4BiYPQSARwLgY8+aQksekMjY6LqRXiAl3pqoO+cbWE/EjKjrKz0QW+nB8wdWRSw7UKW7HAlvWF/e2r21rTVcipQKfkktGAG+ArZWIFvp6c5XsgEWUFHhA4KfT4OhyWfBIgMQaDYKOe5a8XXvZJrx4/58AD+eStlbNdPvt7em6Mc9fo7aV9lXKvFMLgUFWvz4ca9RSLzedVLBL2C3GxJjxIBUceN/hOwdIqXPnBQ4Lh9PGd/BLhf+lpxUo/l/Fij3zEmRcrlEE1yHB78lsevAeBtO/4K+CGAzidrQh9HL+Hr8FuIf6cJZMJ/d0Ds/Q99FH4U7D6D3AT0nYVw8iFnqnwTaJkDlLnw5voT505APb8Tr0RzkNKTiKXweOom2wCgKcM4jC2wuJpDfAqkLyg/Xw+K2IupTfVRd8BtEUwVdAzGvw5HFkuNDCkYmDDbngt+pBbEvgFXNp9ZAnPPctASWgjKCdJ1sk7ETE9tY7zVxdp2qJiz8cZUyV8T4764UnmNKhgMl89rVn1WlNfVH10aIPrFcp87kXm2kAwbvWnwlPoIP4gV8Ed6HL8B78E48gyfwFjyC+3EvruB2vAbsljbcinPol+gX6J/Q8+jb6JvoKLoV3YIWQfWOASm0ohYQ/kEYNOYwDyEdDI0qC6Au5QXHe1wtraxiAlw+iKuDjukeyLBlTkD0dYDO7MzGGbM5GbjKOc/VIxyq3SuVwP/y0qjl290rJ6BoUyXA+6JQ/3fAP6sdrIXGjwXYDQbhzlwILhdtNITZDsFGJU5QnXPDsTeElQb7cBpa1uM4V1basvzD7H8lQiMnCqseDsL7iel8ml1g8Yig3uFQ4HP1MmzlEFsKFhSdRUSlQdINaZXlcHcBC4PY6YH6OSCwrg0uV+4yfFk6Knt4WQIbQ/Cpmtd9c87c95/IKYWDP0URGMgWw2GwqcHEWQ9ijuOoAO/q4jgsiQqQNQepwPMukWcrnjiXhwUdKgFCIO/S7Dnig6o5UEsSKwCVeryi6Pa6AVO6PXCJF1wf8AEYFySwpESsKEmMQyzHc26vDGhT9MlsKQyv2Gn8z6xFPA8vSYAUvE4xwf1x5qFyYZebaryLCB4qiqICDZY5qssuBRMwqSSXIvoUaJ4E/eWWgj5dclMq+UTFIyug4rHEb/QR0R0O+UTK4m6wtkVgq06x2qK4XIrsV3X3Jg+Gaje7ZaGNZNM+79IxjMPNn/R6KcdJkserxzWVErf36HU+gn3hwsX2L6kkKbIC3elyedxuF+8z/Dp0rOICewSDNOV1MLt4l+J26Rx1yW7FpVBeUTwel0eEcXHBswJ0VMjtFlx+v+p2KRcJgg5NFhVW2MWL0QhUyxsut+IWRY8bnlSIwcEtt8sNvaa43H7eFwx4eMi5FZkNq+lySXzApUgSuRbaB38S/JRLgZGE/oKX5WagcSpRVc7kNSp7Keg8SqjsFviIR/UCZmAj7VV0jxAQ2fBL3qjfdKnM1QEnvOITsRASIA+QiudVAFKi6ideUW71YE/MRSWFE3hK5ASvnO3XCYOA6EP70PnWrraIqYB919dJnJlCzLxpzlQyJ1Ou5sGy161InOCSAaa4EEAmseZEkbOIV6ZzeTS674LdO2e2T0+dt3XzWDrt765U1q4t+cwCf2ZiuepInLITYeEXg4F8Hb+sLGgJOB7zM1ONYqbuWIBvpdssM+RSwAlc6qlmWISA41+Eyjk0Wjn168qoooxWqJsdu4qRU7+OdnREqTtSbEue+nVTaz2/v8v91DXXPOXu8rhCd3uATLrcgPfYqctzt6S6PEJldLRCFsJmKLCZZTcHTTP8IKtqc6RYjGx+OBRaej/Lkf0nrv+bv7ne5YlgV9R10V13XQQHoAjXqrWpKthBc2jBumhilPBie5645LGUxsIRLSRwIsfsPpHnRMAwLpnKLrrAwlQ4AUGPS4R3g73u4uVVUQjbWBTC2NwsdPPk0ODA2ubmbDOYd5Umr/mqWVoWWZ05K6aYZhiaoQz2uDCkIC9pw9doloa4YWz4WWxpNcrWXIBdXerO0Jml2Y3z8xvJCZZesqFz6WDnhg2d5L7ODRds9qhCi8VlU8JFk0KWug2yY6NqGOokSC2gcZH2z6geX5geXsNlY+7JrqYmuji/caW+U485Vb2HpUsHAMxo2/BPmlK2Bx+LU7fL/pWW0EA0QGXiV+wZj59SzYdfsvcmCA7eN4yQfKafO9FOdD86gZ5AX0IvoB+j/0narblf4URTEVPUhoP0xPtKrZwp92ZIyHziYaKEhmMkrFhRGJUvPQmQvDYWoFFuo5/E1Be+TPSYF8f18zyEaC6QSj6rE6MuTPvSJEQB7iQBRdyQSpJEE2pKgF0TpDIN7gVz1KSyOY+UUDikhBeQHovH9PgCimskvgeloWy6qcYcgkEWTWCikGKGaigs8uEJt0TEiEegjBR2BXwg4QBOqDEO8EEUxfRorLGOcxZpmstZL5CCNtz4+7QhFtfm/7SNsG469/flhf+TDQALcexffvnyf//ZT3/80g9efP5bX/v7v/vcs09/6vGPffShD33gP9//3nuP3/Puu9/1znfccfvR22695a033/CWq688cvmlhy+ev+jC+hTfztnpyWxTRl3FOrl8d7UCwqZnGP+ugxhg3uIkfvUhgSsB0eG6IVxO4UqmUu5yQv67MgweOTHcYibf5YT/+5NnfP2ZQD1TX/0wiMvLzzG/cN23kGHT/YHf5xRXWWxGOZsDti87ocKkfmLSX546Xp2YqNJLFRyNegXxrC9PSE/UI4orX6986mvBNpxU6VZ78sABUJnKzv2C5g6IOzi8R/S7VW7/Lnb1kkucVA2p2Cn1Gd3jNgy2M8DrHO1gRMip//KYfVv5Qj2+6VtFV4v3Kxe32i+2HkpV1pOhjSW7Ut4Y9nrjhZhXDEhiIe4VgqJUiPnYoS1evwhnLkyq5bOvrhQNqLg9VGrCX/E122/Fwx7D85gkuzXjAdfHDM0lS4/DlWHs0b27BReQl7Dbq3vwMJsmzDvJX7h8PleOZXN3OqlzfudKAbJ+1OMTdt9l5Ivnva+qENcjud80c7khtuZveb6KRVwOox3WNEg1WYeERXxjwsIaHKEvugivYEnmpZUIh3Mi0LLNA2urPeWujjWtLc3D2eGAYeRNt1HIvlawenO6A3cP4RKLT/tdwaX0pY9s3Hjdg5968Dp22P3WIx+JTfXa4Ufunp29myWHrVwl6zgArGwlx1btZz9y+S2768Wdpz4S6526pl4YEtx2VuEIe3z1ng3MP1hGY9b61jRglXrUNYcwt7AcnA92ExJBQ0I38LzjFmIBHQI/6teLHblsLKyn/CkD0J2sF+pLh/xiGd6vie3LkOPP0YS4sYSog60FdSADto584Ij7zqfs//XUnW7SsdQ8MDs7QL4PqX03NDqeGT88niYWm0hJpqyjTz111Eqlxiv2ouMChtR+1zb2Ytu0tRl2KbO2Mf9TpEu0FazpELzhTkuORQ2dY5OT44/GQWL72TwQvOMMj+sDip3I1SiLHXJihuv3J+BAGKgiaLRmqZGwpoZTkZQa0kIm2JhnBw1nS1XsyB0jLWJnzSg58I3Vi63t71+2x5YG9j900WV78L/B8Zsr67Ch4MgA/rc9l1300H7yTwO25OQQi8XhTt9GX6Y3OGZjO6qiKWjQjLVtmq309QD8J26XswMM2zWgJgmEA/OBB0Og5sUKAuTsXhX6WZ9Dnpoc3zS63hpkkROGZhgArEwd8CGMS2NeFmw0neTpciSlM8MpiJQRrCML+ZU5sTSYIcwsa8yEOkulwXzNdNGDm5786hN/OTHxl0989clN+0dH9xeHP/jxv7px/fob/+rjHxyeGRiY+YtwJlNKp8P251gmkwm/a+hQStF0osrh89rbzwtLKtE1JXVokPx0k1MRq2/TfixgYf/S/uF6VVDj0MyPX5rBL4Jsh8+19cNt/WVfypMtFLKelK/cj87eq6QJbcKDdU9sbCSXBeujfU0rFfl6JIkgiX29RJY4qzF5E66Xqd+FkmDXOQWoFf3dz9dq9R/pA7NAAaORAU22CHseSTJgs3mgMBdGClsHoyAZK/Kr1sM0WlAG649XJIWXFt74o3/Ez7L9JTAaGx0cqPYUOwptLfmmZMTUVVlAPux11sifFapazp4Le9k0CC0HzHIAVF8gyZeTBC/vQ+As7qKL8UwmvoRYSlF9WqcxxfNtD4t2etWf6M3Evb/9rTee8do/odbKw/GMtTwxxGqwmzy5V1dA7N+wJ+F5qMX+yf+nhz8pPRjnDH/2nFjmMg76fTQTEDMBH4Yvn/GBuQ3m4zDOsyhzEy8ujyUb17P24Wl/TXKA4TxDDjjyR5PDWfTA4gY6rAILyBFYQI6AKBEcvcBkKbcSkLMSOHDudOmKkFwdiX5kmtw0dcWR6aVbpq7ASyxuoLOTxQ2wGHTy2eU7R6YL9Uhz8rjj6L9tOW4Ao12nv08/SHMoiTaMP9pcV2bLodGgx0ZQwyN61uXlTQ5qlpcgZ9hElCRJHtg47wSvMjzMdhXAbOmU4xyo1seRTt+vhYqpaMC+JJHA9wSiqWJIuz9VLJI9OKROp4qq/Yn4jrj9CbWYmtJMXEzhUKrjT99Oo9poFxAKW3VUB9bQ7nydvE7cr5nFdCSI70kk7EuCkXTRfAPNhHYunl504s1VFLQMRZZEJ5RWRkNsmVMc+wpZsZofZlsMmHmN4ZcKPvlR/r5fvfOdv7qP/2i2J/tfB/79S5u//vXNX/r3AfsHbLTqc36bTi/Qp8kPUAuy2LqGEka4FROeWEGAj8P1NTLOjiU84Zcj1pyVhtwFHe2ZdDwWDvlTADJwB83nRC/1YcE02FLPIh4iAC0TXD10He47DoQeFsTBApGEDkKbXeMTF6RO3O/Phg2OU+UfSl3lsNyvrcm0h3KYr67bMTGS795oP0YielO0Ke6+cuaR1JsvFZvHrf3nT5MoR2k4/G4P9hkGmCHJpa5oRC/HPuvxEEn0kEisycMVWvd84Wb7ZSxyAnXJ+Cr5aj3sJsoDMylvPNuYbxo+/Qv6LA2gPBpD29EOdKulISwriUiAYplYO7DMoi3YbEAbQy6YbX7DbFfmi+RkFlqq1KMVRxDPs2l40SWyNS6vXZiFdYkzZ55R2CKj7dsmt27eGKhkK2Y63V5lgcedFVBBbEcP5oRxnOlBs4/RfTVo9lSDjTUBeer4wxxWrvPHWfu9ZPIp5vlqzOJ10U/irUp3aukXqZIMRoVUWtNc3F7p3j5dqWzvzLaV5F1e3SUtfVBSDK/H6EqTfelOwzO+9ANPMOgBYyEY9JIU0MDHYumm+Ccwjca7dpjG8BDGQ0N+c3tXLHIaGZ7nRJdLfNZjGJ5nWWD/cx7jxUgiAp/VvkQX8qMYSC+2Rh46hDisJQucxDmiq55bll6JuMedTsWziWwkDJJLdfs9/oCqqAXU5MVqAjcNYTWHG+uBhFIjYy5fIH9u//zlY8dexkFIl+7N9/ZOVqu/Oq+397zeu1uq1cneXrp47OUzZey2Xufe6g9i/iPGg++AtkdRJ+pGvWgAeGYD2gQUs2BdxOw2jeKagTUdGEgjNRfm3c5WcnMeFtzE5mrnfFhWAfDKyhxi4e8s5pDF9CNudMvm6cnNO7bsODdu2Ilz6evNlvxmIbvaRZegjamGBAkUSZ1SVqs2noW/NL5sKnz5H9dJpB8DwVCro8kupNrbUzjmcnPYVK8x/FF3PB5fOxi3v8RC+/E/Wns6bc95zh9+u/1F3Hfmu001TfXrrgTohxT5fKqDeCOafp1qEkHzPh2PD3TuWbc0sG7PnnUkHx/65uTk5HmT+A7nQK4x1RbVNPyTjTi4JfpnINviwIGbrTHEi6zfFpjXU+DmJcxIBInLAae7zjUVMFo/AnZupTUfCfkbO07J3gJeFb9JqOC4hZnDI+DXWbgZFeuXWBgZqe+wcOZKGYzgAEEHVseiPr1FM810KhRK3R5p7vD4JI4Tc/6IkYqGA7725ta819MciHfs7K/uaKd/dlZ46vSp36iJmJlKmVF8oDPT5tZ8Pj0fDjcVM6FAIOpLtLW1tiW05s1draOtiO1FaJ0+SU5SC3mhT9agfrQFMM9BdC26z7rn2muuvurKgwcWLp5XdCfs3Ak2V9xOkPmaQltriyLQ4XgsGgl7PWBaKWgwiA0z4Ke6x9BrKvZoPi91ix53TcGiC+CggEUBQIOzmpdzAvhAu1A2Mf7mK9502eFDzAO2e9eO7VOTW8dHN4xYgwM9lVJXR7thBJ2PGjILKziij0utyuM/0XXCFoT2gN46jRoZjP6QK1bWiTSofzB6o2dMV24//Xn6UToAo7EedVrtpgJ9VGkhgLIsdGbZ19mUyfqqs32Y8xXYTm5VFoTlwzkm2NnCHCbY8ywSK8lAjciCsIaxszKf2afDuKfKHOs9eW55w7stlO71yjVFuzzTohK39AnJTdTW9OW6XJO9e1/npqbUZJ/9nrfu2vXW3Xgm3Bze4tLeq4protrVksslXa1F14jqe1X3lte/ldu9uHv3InL2UDtJGV2KIP0+8OnymiyVZOavcEK2XEzIATZZYP4JjmNrqhQM7CjX3EBhHkKoSFatiKuvIYtaPWc/x9acvZEHa1ZClvr7wFTraGMbpMVjETOga163NCAPGKqXqQeQKfDl61NBy1vD1CeDKsvHfG4Il5Jg7pXY2oFAY94oQJ6w32H/Bov4zVi0/5aps/1GxLiAZS6op9coWI/Kl16sRAysXLPfKUIt+zfLz/3mTHnIWPD1XwNF5UsvUfSIcoOPXVzZowJoSAcUtsZqXQmeBOVAEfeqRbHN/ky1mmabKnUw9xzolpUtQPh6UNkgA8xAOiW2KqKA6YD56NV77s1fdOvxw6RQu+Eq+3HghGh2X8RtPGh0w9cd2Yd733x835TnnoXL7l/cM7P4q2g2F7mRROEmfCL1OHpHdwdRO1pnDSPCsSWOC4hBHDwPlrKzmLe2alcAwdkOMGRilM+lkmZ7qF31KRIK4iDbEBAEc9VZ5dCIVgdZbYDIFp0VD3WPI3NSghh+6tg2So88e/kVn728b7KXrV9YeOrYdkKPPHPkyMnLe6fYpZsnjz6xcO2Xrrru69ezvUoOPnNsmp6Gaweu/TJcewvb6+QQXAMdIp2+nf4bvc6J1SqiYeZZhMa7BJk51UiNrwtC3hGECic5grDUmW7SVYLWVjuHS8Nt+aZiuhgx1aSerK97BNOSP3dHnnPO8X9wnz5q/xAUAcCZeKEQX5Vf+mv7h+wSbmKXVuWvW32NWKsfXTr5+vfO0Bx+F/RBs7OvM9DVWfAeSG9iZYFegK2I4A14RbZVsONLBGZCLKC0M8+W13iZ2HIiSOnpUyD8jj37D88em8b25wIJ10dCbHYnEcTKW1wJ13OuReLmDj7LFkc8e5Bz462G8p/NYNBUsBFTLleUxxVm4z58+hG6QHuQB/RfO6pYJWbeH6zvoci8v6yJzOW7a8Xlu425fMdY0Juh66oULOCMQ1aZuk/bPGeD2uwypzRmhmnP1C3P3jI9/c6/fud0ZzG99BMwy1IELDT7pUxYDmechOD9t922/7x31Grv+FYKTGL7FrameTu7+wBLnD2uy4BnvgZ8YgJSTKIM2BUz1jboc44n3Fwjeo/FSykSBRxYj+KbAxMBMOY4HGQ0jd0E8OYoY5tscyadakomHH0e0lWPwhNkYtPDCK7z7BnbM4S2gvaygP7o/fbT2Jb0cFjH/6aFcTQQj9tT9mN4YvmLJx57bDGs0xOsjP1w0Lf0FV+QlicWty5OvOc9jF7WwTs94WDfDGqz8mx1EOOVVbzOObzOoVRTPOZzoygXBnuYB+7mBtmsAgOqbLrKKywv3CeHvjMwcEGxO7Drvbu/u/v+mjuerLRvrFReuO++F+5bBGNJjeqBXe/ZufM9uwLegM8lsrUaiO3r+nxjDTZma2gGnb0poihsBZ2FYmyHYjzJKGU96zECRnmPM8fFtG41m3PQL5vdymehfw6mOorpDSmSotel2ospljv1AnnX0ptIazLY8YViKDGQmE2Orsrjd6N67DK1oT9KgMxm0YXocnQduhsvWspfYJeew2KA7TDEPGA7ZSxpAVHai0JRX4R6vCEPQDAvMnSvUQOR79J0Vy2GNRQQtQADZEKYIL+IdrGIHOyEVUCDken2mzXkRkF3cKaxQ9H4ozGov+bUr0mBhT/5D1jzK3VTYhJq/ml+Ixh0TyC3OzjNfoy57DZdcWT+otrcxDhGf377rW+96carrzxy3RXXXXro4IGLLp+//II9cxfWLtw+NT47MbthfW+12N7a0pxhW6OAvlc9blnkCCoBfXkLjNx/l7J3fHiOrg/6fdgpWu1w9ib0OjsTJpx9CVn8Vzd29ump70u8vM2mM/uVYiFijW18zHJ31cnw7Pl0PpdfYciA5lTnp+edf77XMLznG1GjnnHStm7ZiCqzc0rUULqLcKVmjLUXFzraxwy/H7IdC0XIGvbz9pKz2yqF1O7eaCaTJkv24Jm2anefGrL5YFNT8JRh/wqOdLe5o9p3Q28iYrclCm0JUnuPUt1hhh7r8EcN9iPeohH1s5Nu+F15bo61oRsu7Vv+2SL87KjfMPyjkMU/S7Ynz3zsZ9pMExtN7cnv9HYn25uu7ZkxQyGP3pagfYm2Y/YLnPPjDqYhp49x2+ntf+gacH55DThN0X0X2Nsv+Ff85Iv4yaXvLGJ07YsvgpLB5Bv2C/BT/xu2RJvQAAAAeJxjYGRgYABi5oWJ9+L5bb4yyLMwgMAVrvCPCPq/Pksw81Igl4OBCSQKACByCisAeJxjYGRgYF76X58hhiWYgeH/fyAJFEEB0QB7yAU8AAB4nGMsY1BiAALGUAYG5pcMOixANhK2AmJWKNuBhRFIM0LlGBnYwbQrEDPBxZD1HmBhYJRBUcvAMAmKQXLuQJoTKp4GxCA1TEA8B80NDCzBDGVI/FqoPSC1jGhqmYG4B0UMolYBKueCpp4RSR8LmlwUFDcAsQcQ20PFGyDqGR2AdDA4XCD2gMzigNq3GoiNgdgJHibBDEwAHcYPNgAAAAAoACgAKAFkAeoCVAKqA4AD+gRmBSAFuAX+BkoGjAbwB2IImAj6CVoJrAoaCkIKYAq+C4QMCAwuDFQMggygDQANTA3iDoIO4A8+D4wP8BBgERoRThHYEyITnhP+FGIUrBUWFWAVrhYAFrQXvBguGPYZlBo6GuweAh6yH2YhuiI+Iq4jFCO6JMIlyiYcJnAmxCbwJ3IoKCiGKTIpvCqGKwgrsiwGLGos7C08LZouBC5OLowwHDBSAAEAAABbAXsAEgAAAAAAAgBIAFYAbAAAAS8CLQAAAAB4nH2Qu07DQBBFr/NSkCgiWpqRRZEUa603DsqjT9LQ0keJnVgKtmQ7D/ENSHS0iE+g5eu43iwNRWztzJnd65m7BnCLD3ioHw9d3DluoIOB4yYe8Oq4Rc234zbm3tJxB13vi0qvdcOdnv2q5gb73ztuYgntuEXNp+M23vDjuIOe944Ua+TIkNhYAek6z5I8Iz0hxoaCA15YxJv0wDx3ujoX2FIiMAg4TTDl+t/vsmswhMKEy1AZ4pGNOGOeF9tYTKBlKn9ziWaoJsrokKor9p45u0BJSX0k7HpxMeOq+CZY0XrF0x01Fy99HKkJ6CTiPxf62TOOLRWMI9tBYWE9a1edbffI8onR57lvq8TGkmbiokzzTELeZSZVlawOVb5LeZ3+UQeTaCBqL2NRhYy0qIUYzXSWMBJ1En/hi0pEldfu+wsJj1l8AAAAeJxtzUdulFEQReH/NMEmg8k52mToqlevbZOMQ5uco+QVMGHGClg4IDhDrnR1ht8wGv7u188hh/9t688ZRsMWI7axnR3sZIZZdrGbPexlH/s5wEEOMcdhjnCUYxznBCc5xWnOcJZznOcCF7nEZa4wzwJXucZ1bnCTW9zmDncZEySNojNhkSWWucd9HvCQR6zwmFXWWGeDKZs84SnPeM4LXvKK17zhLe94zwc+8onPfOHrzI/v36aT8diGTdts2W4ndtEu2WW7atfsut2wU7v5r6Ef+qEf+qEf+qEf+qEf+qEf+qEf+qEf+qmf+qmf+qmf+qmf+qmf+qmf+qmf+qmf+k2/6Tf9pt/0m37Tb/pNv+k3/abf9Jt+02/6pV/6pV/6pV/6pV/6pV/6pV/6pV/6pV/6Xb/rd/2u3/W7fp/8BvSP07YAS7gAyFJYsQEBjlm5CAAIAGMgsAEjRCCwAyNwsA5FICBLuAAOUUuwBlNaWLA0G7AoWWBmIIpVWLACJWGwAUVjI2KwAiNEswoJBQQrswoLBQQrsw4PBQQrWbIEKAlFUkSzCg0GBCuxBgFEsSQBiFFYsECIWLEGA0SxJgGIUVi4BACIWLEGAURZWVlZuAH/hbAEjbEFAEQAAAA="
|
|
|
|
/***/ }),
|
|
/* 197 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(84),
|
|
/* template */
|
|
__webpack_require__(200),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ }),
|
|
/* 198 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(85),
|
|
/* template */
|
|
__webpack_require__(204),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ }),
|
|
/* 199 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(86),
|
|
/* template */
|
|
__webpack_require__(205),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ }),
|
|
/* 200 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('button', {
|
|
class: [
|
|
'o2-button',
|
|
'o2-button--' + _vm.type,
|
|
'o2-button--' + _vm.size,
|
|
{
|
|
'is-disabled': _vm.disabled,
|
|
'is-loading': _vm.loading
|
|
}
|
|
],
|
|
attrs: {
|
|
"type": _vm.nativeType,
|
|
"disabled": _vm.disabled
|
|
},
|
|
on: {
|
|
"click": _vm.handleClick
|
|
}
|
|
}, [(_vm.loading) ? _c('i', {
|
|
staticClass: "o2-icon-loading"
|
|
}) : _vm._e(), _vm._v(" "), _c('span', {
|
|
staticClass: "o2-button-text"
|
|
}, [_vm._t("default")], 2)])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }),
|
|
/* 201 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('div', {
|
|
staticClass: "side-nav"
|
|
}, [_c('ul', _vm._l((_vm.data), function(item) {
|
|
return _c('li', {
|
|
staticClass: "nav-item"
|
|
}, [(!item.path) ? _c('a', [_vm._v(_vm._s(item.name))]) : _c('router-link', {
|
|
attrs: {
|
|
"active-class": "active",
|
|
"to": _vm.base + item.path,
|
|
"exact": ""
|
|
},
|
|
domProps: {
|
|
"textContent": _vm._s(item.title || item.name)
|
|
}
|
|
}), _vm._v(" "), (item.children) ? _c('ul', {
|
|
staticClass: "pure-menu-list sub-nav"
|
|
}, _vm._l((item.children), function(navItem) {
|
|
return _c('li', {
|
|
staticClass: "nav-item"
|
|
}, [_c('router-link', {
|
|
attrs: {
|
|
"active-class": "active",
|
|
"to": _vm.base + navItem.path
|
|
},
|
|
domProps: {
|
|
"textContent": _vm._s(navItem.title || navItem.name)
|
|
}
|
|
})], 1)
|
|
})) : _vm._e(), _vm._v(" "), (item.groups) ? _vm._l((item.groups), function(group) {
|
|
return _c('div', {
|
|
staticClass: "nav-group"
|
|
}, [_c('div', {
|
|
staticClass: "nav-group__title"
|
|
}, [_vm._v(_vm._s(group.groupName))]), _vm._v(" "), _c('ul', {
|
|
staticClass: "pure-menu-list"
|
|
}, [_vm._l((group.list), function(navItem) {
|
|
return [(!navItem.disabled) ? _c('li', {
|
|
staticClass: "nav-item"
|
|
}, [_c('router-link', {
|
|
attrs: {
|
|
"active-class": "active",
|
|
"to": _vm.base + navItem.path
|
|
},
|
|
domProps: {
|
|
"textContent": _vm._s(navItem.title)
|
|
}
|
|
})], 1) : _vm._e()]
|
|
})], 2)])
|
|
}) : _vm._e()], 2)
|
|
}))])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }),
|
|
/* 202 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('div', {
|
|
staticClass: "page-container"
|
|
}, [_c('side-nav', {
|
|
attrs: {
|
|
"data": _vm.navConfig['zh-CN'],
|
|
"base": "/component"
|
|
}
|
|
}), _vm._v(" "), _c('div', {
|
|
staticClass: "page-content"
|
|
}, [_c('router-view')], 1)], 1)
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }),
|
|
/* 203 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('div', {
|
|
staticClass: "demo-block",
|
|
class: [_vm.blockClass, {
|
|
'hover': _vm.hovering
|
|
}],
|
|
on: {
|
|
"mouseenter": function($event) {
|
|
_vm.hovering = true
|
|
},
|
|
"mouseleave": function($event) {
|
|
_vm.hovering = false
|
|
}
|
|
}
|
|
}, [_vm._t("source"), _vm._v(" "), _c('div', {
|
|
staticClass: "meta"
|
|
}, [_c('div', {
|
|
staticClass: "description"
|
|
}, [_vm._t("default")], 2), _vm._v(" "), _vm._t("highlight")], 2), _vm._v(" "), _c('div', {
|
|
staticClass: "demo-block-control",
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.isExpanded = !_vm.isExpanded
|
|
}
|
|
}
|
|
}, [_c('span', {
|
|
directives: [{
|
|
name: "show",
|
|
rawName: "v-show",
|
|
value: (_vm.hovering),
|
|
expression: "hovering"
|
|
}]
|
|
}, [_vm._v(_vm._s(_vm.controlText))])])], 2)
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }),
|
|
/* 204 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('div', [_c('h2', [_vm._v("author: " + _vm._s(_vm.author))]), _vm._v(" "), _c('div', [_vm._v("Hello " + _vm._s(_vm.name))])])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }),
|
|
/* 205 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('div', {
|
|
staticClass: "o2-switch",
|
|
class: ['is-' + _vm.switchState],
|
|
on: {
|
|
"click": _vm.toggleState
|
|
}
|
|
}, [_c('div', {
|
|
staticClass: "o2-switch-node"
|
|
})])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }),
|
|
/* 206 */
|
|
/***/ (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__(92);
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
if(content.locals) module.exports = content.locals;
|
|
// add the styles to the DOM
|
|
var update = __webpack_require__(20)("74b2d9b2", content, true);
|
|
// 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?minimize!./../../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-191ca0a3!./../../node_modules/less-loader/index.js!./../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./side-nav.vue", function() {
|
|
var newContent = require("!!./../../node_modules/css-loader/index.js?minimize!./../../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-191ca0a3!./../../node_modules/less-loader/index.js!./../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./side-nav.vue");
|
|
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
|
|
update(newContent);
|
|
});
|
|
}
|
|
// When the module is disposed, remove the <style> tags
|
|
module.hot.dispose(function() { update(); });
|
|
}
|
|
|
|
/***/ }),
|
|
/* 207 */
|
|
/***/ (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__(93);
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
if(content.locals) module.exports = content.locals;
|
|
// add the styles to the DOM
|
|
var update = __webpack_require__(20)("ca603dc6", content, true);
|
|
// 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?minimize!./../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-438aa89e!./../node_modules/less-loader/index.js!./../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./App.vue", function() {
|
|
var newContent = require("!!./../node_modules/css-loader/index.js?minimize!./../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-438aa89e!./../node_modules/less-loader/index.js!./../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./App.vue");
|
|
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
|
|
update(newContent);
|
|
});
|
|
}
|
|
// When the module is disposed, remove the <style> tags
|
|
module.hot.dispose(function() { update(); });
|
|
}
|
|
|
|
/***/ }),
|
|
/* 208 */
|
|
/***/ (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__(94);
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
if(content.locals) module.exports = content.locals;
|
|
// add the styles to the DOM
|
|
var update = __webpack_require__(20)("1ac4b039", content, true);
|
|
// 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?minimize!./../../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-610842ce!./../../node_modules/less-loader/index.js!./../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./demo-block.vue", function() {
|
|
var newContent = require("!!./../../node_modules/css-loader/index.js?minimize!./../../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-610842ce!./../../node_modules/less-loader/index.js!./../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./demo-block.vue");
|
|
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
|
|
update(newContent);
|
|
});
|
|
}
|
|
// When the module is disposed, remove the <style> tags
|
|
module.hot.dispose(function() { update(); });
|
|
}
|
|
|
|
/***/ }),
|
|
/* 209 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* Translates the list format produced by css-loader into something
|
|
* easier to manipulate.
|
|
*/
|
|
module.exports = function listToStyles (parentId, list) {
|
|
var styles = []
|
|
var newStyles = {}
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
var id = item[0]
|
|
var css = item[1]
|
|
var media = item[2]
|
|
var sourceMap = item[3]
|
|
var part = {
|
|
id: parentId + ':' + i,
|
|
css: css,
|
|
media: media,
|
|
sourceMap: sourceMap
|
|
}
|
|
if (!newStyles[id]) {
|
|
styles.push(newStyles[id] = { id: id, parts: [part] })
|
|
} else {
|
|
newStyles[id].parts.push(part)
|
|
}
|
|
}
|
|
return styles
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 210 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/* (ignored) */
|
|
|
|
/***/ }),
|
|
/* 211 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* WEBPACK VAR INJECTION */(function(__dirname) {
|
|
|
|
__webpack_require__(57);
|
|
|
|
var _vue = __webpack_require__(62);
|
|
|
|
var _vue2 = _interopRequireDefault(_vue);
|
|
|
|
var _vueRouter = __webpack_require__(61);
|
|
|
|
var _vueRouter2 = _interopRequireDefault(_vueRouter);
|
|
|
|
var _App = __webpack_require__(58);
|
|
|
|
var _App2 = _interopRequireDefault(_App);
|
|
|
|
var _router = __webpack_require__(55);
|
|
|
|
var _router2 = _interopRequireDefault(_router);
|
|
|
|
var _demoBlock = __webpack_require__(59);
|
|
|
|
var _demoBlock2 = _interopRequireDefault(_demoBlock);
|
|
|
|
var _sideNav = __webpack_require__(60);
|
|
|
|
var _sideNav2 = _interopRequireDefault(_sideNav);
|
|
|
|
var _index = __webpack_require__(56);
|
|
|
|
var _index2 = _interopRequireDefault(_index);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
_vue2.default.use(_index2.default);
|
|
_vue2.default.use(_vueRouter2.default);
|
|
_vue2.default.component('demo-block', _demoBlock2.default);
|
|
_vue2.default.component('side-nav', _sideNav2.default);
|
|
|
|
var router = new _vueRouter2.default({
|
|
mode: 'hash',
|
|
base: __dirname,
|
|
routes: _router2.default
|
|
});
|
|
|
|
var indexScrollTop = 0;
|
|
router.beforeEach(function (route, redirect, next) {
|
|
if (route.path !== '/') {
|
|
indexScrollTop = document.body.scrollTop;
|
|
}
|
|
document.title = route.meta.title || document.title;
|
|
next();
|
|
});
|
|
|
|
router.afterEach(function (route) {
|
|
if (route.path !== '/') {
|
|
document.body.scrollTop = 0;
|
|
} else {
|
|
_vue2.default.nextTick(function () {
|
|
document.body.scrollTop = indexScrollTop;
|
|
});
|
|
}
|
|
});
|
|
|
|
new _vue2.default({ // eslint-disable-line
|
|
render: function render(h) {
|
|
return h(_App2.default);
|
|
},
|
|
router: router
|
|
}).$mount('#app-container');
|
|
/* WEBPACK VAR INJECTION */}.call(exports, "/"))
|
|
|
|
/***/ })
|
|
/******/ ]);
|
|
//# sourceMappingURL=build-docs.js.map
|