| (this.nativeLog || function(s) {console.log(s)})('START JS FRAMEWORK: 0.13.7'); |
| /******/ (function(modules) { // webpackBootstrap |
| /******/ // The module cache |
| /******/ var installedModules = {}; |
| /******/ |
| /******/ // The require function |
| /******/ function __webpack_require__(moduleId) { |
| /******/ |
| /******/ // Check if module is in cache |
| /******/ if(installedModules[moduleId]) |
| /******/ return installedModules[moduleId].exports; |
| /******/ |
| /******/ // Create a new module (and put it into the cache) |
| /******/ var module = installedModules[moduleId] = { |
| /******/ exports: {}, |
| /******/ id: moduleId, |
| /******/ loaded: false |
| /******/ }; |
| /******/ |
| /******/ // Execute the module function |
| /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
| /******/ |
| /******/ // Flag the module as loaded |
| /******/ module.loaded = true; |
| /******/ |
| /******/ // Return the exports of the module |
| /******/ return module.exports; |
| /******/ } |
| /******/ |
| /******/ |
| /******/ // expose the modules object (__webpack_modules__) |
| /******/ __webpack_require__.m = modules; |
| /******/ |
| /******/ // expose the module cache |
| /******/ __webpack_require__.c = installedModules; |
| /******/ |
| /******/ // __webpack_public_path__ |
| /******/ __webpack_require__.p = ""; |
| /******/ |
| /******/ // Load entry module and return exports |
| /******/ return __webpack_require__(0); |
| /******/ }) |
| /************************************************************************/ |
| /******/ ([ |
| /* 0 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| __webpack_require__(1); |
| |
| var _framework = __webpack_require__(76); |
| |
| var framework = _interopRequireWildcard(_framework); |
| |
| var _package = __webpack_require__(105); |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| var _loop = function _loop(methodName) { |
| global[methodName] = function () { |
| var ret = framework[methodName].apply(framework, arguments); |
| if (ret instanceof Error) { |
| console.error(ret.toString()); |
| } else if (ret instanceof Array) { |
| ret.forEach(function (r) { |
| if (r instanceof Error) { |
| console.error(r.toString()); |
| } |
| }); |
| } |
| return ret; |
| }; |
| }; |
| |
| for (var methodName in framework) { |
| _loop(methodName); |
| } |
| |
| Object.assign(global, { |
| frameworkVersion: _package.version, |
| needTransformerVersion: _package.optionalDependencies['weex-transformer'] |
| }); |
| |
| /** |
| * register methods |
| */ |
| var methods = __webpack_require__(106); |
| var _global = global; |
| var registerMethods = _global.registerMethods; |
| |
| registerMethods(methods); |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 1 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| __webpack_require__(2); |
| |
| __webpack_require__(40); |
| |
| __webpack_require__(74); |
| |
| __webpack_require__(75); |
| |
| /***/ }, |
| /* 2 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| __webpack_require__(3); |
| |
| /***/ }, |
| /* 3 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| __webpack_require__(4); |
| module.exports = __webpack_require__(7).Object.assign; |
| |
| /***/ }, |
| /* 4 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 19.1.3.1 Object.assign(target, source) |
| var $export = __webpack_require__(5); |
| |
| $export($export.S + $export.F, 'Object', { assign: __webpack_require__(23) }); |
| |
| /***/ }, |
| /* 5 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var global = __webpack_require__(6), |
| core = __webpack_require__(7), |
| hide = __webpack_require__(8), |
| redefine = __webpack_require__(18), |
| ctx = __webpack_require__(21), |
| PROTOTYPE = 'prototype'; |
| |
| var $export = function $export(type, name, source) { |
| var IS_FORCED = type & $export.F, |
| IS_GLOBAL = type & $export.G, |
| IS_STATIC = type & $export.S, |
| IS_PROTO = type & $export.P, |
| IS_BIND = type & $export.B, |
| target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE], |
| exports = IS_GLOBAL ? core : core[name] || (core[name] = {}), |
| expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}), |
| key, |
| own, |
| out, |
| exp; |
| if (IS_GLOBAL) source = name; |
| for (key in source) { |
| // contains in native |
| own = !IS_FORCED && target && target[key] !== undefined; |
| // export native or passed |
| out = (own ? target : source)[key]; |
| // bind timers to global for call from export context |
| exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; |
| // extend global |
| if (target) redefine(target, key, out, type & $export.U); |
| // export |
| if (exports[key] != out) hide(exports, key, exp); |
| if (IS_PROTO && expProto[key] != out) expProto[key] = out; |
| } |
| }; |
| global.core = core; |
| // type bitmap |
| $export.F = 1; // forced |
| $export.G = 2; // global |
| $export.S = 4; // static |
| $export.P = 8; // proto |
| $export.B = 16; // bind |
| $export.W = 32; // wrap |
| $export.U = 64; // safe |
| $export.R = 128; // real proto method for `library` |
| module.exports = $export; |
| |
| /***/ }, |
| /* 6 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 |
| var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); |
| if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef |
| |
| /***/ }, |
| /* 7 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| var core = module.exports = { version: '2.1.5' }; |
| if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef |
| |
| /***/ }, |
| /* 8 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var dP = __webpack_require__(9), |
| createDesc = __webpack_require__(17); |
| module.exports = __webpack_require__(13) ? function (object, key, value) { |
| return dP.f(object, key, createDesc(1, value)); |
| } : function (object, key, value) { |
| object[key] = value; |
| return object; |
| }; |
| |
| /***/ }, |
| /* 9 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var anObject = __webpack_require__(10), |
| IE8_DOM_DEFINE = __webpack_require__(12), |
| toPrimitive = __webpack_require__(16), |
| dP = Object.defineProperty; |
| |
| exports.f = __webpack_require__(13) ? Object.defineProperty : function defineProperty(O, P, Attributes) { |
| anObject(O); |
| P = toPrimitive(P, true); |
| anObject(Attributes); |
| if (IE8_DOM_DEFINE) try { |
| return dP(O, P, Attributes); |
| } catch (e) {/* empty */} |
| if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); |
| if ('value' in Attributes) O[P] = Attributes.value; |
| return O; |
| }; |
| |
| /***/ }, |
| /* 10 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var isObject = __webpack_require__(11); |
| module.exports = function (it) { |
| if (!isObject(it)) throw TypeError(it + ' is not an object!'); |
| return it; |
| }; |
| |
| /***/ }, |
| /* 11 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; |
| |
| module.exports = function (it) { |
| return (typeof it === 'undefined' ? 'undefined' : _typeof(it)) === 'object' ? it !== null : typeof it === 'function'; |
| }; |
| |
| /***/ }, |
| /* 12 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| module.exports = !__webpack_require__(13) && !__webpack_require__(14)(function () { |
| return Object.defineProperty(__webpack_require__(15)('div'), 'a', { get: function get() { |
| return 7; |
| } }).a != 7; |
| }); |
| |
| /***/ }, |
| /* 13 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // Thank's IE8 for his funny defineProperty |
| module.exports = !__webpack_require__(14)(function () { |
| return Object.defineProperty({}, 'a', { get: function get() { |
| return 7; |
| } }).a != 7; |
| }); |
| |
| /***/ }, |
| /* 14 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| module.exports = function (exec) { |
| try { |
| return !!exec(); |
| } catch (e) { |
| return true; |
| } |
| }; |
| |
| /***/ }, |
| /* 15 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var isObject = __webpack_require__(11), |
| document = __webpack_require__(6).document |
| // in old IE typeof document.createElement is 'object' |
| , |
| is = isObject(document) && isObject(document.createElement); |
| module.exports = function (it) { |
| return is ? document.createElement(it) : {}; |
| }; |
| |
| /***/ }, |
| /* 16 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 7.1.1 ToPrimitive(input [, PreferredType]) |
| var isObject = __webpack_require__(11); |
| // instead of the ES6 spec version, we didn't implement @@toPrimitive case |
| // and the second argument - flag - preferred type is a string |
| module.exports = function (it, S) { |
| if (!isObject(it)) return it; |
| var fn, val; |
| if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; |
| if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; |
| if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; |
| throw TypeError("Can't convert object to primitive value"); |
| }; |
| |
| /***/ }, |
| /* 17 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| module.exports = function (bitmap, value) { |
| return { |
| enumerable: !(bitmap & 1), |
| configurable: !(bitmap & 2), |
| writable: !(bitmap & 4), |
| value: value |
| }; |
| }; |
| |
| /***/ }, |
| /* 18 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var global = __webpack_require__(6), |
| hide = __webpack_require__(8), |
| has = __webpack_require__(19), |
| SRC = __webpack_require__(20)('src'), |
| TO_STRING = 'toString', |
| $toString = Function[TO_STRING], |
| TPL = ('' + $toString).split(TO_STRING); |
| |
| __webpack_require__(7).inspectSource = function (it) { |
| return $toString.call(it); |
| }; |
| |
| (module.exports = function (O, key, val, safe) { |
| var isFunction = typeof val == 'function'; |
| if (isFunction) has(val, 'name') || hide(val, 'name', key); |
| if (O[key] === val) return; |
| if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); |
| if (O === global) { |
| O[key] = val; |
| } else { |
| if (!safe) { |
| delete O[key]; |
| hide(O, key, val); |
| } else { |
| if (O[key]) O[key] = val;else hide(O, key, val); |
| } |
| } |
| // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative |
| })(Function.prototype, TO_STRING, function toString() { |
| return typeof this == 'function' && this[SRC] || $toString.call(this); |
| }); |
| |
| /***/ }, |
| /* 19 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| var hasOwnProperty = {}.hasOwnProperty; |
| module.exports = function (it, key) { |
| return hasOwnProperty.call(it, key); |
| }; |
| |
| /***/ }, |
| /* 20 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| var id = 0, |
| px = Math.random(); |
| module.exports = function (key) { |
| return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); |
| }; |
| |
| /***/ }, |
| /* 21 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // optional / simple context binding |
| var aFunction = __webpack_require__(22); |
| module.exports = function (fn, that, length) { |
| aFunction(fn); |
| if (that === undefined) return fn; |
| switch (length) { |
| case 1: |
| return function (a) { |
| return fn.call(that, a); |
| }; |
| case 2: |
| return function (a, b) { |
| return fn.call(that, a, b); |
| }; |
| case 3: |
| return function (a, b, c) { |
| return fn.call(that, a, b, c); |
| }; |
| } |
| return function () /* ...args */{ |
| return fn.apply(that, arguments); |
| }; |
| }; |
| |
| /***/ }, |
| /* 22 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| module.exports = function (it) { |
| if (typeof it != 'function') throw TypeError(it + ' is not a function!'); |
| return it; |
| }; |
| |
| /***/ }, |
| /* 23 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| // 19.1.2.1 Object.assign(target, source, ...) |
| |
| var getKeys = __webpack_require__(24), |
| gOPS = __webpack_require__(37), |
| pIE = __webpack_require__(38), |
| toObject = __webpack_require__(39), |
| IObject = __webpack_require__(27), |
| $assign = Object.assign; |
| |
| // should work with symbols and should have deterministic property order (V8 bug) |
| module.exports = !$assign || __webpack_require__(14)(function () { |
| var A = {}, |
| B = {}, |
| S = Symbol(), |
| K = 'abcdefghijklmnopqrst'; |
| A[S] = 7; |
| K.split('').forEach(function (k) { |
| B[k] = k; |
| }); |
| return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; |
| }) ? function assign(target, source) { |
| // eslint-disable-line no-unused-vars |
| var T = toObject(target), |
| aLen = arguments.length, |
| index = 1, |
| getSymbols = gOPS.f, |
| isEnum = pIE.f; |
| while (aLen > index) { |
| var S = IObject(arguments[index++]), |
| keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S), |
| length = keys.length, |
| j = 0, |
| key; |
| while (length > j) { |
| if (isEnum.call(S, key = keys[j++])) T[key] = S[key]; |
| } |
| }return T; |
| } : $assign; |
| |
| /***/ }, |
| /* 24 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 19.1.2.14 / 15.2.3.14 Object.keys(O) |
| var $keys = __webpack_require__(25), |
| enumBugKeys = __webpack_require__(36); |
| |
| module.exports = Object.keys || function keys(O) { |
| return $keys(O, enumBugKeys); |
| }; |
| |
| /***/ }, |
| /* 25 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var has = __webpack_require__(19), |
| toIObject = __webpack_require__(26), |
| arrayIndexOf = __webpack_require__(30)(false), |
| IE_PROTO = __webpack_require__(34)('IE_PROTO'); |
| |
| module.exports = function (object, names) { |
| var O = toIObject(object), |
| i = 0, |
| result = [], |
| key; |
| for (key in O) { |
| if (key != IE_PROTO) has(O, key) && result.push(key); |
| } // Don't enum bug & hidden keys |
| while (names.length > i) { |
| if (has(O, key = names[i++])) { |
| ~arrayIndexOf(result, key) || result.push(key); |
| } |
| }return result; |
| }; |
| |
| /***/ }, |
| /* 26 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // to indexed object, toObject with fallback for non-array-like ES3 strings |
| var IObject = __webpack_require__(27), |
| defined = __webpack_require__(29); |
| module.exports = function (it) { |
| return IObject(defined(it)); |
| }; |
| |
| /***/ }, |
| /* 27 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // fallback for non-array-like ES3 and non-enumerable old V8 strings |
| var cof = __webpack_require__(28); |
| module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) { |
| return cof(it) == 'String' ? it.split('') : Object(it); |
| }; |
| |
| /***/ }, |
| /* 28 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| var toString = {}.toString; |
| |
| module.exports = function (it) { |
| return toString.call(it).slice(8, -1); |
| }; |
| |
| /***/ }, |
| /* 29 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| // 7.2.1 RequireObjectCoercible(argument) |
| module.exports = function (it) { |
| if (it == undefined) throw TypeError("Can't call method on " + it); |
| return it; |
| }; |
| |
| /***/ }, |
| /* 30 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // false -> Array#indexOf |
| // true -> Array#includes |
| var toIObject = __webpack_require__(26), |
| toLength = __webpack_require__(31), |
| toIndex = __webpack_require__(33); |
| module.exports = function (IS_INCLUDES) { |
| return function ($this, el, fromIndex) { |
| var O = toIObject($this), |
| length = toLength(O.length), |
| index = toIndex(fromIndex, length), |
| value; |
| // Array#includes uses SameValueZero equality algorithm |
| if (IS_INCLUDES && el != el) while (length > index) { |
| value = O[index++]; |
| if (value != value) return true; |
| // Array#toIndex ignores holes, Array#includes - not |
| } else for (; length > index; index++) { |
| if (IS_INCLUDES || index in O) { |
| if (O[index] === el) return IS_INCLUDES || index; |
| } |
| }return !IS_INCLUDES && -1; |
| }; |
| }; |
| |
| /***/ }, |
| /* 31 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 7.1.15 ToLength |
| var toInteger = __webpack_require__(32), |
| min = Math.min; |
| module.exports = function (it) { |
| return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 |
| }; |
| |
| /***/ }, |
| /* 32 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| // 7.1.4 ToInteger |
| var ceil = Math.ceil, |
| floor = Math.floor; |
| module.exports = function (it) { |
| return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); |
| }; |
| |
| /***/ }, |
| /* 33 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var toInteger = __webpack_require__(32), |
| max = Math.max, |
| min = Math.min; |
| module.exports = function (index, length) { |
| index = toInteger(index); |
| return index < 0 ? max(index + length, 0) : min(index, length); |
| }; |
| |
| /***/ }, |
| /* 34 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var shared = __webpack_require__(35)('keys'), |
| uid = __webpack_require__(20); |
| module.exports = function (key) { |
| return shared[key] || (shared[key] = uid(key)); |
| }; |
| |
| /***/ }, |
| /* 35 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var global = __webpack_require__(6), |
| SHARED = '__core-js_shared__', |
| store = global[SHARED] || (global[SHARED] = {}); |
| module.exports = function (key) { |
| return store[key] || (store[key] = {}); |
| }; |
| |
| /***/ }, |
| /* 36 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| // IE 8- don't enum bug keys |
| module.exports = 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'.split(','); |
| |
| /***/ }, |
| /* 37 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| exports.f = Object.getOwnPropertySymbols; |
| |
| /***/ }, |
| /* 38 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| exports.f = {}.propertyIsEnumerable; |
| |
| /***/ }, |
| /* 39 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 7.1.13 ToObject(argument) |
| var defined = __webpack_require__(29); |
| module.exports = function (it) { |
| return Object(defined(it)); |
| }; |
| |
| /***/ }, |
| /* 40 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| // fix Promise Problem on JSContext of iOS7~8 |
| // @see https://bugs.webkit.org/show_bug.cgi?id=135866 |
| global.Promise = null; |
| __webpack_require__(41); |
| __webpack_require__(44); |
| __webpack_require__(55); |
| __webpack_require__(59); |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 41 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| // 19.1.3.6 Object.prototype.toString() |
| |
| var classof = __webpack_require__(42), |
| test = {}; |
| test[__webpack_require__(43)('toStringTag')] = 'z'; |
| if (test + '' != '[object z]') { |
| __webpack_require__(18)(Object.prototype, 'toString', function toString() { |
| return '[object ' + classof(this) + ']'; |
| }, true); |
| } |
| |
| /***/ }, |
| /* 42 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // getting tag from 19.1.3.6 Object.prototype.toString() |
| var cof = __webpack_require__(28), |
| TAG = __webpack_require__(43)('toStringTag') |
| // ES3 wrong here |
| , |
| ARG = cof(function () { |
| return arguments; |
| }()) == 'Arguments'; |
| |
| // fallback for IE11 Script Access Denied error |
| var tryGet = function tryGet(it, key) { |
| try { |
| return it[key]; |
| } catch (e) {/* empty */} |
| }; |
| |
| module.exports = function (it) { |
| var O, T, B; |
| return it === undefined ? 'Undefined' : it === null ? 'Null' |
| // @@toStringTag case |
| : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T |
| // builtinTag case |
| : ARG ? cof(O) |
| // ES3 arguments fallback |
| : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; |
| }; |
| |
| /***/ }, |
| /* 43 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var store = __webpack_require__(35)('wks'), |
| uid = __webpack_require__(20), |
| _Symbol = __webpack_require__(6).Symbol, |
| USE_SYMBOL = typeof _Symbol == 'function'; |
| module.exports = function (name) { |
| return store[name] || (store[name] = USE_SYMBOL && _Symbol[name] || (USE_SYMBOL ? _Symbol : uid)('Symbol.' + name)); |
| }; |
| |
| /***/ }, |
| /* 44 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var $at = __webpack_require__(45)(true); |
| |
| // 21.1.3.27 String.prototype[@@iterator]() |
| __webpack_require__(46)(String, 'String', function (iterated) { |
| this._t = String(iterated); // target |
| this._i = 0; // next index |
| // 21.1.5.2.1 %StringIteratorPrototype%.next() |
| }, function () { |
| var O = this._t, |
| index = this._i, |
| point; |
| if (index >= O.length) return { value: undefined, done: true }; |
| point = $at(O, index); |
| this._i += point.length; |
| return { value: point, done: false }; |
| }); |
| |
| /***/ }, |
| /* 45 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var toInteger = __webpack_require__(32), |
| defined = __webpack_require__(29); |
| // true -> String#at |
| // false -> String#codePointAt |
| module.exports = function (TO_STRING) { |
| return function (that, pos) { |
| var s = String(defined(that)), |
| i = toInteger(pos), |
| l = s.length, |
| a, |
| b; |
| if (i < 0 || i >= l) return TO_STRING ? '' : undefined; |
| a = s.charCodeAt(i); |
| return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; |
| }; |
| }; |
| |
| /***/ }, |
| /* 46 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var LIBRARY = __webpack_require__(47), |
| $export = __webpack_require__(5), |
| redefine = __webpack_require__(18), |
| hide = __webpack_require__(8), |
| has = __webpack_require__(19), |
| Iterators = __webpack_require__(48), |
| $iterCreate = __webpack_require__(49), |
| setToStringTag = __webpack_require__(53), |
| getPrototypeOf = __webpack_require__(54), |
| ITERATOR = __webpack_require__(43)('iterator'), |
| BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next` |
| , |
| FF_ITERATOR = '@@iterator', |
| KEYS = 'keys', |
| VALUES = 'values'; |
| |
| var returnThis = function returnThis() { |
| return this; |
| }; |
| |
| module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) { |
| $iterCreate(Constructor, NAME, next); |
| var getMethod = function getMethod(kind) { |
| if (!BUGGY && kind in proto) return proto[kind]; |
| switch (kind) { |
| case KEYS: |
| return function keys() { |
| return new Constructor(this, kind); |
| }; |
| case VALUES: |
| return function values() { |
| return new Constructor(this, kind); |
| }; |
| }return function entries() { |
| return new Constructor(this, kind); |
| }; |
| }; |
| var TAG = NAME + ' Iterator', |
| DEF_VALUES = DEFAULT == VALUES, |
| VALUES_BUG = false, |
| proto = Base.prototype, |
| $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT], |
| $default = $native || getMethod(DEFAULT), |
| $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined, |
| $anyNative = NAME == 'Array' ? proto.entries || $native : $native, |
| methods, |
| key, |
| IteratorPrototype; |
| // Fix native |
| if ($anyNative) { |
| IteratorPrototype = getPrototypeOf($anyNative.call(new Base())); |
| if (IteratorPrototype !== Object.prototype) { |
| // Set @@toStringTag to native iterators |
| setToStringTag(IteratorPrototype, TAG, true); |
| // fix for some old engines |
| if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis); |
| } |
| } |
| // fix Array#{values, @@iterator}.name in V8 / FF |
| if (DEF_VALUES && $native && $native.name !== VALUES) { |
| VALUES_BUG = true; |
| $default = function values() { |
| return $native.call(this); |
| }; |
| } |
| // Define iterator |
| if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) { |
| hide(proto, ITERATOR, $default); |
| } |
| // Plug for library |
| Iterators[NAME] = $default; |
| Iterators[TAG] = returnThis; |
| if (DEFAULT) { |
| methods = { |
| values: DEF_VALUES ? $default : getMethod(VALUES), |
| keys: IS_SET ? $default : getMethod(KEYS), |
| entries: $entries |
| }; |
| if (FORCED) for (key in methods) { |
| if (!(key in proto)) redefine(proto, key, methods[key]); |
| } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); |
| } |
| return methods; |
| }; |
| |
| /***/ }, |
| /* 47 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| module.exports = false; |
| |
| /***/ }, |
| /* 48 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| module.exports = {}; |
| |
| /***/ }, |
| /* 49 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var create = __webpack_require__(50), |
| descriptor = __webpack_require__(17), |
| setToStringTag = __webpack_require__(53), |
| IteratorPrototype = {}; |
| |
| // 25.1.2.1.1 %IteratorPrototype%[@@iterator]() |
| __webpack_require__(8)(IteratorPrototype, __webpack_require__(43)('iterator'), function () { |
| return this; |
| }); |
| |
| module.exports = function (Constructor, NAME, next) { |
| Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) }); |
| setToStringTag(Constructor, NAME + ' Iterator'); |
| }; |
| |
| /***/ }, |
| /* 50 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) |
| var anObject = __webpack_require__(10), |
| dPs = __webpack_require__(51), |
| enumBugKeys = __webpack_require__(36), |
| IE_PROTO = __webpack_require__(34)('IE_PROTO'), |
| Empty = function Empty() {/* empty */}, |
| PROTOTYPE = 'prototype'; |
| |
| // Create object with fake `null` prototype: use iframe Object with cleared prototype |
| var _createDict = function createDict() { |
| // Thrash, waste and sodomy: IE GC bug |
| var iframe = __webpack_require__(15)('iframe'), |
| i = enumBugKeys.length, |
| gt = '>', |
| iframeDocument; |
| iframe.style.display = 'none'; |
| __webpack_require__(52).appendChild(iframe); |
| iframe.src = 'javascript:'; // eslint-disable-line no-script-url |
| // createDict = iframe.contentWindow.Object; |
| // html.removeChild(iframe); |
| iframeDocument = iframe.contentWindow.document; |
| iframeDocument.open(); |
| iframeDocument.write('<script>document.F=Object</script' + gt); |
| iframeDocument.close(); |
| _createDict = iframeDocument.F; |
| while (i--) { |
| delete _createDict[PROTOTYPE][enumBugKeys[i]]; |
| }return _createDict(); |
| }; |
| |
| module.exports = Object.create || function create(O, Properties) { |
| var result; |
| if (O !== null) { |
| Empty[PROTOTYPE] = anObject(O); |
| result = new Empty(); |
| Empty[PROTOTYPE] = null; |
| // add "__proto__" for Object.getPrototypeOf polyfill |
| result[IE_PROTO] = O; |
| } else result = _createDict(); |
| return Properties === undefined ? result : dPs(result, Properties); |
| }; |
| |
| /***/ }, |
| /* 51 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var dP = __webpack_require__(9), |
| anObject = __webpack_require__(10), |
| getKeys = __webpack_require__(24); |
| |
| module.exports = __webpack_require__(13) ? Object.defineProperties : function defineProperties(O, Properties) { |
| anObject(O); |
| var keys = getKeys(Properties), |
| length = keys.length, |
| i = 0, |
| P; |
| while (length > i) { |
| dP.f(O, P = keys[i++], Properties[P]); |
| }return O; |
| }; |
| |
| /***/ }, |
| /* 52 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| module.exports = __webpack_require__(6).document && document.documentElement; |
| |
| /***/ }, |
| /* 53 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var def = __webpack_require__(9).f, |
| has = __webpack_require__(19), |
| TAG = __webpack_require__(43)('toStringTag'); |
| |
| module.exports = function (it, tag, stat) { |
| if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag }); |
| }; |
| |
| /***/ }, |
| /* 54 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) |
| var has = __webpack_require__(19), |
| toObject = __webpack_require__(39), |
| IE_PROTO = __webpack_require__(34)('IE_PROTO'), |
| ObjectProto = Object.prototype; |
| |
| module.exports = Object.getPrototypeOf || function (O) { |
| O = toObject(O); |
| if (has(O, IE_PROTO)) return O[IE_PROTO]; |
| if (typeof O.constructor == 'function' && O instanceof O.constructor) { |
| return O.constructor.prototype; |
| }return O instanceof Object ? ObjectProto : null; |
| }; |
| |
| /***/ }, |
| /* 55 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var $iterators = __webpack_require__(56), |
| redefine = __webpack_require__(18), |
| global = __webpack_require__(6), |
| hide = __webpack_require__(8), |
| Iterators = __webpack_require__(48), |
| wks = __webpack_require__(43), |
| ITERATOR = wks('iterator'), |
| TO_STRING_TAG = wks('toStringTag'), |
| ArrayValues = Iterators.Array; |
| |
| for (var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++) { |
| var NAME = collections[i], |
| Collection = global[NAME], |
| proto = Collection && Collection.prototype, |
| key; |
| if (proto) { |
| if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues); |
| if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME); |
| Iterators[NAME] = ArrayValues; |
| for (key in $iterators) { |
| if (!proto[key]) redefine(proto, key, $iterators[key], true); |
| } |
| } |
| } |
| |
| /***/ }, |
| /* 56 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var addToUnscopables = __webpack_require__(57), |
| step = __webpack_require__(58), |
| Iterators = __webpack_require__(48), |
| toIObject = __webpack_require__(26); |
| |
| // 22.1.3.4 Array.prototype.entries() |
| // 22.1.3.13 Array.prototype.keys() |
| // 22.1.3.29 Array.prototype.values() |
| // 22.1.3.30 Array.prototype[@@iterator]() |
| module.exports = __webpack_require__(46)(Array, 'Array', function (iterated, kind) { |
| this._t = toIObject(iterated); // target |
| this._i = 0; // next index |
| this._k = kind; // kind |
| // 22.1.5.2.1 %ArrayIteratorPrototype%.next() |
| }, function () { |
| var O = this._t, |
| kind = this._k, |
| index = this._i++; |
| if (!O || index >= O.length) { |
| this._t = undefined; |
| return step(1); |
| } |
| if (kind == 'keys') return step(0, index); |
| if (kind == 'values') return step(0, O[index]); |
| return step(0, [index, O[index]]); |
| }, 'values'); |
| |
| // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) |
| Iterators.Arguments = Iterators.Array; |
| |
| addToUnscopables('keys'); |
| addToUnscopables('values'); |
| addToUnscopables('entries'); |
| |
| /***/ }, |
| /* 57 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 22.1.3.31 Array.prototype[@@unscopables] |
| var UNSCOPABLES = __webpack_require__(43)('unscopables'), |
| ArrayProto = Array.prototype; |
| if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(8)(ArrayProto, UNSCOPABLES, {}); |
| module.exports = function (key) { |
| ArrayProto[UNSCOPABLES][key] = true; |
| }; |
| |
| /***/ }, |
| /* 58 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| module.exports = function (done, value) { |
| return { value: value, done: !!done }; |
| }; |
| |
| /***/ }, |
| /* 59 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var LIBRARY = __webpack_require__(47), |
| global = __webpack_require__(6), |
| ctx = __webpack_require__(21), |
| classof = __webpack_require__(42), |
| $export = __webpack_require__(5), |
| isObject = __webpack_require__(11), |
| anObject = __webpack_require__(10), |
| aFunction = __webpack_require__(22), |
| anInstance = __webpack_require__(60), |
| forOf = __webpack_require__(61), |
| setProto = __webpack_require__(65).set, |
| speciesConstructor = __webpack_require__(67), |
| task = __webpack_require__(68).set, |
| microtask = __webpack_require__(70), |
| PROMISE = 'Promise', |
| TypeError = global.TypeError, |
| process = global.process, |
| $Promise = global[PROMISE], |
| process = global.process, |
| isNode = classof(process) == 'process', |
| empty = function empty() {/* empty */}, |
| Internal, |
| GenericPromiseCapability, |
| Wrapper; |
| |
| var USE_NATIVE = !!function () { |
| try { |
| // correct subclassing with @@species support |
| var promise = $Promise.resolve(1), |
| FakePromise = (promise.constructor = {})[__webpack_require__(43)('species')] = function (exec) { |
| exec(empty, empty); |
| }; |
| // unhandled rejections tracking support, NodeJS Promise without it fails @@species test |
| return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise; |
| } catch (e) {/* empty */} |
| }(); |
| |
| // helpers |
| var sameConstructor = function sameConstructor(a, b) { |
| // with library wrapper special case |
| return a === b || a === $Promise && b === Wrapper; |
| }; |
| var isThenable = function isThenable(it) { |
| var then; |
| return isObject(it) && typeof (then = it.then) == 'function' ? then : false; |
| }; |
| var newPromiseCapability = function newPromiseCapability(C) { |
| return sameConstructor($Promise, C) ? new PromiseCapability(C) : new GenericPromiseCapability(C); |
| }; |
| var PromiseCapability = GenericPromiseCapability = function GenericPromiseCapability(C) { |
| var resolve, reject; |
| this.promise = new C(function ($$resolve, $$reject) { |
| if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); |
| resolve = $$resolve; |
| reject = $$reject; |
| }); |
| this.resolve = aFunction(resolve); |
| this.reject = aFunction(reject); |
| }; |
| var perform = function perform(exec) { |
| try { |
| exec(); |
| } catch (e) { |
| return { error: e }; |
| } |
| }; |
| var notify = function notify(promise, isReject) { |
| if (promise._n) return; |
| promise._n = true; |
| var chain = promise._c; |
| microtask(function () { |
| var value = promise._v, |
| ok = promise._s == 1, |
| i = 0; |
| var run = function run(reaction) { |
| var handler = ok ? reaction.ok : reaction.fail, |
| resolve = reaction.resolve, |
| reject = reaction.reject, |
| domain = reaction.domain, |
| result, |
| then; |
| try { |
| if (handler) { |
| if (!ok) { |
| if (promise._h == 2) onHandleUnhandled(promise); |
| promise._h = 1; |
| } |
| if (handler === true) result = value;else { |
| if (domain) domain.enter(); |
| result = handler(value); |
| if (domain) domain.exit(); |
| } |
| if (result === reaction.promise) { |
| reject(TypeError('Promise-chain cycle')); |
| } else if (then = isThenable(result)) { |
| then.call(result, resolve, reject); |
| } else resolve(result); |
| } else reject(value); |
| } catch (e) { |
| reject(e); |
| } |
| }; |
| while (chain.length > i) { |
| run(chain[i++]); |
| } // variable length - can't use forEach |
| promise._c = []; |
| promise._n = false; |
| if (isReject && !promise._h) onUnhandled(promise); |
| }); |
| }; |
| var onUnhandled = function onUnhandled(promise) { |
| task.call(global, function () { |
| var value = promise._v, |
| abrupt, |
| handler, |
| console; |
| if (isUnhandled(promise)) { |
| abrupt = perform(function () { |
| if (isNode) { |
| process.emit('unhandledRejection', value, promise); |
| } else if (handler = global.onunhandledrejection) { |
| handler({ promise: promise, reason: value }); |
| } else if ((console = global.console) && console.error) { |
| console.error('Unhandled promise rejection', value); |
| } |
| }); |
| // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should |
| promise._h = isNode || isUnhandled(promise) ? 2 : 1; |
| }promise._a = undefined; |
| if (abrupt) throw abrupt.error; |
| }); |
| }; |
| var isUnhandled = function isUnhandled(promise) { |
| if (promise._h == 1) return false; |
| var chain = promise._a || promise._c, |
| i = 0, |
| reaction; |
| while (chain.length > i) { |
| reaction = chain[i++]; |
| if (reaction.fail || !isUnhandled(reaction.promise)) return false; |
| }return true; |
| }; |
| var onHandleUnhandled = function onHandleUnhandled(promise) { |
| task.call(global, function () { |
| var handler; |
| if (isNode) { |
| process.emit('rejectionHandled', promise); |
| } else if (handler = global.onrejectionhandled) { |
| handler({ promise: promise, reason: promise._v }); |
| } |
| }); |
| }; |
| var $reject = function $reject(value) { |
| var promise = this; |
| if (promise._d) return; |
| promise._d = true; |
| promise = promise._w || promise; // unwrap |
| promise._v = value; |
| promise._s = 2; |
| if (!promise._a) promise._a = promise._c.slice(); |
| notify(promise, true); |
| }; |
| var $resolve = function $resolve(value) { |
| var promise = this, |
| then; |
| if (promise._d) return; |
| promise._d = true; |
| promise = promise._w || promise; // unwrap |
| try { |
| if (promise === value) throw TypeError("Promise can't be resolved itself"); |
| if (then = isThenable(value)) { |
| microtask(function () { |
| var wrapper = { _w: promise, _d: false }; // wrap |
| try { |
| then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1)); |
| } catch (e) { |
| $reject.call(wrapper, e); |
| } |
| }); |
| } else { |
| promise._v = value; |
| promise._s = 1; |
| notify(promise, false); |
| } |
| } catch (e) { |
| $reject.call({ _w: promise, _d: false }, e); // wrap |
| } |
| }; |
| |
| // constructor polyfill |
| if (!USE_NATIVE) { |
| // 25.4.3.1 Promise(executor) |
| $Promise = function Promise(executor) { |
| anInstance(this, $Promise, PROMISE, '_h'); |
| aFunction(executor); |
| Internal.call(this); |
| try { |
| executor(ctx($resolve, this, 1), ctx($reject, this, 1)); |
| } catch (err) { |
| $reject.call(this, err); |
| } |
| }; |
| Internal = function Promise(executor) { |
| this._c = []; // <- awaiting reactions |
| this._a = undefined; // <- checked in isUnhandled reactions |
| this._s = 0; // <- state |
| this._d = false; // <- done |
| this._v = undefined; // <- value |
| this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled |
| this._n = false; // <- notify |
| }; |
| Internal.prototype = __webpack_require__(71)($Promise.prototype, { |
| // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected) |
| then: function then(onFulfilled, onRejected) { |
| var reaction = newPromiseCapability(speciesConstructor(this, $Promise)); |
| reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; |
| reaction.fail = typeof onRejected == 'function' && onRejected; |
| reaction.domain = isNode ? process.domain : undefined; |
| this._c.push(reaction); |
| if (this._a) this._a.push(reaction); |
| if (this._s) notify(this, false); |
| return reaction.promise; |
| }, |
| // 25.4.5.1 Promise.prototype.catch(onRejected) |
| 'catch': function _catch(onRejected) { |
| return this.then(undefined, onRejected); |
| } |
| }); |
| PromiseCapability = function PromiseCapability() { |
| var promise = new Internal(); |
| this.promise = promise; |
| this.resolve = ctx($resolve, promise, 1); |
| this.reject = ctx($reject, promise, 1); |
| }; |
| } |
| |
| $export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise }); |
| __webpack_require__(53)($Promise, PROMISE); |
| __webpack_require__(72)(PROMISE); |
| Wrapper = __webpack_require__(7)[PROMISE]; |
| |
| // statics |
| $export($export.S + $export.F * !USE_NATIVE, PROMISE, { |
| // 25.4.4.5 Promise.reject(r) |
| reject: function reject(r) { |
| var capability = newPromiseCapability(this), |
| $$reject = capability.reject; |
| $$reject(r); |
| return capability.promise; |
| } |
| }); |
| $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, { |
| // 25.4.4.6 Promise.resolve(x) |
| resolve: function resolve(x) { |
| // instanceof instead of internal slot check because we should fix it without replacement native Promise core |
| if (x instanceof $Promise && sameConstructor(x.constructor, this)) return x; |
| var capability = newPromiseCapability(this), |
| $$resolve = capability.resolve; |
| $$resolve(x); |
| return capability.promise; |
| } |
| }); |
| $export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(73)(function (iter) { |
| $Promise.all(iter)['catch'](empty); |
| })), PROMISE, { |
| // 25.4.4.1 Promise.all(iterable) |
| all: function all(iterable) { |
| var C = this, |
| capability = newPromiseCapability(C), |
| resolve = capability.resolve, |
| reject = capability.reject; |
| var abrupt = perform(function () { |
| var values = [], |
| index = 0, |
| remaining = 1; |
| forOf(iterable, false, function (promise) { |
| var $index = index++, |
| alreadyCalled = false; |
| values.push(undefined); |
| remaining++; |
| C.resolve(promise).then(function (value) { |
| if (alreadyCalled) return; |
| alreadyCalled = true; |
| values[$index] = value; |
| --remaining || resolve(values); |
| }, reject); |
| }); |
| --remaining || resolve(values); |
| }); |
| if (abrupt) reject(abrupt.error); |
| return capability.promise; |
| }, |
| // 25.4.4.4 Promise.race(iterable) |
| race: function race(iterable) { |
| var C = this, |
| capability = newPromiseCapability(C), |
| reject = capability.reject; |
| var abrupt = perform(function () { |
| forOf(iterable, false, function (promise) { |
| C.resolve(promise).then(capability.resolve, reject); |
| }); |
| }); |
| if (abrupt) reject(abrupt.error); |
| return capability.promise; |
| } |
| }); |
| |
| /***/ }, |
| /* 60 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| module.exports = function (it, Constructor, name, forbiddenField) { |
| if (!(it instanceof Constructor) || forbiddenField !== undefined && forbiddenField in it) { |
| throw TypeError(name + ': incorrect invocation!'); |
| }return it; |
| }; |
| |
| /***/ }, |
| /* 61 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var ctx = __webpack_require__(21), |
| call = __webpack_require__(62), |
| isArrayIter = __webpack_require__(63), |
| anObject = __webpack_require__(10), |
| toLength = __webpack_require__(31), |
| getIterFn = __webpack_require__(64); |
| module.exports = function (iterable, entries, fn, that, ITERATOR) { |
| var iterFn = ITERATOR ? function () { |
| return iterable; |
| } : getIterFn(iterable), |
| f = ctx(fn, that, entries ? 2 : 1), |
| index = 0, |
| length, |
| step, |
| iterator; |
| if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!'); |
| // fast case for arrays with default iterator |
| if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) { |
| entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); |
| } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) { |
| call(iterator, f, step.value, entries); |
| } |
| }; |
| |
| /***/ }, |
| /* 62 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // call something on iterator step with safe closing on error |
| var anObject = __webpack_require__(10); |
| module.exports = function (iterator, fn, value, entries) { |
| try { |
| return entries ? fn(anObject(value)[0], value[1]) : fn(value); |
| // 7.4.6 IteratorClose(iterator, completion) |
| } catch (e) { |
| var ret = iterator['return']; |
| if (ret !== undefined) anObject(ret.call(iterator)); |
| throw e; |
| } |
| }; |
| |
| /***/ }, |
| /* 63 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // check on default Array iterator |
| var Iterators = __webpack_require__(48), |
| ITERATOR = __webpack_require__(43)('iterator'), |
| ArrayProto = Array.prototype; |
| |
| module.exports = function (it) { |
| return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it); |
| }; |
| |
| /***/ }, |
| /* 64 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var classof = __webpack_require__(42), |
| ITERATOR = __webpack_require__(43)('iterator'), |
| Iterators = __webpack_require__(48); |
| module.exports = __webpack_require__(7).getIteratorMethod = function (it) { |
| if (it != undefined) return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)]; |
| }; |
| |
| /***/ }, |
| /* 65 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // Works with __proto__ only. Old v8 can't work with null proto objects. |
| /* eslint-disable no-proto */ |
| var isObject = __webpack_require__(11), |
| anObject = __webpack_require__(10); |
| var check = function check(O, proto) { |
| anObject(O); |
| if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!"); |
| }; |
| module.exports = { |
| set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line |
| function (test, buggy, set) { |
| try { |
| set = __webpack_require__(21)(Function.call, __webpack_require__(66).f(Object.prototype, '__proto__').set, 2); |
| set(test, []); |
| buggy = !(test instanceof Array); |
| } catch (e) { |
| buggy = true; |
| } |
| return function setPrototypeOf(O, proto) { |
| check(O, proto); |
| if (buggy) O.__proto__ = proto;else set(O, proto); |
| return O; |
| }; |
| }({}, false) : undefined), |
| check: check |
| }; |
| |
| /***/ }, |
| /* 66 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var pIE = __webpack_require__(38), |
| createDesc = __webpack_require__(17), |
| toIObject = __webpack_require__(26), |
| toPrimitive = __webpack_require__(16), |
| has = __webpack_require__(19), |
| IE8_DOM_DEFINE = __webpack_require__(12), |
| gOPD = Object.getOwnPropertyDescriptor; |
| |
| exports.f = __webpack_require__(13) ? gOPD : function getOwnPropertyDescriptor(O, P) { |
| O = toIObject(O); |
| P = toPrimitive(P, true); |
| if (IE8_DOM_DEFINE) try { |
| return gOPD(O, P); |
| } catch (e) {/* empty */} |
| if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]); |
| }; |
| |
| /***/ }, |
| /* 67 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // 7.3.20 SpeciesConstructor(O, defaultConstructor) |
| var anObject = __webpack_require__(10), |
| aFunction = __webpack_require__(22), |
| SPECIES = __webpack_require__(43)('species'); |
| module.exports = function (O, D) { |
| var C = anObject(O).constructor, |
| S; |
| return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S); |
| }; |
| |
| /***/ }, |
| /* 68 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var ctx = __webpack_require__(21), |
| invoke = __webpack_require__(69), |
| html = __webpack_require__(52), |
| cel = __webpack_require__(15), |
| global = __webpack_require__(6), |
| process = global.process, |
| setTask = global.setImmediate, |
| clearTask = global.clearImmediate, |
| MessageChannel = global.MessageChannel, |
| counter = 0, |
| queue = {}, |
| ONREADYSTATECHANGE = 'onreadystatechange', |
| defer, |
| channel, |
| port; |
| var run = function run() { |
| var id = +this; |
| if (queue.hasOwnProperty(id)) { |
| var fn = queue[id]; |
| delete queue[id]; |
| fn(); |
| } |
| }; |
| var listener = function listener(event) { |
| run.call(event.data); |
| }; |
| // Node.js 0.9+ & IE10+ has setImmediate, otherwise: |
| if (!setTask || !clearTask) { |
| setTask = function setImmediate(fn) { |
| var args = [], |
| i = 1; |
| while (arguments.length > i) { |
| args.push(arguments[i++]); |
| }queue[++counter] = function () { |
| invoke(typeof fn == 'function' ? fn : Function(fn), args); |
| }; |
| defer(counter); |
| return counter; |
| }; |
| clearTask = function clearImmediate(id) { |
| delete queue[id]; |
| }; |
| // Node.js 0.8- |
| if (__webpack_require__(28)(process) == 'process') { |
| defer = function defer(id) { |
| process.nextTick(ctx(run, id, 1)); |
| }; |
| // Browsers with MessageChannel, includes WebWorkers |
| } else if (MessageChannel) { |
| channel = new MessageChannel(); |
| port = channel.port2; |
| channel.port1.onmessage = listener; |
| defer = ctx(port.postMessage, port, 1); |
| // Browsers with postMessage, skip WebWorkers |
| // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' |
| } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) { |
| defer = function defer(id) { |
| global.postMessage(id + '', '*'); |
| }; |
| global.addEventListener('message', listener, false); |
| // IE8- |
| } else if (ONREADYSTATECHANGE in cel('script')) { |
| defer = function defer(id) { |
| html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () { |
| html.removeChild(this); |
| run.call(id); |
| }; |
| }; |
| // Rest old browsers |
| } else { |
| defer = function defer(id) { |
| setTimeout(ctx(run, id, 1), 0); |
| }; |
| } |
| } |
| module.exports = { |
| set: setTask, |
| clear: clearTask |
| }; |
| |
| /***/ }, |
| /* 69 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| // fast apply, http://jsperf.lnkit.com/fast-apply/5 |
| module.exports = function (fn, args, that) { |
| var un = that === undefined; |
| switch (args.length) { |
| case 0: |
| return un ? fn() : fn.call(that); |
| case 1: |
| return un ? fn(args[0]) : fn.call(that, args[0]); |
| case 2: |
| return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]); |
| case 3: |
| return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]); |
| case 4: |
| return un ? fn(args[0], args[1], args[2], args[3]) : fn.call(that, args[0], args[1], args[2], args[3]); |
| }return fn.apply(that, args); |
| }; |
| |
| /***/ }, |
| /* 70 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var global = __webpack_require__(6), |
| macrotask = __webpack_require__(68).set, |
| Observer = global.MutationObserver || global.WebKitMutationObserver, |
| process = global.process, |
| Promise = global.Promise, |
| isNode = __webpack_require__(28)(process) == 'process', |
| head, |
| last, |
| notify; |
| |
| var flush = function flush() { |
| var parent, fn; |
| if (isNode && (parent = process.domain)) parent.exit(); |
| while (head) { |
| fn = head.fn; |
| fn(); // <- currently we use it only for Promise - try / catch not required |
| head = head.next; |
| }last = undefined; |
| if (parent) parent.enter(); |
| }; |
| |
| // Node.js |
| if (isNode) { |
| notify = function notify() { |
| process.nextTick(flush); |
| }; |
| // browsers with MutationObserver |
| } else if (Observer) { |
| var toggle = true, |
| node = document.createTextNode(''); |
| new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new |
| notify = function notify() { |
| node.data = toggle = !toggle; |
| }; |
| // environments with maybe non-completely correct, but existent Promise |
| } else if (Promise && Promise.resolve) { |
| notify = function notify() { |
| Promise.resolve().then(flush); |
| }; |
| // for other environments - macrotask based on: |
| // - setImmediate |
| // - MessageChannel |
| // - window.postMessag |
| // - onreadystatechange |
| // - setTimeout |
| } else { |
| notify = function notify() { |
| // strange IE + webpack dev server bug - use .call(global) |
| macrotask.call(global, flush); |
| }; |
| } |
| |
| module.exports = function (fn) { |
| var task = { fn: fn, next: undefined }; |
| if (last) last.next = task; |
| if (!head) { |
| head = task; |
| notify(); |
| }last = task; |
| }; |
| |
| /***/ }, |
| /* 71 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var redefine = __webpack_require__(18); |
| module.exports = function (target, src, safe) { |
| for (var key in src) { |
| redefine(target, key, src[key], safe); |
| }return target; |
| }; |
| |
| /***/ }, |
| /* 72 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var global = __webpack_require__(6), |
| dP = __webpack_require__(9), |
| DESCRIPTORS = __webpack_require__(13), |
| SPECIES = __webpack_require__(43)('species'); |
| |
| module.exports = function (KEY) { |
| var C = global[KEY]; |
| if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, { |
| configurable: true, |
| get: function get() { |
| return this; |
| } |
| }); |
| }; |
| |
| /***/ }, |
| /* 73 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var ITERATOR = __webpack_require__(43)('iterator'), |
| SAFE_CLOSING = false; |
| |
| try { |
| var riter = [7][ITERATOR](); |
| riter['return'] = function () { |
| SAFE_CLOSING = true; |
| }; |
| Array.from(riter, function () { |
| throw 2; |
| }); |
| } catch (e) {/* empty */} |
| |
| module.exports = function (exec, skipClosing) { |
| if (!skipClosing && !SAFE_CLOSING) return false; |
| var safe = false; |
| try { |
| var arr = [7], |
| iter = arr[ITERATOR](); |
| iter.next = function () { |
| safe = true; |
| }; |
| arr[ITERATOR] = function () { |
| return iter; |
| }; |
| exec(arr); |
| } catch (e) {/* empty */} |
| return safe; |
| }; |
| |
| /***/ }, |
| /* 74 */ |
| /***/ function(module, exports) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| var _global = global; |
| var setTimeout = _global.setTimeout; |
| var setTimeoutNative = _global.setTimeoutNative; |
| |
| // fix no setTimeout on Android V8 |
| |
| if (typeof setTimeout === 'undefined' && typeof setTimeoutNative === 'function') { |
| (function () { |
| var timeoutMap = {}; |
| var timeoutId = 0; |
| global.setTimeout = function (cb, time) { |
| timeoutMap[++timeoutId] = cb; |
| setTimeoutNative(timeoutId.toString(), time); |
| }; |
| global.setTimeoutCallback = function (id) { |
| if (typeof timeoutMap[id] === 'function') { |
| timeoutMap[id](); |
| delete timeoutMap[id]; |
| } |
| }; |
| })(); |
| } |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 75 */ |
| /***/ function(module, exports) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| var _global = global; |
| var console = _global.console; |
| |
| |
| if (typeof console === 'undefined') { |
| global.console = { |
| log: function log() { |
| if (typeof nativeLog === 'function') { |
| nativeLog.apply(undefined, arguments); |
| } |
| }, |
| error: function error() { |
| for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
| args[_key] = arguments[_key]; |
| } |
| |
| throw new Error(args); |
| } |
| }; |
| } |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 76 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; /** |
| * @fileOverview Main entry, instance manager |
| * |
| * - createInstance(instanceId, code, options, data) |
| * - refreshInstance(instanceId, data) |
| * - destroyInstance(instanceId) |
| * - registerComponents(components) |
| * - registerModules(modules) |
| * - getRoot(instanceId) |
| * - instanceMap |
| * - callJS(instanceId, tasks) |
| * - fireEvent(ref, type, data) |
| * - callback(funcId, data) |
| */ |
| |
| exports.createInstance = createInstance; |
| exports.refreshInstance = refreshInstance; |
| exports.destroyInstance = destroyInstance; |
| exports.registerComponents = registerComponents; |
| exports.registerModules = registerModules; |
| exports.registerMethods = registerMethods; |
| exports.getRoot = getRoot; |
| exports.callJS = callJS; |
| |
| var _perf = __webpack_require__(77); |
| |
| var perf = _interopRequireWildcard(_perf); |
| |
| var _config = __webpack_require__(79); |
| |
| var config = _interopRequireWildcard(_config); |
| |
| var _app = __webpack_require__(80); |
| |
| var _app2 = _interopRequireDefault(_app); |
| |
| var _vm = __webpack_require__(85); |
| |
| var _vm2 = _interopRequireDefault(_vm); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } |
| |
| var nativeComponentMap = config.nativeComponentMap; |
| |
| var instanceMap = {}; |
| |
| /** |
| * create a Weex instance |
| * |
| * @param {string} instanceId |
| * @param {string} code |
| * @param {object} [options] option `HAS_LOG` enable print log |
| * @param {object} [data] |
| */ |
| function createInstance(instanceId, code, options, data) { |
| var instance = instanceMap[instanceId]; |
| options = options || {}; |
| |
| config.debug = options.debug; |
| |
| var result; |
| if (!instance) { |
| perf.start('createInstance', instanceId); |
| instance = new _app2.default(instanceId, options); |
| instanceMap[instanceId] = instance; |
| result = instance.init(code, data); |
| perf.end('createInstance', instanceId); |
| } else { |
| result = new Error('invalid instance id "' + instanceId + '"'); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * refresh a Weex instance |
| * |
| * @param {string} instanceId |
| * @param {object} data |
| */ |
| function refreshInstance(instanceId, data) { |
| var instance = instanceMap[instanceId]; |
| var result; |
| if (instance) { |
| perf.start('refreshData', instanceId); |
| result = instance.refreshData(data); |
| perf.end('refreshData', instanceId); |
| } else { |
| result = new Error('invalid instance id "' + instanceId + '"'); |
| } |
| return result; |
| } |
| |
| /** |
| * destroy a Weex instance |
| * @param {string} instanceId |
| */ |
| function destroyInstance(instanceId) { |
| var instance = instanceMap[instanceId]; |
| if (!instance) { |
| return new Error('invalid instance id "' + instanceId + '"'); |
| } |
| |
| perf.start('destroyInstance', instanceId); |
| instance.destroy(); |
| delete instanceMap[instanceId]; |
| perf.end('destroyInstance', instanceId); |
| |
| return instanceMap; |
| } |
| |
| /** |
| * register the name of each native component |
| * @param {array} components array of name |
| */ |
| function registerComponents(components) { |
| if (Array.isArray(components)) { |
| components.forEach(function register(name) { |
| /* istanbul ignore if */ |
| if (!name) { |
| return; |
| } |
| if (typeof name === 'string') { |
| nativeComponentMap[name] = true; |
| } else if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object' && typeof name.type === 'string') { |
| nativeComponentMap[name.type] = name; |
| } |
| }); |
| } |
| } |
| |
| /** |
| * register the name and methods of each module |
| * @param {object} modules a object of modules |
| */ |
| function registerModules(modules) { |
| if ((typeof modules === 'undefined' ? 'undefined' : _typeof(modules)) === 'object') { |
| _vm2.default.registerModules(modules); |
| } |
| } |
| |
| /** |
| * register the name and methods of each api |
| * @param {object} apis a object of apis |
| */ |
| function registerMethods(apis) { |
| if ((typeof apis === 'undefined' ? 'undefined' : _typeof(apis)) === 'object') { |
| _vm2.default.registerMethods(apis); |
| } |
| } |
| |
| /** |
| * get a whole element tree of an instance |
| * for debugging |
| * @param {string} instanceId |
| * @return {object} a virtual dom tree |
| */ |
| function getRoot(instanceId) { |
| var instance = instanceMap[instanceId]; |
| var result; |
| if (instance) { |
| result = instance.getRootElement(); |
| } else { |
| result = new Error('invalid instance id "' + instanceId + '"'); |
| } |
| return result; |
| } |
| |
| var jsHandlers = { |
| fireEvent: function fireEvent(instanceId, ref, type, data) { |
| var instance = instanceMap[instanceId]; |
| var result; |
| perf.start('fireEvent', instanceId + '-' + ref + '-' + type); |
| result = instance.fireEvent(ref, type, data); |
| perf.end('fireEvent', instanceId + '-' + ref + '-' + type); |
| return result; |
| }, |
| |
| callback: function callback(instanceId, funcId, data, ifLast) { |
| var instance = instanceMap[instanceId]; |
| var result; |
| perf.start('callback', instanceId + '-' + funcId + '-' + data + '-' + ifLast); |
| result = instance.callback(funcId, data, ifLast); |
| perf.end('callback', instanceId + '-' + funcId + '-' + data + '-' + ifLast); |
| return result; |
| } |
| }; |
| |
| /** |
| * accept calls from native (event or callback) |
| * |
| * @param {string} instanceId |
| * @param {array} tasks list with `method` and `args` |
| */ |
| function callJS(instanceId, tasks) { |
| var instance = instanceMap[instanceId]; |
| var results = []; |
| if (instance && Array.isArray(tasks)) { |
| tasks.forEach(function (task) { |
| var handler = jsHandlers[task.method]; |
| var args = [].concat(_toConsumableArray(task.args)); |
| if (typeof handler === 'function') { |
| log('javascript:', task.method, task.args); |
| args.unshift(instanceId); |
| results.push(handler.apply(undefined, _toConsumableArray(args))); |
| } |
| }); |
| } else { |
| results.push(new Error('invalid instance id "' + instanceId + '" or tasks')); |
| } |
| |
| return results; |
| } |
| |
| /***/ }, |
| /* 77 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.start = start; |
| exports.end = end; |
| exports.reset = reset; |
| exports.toJSON = toJSON; |
| |
| var _log = __webpack_require__(78); |
| |
| var _log2 = _interopRequireDefault(_log); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| var data = { type: 'root', children: [] }; |
| var current = data; |
| var stack = [current]; |
| |
| function spaces(num) { |
| return Array(num).join(' '); |
| } |
| |
| function start(type, id) { |
| var task = { type: type, id: id, children: [], start: Date.now() }; |
| current.children.push(task); |
| stack.push(task); |
| current = task; |
| (0, _log2.default)('perf:' + spaces(stack.length - 1), 'start', task.type, task.id); |
| } |
| |
| function end(type, id) { |
| var task = stack.pop(); |
| task.end = Date.now(); |
| current = stack[stack.length - 1]; |
| (0, _log2.default)('perf:' + spaces(stack.length), 'end', task.end - task.start + 'ms', task.type, task.id); |
| } |
| |
| function reset() { |
| data.children = []; |
| current = data; |
| stack.length = 0; |
| stack.push(current); |
| } |
| |
| function toJSON() { |
| return JSON.parse(JSON.stringify(data)); |
| } |
| |
| /***/ }, |
| /* 78 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = log; |
| |
| var _config = __webpack_require__(79); |
| |
| var config = _interopRequireWildcard(_config); |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function log() { |
| if (config.debug) { |
| var _global$console; |
| |
| (_global$console = global.console).log.apply(_global$console, arguments); |
| } |
| } |
| |
| global.log = log; |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 79 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| var nativeComponentMap = exports.nativeComponentMap = { |
| text: true, |
| image: true, |
| container: true, |
| slider: { |
| type: 'slider', |
| append: 'tree' |
| }, |
| cell: { |
| type: 'cell', |
| append: 'tree' |
| } |
| }; |
| |
| var customComponentMap = exports.customComponentMap = {}; |
| |
| var debug = exports.debug = false; |
| |
| /***/ }, |
| /* 80 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = AppInstance; |
| |
| var _util = __webpack_require__(81); |
| |
| var _perf = __webpack_require__(77); |
| |
| var perf = _interopRequireWildcard(_perf); |
| |
| var _bundle = __webpack_require__(82); |
| |
| var bundle = _interopRequireWildcard(_bundle); |
| |
| var _ctrl = __webpack_require__(100); |
| |
| var ctrl = _interopRequireWildcard(_ctrl); |
| |
| var _differ = __webpack_require__(102); |
| |
| var _differ2 = _interopRequireDefault(_differ); |
| |
| var _event = __webpack_require__(103); |
| |
| var _event2 = _interopRequireDefault(_event); |
| |
| var _domListener = __webpack_require__(101); |
| |
| var _domListener2 = _interopRequireDefault(_domListener); |
| |
| var _dom = __webpack_require__(104); |
| |
| var _register = __webpack_require__(98); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function AppInstance(instanceId, options) { |
| var _this = this; |
| |
| perf.start('initInstance', instanceId); |
| this.id = instanceId; |
| this.options = options || {}; |
| this.vm = null; |
| this.doc = new _dom.Document(instanceId); |
| this.customComponentMap = {}; |
| this.callbacks = {}; |
| this.differ = new _differ2.default(instanceId); |
| this.uid = 0; |
| this.rendered = false; |
| this.eventManager = new _event2.default(); |
| this.listener = new _domListener2.default(this.id, function (tasks) { |
| _this.callTasks(tasks); |
| }); |
| this.doc.setEventManager(this.eventManager); |
| this.doc.setListener(this.listener); |
| |
| perf.end('initInstance', instanceId); |
| } /** |
| * @fileOverview |
| * Weex instance constructor & definition |
| */ |
| |
| function normalize(app, v) { |
| var type = (0, _util.typof)(v); |
| |
| switch (type) { |
| case 'undefined': |
| case 'null': |
| return ''; |
| case 'regexp': |
| return v.toString(); |
| case 'date': |
| return v.toISOString(); |
| case 'number': |
| case 'string': |
| case 'boolean': |
| case 'array': |
| case 'object': |
| if (v instanceof _dom.Node) { |
| return v.ref; |
| } |
| return v; |
| case 'function': |
| app.callbacks[++app.uid] = v; |
| return app.uid.toString(); |
| default: |
| return JSON.stringify(v); |
| } |
| } |
| |
| AppInstance.prototype.callTasks = function (tasks) { |
| var _this2 = this; |
| |
| if ((0, _util.typof)(tasks) !== 'array') { |
| tasks = [tasks]; |
| } |
| |
| tasks.forEach(function (task) { |
| task.args = task.args.map(function (arg) { |
| return normalize(_this2, arg); |
| }); |
| }); |
| |
| callNative(this.id, tasks, '-1'); |
| }; |
| |
| (0, _util.extend)(AppInstance.prototype, bundle, ctrl, { |
| registerComponent: _register.registerComponent, |
| requireComponent: _register.requireComponent, |
| requireModule: _register.requireModule |
| }); |
| |
| /***/ }, |
| /* 81 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.warn = exports.log = exports.indexOf = exports.define = exports.normalize = exports.typof = exports.stringify = exports.isArray = exports.isPlainObject = exports.isObject = exports.extend = exports.toArray = exports.bind = exports.camelize = exports.isReserved = undefined; |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; /// lang.js |
| |
| |
| var _config2 = __webpack_require__(79); |
| |
| var _config3 = _interopRequireDefault(_config2); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| /** |
| * Check is a string starts with $ or _ |
| * |
| * @param {String} str |
| * @return {Boolean} |
| */ |
| |
| var isReserved = exports.isReserved = function isReserved(str) { |
| var c = (str + '').charCodeAt(0); |
| return c === 0x24 || c === 0x5F; |
| }; |
| |
| /** |
| * Camelize a hyphen-delmited string. |
| * |
| * @param {String} str |
| * @return {String} |
| */ |
| |
| var camelRE = /-(\w)/g; |
| function toUpper(_, c) { |
| return c ? c.toUpperCase() : ''; |
| } |
| var camelize = exports.camelize = function camelize(str) { |
| return str.replace(camelRE, toUpper); |
| }; |
| |
| /** |
| * Simple bind, faster than native |
| * |
| * @param {Function} fn |
| * @param {Object} ctx |
| * @return {Function} |
| */ |
| |
| var bind = exports.bind = function bind(fn, ctx) { |
| return function (a) { |
| var l = arguments.length; |
| return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx); |
| }; |
| }; |
| |
| /** |
| * Convert an Array-like object to a real Array. |
| * |
| * @param {Array-like} list |
| * @param {Number} [start] - start index |
| * @return {Array} |
| */ |
| |
| var toArray = exports.toArray = 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. |
| * |
| * @param {Object} to |
| * @param {Object} from |
| */ |
| |
| var extend = exports.extend = function extend(target) { |
| for (var _len = arguments.length, src = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
| src[_key - 1] = arguments[_key]; |
| } |
| |
| if (typeof Object.assign === 'function') { |
| Object.assign.apply(Object, [target].concat(src)); |
| } else { |
| var first = src.shift(); |
| for (var key in first) { |
| target[key] = first[key]; |
| } |
| if (src.length) { |
| extend.apply(undefined, [target].concat(src)); |
| } |
| } |
| return target; |
| }; |
| |
| /** |
| * Quick object check - this is primarily used to tell |
| * Objects from primitive values when we know the value |
| * is a JSON-compliant type. |
| * |
| * @param {*} obj |
| * @return {Boolean} |
| */ |
| |
| var isObject = exports.isObject = function isObject(obj) { |
| return !!(obj && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object'); |
| }; |
| |
| /** |
| * Strict object type check. Only returns true |
| * for plain JavaScript objects. |
| * |
| * @param {*} obj |
| * @return {Boolean} |
| */ |
| |
| var toString = Object.prototype.toString; |
| var isPlainObject = exports.isPlainObject = function isPlainObject(obj) { |
| return toString.call(obj) === '[object Object]'; |
| }; |
| |
| /** |
| * Array type check. |
| * |
| * @param {*} obj |
| * @return {Boolean} |
| */ |
| |
| var isArray = exports.isArray = function isArray(obj) { |
| return Array.isArray(obj); |
| }; |
| |
| var stringify = exports.stringify = function stringify(x) { |
| return typeof x === 'undefined' || x === null || typeof x === 'function' ? '' : (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' ? x instanceof RegExp ? x.toString() : x instanceof Date ? JSON.parse(JSON.stringify(x)) : JSON.stringify(x) : x.toString(); |
| }; |
| |
| var typof = exports.typof = function typof(v) { |
| var s = Object.prototype.toString.call(v); |
| return s.substring(8, s.length - 1).toLowerCase(); |
| }; |
| |
| var normalize = exports.normalize = function normalize(v) { |
| var type = typof(v); |
| |
| switch (type) { |
| case 'undefined': |
| case 'null': |
| return ''; |
| case 'regexp': |
| return v.toString(); |
| case 'date': |
| return v.toISOString(); |
| case 'number': |
| case 'string': |
| case 'boolean': |
| case 'array': |
| case 'object': |
| case 'function': |
| return v; |
| default: |
| return JSON.stringify(v); |
| } |
| }; |
| |
| /** |
| * Define a non-enumerable property |
| * |
| * @param {Object} obj |
| * @param {String} key |
| * @param {*} val |
| * @param {Boolean} [enumerable] |
| */ |
| |
| var define = exports.define = function define(obj, key, val, enumerable) { |
| Object.defineProperty(obj, key, { |
| value: val, |
| enumerable: !!enumerable, |
| writable: true, |
| configurable: true |
| }); |
| }; |
| |
| /** |
| * Manual indexOf because it's slightly faster than |
| * native. |
| * |
| * @param {Array} arr |
| * @param {*} obj |
| */ |
| |
| var indexOf = exports.indexOf = function indexOf(arr, obj) { |
| for (var i = 0, l = arr.length; i < l; i++) { |
| if (arr[i] === obj) return i; |
| } |
| return -1; |
| }; |
| |
| /// debug.js |
| |
| var hasConsole = typeof console !== 'undefined'; |
| |
| /** |
| * Log a message. |
| * |
| * @param {String} msg |
| */ |
| |
| var log = exports.log = function log(msg) { |
| var _config = _config3.default || {}; |
| if (hasConsole && _config.debug) { |
| console.log.call(undefined, '[info]: ', msg); |
| } |
| }; |
| |
| /** |
| * We've got a problem here. |
| * |
| * @param {String} msg |
| */ |
| |
| var warn = exports.warn = function warn(msg) { |
| // if (hasConsole && (!config.silent || config.debug)) { |
| if (hasConsole) { |
| console.warn.call(undefined, '[warn]: ', msg); |
| /* istanbul ignore if */ |
| // if (config.debug) { |
| // /* jshint debug: true */ |
| // debugger |
| // } |
| } |
| }; |
| |
| /***/ }, |
| /* 82 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.require = exports.define = undefined; |
| exports.clearCommonModules = clearCommonModules; |
| exports.bootstrap = bootstrap; |
| exports.register = register; |
| exports.render = render; |
| |
| var _semver = __webpack_require__(83); |
| |
| var _semver2 = _interopRequireDefault(_semver); |
| |
| var _util = __webpack_require__(81); |
| |
| var _ = _interopRequireWildcard(_util); |
| |
| var _config = __webpack_require__(79); |
| |
| var config = _interopRequireWildcard(_config); |
| |
| var _perf = __webpack_require__(77); |
| |
| var perf = _interopRequireWildcard(_perf); |
| |
| var _vm = __webpack_require__(85); |
| |
| var _vm2 = _interopRequireDefault(_vm); |
| |
| var _downgrade = __webpack_require__(99); |
| |
| var downgrade = _interopRequireWildcard(_downgrade); |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /** |
| * @fileOverview |
| * api that invoked by js bundle code |
| * |
| * - define(name, factory): define a new composed component type |
| * - bootstrap(type, config, data): require a certain type & |
| * render with (optional) data |
| * |
| * deprecated: |
| * - register(type, options): register a new composed component type |
| * - render(type, data): render by a certain type with (optional) data |
| * - require(type)(data): require a type then render with data |
| */ |
| |
| var WEEX_COMPONENT_REG = /^\@weex-component\//; |
| var WEEX_MODULE_REG = /^\@weex-module\//; |
| var NORMAL_MODULE_REG = /^\.{1,2}\//; |
| var JS_SURFIX_REG = /\.js$/; |
| |
| var isWeexComponent = function isWeexComponent(name) { |
| return !!name.match(WEEX_COMPONENT_REG); |
| }; |
| var isWeexModule = function isWeexModule(name) { |
| return !!name.match(WEEX_MODULE_REG); |
| }; |
| var isNormalModule = function isNormalModule(name) { |
| return !!name.match(NORMAL_MODULE_REG); |
| }; |
| var isNpmModule = function isNpmModule(name) { |
| return !isWeexComponent(name) && !isWeexModule(name) && !isNormalModule(name); |
| }; |
| |
| function removeWeexPrefix(str) { |
| return str.replace(WEEX_COMPONENT_REG, '').replace(WEEX_MODULE_REG, ''); |
| } |
| |
| function removeJSSurfix(str) { |
| return str.replace(JS_SURFIX_REG, ''); |
| } |
| |
| var commonModules = {}; |
| |
| function clearCommonModules() { |
| commonModules = {}; |
| } |
| |
| // define(name, factory) for primary usage |
| // or |
| // define(name, deps, factory) for compatibility |
| // Notice: DO NOT use function define() {}, |
| // it will cause error after builded by webpack |
| var define = exports.define = function define(name, deps, factory) { |
| var _this = this; |
| |
| perf.start('define', name); |
| |
| if (_.typof(deps) === 'function') { |
| factory = deps; |
| deps = []; |
| } |
| |
| var _require = function _require(name) { |
| var cleanName = void 0; |
| |
| if (isWeexComponent(name)) { |
| cleanName = removeWeexPrefix(name); |
| return _this.requireComponent(cleanName); |
| } |
| if (isWeexModule(name)) { |
| cleanName = removeWeexPrefix(name); |
| return _this.requireModule(cleanName); |
| } |
| if (isNormalModule(name)) { |
| cleanName = removeJSSurfix(name); |
| return commonModules[name]; |
| } |
| if (isNpmModule(name)) { |
| cleanName = removeJSSurfix(name); |
| return commonModules[name]; |
| } |
| }; |
| var _module = { exports: {} }; |
| |
| var cleanName = void 0; |
| if (isWeexComponent(name)) { |
| cleanName = removeWeexPrefix(name); |
| |
| factory(_require, _module.exports, _module); |
| |
| this.registerComponent(cleanName, _module.exports); |
| } else if (isWeexModule(name)) { |
| cleanName = removeWeexPrefix(name); |
| |
| factory(_require, _module.exports, _module); |
| |
| _vm2.default.registerModules(_defineProperty({}, cleanName, _module.exports)); |
| } else if (isNormalModule(name)) { |
| cleanName = removeJSSurfix(name); |
| |
| factory(_require, _module.exports, _module); |
| |
| commonModules[cleanName] = _module.exports; |
| } else if (isNpmModule(name)) { |
| cleanName = removeJSSurfix(name); |
| |
| factory(_require, _module.exports, _module); |
| |
| var exports = _module.exports; |
| if (exports.template || exports.style || exports.methods) { |
| // downgrade to old define method (define('componentName', factory)) |
| // the exports contain one key of template, style or methods |
| // but it has risk!!! |
| this.registerComponent(cleanName, exports); |
| } else { |
| commonModules[cleanName] = _module.exports; |
| } |
| } |
| |
| perf.end('define', name); |
| }; |
| |
| function bootstrap(name, config, data) { |
| var cleanName = void 0; |
| |
| if (isWeexComponent(name)) { |
| cleanName = removeWeexPrefix(name); |
| } else if (isNpmModule(name)) { |
| cleanName = removeJSSurfix(name); |
| // check if define by old 'define' method |
| if (!this.customComponentMap[cleanName]) { |
| return new Error('It\'s not a component: ' + name); |
| } |
| } else { |
| return new Error('Wrong component name: ' + name); |
| } |
| |
| config = _.isPlainObject(config) ? config : {}; |
| |
| if (typeof config.transformerVersion === 'string' && typeof global.needTransformerVersion === 'string' && !_semver2.default.satisfies(config.transformerVersion, global.needTransformerVersion)) { |
| return new Error('JS Bundle version: ' + config.transformerVersion + ' ' + ('not compatible with ' + global.needTransformerVersion)); |
| } |
| |
| var _checkDowngrade = downgrade.check(config.downgrade); |
| if (_checkDowngrade.isDowngrade) { |
| this.callTasks([{ |
| module: 'instanceWrap', |
| method: 'error', |
| args: [_checkDowngrade.errorType, _checkDowngrade.code, _checkDowngrade.errorMessage] |
| }]); |
| return new Error('Downgrade: ' + config.downgrade); |
| } |
| |
| perf.start('create vm', cleanName); |
| |
| this.vm = new _vm2.default(cleanName, { _app: this }, null, data, { |
| 'hook:ready': function hookReady() { |
| perf.end('create vm', cleanName); |
| } |
| }); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| function register(type, options) { |
| perf.start('register', type); |
| this.registerComponent(type, options); |
| perf.end('register', type); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| function render(type, data) { |
| return this.bootstrap(type, {}, data); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| function _require2(type) { |
| var _this2 = this; |
| |
| return function (data) { |
| return _this2.bootstrap(type, {}, data); |
| }; |
| } |
| exports.require = _require2; |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 83 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(process) {'use strict'; |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; |
| |
| exports = module.exports = SemVer; |
| |
| // The debug function is excluded entirely from the minified version. |
| /* nomin */var debug; |
| /* nomin */if ((typeof process === 'undefined' ? 'undefined' : _typeof(process)) === 'object' && |
| /* nomin */process.env && |
| /* nomin */process.env.NODE_DEBUG && |
| /* nomin *//\bsemver\b/i.test(process.env.NODE_DEBUG)) |
| /* nomin */debug = function debug() { |
| /* nomin */var args = Array.prototype.slice.call(arguments, 0); |
| /* nomin */args.unshift('SEMVER'); |
| /* nomin */console.log.apply(console, args); |
| /* nomin */ |
| }; |
| /* nomin */else |
| /* nomin */debug = function debug() {}; |
| |
| // Note: this is the semver.org version of the spec that it implements |
| // Not necessarily the package version of this code. |
| exports.SEMVER_SPEC_VERSION = '2.0.0'; |
| |
| var MAX_LENGTH = 256; |
| var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991; |
| |
| // The actual regexps go on exports.re |
| var re = exports.re = []; |
| var src = exports.src = []; |
| var R = 0; |
| |
| // The following Regular Expressions can be used for tokenizing, |
| // validating, and parsing SemVer version strings. |
| |
| // ## Numeric Identifier |
| // A single `0`, or a non-zero digit followed by zero or more digits. |
| |
| var NUMERICIDENTIFIER = R++; |
| src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'; |
| var NUMERICIDENTIFIERLOOSE = R++; |
| src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'; |
| |
| // ## Non-numeric Identifier |
| // Zero or more digits, followed by a letter or hyphen, and then zero or |
| // more letters, digits, or hyphens. |
| |
| var NONNUMERICIDENTIFIER = R++; |
| src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'; |
| |
| // ## Main Version |
| // Three dot-separated numeric identifiers. |
| |
| var MAINVERSION = R++; |
| src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' + '(' + src[NUMERICIDENTIFIER] + ')\\.' + '(' + src[NUMERICIDENTIFIER] + ')'; |
| |
| var MAINVERSIONLOOSE = R++; |
| src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[NUMERICIDENTIFIERLOOSE] + ')'; |
| |
| // ## Pre-release Version Identifier |
| // A numeric identifier, or a non-numeric identifier. |
| |
| var PRERELEASEIDENTIFIER = R++; |
| src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] + '|' + src[NONNUMERICIDENTIFIER] + ')'; |
| |
| var PRERELEASEIDENTIFIERLOOSE = R++; |
| src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] + '|' + src[NONNUMERICIDENTIFIER] + ')'; |
| |
| // ## Pre-release Version |
| // Hyphen, followed by one or more dot-separated pre-release version |
| // identifiers. |
| |
| var PRERELEASE = R++; |
| src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] + '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'; |
| |
| var PRERELEASELOOSE = R++; |
| src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'; |
| |
| // ## Build Metadata Identifier |
| // Any combination of digits, letters, or hyphens. |
| |
| var BUILDIDENTIFIER = R++; |
| src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'; |
| |
| // ## Build Metadata |
| // Plus sign, followed by one or more period-separated build metadata |
| // identifiers. |
| |
| var BUILD = R++; |
| src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] + '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'; |
| |
| // ## Full Version String |
| // A main version, followed optionally by a pre-release version and |
| // build metadata. |
| |
| // Note that the only major, minor, patch, and pre-release sections of |
| // the version string are capturing groups. The build metadata is not a |
| // capturing group, because it should not ever be used in version |
| // comparison. |
| |
| var FULL = R++; |
| var FULLPLAIN = 'v?' + src[MAINVERSION] + src[PRERELEASE] + '?' + src[BUILD] + '?'; |
| |
| src[FULL] = '^' + FULLPLAIN + '$'; |
| |
| // like full, but allows v1.2.3 and =1.2.3, which people do sometimes. |
| // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty |
| // common in the npm registry. |
| var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] + src[PRERELEASELOOSE] + '?' + src[BUILD] + '?'; |
| |
| var LOOSE = R++; |
| src[LOOSE] = '^' + LOOSEPLAIN + '$'; |
| |
| var GTLT = R++; |
| src[GTLT] = '((?:<|>)?=?)'; |
| |
| // Something like "2.*" or "1.2.x". |
| // Note that "x.x" is a valid xRange identifer, meaning "any version" |
| // Only the first item is strictly required. |
| var XRANGEIDENTIFIERLOOSE = R++; |
| src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'; |
| var XRANGEIDENTIFIER = R++; |
| src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'; |
| |
| var XRANGEPLAIN = R++; |
| src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + '(?:' + src[PRERELEASE] + ')?' + src[BUILD] + '?' + ')?)?'; |
| |
| var XRANGEPLAINLOOSE = R++; |
| src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[PRERELEASELOOSE] + ')?' + src[BUILD] + '?' + ')?)?'; |
| |
| var XRANGE = R++; |
| src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'; |
| var XRANGELOOSE = R++; |
| src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'; |
| |
| // Tilde ranges. |
| // Meaning is "reasonably at or greater than" |
| var LONETILDE = R++; |
| src[LONETILDE] = '(?:~>?)'; |
| |
| var TILDETRIM = R++; |
| src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'; |
| re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g'); |
| var tildeTrimReplace = '$1~'; |
| |
| var TILDE = R++; |
| src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'; |
| var TILDELOOSE = R++; |
| src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'; |
| |
| // Caret ranges. |
| // Meaning is "at least and backwards compatible with" |
| var LONECARET = R++; |
| src[LONECARET] = '(?:\\^)'; |
| |
| var CARETTRIM = R++; |
| src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'; |
| re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g'); |
| var caretTrimReplace = '$1^'; |
| |
| var CARET = R++; |
| src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'; |
| var CARETLOOSE = R++; |
| src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'; |
| |
| // A simple gt/lt/eq thing, or just "" to indicate "any version" |
| var COMPARATORLOOSE = R++; |
| src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'; |
| var COMPARATOR = R++; |
| src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'; |
| |
| // An expression to strip any whitespace between the gtlt and the thing |
| // it modifies, so that `> 1.2.3` ==> `>1.2.3` |
| var COMPARATORTRIM = R++; |
| src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] + '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'; |
| |
| // this one has to use the /g flag |
| re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g'); |
| var comparatorTrimReplace = '$1$2$3'; |
| |
| // Something like `1.2.3 - 1.2.4` |
| // Note that these all use the loose form, because they'll be |
| // checked against either the strict or loose comparator form |
| // later. |
| var HYPHENRANGE = R++; |
| src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[XRANGEPLAIN] + ')' + '\\s*$'; |
| |
| var HYPHENRANGELOOSE = R++; |
| src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[XRANGEPLAINLOOSE] + ')' + '\\s*$'; |
| |
| // Star ranges basically just allow anything at all. |
| var STAR = R++; |
| src[STAR] = '(<|>)?=?\\s*\\*'; |
| |
| // Compile to actual regexp objects. |
| // All are flag-free, unless they were created above with a flag. |
| for (var i = 0; i < R; i++) { |
| debug(i, src[i]); |
| if (!re[i]) re[i] = new RegExp(src[i]); |
| } |
| |
| exports.parse = parse; |
| function parse(version, loose) { |
| if (version instanceof SemVer) return version; |
| |
| if (typeof version !== 'string') return null; |
| |
| if (version.length > MAX_LENGTH) return null; |
| |
| var r = loose ? re[LOOSE] : re[FULL]; |
| if (!r.test(version)) return null; |
| |
| try { |
| return new SemVer(version, loose); |
| } catch (er) { |
| return null; |
| } |
| } |
| |
| exports.valid = valid; |
| function valid(version, loose) { |
| var v = parse(version, loose); |
| return v ? v.version : null; |
| } |
| |
| exports.clean = clean; |
| function clean(version, loose) { |
| var s = parse(version.trim().replace(/^[=v]+/, ''), loose); |
| return s ? s.version : null; |
| } |
| |
| exports.SemVer = SemVer; |
| |
| function SemVer(version, loose) { |
| if (version instanceof SemVer) { |
| if (version.loose === loose) return version;else version = version.version; |
| } else if (typeof version !== 'string') { |
| throw new TypeError('Invalid Version: ' + version); |
| } |
| |
| if (version.length > MAX_LENGTH) throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters'); |
| |
| if (!(this instanceof SemVer)) return new SemVer(version, loose); |
| |
| debug('SemVer', version, loose); |
| this.loose = loose; |
| var m = version.trim().match(loose ? re[LOOSE] : re[FULL]); |
| |
| if (!m) throw new TypeError('Invalid Version: ' + version); |
| |
| this.raw = version; |
| |
| // these are actually numbers |
| this.major = +m[1]; |
| this.minor = +m[2]; |
| this.patch = +m[3]; |
| |
| if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError('Invalid major version'); |
| |
| if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError('Invalid minor version'); |
| |
| if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError('Invalid patch version'); |
| |
| // numberify any prerelease numeric ids |
| if (!m[4]) this.prerelease = [];else this.prerelease = m[4].split('.').map(function (id) { |
| if (/^[0-9]+$/.test(id)) { |
| var num = +id; |
| if (num >= 0 && num < MAX_SAFE_INTEGER) return num; |
| } |
| return id; |
| }); |
| |
| this.build = m[5] ? m[5].split('.') : []; |
| this.format(); |
| } |
| |
| SemVer.prototype.format = function () { |
| this.version = this.major + '.' + this.minor + '.' + this.patch; |
| if (this.prerelease.length) this.version += '-' + this.prerelease.join('.'); |
| return this.version; |
| }; |
| |
| SemVer.prototype.toString = function () { |
| return this.version; |
| }; |
| |
| SemVer.prototype.compare = function (other) { |
| debug('SemVer.compare', this.version, this.loose, other); |
| if (!(other instanceof SemVer)) other = new SemVer(other, this.loose); |
| |
| return this.compareMain(other) || this.comparePre(other); |
| }; |
| |
| SemVer.prototype.compareMain = function (other) { |
| if (!(other instanceof SemVer)) other = new SemVer(other, this.loose); |
| |
| return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch); |
| }; |
| |
| SemVer.prototype.comparePre = function (other) { |
| if (!(other instanceof SemVer)) other = new SemVer(other, this.loose); |
| |
| // NOT having a prerelease is > having one |
| if (this.prerelease.length && !other.prerelease.length) return -1;else if (!this.prerelease.length && other.prerelease.length) return 1;else if (!this.prerelease.length && !other.prerelease.length) return 0; |
| |
| var i = 0; |
| do { |
| var a = this.prerelease[i]; |
| var b = other.prerelease[i]; |
| debug('prerelease compare', i, a, b); |
| if (a === undefined && b === undefined) return 0;else if (b === undefined) return 1;else if (a === undefined) return -1;else if (a === b) continue;else return compareIdentifiers(a, b); |
| } while (++i); |
| }; |
| |
| // preminor will bump the version up to the next minor release, and immediately |
| // down to pre-release. premajor and prepatch work the same way. |
| SemVer.prototype.inc = function (release, identifier) { |
| switch (release) { |
| case 'premajor': |
| this.prerelease.length = 0; |
| this.patch = 0; |
| this.minor = 0; |
| this.major++; |
| this.inc('pre', identifier); |
| break; |
| case 'preminor': |
| this.prerelease.length = 0; |
| this.patch = 0; |
| this.minor++; |
| this.inc('pre', identifier); |
| break; |
| case 'prepatch': |
| // If this is already a prerelease, it will bump to the next version |
| // drop any prereleases that might already exist, since they are not |
| // relevant at this point. |
| this.prerelease.length = 0; |
| this.inc('patch', identifier); |
| this.inc('pre', identifier); |
| break; |
| // If the input is a non-prerelease version, this acts the same as |
| // prepatch. |
| case 'prerelease': |
| if (this.prerelease.length === 0) this.inc('patch', identifier); |
| this.inc('pre', identifier); |
| break; |
| |
| case 'major': |
| // If this is a pre-major version, bump up to the same major version. |
| // Otherwise increment major. |
| // 1.0.0-5 bumps to 1.0.0 |
| // 1.1.0 bumps to 2.0.0 |
| if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++; |
| this.minor = 0; |
| this.patch = 0; |
| this.prerelease = []; |
| break; |
| case 'minor': |
| // If this is a pre-minor version, bump up to the same minor version. |
| // Otherwise increment minor. |
| // 1.2.0-5 bumps to 1.2.0 |
| // 1.2.1 bumps to 1.3.0 |
| if (this.patch !== 0 || this.prerelease.length === 0) this.minor++; |
| this.patch = 0; |
| this.prerelease = []; |
| break; |
| case 'patch': |
| // If this is not a pre-release version, it will increment the patch. |
| // If it is a pre-release it will bump up to the same patch version. |
| // 1.2.0-5 patches to 1.2.0 |
| // 1.2.0 patches to 1.2.1 |
| if (this.prerelease.length === 0) this.patch++; |
| this.prerelease = []; |
| break; |
| // This probably shouldn't be used publicly. |
| // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. |
| case 'pre': |
| if (this.prerelease.length === 0) this.prerelease = [0];else { |
| var i = this.prerelease.length; |
| while (--i >= 0) { |
| if (typeof this.prerelease[i] === 'number') { |
| this.prerelease[i]++; |
| i = -2; |
| } |
| } |
| if (i === -1) // didn't increment anything |
| this.prerelease.push(0); |
| } |
| if (identifier) { |
| // 1.2.0-beta.1 bumps to 1.2.0-beta.2, |
| // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 |
| if (this.prerelease[0] === identifier) { |
| if (isNaN(this.prerelease[1])) this.prerelease = [identifier, 0]; |
| } else this.prerelease = [identifier, 0]; |
| } |
| break; |
| |
| default: |
| throw new Error('invalid increment argument: ' + release); |
| } |
| this.format(); |
| this.raw = this.version; |
| return this; |
| }; |
| |
| exports.inc = inc; |
| function inc(version, release, loose, identifier) { |
| if (typeof loose === 'string') { |
| identifier = loose; |
| loose = undefined; |
| } |
| |
| try { |
| return new SemVer(version, loose).inc(release, identifier).version; |
| } catch (er) { |
| return null; |
| } |
| } |
| |
| exports.diff = diff; |
| function diff(version1, version2) { |
| if (eq(version1, version2)) { |
| return null; |
| } else { |
| var v1 = parse(version1); |
| var v2 = parse(version2); |
| if (v1.prerelease.length || v2.prerelease.length) { |
| for (var key in v1) { |
| if (key === 'major' || key === 'minor' || key === 'patch') { |
| if (v1[key] !== v2[key]) { |
| return 'pre' + key; |
| } |
| } |
| } |
| return 'prerelease'; |
| } |
| for (var key in v1) { |
| if (key === 'major' || key === 'minor' || key === 'patch') { |
| if (v1[key] !== v2[key]) { |
| return key; |
| } |
| } |
| } |
| } |
| } |
| |
| exports.compareIdentifiers = compareIdentifiers; |
| |
| var numeric = /^[0-9]+$/; |
| function compareIdentifiers(a, b) { |
| var anum = numeric.test(a); |
| var bnum = numeric.test(b); |
| |
| if (anum && bnum) { |
| a = +a; |
| b = +b; |
| } |
| |
| return anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : a > b ? 1 : 0; |
| } |
| |
| exports.rcompareIdentifiers = rcompareIdentifiers; |
| function rcompareIdentifiers(a, b) { |
| return compareIdentifiers(b, a); |
| } |
| |
| exports.major = major; |
| function major(a, loose) { |
| return new SemVer(a, loose).major; |
| } |
| |
| exports.minor = minor; |
| function minor(a, loose) { |
| return new SemVer(a, loose).minor; |
| } |
| |
| exports.patch = patch; |
| function patch(a, loose) { |
| return new SemVer(a, loose).patch; |
| } |
| |
| exports.compare = compare; |
| function compare(a, b, loose) { |
| return new SemVer(a, loose).compare(b); |
| } |
| |
| exports.compareLoose = compareLoose; |
| function compareLoose(a, b) { |
| return compare(a, b, true); |
| } |
| |
| exports.rcompare = rcompare; |
| function rcompare(a, b, loose) { |
| return compare(b, a, loose); |
| } |
| |
| exports.sort = sort; |
| function sort(list, loose) { |
| return list.sort(function (a, b) { |
| return exports.compare(a, b, loose); |
| }); |
| } |
| |
| exports.rsort = rsort; |
| function rsort(list, loose) { |
| return list.sort(function (a, b) { |
| return exports.rcompare(a, b, loose); |
| }); |
| } |
| |
| exports.gt = gt; |
| function gt(a, b, loose) { |
| return compare(a, b, loose) > 0; |
| } |
| |
| exports.lt = lt; |
| function lt(a, b, loose) { |
| return compare(a, b, loose) < 0; |
| } |
| |
| exports.eq = eq; |
| function eq(a, b, loose) { |
| return compare(a, b, loose) === 0; |
| } |
| |
| exports.neq = neq; |
| function neq(a, b, loose) { |
| return compare(a, b, loose) !== 0; |
| } |
| |
| exports.gte = gte; |
| function gte(a, b, loose) { |
| return compare(a, b, loose) >= 0; |
| } |
| |
| exports.lte = lte; |
| function lte(a, b, loose) { |
| return compare(a, b, loose) <= 0; |
| } |
| |
| exports.cmp = cmp; |
| function cmp(a, op, b, loose) { |
| var ret; |
| switch (op) { |
| case '===': |
| if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) === 'object') a = a.version; |
| if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) === 'object') b = b.version; |
| ret = a === b; |
| break; |
| case '!==': |
| if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) === 'object') a = a.version; |
| if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) === 'object') b = b.version; |
| ret = a !== b; |
| break; |
| case '':case '=':case '==': |
| ret = eq(a, b, loose);break; |
| case '!=': |
| ret = neq(a, b, loose);break; |
| case '>': |
| ret = gt(a, b, loose);break; |
| case '>=': |
| ret = gte(a, b, loose);break; |
| case '<': |
| ret = lt(a, b, loose);break; |
| case '<=': |
| ret = lte(a, b, loose);break; |
| default: |
| throw new TypeError('Invalid operator: ' + op); |
| } |
| return ret; |
| } |
| |
| exports.Comparator = Comparator; |
| function Comparator(comp, loose) { |
| if (comp instanceof Comparator) { |
| if (comp.loose === loose) return comp;else comp = comp.value; |
| } |
| |
| if (!(this instanceof Comparator)) return new Comparator(comp, loose); |
| |
| debug('comparator', comp, loose); |
| this.loose = loose; |
| this.parse(comp); |
| |
| if (this.semver === ANY) this.value = '';else this.value = this.operator + this.semver.version; |
| |
| debug('comp', this); |
| } |
| |
| var ANY = {}; |
| Comparator.prototype.parse = function (comp) { |
| var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]; |
| var m = comp.match(r); |
| |
| if (!m) throw new TypeError('Invalid comparator: ' + comp); |
| |
| this.operator = m[1]; |
| if (this.operator === '=') this.operator = ''; |
| |
| // if it literally is just '>' or '' then allow anything. |
| if (!m[2]) this.semver = ANY;else this.semver = new SemVer(m[2], this.loose); |
| }; |
| |
| Comparator.prototype.toString = function () { |
| return this.value; |
| }; |
| |
| Comparator.prototype.test = function (version) { |
| debug('Comparator.test', version, this.loose); |
| |
| if (this.semver === ANY) return true; |
| |
| if (typeof version === 'string') version = new SemVer(version, this.loose); |
| |
| return cmp(version, this.operator, this.semver, this.loose); |
| }; |
| |
| exports.Range = Range; |
| function Range(range, loose) { |
| if (range instanceof Range && range.loose === loose) return range; |
| |
| if (!(this instanceof Range)) return new Range(range, loose); |
| |
| this.loose = loose; |
| |
| // First, split based on boolean or || |
| this.raw = range; |
| this.set = range.split(/\s*\|\|\s*/).map(function (range) { |
| return this.parseRange(range.trim()); |
| }, this).filter(function (c) { |
| // throw out any that are not relevant for whatever reason |
| return c.length; |
| }); |
| |
| if (!this.set.length) { |
| throw new TypeError('Invalid SemVer Range: ' + range); |
| } |
| |
| this.format(); |
| } |
| |
| Range.prototype.format = function () { |
| this.range = this.set.map(function (comps) { |
| return comps.join(' ').trim(); |
| }).join('||').trim(); |
| return this.range; |
| }; |
| |
| Range.prototype.toString = function () { |
| return this.range; |
| }; |
| |
| Range.prototype.parseRange = function (range) { |
| var loose = this.loose; |
| range = range.trim(); |
| debug('range', range, loose); |
| // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` |
| var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]; |
| range = range.replace(hr, hyphenReplace); |
| debug('hyphen replace', range); |
| // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` |
| range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace); |
| debug('comparator trim', range, re[COMPARATORTRIM]); |
| |
| // `~ 1.2.3` => `~1.2.3` |
| range = range.replace(re[TILDETRIM], tildeTrimReplace); |
| |
| // `^ 1.2.3` => `^1.2.3` |
| range = range.replace(re[CARETTRIM], caretTrimReplace); |
| |
| // normalize spaces |
| range = range.split(/\s+/).join(' '); |
| |
| // At this point, the range is completely trimmed and |
| // ready to be split into comparators. |
| |
| var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]; |
| var set = range.split(' ').map(function (comp) { |
| return parseComparator(comp, loose); |
| }).join(' ').split(/\s+/); |
| if (this.loose) { |
| // in loose mode, throw out any that are not valid comparators |
| set = set.filter(function (comp) { |
| return !!comp.match(compRe); |
| }); |
| } |
| set = set.map(function (comp) { |
| return new Comparator(comp, loose); |
| }); |
| |
| return set; |
| }; |
| |
| // Mostly just for testing and legacy API reasons |
| exports.toComparators = toComparators; |
| function toComparators(range, loose) { |
| return new Range(range, loose).set.map(function (comp) { |
| return comp.map(function (c) { |
| return c.value; |
| }).join(' ').trim().split(' '); |
| }); |
| } |
| |
| // comprised of xranges, tildes, stars, and gtlt's at this point. |
| // already replaced the hyphen ranges |
| // turn into a set of JUST comparators. |
| function parseComparator(comp, loose) { |
| debug('comp', comp); |
| comp = replaceCarets(comp, loose); |
| debug('caret', comp); |
| comp = replaceTildes(comp, loose); |
| debug('tildes', comp); |
| comp = replaceXRanges(comp, loose); |
| debug('xrange', comp); |
| comp = replaceStars(comp, loose); |
| debug('stars', comp); |
| return comp; |
| } |
| |
| function isX(id) { |
| return !id || id.toLowerCase() === 'x' || id === '*'; |
| } |
| |
| // ~, ~> --> * (any, kinda silly) |
| // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 |
| // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 |
| // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 |
| // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 |
| // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 |
| function replaceTildes(comp, loose) { |
| return comp.trim().split(/\s+/).map(function (comp) { |
| return replaceTilde(comp, loose); |
| }).join(' '); |
| } |
| |
| function replaceTilde(comp, loose) { |
| var r = loose ? re[TILDELOOSE] : re[TILDE]; |
| return comp.replace(r, function (_, M, m, p, pr) { |
| debug('tilde', comp, _, M, m, p, pr); |
| var ret; |
| |
| if (isX(M)) ret = '';else if (isX(m)) ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';else if (isX(p)) |
| // ~1.2 == >=1.2.0- <1.3.0- |
| ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';else if (pr) { |
| debug('replaceTilde pr', pr); |
| if (pr.charAt(0) !== '-') pr = '-' + pr; |
| ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + (+m + 1) + '.0'; |
| } else |
| // ~1.2.3 == >=1.2.3 <1.3.0 |
| ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0'; |
| |
| debug('tilde return', ret); |
| return ret; |
| }); |
| } |
| |
| // ^ --> * (any, kinda silly) |
| // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 |
| // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 |
| // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 |
| // ^1.2.3 --> >=1.2.3 <2.0.0 |
| // ^1.2.0 --> >=1.2.0 <2.0.0 |
| function replaceCarets(comp, loose) { |
| return comp.trim().split(/\s+/).map(function (comp) { |
| return replaceCaret(comp, loose); |
| }).join(' '); |
| } |
| |
| function replaceCaret(comp, loose) { |
| debug('caret', comp, loose); |
| var r = loose ? re[CARETLOOSE] : re[CARET]; |
| return comp.replace(r, function (_, M, m, p, pr) { |
| debug('caret', comp, _, M, m, p, pr); |
| var ret; |
| |
| if (isX(M)) ret = '';else if (isX(m)) ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';else if (isX(p)) { |
| if (M === '0') ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';else ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'; |
| } else if (pr) { |
| debug('replaceCaret pr', pr); |
| if (pr.charAt(0) !== '-') pr = '-' + pr; |
| if (M === '0') { |
| if (m === '0') ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + m + '.' + (+p + 1);else ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + (+m + 1) + '.0'; |
| } else ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + (+M + 1) + '.0.0'; |
| } else { |
| debug('no pr'); |
| if (M === '0') { |
| if (m === '0') ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1);else ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0'; |
| } else ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0'; |
| } |
| |
| debug('caret return', ret); |
| return ret; |
| }); |
| } |
| |
| function replaceXRanges(comp, loose) { |
| debug('replaceXRanges', comp, loose); |
| return comp.split(/\s+/).map(function (comp) { |
| return replaceXRange(comp, loose); |
| }).join(' '); |
| } |
| |
| function replaceXRange(comp, loose) { |
| comp = comp.trim(); |
| var r = loose ? re[XRANGELOOSE] : re[XRANGE]; |
| return comp.replace(r, function (ret, gtlt, M, m, p, pr) { |
| debug('xRange', comp, ret, gtlt, M, m, p, pr); |
| var xM = isX(M); |
| var xm = xM || isX(m); |
| var xp = xm || isX(p); |
| var anyX = xp; |
| |
| if (gtlt === '=' && anyX) gtlt = ''; |
| |
| if (xM) { |
| if (gtlt === '>' || gtlt === '<') { |
| // nothing is allowed |
| ret = '<0.0.0'; |
| } else { |
| // nothing is forbidden |
| ret = '*'; |
| } |
| } else if (gtlt && anyX) { |
| // replace X with 0 |
| if (xm) m = 0; |
| if (xp) p = 0; |
| |
| if (gtlt === '>') { |
| // >1 => >=2.0.0 |
| // >1.2 => >=1.3.0 |
| // >1.2.3 => >= 1.2.4 |
| gtlt = '>='; |
| if (xm) { |
| M = +M + 1; |
| m = 0; |
| p = 0; |
| } else if (xp) { |
| m = +m + 1; |
| p = 0; |
| } |
| } else if (gtlt === '<=') { |
| // <=0.7.x is actually <0.8.0, since any 0.7.x should |
| // pass. Similarly, <=7.x is actually <8.0.0, etc. |
| gtlt = '<'; |
| if (xm) M = +M + 1;else m = +m + 1; |
| } |
| |
| ret = gtlt + M + '.' + m + '.' + p; |
| } else if (xm) { |
| ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'; |
| } else if (xp) { |
| ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'; |
| } |
| |
| debug('xRange return', ret); |
| |
| return ret; |
| }); |
| } |
| |
| // Because * is AND-ed with everything else in the comparator, |
| // and '' means "any version", just remove the *s entirely. |
| function replaceStars(comp, loose) { |
| debug('replaceStars', comp, loose); |
| // Looseness is ignored here. star is always as loose as it gets! |
| return comp.trim().replace(re[STAR], ''); |
| } |
| |
| // This function is passed to string.replace(re[HYPHENRANGE]) |
| // M, m, patch, prerelease, build |
| // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 |
| // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do |
| // 1.2 - 3.4 => >=1.2.0 <3.5.0 |
| function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) { |
| |
| if (isX(fM)) from = '';else if (isX(fm)) from = '>=' + fM + '.0.0';else if (isX(fp)) from = '>=' + fM + '.' + fm + '.0';else from = '>=' + from; |
| |
| if (isX(tM)) to = '';else if (isX(tm)) to = '<' + (+tM + 1) + '.0.0';else if (isX(tp)) to = '<' + tM + '.' + (+tm + 1) + '.0';else if (tpr) to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;else to = '<=' + to; |
| |
| return (from + ' ' + to).trim(); |
| } |
| |
| // if ANY of the sets match ALL of its comparators, then pass |
| Range.prototype.test = function (version) { |
| if (!version) return false; |
| |
| if (typeof version === 'string') version = new SemVer(version, this.loose); |
| |
| for (var i = 0; i < this.set.length; i++) { |
| if (testSet(this.set[i], version)) return true; |
| } |
| return false; |
| }; |
| |
| function testSet(set, version) { |
| for (var i = 0; i < set.length; i++) { |
| if (!set[i].test(version)) return false; |
| } |
| |
| if (version.prerelease.length) { |
| // Find the set of versions that are allowed to have prereleases |
| // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 |
| // That should allow `1.2.3-pr.2` to pass. |
| // However, `1.2.4-alpha.notready` should NOT be allowed, |
| // even though it's within the range set by the comparators. |
| for (var i = 0; i < set.length; i++) { |
| debug(set[i].semver); |
| if (set[i].semver === ANY) continue; |
| |
| if (set[i].semver.prerelease.length > 0) { |
| var allowed = set[i].semver; |
| if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true; |
| } |
| } |
| |
| // Version has a -pre, but it's not one of the ones we like. |
| return false; |
| } |
| |
| return true; |
| } |
| |
| exports.satisfies = satisfies; |
| function satisfies(version, range, loose) { |
| try { |
| range = new Range(range, loose); |
| } catch (er) { |
| return false; |
| } |
| return range.test(version); |
| } |
| |
| exports.maxSatisfying = maxSatisfying; |
| function maxSatisfying(versions, range, loose) { |
| return versions.filter(function (version) { |
| return satisfies(version, range, loose); |
| }).sort(function (a, b) { |
| return rcompare(a, b, loose); |
| })[0] || null; |
| } |
| |
| exports.validRange = validRange; |
| function validRange(range, loose) { |
| try { |
| // Return '*' instead of '' so that truthiness works. |
| // This will throw if it's invalid anyway |
| return new Range(range, loose).range || '*'; |
| } catch (er) { |
| return null; |
| } |
| } |
| |
| // Determine if version is less than all the versions possible in the range |
| exports.ltr = ltr; |
| function ltr(version, range, loose) { |
| return outside(version, range, '<', loose); |
| } |
| |
| // Determine if version is greater than all the versions possible in the range. |
| exports.gtr = gtr; |
| function gtr(version, range, loose) { |
| return outside(version, range, '>', loose); |
| } |
| |
| exports.outside = outside; |
| function outside(version, range, hilo, loose) { |
| version = new SemVer(version, loose); |
| range = new Range(range, loose); |
| |
| var gtfn, ltefn, ltfn, comp, ecomp; |
| switch (hilo) { |
| case '>': |
| gtfn = gt; |
| ltefn = lte; |
| ltfn = lt; |
| comp = '>'; |
| ecomp = '>='; |
| break; |
| case '<': |
| gtfn = lt; |
| ltefn = gte; |
| ltfn = gt; |
| comp = '<'; |
| ecomp = '<='; |
| break; |
| default: |
| throw new TypeError('Must provide a hilo val of "<" or ">"'); |
| } |
| |
| // If it satisifes the range it is not outside |
| if (satisfies(version, range, loose)) { |
| return false; |
| } |
| |
| // From now on, variable terms are as if we're in "gtr" mode. |
| // but note that everything is flipped for the "ltr" function. |
| |
| for (var i = 0; i < range.set.length; ++i) { |
| var comparators = range.set[i]; |
| |
| var high = null; |
| var low = null; |
| |
| comparators.forEach(function (comparator) { |
| if (comparator.semver === ANY) { |
| comparator = new Comparator('>=0.0.0'); |
| } |
| high = high || comparator; |
| low = low || comparator; |
| if (gtfn(comparator.semver, high.semver, loose)) { |
| high = comparator; |
| } else if (ltfn(comparator.semver, low.semver, loose)) { |
| low = comparator; |
| } |
| }); |
| |
| // If the edge version comparator has a operator then our version |
| // isn't outside it |
| if (high.operator === comp || high.operator === ecomp) { |
| return false; |
| } |
| |
| // If the lowest version comparator has an operator and our version |
| // is less than it then it isn't higher than the range |
| if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { |
| return false; |
| } else if (low.operator === ecomp && ltfn(version, low.semver)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(84))) |
| |
| /***/ }, |
| /* 84 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| // shim for using process in browser |
| |
| var process = module.exports = {}; |
| var queue = []; |
| var draining = false; |
| var currentQueue; |
| var queueIndex = -1; |
| |
| function cleanUpNextTick() { |
| draining = false; |
| if (currentQueue.length) { |
| queue = currentQueue.concat(queue); |
| } else { |
| queueIndex = -1; |
| } |
| if (queue.length) { |
| drainQueue(); |
| } |
| } |
| |
| function drainQueue() { |
| if (draining) { |
| return; |
| } |
| var timeout = setTimeout(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; |
| clearTimeout(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) { |
| setTimeout(drainQueue, 0); |
| } |
| }; |
| |
| // 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; |
| }; |
| |
| /***/ }, |
| /* 85 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = Vm; |
| |
| var _util = __webpack_require__(81); |
| |
| var _scope = __webpack_require__(86); |
| |
| var scope = _interopRequireWildcard(_scope); |
| |
| var _compiler = __webpack_require__(93); |
| |
| var compiler = _interopRequireWildcard(_compiler); |
| |
| var _directive = __webpack_require__(94); |
| |
| var directive = _interopRequireWildcard(_directive); |
| |
| var _domHelper = __webpack_require__(96); |
| |
| var domHelper = _interopRequireWildcard(_domHelper); |
| |
| var _events = __webpack_require__(97); |
| |
| var events = _interopRequireWildcard(_events); |
| |
| var _register = __webpack_require__(98); |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function callOldReadyEntry(vm, component) { |
| if (component.methods && component.methods.ready) { |
| component.methods.ready.call(vm); |
| } |
| } |
| |
| /** |
| * ViewModel constructor |
| * |
| * @param {string} type |
| * @param {object} parentVm which contains _app |
| * @param {object} parentEl root element or frag block |
| * @param {object} mergedData external data |
| * @param {object} externalEvents external events |
| */ |
| |
| // import * as modules from './../api/modules' |
| // import * as api from './../api/api' |
| |
| /** |
| * @fileOverview |
| * ViewModel Constructor & definition |
| */ |
| |
| function Vm(type, parentVm, parentEl, mergedData, externalEvents) { |
| this._parent = parentVm._realParent ? parentVm._realParent : parentVm; |
| this._app = parentVm._app; |
| parentVm._childrenVms && parentVm._childrenVms.push(this); |
| |
| var component = this._app.customComponentMap[type] || {}; |
| var data = component.data || {}; |
| |
| this._options = component; |
| this._methods = component.methods || {}; |
| this._computed = component.computed || {}; |
| this._css = component.style || {}; |
| this._ids = {}; |
| this._watchers = []; |
| this._vmEvents = {}; |
| this._childrenVms = []; |
| this._type = type; |
| |
| // bind events and lifecycles |
| this._initEvents(externalEvents); |
| |
| this.$emit('hook:init'); |
| this._inited = true; |
| // proxy data and methods |
| // observe data and add this to vms |
| this._data = typeof data === 'function' ? data() : data; |
| if (mergedData) { |
| (0, _util.extend)(this._data, mergedData); |
| } |
| this._initScope(); |
| |
| this.$emit('hook:created'); |
| this._created = true; |
| // backward old ready entry |
| callOldReadyEntry(this, component); |
| |
| // if no parentElement then specify the documentElement |
| this._parentEl = parentEl || this._app.doc.documentElement; |
| this._build(); |
| } |
| |
| (0, _util.extend)(Vm.prototype, scope, compiler, directive, domHelper, events); |
| (0, _util.extend)(Vm, { |
| registerModules: _register.registerModules, |
| registerMethods: _register.registerMethods |
| }); |
| // Vm.registerModules(modules) |
| |
| /***/ }, |
| /* 86 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var _ = __webpack_require__(87); |
| var Observer = __webpack_require__(88); |
| var Dep = __webpack_require__(90); |
| |
| /** |
| * Setup the scope of an instance, which contains: |
| * - observed data |
| * - computed properties |
| * - user methods |
| * - meta properties |
| */ |
| |
| exports._initScope = function () { |
| this._initData(); |
| this._initComputed(); |
| this._initMethods(); |
| // this._initMeta() |
| }; |
| |
| /** |
| * Initialize the data. |
| */ |
| |
| exports._initData = function () { |
| // proxy data on instance |
| var data = this._data; |
| var i, key; |
| // // make sure all props properties are observed |
| // var props = this.$options.props |
| // if (props) { |
| // i = props.length |
| // while (i--) { |
| // key = _.camelize(props[i]) |
| // if (!(key in data)) { |
| // data[key] = null |
| // } |
| // } |
| // } |
| var keys = Object.keys(data); |
| i = keys.length; |
| while (i--) { |
| key = keys[i]; |
| if (!_.isReserved(key)) { |
| this._proxy(key); |
| } |
| } |
| // observe data |
| Observer.create(data).addVm(this); |
| }; |
| |
| // /** |
| // * Swap the isntance's $data. Called in $data's setter. |
| // * |
| // * @param {Object} newData |
| // */ |
| |
| // exports._setData = function (newData) { |
| // newData = newData || {} |
| // var oldData = this._data |
| // this._data = newData |
| // var keys, key, i |
| // // unproxy keys not present in new data |
| // keys = Object.keys(oldData) |
| // i = keys.length |
| // while (i--) { |
| // key = keys[i] |
| // if (!_.isReserved(key) && !(key in newData)) { |
| // this._unproxy(key) |
| // } |
| // } |
| // // proxy keys not already proxied, |
| // // and trigger change for changed values |
| // keys = Object.keys(newData) |
| // i = keys.length |
| // while (i--) { |
| // key = keys[i] |
| // if (!this.hasOwnProperty(key) && !_.isReserved(key)) { |
| // // new property |
| // this._proxy(key) |
| // } |
| // } |
| // oldData.__ob__.removeVm(this) |
| // Observer.create(newData).addVm(this) |
| // this._digest() |
| // } |
| |
| /** |
| * Proxy a property, so that |
| * vm.prop === vm._data.prop |
| * |
| * @param {String} key |
| */ |
| |
| exports._proxy = function (key) { |
| // need to store ref to self here |
| // because these getter/setters might |
| // be called by child instances! |
| var self = this; |
| Object.defineProperty(self, key, { |
| configurable: true, |
| enumerable: true, |
| get: function proxyGetter() { |
| return self._data[key]; |
| }, |
| set: function proxySetter(val) { |
| self._data[key] = val; |
| } |
| }); |
| }; |
| |
| /** |
| * Unproxy a property. |
| * |
| * @param {String} key |
| */ |
| |
| exports._unproxy = function (key) { |
| delete this[key]; |
| }; |
| |
| // /** |
| // * Force update on every watcher in scope. |
| // */ |
| |
| // exports._digest = function () { |
| // var i = this._watchers.length |
| // while (i--) { |
| // this._watchers[i].update() |
| // } |
| // var children = this._children |
| // i = children.length |
| // while (i--) { |
| // var child = children[i] |
| // if (child.$options.inherit) { |
| // child._digest() |
| // } |
| // } |
| // } |
| |
| /** |
| * Setup computed properties. They are essentially |
| * special getter/setters |
| */ |
| |
| function noop() {} |
| exports._initComputed = function () { |
| // var computed = this.$options.computed |
| var computed = this._computed; |
| if (computed) { |
| for (var key in computed) { |
| var userDef = computed[key]; |
| var def = { |
| enumerable: true, |
| configurable: true |
| }; |
| if (typeof userDef === 'function') { |
| def.get = _.bind(userDef, this); |
| def.set = noop; |
| } else { |
| def.get = userDef.get ? _.bind(userDef.get, this) : noop; |
| def.set = userDef.set ? _.bind(userDef.set, this) : noop; |
| } |
| Object.defineProperty(this, key, def); |
| } |
| } |
| }; |
| |
| /** |
| * Setup instance methods. Methods must be bound to the |
| * instance since they might be called by children |
| * inheriting them. |
| */ |
| |
| exports._initMethods = function () { |
| // var methods = this.$options.methods |
| var methods = this._methods; |
| if (methods) { |
| for (var key in methods) { |
| this[key] = _.bind(methods[key], this); |
| } |
| } |
| }; |
| |
| // /** |
| // * Initialize meta information like $index, $key & $value. |
| // */ |
| |
| // exports._initMeta = function () { |
| // var metas = this.$options._meta |
| // if (metas) { |
| // for (var key in metas) { |
| // this._defineMeta(key, metas[key]) |
| // } |
| // } |
| // } |
| |
| // /** |
| // * Define a meta property, e.g $index, $key, $value |
| // * which only exists on the vm instance but not in $data. |
| // * |
| // * @param {String} key |
| // * @param {*} value |
| // */ |
| |
| // exports._defineMeta = function (key, value) { |
| // var dep = new Dep() |
| // Object.defineProperty(this, key, { |
| // enumerable: true, |
| // configurable: true, |
| // get: function metaGetter () { |
| // if (Observer.target) { |
| // Observer.target.addDep(dep) |
| // } |
| // return value |
| // }, |
| // set: function metaSetter (val) { |
| // if (val !== value) { |
| // value = val |
| // dep.notify() |
| // } |
| // } |
| // }) |
| // } |
| |
| /***/ }, |
| /* 87 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| // required for code in instance/observer |
| module.exports = __webpack_require__(81); |
| |
| /***/ }, |
| /* 88 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var _ = __webpack_require__(87); |
| var config = __webpack_require__(89); |
| var Dep = __webpack_require__(90); |
| var arrayMethods = __webpack_require__(91); |
| var arrayKeys = Object.getOwnPropertyNames(arrayMethods); |
| __webpack_require__(92); |
| |
| var uid = 0; |
| |
| /** |
| * Type enums |
| */ |
| |
| var ARRAY = 0; |
| var OBJECT = 1; |
| |
| /** |
| * Augment an target Object or Array by intercepting |
| * the prototype chain using __proto__ |
| * |
| * @param {Object|Array} target |
| * @param {Object} proto |
| */ |
| |
| function protoAugment(target, src) { |
| target.__proto__ = src; |
| } |
| |
| /** |
| * Augment an target Object or Array by defining |
| * hidden properties. |
| * |
| * @param {Object|Array} target |
| * @param {Object} proto |
| */ |
| |
| function copyAugment(target, src, keys) { |
| var i = keys.length; |
| var key; |
| while (i--) { |
| key = keys[i]; |
| _.define(target, key, src[key]); |
| } |
| } |
| |
| /** |
| * 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. |
| * |
| * @param {Array|Object} value |
| * @param {Number} type |
| * @constructor |
| */ |
| |
| function Observer(value, type) { |
| this.id = ++uid; |
| this.value = value; |
| this.active = true; |
| this.deps = []; |
| _.define(value, '__ob__', this); |
| if (type === ARRAY) { |
| var augment = config.proto && _.hasProto ? protoAugment : copyAugment; |
| augment(value, arrayMethods, arrayKeys); |
| this.observeArray(value); |
| } else if (type === OBJECT) { |
| this.walk(value); |
| } |
| } |
| |
| Observer.target = null; |
| |
| var p = Observer.prototype; |
| |
| /** |
| * 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. |
| * |
| * @param {*} value |
| * @return {Observer|undefined} |
| * @static |
| */ |
| |
| Observer.create = function (value) { |
| if (value && value.hasOwnProperty('__ob__') && value.__ob__ instanceof Observer) { |
| return value.__ob__; |
| } else if (_.isArray(value)) { |
| return new Observer(value, ARRAY); |
| } else if (_.isPlainObject(value) && !value._isVue // avoid Vue instance |
| ) { |
| return new Observer(value, OBJECT); |
| } |
| }; |
| |
| /** |
| * Walk through each property and convert them into |
| * getter/setters. This method should only be called when |
| * value type is Object. Properties prefixed with `$` or `_` |
| * and accessor properties are ignored. |
| * |
| * @param {Object} obj |
| */ |
| |
| p.walk = function (obj) { |
| var keys = Object.keys(obj); |
| var i = keys.length; |
| var key, prefix; |
| while (i--) { |
| key = keys[i]; |
| prefix = key.charCodeAt(0); |
| if (prefix !== 0x24 && prefix !== 0x5F) { |
| // skip $ or _ |
| this.convert(key, obj[key]); |
| } |
| } |
| }; |
| |
| /** |
| * Try to carete an observer for a child value, |
| * and if value is array, link dep to the array. |
| * |
| * @param {*} val |
| * @return {Dep|undefined} |
| */ |
| |
| p.observe = function (val) { |
| return Observer.create(val); |
| }; |
| |
| /** |
| * Observe a list of Array items. |
| * |
| * @param {Array} items |
| */ |
| |
| p.observeArray = function (items) { |
| var i = items.length; |
| while (i--) { |
| this.observe(items[i]); |
| } |
| }; |
| |
| /** |
| * Convert a property into getter/setter so we can emit |
| * the events when the property is accessed/changed. |
| * |
| * @param {String} key |
| * @param {*} val |
| */ |
| |
| p.convert = function (key, val) { |
| var ob = this; |
| var childOb = ob.observe(val); |
| var dep = new Dep(); |
| if (childOb) { |
| childOb.deps.push(dep); |
| } |
| Object.defineProperty(ob.value, key, { |
| enumerable: true, |
| configurable: true, |
| get: function get() { |
| // Observer.target is a watcher whose getter is |
| // currently being evaluated. |
| if (ob.active && Observer.target) { |
| Observer.target.addDep(dep); |
| } |
| return val; |
| }, |
| set: function set(newVal) { |
| if (newVal === val) return; |
| // remove dep from old value |
| var oldChildOb = val && val.__ob__; |
| if (oldChildOb) { |
| oldChildOb.deps.$remove(dep); |
| } |
| val = newVal; |
| // add dep to new value |
| var newChildOb = ob.observe(newVal); |
| if (newChildOb) { |
| newChildOb.deps.push(dep); |
| } |
| dep.notify(); |
| } |
| }); |
| }; |
| |
| /** |
| * Notify change on all self deps on an observer. |
| * This is called when a mutable value mutates. e.g. |
| * when an Array's mutating methods are called, or an |
| * Object's $add/$delete are called. |
| */ |
| |
| p.notify = function () { |
| var deps = this.deps; |
| for (var i = 0, l = deps.length; i < l; i++) { |
| deps[i].notify(); |
| } |
| }; |
| |
| /** |
| * Add an owner vm, so that when $add/$delete mutations |
| * happen we can notify owner vms to proxy the keys and |
| * digest the watchers. This is only called when the object |
| * is observed as an instance's root $data. |
| * |
| * @param {Vue} vm |
| */ |
| |
| p.addVm = function (vm) { |
| (this.vms = this.vms || []).push(vm); |
| }; |
| |
| /** |
| * Remove an owner vm. This is called when the object is |
| * swapped out as an instance's $data object. |
| * |
| * @param {Vue} vm |
| */ |
| |
| p.removeVm = function (vm) { |
| this.vms.$remove(vm); |
| }; |
| |
| module.exports = Observer; |
| |
| /***/ }, |
| /* 89 */ |
| /***/ function(module, exports) { |
| |
| "use strict"; |
| |
| module.exports = { proto: true }; |
| |
| /***/ }, |
| /* 90 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var _ = __webpack_require__(87); |
| |
| /** |
| * A dep is an observable that can have multiple |
| * directives subscribing to it. |
| * |
| * @constructor |
| */ |
| |
| function Dep() { |
| this.subs = []; |
| } |
| |
| var p = Dep.prototype; |
| |
| /** |
| * Add a directive subscriber. |
| * |
| * @param {Directive} sub |
| */ |
| |
| p.addSub = function (sub) { |
| this.subs.push(sub); |
| }; |
| |
| /** |
| * Remove a directive subscriber. |
| * |
| * @param {Directive} sub |
| */ |
| |
| p.removeSub = function (sub) { |
| this.subs.$remove(sub); |
| }; |
| |
| /** |
| * Notify all subscribers of a new value. |
| */ |
| |
| p.notify = function () { |
| // stablize the subscriber list first |
| var subs = _.toArray(this.subs); |
| for (var i = 0, l = subs.length; i < l; i++) { |
| subs[i].update(); |
| } |
| }; |
| |
| module.exports = Dep; |
| |
| /***/ }, |
| /* 91 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var _ = __webpack_require__(87); |
| var arrayProto = Array.prototype; |
| var arrayMethods = Object.create(arrayProto) |
| |
| /** |
| * Intercept mutating methods and emit events |
| */ |
| |
| ;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) { |
| // cache original method |
| var original = arrayProto[method]; |
| _.define(arrayMethods, method, function mutator() { |
| // avoid leaking arguments: |
| // http://jsperf.com/closure-with-arguments |
| var i = arguments.length; |
| var args = new Array(i); |
| while (i--) { |
| args[i] = arguments[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.notify(); |
| return result; |
| }); |
| }); |
| |
| /** |
| * Swap the element at the given index with a new value |
| * and emits corresponding event. |
| * |
| * @param {Number} index |
| * @param {*} val |
| * @return {*} - replaced element |
| */ |
| |
| _.define(arrayProto, '$set', function $set(index, val) { |
| if (index >= this.length) { |
| this.length = index + 1; |
| } |
| return this.splice(index, 1, val)[0]; |
| }); |
| |
| /** |
| * Convenience method to remove the element at given index. |
| * |
| * @param {Number} index |
| * @param {*} val |
| */ |
| |
| _.define(arrayProto, '$remove', function $remove(index) { |
| /* istanbul ignore if */ |
| if (!this.length) return; |
| if (typeof index !== 'number') { |
| index = _.indexOf(this, index); |
| } |
| if (index > -1) { |
| this.splice(index, 1); |
| } |
| }); |
| |
| module.exports = arrayMethods; |
| |
| /***/ }, |
| /* 92 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| var _ = __webpack_require__(87); |
| var objProto = Object.prototype; |
| |
| /** |
| * Add a new property to an observed object |
| * and emits corresponding event |
| * |
| * @param {String} key |
| * @param {*} val |
| * @public |
| */ |
| |
| _.define(objProto, '$add', function $add(key, val) { |
| if (this.hasOwnProperty(key)) return; |
| var ob = this.__ob__; |
| if (!ob || _.isReserved(key)) { |
| this[key] = val; |
| return; |
| } |
| ob.convert(key, val); |
| ob.notify(); |
| if (ob.vms) { |
| var i = ob.vms.length; |
| while (i--) { |
| var vm = ob.vms[i]; |
| vm._proxy(key); |
| // vm._digest() // todo |
| } |
| } |
| }); |
| |
| /** |
| * Set a property on an observed object, calling add to |
| * ensure the property is observed. |
| * |
| * @param {String} key |
| * @param {*} val |
| * @public |
| */ |
| |
| _.define(objProto, '$set', function $set(key, val) { |
| this.$add(key, val); |
| this[key] = val; |
| }); |
| |
| /** |
| * Deletes a property from an observed object |
| * and emits corresponding event |
| * |
| * @param {String} key |
| * @public |
| */ |
| |
| _.define(objProto, '$delete', function $delete(key) { |
| if (!this.hasOwnProperty(key)) return; |
| delete this[key]; |
| var ob = this.__ob__; |
| if (!ob || _.isReserved(key)) { |
| return; |
| } |
| ob.notify(); |
| if (ob.vms) { |
| var i = ob.vms.length; |
| while (i--) { |
| var vm = ob.vms[i]; |
| vm._unproxy(key); |
| // vm._digest() // todo |
| } |
| } |
| }); |
| |
| /***/ }, |
| /* 93 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; |
| |
| exports._build = _build; |
| exports._generate = _generate; |
| exports._generateElement = _generateElement; |
| exports._setChildren = _setChildren; |
| exports._checkRepeat = _checkRepeat; |
| exports._checkDisplay = _checkDisplay; |
| exports._watchBlock = _watchBlock; |
| exports._mergeContext = _mergeContext; |
| /** |
| * @fileOverview |
| * ViewModel template parser & data-binding process |
| * |
| * required: |
| * index.js: Vm |
| * dom-helper.js: _createElement, _createBlock |
| * dom-helper.js: _attachTarget, _moveTarget, _removeTarget |
| * directive.js: _bindElement, _bindSubVm, _watch |
| * events.js: $on |
| */ |
| |
| /** |
| * build(externalDirs) |
| * createVm() |
| * merge(externalDirs, dirs) |
| * generate(template, parentNode) |
| * if (type is content) create contentNode |
| * else if (dirs have v-for) foreach -> create context |
| * -> generate(templateWithoutFor, parentNode): diff(list) onchange |
| * else if (dirs have v-if) assert |
| * -> generate(templateWithoutIf, parentNode): toggle(shown) onchange |
| * else if (type is native) |
| * set(dirs): update(id/attr/style/class) onchange |
| * append(template, parentNode) |
| * foreach childNodes -> generate(childNode, template) |
| * else if (type is custom) |
| * addChildVm(vm, parentVm) |
| * build(externalDirs) |
| * foreach childNodes -> generate(childNode, template) |
| */ |
| function _build() { |
| var opt = this._options || {}; |
| var template = opt.template || {}; |
| |
| if (opt.replace) { |
| if (template.children && template.children.length === 1) { |
| this._generate(template.children[0], this._parentEl); |
| } else { |
| this._generate(template.children, this._parentEl); |
| } |
| } else { |
| this._generate(template, this._parentEl); |
| } |
| |
| this.$emit('hook:ready'); |
| this._ready = true; |
| } |
| |
| /** |
| * Generate elements by child or children and append to parent elements. |
| * Root element info would be merged if has. The first argument may be an array |
| * if the root element with options.replace has not only one child. |
| * |
| * @param {object|array} target |
| * @param {object} parentEl |
| * @param {object} context |
| */ |
| function _generate(target, parentEl, context) { |
| var _this = this; |
| |
| if (Array.isArray(target)) { |
| var _ret = function () { |
| var fragBlock = _this._createBlock(parentEl); |
| target.forEach(function (child) { |
| _this._generate(child, fragBlock, context); |
| }); |
| return { |
| v: void 0 |
| }; |
| }(); |
| |
| if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v; |
| } |
| |
| context = context || {}; |
| |
| if (target.type === 'content' || target.type === 'slot') { |
| this._content = this._createBlock(parentEl); |
| return; |
| } |
| |
| if (!context.hasOwnProperty('repeat') && target.repeat) { |
| var _ret2 = function () { |
| var list = target.repeat.call(_this); |
| var repeatId = latestRepeatId++; |
| var latestItemId = markList(list, repeatId); |
| |
| var fragBlock = _this._createBlock(parentEl); |
| fragBlock.children = []; |
| fragBlock.data = list.slice(0); |
| |
| _this._checkRepeat(target, fragBlock, repeatId, latestItemId); |
| |
| list.forEach(function (item, index) { |
| if ((typeof item === 'undefined' ? 'undefined' : _typeof(item)) === 'object') { |
| item.INDEX = index; |
| } |
| _this._generate(target, fragBlock, { repeat: item }); |
| }); |
| |
| return { |
| v: void 0 |
| }; |
| }(); |
| |
| if ((typeof _ret2 === 'undefined' ? 'undefined' : _typeof(_ret2)) === "object") return _ret2.v; |
| } |
| |
| var subContext = this; |
| if (context.repeat && !context.shown) { |
| subContext = this._mergeContext(context.repeat); |
| } |
| |
| if (!context.hasOwnProperty('shown') && target.shown) { |
| var display = target.shown.call(subContext); |
| var newContext = { shown: true }; |
| var _fragBlock = subContext._createBlock(parentEl); |
| |
| if (parentEl.element && parentEl.children) { |
| parentEl.children.push(_fragBlock); |
| } |
| |
| if (context.repeat) { |
| newContext.repeat = context.repeat; |
| } |
| |
| _fragBlock.display = !!display; |
| subContext._checkDisplay(target, _fragBlock, newContext); |
| |
| if (display) { |
| subContext._generate(target, _fragBlock, newContext); |
| } |
| |
| return; |
| } |
| |
| var typeGetter = target.type; |
| var type = typeGetter; |
| |
| if (typeof typeGetter === 'function') { |
| type = typeGetter.call(subContext); |
| |
| if (!context.hasOwnProperty('type')) { |
| var _ret3 = function () { |
| var newContext = { type: type }; |
| var fragBlock = subContext._createBlock(parentEl); |
| |
| if (parentEl.element && parentEl.children) { |
| parentEl.children.push(fragBlock); |
| } |
| |
| subContext._watch(typeGetter, function (value) { |
| subContext._removeBlock(fragBlock, true); |
| subContext._generate(target, fragBlock, { type: value }); |
| }); |
| |
| subContext._generate(target, fragBlock, newContext); |
| |
| return { |
| v: void 0 |
| }; |
| }(); |
| |
| if ((typeof _ret3 === 'undefined' ? 'undefined' : _typeof(_ret3)) === "object") return _ret3.v; |
| } |
| } |
| |
| var isComponent = void 0; |
| if (this._app && this._app.customComponentMap && type) { |
| isComponent = this._app.customComponentMap[type]; |
| } else { |
| isComponent = target.component; |
| } |
| |
| if (isComponent) { |
| var Vm = this.constructor; |
| var subVm = new Vm(type, subContext, parentEl, undefined, { |
| 'hook:init': function hookInit() { |
| subContext._setId(target.id, null, this); |
| }, |
| 'hook:created': function hookCreated() { |
| subContext._bindSubVm(this, target, context.repeat); |
| }, |
| 'hook:ready': function hookReady() { |
| if (this._content) { |
| subContext._setChildren(target, this._content); |
| } |
| } |
| }); |
| subContext._bindSubVmAfterInitialized(subVm, target); |
| return; |
| } |
| |
| var element = subContext._generateElement(type, target, parentEl); |
| var treeMode = target.append === 'tree'; |
| if (!treeMode) { |
| subContext._attachTarget(element, parentEl); |
| } |
| subContext._setChildren(target, element); |
| if (treeMode) { |
| subContext._attachTarget(element, parentEl); |
| } |
| } |
| |
| /** |
| * Generate element from template and attach to the dest if needed. |
| * The time to attach depends on whether the mode status is node or tree. |
| * |
| * @param {object} template |
| * @param {object} dest |
| */ |
| function _generateElement(type, template, dest) { |
| |
| this._applyNaitveComponentOptions(template); |
| |
| var element = void 0; |
| if (dest.ref === '_documentElement') { |
| // if its parent is documentElement then it's a body |
| element = this._createBody(type); |
| } else { |
| element = this._createElement(type); |
| } |
| // TODO it was a root element when not in a fragment |
| if (!this._rootEl) { |
| this._rootEl = element; |
| } |
| |
| this._bindElement(element, template); |
| |
| if (template.attr && template.attr.append) { |
| // backward, append prop in attr |
| element.append = template.attr.append; |
| } |
| |
| return element; |
| } |
| |
| /** |
| * Set all children to a certain parent element. |
| * |
| * @param {object} template |
| * @param {object} parentEl |
| */ |
| function _setChildren(template, parentEl) { |
| var _this2 = this; |
| |
| var children = template.children; |
| if (children && children.length) { |
| children.forEach(function (child) { |
| _this2._generate(child, parentEl); |
| }); |
| } |
| } |
| |
| /** |
| * Watch the list update and refresh the changes. |
| * |
| * @param {object} target |
| * @param {object} fragBlock |
| */ |
| function _checkRepeat(target, fragBlock, repeatId, latestItemId) { |
| var _this3 = this; |
| |
| var children = fragBlock.children; |
| |
| this._watchBlock(fragBlock, target.repeat, 'repeat', function (value) { |
| if (!fragBlock) { |
| return; |
| } |
| |
| var oldChildren = children.slice(); |
| var oldValue = fragBlock.data.slice(); |
| // 1. collect all new refs track by |
| var trackMap = {}; |
| var reusedMap = {}; |
| value.forEach(function (item, index) { |
| var key = item['__wx_repeat_' + repeatId + '__']; |
| if (!key) { |
| key = latestItemId++; |
| setRepeatItemId(item, repeatId, key); |
| } |
| trackMap[key] = item; |
| }); |
| |
| // 2. remove unused element foreach old item |
| var reusedList = []; |
| oldValue.forEach(function (item, index) { |
| var key = item['__wx_repeat_' + repeatId + '__']; |
| if (trackMap.hasOwnProperty(key)) { |
| reusedMap[key] = { item: item, index: index, target: oldChildren[index] }; |
| reusedList.push(item); |
| } else { |
| _this3._removeTarget(oldChildren[index]); |
| } |
| }); |
| |
| // 3. create new element foreach new item |
| children.length = 0; |
| fragBlock.data = value.slice(); |
| fragBlock.updateMark = fragBlock.start; |
| |
| value.forEach(function (item, index) { |
| var key = item['__wx_repeat_' + repeatId + '__']; |
| var reused = reusedMap[key]; |
| if ((typeof item === 'undefined' ? 'undefined' : _typeof(item)) === 'object') { |
| item.INDEX = index; |
| } |
| if (reused) { |
| if (reused.item === reusedList[0]) { |
| reusedList.shift(); |
| } else { |
| reusedList.$remove(reused.item); |
| _this3._moveTarget(reused.target, fragBlock.updateMark, true); |
| } |
| children.push(reused.target); |
| fragBlock.updateMark = reused.target; |
| } else { |
| _this3._generate(target, fragBlock, { repeat: item }); |
| } |
| }); |
| |
| delete fragBlock.updateMark; |
| }); |
| } |
| |
| var latestRepeatId = 1; |
| |
| function markList(list, repeatId) { |
| var latestItemId = 1; |
| list.forEach(function (item) { |
| setRepeatItemId(item, repeatId, latestItemId++); |
| }); |
| return latestItemId; |
| } |
| |
| function setRepeatItemId(item, repeatId, itemId) { |
| var key = '__wx_repeat_' + repeatId + '__'; |
| if ((typeof item === 'undefined' ? 'undefined' : _typeof(item)) === 'object') { |
| Object.defineProperty(item, key, { |
| value: itemId |
| }); |
| } |
| } |
| |
| /** |
| * Watch the display update and add/remove the element. |
| * |
| * @param {object} target |
| * @param {object} fragBlock |
| * @param {object} context |
| */ |
| function _checkDisplay(target, fragBlock, context) { |
| var _this4 = this; |
| |
| this._watchBlock(fragBlock, target.shown, 'shown', function (value) { |
| if (!fragBlock || !!fragBlock.display === !!value) { |
| return; |
| } |
| fragBlock.display = value; |
| if (value) { |
| _this4._generate(target, fragBlock, context); |
| } else { |
| _this4._removeBlock(fragBlock, true); |
| } |
| }); |
| } |
| |
| function _watchBlock(fragBlock, calc, type, handler) { |
| var differ = this && this._app && this._app.differ; |
| var config = {}; |
| var depth = (fragBlock.element.depth || 0) + 1; |
| |
| this._watch(calc, function (value) { |
| config.latestValue = value; |
| if (differ && !config.recorded) { |
| differ.append(type, depth, fragBlock.blockId, function () { |
| var latestValue = config.latestValue; |
| handler(latestValue); |
| config.recorded = false; |
| config.latestValue = undefined; |
| }); |
| } |
| config.recorded = true; |
| }); |
| } |
| |
| /** |
| * Clone a context and merge certain data. |
| * |
| * @param {object} mergedData |
| * @return {object} |
| */ |
| function _mergeContext(mergedData) { |
| var context = Object.create(this); |
| context._data = mergedData; |
| context._initData(); |
| context._realParent = this; |
| return context; |
| } |
| |
| /***/ }, |
| /* 94 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; /** |
| * @fileOverview |
| * Directive Parser |
| */ |
| |
| exports._applyNaitveComponentOptions = _applyNaitveComponentOptions; |
| exports._bindElement = _bindElement; |
| exports._bindSubVm = _bindSubVm; |
| exports._bindSubVmAfterInitialized = _bindSubVmAfterInitialized; |
| exports._setId = _setId; |
| exports._setAttr = _setAttr; |
| exports._setClass = _setClass; |
| exports._setStyle = _setStyle; |
| exports._setEvent = _setEvent; |
| exports._bindEvents = _bindEvents; |
| exports._bindDir = _bindDir; |
| exports._bindKey = _bindKey; |
| exports._watch = _watch; |
| |
| var _util = __webpack_require__(81); |
| |
| var _watcher = __webpack_require__(95); |
| |
| var _watcher2 = _interopRequireDefault(_watcher); |
| |
| var _config = __webpack_require__(79); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| var SETTERS = { |
| attr: 'setAttr', |
| style: 'setStyle', |
| event: 'addEvent' |
| }; |
| |
| /** |
| * apply the native component's options(specified by template.type) |
| * to the template |
| */ |
| function _applyNaitveComponentOptions(template) { |
| var type = template.type; |
| |
| var options = _config.nativeComponentMap[type]; |
| |
| if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') { |
| (0, _util.extend)(template, options); |
| } |
| } |
| |
| /** |
| * bind all id, attr, classnames, style, events to an element |
| */ |
| function _bindElement(el, template) { |
| this._setId(template.id, el, this); |
| this._setAttr(el, template.attr); |
| this._setClass(el, template.classList); |
| this._setStyle(el, template.style); |
| this._bindEvents(el, template.events); |
| } |
| |
| /** |
| * bind all props to sub vm and bind all style, events to the root element |
| * of the sub vm if it doesn't have a replaced multi-node fragment |
| */ |
| function _bindSubVm(subVm, template, repeatItem) { |
| subVm = subVm || {}; |
| template = template || {}; |
| |
| var options = subVm._options || {}; |
| |
| // bind props |
| var props = options.props; |
| |
| if (Array.isArray(props)) { |
| props = props.reduce(function (result, value) { |
| result[value] = true; |
| return result; |
| }, {}); |
| } |
| |
| mergeProps(repeatItem, props, this, subVm); |
| mergeProps(template.attr, props, this, subVm); |
| } |
| |
| function _bindSubVmAfterInitialized(subVm, template) { |
| mergeClassStyle(template.classList, this, subVm); |
| mergeStyle(template.style, this, subVm); |
| mergeEvent(template.events, this, subVm); |
| } |
| |
| function mergeProps(target, props, vm, subVm) { |
| if (!target) { |
| return; |
| } |
| |
| var _loop = function _loop(key) { |
| if (!props || props[key]) { |
| var value = target[key]; |
| if (typeof value === 'function') { |
| var returnValue = vm._watch(value, function (v) { |
| subVm[key] = v; |
| }); |
| subVm[key] = returnValue; |
| } else { |
| subVm[key] = value; |
| } |
| } |
| }; |
| |
| for (var key in target) { |
| _loop(key); |
| } |
| } |
| |
| function mergeStyle(target, vm, subVm) { |
| var _loop2 = function _loop2(key) { |
| var value = target[key]; |
| if (typeof value === 'function') { |
| var returnValue = vm._watch(value, function (v) { |
| if (subVm._rootEl) { |
| subVm._rootEl.setStyle(key, v); |
| } |
| }); |
| subVm._rootEl.setStyle(key, returnValue); |
| } else { |
| if (subVm._rootEl) { |
| subVm._rootEl.setStyle(key, value); |
| } |
| } |
| }; |
| |
| for (var key in target) { |
| _loop2(key); |
| } |
| } |
| |
| function mergeClassStyle(target, vm, subVm) { |
| var css = vm._options && vm._options.style || {}; |
| |
| if (!subVm._rootEl) { |
| return; |
| } |
| |
| if (typeof target === 'function') { |
| var _value = vm._watch(target, function (v) { |
| setClassStyle(subVm._rootEl, css, v); |
| }); |
| setClassStyle(subVm._rootEl, css, _value); |
| } else if (target) { |
| setClassStyle(subVm._rootEl, css, target); |
| } |
| } |
| |
| function mergeEvent(target, vm, subVm) { |
| if (target && subVm._rootEl) { |
| for (var type in target) { |
| var handler = vm[target[type]]; |
| if (handler) { |
| subVm._rootEl.addEvent(type, (0, _util.bind)(handler, vm)); |
| } |
| } |
| } |
| } |
| |
| /** |
| * bind id to an element |
| * each id is unique in a whole vm |
| */ |
| function _setId(id, el, vm) { |
| var _this = this; |
| |
| var map = Object.create(null); |
| |
| Object.defineProperties(map, { |
| vm: { |
| value: vm, |
| writable: false, |
| configurable: false |
| }, |
| el: { |
| get: function get() { |
| return el || vm._rootEl; |
| }, |
| configurable: false |
| } |
| }); |
| |
| if (typeof id === 'function') { |
| var handler = id; |
| id = handler.call(this); |
| if (id) { |
| this._ids[id] = map; |
| } |
| this._watch(handler, function (newId) { |
| if (newId) { |
| _this._ids[newId] = map; |
| } |
| }); |
| } else if (id && typeof id === 'string') { |
| this._ids[id] = map; |
| } |
| } |
| |
| /** |
| * bind attr to an element |
| */ |
| function _setAttr(el, attr) { |
| this._bindDir(el, 'attr', attr); |
| } |
| |
| function setClassStyle(el, css, classList) { |
| var classStyle = {}; |
| var length = classList.length; |
| |
| for (var i = 0; i < length; i++) { |
| var style = css[classList[i]]; |
| if (style) { |
| for (var key in style) { |
| classStyle[key] = style[key]; |
| } |
| } |
| } |
| el.setClassStyle(classStyle); |
| } |
| |
| /** |
| * bind classnames to an element |
| */ |
| function _setClass(el, classList) { |
| |
| if (typeof classList !== 'function' && !Array.isArray(classList)) { |
| return; |
| } |
| if (Array.isArray(classList) && !classList.length) { |
| el.setClassStyle({}); |
| return; |
| } |
| |
| var style = this._options && this._options.style || {}; |
| if (typeof classList === 'function') { |
| var _value2 = this._watch(classList, function (v) { |
| setClassStyle(el, style, v); |
| }); |
| setClassStyle(el, style, _value2); |
| } else { |
| setClassStyle(el, style, classList); |
| } |
| } |
| |
| /** |
| * bind style to an element |
| */ |
| function _setStyle(el, style) { |
| this._bindDir(el, 'style', style); |
| } |
| |
| /** |
| * add an event type and handler to an element and generate a dom update |
| */ |
| function _setEvent(el, type, handler) { |
| el.addEvent(type, (0, _util.bind)(handler, this)); |
| } |
| |
| /** |
| * add all events of an element |
| */ |
| function _bindEvents(el, events) { |
| if (!events) { |
| return; |
| } |
| var keys = Object.keys(events); |
| var i = keys.length; |
| while (i--) { |
| var key = keys[i]; |
| var handler = events[key]; |
| if (typeof handler === 'string') { |
| handler = this[handler]; |
| } |
| this._setEvent(el, key, handler); |
| } |
| } |
| |
| /** |
| * set a series of members as a kind of an element |
| * for example: style, attr, ... |
| * if the value is a function then bind the data changes |
| */ |
| function _bindDir(el, name, data) { |
| if (!data) { |
| return; |
| } |
| var keys = Object.keys(data); |
| var i = keys.length; |
| while (i--) { |
| var key = keys[i]; |
| var _value3 = data[key]; |
| if (typeof _value3 === 'function') { |
| var update = _value3; |
| this._bindKey(el, name, key, update); |
| } else { |
| el[SETTERS[name]](key, _value3); |
| } |
| } |
| } |
| |
| /** |
| * bind data changes to a certain key to a name series in an element |
| */ |
| function _bindKey(el, name, key, calc) { |
| var _this2 = this; |
| |
| var methodName = SETTERS[name]; |
| var obj = el[name]; |
| // watch the calc, and returns a value by calc.call() |
| var value = this._watch(calc, function (value) { |
| function handler() { |
| el[methodName](key, value); |
| } |
| var differ = _this2 && _this2._app && _this2._app.differ; |
| if (differ) { |
| differ.append('element', el.depth, el.ref, handler); |
| } else { |
| handler(); |
| } |
| }); |
| |
| el[methodName](key, value); |
| } |
| |
| /** |
| * watch a calc function and callback if the calc value changes |
| */ |
| function _watch(calc, callback) { |
| var watcher = new _watcher2.default(this, calc, function (value, oldValue) { |
| /* istanbul ignore if */ |
| if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) !== 'object' && value === oldValue) { |
| return; |
| } |
| callback(value); |
| }); |
| |
| return watcher.value; |
| } |
| |
| /***/ }, |
| /* 95 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| /** |
| * The MIT License (MIT) |
| * |
| * Copyright (c) 2013-2015 Yuxi Evan You |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| |
| var _ = __webpack_require__(87); |
| // var config = require('./config') |
| var Observer = __webpack_require__(88); |
| // var expParser = require('./parsers/expression') |
| // var batcher = require('./batcher') |
| var uid = 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. |
| * |
| * @param {Vue} vm |
| * @param {String} expression |
| * @param {Function} cb |
| * @param {Object} options |
| * - {Array} filters |
| * - {Boolean} twoWay |
| * - {Boolean} deep |
| * - {Boolean} user |
| * - {Function} [preProcess] |
| * @constructor |
| */ |
| |
| // function Watcher (vm, expression, cb, options) { |
| function Watcher(vm, update, cb) { |
| this.vm = vm; |
| vm._watchers.push(this); |
| // this.expression = expression |
| this.cb = cb; |
| this.id = ++uid; // uid for batching |
| this.active = true; |
| // options = options || {} |
| // this.deep = !!options.deep |
| // this.user = !!options.user |
| // this.twoWay = !!options.twoWay |
| // this.filters = options.filters |
| // this.preProcess = options.preProcess |
| this.deps = []; |
| this.newDeps = []; |
| // parse expression for getter/setter |
| // var res = expParser.parse(expression, options.twoWay) |
| // this.getter = res.get |
| // this.setter = res.set |
| this.getter = update; |
| this.value = this.get(); |
| } |
| |
| var p = Watcher.prototype; |
| |
| /** |
| * Add a dependency to this directive. |
| * |
| * @param {Dep} dep |
| */ |
| |
| p.addDep = function (dep) { |
| var newDeps = this.newDeps; |
| var old = this.deps; |
| if (_.indexOf(newDeps, dep) < 0) { |
| newDeps.push(dep); |
| var i = _.indexOf(old, dep); |
| if (i < 0) { |
| dep.addSub(this); |
| } else { |
| old[i] = null; |
| } |
| } |
| }; |
| |
| /** |
| * Evaluate the getter, and re-collect dependencies. |
| */ |
| |
| p.get = function () { |
| this.beforeGet(); |
| var vm = this.vm; |
| var value; |
| try { |
| value = this.getter.call(vm, vm); |
| } catch (e) { |
| // if (config.warnExpressionErrors) { |
| // _.warn( |
| // 'Error when evaluating expression "' + |
| // this.expression + '":\n ' + e |
| // ) |
| // } |
| _.warn('Error when update"'); |
| } |
| // "touch" every property so they are all tracked as |
| // dependencies for deep watching |
| if (this.deep) { |
| traverse(value); |
| } |
| if (this.preProcess) { |
| value = this.preProcess(value); |
| } |
| if (this.filters) { |
| value = vm._applyFilters(value, null, this.filters, false); |
| } |
| this.afterGet(); |
| return value; |
| }; |
| |
| // /** |
| // * Set the corresponding value with the setter. |
| // * |
| // * @param {*} value |
| // */ |
| |
| // p.set = function (value) { |
| // var vm = this.vm |
| // if (this.filters) { |
| // value = vm._applyFilters( |
| // value, this.value, this.filters, true) |
| // } |
| // try { |
| // this.setter.call(vm, vm, value) |
| // } catch (e) { |
| // // if (config.warnExpressionErrors) { |
| // _.warn( |
| // 'Error when evaluating setter "' + |
| // this.expression + '":\n ' + e |
| // ) |
| // // } |
| // } |
| // } |
| |
| /** |
| * Prepare for dependency collection. |
| */ |
| |
| p.beforeGet = function () { |
| Observer.target = this; |
| }; |
| |
| /** |
| * Clean up for dependency collection. |
| */ |
| |
| p.afterGet = function () { |
| Observer.target = null; |
| var i = this.deps.length; |
| while (i--) { |
| var dep = this.deps[i]; |
| if (dep) { |
| dep.removeSub(this); |
| } |
| } |
| this.deps = this.newDeps; |
| this.newDeps = []; |
| }; |
| |
| /** |
| * Subscriber interface. |
| * Will be called when a dependency changes. |
| */ |
| |
| // p.update = function () { |
| // if (!config.async || config.debug) { |
| // this.run() |
| // } else { |
| // batcher.push(this) |
| // } |
| // } |
| |
| // /** |
| // * Batcher job interface. |
| // * Will be called by the batcher. |
| // */ |
| |
| // p.run = function () { |
| p.update = function () { |
| if (this.active) { |
| var value = this.get(); |
| if (value !== this.value || Array.isArray(value) || this.deep) { |
| var oldValue = this.value; |
| this.value = value; |
| this.cb(value, oldValue); |
| } |
| } |
| }; |
| |
| /** |
| * Remove self from all dependencies' subcriber list. |
| */ |
| |
| p.teardown = function () { |
| if (this.active) { |
| // remove self from vm's watcher list |
| // we can skip this if the vm if being destroyed |
| // which can improve teardown performance. |
| if (!this.vm._isBeingDestroyed) { |
| this.vm._watchers.$remove(this); |
| } |
| var i = this.deps.length; |
| while (i--) { |
| this.deps[i].removeSub(this); |
| } |
| this.active = false; |
| this.vm = this.cb = this.value = null; |
| } |
| }; |
| |
| /** |
| * Recrusively traverse an object to evoke all converted |
| * getters, so that every nested property inside the object |
| * is collected as a "deep" dependency. |
| * |
| * @param {Object} obj |
| */ |
| |
| function traverse(obj) { |
| var key, val, i; |
| for (key in obj) { |
| val = obj[key]; |
| if (_.isArray(val)) { |
| i = val.length; |
| while (i--) { |
| traverse(val[i]); |
| } |
| } else if (_.isObject(val)) { |
| traverse(val); |
| } |
| } |
| } |
| |
| module.exports = Watcher; |
| |
| /***/ }, |
| /* 96 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports._createBody = _createBody; |
| exports._createElement = _createElement; |
| exports._createBlock = _createBlock; |
| exports._createBlockStart = _createBlockStart; |
| exports._createBlockEnd = _createBlockEnd; |
| exports._attachTarget = _attachTarget; |
| exports._moveTarget = _moveTarget; |
| exports._moveElement = _moveElement; |
| exports._moveBlock = _moveBlock; |
| exports._removeTarget = _removeTarget; |
| exports._removeElement = _removeElement; |
| exports._removeBlock = _removeBlock; |
| /** |
| * @fileOverview Document & Element Helpers. |
| * |
| * required: |
| * Document#: createElement, createComment, getRef |
| * Element#: appendChild, insertBefore, removeChild, nextSibling |
| */ |
| |
| /** |
| * Create a body by type |
| * Using this._app.doc |
| * |
| * @param {string} type |
| */ |
| function _createBody(type) { |
| var doc = this._app.doc; |
| return doc.createBody(type); |
| } |
| |
| /** |
| * Create an element by type |
| * Using this._app.doc |
| * |
| * @param {string} type |
| */ |
| function _createElement(type) { |
| var doc = this._app.doc; |
| return doc.createElement(type); |
| } |
| |
| /** |
| * Create and return a frag block for an element. |
| * The frag block has a starter, ender and the element itself. |
| * |
| * @param {object} element |
| */ |
| function _createBlock(element) { |
| var start = this._createBlockStart(); |
| var end = this._createBlockEnd(); |
| var blockId = lastestBlockId++; |
| if (element.element) { |
| element.element.insertBefore(start, element.end); |
| element.element.insertBefore(end, element.end); |
| element = element.element; |
| } else { |
| element.appendChild(start); |
| element.appendChild(end); |
| } |
| return { start: start, end: end, element: element, blockId: blockId }; |
| } |
| |
| var lastestBlockId = 1; |
| |
| /** |
| * Create and return a block starter. |
| * Using this._app.doc |
| */ |
| function _createBlockStart() { |
| var doc = this._app.doc; |
| var anchor = doc.createComment('start'); |
| return anchor; |
| } |
| |
| /** |
| * Create and return a block ender. |
| * Using this._app.doc |
| */ |
| function _createBlockEnd() { |
| var doc = this._app.doc; |
| var anchor = doc.createComment('end'); |
| return anchor; |
| } |
| |
| /** |
| * Attach target to a certain dest using appendChild by default. |
| * If the dest is a frag block then insert before the ender. |
| * If the target is a frag block then attach the starter and ender in order. |
| * |
| * @param {object} target |
| * @param {object} dest |
| */ |
| function _attachTarget(target, dest) { |
| |
| if (dest.element) { |
| var before = dest.end; |
| var after = dest.updateMark; |
| // push new target for watch list update later |
| if (dest.children) { |
| dest.children.push(target); |
| } |
| // for check repeat case |
| if (after) { |
| this._moveTarget(target, after); |
| dest.updateMark = target.element ? target.end : target; |
| } else if (target.element) { |
| dest.element.insertBefore(target.start, before); |
| dest.element.insertBefore(target.end, before); |
| } else { |
| dest.element.insertBefore(target, before); |
| } |
| } else { |
| if (target.element) { |
| dest.appendChild(target.start); |
| dest.appendChild(target.end); |
| } else { |
| dest.appendChild(target); |
| } |
| } |
| } |
| |
| /** |
| * Move target before a certain element. The target maybe block or element. |
| * |
| * @param {object} target |
| * @param {object} before |
| */ |
| function _moveTarget(target, after) { |
| if (target.element) { |
| this._moveBlock(target, after); |
| } else { |
| this._moveElement(target, after); |
| } |
| } |
| |
| /** |
| * Move element before a certain element. |
| * |
| * @param {object} element |
| * @param {object} before |
| */ |
| function _moveElement(element, after) { |
| var doc = this._app.doc; |
| var parent = doc.getRef(after.parentRef); |
| |
| if (parent) { |
| parent.insertAfter(element, after); |
| } |
| } |
| |
| /** |
| * Move all elements of the block before a certain element. |
| * |
| * @param {object} fragBlock |
| * @param {object} before |
| */ |
| function _moveBlock(fragBlock, after) { |
| var doc = this._app.doc; |
| var parent = doc.getRef(after.parentRef); |
| |
| if (parent) { |
| (function () { |
| var el = fragBlock.start; |
| var group = [el]; |
| |
| while (el && el !== fragBlock.end) { |
| el = el.next(); |
| group.push(el); |
| } |
| |
| var temp = after; |
| group.forEach(function (el) { |
| parent.insertAfter(el, temp); |
| temp = el; |
| }); |
| })(); |
| } |
| } |
| |
| /** |
| * Remove target from DOM tree. |
| * If the target is a frag block then call _removeBlock |
| * |
| * @param {object} target |
| */ |
| function _removeTarget(target) { |
| |
| if (target.element) { |
| this._removeBlock(target); |
| } else { |
| this._removeElement(target); |
| } |
| } |
| |
| /** |
| * Remove a certain element. |
| * Using this._app.doc |
| * |
| * @param {object} target |
| */ |
| function _removeElement(target) { |
| var doc = this._app.doc; |
| var parent = doc.getRef(target.parentRef); |
| |
| if (parent) { |
| parent.removeChild(target); |
| } |
| } |
| |
| /** |
| * Remove a frag block. |
| * The second param decides whether the block self should be removed too. |
| * |
| * @param {object} fragBlock |
| * @param {Boolean} preserveBlock=false |
| */ |
| function _removeBlock(fragBlock) { |
| var _this = this; |
| |
| var preserveBlock = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1]; |
| |
| var result = []; |
| var el = fragBlock.start.next(); |
| |
| while (el && el !== fragBlock.end) { |
| result.push(el); |
| el = el.next(); |
| } |
| |
| if (!preserveBlock) { |
| this._removeElement(fragBlock.start); |
| } |
| result.forEach(function (el) { |
| _this._removeElement(el); |
| }); |
| if (!preserveBlock) { |
| this._removeElement(fragBlock.end); |
| } |
| } |
| |
| /***/ }, |
| /* 97 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.$emit = $emit; |
| exports.$dispatch = $dispatch; |
| exports.$broadcast = $broadcast; |
| exports.$on = $on; |
| exports.$off = $off; |
| exports._initEvents = _initEvents; |
| function Evt(type, detail) { |
| if (detail instanceof Evt) { |
| return detail; |
| } |
| |
| this.timestamp = Date.now(); |
| this.detail = detail; |
| this.type = type; |
| |
| var shouldStop = false; |
| this.stop = function () { |
| shouldStop = true; |
| }; |
| this.hasStopped = function () { |
| return shouldStop; |
| }; |
| } |
| |
| function $emit(type, detail) { |
| var _this = this; |
| |
| var events = this._vmEvents; |
| var handlerList = events[type]; |
| if (handlerList) { |
| (function () { |
| var evt = new Evt(type, detail); |
| handlerList.forEach(function (handler) { |
| handler.call(_this, evt); |
| }); |
| })(); |
| } |
| } |
| |
| function $dispatch(type, detail) { |
| var evt = new Evt(type, detail); |
| this.$emit(type, evt); |
| |
| if (!evt.hasStopped() && this._parent && this._parent.$dispatch) { |
| this._parent.$dispatch(type, evt); |
| } |
| } |
| |
| function $broadcast(type, detail) { |
| var evt = new Evt(type, detail); |
| this.$emit(type, evt); |
| |
| if (!evt.hasStopped() && this._childrenVms) { |
| this._childrenVms.forEach(function (subVm) { |
| subVm.$broadcast(type, evt); |
| }); |
| } |
| } |
| |
| function $on(type, handler) { |
| if (!type || typeof handler !== 'function') { |
| return; |
| } |
| var events = this._vmEvents; |
| var handlerList = events[type] || []; |
| handlerList.push(handler); |
| events[type] = handlerList; |
| |
| // fixed old version lifecycle design |
| if (type === 'hook:ready' && this._ready) { |
| this.$emit('hook:ready'); |
| } |
| } |
| |
| function $off(type, handler) { |
| if (!type) { |
| return; |
| } |
| var events = this._vmEvents; |
| if (!handler) { |
| delete events[type]; |
| return; |
| } |
| var handlerList = events[type]; |
| if (!handlerList) { |
| return; |
| } |
| handlerList.$remove(handler); |
| } |
| |
| var LIFE_CYCLE_TYPES = ['init', 'created', 'ready']; |
| |
| function _initEvents(externalEvents) { |
| var _this2 = this; |
| |
| var options = this._options || {}; |
| var events = options.events || {}; |
| for (var type1 in events) { |
| this.$on(type1, events[type1]); |
| } |
| for (var type2 in externalEvents) { |
| this.$on(type2, externalEvents[type2]); |
| } |
| LIFE_CYCLE_TYPES.forEach(function (type) { |
| _this2.$on('hook:' + type, options[type]); |
| }); |
| } |
| |
| /***/ }, |
| /* 98 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.clearModules = clearModules; |
| exports.getModule = getModule; |
| exports.requireModule = requireModule; |
| exports.registerModules = registerModules; |
| exports.registerMethods = registerMethods; |
| exports.requireComponent = requireComponent; |
| exports.registerComponent = registerComponent; |
| var nativeModules = {}; |
| |
| function assignModules(modules, ifReplace) { |
| var _loop = function _loop(moduleName) { |
| |
| // init `modules[moduleName][]` |
| var methods = nativeModules[moduleName]; |
| if (!methods) { |
| methods = {}; |
| nativeModules[moduleName] = methods; |
| } |
| |
| // push each non-existed new method |
| modules[moduleName].forEach(function (method) { |
| if (typeof method === 'string') { |
| method = { |
| name: method |
| }; |
| } |
| |
| if (!methods[method.name] || ifReplace) { |
| methods[method.name] = method; |
| } |
| }); |
| }; |
| |
| for (var moduleName in modules) { |
| _loop(moduleName); |
| } |
| } |
| |
| function assignApis(Ctor, apis) { |
| var p = Ctor.prototype; |
| |
| for (var apiName in apis) { |
| if (!p.hasOwnProperty(apiName)) { |
| p[apiName] = apis[apiName]; |
| } |
| } |
| } |
| |
| function clearModules() { |
| nativeModules = {}; |
| } |
| |
| function getModule(moduleName) { |
| return nativeModules[moduleName]; |
| } |
| |
| /** |
| * @context a instance of AppInstance |
| */ |
| function requireModule(moduleName) { |
| var _this = this; |
| |
| var methods = nativeModules[moduleName]; |
| var target = {}; |
| |
| var _loop2 = function _loop2(methodName) { |
| target[methodName] = function () { |
| for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
| args[_key] = arguments[_key]; |
| } |
| |
| return _this.callTasks({ |
| module: moduleName, |
| method: methodName, |
| args: args |
| }); |
| }; |
| }; |
| |
| for (var methodName in methods) { |
| _loop2(methodName); |
| } |
| |
| return target; |
| } |
| |
| /** |
| * @context Vm |
| */ |
| function registerModules(modules, ifReplace) { |
| assignModules(modules, ifReplace); |
| } |
| |
| /** |
| * @context Vm |
| */ |
| function registerMethods(apis) { |
| assignApis(this, apis); |
| } |
| |
| /** |
| * @context a instance of AppInstance |
| */ |
| function requireComponent(name) { |
| var customComponentMap = this.customComponentMap; |
| |
| return customComponentMap[name]; |
| } |
| |
| /** |
| * @context a instance of AppInstance |
| */ |
| function registerComponent(name, exports) { |
| var customComponentMap = this.customComponentMap; |
| |
| |
| if (customComponentMap[name]) { |
| throw new Error('define a component(' + name + ') that already exists'); |
| } |
| |
| customComponentMap[name] = exports; |
| } |
| |
| /***/ }, |
| /* 99 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.normalizeVersion = normalizeVersion; |
| exports.getError = getError; |
| exports.check = check; |
| |
| var _semver = __webpack_require__(83); |
| |
| var _semver2 = _interopRequireDefault(_semver); |
| |
| var _util = __webpack_require__(81); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| /** |
| * [normalizeVersion description] |
| * @param {String} Version. ie: 1, 1.0, 1.0.0 |
| * @return {String} Version |
| */ |
| function normalizeVersion(v) { |
| var isValid = _semver2.default.valid(v) ? true : false; |
| if (isValid) { |
| return v; |
| } |
| |
| v = typeof v === 'string' ? v : ''; |
| var split = v.split('.'); |
| var i = 0; |
| var result = []; |
| |
| while (i < 3) { |
| var s = typeof split[i] === 'string' && split[i] ? split[i] : '0'; |
| result.push(s); |
| i++; |
| } |
| |
| return result.join('.'); |
| } |
| |
| function getError(key, val, criteria) { |
| var result = { |
| isDowngrade: true, |
| errorType: 1, |
| code: 1000 |
| }; |
| var getMsg = function getMsg(key, val, criteria) { |
| return 'Downgrade[' + key + '] :: deviceInfo ' + val + ' matched criteria ' + criteria; |
| }; |
| var _key = key.toLowerCase(); |
| |
| result.errorMessage = getMsg(key, val, criteria); |
| |
| if (_key.indexOf('osversion') >= 0) { |
| result.code = 1001; |
| } else if (_key.indexOf('appversion') >= 0) { |
| result.code = 1002; |
| } else if (_key.indexOf('weexversion') >= 0) { |
| result.code = 1003; |
| } else if (_key.indexOf('devicemodel') >= 0) { |
| result.code = 1004; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * WEEX framework input(deviceInfo) |
| * { |
| * platform: 'iOS' or 'android' |
| * osVersion: '1.0.0' or '1.0' or '1' |
| * appVersion: '1.0.0' or '1.0' or '1' |
| * weexVersion: '1.0.0' or '1.0' or '1' |
| * dDeviceModel: 'MODEL_NAME' |
| * } |
| * |
| * downgrade config(config) |
| * { |
| * ios: { |
| * osVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0' |
| * appVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0' |
| * weexVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0' |
| * deviceModel: ['modelA', 'modelB', ...] |
| * }, |
| * android: { |
| * osVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0' |
| * appVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0' |
| * weexVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0' |
| * deviceModel: ['modelA', 'modelB', ...] |
| * } |
| * } |
| * |
| * |
| * @param {object} deviceInfo Weex SDK framework input |
| * @param {object} config user input |
| * @return {Object} { isDowngrade: true/false, errorMessage... } |
| */ |
| function check(config, deviceInfo) { |
| deviceInfo = deviceInfo || global.WXEnvironment; |
| deviceInfo = (0, _util.isPlainObject)(deviceInfo) ? deviceInfo : {}; |
| config = (0, _util.isPlainObject)(config) ? config : {}; |
| var platform = deviceInfo.platform || 'unknow'; |
| var dPlatform = platform.toLowerCase(); |
| var cObj = config[dPlatform] || {}; |
| |
| var result = { |
| isDowngrade: false // defautl is pass |
| }; |
| |
| for (var i in deviceInfo) { |
| var key = i; |
| var keyLower = key.toLowerCase(); |
| var val = deviceInfo[i]; |
| var isVersion = keyLower.indexOf('version') >= 0 ? true : false; |
| var isDeviceModel = keyLower.indexOf('devicemodel') >= 0 ? true : false; |
| var criteria = cObj[i]; |
| |
| if (criteria && isVersion) { |
| var c = this.normalizeVersion(criteria); |
| var d = this.normalizeVersion(deviceInfo[i]); |
| |
| if (_semver2.default.satisfies(d, c)) { |
| result = (0, _util.extend)(this.getError(key, val, criteria)); |
| break; |
| } |
| } else if (isDeviceModel) { |
| var _criteria = (0, _util.typof)(criteria) === 'array' ? criteria : [criteria]; |
| if (_criteria.indexOf(val) >= 0) { |
| result = (0, _util.extend)(this.getError(key, val, criteria)); |
| break; |
| } |
| } |
| } |
| |
| return result; |
| } |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ }, |
| /* 100 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.init = init; |
| exports.destroy = destroy; |
| exports.getRootElement = getRootElement; |
| exports.updateActions = updateActions; |
| exports.fireEvent = fireEvent; |
| exports.callback = callback; |
| exports.refreshData = refreshData; |
| |
| var _util = __webpack_require__(81); |
| |
| var _perf = __webpack_require__(77); |
| |
| var perf = _interopRequireWildcard(_perf); |
| |
| var _domListener = __webpack_require__(101); |
| |
| var _domListener2 = _interopRequireDefault(_domListener); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } /** |
| * @fileOverview |
| * instance controls from native |
| * |
| * - init bundle |
| * - fire event |
| * - callback |
| * - destroy |
| * |
| * corresponded with the API of instance manager (framework.js) |
| */ |
| |
| function init(code, data) { |
| var _this = this; |
| |
| var result; |
| // @see: lib/app/bundle.js |
| var define = (0, _util.bind)(this.define, this); |
| var bootstrap = function bootstrap(name, config, _data) { |
| result = _this.bootstrap(name, config, _data || data); |
| _this.doc.listener.createFinish(); |
| _this.doc.close(); |
| }; |
| |
| // backward(register/render) |
| var register = (0, _util.bind)(this.register, this); |
| var render = function render(name, _data) { |
| result = _this.bootstrap(name, {}, _data); |
| }; |
| |
| var require = function require(name) { |
| return function (_data) { |
| result = _this.bootstrap(name, {}, _data); |
| }; |
| }; |
| |
| var document = this.doc; |
| |
| perf.start('run bundle', this.id); |
| |
| var functionBody = void 0; |
| /* istanbul ignore if */ |
| if (typeof code === 'function') { |
| // `function () {...}` -> `{...}` |
| // not very strict |
| functionBody = code.toString().substr(12); |
| } else if (code) { |
| functionBody = code.toString(); |
| } |
| |
| var fn = new Function('define', 'require', 'document', 'bootstrap', 'register', 'render', functionBody); |
| |
| fn(define, require, document, bootstrap, register, render); |
| |
| perf.end('run bundle', this.id); |
| return result; |
| } |
| |
| function destroy() { |
| this.id = ''; |
| this.eventManager = null; |
| this.options = null; |
| this.blocks = null; |
| this.vm = null; |
| this.doc = null; |
| this.customComponentMap = null; |
| this.callbacks = null; |
| } |
| |
| function getRootElement() { |
| var doc = this.doc || {}; |
| var body = doc.body || {}; |
| return body.toJSON ? body.toJSON() : {}; |
| } |
| |
| function updateActions(addonTasks) { |
| this.differ.flush(); |
| var tasks = []; |
| if (this.listener && this.listener.updates.length) { |
| tasks.push.apply(tasks, _toConsumableArray(this.listener.updates)); |
| this.listener.updates = []; |
| } |
| if (addonTasks && addonTasks.length) { |
| tasks.push.apply(tasks, _toConsumableArray(addonTasks)); |
| } |
| if (tasks.length) { |
| this.callTasks(tasks); |
| } |
| } |
| |
| function fireEvent(ref, type, e, domChanges) { |
| var _this2 = this; |
| |
| if (Array.isArray(ref)) { |
| ref.some(function (ref) { |
| return _this2.fireEvent(ref, type, e) !== false; |
| }); |
| return; |
| } |
| |
| var el = this.doc.getRef(ref); |
| |
| if (el) { |
| perf.start('manage event', ref + '-' + type); |
| e = e || {}; |
| e.type = type; |
| e.target = el; |
| e.timestamp = Date.now(); |
| if (domChanges) { |
| updateElement(el, domChanges); |
| } |
| var result = this.eventManager.fire(el, type, e); |
| perf.end('manage event', ref + '-' + type); |
| this.updateActions(); |
| return result; |
| } |
| |
| return new Error('invalid element reference "' + ref + '"'); |
| } |
| |
| function callback(callbackId, data, ifKeepAlive) { |
| var callback = this.callbacks[callbackId]; |
| |
| if (typeof callback === 'function') { |
| callback(data); // data is already a object, @see: lib/framework.js |
| |
| if (typeof ifKeepAlive === 'undefined' || ifKeepAlive === false) { |
| this.callbacks[callbackId] = undefined; |
| } |
| |
| this.updateActions(); |
| return; |
| } |
| |
| return new Error('invalid callback id "' + callbackId + '"'); |
| } |
| |
| function refreshData(data) { |
| var vm = this.vm; |
| |
| if (vm && data) { |
| if (typeof vm.refreshData === 'function') { |
| vm.refreshData(data); |
| } else { |
| (0, _util.extend)(vm, data); |
| } |
| this.updateActions([(0, _domListener.createAction)('refreshFinish', [])]); |
| return; |
| } |
| |
| return new Error('invalid data "' + data + '"'); |
| } |
| |
| function updateElement(el, changes) { |
| var attrs = changes.attrs || {}; |
| for (var name in attrs) { |
| el.setAttr(name, attrs); |
| } |
| var style = changes.style || {}; |
| for (var _name in style) { |
| el.setStyle(_name, style[_name]); |
| } |
| } |
| |
| /***/ }, |
| /* 101 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = Listener; |
| exports.createAction = createAction; |
| function Listener(id, handler) { |
| this.id = id; |
| this.batched = false; |
| this.updates = []; |
| if (typeof handler === 'function') { |
| this.handler = handler; |
| } |
| } |
| |
| Listener.prototype.createFinish = function (callback) { |
| var handler = this.handler; |
| handler([createAction('createFinish', [])], callback); |
| }; |
| |
| Listener.prototype.createBody = function (element, ref) { |
| var actions = [createAction('createBody', [element.toJSON()])]; |
| this.addActions(actions); |
| }; |
| |
| Listener.prototype.addElement = function (element, ref, index) { |
| if (!(index >= 0)) { |
| index = -1; |
| } |
| this.addActions(createAction('addElement', [ref, element.toJSON(), index])); |
| }; |
| |
| Listener.prototype.removeElement = function (ref) { |
| if (Array.isArray(ref)) { |
| var actions = ref.map(function (r) { |
| return createAction('removeElement', [r]); |
| }); |
| this.addActions(actions); |
| } else { |
| this.addActions(createAction('removeElement', [ref])); |
| } |
| }; |
| |
| Listener.prototype.moveElement = function (targetRef, parentRef, index) { |
| this.addActions(createAction('moveElement', [targetRef, parentRef, index])); |
| }; |
| |
| Listener.prototype.setAttr = function (ref, key, value) { |
| var result = {}; |
| result[key] = value; |
| this.addActions(createAction('updateAttrs', [ref, result])); |
| }; |
| |
| Listener.prototype.setStyle = function (ref, key, value) { |
| var result = {}; |
| result[key] = value; |
| this.addActions(createAction('updateStyle', [ref, result])); |
| }; |
| |
| Listener.prototype.setStyles = function (ref, style) { |
| this.addActions(createAction('updateStyle', [ref, style])); |
| }; |
| |
| Listener.prototype.addEvent = function (ref, type) { |
| this.addActions(createAction('addEvent', [ref, type])); |
| }; |
| |
| Listener.prototype.removeEvent = function (ref, type) { |
| this.addActions(createAction('removeEvent', [ref, type])); |
| }; |
| |
| Listener.prototype.handler = function (actions, cb) { |
| cb && cb(); |
| }; |
| |
| Listener.prototype.addActions = function (actions) { |
| var updates = this.updates; |
| var handler = this.handler; |
| |
| if (!Array.isArray(actions)) { |
| actions = [actions]; |
| } |
| |
| if (this.batched) { |
| updates.push.apply(updates, actions); |
| } else { |
| handler(actions); |
| } |
| }; |
| |
| function createAction(name, args) { |
| return { module: 'dom', method: name, args: args }; |
| } |
| |
| /***/ }, |
| /* 102 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| |
| var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
| |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
| |
| var Differ = function () { |
| function Differ(id) { |
| _classCallCheck(this, Differ); |
| |
| this.id = id; |
| this.map = []; |
| this.hooks = []; |
| } |
| |
| _createClass(Differ, [{ |
| key: 'isEmpty', |
| value: function isEmpty() { |
| return this.map.length === 0; |
| } |
| }, { |
| key: 'append', |
| value: function append(type, depth, ref, handler) { |
| var map = this.map; |
| if (!map[depth]) { |
| map[depth] = {}; |
| } |
| var group = map[depth]; |
| if (!group[type]) { |
| group[type] = {}; |
| } |
| if (type === 'element') { |
| if (!group[type][ref]) { |
| group[type][ref] = []; |
| } |
| group[type][ref].push(handler); |
| } else { |
| group[type][ref] = handler; |
| } |
| } |
| }, { |
| key: 'flush', |
| value: function flush() { |
| var map = this.map.slice(); |
| this.map.length = 0; |
| map.forEach(function (group) { |
| callTypeMap(group, 'repeat'); |
| callTypeMap(group, 'shown'); |
| callTypeList(group, 'element'); |
| }); |
| |
| var hooks = this.hooks.slice(); |
| this.hooks.length = 0; |
| hooks.forEach(function (fn) { |
| fn(); |
| }); |
| |
| if (!this.isEmpty()) { |
| this.flush(); |
| } |
| } |
| }, { |
| key: 'then', |
| value: function then(fn) { |
| this.hooks.push(fn); |
| } |
| }]); |
| |
| return Differ; |
| }(); |
| |
| exports.default = Differ; |
| |
| |
| function callTypeMap(group, type) { |
| var map = group[type]; |
| for (var ref in map) { |
| map[ref](); |
| } |
| } |
| |
| function callTypeList(group, type) { |
| var map = group[type]; |
| for (var ref in map) { |
| var list = map[ref]; |
| list.forEach(function (handler) { |
| handler(); |
| }); |
| } |
| } |
| |
| /***/ }, |
| /* 103 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| |
| var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; /** |
| * @fileOverview event manager |
| */ |
| |
| exports.default = EventManager; |
| |
| var _util = __webpack_require__(81); |
| |
| var _ = _interopRequireWildcard(_util); |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function EventManager() { |
| this.els = []; |
| this.targets = []; |
| } |
| |
| EventManager.prototype._get = function (el, force) { |
| var index = _.indexOf(this.els, el); |
| var target; |
| if (index >= 0) { |
| target = this.targets[index]; |
| } else if (force) { |
| target = { el: el, events: {} }; |
| this.els.push(el); |
| this.targets.push(target); |
| } |
| return target; |
| }; |
| |
| EventManager.prototype.add = function (el, type, handler) { |
| if ((typeof el === 'undefined' ? 'undefined' : _typeof(el)) !== 'object' || !el || typeof type !== 'string' || !type || typeof handler !== 'function') { |
| return; |
| } |
| var target = this._get(el, true); |
| target.events[type] = handler; |
| }; |
| |
| EventManager.prototype.remove = function (el, type) { |
| if ((typeof el === 'undefined' ? 'undefined' : _typeof(el)) !== 'object' || !el || typeof type !== 'string' || !type) { |
| return; |
| } |
| var target = this._get(el); |
| if (target) { |
| delete target.events[type]; |
| } |
| }; |
| |
| EventManager.prototype.fire = function (el, type, e) { |
| var target = this._get(el); |
| var handler, el; |
| if (target) { |
| el = target.el; |
| handler = target.events[type]; |
| if (typeof handler === 'function') { |
| return handler.call(el, e); |
| } |
| } |
| }; |
| |
| /***/ }, |
| /* 104 */ |
| /***/ function(module, exports) { |
| |
| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.Document = Document; |
| exports.destroyDocument = destroyDocument; |
| exports.Node = Node; |
| exports.Element = Element; |
| exports.Comment = Comment; |
| /** |
| * @fileOverview |
| * A simple virtual dom implementation |
| */ |
| |
| var DEFAULT_TAG_NAME = 'div'; |
| |
| var instanceMap = exports.instanceMap = {}; |
| |
| function Document(id) { |
| id = id ? id.toString() : ''; |
| this.id = id; |
| this.nextRef = 1; |
| this.nodeMap = {}; |
| this.listener = null; |
| this.eventManager = null; |
| this.closed = false; |
| instanceMap[id] = this; |
| |
| this.createDocumentElement(); |
| } |
| |
| function destroyDocument(id) { |
| delete instanceMap[id]; |
| } |
| |
| Document.prototype.open = function () { |
| this.closed = false; |
| if (this.listener) { |
| this.listener.batched = false; |
| } |
| }; |
| Document.prototype.close = function () { |
| this.closed = true; |
| if (this.listener) { |
| this.listener.batched = true; |
| } |
| }; |
| |
| Document.prototype.setEventManager = function (eventManager) { |
| this.eventManager = eventManager; |
| }; |
| |
| Document.prototype.setListener = function (listener) { |
| this.listener = listener; |
| listener.batched = !!this.closed; |
| }; |
| |
| Document.prototype.addRef = function (el) { |
| el.ref = this.nextRef.toString(); |
| this.nodeMap[el.ref] = el; |
| this.nextRef++; |
| }; |
| |
| Document.prototype.getRef = function (ref) { |
| return this.nodeMap[ref]; |
| }; |
| |
| Document.prototype.removeRef = function (ref) { |
| delete this.nodeMap[ref]; |
| }; |
| |
| Document.prototype.createDocumentElement = function (type, props) { |
| if (!this.documentElement) { |
| this.documentElement = new Element(type, props, this); |
| this.nodeMap._documentElement = this.documentElement; |
| this.documentElement.ref = '_documentElement'; |
| this.documentElement.attached = true; |
| } |
| |
| return this.documentElement; |
| }; |
| |
| Document.prototype.createBody = function (type, props) { |
| if (!this.body) { |
| this.body = new Element(type, props, this); |
| this.nodeMap._root = this.body; |
| this.body.ref = '_root'; |
| this.body.depth = 1; |
| } |
| |
| return this.body; |
| }; |
| |
| Document.prototype.createElement = function (tagName, props) { |
| return new Element(tagName, props, this); |
| }; |
| |
| Document.prototype.createComment = function (text) { |
| return new Comment(text, this); |
| }; |
| |
| function Node() {} |
| |
| Node.prototype.create = function (instanceId) { |
| this.parentRef = null; |
| this.attached = false; |
| if (instanceId) { |
| this.instanceId = instanceId; |
| var doc = instanceMap[instanceId]; |
| doc.addRef(this); |
| } |
| }; |
| |
| Node.prototype.destroy = function () { |
| var ref = this.ref; |
| var instanceId = this.instanceId; |
| if (instanceId) { |
| var doc = instanceMap[instanceId]; |
| doc.removeRef(ref); |
| } |
| |
| var children = this.children || []; |
| var length = children.length; |
| for (var i = 0; i < length; i++) { |
| children[i].destroy(); |
| } |
| }; |
| |
| Node.prototype.getRenderer = function () { |
| var doc = instanceMap[this.instanceId]; |
| return doc.listener; |
| }; |
| |
| Node.prototype.next = function () { |
| var instanceId = this.instanceId; |
| var doc = instanceMap[instanceId]; |
| var parent = doc.getRef(this.parentRef); |
| if (parent) { |
| return parent.children[parent.children.indexOf(this) + 1]; |
| } |
| }; |
| |
| Node.prototype.prev = function () { |
| var instanceId = this.instanceId; |
| var doc = instanceMap[instanceId]; |
| var parent = doc.getRef(this.parentRef); |
| if (parent) { |
| return parent.children[parent.children.indexOf(this) - 1]; |
| } |
| }; |
| |
| function Element() { |
| var type = arguments.length <= 0 || arguments[0] === undefined ? DEFAULT_TAG_NAME : arguments[0]; |
| var props = arguments[1]; |
| var ownerDocument = arguments[2]; |
| |
| props = props || {}; |
| this.create(ownerDocument.id); |
| this.ownerDocument = ownerDocument; |
| this.type = type; |
| this.attr = props.attr || {}; |
| this.classStyle = props.classStyle || {}; |
| this.style = props.style || {}; |
| this.event = []; |
| this.children = []; |
| this.pureChildren = []; |
| } |
| |
| Element.prototype = new Node(); |
| |
| Element.prototype.appendChild = function (node) { |
| |
| removeIfExisted(node); |
| node.parentRef = this.ref; |
| this.children.push(node); |
| |
| if (this.attached) { |
| setAttached(node, this.depth); |
| } else { |
| setDetached(node); |
| } |
| |
| if (node instanceof Element) { |
| this.pureChildren.push(node); |
| |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| if (this.ref === '_documentElement') { |
| // if its parent is documentElement then it's a body |
| renderer.createBody(node, this.ref); |
| } else { |
| renderer.addElement(node, this.ref); |
| } |
| } |
| } |
| } |
| }; |
| |
| Element.prototype.insertBefore = function (node, before) { |
| |
| if (node.parentRef === this.ref) { |
| moveBefore(node, before, this.children); |
| if (node instanceof Element) { |
| var pureBeforeIndex = movePureBefore(node, before, this.pureChildren); |
| if (pureBeforeIndex >= 0 && this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.moveElement(node.ref, this.ref, pureBeforeIndex); |
| } |
| } |
| } |
| return; |
| } |
| |
| removeIfExisted(node); |
| |
| var children = this.children; |
| var index = children.indexOf(before); |
| |
| node.parentRef = this.ref; |
| if (this.attached) { |
| setAttached(node, this.depth); |
| } else { |
| setDetached(node); |
| } |
| children.splice(index, 0, node); |
| |
| if (node instanceof Element) { |
| var pureChildren = this.pureChildren; |
| var pureIndex = getPureAfter(before, pureChildren); |
| |
| pureChildren.splice(pureIndex, 0, node); |
| |
| if (this.attached) { |
| var _renderer = this.getRenderer(); |
| if (_renderer) { |
| _renderer.addElement(node, this.ref, pureIndex); |
| } |
| } |
| } |
| }; |
| |
| Element.prototype.insertAfter = function (node, after) { |
| |
| if (node.parentRef === this.ref) { |
| moveAfter(node, after, this.children); |
| if (node instanceof Element) { |
| var pureAfterIndex = movePureAfter(node, after, this.pureChildren); |
| if (pureAfterIndex >= 0 && this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.moveElement(node.ref, this.ref, pureAfterIndex); |
| } |
| } |
| } |
| return; |
| } |
| |
| removeIfExisted(node); |
| |
| var children = this.children; |
| var index = children.indexOf(after); |
| |
| node.parentRef = this.ref; |
| if (this.attached) { |
| setAttached(node, this.depth); |
| } else { |
| setDetached(node); |
| } |
| children.splice(index + 1, 0, node); |
| |
| if (node instanceof Element) { |
| var pureChildren = this.pureChildren; |
| var pureIndex = getPureBefore(after, pureChildren); |
| |
| pureChildren.splice(pureIndex + 1, 0, node); |
| |
| if (this.attached) { |
| var _renderer2 = this.getRenderer(); |
| if (_renderer2) { |
| _renderer2.addElement(node, this.ref, pureIndex + 1); |
| } |
| } |
| } |
| }; |
| |
| Element.prototype.removeChild = function (node, preserved) { |
| var children = this.children; |
| var index = children.indexOf(node); |
| |
| setDetached(node); |
| |
| if (index >= 0) { |
| node.parentRef = null; |
| children.splice(index, 1); |
| if (!preserved) { |
| node.destroy(); |
| } |
| } |
| |
| if (node instanceof Element) { |
| this.pureChildren.$remove(node); |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.removeElement(node.ref); |
| } |
| } |
| } |
| }; |
| |
| Element.prototype.clear = function () { |
| var children = this.children; |
| var length = children.length; |
| for (var i = 0; i < length; i++) { |
| var child = children[i]; |
| child.parentRef = null; |
| setDetached(child); |
| child.destroy(); |
| } |
| children.length = 0; |
| |
| if (this.attached) { |
| var refs = this.pureChildren.map(function (child) { |
| return child.ref; |
| }); |
| this.pureChildren.length = 0; |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.removeElement(refs); |
| } |
| } |
| }; |
| |
| function moveBefore(node, before, children) { |
| var targetIndex = children.indexOf(node); |
| var beforeIndex = children.indexOf(before); |
| |
| /* istanbul ignore next */ |
| if (targetIndex === beforeIndex || targetIndex + 1 === beforeIndex) { |
| return -1; |
| } |
| |
| var newIndex = targetIndex < beforeIndex ? beforeIndex - 1 : beforeIndex; |
| children.splice(targetIndex, 1); |
| children.splice(newIndex, 0, node); |
| |
| return beforeIndex; |
| } |
| |
| function movePureBefore(node, before, pureChildren) { |
| var pureTargetIndex = pureChildren.indexOf(node); |
| var pureBeforeIndex = getPureAfter(before, pureChildren); |
| |
| /* istanbul ignore next */ |
| if (pureTargetIndex === pureBeforeIndex || pureTargetIndex + 1 === pureBeforeIndex) { |
| return -1; |
| } |
| |
| var pureNewIndex = pureTargetIndex < pureBeforeIndex ? pureBeforeIndex - 1 : pureBeforeIndex; |
| |
| pureChildren.splice(pureTargetIndex, 1); |
| pureChildren.splice(pureNewIndex, 0, node); |
| |
| return pureBeforeIndex; |
| } |
| |
| function getPureAfter(node, pureChildren) { |
| var pureIndex = pureChildren.indexOf(node); |
| while (node && pureIndex < 0) { |
| node = node.next(); |
| pureIndex = pureChildren.indexOf(node); |
| } |
| if (pureIndex < 0) { |
| pureIndex = pureChildren.length; |
| } |
| return pureIndex; |
| } |
| |
| function moveAfter(node, after, children) { |
| var targetIndex = children.indexOf(node); |
| var afterIndex = children.indexOf(after); |
| |
| /* istanbul ignore next */ |
| if (targetIndex === afterIndex || targetIndex === afterIndex + 1) { |
| return -1; |
| } |
| |
| var newIndex = targetIndex < afterIndex ? afterIndex : afterIndex + 1; |
| children.splice(targetIndex, 1); |
| children.splice(newIndex, 0, node); |
| |
| return afterIndex; |
| } |
| |
| function movePureAfter(node, after, pureChildren) { |
| var pureTargetIndex = pureChildren.indexOf(node); |
| var pureAfterIndex = getPureBefore(after, pureChildren); |
| |
| /* istanbul ignore next */ |
| if (pureTargetIndex === pureAfterIndex || pureTargetIndex === pureAfterIndex + 1) { |
| return -1; |
| } |
| |
| var pureNewIndex = pureTargetIndex < pureAfterIndex ? pureAfterIndex : pureAfterIndex + 1; |
| |
| pureChildren.splice(pureTargetIndex, 1); |
| pureChildren.splice(pureNewIndex, 0, node); |
| |
| return pureAfterIndex + 1; |
| } |
| |
| function getPureBefore(node, pureChildren) { |
| var pureIndex = pureChildren.indexOf(node); |
| while (node && pureIndex < 0) { |
| node = node.prev(); |
| pureIndex = pureChildren.indexOf(node); |
| } |
| /* istanbul ignore next */ |
| if (pureIndex < 0) { |
| pureIndex = -1; |
| } |
| return pureIndex; |
| } |
| |
| function setAttached(node, depth) { |
| if (node.ref === '_root') { |
| depth = 1; |
| } else { |
| depth = depth > 0 ? depth + 1 : 0; |
| } |
| node.attached = true; |
| node.depth = depth; |
| if (node.children) { |
| node.children.forEach(function (sub) { |
| setAttached(sub, depth); |
| }); |
| } |
| } |
| |
| function setDetached(node) { |
| node.attached = false; |
| node.depth = 0; |
| if (node.children) { |
| node.children.forEach(function (sub) { |
| setDetached(sub); |
| }); |
| } |
| } |
| |
| function removeIfExisted(node) { |
| var doc = instanceMap[node.instanceId]; |
| if (doc) { |
| var existedNode = doc.getRef(node.ref); |
| if (existedNode) { |
| var existedParent = doc.getRef(existedNode.parentRef); |
| if (existedParent && existedParent.removeChild) { |
| existedParent.removeChild(existedNode, true); |
| } |
| } |
| } |
| } |
| |
| Element.prototype.setAttr = function (key, value) { |
| if (this.attr[key] === value) { |
| return; |
| } |
| this.attr[key] = value; |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.setAttr(this.ref, key, value); |
| } |
| } |
| }; |
| |
| Element.prototype.setStyle = function (key, value) { |
| if (this.style[key] === value) { |
| return; |
| } |
| this.style[key] = value; |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.setStyle(this.ref, key, value); |
| } |
| } |
| }; |
| |
| Element.prototype.setClassStyle = function (classStyle) { |
| this.classStyle = classStyle; |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.setStyles(this.ref, this.toStyle()); |
| } |
| } |
| }; |
| |
| Element.prototype.addEvent = function (type, handler) { |
| var index = this.event.indexOf(type); |
| |
| if (index < 0) { |
| this.event.push(type); |
| var eventManager = this.ownerDocument.eventManager; |
| eventManager.add(this, type, handler); |
| |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.addEvent(this.ref, type); |
| } |
| } |
| } |
| }; |
| |
| Element.prototype.removeEvent = function (type) { |
| var index = this.event.indexOf(type); |
| |
| if (index >= 0) { |
| this.event.splice(index, 1); |
| var eventManager = this.ownerDocument.eventManager; |
| eventManager.remove(this, type); |
| |
| if (this.attached) { |
| var renderer = this.getRenderer(); |
| if (renderer) { |
| renderer.removeEvent(this.ref, type); |
| } |
| } |
| } |
| }; |
| |
| Element.prototype.toStyle = function () { |
| var result = {}; |
| var classStyle = this.classStyle; |
| var style = this.style; |
| for (var name in classStyle) { |
| result[name] = classStyle[name]; |
| } |
| for (var _name in style) { |
| result[_name] = style[_name]; |
| } |
| return result; |
| }; |
| |
| Element.prototype.toJSON = function () { |
| var result = { |
| ref: this.ref.toString(), |
| type: this.type, |
| attr: this.attr, |
| style: this.toStyle() |
| }; |
| |
| if (this.event && this.event.length) { |
| result.event = this.event; |
| } |
| if (this.pureChildren && this.pureChildren.length) { |
| result.children = this.pureChildren.map(function (child) { |
| return child.toJSON(); |
| }); |
| } |
| |
| return result; |
| }; |
| |
| Element.prototype.toString = function () { |
| return '<' + this.type + ' attr=' + JSON.stringify(this.attr) + ' style=' + JSON.stringify(this.toStyle()) + '>' + this.pureChildren.map(function (child) { |
| return child.toString(); |
| }).join('') + '</' + this.type + '>'; |
| }; |
| |
| function Comment(value, ownerDocument) { |
| this.create(ownerDocument.id); |
| this.type = 'comment'; |
| this.value = value; |
| } |
| |
| Comment.prototype = new Node(); |
| |
| Comment.prototype.toString = function () { |
| return '<!-- ' + this.value + ' -->'; |
| }; |
| |
| /***/ }, |
| /* 105 */ |
| /***/ function(module, exports) { |
| |
| module.exports = { |
| "name": "weex-jsframework", |
| "version": "0.13.7", |
| "description": "JS Framework for Weex solution which is a extendable cross-platform solution for dynamic programming and publishing projects", |
| "main": "index.js", |
| "scripts": { |
| "dev": "webpack --watch --config ./webpack.config.js", |
| "build": "webpack --config ./webpack.config.js", |
| "compress": "uglifyjs dist/index.js -o dist/index.min.js", |
| "lint": "jscs --config .jscsrc polyfill/*.js polyfill/__test__/*.js lib/*.js lib/__test__/*.js lib/app/*.js lib/app/__test__/*.js lib/vm/*.js lib/vm/__test__/*.js", |
| "test": "mocha --compilers js:babel-core/register polyfill/__test__/*.js lib/__test__/*.js lib/**/__test__/*.js", |
| "cover": "babel-node node_modules/isparta/bin/isparta cover --report text node_modules/mocha/bin/_mocha -- --reporter dot lib/__test__/*.js lib/**/__test__/*.js", |
| "ci": "npm run lint && npm run cover" |
| }, |
| "repository": { |
| "type": "git", |
| "url": "git@github.com:alibaba/weex.git" |
| }, |
| "author": [ |
| { |
| "name": "jinjiang", |
| "email": "zhaojinjiang@me.com" |
| }, |
| { |
| "name": "Terry King", |
| "email": "terrykingcha@gmail.com" |
| } |
| ], |
| "contributors": [ |
| { |
| "name": "pushiming", |
| "email": "pushiming@gmail.com" |
| }, |
| { |
| "name": "iskenhuang", |
| "email": "iskenhuang@gmail.com" |
| }, |
| { |
| "name": "yuanyan", |
| "email": "yuanyan.cao@gmail.com" |
| } |
| ], |
| "keywords": [ |
| "weex", |
| "mvvm", |
| "browser", |
| "hybrid", |
| "framework" |
| ], |
| "license": "Apache-2.0", |
| "dependencies": { |
| "semver": "~5.1.0", |
| "core-js": "~2.1.1" |
| }, |
| "devDependencies": { |
| "babel-cli": "~6.4.5", |
| "babel-core": "~6.4.5", |
| "babel-loader": "~6.2.1", |
| "babel-preset-es2015": "~6.3.13", |
| "chai": "~3.2.0", |
| "isparta": "~4.0.0", |
| "istanbul": "~0.4.2", |
| "jscs": "~2.9.0", |
| "json-loader": "^0.5.4", |
| "mocha": "~2.3.4", |
| "sinon": "~1.17.2", |
| "sinon-chai": "~2.8.0", |
| "uglify-js": "^2.6.2", |
| "watch-cli": "~0.2.1", |
| "webpack": "~1.12.12" |
| }, |
| "optionalDependencies": { |
| "weex-transformer": "~0.3" |
| } |
| }; |
| |
| /***/ }, |
| /* 106 */ |
| /***/ function(module, exports, __webpack_require__) { |
| |
| /* WEBPACK VAR INJECTION */(function(global) {'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.$ = $; |
| exports.$el = $el; |
| exports.$vm = $vm; |
| exports.$renderThen = $renderThen; |
| exports.$scrollTo = $scrollTo; |
| exports.$transition = $transition; |
| exports.$getConfig = $getConfig; |
| exports.$sendHttp = $sendHttp; |
| exports.$openURL = $openURL; |
| exports.$setTitle = $setTitle; |
| exports.$call = $call; |
| |
| var _util = __webpack_require__(81); |
| |
| /** |
| * ========================================================== |
| * common |
| * ========================================================== |
| */ |
| |
| /** |
| * @deprecated use $vm instead |
| * find the vm by id |
| * Note: there is only one id in whole component |
| * @param {string} id |
| * @return {Vm} |
| */ |
| function $(id) { |
| nativeLog('[WARNING] the Vm#$ api is deprecated, please use Vm#$vm instead'); |
| var info = this._ids[id]; |
| if (info) { |
| return info.vm; |
| } |
| } |
| |
| /** |
| * find the element by id |
| * Note: there is only one id in whole component |
| * @param {string} id |
| * @return {Element} |
| */ |
| /** |
| * @fileOverview The api for invoking with "$" prefix |
| */ |
| function $el(id) { |
| var info = this._ids[id]; |
| if (info) { |
| return info.el; |
| } |
| } |
| |
| /** |
| * find the vm of the custom component by id |
| * Note: there is only one id in whole component |
| * @param {string} id |
| * @return {Vm} |
| */ |
| function $vm(id) { |
| var info = this._ids[id]; |
| if (info) { |
| return info.vm; |
| } |
| } |
| |
| /** |
| * Fire when differ rendering finished |
| * |
| * @param {Function} fn |
| */ |
| function $renderThen(fn) { |
| var app = this._app; |
| var differ = app.differ; |
| return differ.then(function () { |
| fn(); |
| }); |
| } |
| |
| /** |
| * scroll an element specified by id into view, |
| * moreover specify a number of offset optionally |
| * @param {string} id |
| * @param {number} offset |
| */ |
| function $scrollTo(id, offset) { |
| var el = this.$el(id); |
| if (el) { |
| var dom = this._app.requireModule('dom'); |
| dom.scrollToElement(el.ref, { offset: offset }); |
| } |
| } |
| |
| /** |
| * perform transition animation on an element specified by id |
| * @param {string} id |
| * @param {object} options |
| * @param {object} options.styles |
| * @param {object} options.duration(ms) |
| * @param {object} [options.timingFunction] |
| * @param {object} [options.delay=0(ms)] |
| * @param {Function} callback |
| */ |
| function $transition(id, options, callback) { |
| var _this = this; |
| |
| var el = this.$el(id); |
| if (el && options && options.styles) { |
| var animation = this._app.requireModule('animation'); |
| animation.transition(el.ref, options, function () { |
| _this._setStyle(el, options.styles); |
| callback && callback.apply(undefined, arguments); |
| }); |
| } |
| } |
| |
| /** |
| * get some config |
| * @return {object} some config for app instance |
| * @property {string} bundleUrl |
| * @property {boolean} debug |
| * @property {object} env |
| * @property {string} env.weexVersion(ex. 1.0.0) |
| * @property {string} env.appName(ex. TB/TM) |
| * @property {string} env.appVersion(ex. 5.0.0) |
| * @property {string} env.platform(ex. iOS/Android) |
| * @property {string} env.osVersion(ex. 7.0.0) |
| * @property {string} env.deviceModel **native only** |
| * @property {number} env.[deviceWidth=750] |
| * @property {number} env.deviceHeight |
| */ |
| function $getConfig(callback) { |
| var config = (0, _util.extend)({ |
| env: global.WXEnvironment || {} |
| }, this._app.options); |
| if ((0, _util.typof)(callback) === 'function') { |
| nativeLog('[WARNING] the callback of Vm#$getConfig(callback) is deprecated, ' + 'this api now can directly RETURN config info.'); |
| callback(config); |
| } |
| return config; |
| } |
| |
| /** |
| * request network via http protocol |
| * @param {object} params |
| * @param {Function} callback |
| */ |
| function $sendHttp(params, callback) { |
| var stream = this._app.requireModule('stream'); |
| stream.sendHttp(params, callback); |
| } |
| |
| /** |
| * open a url |
| * @param {string} url |
| */ |
| function $openURL(url) { |
| var event = this._app.requireModule('event'); |
| event.openURL(url); |
| } |
| |
| /** |
| * set a title for page |
| * @param {string} title |
| */ |
| function $setTitle(title) { |
| var pageInfo = this._app.requireModule('pageInfo'); |
| pageInfo.setTitle(title); |
| } |
| |
| /** |
| * invoke a native method by specifing the name of module and method |
| * @param {string} moduleName |
| * @param {string} methodName |
| * @param {...*} the rest arguments |
| */ |
| function $call(moduleName, methodName) { |
| var module = this._app.requireModule(moduleName); |
| if (module && module[methodName]) { |
| for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { |
| args[_key - 2] = arguments[_key]; |
| } |
| |
| module[methodName].apply(module, args); |
| } |
| } |
| /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
| |
| /***/ } |
| /******/ ]); |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["webpack:///webpack/bootstrap 4a920ef927070895eb02","webpack:///./index.js","webpack:///./polyfill/index.js","webpack:///./polyfill/objectAssign.js","webpack:///./~/core-js/fn/object/assign.js","webpack:///./~/core-js/modules/es6.object.assign.js","webpack:///./~/core-js/modules/_export.js","webpack:///./~/core-js/modules/_global.js","webpack:///./~/core-js/modules/_core.js","webpack:///./~/core-js/modules/_hide.js","webpack:///./~/core-js/modules/_object-dp.js","webpack:///./~/core-js/modules/_an-object.js","webpack:///./~/core-js/modules/_is-object.js","webpack:///./~/core-js/modules/_ie8-dom-define.js","webpack:///./~/core-js/modules/_descriptors.js","webpack:///./~/core-js/modules/_fails.js","webpack:///./~/core-js/modules/_dom-create.js","webpack:///./~/core-js/modules/_to-primitive.js","webpack:///./~/core-js/modules/_property-desc.js","webpack:///./~/core-js/modules/_redefine.js","webpack:///./~/core-js/modules/_has.js","webpack:///./~/core-js/modules/_uid.js","webpack:///./~/core-js/modules/_ctx.js","webpack:///./~/core-js/modules/_a-function.js","webpack:///./~/core-js/modules/_object-assign.js","webpack:///./~/core-js/modules/_object-keys.js","webpack:///./~/core-js/modules/_object-keys-internal.js","webpack:///./~/core-js/modules/_to-iobject.js","webpack:///./~/core-js/modules/_iobject.js","webpack:///./~/core-js/modules/_cof.js","webpack:///./~/core-js/modules/_defined.js","webpack:///./~/core-js/modules/_array-includes.js","webpack:///./~/core-js/modules/_to-length.js","webpack:///./~/core-js/modules/_to-integer.js","webpack:///./~/core-js/modules/_to-index.js","webpack:///./~/core-js/modules/_shared-key.js","webpack:///./~/core-js/modules/_shared.js","webpack:///./~/core-js/modules/_enum-bug-keys.js","webpack:///./~/core-js/modules/_object-gops.js","webpack:///./~/core-js/modules/_object-pie.js","webpack:///./~/core-js/modules/_to-object.js","webpack:///./polyfill/promise.js","webpack:///./~/core-js/modules/es6.object.to-string.js","webpack:///./~/core-js/modules/_classof.js","webpack:///./~/core-js/modules/_wks.js","webpack:///./~/core-js/modules/es6.string.iterator.js","webpack:///./~/core-js/modules/_string-at.js","webpack:///./~/core-js/modules/_iter-define.js","webpack:///./~/core-js/modules/_library.js","webpack:///./~/core-js/modules/_iterators.js","webpack:///./~/core-js/modules/_iter-create.js","webpack:///./~/core-js/modules/_object-create.js","webpack:///./~/core-js/modules/_object-dps.js","webpack:///./~/core-js/modules/_html.js","webpack:///./~/core-js/modules/_set-to-string-tag.js","webpack:///./~/core-js/modules/_object-gpo.js","webpack:///./~/core-js/modules/web.dom.iterable.js","webpack:///./~/core-js/modules/es6.array.iterator.js","webpack:///./~/core-js/modules/_add-to-unscopables.js","webpack:///./~/core-js/modules/_iter-step.js","webpack:///./~/core-js/modules/es6.promise.js","webpack:///./~/core-js/modules/_an-instance.js","webpack:///./~/core-js/modules/_for-of.js","webpack:///./~/core-js/modules/_iter-call.js","webpack:///./~/core-js/modules/_is-array-iter.js","webpack:///./~/core-js/modules/core.get-iterator-method.js","webpack:///./~/core-js/modules/_set-proto.js","webpack:///./~/core-js/modules/_object-gopd.js","webpack:///./~/core-js/modules/_species-constructor.js","webpack:///./~/core-js/modules/_task.js","webpack:///./~/core-js/modules/_invoke.js","webpack:///./~/core-js/modules/_microtask.js","webpack:///./~/core-js/modules/_redefine-all.js","webpack:///./~/core-js/modules/_set-species.js","webpack:///./~/core-js/modules/_iter-detect.js","webpack:///./polyfill/setTimeout.js","webpack:///./polyfill/consolelog.js","webpack:///./lib/framework.js","webpack:///./lib/perf.js","webpack:///./lib/log.js","webpack:///./lib/config.js","webpack:///./lib/app/index.js","webpack:///./lib/util/index.js","webpack:///./lib/app/bundle.js","webpack:///./~/semver/semver.js","webpack:///./~/process/browser.js","webpack:///./lib/vm/index.js","webpack:///./lib/vm/instance/scope.js","webpack:///./lib/vm/util.js","webpack:///./lib/vm/observer/index.js","webpack:///./lib/vm/config.js","webpack:///./lib/vm/observer/dep.js","webpack:///./lib/vm/observer/array.js","webpack:///./lib/vm/observer/object.js","webpack:///./lib/vm/compiler.js","webpack:///./lib/vm/directive.js","webpack:///./lib/vm/watcher.js","webpack:///./lib/vm/dom-helper.js","webpack:///./lib/vm/events.js","webpack:///./lib/app/register.js","webpack:///./lib/app/downgrade.js","webpack:///./lib/app/ctrl.js","webpack:///./lib/app/dom-listener.js","webpack:///./lib/app/differ.js","webpack:///./lib/app/event.js","webpack:///./lib/app/dom.js","webpack:///./package.json","webpack:///./lib/api/methods.js"],"names":[],"mappings":"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","file":"index.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 4a920ef927070895eb02\n **/","import './polyfill'\nimport * as framework from './lib/framework'\nimport {version, optionalDependencies} from './package.json'\n\nfor (let methodName in framework) {\n    global[methodName] = function (...args) {\n        const ret = framework[methodName](...args)\n        if (ret instanceof Error) {\n            console.error(ret.toString())\n        } else if (ret instanceof Array) {\n            ret.forEach(r => {\n                if (r instanceof Error) {\n                    console.error(r.toString())\n                }\n            })\n        }\n        return ret\n    }\n}\n\nObject.assign(global, {\n    frameworkVersion: version,\n    needTransformerVersion: optionalDependencies['weex-transformer']\n})\n\n/**\n * register methods\n */\nconst methods = require('./lib/api/methods')\nconst {registerMethods} = global\nregisterMethods(methods)\n\n\n\n/** WEBPACK FOOTER **\n ** ./index.js\n **/","import './objectAssign'\nimport './promise'\nimport './setTimeout'\nimport './consolelog'\n\n\n\n/** WEBPACK FOOTER **\n ** ./polyfill/index.js\n **/","import 'core-js/fn/object/assign'\n\n\n\n/** WEBPACK FOOTER **\n ** ./polyfill/objectAssign.js\n **/","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/fn/object/assign.js\n **/","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', {assign: require('./_object-assign')});\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/es6.object.assign.js\n **/","var global    = require('./_global')\n  , core      = require('./_core')\n  , hide      = require('./_hide')\n  , redefine  = require('./_redefine')\n  , ctx       = require('./_ctx')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})\n    , key, own, out, exp;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    // export native or passed\n    out = (own ? target : source)[key];\n    // bind timers to global for call from export context\n    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // extend global\n    if(target)redefine(target, key, out, type & $export.U);\n    // export\n    if(exports[key] != out)hide(exports, key, exp);\n    if(IS_PROTO && expProto[key] != out)expProto[key] = out;\n  }\n};\nglobal.core = core;\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_export.js\n **/","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_global.js\n **/","var core = module.exports = {version: '2.1.5'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_core.js\n **/","var dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_hide.js\n **/","var anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-dp.js\n **/","var isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_an-object.js\n **/","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_is-object.js\n **/","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\r\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\r\n});\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_ie8-dom-define.js\n **/","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_descriptors.js\n **/","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_fails.js\n **/","var isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_dom-create.js\n **/","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_to-primitive.js\n **/","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_property-desc.js\n **/","var global    = require('./_global')\n  , hide      = require('./_hide')\n  , has       = require('./_has')\n  , SRC       = require('./_uid')('src')\n  , TO_STRING = 'toString'\n  , $toString = Function[TO_STRING]\n  , TPL       = ('' + $toString).split(TO_STRING);\n\nrequire('./_core').inspectSource = function(it){\n  return $toString.call(it);\n};\n\n(module.exports = function(O, key, val, safe){\n  var isFunction = typeof val == 'function';\n  if(isFunction)has(val, 'name') || hide(val, 'name', key);\n  if(O[key] === val)return;\n  if(isFunction)has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));\n  if(O === global){\n    O[key] = val;\n  } else {\n    if(!safe){\n      delete O[key];\n      hide(O, key, val);\n    } else {\n      if(O[key])O[key] = val;\n      else hide(O, key, val);\n    }\n  }\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, TO_STRING, function toString(){\n  return typeof this == 'function' && this[SRC] || $toString.call(this);\n});\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_redefine.js\n **/","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_has.js\n **/","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_uid.js\n **/","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_ctx.js\n **/","module.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_a-function.js\n **/","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys  = require('./_object-keys')\n  , gOPS     = require('./_object-gops')\n  , pIE      = require('./_object-pie')\n  , toObject = require('./_to-object')\n  , IObject  = require('./_iobject')\n  , $assign  = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function(){\n  var A = {}\n    , B = {}\n    , S = Symbol()\n    , K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function(k){ B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source){ // eslint-disable-line no-unused-vars\n  var T     = toObject(target)\n    , aLen  = arguments.length\n    , index = 1\n    , getSymbols = gOPS.f\n    , isEnum     = pIE.f;\n  while(aLen > index){\n    var S      = IObject(arguments[index++])\n      , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)\n      , length = keys.length\n      , j      = 0\n      , key;\n    while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];\n  } return T;\n} : $assign;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-assign.js\n **/","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\r\nvar $keys       = require('./_object-keys-internal')\r\n  , enumBugKeys = require('./_enum-bug-keys');\r\n\r\nmodule.exports = Object.keys || function keys(O){\r\n  return $keys(O, enumBugKeys);\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-keys.js\n **/","var has          = require('./_has')\r\n  , toIObject    = require('./_to-iobject')\r\n  , arrayIndexOf = require('./_array-includes')(false)\r\n  , IE_PROTO     = require('./_shared-key')('IE_PROTO');\r\n\r\nmodule.exports = function(object, names){\r\n  var O      = toIObject(object)\r\n    , i      = 0\r\n    , result = []\r\n    , key;\r\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\r\n  // Don't enum bug & hidden keys\r\n  while(names.length > i)if(has(O, key = names[i++])){\r\n    ~arrayIndexOf(result, key) || result.push(key);\r\n  }\r\n  return result;\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-keys-internal.js\n **/","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n  , defined = require('./_defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_to-iobject.js\n **/","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iobject.js\n **/","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_cof.js\n **/","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_defined.js\n **/","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject')\n  , toLength  = require('./_to-length')\n  , toIndex   = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n  return function($this, el, fromIndex){\n    var O      = toIObject($this)\n      , length = toLength(O.length)\n      , index  = toIndex(fromIndex, length)\n      , value;\n    // Array#includes uses SameValueZero equality algorithm\n    if(IS_INCLUDES && el != el)while(length > index){\n      value = O[index++];\n      if(value != value)return true;\n    // Array#toIndex ignores holes, Array#includes - not\n    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n      if(O[index] === el)return IS_INCLUDES || index;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_array-includes.js\n **/","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_to-length.js\n **/","// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_to-integer.js\n **/","var toInteger = require('./_to-integer')\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_to-index.js\n **/","var shared = require('./_shared')('keys')\r\n  , uid    = require('./_uid');\r\nmodule.exports = function(key){\r\n  return shared[key] || (shared[key] = uid(key));\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_shared-key.js\n **/","var global = require('./_global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_shared.js\n **/","// IE 8- don't enum bug keys\r\nmodule.exports = (\r\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\r\n).split(',');\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_enum-bug-keys.js\n **/","exports.f = Object.getOwnPropertySymbols;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-gops.js\n **/","exports.f = {}.propertyIsEnumerable;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-pie.js\n **/","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_to-object.js\n **/","// fix Promise Problem on JSContext of iOS7~8\n// @see https://bugs.webkit.org/show_bug.cgi?id=135866\nglobal.Promise = null\nrequire('core-js/modules/es6.object.to-string')\nrequire('core-js/modules/es6.string.iterator')\nrequire('core-js/modules/web.dom.iterable')\nrequire('core-js/modules/es6.promise')\n\n\n/** WEBPACK FOOTER **\n ** ./polyfill/promise.js\n **/","'use strict';\n// 19.1.3.6 Object.prototype.toString()\nvar classof = require('./_classof')\n  , test    = {};\ntest[require('./_wks')('toStringTag')] = 'z';\nif(test + '' != '[object z]'){\n  require('./_redefine')(Object.prototype, 'toString', function toString(){\n    return '[object ' + classof(this) + ']';\n  }, true);\n}\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/es6.object.to-string.js\n **/","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n  , TAG = require('./_wks')('toStringTag')\n  // ES3 wrong here\n  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n  try {\n    return it[key];\n  } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_classof.js\n **/","var store      = require('./_shared')('wks')\n  , uid        = require('./_uid')\n  , Symbol     = require('./_global').Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\nmodule.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_wks.js\n **/","'use strict';\nvar $at  = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , index = this._i\n    , point;\n  if(index >= O.length)return {value: undefined, done: true};\n  point = $at(O, index);\n  this._i += point.length;\n  return {value: point, done: false};\n});\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/es6.string.iterator.js\n **/","var toInteger = require('./_to-integer')\n  , defined   = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_string-at.js\n **/","'use strict';\nvar LIBRARY        = require('./_library')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , hide           = require('./_hide')\n  , has            = require('./_has')\n  , Iterators      = require('./_iterators')\n  , $iterCreate    = require('./_iter-create')\n  , setToStringTag = require('./_set-to-string-tag')\n  , getPrototypeOf = require('./_object-gpo')\n  , ITERATOR       = require('./_wks')('iterator')\n  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n  , FF_ITERATOR    = '@@iterator'\n  , KEYS           = 'keys'\n  , VALUES         = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function(kind){\n    if(!BUGGY && kind in proto)return proto[kind];\n    switch(kind){\n      case KEYS: return function keys(){ return new Constructor(this, kind); };\n      case VALUES: return function values(){ return new Constructor(this, kind); };\n    } return function entries(){ return new Constructor(this, kind); };\n  };\n  var TAG        = NAME + ' Iterator'\n    , DEF_VALUES = DEFAULT == VALUES\n    , VALUES_BUG = false\n    , proto      = Base.prototype\n    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n    , $default   = $native || getMethod(DEFAULT)\n    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n    , methods, key, IteratorPrototype;\n  // Fix native\n  if($anyNative){\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n    if(IteratorPrototype !== Object.prototype){\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if(DEF_VALUES && $native && $native.name !== VALUES){\n    VALUES_BUG = true;\n    $default = function values(){ return $native.call(this); };\n  }\n  // Define iterator\n  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG]  = returnThis;\n  if(DEFAULT){\n    methods = {\n      values:  DEF_VALUES ? $default : getMethod(VALUES),\n      keys:    IS_SET     ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if(FORCED)for(key in methods){\n      if(!(key in proto))redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iter-define.js\n **/","module.exports = false;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_library.js\n **/","module.exports = {};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iterators.js\n **/","'use strict';\nvar create         = require('./_object-create')\n  , descriptor     = require('./_property-desc')\n  , setToStringTag = require('./_set-to-string-tag')\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iter-create.js\n **/","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\r\nvar anObject    = require('./_an-object')\r\n  , dPs         = require('./_object-dps')\r\n  , enumBugKeys = require('./_enum-bug-keys')\r\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\r\n  , Empty       = function(){ /* empty */ }\r\n  , PROTOTYPE   = 'prototype';\r\n\r\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\r\nvar createDict = function(){\r\n  // Thrash, waste and sodomy: IE GC bug\r\n  var iframe = require('./_dom-create')('iframe')\r\n    , i      = enumBugKeys.length\r\n    , gt     = '>'\r\n    , iframeDocument;\r\n  iframe.style.display = 'none';\r\n  require('./_html').appendChild(iframe);\r\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\r\n  // createDict = iframe.contentWindow.Object;\r\n  // html.removeChild(iframe);\r\n  iframeDocument = iframe.contentWindow.document;\r\n  iframeDocument.open();\r\n  iframeDocument.write('<script>document.F=Object</script' + gt);\r\n  iframeDocument.close();\r\n  createDict = iframeDocument.F;\r\n  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\r\n  return createDict();\r\n};\r\n\r\nmodule.exports = Object.create || function create(O, Properties){\r\n  var result;\r\n  if(O !== null){\r\n    Empty[PROTOTYPE] = anObject(O);\r\n    result = new Empty;\r\n    Empty[PROTOTYPE] = null;\r\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\r\n    result[IE_PROTO] = O;\r\n  } else result = createDict();\r\n  return Properties === undefined ? result : dPs(result, Properties);\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-create.js\n **/","var dP       = require('./_object-dp')\r\n  , anObject = require('./_an-object')\r\n  , getKeys  = require('./_object-keys');\r\n\r\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\r\n  anObject(O);\r\n  var keys   = getKeys(Properties)\r\n    , length = keys.length\r\n    , i = 0\r\n    , P;\r\n  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\r\n  return O;\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-dps.js\n **/","module.exports = require('./_global').document && document.documentElement;\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_html.js\n **/","var def = require('./_object-dp').f\n  , has = require('./_has')\n  , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_set-to-string-tag.js\n **/","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\r\nvar has         = require('./_has')\r\n  , toObject    = require('./_to-object')\r\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\r\n  , ObjectProto = Object.prototype;\r\n\r\nmodule.exports = Object.getPrototypeOf || function(O){\r\n  O = toObject(O);\r\n  if(has(O, IE_PROTO))return O[IE_PROTO];\r\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\r\n    return O.constructor.prototype;\r\n  } return O instanceof Object ? ObjectProto : null;\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-gpo.js\n **/","var $iterators    = require('./es6.array.iterator')\n  , redefine      = require('./_redefine')\n  , global        = require('./_global')\n  , hide          = require('./_hide')\n  , Iterators     = require('./_iterators')\n  , wks           = require('./_wks')\n  , ITERATOR      = wks('iterator')\n  , TO_STRING_TAG = wks('toStringTag')\n  , ArrayValues   = Iterators.Array;\n\nfor(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){\n  var NAME       = collections[i]\n    , Collection = global[NAME]\n    , proto      = Collection && Collection.prototype\n    , key;\n  if(proto){\n    if(!proto[ITERATOR])hide(proto, ITERATOR, ArrayValues);\n    if(!proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);\n    Iterators[NAME] = ArrayValues;\n    for(key in $iterators)if(!proto[key])redefine(proto, key, $iterators[key], true);\n  }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/web.dom.iterable.js\n **/","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables')\n  , step             = require('./_iter-step')\n  , Iterators        = require('./_iterators')\n  , toIObject        = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , kind  = this._k\n    , index = this._i++;\n  if(!O || index >= O.length){\n    this._t = undefined;\n    return step(1);\n  }\n  if(kind == 'keys'  )return step(0, index);\n  if(kind == 'values')return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/es6.array.iterator.js\n **/","// 22.1.3.31 Array.prototype[@@unscopables]\nvar UNSCOPABLES = require('./_wks')('unscopables')\n  , ArrayProto  = Array.prototype;\nif(ArrayProto[UNSCOPABLES] == undefined)require('./_hide')(ArrayProto, UNSCOPABLES, {});\nmodule.exports = function(key){\n  ArrayProto[UNSCOPABLES][key] = true;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_add-to-unscopables.js\n **/","module.exports = function(done, value){\n  return {value: value, done: !!done};\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iter-step.js\n **/","'use strict';\nvar LIBRARY            = require('./_library')\n  , global             = require('./_global')\n  , ctx                = require('./_ctx')\n  , classof            = require('./_classof')\n  , $export            = require('./_export')\n  , isObject           = require('./_is-object')\n  , anObject           = require('./_an-object')\n  , aFunction          = require('./_a-function')\n  , anInstance         = require('./_an-instance')\n  , forOf              = require('./_for-of')\n  , setProto           = require('./_set-proto').set\n  , speciesConstructor = require('./_species-constructor')\n  , task               = require('./_task').set\n  , microtask          = require('./_microtask')\n  , PROMISE            = 'Promise'\n  , TypeError          = global.TypeError\n  , process            = global.process\n  , $Promise           = global[PROMISE]\n  , process            = global.process\n  , isNode             = classof(process) == 'process'\n  , empty              = function(){ /* empty */ }\n  , Internal, GenericPromiseCapability, Wrapper;\n\nvar USE_NATIVE = !!function(){\n  try {\n    // correct subclassing with @@species support\n    var promise     = $Promise.resolve(1)\n      , FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function(exec){ exec(empty, empty); };\n    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;\n  } catch(e){ /* empty */ }\n}();\n\n// helpers\nvar sameConstructor = function(a, b){\n  // with library wrapper special case\n  return a === b || a === $Promise && b === Wrapper;\n};\nvar isThenable = function(it){\n  var then;\n  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\nvar newPromiseCapability = function(C){\n  return sameConstructor($Promise, C)\n    ? new PromiseCapability(C)\n    : new GenericPromiseCapability(C);\n};\nvar PromiseCapability = GenericPromiseCapability = function(C){\n  var resolve, reject;\n  this.promise = new C(function($$resolve, $$reject){\n    if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject  = $$reject;\n  });\n  this.resolve = aFunction(resolve);\n  this.reject  = aFunction(reject);\n};\nvar perform = function(exec){\n  try {\n    exec();\n  } catch(e){\n    return {error: e};\n  }\n};\nvar notify = function(promise, isReject){\n  if(promise._n)return;\n  promise._n = true;\n  var chain = promise._c;\n  microtask(function(){\n    var value = promise._v\n      , ok    = promise._s == 1\n      , i     = 0;\n    var run = function(reaction){\n      var handler = ok ? reaction.ok : reaction.fail\n        , resolve = reaction.resolve\n        , reject  = reaction.reject\n        , domain  = reaction.domain\n        , result, then;\n      try {\n        if(handler){\n          if(!ok){\n            if(promise._h == 2)onHandleUnhandled(promise);\n            promise._h = 1;\n          }\n          if(handler === true)result = value;\n          else {\n            if(domain)domain.enter();\n            result = handler(value);\n            if(domain)domain.exit();\n          }\n          if(result === reaction.promise){\n            reject(TypeError('Promise-chain cycle'));\n          } else if(then = isThenable(result)){\n            then.call(result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch(e){\n        reject(e);\n      }\n    };\n    while(chain.length > i)run(chain[i++]); // variable length - can't use forEach\n    promise._c = [];\n    promise._n = false;\n    if(isReject && !promise._h)onUnhandled(promise);\n  });\n};\nvar onUnhandled = function(promise){\n  task.call(global, function(){\n    var value = promise._v\n      , abrupt, handler, console;\n    if(isUnhandled(promise)){\n      abrupt = perform(function(){\n        if(isNode){\n          process.emit('unhandledRejection', value, promise);\n        } else if(handler = global.onunhandledrejection){\n          handler({promise: promise, reason: value});\n        } else if((console = global.console) && console.error){\n          console.error('Unhandled promise rejection', value);\n        }\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      promise._h = isNode || isUnhandled(promise) ? 2 : 1;\n    } promise._a = undefined;\n    if(abrupt)throw abrupt.error;\n  });\n};\nvar isUnhandled = function(promise){\n  if(promise._h == 1)return false;\n  var chain = promise._a || promise._c\n    , i     = 0\n    , reaction;\n  while(chain.length > i){\n    reaction = chain[i++];\n    if(reaction.fail || !isUnhandled(reaction.promise))return false;\n  } return true;\n};\nvar onHandleUnhandled = function(promise){\n  task.call(global, function(){\n    var handler;\n    if(isNode){\n      process.emit('rejectionHandled', promise);\n    } else if(handler = global.onrejectionhandled){\n      handler({promise: promise, reason: promise._v});\n    }\n  });\n};\nvar $reject = function(value){\n  var promise = this;\n  if(promise._d)return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  promise._v = value;\n  promise._s = 2;\n  if(!promise._a)promise._a = promise._c.slice();\n  notify(promise, true);\n};\nvar $resolve = function(value){\n  var promise = this\n    , then;\n  if(promise._d)return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  try {\n    if(promise === value)throw TypeError(\"Promise can't be resolved itself\");\n    if(then = isThenable(value)){\n      microtask(function(){\n        var wrapper = {_w: promise, _d: false}; // wrap\n        try {\n          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));\n        } catch(e){\n          $reject.call(wrapper, e);\n        }\n      });\n    } else {\n      promise._v = value;\n      promise._s = 1;\n      notify(promise, false);\n    }\n  } catch(e){\n    $reject.call({_w: promise, _d: false}, e); // wrap\n  }\n};\n\n// constructor polyfill\nif(!USE_NATIVE){\n  // 25.4.3.1 Promise(executor)\n  $Promise = function Promise(executor){\n    anInstance(this, $Promise, PROMISE, '_h');\n    aFunction(executor);\n    Internal.call(this);\n    try {\n      executor(ctx($resolve, this, 1), ctx($reject, this, 1));\n    } catch(err){\n      $reject.call(this, err);\n    }\n  };\n  Internal = function Promise(executor){\n    this._c = [];             // <- awaiting reactions\n    this._a = undefined;      // <- checked in isUnhandled reactions\n    this._s = 0;              // <- state\n    this._d = false;          // <- done\n    this._v = undefined;      // <- value\n    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n    this._n = false;          // <- notify\n  };\n  Internal.prototype = require('./_redefine-all')($Promise.prototype, {\n    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n    then: function then(onFulfilled, onRejected){\n      var reaction    = newPromiseCapability(speciesConstructor(this, $Promise));\n      reaction.ok     = typeof onFulfilled == 'function' ? onFulfilled : true;\n      reaction.fail   = typeof onRejected == 'function' && onRejected;\n      reaction.domain = isNode ? process.domain : undefined;\n      this._c.push(reaction);\n      if(this._a)this._a.push(reaction);\n      if(this._s)notify(this, false);\n      return reaction.promise;\n    },\n    // 25.4.5.1 Promise.prototype.catch(onRejected)\n    'catch': function(onRejected){\n      return this.then(undefined, onRejected);\n    }\n  });\n  PromiseCapability = function(){\n    var promise  = new Internal;\n    this.promise = promise;\n    this.resolve = ctx($resolve, promise, 1);\n    this.reject  = ctx($reject, promise, 1);\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});\nrequire('./_set-to-string-tag')($Promise, PROMISE);\nrequire('./_set-species')(PROMISE);\nWrapper = require('./_core')[PROMISE];\n\n// statics\n$export($export.S + $export.F * !USE_NATIVE, PROMISE, {\n  // 25.4.4.5 Promise.reject(r)\n  reject: function reject(r){\n    var capability = newPromiseCapability(this)\n      , $$reject   = capability.reject;\n    $$reject(r);\n    return capability.promise;\n  }\n});\n$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {\n  // 25.4.4.6 Promise.resolve(x)\n  resolve: function resolve(x){\n    // instanceof instead of internal slot check because we should fix it without replacement native Promise core\n    if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;\n    var capability = newPromiseCapability(this)\n      , $$resolve  = capability.resolve;\n    $$resolve(x);\n    return capability.promise;\n  }\n});\n$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function(iter){\n  $Promise.all(iter)['catch'](empty);\n})), PROMISE, {\n  // 25.4.4.1 Promise.all(iterable)\n  all: function all(iterable){\n    var C          = this\n      , capability = newPromiseCapability(C)\n      , resolve    = capability.resolve\n      , reject     = capability.reject;\n    var abrupt = perform(function(){\n      var values    = []\n        , index     = 0\n        , remaining = 1;\n      forOf(iterable, false, function(promise){\n        var $index        = index++\n          , alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        C.resolve(promise).then(function(value){\n          if(alreadyCalled)return;\n          alreadyCalled  = true;\n          values[$index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if(abrupt)reject(abrupt.error);\n    return capability.promise;\n  },\n  // 25.4.4.4 Promise.race(iterable)\n  race: function race(iterable){\n    var C          = this\n      , capability = newPromiseCapability(C)\n      , reject     = capability.reject;\n    var abrupt = perform(function(){\n      forOf(iterable, false, function(promise){\n        C.resolve(promise).then(capability.resolve, reject);\n      });\n    });\n    if(abrupt)reject(abrupt.error);\n    return capability.promise;\n  }\n});\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/es6.promise.js\n **/","module.exports = function(it, Constructor, name, forbiddenField){\n  if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){\n    throw TypeError(name + ': incorrect invocation!');\n  } return it;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_an-instance.js\n **/","var ctx         = require('./_ctx')\n  , call        = require('./_iter-call')\n  , isArrayIter = require('./_is-array-iter')\n  , anObject    = require('./_an-object')\n  , toLength    = require('./_to-length')\n  , getIterFn   = require('./core.get-iterator-method');\nmodule.exports = function(iterable, entries, fn, that, ITERATOR){\n  var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)\n    , f      = ctx(fn, that, entries ? 2 : 1)\n    , index  = 0\n    , length, step, iterator;\n  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');\n  // fast case for arrays with default iterator\n  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){\n    entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){\n    call(iterator, f, step.value, entries);\n  }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_for-of.js\n **/","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function(iterator, fn, value, entries){\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch(e){\n    var ret = iterator['return'];\n    if(ret !== undefined)anObject(ret.call(iterator));\n    throw e;\n  }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iter-call.js\n **/","// check on default Array iterator\nvar Iterators  = require('./_iterators')\n  , ITERATOR   = require('./_wks')('iterator')\n  , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_is-array-iter.js\n **/","var classof   = require('./_classof')\n  , ITERATOR  = require('./_wks')('iterator')\n  , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/core.get-iterator-method.js\n **/","// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = require('./_is-object')\n  , anObject = require('./_an-object');\nvar check = function(O, proto){\n  anObject(O);\n  if(!isObject(proto) && proto !== null)throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function(test, buggy, set){\n      try {\n        set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch(e){ buggy = true; }\n      return function setPrototypeOf(O, proto){\n        check(O, proto);\n        if(buggy)O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_set-proto.js\n **/","var pIE            = require('./_object-pie')\r\n  , createDesc     = require('./_property-desc')\r\n  , toIObject      = require('./_to-iobject')\r\n  , toPrimitive    = require('./_to-primitive')\r\n  , has            = require('./_has')\r\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\r\n  , gOPD           = Object.getOwnPropertyDescriptor;\r\n\r\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P){\r\n  O = toIObject(O);\r\n  P = toPrimitive(P, true);\r\n  if(IE8_DOM_DEFINE)try {\r\n    return gOPD(O, P);\r\n  } catch(e){ /* empty */ }\r\n  if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_object-gopd.js\n **/","// 7.3.20 SpeciesConstructor(O, defaultConstructor)\nvar anObject  = require('./_an-object')\n  , aFunction = require('./_a-function')\n  , SPECIES   = require('./_wks')('species');\nmodule.exports = function(O, D){\n  var C = anObject(O).constructor, S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_species-constructor.js\n **/","var ctx                = require('./_ctx')\n  , invoke             = require('./_invoke')\n  , html               = require('./_html')\n  , cel                = require('./_dom-create')\n  , global             = require('./_global')\n  , process            = global.process\n  , setTask            = global.setImmediate\n  , clearTask          = global.clearImmediate\n  , MessageChannel     = global.MessageChannel\n  , counter            = 0\n  , queue              = {}\n  , ONREADYSTATECHANGE = 'onreadystatechange'\n  , defer, channel, port;\nvar run = function(){\n  var id = +this;\n  if(queue.hasOwnProperty(id)){\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\nvar listener = function(event){\n  run.call(event.data);\n};\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif(!setTask || !clearTask){\n  setTask = function setImmediate(fn){\n    var args = [], i = 1;\n    while(arguments.length > i)args.push(arguments[i++]);\n    queue[++counter] = function(){\n      invoke(typeof fn == 'function' ? fn : Function(fn), args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clearTask = function clearImmediate(id){\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if(require('./_cof')(process) == 'process'){\n    defer = function(id){\n      process.nextTick(ctx(run, id, 1));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  } else if(MessageChannel){\n    channel = new MessageChannel;\n    port    = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = ctx(port.postMessage, port, 1);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){\n    defer = function(id){\n      global.postMessage(id + '', '*');\n    };\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if(ONREADYSTATECHANGE in cel('script')){\n    defer = function(id){\n      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){\n        html.removeChild(this);\n        run.call(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function(id){\n      setTimeout(ctx(run, id, 1), 0);\n    };\n  }\n}\nmodule.exports = {\n  set:   setTask,\n  clear: clearTask\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_task.js\n **/","// fast apply, http://jsperf.lnkit.com/fast-apply/5\nmodule.exports = function(fn, args, that){\n  var un = that === undefined;\n  switch(args.length){\n    case 0: return un ? fn()\n                      : fn.call(that);\n    case 1: return un ? fn(args[0])\n                      : fn.call(that, args[0]);\n    case 2: return un ? fn(args[0], args[1])\n                      : fn.call(that, args[0], args[1]);\n    case 3: return un ? fn(args[0], args[1], args[2])\n                      : fn.call(that, args[0], args[1], args[2]);\n    case 4: return un ? fn(args[0], args[1], args[2], args[3])\n                      : fn.call(that, args[0], args[1], args[2], args[3]);\n  } return              fn.apply(that, args);\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_invoke.js\n **/","var global    = require('./_global')\n  , macrotask = require('./_task').set\n  , Observer  = global.MutationObserver || global.WebKitMutationObserver\n  , process   = global.process\n  , Promise   = global.Promise\n  , isNode    = require('./_cof')(process) == 'process'\n  , head, last, notify;\n\nvar flush = function(){\n  var parent, fn;\n  if(isNode && (parent = process.domain))parent.exit();\n  while(head){\n    fn = head.fn;\n    fn(); // <- currently we use it only for Promise - try / catch not required\n    head = head.next;\n  } last = undefined;\n  if(parent)parent.enter();\n};\n\n// Node.js\nif(isNode){\n  notify = function(){\n    process.nextTick(flush);\n  };\n// browsers with MutationObserver\n} else if(Observer){\n  var toggle = true\n    , node   = document.createTextNode('');\n  new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new\n  notify = function(){\n    node.data = toggle = !toggle;\n  };\n// environments with maybe non-completely correct, but existent Promise\n} else if(Promise && Promise.resolve){\n  notify = function(){\n    Promise.resolve().then(flush);\n  };\n// for other environments - macrotask based on:\n// - setImmediate\n// - MessageChannel\n// - window.postMessag\n// - onreadystatechange\n// - setTimeout\n} else {\n  notify = function(){\n    // strange IE + webpack dev server bug - use .call(global)\n    macrotask.call(global, flush);\n  };\n}\n\nmodule.exports = function(fn){\n  var task = {fn: fn, next: undefined};\n  if(last)last.next = task;\n  if(!head){\n    head = task;\n    notify();\n  } last = task;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_microtask.js\n **/","var redefine = require('./_redefine');\nmodule.exports = function(target, src, safe){\n  for(var key in src)redefine(target, key, src[key], safe);\n  return target;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_redefine-all.js\n **/","'use strict';\nvar global      = require('./_global')\n  , dP          = require('./_object-dp')\n  , DESCRIPTORS = require('./_descriptors')\n  , SPECIES     = require('./_wks')('species');\n\nmodule.exports = function(KEY){\n  var C = global[KEY];\n  if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {\n    configurable: true,\n    get: function(){ return this; }\n  });\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_set-species.js\n **/","var ITERATOR     = require('./_wks')('iterator')\n  , SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function(){ SAFE_CLOSING = true; };\n  Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n  if(!skipClosing && !SAFE_CLOSING)return false;\n  var safe = false;\n  try {\n    var arr  = [7]\n      , iter = arr[ITERATOR]();\n    iter.next = function(){ safe = true; };\n    arr[ITERATOR] = function(){ return iter; };\n    exec(arr);\n  } catch(e){ /* empty */ }\n  return safe;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./~/core-js/modules/_iter-detect.js\n **/","const {\n  setTimeout, setTimeoutNative\n} = global\n\n// fix no setTimeout on Android V8\nif (typeof setTimeout === 'undefined' &&\n  typeof setTimeoutNative === 'function') {\n  const timeoutMap = {}\n  let timeoutId = 0\n  global.setTimeout = (cb, time) => {\n    timeoutMap[++timeoutId] = cb\n    setTimeoutNative(timeoutId.toString(), time)\n  }\n  global.setTimeoutCallback = (id) => {\n    if (typeof timeoutMap[id] === 'function') {\n      timeoutMap[id]()\n      delete timeoutMap[id]\n    }\n  }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./polyfill/setTimeout.js\n **/","const {console} = global\n\nif (typeof console === 'undefined') {\n  global.console = {\n    log: (...args) => {\n      if (typeof nativeLog === 'function') {\n        nativeLog(...args)\n      }\n    },\n    error: (...args) => {\n      throw new Error(args)\n    }\n  }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./polyfill/consolelog.js\n **/","/**\n * @fileOverview Main entry, instance manager\n *\n * - createInstance(instanceId, code, options, data)\n * - refreshInstance(instanceId, data)\n * - destroyInstance(instanceId)\n * - registerComponents(components)\n * - registerModules(modules)\n * - getRoot(instanceId)\n * - instanceMap\n * - callJS(instanceId, tasks)\n *   - fireEvent(ref, type, data)\n *   - callback(funcId, data)\n */\n\nimport * as perf from './perf'\nimport * as config from './config'\nimport AppInstance from './app'\nimport Vm from './vm'\n\nvar {\n  nativeComponentMap\n} = config\nvar instanceMap = {}\n\n/**\n * create a Weex instance\n *\n * @param  {string} instanceId\n * @param  {string} code\n * @param  {object} [options] option `HAS_LOG` enable print log\n * @param  {object} [data]\n */\nexport function createInstance(instanceId, code, options, data) {\n  var instance = instanceMap[instanceId]\n  options = options || {}\n\n  config.debug = options.debug\n\n  var result\n  if (!instance) {\n    perf.start('createInstance', instanceId)\n    instance = new AppInstance(instanceId, options)\n    instanceMap[instanceId] = instance\n    result = instance.init(code, data)\n    perf.end('createInstance', instanceId)\n  } else {\n    result = new Error(`invalid instance id \"${instanceId}\"`)\n  }\n\n  return result\n}\n\n/**\n * refresh a Weex instance\n *\n * @param  {string} instanceId\n * @param  {object} data\n */\nexport function refreshInstance(instanceId, data) {\n  var instance = instanceMap[instanceId]\n  var result\n  if (instance) {\n    perf.start('refreshData', instanceId)\n    result = instance.refreshData(data)\n    perf.end('refreshData', instanceId)\n  } else {\n    result = new Error(`invalid instance id \"${instanceId}\"`)\n  }\n  return result\n}\n\n/**\n * destroy a Weex instance\n * @param  {string} instanceId\n */\nexport function destroyInstance(instanceId) {\n  var instance = instanceMap[instanceId]\n  if (!instance) {\n    return new Error(`invalid instance id \"${instanceId}\"`)\n  }\n\n  perf.start('destroyInstance', instanceId)\n  instance.destroy()\n  delete instanceMap[instanceId]\n  perf.end('destroyInstance', instanceId)\n\n  return instanceMap\n}\n\n/**\n * register the name of each native component\n * @param  {array} components array of name\n */\nexport function registerComponents(components) {\n  if (Array.isArray(components)) {\n    components.forEach(function register(name) {\n      /* istanbul ignore if */\n      if (!name) {\n        return\n      }\n      if (typeof name === 'string') {\n        nativeComponentMap[name] = true\n      } else if (typeof name === 'object' && typeof name.type === 'string') {\n        nativeComponentMap[name.type] = name\n      }\n    })\n  }\n}\n\n/**\n * register the name and methods of each module\n * @param  {object} modules a object of modules\n */\nexport function registerModules(modules) {\n  if (typeof modules === 'object') {\n    Vm.registerModules(modules)\n  }\n}\n\n/**\n * register the name and methods of each api\n * @param  {object} apis a object of apis\n */\nexport function registerMethods(apis) {\n  if (typeof apis === 'object') {\n    Vm.registerMethods(apis)\n  }\n}\n\n/**\n * get a whole element tree of an instance\n * for debugging\n * @param  {string} instanceId\n * @return {object} a virtual dom tree\n */\nexport function getRoot(instanceId) {\n  var instance = instanceMap[instanceId]\n  var result\n  if (instance) {\n    result = instance.getRootElement()\n  } else {\n    result = new Error(`invalid instance id \"${instanceId}\"`)\n  }\n  return result\n}\n\nvar jsHandlers = {\n  fireEvent: function fireEvent(instanceId, ref, type, data) {\n    var instance = instanceMap[instanceId]\n    var result\n    perf.start('fireEvent', instanceId + '-' + ref + '-' + type)\n    result = instance.fireEvent(ref, type, data)\n    perf.end('fireEvent', instanceId + '-' + ref + '-' + type)\n    return result\n  },\n\n  callback: function callback(instanceId, funcId, data, ifLast) {\n    var instance = instanceMap[instanceId]\n    var result\n    perf.start('callback',\n      instanceId + '-' + funcId + '-' + data + '-' + ifLast)\n    result = instance.callback(funcId, data, ifLast)\n    perf.end('callback',\n      instanceId + '-' + funcId + '-' + data + '-' + ifLast)\n    return result\n  }\n}\n\n/**\n * accept calls from native (event or callback)\n *\n * @param  {string} instanceId\n * @param  {array} tasks list with `method` and `args`\n */\nexport function callJS(instanceId, tasks) {\n  const instance = instanceMap[instanceId]\n  let results = []\n  if (instance && Array.isArray(tasks)) {\n    tasks.forEach((task) => {\n      const handler = jsHandlers[task.method]\n      const args = [...task.args]\n      if (typeof handler === 'function') {\n        log('javascript:', task.method, task.args)\n        args.unshift(instanceId)\n        results.push(handler(...args))\n      }\n    })\n  } else {\n    results.push(new Error(`invalid instance id \"${instanceId}\" or tasks`))\n  }\n\n  return results\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/framework.js\n **/","import log from './log'\n\nvar data = {type: 'root', children: []}\nvar current = data\nvar stack = [current]\n\nfunction spaces(num) {\n  return Array(num).join(' ')\n}\n\nexport function start(type, id) {\n  var task = {type: type, id: id, children: [], start: Date.now()}\n  current.children.push(task)\n  stack.push(task)\n  current = task\n  log('perf:' + spaces(stack.length - 1), 'start', task.type, task.id)\n}\n\nexport function end(type, id) {\n  var task = stack.pop()\n  task.end = Date.now()\n  current = stack[stack.length - 1]\n  log('perf:' + spaces(stack.length), 'end',\n    (task.end - task.start) + 'ms', task.type, task.id)\n}\n\nexport function reset() {\n  data.children = []\n  current = data\n  stack.length = 0\n  stack.push(current)\n}\n\nexport function toJSON() {\n  return JSON.parse(JSON.stringify(data))\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/perf.js\n **/","import * as config from './config'\n\nexport default function log(...args) {\n  if (config.debug) {\n    global.console.log(...args)\n  }\n}\n\nglobal.log = log\n\n\n/** WEBPACK FOOTER **\n ** ./lib/log.js\n **/","export const nativeComponentMap = {\n  text: true,\n  image: true,\n  container: true,\n  slider: {\n    type: 'slider',\n    append: 'tree'\n  },\n  cell: {\n    type: 'cell',\n    append: 'tree'\n  }\n}\n\nexport const customComponentMap = {}\n\nexport var debug = false\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/config.js\n **/","/**\n * @fileOverview\n * Weex instance constructor & definition\n */\n\nimport {typof, extend} from '../util'\nimport * as perf from '../perf'\nimport * as bundle from './bundle'\nimport * as ctrl from './ctrl'\nimport Differ from './differ'\n\nimport EventManager from './event'\nimport Listener from './dom-listener'\nimport {Document, Node} from './dom'\nimport {registerComponent, requireComponent, requireModule} from './register'\n\nexport default function AppInstance(instanceId, options) {\n  perf.start('initInstance', instanceId)\n  this.id = instanceId\n  this.options = options || {}\n  this.vm = null\n  this.doc = new Document(instanceId)\n  this.customComponentMap = {}\n  this.callbacks = {}\n  this.differ = new Differ(instanceId)\n  this.uid = 0\n  this.rendered = false\n  this.eventManager = new EventManager()\n  this.listener = new Listener(this.id, (tasks) => {\n    this.callTasks(tasks)\n  })\n  this.doc.setEventManager(this.eventManager)\n  this.doc.setListener(this.listener)\n\n  perf.end('initInstance', instanceId)\n}\n\nfunction normalize(app, v) {\n  var type = typof(v)\n\n  switch (type) {\n    case 'undefined':\n    case 'null':\n      return ''\n    case 'regexp':\n      return v.toString()\n    case 'date':\n      return v.toISOString()\n    case 'number':\n    case 'string':\n    case 'boolean':\n    case 'array':\n    case 'object':\n      if (v instanceof Node) {\n        return v.ref\n      }\n      return v\n    case 'function':\n      app.callbacks[++app.uid] = v\n      return app.uid.toString()\n    default:\n      return JSON.stringify(v)\n  }\n}\n\nAppInstance.prototype.callTasks = function (tasks) {\n  if (typof(tasks) !== 'array') {\n    tasks = [tasks]\n  }\n\n  tasks.forEach((task) => {\n    task.args = task.args.map(arg => normalize(this, arg))\n  })\n\n  callNative(this.id, tasks, '-1')\n}\n\nextend(AppInstance.prototype, bundle, ctrl, {\n  registerComponent,\n  requireComponent,\n  requireModule\n})\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/index.js\n **/","/// lang.js\nimport Config from '../config'\n\n/**\n * Check is a string starts with $ or _\n *\n * @param {String} str\n * @return {Boolean}\n */\n\nexport var isReserved = (str) => {\n  let c = (str + '').charCodeAt(0)\n  return c === 0x24 || c === 0x5F\n}\n\n/**\n * Camelize a hyphen-delmited string.\n *\n * @param {String} str\n * @return {String}\n */\n\nlet camelRE = /-(\\w)/g\nfunction toUpper (_, c) {\n  return c ? c.toUpperCase () : ''\n}\nexport var camelize = (str) => {\n  return str.replace(camelRE, toUpper)\n}\n\n/**\n * Simple bind, faster than native\n *\n * @param {Function} fn\n * @param {Object} ctx\n * @return {Function}\n */\n\nexport var bind = function (fn, ctx) {\n  return function (a) {\n    let l = arguments.length\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n}\n\n/**\n * Convert an Array-like object to a real Array.\n *\n * @param {Array-like} list\n * @param {Number} [start] - start index\n * @return {Array}\n */\n\nexport var toArray = (list, start) => {\n  start = start || 0\n  let i = list.length - start\n  let ret = new Array(i)\n  while (i--) {\n    ret[i] = list[i + start]\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n *\n * @param {Object} to\n * @param {Object} from\n */\n\nexport var extend = (target, ...src) => {\n  if (typeof Object.assign === 'function') {\n    Object.assign(target, ...src)\n  } else {\n    const first = src.shift()\n    for (const key in first) {\n      target[key] = first[key]\n    }\n    if (src.length) {\n      extend(target, ...src)\n    }\n  }\n  return target\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nexport var isObject = (obj) => {\n  return !!(obj && typeof obj === 'object')\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nlet toString = Object.prototype.toString\nexport var isPlainObject = (obj) => {\n  return toString.call(obj) === '[object Object]'\n}\n\n/**\n * Array type check.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nexport var isArray = (obj) => {\n  return Array.isArray(obj)\n}\n\nexport var stringify = (x) => {\n  return typeof x === 'undefined' || x === null || typeof(x) === 'function'\n    ? ''\n    : typeof x === 'object'\n      ? x instanceof RegExp\n        ? x.toString()\n        : x instanceof Date\n          ? JSON.parse(JSON.stringify(x))\n          : JSON.stringify(x)\n      : x.toString()\n}\n\nexport var typof = (v) => {\n  let s = Object.prototype.toString.call(v)\n  return s.substring(8, s.length - 1).toLowerCase()\n}\n\nexport var normalize = (v) => {\n  let type = typof(v)\n\n  switch(type) {\n    case 'undefined':\n    case 'null':\n      return ''\n    case 'regexp':\n      return v.toString()\n    case 'date':\n      return v.toISOString()\n    case 'number':\n    case 'string':\n    case 'boolean':\n    case 'array':\n    case 'object':\n    case 'function':\n      return v\n    default:\n      return JSON.stringify(v)\n  }\n}\n\n/**\n * Define a non-enumerable property\n *\n * @param {Object} obj\n * @param {String} key\n * @param {*} val\n * @param {Boolean} [enumerable]\n */\n\nexport var define = (obj, key, val, enumerable) => {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  })\n}\n\n/**\n * Manual indexOf because it's slightly faster than\n * native.\n *\n * @param {Array} arr\n * @param {*} obj\n */\n\nexport var indexOf = (arr, obj) => {\n  for (let i = 0, l = arr.length; i < l; i++) {\n    if (arr[i] === obj) return i\n  }\n  return -1\n}\n\n\n/// debug.js\n\n\nconst hasConsole = typeof console !== 'undefined'\n\n/**\n * Log a message.\n *\n * @param {String} msg\n */\n\nexport var log = (msg) => {\n  const _config = Config || {}\n  if (hasConsole && _config.debug) {\n    console.log.call(this, '[info]: ', msg)\n  }\n}\n\n/**\n * We've got a problem here.\n *\n * @param {String} msg\n */\n\nexport var warn = (msg) => {\n  // if (hasConsole && (!config.silent || config.debug)) {\n  if (hasConsole) {\n    console.warn.call(this, '[warn]: ', msg)\n    /* istanbul ignore if */\n    // if (config.debug) {\n    //   /* jshint debug: true */\n    //   debugger\n    // }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/util/index.js\n **/","/**\n * @fileOverview\n * api that invoked by js bundle code\n *\n * - define(name, factory): define a new composed component type\n * - bootstrap(type, config, data): require a certain type &\n *         render with (optional) data\n *\n * deprecated:\n * - register(type, options): register a new composed component type\n * - render(type, data): render by a certain type with (optional) data\n * - require(type)(data): require a type then render with data\n */\n\nimport semver from 'semver'\nimport * as _ from '../util'\nimport * as config from '../config'\nimport * as perf from '../perf'\nimport Vm from '../vm'\nimport * as downgrade from './downgrade'\n\nconst WEEX_COMPONENT_REG = /^\\@weex-component\\//\nconst WEEX_MODULE_REG = /^\\@weex-module\\//\nconst NORMAL_MODULE_REG = /^\\.{1,2}\\//\nconst JS_SURFIX_REG = /\\.js$/\n\nconst isWeexComponent = name => !!name.match(WEEX_COMPONENT_REG)\nconst isWeexModule = name => !!name.match(WEEX_MODULE_REG)\nconst isNormalModule = name => !!name.match(NORMAL_MODULE_REG)\nconst isNpmModule = name => !isWeexComponent(name) &&\n                              !isWeexModule(name) &&\n                              !isNormalModule(name)\n\nfunction removeWeexPrefix(str) {\n  return str.replace(WEEX_COMPONENT_REG, '')\n          .replace(WEEX_MODULE_REG, '')\n}\n\nfunction removeJSSurfix(str) {\n  return str.replace(JS_SURFIX_REG, '')\n}\n\nlet commonModules = {}\n\nexport function clearCommonModules() {\n  commonModules = {}\n}\n\n// define(name, factory) for primary usage\n// or\n// define(name, deps, factory) for compatibility\n// Notice: DO NOT use function define() {},\n// it will cause error after builded by webpack\nexport var define = function (name, deps, factory) {\n  perf.start('define', name)\n\n  if (_.typof(deps) === 'function') {\n    factory = deps\n    deps = []\n  }\n\n  let _require = (name) => {\n    let cleanName\n\n    if (isWeexComponent(name)) {\n      cleanName = removeWeexPrefix(name)\n      return this.requireComponent(cleanName)\n    }\n    if (isWeexModule(name)) {\n      cleanName = removeWeexPrefix(name)\n      return this.requireModule(cleanName)\n    }\n    if (isNormalModule(name)) {\n      cleanName = removeJSSurfix(name)\n      return commonModules[name]\n    }\n    if (isNpmModule(name)) {\n      cleanName = removeJSSurfix(name)\n      return commonModules[name]\n    }\n  }\n  let _module = {exports: {}}\n\n  let cleanName\n  if (isWeexComponent(name)) {\n    cleanName = removeWeexPrefix(name)\n\n    factory(_require, _module.exports, _module)\n\n    this.registerComponent(cleanName, _module.exports)\n  } else if (isWeexModule(name)) {\n    cleanName = removeWeexPrefix(name)\n\n    factory(_require, _module.exports, _module)\n\n    Vm.registerModules({\n      [cleanName]: _module.exports\n    })\n  } else if (isNormalModule(name)) {\n    cleanName = removeJSSurfix(name)\n\n    factory(_require, _module.exports, _module)\n\n    commonModules[cleanName] = _module.exports\n  } else if (isNpmModule(name)) {\n    cleanName = removeJSSurfix(name)\n\n    factory(_require, _module.exports, _module)\n\n    let exports = _module.exports\n    if (exports.template ||\n        exports.style ||\n        exports.methods) {\n      // downgrade to old define method (define('componentName', factory))\n      // the exports contain one key of template, style or methods\n      // but it has risk!!!\n      this.registerComponent(cleanName, exports)\n    } else {\n      commonModules[cleanName] = _module.exports\n    }\n  }\n\n  perf.end('define', name)\n}\n\nexport function bootstrap(name, config, data) {\n  let cleanName\n\n  if (isWeexComponent(name)) {\n    cleanName = removeWeexPrefix(name)\n  } else if (isNpmModule(name)) {\n    cleanName = removeJSSurfix(name)\n    // check if define by old 'define' method\n    if (!this.customComponentMap[cleanName]) {\n      return new Error(`It's not a component: ${name}`)\n    }\n  } else {\n    return new Error(`Wrong component name: ${name}`)\n  }\n\n  config = _.isPlainObject(config) ? config : {}\n\n  if (typeof config.transformerVersion === 'string' &&\n    typeof global.needTransformerVersion === 'string' &&\n    !semver.satisfies(config.transformerVersion,\n      global.needTransformerVersion)) {\n    return new Error(`JS Bundle version: ${config.transformerVersion} ` +\n      `not compatible with ${global.needTransformerVersion}`)\n  }\n\n  let _checkDowngrade = downgrade.check(config.downgrade)\n  if (_checkDowngrade.isDowngrade) {\n    this.callTasks([{\n      module: 'instanceWrap',\n      method: 'error',\n      args: [\n        _checkDowngrade.errorType,\n        _checkDowngrade.code,\n        _checkDowngrade.errorMessage\n      ]\n    }])\n    return new Error(`Downgrade: ${config.downgrade}`)\n  }\n\n  perf.start('create vm', cleanName)\n\n  this.vm = new Vm(cleanName, {_app: this}, null, data, {\n    'hook:ready': () => {\n      perf.end('create vm', cleanName)\n    }\n  })\n}\n\n/**\n * @deprecated\n */\nexport function register(type, options) {\n  perf.start('register', type)\n  this.registerComponent(type, options)\n  perf.end('register', type)\n}\n\n/**\n * @deprecated\n */\nexport function render(type, data) {\n  return this.bootstrap(type, {}, data)\n}\n\n/**\n * @deprecated\n */\nexport function require(type) {\n  return (data) => {\n    return this.bootstrap(type, {}, data)\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/bundle.js\n **/","exports = module.exports = SemVer;\n\n// The debug function is excluded entirely from the minified version.\n/* nomin */ var debug;\n/* nomin */ if (typeof process === 'object' &&\n    /* nomin */ process.env &&\n    /* nomin */ process.env.NODE_DEBUG &&\n    /* nomin */ /\\bsemver\\b/i.test(process.env.NODE_DEBUG))\n  /* nomin */ debug = function() {\n    /* nomin */ var args = Array.prototype.slice.call(arguments, 0);\n    /* nomin */ args.unshift('SEMVER');\n    /* nomin */ console.log.apply(console, args);\n    /* nomin */ };\n/* nomin */ else\n  /* nomin */ debug = function() {};\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nexports.SEMVER_SPEC_VERSION = '2.0.0';\n\nvar MAX_LENGTH = 256;\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;\n\n// The actual regexps go on exports.re\nvar re = exports.re = [];\nvar src = exports.src = [];\nvar R = 0;\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\nvar NUMERICIDENTIFIER = R++;\nsrc[NUMERICIDENTIFIER] = '0|[1-9]\\\\d*';\nvar NUMERICIDENTIFIERLOOSE = R++;\nsrc[NUMERICIDENTIFIERLOOSE] = '[0-9]+';\n\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\nvar NONNUMERICIDENTIFIER = R++;\nsrc[NONNUMERICIDENTIFIER] = '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*';\n\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\nvar MAINVERSION = R++;\nsrc[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[NUMERICIDENTIFIER] + ')';\n\nvar MAINVERSIONLOOSE = R++;\nsrc[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')';\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\nvar PRERELEASEIDENTIFIER = R++;\nsrc[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +\n                            '|' + src[NONNUMERICIDENTIFIER] + ')';\n\nvar PRERELEASEIDENTIFIERLOOSE = R++;\nsrc[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +\n                                 '|' + src[NONNUMERICIDENTIFIER] + ')';\n\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\nvar PRERELEASE = R++;\nsrc[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +\n                  '(?:\\\\.' + src[PRERELEASEIDENTIFIER] + ')*))';\n\nvar PRERELEASELOOSE = R++;\nsrc[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +\n                       '(?:\\\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\nvar BUILDIDENTIFIER = R++;\nsrc[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\nvar BUILD = R++;\nsrc[BUILD] = '(?:\\\\+(' + src[BUILDIDENTIFIER] +\n             '(?:\\\\.' + src[BUILDIDENTIFIER] + ')*))';\n\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\nvar FULL = R++;\nvar FULLPLAIN = 'v?' + src[MAINVERSION] +\n                src[PRERELEASE] + '?' +\n                src[BUILD] + '?';\n\nsrc[FULL] = '^' + FULLPLAIN + '$';\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\nvar LOOSEPLAIN = '[v=\\\\s]*' + src[MAINVERSIONLOOSE] +\n                 src[PRERELEASELOOSE] + '?' +\n                 src[BUILD] + '?';\n\nvar LOOSE = R++;\nsrc[LOOSE] = '^' + LOOSEPLAIN + '$';\n\nvar GTLT = R++;\nsrc[GTLT] = '((?:<|>)?=?)';\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\nvar XRANGEIDENTIFIERLOOSE = R++;\nsrc[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\\\*';\nvar XRANGEIDENTIFIER = R++;\nsrc[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\\\*';\n\nvar XRANGEPLAIN = R++;\nsrc[XRANGEPLAIN] = '[v=\\\\s]*(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:' + src[PRERELEASE] + ')?' +\n                   src[BUILD] + '?' +\n                   ')?)?';\n\nvar XRANGEPLAINLOOSE = R++;\nsrc[XRANGEPLAINLOOSE] = '[v=\\\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:' + src[PRERELEASELOOSE] + ')?' +\n                        src[BUILD] + '?' +\n                        ')?)?';\n\nvar XRANGE = R++;\nsrc[XRANGE] = '^' + src[GTLT] + '\\\\s*' + src[XRANGEPLAIN] + '$';\nvar XRANGELOOSE = R++;\nsrc[XRANGELOOSE] = '^' + src[GTLT] + '\\\\s*' + src[XRANGEPLAINLOOSE] + '$';\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\nvar LONETILDE = R++;\nsrc[LONETILDE] = '(?:~>?)';\n\nvar TILDETRIM = R++;\nsrc[TILDETRIM] = '(\\\\s*)' + src[LONETILDE] + '\\\\s+';\nre[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');\nvar tildeTrimReplace = '$1~';\n\nvar TILDE = R++;\nsrc[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';\nvar TILDELOOSE = R++;\nsrc[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\nvar LONECARET = R++;\nsrc[LONECARET] = '(?:\\\\^)';\n\nvar CARETTRIM = R++;\nsrc[CARETTRIM] = '(\\\\s*)' + src[LONECARET] + '\\\\s+';\nre[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');\nvar caretTrimReplace = '$1^';\n\nvar CARET = R++;\nsrc[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';\nvar CARETLOOSE = R++;\nsrc[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\nvar COMPARATORLOOSE = R++;\nsrc[COMPARATORLOOSE] = '^' + src[GTLT] + '\\\\s*(' + LOOSEPLAIN + ')$|^$';\nvar COMPARATOR = R++;\nsrc[COMPARATOR] = '^' + src[GTLT] + '\\\\s*(' + FULLPLAIN + ')$|^$';\n\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\nvar COMPARATORTRIM = R++;\nsrc[COMPARATORTRIM] = '(\\\\s*)' + src[GTLT] +\n                      '\\\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';\n\n// this one has to use the /g flag\nre[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');\nvar comparatorTrimReplace = '$1$2$3';\n\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\nvar HYPHENRANGE = R++;\nsrc[HYPHENRANGE] = '^\\\\s*(' + src[XRANGEPLAIN] + ')' +\n                   '\\\\s+-\\\\s+' +\n                   '(' + src[XRANGEPLAIN] + ')' +\n                   '\\\\s*$';\n\nvar HYPHENRANGELOOSE = R++;\nsrc[HYPHENRANGELOOSE] = '^\\\\s*(' + src[XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s+-\\\\s+' +\n                        '(' + src[XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s*$';\n\n// Star ranges basically just allow anything at all.\nvar STAR = R++;\nsrc[STAR] = '(<|>)?=?\\\\s*\\\\*';\n\n// Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\nfor (var i = 0; i < R; i++) {\n  debug(i, src[i]);\n  if (!re[i])\n    re[i] = new RegExp(src[i]);\n}\n\nexports.parse = parse;\nfunction parse(version, loose) {\n  if (version instanceof SemVer)\n    return version;\n\n  if (typeof version !== 'string')\n    return null;\n\n  if (version.length > MAX_LENGTH)\n    return null;\n\n  var r = loose ? re[LOOSE] : re[FULL];\n  if (!r.test(version))\n    return null;\n\n  try {\n    return new SemVer(version, loose);\n  } catch (er) {\n    return null;\n  }\n}\n\nexports.valid = valid;\nfunction valid(version, loose) {\n  var v = parse(version, loose);\n  return v ? v.version : null;\n}\n\n\nexports.clean = clean;\nfunction clean(version, loose) {\n  var s = parse(version.trim().replace(/^[=v]+/, ''), loose);\n  return s ? s.version : null;\n}\n\nexports.SemVer = SemVer;\n\nfunction SemVer(version, loose) {\n  if (version instanceof SemVer) {\n    if (version.loose === loose)\n      return version;\n    else\n      version = version.version;\n  } else if (typeof version !== 'string') {\n    throw new TypeError('Invalid Version: ' + version);\n  }\n\n  if (version.length > MAX_LENGTH)\n    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')\n\n  if (!(this instanceof SemVer))\n    return new SemVer(version, loose);\n\n  debug('SemVer', version, loose);\n  this.loose = loose;\n  var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);\n\n  if (!m)\n    throw new TypeError('Invalid Version: ' + version);\n\n  this.raw = version;\n\n  // these are actually numbers\n  this.major = +m[1];\n  this.minor = +m[2];\n  this.patch = +m[3];\n\n  if (this.major > MAX_SAFE_INTEGER || this.major < 0)\n    throw new TypeError('Invalid major version')\n\n  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)\n    throw new TypeError('Invalid minor version')\n\n  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)\n    throw new TypeError('Invalid patch version')\n\n  // numberify any prerelease numeric ids\n  if (!m[4])\n    this.prerelease = [];\n  else\n    this.prerelease = m[4].split('.').map(function(id) {\n      if (/^[0-9]+$/.test(id)) {\n        var num = +id\n        if (num >= 0 && num < MAX_SAFE_INTEGER)\n          return num\n      }\n      return id;\n    });\n\n  this.build = m[5] ? m[5].split('.') : [];\n  this.format();\n}\n\nSemVer.prototype.format = function() {\n  this.version = this.major + '.' + this.minor + '.' + this.patch;\n  if (this.prerelease.length)\n    this.version += '-' + this.prerelease.join('.');\n  return this.version;\n};\n\nSemVer.prototype.toString = function() {\n  return this.version;\n};\n\nSemVer.prototype.compare = function(other) {\n  debug('SemVer.compare', this.version, this.loose, other);\n  if (!(other instanceof SemVer))\n    other = new SemVer(other, this.loose);\n\n  return this.compareMain(other) || this.comparePre(other);\n};\n\nSemVer.prototype.compareMain = function(other) {\n  if (!(other instanceof SemVer))\n    other = new SemVer(other, this.loose);\n\n  return compareIdentifiers(this.major, other.major) ||\n         compareIdentifiers(this.minor, other.minor) ||\n         compareIdentifiers(this.patch, other.patch);\n};\n\nSemVer.prototype.comparePre = function(other) {\n  if (!(other instanceof SemVer))\n    other = new SemVer(other, this.loose);\n\n  // NOT having a prerelease is > having one\n  if (this.prerelease.length && !other.prerelease.length)\n    return -1;\n  else if (!this.prerelease.length && other.prerelease.length)\n    return 1;\n  else if (!this.prerelease.length && !other.prerelease.length)\n    return 0;\n\n  var i = 0;\n  do {\n    var a = this.prerelease[i];\n    var b = other.prerelease[i];\n    debug('prerelease compare', i, a, b);\n    if (a === undefined && b === undefined)\n      return 0;\n    else if (b === undefined)\n      return 1;\n    else if (a === undefined)\n      return -1;\n    else if (a === b)\n      continue;\n    else\n      return compareIdentifiers(a, b);\n  } while (++i);\n};\n\n// preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\nSemVer.prototype.inc = function(release, identifier) {\n  switch (release) {\n    case 'premajor':\n      this.prerelease.length = 0;\n      this.patch = 0;\n      this.minor = 0;\n      this.major++;\n      this.inc('pre', identifier);\n      break;\n    case 'preminor':\n      this.prerelease.length = 0;\n      this.patch = 0;\n      this.minor++;\n      this.inc('pre', identifier);\n      break;\n    case 'prepatch':\n      // If this is already a prerelease, it will bump to the next version\n      // drop any prereleases that might already exist, since they are not\n      // relevant at this point.\n      this.prerelease.length = 0;\n      this.inc('patch', identifier);\n      this.inc('pre', identifier);\n      break;\n    // If the input is a non-prerelease version, this acts the same as\n    // prepatch.\n    case 'prerelease':\n      if (this.prerelease.length === 0)\n        this.inc('patch', identifier);\n      this.inc('pre', identifier);\n      break;\n\n    case 'major':\n      // If this is a pre-major version, bump up to the same major version.\n      // Otherwise increment major.\n      // 1.0.0-5 bumps to 1.0.0\n      // 1.1.0 bumps to 2.0.0\n      if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0)\n        this.major++;\n      this.minor = 0;\n      this.patch = 0;\n      this.prerelease = [];\n      break;\n    case 'minor':\n      // If this is a pre-minor version, bump up to the same minor version.\n      // Otherwise increment minor.\n      // 1.2.0-5 bumps to 1.2.0\n      // 1.2.1 bumps to 1.3.0\n      if (this.patch !== 0 || this.prerelease.length === 0)\n        this.minor++;\n      this.patch = 0;\n      this.prerelease = [];\n      break;\n    case 'patch':\n      // If this is not a pre-release version, it will increment the patch.\n      // If it is a pre-release it will bump up to the same patch version.\n      // 1.2.0-5 patches to 1.2.0\n      // 1.2.0 patches to 1.2.1\n      if (this.prerelease.length === 0)\n        this.patch++;\n      this.prerelease = [];\n      break;\n    // This probably shouldn't be used publicly.\n    // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n    case 'pre':\n      if (this.prerelease.length === 0)\n        this.prerelease = [0];\n      else {\n        var i = this.prerelease.length;\n        while (--i >= 0) {\n          if (typeof this.prerelease[i] === 'number') {\n            this.prerelease[i]++;\n            i = -2;\n          }\n        }\n        if (i === -1) // didn't increment anything\n          this.prerelease.push(0);\n      }\n      if (identifier) {\n        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n        if (this.prerelease[0] === identifier) {\n          if (isNaN(this.prerelease[1]))\n            this.prerelease = [identifier, 0];\n        } else\n          this.prerelease = [identifier, 0];\n      }\n      break;\n\n    default:\n      throw new Error('invalid increment argument: ' + release);\n  }\n  this.format();\n  this.raw = this.version;\n  return this;\n};\n\nexports.inc = inc;\nfunction inc(version, release, loose, identifier) {\n  if (typeof(loose) === 'string') {\n    identifier = loose;\n    loose = undefined;\n  }\n\n  try {\n    return new SemVer(version, loose).inc(release, identifier).version;\n  } catch (er) {\n    return null;\n  }\n}\n\nexports.diff = diff;\nfunction diff(version1, version2) {\n  if (eq(version1, version2)) {\n    return null;\n  } else {\n    var v1 = parse(version1);\n    var v2 = parse(version2);\n    if (v1.prerelease.length || v2.prerelease.length) {\n      for (var key in v1) {\n        if (key === 'major' || key === 'minor' || key === 'patch') {\n          if (v1[key] !== v2[key]) {\n            return 'pre'+key;\n          }\n        }\n      }\n      return 'prerelease';\n    }\n    for (var key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return key;\n        }\n      }\n    }\n  }\n}\n\nexports.compareIdentifiers = compareIdentifiers;\n\nvar numeric = /^[0-9]+$/;\nfunction compareIdentifiers(a, b) {\n  var anum = numeric.test(a);\n  var bnum = numeric.test(b);\n\n  if (anum && bnum) {\n    a = +a;\n    b = +b;\n  }\n\n  return (anum && !bnum) ? -1 :\n         (bnum && !anum) ? 1 :\n         a < b ? -1 :\n         a > b ? 1 :\n         0;\n}\n\nexports.rcompareIdentifiers = rcompareIdentifiers;\nfunction rcompareIdentifiers(a, b) {\n  return compareIdentifiers(b, a);\n}\n\nexports.major = major;\nfunction major(a, loose) {\n  return new SemVer(a, loose).major;\n}\n\nexports.minor = minor;\nfunction minor(a, loose) {\n  return new SemVer(a, loose).minor;\n}\n\nexports.patch = patch;\nfunction patch(a, loose) {\n  return new SemVer(a, loose).patch;\n}\n\nexports.compare = compare;\nfunction compare(a, b, loose) {\n  return new SemVer(a, loose).compare(b);\n}\n\nexports.compareLoose = compareLoose;\nfunction compareLoose(a, b) {\n  return compare(a, b, true);\n}\n\nexports.rcompare = rcompare;\nfunction rcompare(a, b, loose) {\n  return compare(b, a, loose);\n}\n\nexports.sort = sort;\nfunction sort(list, loose) {\n  return list.sort(function(a, b) {\n    return exports.compare(a, b, loose);\n  });\n}\n\nexports.rsort = rsort;\nfunction rsort(list, loose) {\n  return list.sort(function(a, b) {\n    return exports.rcompare(a, b, loose);\n  });\n}\n\nexports.gt = gt;\nfunction gt(a, b, loose) {\n  return compare(a, b, loose) > 0;\n}\n\nexports.lt = lt;\nfunction lt(a, b, loose) {\n  return compare(a, b, loose) < 0;\n}\n\nexports.eq = eq;\nfunction eq(a, b, loose) {\n  return compare(a, b, loose) === 0;\n}\n\nexports.neq = neq;\nfunction neq(a, b, loose) {\n  return compare(a, b, loose) !== 0;\n}\n\nexports.gte = gte;\nfunction gte(a, b, loose) {\n  return compare(a, b, loose) >= 0;\n}\n\nexports.lte = lte;\nfunction lte(a, b, loose) {\n  return compare(a, b, loose) <= 0;\n}\n\nexports.cmp = cmp;\nfunction cmp(a, op, b, loose) {\n  var ret;\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') a = a.version;\n      if (typeof b === 'object') b = b.version;\n      ret = a === b;\n      break;\n    case '!==':\n      if (typeof a === 'object') a = a.version;\n      if (typeof b === 'object') b = b.version;\n      ret = a !== b;\n      break;\n    case '': case '=': case '==': ret = eq(a, b, loose); break;\n    case '!=': ret = neq(a, b, loose); break;\n    case '>': ret = gt(a, b, loose); break;\n    case '>=': ret = gte(a, b, loose); break;\n    case '<': ret = lt(a, b, loose); break;\n    case '<=': ret = lte(a, b, loose); break;\n    default: throw new TypeError('Invalid operator: ' + op);\n  }\n  return ret;\n}\n\nexports.Comparator = Comparator;\nfunction Comparator(comp, loose) {\n  if (comp instanceof Comparator) {\n    if (comp.loose === loose)\n      return comp;\n    else\n      comp = comp.value;\n  }\n\n  if (!(this instanceof Comparator))\n    return new Comparator(comp, loose);\n\n  debug('comparator', comp, loose);\n  this.loose = loose;\n  this.parse(comp);\n\n  if (this.semver === ANY)\n    this.value = '';\n  else\n    this.value = this.operator + this.semver.version;\n\n  debug('comp', this);\n}\n\nvar ANY = {};\nComparator.prototype.parse = function(comp) {\n  var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];\n  var m = comp.match(r);\n\n  if (!m)\n    throw new TypeError('Invalid comparator: ' + comp);\n\n  this.operator = m[1];\n  if (this.operator === '=')\n    this.operator = '';\n\n  // if it literally is just '>' or '' then allow anything.\n  if (!m[2])\n    this.semver = ANY;\n  else\n    this.semver = new SemVer(m[2], this.loose);\n};\n\nComparator.prototype.toString = function() {\n  return this.value;\n};\n\nComparator.prototype.test = function(version) {\n  debug('Comparator.test', version, this.loose);\n\n  if (this.semver === ANY)\n    return true;\n\n  if (typeof version === 'string')\n    version = new SemVer(version, this.loose);\n\n  return cmp(version, this.operator, this.semver, this.loose);\n};\n\n\nexports.Range = Range;\nfunction Range(range, loose) {\n  if ((range instanceof Range) && range.loose === loose)\n    return range;\n\n  if (!(this instanceof Range))\n    return new Range(range, loose);\n\n  this.loose = loose;\n\n  // First, split based on boolean or ||\n  this.raw = range;\n  this.set = range.split(/\\s*\\|\\|\\s*/).map(function(range) {\n    return this.parseRange(range.trim());\n  }, this).filter(function(c) {\n    // throw out any that are not relevant for whatever reason\n    return c.length;\n  });\n\n  if (!this.set.length) {\n    throw new TypeError('Invalid SemVer Range: ' + range);\n  }\n\n  this.format();\n}\n\nRange.prototype.format = function() {\n  this.range = this.set.map(function(comps) {\n    return comps.join(' ').trim();\n  }).join('||').trim();\n  return this.range;\n};\n\nRange.prototype.toString = function() {\n  return this.range;\n};\n\nRange.prototype.parseRange = function(range) {\n  var loose = this.loose;\n  range = range.trim();\n  debug('range', range, loose);\n  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];\n  range = range.replace(hr, hyphenReplace);\n  debug('hyphen replace', range);\n  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);\n  debug('comparator trim', range, re[COMPARATORTRIM]);\n\n  // `~ 1.2.3` => `~1.2.3`\n  range = range.replace(re[TILDETRIM], tildeTrimReplace);\n\n  // `^ 1.2.3` => `^1.2.3`\n  range = range.replace(re[CARETTRIM], caretTrimReplace);\n\n  // normalize spaces\n  range = range.split(/\\s+/).join(' ');\n\n  // At this point, the range is completely trimmed and\n  // ready to be split into comparators.\n\n  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];\n  var set = range.split(' ').map(function(comp) {\n    return parseComparator(comp, loose);\n  }).join(' ').split(/\\s+/);\n  if (this.loose) {\n    // in loose mode, throw out any that are not valid comparators\n    set = set.filter(function(comp) {\n      return !!comp.match(compRe);\n    });\n  }\n  set = set.map(function(comp) {\n    return new Comparator(comp, loose);\n  });\n\n  return set;\n};\n\n// Mostly just for testing and legacy API reasons\nexports.toComparators = toComparators;\nfunction toComparators(range, loose) {\n  return new Range(range, loose).set.map(function(comp) {\n    return comp.map(function(c) {\n      return c.value;\n    }).join(' ').trim().split(' ');\n  });\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nfunction parseComparator(comp, loose) {\n  debug('comp', comp);\n  comp = replaceCarets(comp, loose);\n  debug('caret', comp);\n  comp = replaceTildes(comp, loose);\n  debug('tildes', comp);\n  comp = replaceXRanges(comp, loose);\n  debug('xrange', comp);\n  comp = replaceStars(comp, loose);\n  debug('stars', comp);\n  return comp;\n}\n\nfunction isX(id) {\n  return !id || id.toLowerCase() === 'x' || id === '*';\n}\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\nfunction replaceTildes(comp, loose) {\n  return comp.trim().split(/\\s+/).map(function(comp) {\n    return replaceTilde(comp, loose);\n  }).join(' ');\n}\n\nfunction replaceTilde(comp, loose) {\n  var r = loose ? re[TILDELOOSE] : re[TILDE];\n  return comp.replace(r, function(_, M, m, p, pr) {\n    debug('tilde', comp, _, M, m, p, pr);\n    var ret;\n\n    if (isX(M))\n      ret = '';\n    else if (isX(m))\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    else if (isX(p))\n      // ~1.2 == >=1.2.0- <1.3.0-\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n    else if (pr) {\n      debug('replaceTilde pr', pr);\n      if (pr.charAt(0) !== '-')\n        pr = '-' + pr;\n      ret = '>=' + M + '.' + m + '.' + p + pr +\n            ' <' + M + '.' + (+m + 1) + '.0';\n    } else\n      // ~1.2.3 == >=1.2.3 <1.3.0\n      ret = '>=' + M + '.' + m + '.' + p +\n            ' <' + M + '.' + (+m + 1) + '.0';\n\n    debug('tilde return', ret);\n    return ret;\n  });\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\nfunction replaceCarets(comp, loose) {\n  return comp.trim().split(/\\s+/).map(function(comp) {\n    return replaceCaret(comp, loose);\n  }).join(' ');\n}\n\nfunction replaceCaret(comp, loose) {\n  debug('caret', comp, loose);\n  var r = loose ? re[CARETLOOSE] : re[CARET];\n  return comp.replace(r, function(_, M, m, p, pr) {\n    debug('caret', comp, _, M, m, p, pr);\n    var ret;\n\n    if (isX(M))\n      ret = '';\n    else if (isX(m))\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    else if (isX(p)) {\n      if (M === '0')\n        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n      else\n        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';\n    } else if (pr) {\n      debug('replaceCaret pr', pr);\n      if (pr.charAt(0) !== '-')\n        pr = '-' + pr;\n      if (M === '0') {\n        if (m === '0')\n          ret = '>=' + M + '.' + m + '.' + p + pr +\n                ' <' + M + '.' + m + '.' + (+p + 1);\n        else\n          ret = '>=' + M + '.' + m + '.' + p + pr +\n                ' <' + M + '.' + (+m + 1) + '.0';\n      } else\n        ret = '>=' + M + '.' + m + '.' + p + pr +\n              ' <' + (+M + 1) + '.0.0';\n    } else {\n      debug('no pr');\n      if (M === '0') {\n        if (m === '0')\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + m + '.' + (+p + 1);\n        else\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + (+m + 1) + '.0';\n      } else\n        ret = '>=' + M + '.' + m + '.' + p +\n              ' <' + (+M + 1) + '.0.0';\n    }\n\n    debug('caret return', ret);\n    return ret;\n  });\n}\n\nfunction replaceXRanges(comp, loose) {\n  debug('replaceXRanges', comp, loose);\n  return comp.split(/\\s+/).map(function(comp) {\n    return replaceXRange(comp, loose);\n  }).join(' ');\n}\n\nfunction replaceXRange(comp, loose) {\n  comp = comp.trim();\n  var r = loose ? re[XRANGELOOSE] : re[XRANGE];\n  return comp.replace(r, function(ret, gtlt, M, m, p, pr) {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr);\n    var xM = isX(M);\n    var xm = xM || isX(m);\n    var xp = xm || isX(p);\n    var anyX = xp;\n\n    if (gtlt === '=' && anyX)\n      gtlt = '';\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0';\n      } else {\n        // nothing is forbidden\n        ret = '*';\n      }\n    } else if (gtlt && anyX) {\n      // replace X with 0\n      if (xm)\n        m = 0;\n      if (xp)\n        p = 0;\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        // >1.2.3 => >= 1.2.4\n        gtlt = '>=';\n        if (xm) {\n          M = +M + 1;\n          m = 0;\n          p = 0;\n        } else if (xp) {\n          m = +m + 1;\n          p = 0;\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm)\n          M = +M + 1\n        else\n          m = +m + 1\n      }\n\n      ret = gtlt + M + '.' + m + '.' + p;\n    } else if (xm) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    } else if (xp) {\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n    }\n\n    debug('xRange return', ret);\n\n    return ret;\n  });\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nfunction replaceStars(comp, loose) {\n  debug('replaceStars', comp, loose);\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[STAR], '');\n}\n\n// This function is passed to string.replace(re[HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\nfunction hyphenReplace($0,\n                       from, fM, fm, fp, fpr, fb,\n                       to, tM, tm, tp, tpr, tb) {\n\n  if (isX(fM))\n    from = '';\n  else if (isX(fm))\n    from = '>=' + fM + '.0.0';\n  else if (isX(fp))\n    from = '>=' + fM + '.' + fm + '.0';\n  else\n    from = '>=' + from;\n\n  if (isX(tM))\n    to = '';\n  else if (isX(tm))\n    to = '<' + (+tM + 1) + '.0.0';\n  else if (isX(tp))\n    to = '<' + tM + '.' + (+tm + 1) + '.0';\n  else if (tpr)\n    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;\n  else\n    to = '<=' + to;\n\n  return (from + ' ' + to).trim();\n}\n\n\n// if ANY of the sets match ALL of its comparators, then pass\nRange.prototype.test = function(version) {\n  if (!version)\n    return false;\n\n  if (typeof version === 'string')\n    version = new SemVer(version, this.loose);\n\n  for (var i = 0; i < this.set.length; i++) {\n    if (testSet(this.set[i], version))\n      return true;\n  }\n  return false;\n};\n\nfunction testSet(set, version) {\n  for (var i = 0; i < set.length; i++) {\n    if (!set[i].test(version))\n      return false;\n  }\n\n  if (version.prerelease.length) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (var i = 0; i < set.length; i++) {\n      debug(set[i].semver);\n      if (set[i].semver === ANY)\n        continue;\n\n      if (set[i].semver.prerelease.length > 0) {\n        var allowed = set[i].semver;\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch)\n          return true;\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false;\n  }\n\n  return true;\n}\n\nexports.satisfies = satisfies;\nfunction satisfies(version, range, loose) {\n  try {\n    range = new Range(range, loose);\n  } catch (er) {\n    return false;\n  }\n  return range.test(version);\n}\n\nexports.maxSatisfying = maxSatisfying;\nfunction maxSatisfying(versions, range, loose) {\n  return versions.filter(function(version) {\n    return satisfies(version, range, loose);\n  }).sort(function(a, b) {\n    return rcompare(a, b, loose);\n  })[0] || null;\n}\n\nexports.validRange = validRange;\nfunction validRange(range, loose) {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, loose).range || '*';\n  } catch (er) {\n    return null;\n  }\n}\n\n// Determine if version is less than all the versions possible in the range\nexports.ltr = ltr;\nfunction ltr(version, range, loose) {\n  return outside(version, range, '<', loose);\n}\n\n// Determine if version is greater than all the versions possible in the range.\nexports.gtr = gtr;\nfunction gtr(version, range, loose) {\n  return outside(version, range, '>', loose);\n}\n\nexports.outside = outside;\nfunction outside(version, range, hilo, loose) {\n  version = new SemVer(version, loose);\n  range = new Range(range, loose);\n\n  var gtfn, ltefn, ltfn, comp, ecomp;\n  switch (hilo) {\n    case '>':\n      gtfn = gt;\n      ltefn = lte;\n      ltfn = lt;\n      comp = '>';\n      ecomp = '>=';\n      break;\n    case '<':\n      gtfn = lt;\n      ltefn = gte;\n      ltfn = gt;\n      comp = '<';\n      ecomp = '<=';\n      break;\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"');\n  }\n\n  // If it satisifes the range it is not outside\n  if (satisfies(version, range, loose)) {\n    return false;\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i];\n\n    var high = null;\n    var low = null;\n\n    comparators.forEach(function(comparator) {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator;\n      low = low || comparator;\n      if (gtfn(comparator.semver, high.semver, loose)) {\n        high = comparator;\n      } else if (ltfn(comparator.semver, low.semver, loose)) {\n        low = comparator;\n      }\n    });\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false;\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false;\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/semver/semver.js\n **/","// shim for using process in browser\n\nvar process = module.exports = {};\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = setTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    clearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        setTimeout(drainQueue, 0);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/process/browser.js\n **/","/**\n * @fileOverview\n * ViewModel Constructor & definition\n */\n\nimport {extend, toArray} from '../util'\n\nimport * as scope from './instance/scope'\nimport * as compiler from './compiler'\nimport * as directive from './directive'\nimport * as domHelper from './dom-helper'\nimport * as events from './events'\n// import * as modules from './../api/modules'\n// import * as api from './../api/api'\n\nimport {registerModules, registerMethods} from '../app/register'\n\nfunction callOldReadyEntry(vm, component) {\n  if (component.methods &&\n      component.methods.ready) {\n    component.methods.ready.call(vm)\n  }\n}\n\n/**\n * ViewModel constructor\n *\n * @param {string} type\n * @param {object} parentVm   which contains _app\n * @param {object} parentEl   root element or frag block\n * @param {object} mergedData external data\n * @param {object} externalEvents external events\n */\nexport default function Vm(\n  type,\n  parentVm,\n  parentEl,\n  mergedData,\n  externalEvents\n) {\n  this._parent = parentVm._realParent ? parentVm._realParent : parentVm\n  this._app = parentVm._app\n  parentVm._childrenVms && parentVm._childrenVms.push(this)\n\n  const component = this._app.customComponentMap[type] || {}\n  const data = component.data || {}\n\n  this._options = component\n  this._methods = component.methods || {}\n  this._computed = component.computed || {}\n  this._css = component.style || {}\n  this._ids = {}\n  this._watchers = []\n  this._vmEvents = {}\n  this._childrenVms = []\n  this._type = type\n\n  // bind events and lifecycles\n  this._initEvents(externalEvents)\n\n  this.$emit('hook:init')\n  this._inited = true\n  // proxy data and methods\n  // observe data and add this to vms\n  this._data = typeof data === 'function' ? data() : data\n  if (mergedData) {\n    extend(this._data, mergedData)\n  }\n  this._initScope()\n\n  this.$emit('hook:created')\n  this._created = true\n  // backward old ready entry\n  callOldReadyEntry(this, component)\n\n  // if no parentElement then specify the documentElement\n  this._parentEl = parentEl || this._app.doc.documentElement\n  this._build()\n}\n\nextend(Vm.prototype, scope, compiler, directive, domHelper, events)\nextend(Vm, {\n  registerModules,\n  registerMethods\n})\n// Vm.registerModules(modules)\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/index.js\n **/","var _ = require('../util')\nvar Observer = require('../observer')\nvar Dep = require('../observer/dep')\n\n/**\n * Setup the scope of an instance, which contains:\n * - observed data\n * - computed properties\n * - user methods\n * - meta properties\n */\n\nexports._initScope = function () {\n  this._initData()\n  this._initComputed()\n  this._initMethods()\n  // this._initMeta()\n}\n\n/**\n * Initialize the data. \n */\n\nexports._initData = function () {\n  // proxy data on instance\n  var data = this._data\n  var i, key\n  // // make sure all props properties are observed\n  // var props = this.$options.props\n  // if (props) {\n  //   i = props.length\n  //   while (i--) {\n  //     key = _.camelize(props[i])\n  //     if (!(key in data)) {\n  //       data[key] = null\n  //     }\n  //   }\n  // }\n  var keys = Object.keys(data)\n  i = keys.length\n  while (i--) {\n    key = keys[i]\n    if (!_.isReserved(key)) {\n      this._proxy(key)\n    }\n  }\n  // observe data\n  Observer.create(data).addVm(this)\n}\n\n// /**\n//  * Swap the isntance's $data. Called in $data's setter.\n//  *\n//  * @param {Object} newData\n//  */\n\n// exports._setData = function (newData) {\n//   newData = newData || {}\n//   var oldData = this._data\n//   this._data = newData\n//   var keys, key, i\n//   // unproxy keys not present in new data\n//   keys = Object.keys(oldData)\n//   i = keys.length\n//   while (i--) {\n//     key = keys[i]\n//     if (!_.isReserved(key) && !(key in newData)) {\n//       this._unproxy(key)\n//     }\n//   }\n//   // proxy keys not already proxied,\n//   // and trigger change for changed values\n//   keys = Object.keys(newData)\n//   i = keys.length\n//   while (i--) {\n//     key = keys[i]\n//     if (!this.hasOwnProperty(key) && !_.isReserved(key)) {\n//       // new property\n//       this._proxy(key)\n//     }\n//   }\n//   oldData.__ob__.removeVm(this)\n//   Observer.create(newData).addVm(this)\n//   this._digest()\n// }\n\n/**\n * Proxy a property, so that\n * vm.prop === vm._data.prop\n *\n * @param {String} key\n */\n\nexports._proxy = function (key) {\n  // need to store ref to self here\n  // because these getter/setters might\n  // be called by child instances!\n  var self = this\n  Object.defineProperty(self, key, {\n    configurable: true,\n    enumerable: true,\n    get: function proxyGetter () {\n      return self._data[key]\n    },\n    set: function proxySetter (val) {\n      self._data[key] = val\n    }\n  })\n}\n\n/**\n * Unproxy a property.\n *\n * @param {String} key\n */\n\nexports._unproxy = function (key) {\n  delete this[key]\n}\n\n// /**\n//  * Force update on every watcher in scope.\n//  */\n\n// exports._digest = function () {\n//   var i = this._watchers.length\n//   while (i--) {\n//     this._watchers[i].update()\n//   }\n//   var children = this._children\n//   i = children.length\n//   while (i--) {\n//     var child = children[i]\n//     if (child.$options.inherit) {\n//       child._digest()\n//     }\n//   }\n// }\n\n/**\n * Setup computed properties. They are essentially\n * special getter/setters\n */\n\nfunction noop () {}\nexports._initComputed = function () {\n  // var computed = this.$options.computed\n  var computed = this._computed\n  if (computed) {\n    for (var key in computed) {\n      var userDef = computed[key]\n      var def = {\n        enumerable: true,\n        configurable: true\n      }\n      if (typeof userDef === 'function') {\n        def.get = _.bind(userDef, this)\n        def.set = noop\n      } else {\n        def.get = userDef.get\n          ? _.bind(userDef.get, this)\n          : noop\n        def.set = userDef.set\n          ? _.bind(userDef.set, this)\n          : noop\n      }\n      Object.defineProperty(this, key, def)\n    }\n  }\n}\n\n/**\n * Setup instance methods. Methods must be bound to the\n * instance since they might be called by children\n * inheriting them.\n */\n\nexports._initMethods = function () {\n  // var methods = this.$options.methods\n  var methods = this._methods\n  if (methods) {\n    for (var key in methods) {\n      this[key] = _.bind(methods[key], this)\n    }\n  }\n}\n\n// /**\n//  * Initialize meta information like $index, $key & $value.\n//  */\n\n// exports._initMeta = function () {\n//   var metas = this.$options._meta\n//   if (metas) {\n//     for (var key in metas) {\n//       this._defineMeta(key, metas[key])\n//     }\n//   }\n// }\n\n// /**\n//  * Define a meta property, e.g $index, $key, $value\n//  * which only exists on the vm instance but not in $data.\n//  *\n//  * @param {String} key\n//  * @param {*} value\n//  */\n\n// exports._defineMeta = function (key, value) {\n//   var dep = new Dep()\n//   Object.defineProperty(this, key, {\n//     enumerable: true,\n//     configurable: true,\n//     get: function metaGetter () {\n//       if (Observer.target) {\n//         Observer.target.addDep(dep)\n//       }\n//       return value\n//     },\n//     set: function metaSetter (val) {\n//       if (val !== value) {\n//         value = val\n//         dep.notify()\n//       }\n//     }\n//   })\n// }\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/instance/scope.js\n **/","// required for code in instance/observer\nmodule.exports = require('../util')\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/util.js\n **/","var _ = require('../util')\nvar config = require('../config')\nvar Dep = require('./dep')\nvar arrayMethods = require('./array')\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods)\nrequire('./object')\n\nvar uid = 0\n\n/**\n * Type enums\n */\n\nvar ARRAY  = 0\nvar OBJECT = 1\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n *\n * @param {Object|Array} target\n * @param {Object} proto\n */\n\nfunction protoAugment (target, src) {\n  target.__proto__ = src\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n *\n * @param {Object|Array} target\n * @param {Object} proto\n */\n\nfunction copyAugment (target, src, keys) {\n  var i = keys.length\n  var key\n  while (i--) {\n    key = keys[i]\n    _.define(target, key, src[key])\n  }\n}\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n *\n * @param {Array|Object} value\n * @param {Number} type\n * @constructor\n */\n\nfunction Observer (value, type) {\n  this.id = ++uid\n  this.value = value\n  this.active = true\n  this.deps = []\n  _.define(value, '__ob__', this)\n  if (type === ARRAY) {\n    var augment = config.proto && _.hasProto\n      ? protoAugment\n      : copyAugment\n    augment(value, arrayMethods, arrayKeys)\n    this.observeArray(value)\n  } else if (type === OBJECT) {\n    this.walk(value)\n  }\n}\n\nObserver.target = null\n\nvar p = Observer.prototype\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n *\n * @param {*} value\n * @return {Observer|undefined}\n * @static\n */\n\nObserver.create = function (value) {\n  if (\n    value &&\n    value.hasOwnProperty('__ob__') &&\n    value.__ob__ instanceof Observer\n  ) {\n    return value.__ob__\n  } else if (_.isArray(value)) {\n    return new Observer(value, ARRAY)\n  } else if (\n    _.isPlainObject(value) &&\n    !value._isVue // avoid Vue instance\n  ) {\n    return new Observer(value, OBJECT)\n  }\n}\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object. Properties prefixed with `$` or `_`\n * and accessor properties are ignored.\n *\n * @param {Object} obj\n */\n\np.walk = function (obj) {\n  var keys = Object.keys(obj)\n  var i = keys.length\n  var key, prefix\n  while (i--) {\n    key = keys[i]\n    prefix = key.charCodeAt(0)\n    if (prefix !== 0x24 && prefix !== 0x5F) { // skip $ or _\n      this.convert(key, obj[key])\n    }\n  }\n}\n\n/**\n * Try to carete an observer for a child value,\n * and if value is array, link dep to the array.\n *\n * @param {*} val\n * @return {Dep|undefined}\n */\n\np.observe = function (val) {\n  return Observer.create(val)\n}\n\n/**\n * Observe a list of Array items.\n *\n * @param {Array} items\n */\n\np.observeArray = function (items) {\n  var i = items.length\n  while (i--) {\n    this.observe(items[i])\n  }\n}\n\n/**\n * Convert a property into getter/setter so we can emit\n * the events when the property is accessed/changed.\n *\n * @param {String} key\n * @param {*} val\n */\n\np.convert = function (key, val) {\n  var ob = this\n  var childOb = ob.observe(val)\n  var dep = new Dep()\n  if (childOb) {\n    childOb.deps.push(dep)\n  }\n  Object.defineProperty(ob.value, key, {\n    enumerable: true,\n    configurable: true,\n    get: function () {\n      // Observer.target is a watcher whose getter is\n      // currently being evaluated.\n      if (ob.active && Observer.target) {\n        Observer.target.addDep(dep)\n      }\n      return val\n    },\n    set: function (newVal) {\n      if (newVal === val) return\n      // remove dep from old value\n      var oldChildOb = val && val.__ob__\n      if (oldChildOb) {\n        oldChildOb.deps.$remove(dep)\n      }\n      val = newVal\n      // add dep to new value\n      var newChildOb = ob.observe(newVal)\n      if (newChildOb) {\n        newChildOb.deps.push(dep)\n      }\n      dep.notify()\n    }\n  })\n}\n\n/**\n * Notify change on all self deps on an observer.\n * This is called when a mutable value mutates. e.g.\n * when an Array's mutating methods are called, or an\n * Object's $add/$delete are called.\n */\n\np.notify = function () {\n  var deps = this.deps\n  for (var i = 0, l = deps.length; i < l; i++) {\n    deps[i].notify()\n  }\n}\n\n/**\n * Add an owner vm, so that when $add/$delete mutations\n * happen we can notify owner vms to proxy the keys and\n * digest the watchers. This is only called when the object\n * is observed as an instance's root $data.\n *\n * @param {Vue} vm\n */\n\np.addVm = function (vm) {\n  (this.vms = this.vms || []).push(vm)\n}\n\n/**\n * Remove an owner vm. This is called when the object is\n * swapped out as an instance's $data object.\n *\n * @param {Vue} vm\n */\n\np.removeVm = function (vm) {\n  this.vms.$remove(vm)\n}\n\nmodule.exports = Observer\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/observer/index.js\n **/","module.exports = {proto: true}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/config.js\n **/","var _ = require('../util')\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n *\n * @constructor\n */\n\nfunction Dep () {\n  this.subs = []\n}\n\nvar p = Dep.prototype\n\n/**\n * Add a directive subscriber.\n *\n * @param {Directive} sub\n */\n\np.addSub = function (sub) {\n  this.subs.push(sub)\n}\n\n/**\n * Remove a directive subscriber.\n *\n * @param {Directive} sub\n */\n\np.removeSub = function (sub) {\n  this.subs.$remove(sub)\n}\n\n/**\n * Notify all subscribers of a new value.\n */\n\np.notify = function () {\n  // stablize the subscriber list first\n  var subs = _.toArray(this.subs)\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update()\n  }\n}\n\nmodule.exports = Dep\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/observer/dep.js\n **/","var _ = require('../util')\nvar arrayProto = Array.prototype\nvar arrayMethods = Object.create(arrayProto)\n\n/**\n * Intercept mutating methods and emit events\n */\n\n;[\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n]\n.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method]\n  _.define(arrayMethods, method, function mutator () {\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length\n    var args = new Array(i)\n    while (i--) {\n      args[i] = arguments[i]\n    }\n    var result = original.apply(this, args)\n    var ob = this.__ob__\n    var inserted\n    switch (method) {\n      case 'push':\n        inserted = args\n        break\n      case 'unshift':\n        inserted = args\n        break\n      case 'splice':\n        inserted = args.slice(2)\n        break\n    }\n    if (inserted) ob.observeArray(inserted)\n    // notify change\n    ob.notify()\n    return result\n  })\n})\n\n/**\n * Swap the element at the given index with a new value\n * and emits corresponding event.\n *\n * @param {Number} index\n * @param {*} val\n * @return {*} - replaced element\n */\n\n_.define(\n  arrayProto,\n  '$set',\n  function $set (index, val) {\n    if (index >= this.length) {\n      this.length = index + 1\n    }\n    return this.splice(index, 1, val)[0]\n  }\n)\n\n/**\n * Convenience method to remove the element at given index.\n *\n * @param {Number} index\n * @param {*} val\n */\n\n_.define(\n  arrayProto,\n  '$remove',\n  function $remove (index) {\n    /* istanbul ignore if */\n    if (!this.length) return\n    if (typeof index !== 'number') {\n      index = _.indexOf(this, index)\n    }\n    if (index > -1) {\n      this.splice(index, 1)\n    }\n  }\n)\n\nmodule.exports = arrayMethods\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/observer/array.js\n **/","var _ = require('../util')\nvar objProto = Object.prototype\n\n/**\n * Add a new property to an observed object\n * and emits corresponding event\n *\n * @param {String} key\n * @param {*} val\n * @public\n */\n\n_.define(\n  objProto,\n  '$add',\n  function $add (key, val) {\n    if (this.hasOwnProperty(key)) return\n    var ob = this.__ob__\n    if (!ob || _.isReserved(key)) {\n      this[key] = val\n      return\n    }\n    ob.convert(key, val)\n    ob.notify()\n    if (ob.vms) {\n      var i = ob.vms.length\n      while (i--) {\n        var vm = ob.vms[i]\n        vm._proxy(key)\n        // vm._digest() // todo\n      }\n    }\n  }\n)\n\n/**\n * Set a property on an observed object, calling add to\n * ensure the property is observed.\n *\n * @param {String} key\n * @param {*} val\n * @public\n */\n\n_.define(\n  objProto,\n  '$set',\n  function $set (key, val) {\n    this.$add(key, val)\n    this[key] = val\n  }\n)\n\n/**\n * Deletes a property from an observed object\n * and emits corresponding event\n *\n * @param {String} key\n * @public\n */\n\n_.define(\n  objProto,\n  '$delete',\n  function $delete (key) {\n    if (!this.hasOwnProperty(key)) return\n    delete this[key]\n    var ob = this.__ob__\n    if (!ob || _.isReserved(key)) {\n      return\n    }\n    ob.notify()\n    if (ob.vms) {\n      var i = ob.vms.length\n      while (i--) {\n        var vm = ob.vms[i]\n        vm._unproxy(key)\n        // vm._digest() // todo\n      }\n    }\n  }\n)\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/observer/object.js\n **/"," /**\n * @fileOverview\n * ViewModel template parser & data-binding process\n *\n * required:\n * index.js: Vm\n * dom-helper.js: _createElement, _createBlock\n * dom-helper.js: _attachTarget, _moveTarget, _removeTarget\n * directive.js: _bindElement, _bindSubVm, _watch\n * events.js: $on\n */\n\n/**\n * build(externalDirs)\n *   createVm()\n *   merge(externalDirs, dirs)\n *   generate(template, parentNode)\n *     if (type is content) create contentNode\n *     else if (dirs have v-for) foreach -> create context\n *       -> generate(templateWithoutFor, parentNode): diff(list) onchange\n *     else if (dirs have v-if) assert\n *       -> generate(templateWithoutIf, parentNode): toggle(shown) onchange\n *     else if (type is native)\n *       set(dirs): update(id/attr/style/class) onchange\n *       append(template, parentNode)\n *       foreach childNodes -> generate(childNode, template)\n *     else if (type is custom)\n *       addChildVm(vm, parentVm)\n *       build(externalDirs)\n *       foreach childNodes -> generate(childNode, template)\n */\nexport function _build() {\n  const opt = this._options || {}\n  const template = opt.template || {}\n\n  if (opt.replace) {\n    if (template.children && template.children.length === 1) {\n      this._generate(template.children[0], this._parentEl)\n    }\n    else {\n      this._generate(template.children, this._parentEl)\n    }\n  }\n  else {\n    this._generate(template, this._parentEl)\n  }\n\n  this.$emit('hook:ready')\n  this._ready = true\n}\n\n/**\n * Generate elements by child or children and append to parent elements.\n * Root element info would be merged if has. The first argument may be an array\n * if the root element with options.replace has not only one child.\n *\n * @param  {object|array} target\n * @param  {object} parentEl\n * @param  {object} context\n */\nexport function _generate(target, parentEl, context) {\n\n  if (Array.isArray(target)) {\n    const fragBlock = this._createBlock(parentEl)\n    target.forEach((child) => {\n      this._generate(child, fragBlock, context)\n    })\n    return\n  }\n\n  context = context || {}\n\n  if (target.type === 'content' || target.type === 'slot') {\n    this._content = this._createBlock(parentEl)\n    return\n  }\n\n  if (!context.hasOwnProperty('repeat') && target.repeat) {\n    const list = target.repeat.call(this)\n    const repeatId = latestRepeatId++\n    const latestItemId = markList(list, repeatId)\n\n    const fragBlock = this._createBlock(parentEl)\n    fragBlock.children = []\n    fragBlock.data = list.slice(0)\n\n    this._checkRepeat(target, fragBlock, repeatId, latestItemId)\n\n    list.forEach((item, index) => {\n      if (typeof item === 'object') {\n        item.INDEX = index\n      }\n      this._generate(target, fragBlock, {repeat: item})\n    })\n\n    return\n  }\n\n  let subContext = this\n  if (context.repeat && !context.shown) {\n    subContext = this._mergeContext(context.repeat)\n  }\n\n  if (!context.hasOwnProperty('shown') && target.shown) {\n    const display = target.shown.call(subContext)\n    const newContext = {shown: true}\n    const fragBlock = subContext._createBlock(parentEl)\n\n    if (parentEl.element && parentEl.children) {\n      parentEl.children.push(fragBlock)\n    }\n\n    if (context.repeat) {\n      newContext.repeat = context.repeat\n    }\n\n    fragBlock.display = !!display\n    subContext._checkDisplay(target, fragBlock, newContext)\n\n    if (display) {\n      subContext._generate(target, fragBlock, newContext)\n    }\n\n    return\n  }\n\n  let typeGetter = target.type\n  let type = typeGetter\n\n  if (typeof typeGetter === 'function') {\n    type = typeGetter.call(subContext)\n\n    if (!context.hasOwnProperty('type')) {\n      const newContext = {type: type}\n      const fragBlock = subContext._createBlock(parentEl)\n\n      if (parentEl.element && parentEl.children) {\n        parentEl.children.push(fragBlock)\n      }\n\n      subContext._watch(typeGetter, (value) => {\n        subContext._removeBlock(fragBlock, true)\n        subContext._generate(target, fragBlock, {type: value})\n      })\n\n      subContext._generate(target, fragBlock, newContext)\n\n      return\n    }\n  }\n\n  let isComponent\n  if (this._app && this._app.customComponentMap && type) {\n    isComponent = this._app.customComponentMap[type]\n  }\n  else {\n    isComponent = target.component\n  }\n\n  if (isComponent) {\n    const Vm = this.constructor\n    const subVm = new Vm(type, subContext, parentEl, undefined, {\n      'hook:init': function () {\n        subContext._setId(target.id, null, this)\n      },\n      'hook:created': function () {\n        subContext._bindSubVm(this, target, context.repeat)\n      },\n      'hook:ready': function () {\n        if (this._content) {\n          subContext._setChildren(target, this._content)\n        }\n      }\n    })\n    subContext._bindSubVmAfterInitialized(subVm, target)\n    return\n  }\n\n  const element = subContext._generateElement(type, target, parentEl)\n  const treeMode = target.append === 'tree'\n  if (!treeMode) {\n    subContext._attachTarget(element, parentEl)\n  }\n  subContext._setChildren(target, element)\n  if (treeMode) {\n    subContext._attachTarget(element, parentEl)\n  }\n}\n\n/**\n * Generate element from template and attach to the dest if needed.\n * The time to attach depends on whether the mode status is node or tree.\n *\n * @param  {object} template\n * @param  {object} dest\n */\nexport function _generateElement(type, template, dest) {\n\n  this._applyNaitveComponentOptions(template)\n\n  let element\n  if (dest.ref === '_documentElement') {\n    // if its parent is documentElement then it's a body\n    element = this._createBody(type)\n  } else {\n    element = this._createElement(type)\n  }\n  // TODO it was a root element when not in a fragment\n  if (!this._rootEl) {\n    this._rootEl = element\n  }\n\n  this._bindElement(element, template)\n\n  if (template.attr && template.attr.append) { // backward, append prop in attr\n    element.append = template.attr.append\n  }\n\n  return element\n}\n\n/**\n * Set all children to a certain parent element.\n *\n * @param {object} template\n * @param {object} parentEl\n */\nexport function _setChildren(template, parentEl) {\n  const children = template.children\n  if (children && children.length) {\n    children.forEach((child) => {\n      this._generate(child, parentEl)\n    })\n  }\n}\n\n/**\n * Watch the list update and refresh the changes.\n *\n * @param  {object} target\n * @param  {object} fragBlock\n */\nexport function _checkRepeat(target, fragBlock, repeatId, latestItemId) {\n  const children = fragBlock.children\n\n  this._watchBlock(fragBlock, target.repeat, 'repeat', (value) => {\n    if (!fragBlock) {\n      return\n    }\n\n    const oldChildren = children.slice()\n    const oldValue = fragBlock.data.slice()\n    // 1. collect all new refs track by\n    const trackMap = {}\n    const reusedMap = {}\n    value.forEach((item, index) => {\n      let key = item[`__wx_repeat_${repeatId}__`]\n      if (!key) {\n        key = latestItemId++\n        setRepeatItemId(item, repeatId, key)\n      }\n      trackMap[key] = item\n    })\n\n    // 2. remove unused element foreach old item\n    const reusedList = []\n    oldValue.forEach((item, index) => {\n      const key = item[`__wx_repeat_${repeatId}__`]\n      if (trackMap.hasOwnProperty(key)) {\n        reusedMap[key] = {item, index, target: oldChildren[index]}\n        reusedList.push(item)\n      }\n      else {\n        this._removeTarget(oldChildren[index])\n      }\n    })\n\n    // 3. create new element foreach new item\n    children.length = 0\n    fragBlock.data = value.slice()\n    fragBlock.updateMark = fragBlock.start\n\n    value.forEach((item, index) => {\n      const key = item[`__wx_repeat_${repeatId}__`]\n      const reused = reusedMap[key]\n      if (typeof item === 'object') {\n        item.INDEX = index\n      }\n      if (reused) {\n        if (reused.item === reusedList[0]) {\n          reusedList.shift()\n        } else {\n          reusedList.$remove(reused.item)\n          this._moveTarget(reused.target, fragBlock.updateMark, true)\n        }\n        children.push(reused.target)\n        fragBlock.updateMark = reused.target\n      }\n      else {\n        this._generate(target, fragBlock, {repeat: item})\n      }\n    })\n\n    delete fragBlock.updateMark\n  })\n}\n\nlet latestRepeatId = 1\n\nfunction markList(list, repeatId) {\n  let latestItemId = 1\n  list.forEach((item) => {\n    setRepeatItemId(item, repeatId, latestItemId++)\n  })\n  return latestItemId\n}\n\nfunction setRepeatItemId(item, repeatId, itemId) {\n  const key = `__wx_repeat_${repeatId}__`\n  if (typeof item === 'object') {\n    Object.defineProperty(item, key, {\n      value: itemId\n    })\n  }\n}\n\n/**\n * Watch the display update and add/remove the element.\n *\n * @param  {object} target\n * @param  {object} fragBlock\n * @param  {object} context\n */\nexport function _checkDisplay(target, fragBlock, context) {\n\n  this._watchBlock(fragBlock, target.shown, 'shown', (value) => {\n    if (!fragBlock || !!fragBlock.display === !!value) {\n      return\n    }\n    fragBlock.display = value\n    if (value) {\n      this._generate(target, fragBlock, context)\n    }\n    else {\n      this._removeBlock(fragBlock, true)\n    }\n  })\n}\n\nexport function _watchBlock(fragBlock, calc, type, handler) {\n  const differ = this && this._app && this._app.differ\n  const config = {}\n  const depth = (fragBlock.element.depth || 0) + 1\n\n  this._watch(calc, (value) => {\n    config.latestValue = value\n    if (differ && !config.recorded) {\n      differ.append(type, depth, fragBlock.blockId, () => {\n        const latestValue = config.latestValue\n        handler(latestValue)\n        config.recorded = false\n        config.latestValue = undefined\n      })\n    }\n    config.recorded = true\n  })\n}\n\n/**\n * Clone a context and merge certain data.\n *\n * @param  {object} mergedData\n * @return {object}\n */\nexport function _mergeContext(mergedData) {\n  const context = Object.create(this)\n  context._data = mergedData\n  context._initData()\n  context._realParent = this\n  return context\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/compiler.js\n **/","/**\n * @fileOverview\n * Directive Parser\n */\n\nimport {bind, extend} from '../util'\n\nimport Watcher from './watcher'\nimport {nativeComponentMap} from '../config'\n\nconst SETTERS = {\n  attr: 'setAttr',\n  style: 'setStyle',\n  event: 'addEvent'\n}\n\n/**\n * apply the native component's options(specified by template.type)\n * to the template\n */\nexport function _applyNaitveComponentOptions(template) {\n  const {type} = template\n  const options = nativeComponentMap[type]\n\n  if (typeof options === 'object') {\n    extend(template, options)\n  }\n}\n\n/**\n * bind all id, attr, classnames, style, events to an element\n */\nexport function _bindElement(el, template) {\n  this._setId(template.id, el, this)\n  this._setAttr(el, template.attr)\n  this._setClass(el, template.classList)\n  this._setStyle(el, template.style)\n  this._bindEvents(el, template.events)\n}\n\n/**\n * bind all props to sub vm and bind all style, events to the root element\n * of the sub vm if it doesn't have a replaced multi-node fragment\n */\nexport function _bindSubVm(subVm, template, repeatItem) {\n  subVm = subVm || {}\n  template = template || {}\n\n  const options = subVm._options || {}\n\n  // bind props\n  let props = options.props\n\n  if (Array.isArray(props)) {\n    props = props.reduce((result, value) => {\n      result[value] = true\n      return result\n    }, {})\n  }\n\n  mergeProps(repeatItem, props, this, subVm)\n  mergeProps(template.attr, props, this, subVm)\n}\n\nexport function _bindSubVmAfterInitialized(subVm, template) {\n  mergeClassStyle(template.classList, this, subVm)\n  mergeStyle(template.style, this, subVm)\n  mergeEvent(template.events, this, subVm)\n}\n\nfunction mergeProps(target, props, vm, subVm) {\n  if (!target) {\n    return\n  }\n  for (const key in target) {\n    if (!props || props[key]) {\n      const value = target[key]\n      if (typeof value === 'function') {\n        const returnValue = vm._watch(value, function (v) {\n          subVm[key] = v\n        })\n        subVm[key] = returnValue\n      }\n      else {\n        subVm[key] = value\n      }\n    }\n  }\n}\n\nfunction mergeStyle(target, vm, subVm) {\n  for (const key in target) {\n    const value = target[key]\n    if (typeof value === 'function') {\n      const returnValue = vm._watch(value, function (v) {\n        if (subVm._rootEl) {\n          subVm._rootEl.setStyle(key, v)\n        }\n      })\n      subVm._rootEl.setStyle(key, returnValue)\n    }\n    else {\n      if (subVm._rootEl) {\n        subVm._rootEl.setStyle(key, value)\n      }\n    }\n  }\n}\n\nfunction mergeClassStyle(target, vm, subVm) {\n  var css = vm._options && vm._options.style || {}\n\n  if (!subVm._rootEl) {\n    return\n  }\n\n  if (typeof target === 'function') {\n    const value = vm._watch(target,  v => {\n      setClassStyle(subVm._rootEl, css, v)\n    })\n    setClassStyle(subVm._rootEl, css, value)\n  } else if (target) {\n    setClassStyle(subVm._rootEl, css, target)\n  }\n}\n\nfunction mergeEvent(target, vm, subVm) {\n  if (target && subVm._rootEl) {\n    for (const type in target) {\n      const handler = vm[target[type]]\n      if (handler) {\n        subVm._rootEl.addEvent(type, bind(handler, vm))\n      }\n    }\n  }\n}\n\n/**\n * bind id to an element\n * each id is unique in a whole vm\n */\nexport function _setId(id, el, vm) {\n  const map = Object.create(null)\n\n  Object.defineProperties(map, {\n    vm: {\n      value: vm,\n      writable: false,\n      configurable: false\n    },\n    el: {\n      get: () => el || vm._rootEl,\n      configurable: false\n    }\n  })\n\n  if (typeof id === 'function') {\n    const handler = id\n    id = handler.call(this)\n    if (id) {\n      this._ids[id] = map\n    }\n    this._watch(handler, (newId) => {\n      if (newId) {\n        this._ids[newId] = map\n      }\n    })\n  }\n  else if (id && typeof id === 'string') {\n    this._ids[id] = map\n  }\n}\n\n/**\n * bind attr to an element\n */\nexport function _setAttr(el, attr) {\n  this._bindDir(el, 'attr', attr)\n}\n\nfunction setClassStyle(el, css, classList) {\n  const classStyle = {}\n  const length = classList.length\n\n  for (let i = 0; i < length; i++) {\n    const style = css[classList[i]]\n    if (style) {\n      for (const key in style) {\n        classStyle[key] = style[key]\n      }\n    }\n  }\n  el.setClassStyle(classStyle)\n}\n\n/**\n * bind classnames to an element\n */\nexport function _setClass(el, classList) {\n\n  if (typeof classList !== 'function' && !Array.isArray(classList)) {\n    return\n  }\n  if (Array.isArray(classList) && !classList.length) {\n    el.setClassStyle({})\n    return\n  }\n\n  const style = this._options && this._options.style || {}\n  if (typeof classList === 'function') {\n    const value = this._watch(classList,  v => {\n      setClassStyle(el, style, v)\n    })\n    setClassStyle(el, style, value)\n  }\n  else {\n    setClassStyle(el, style, classList)\n  }\n}\n\n/**\n * bind style to an element\n */\nexport function _setStyle(el, style) {\n  this._bindDir(el, 'style', style)\n}\n\n/**\n * add an event type and handler to an element and generate a dom update\n */\nexport function _setEvent(el, type, handler) {\n  el.addEvent(type, bind(handler, this))\n}\n\n/**\n * add all events of an element\n */\nexport function _bindEvents(el, events) {\n  if (!events) {\n    return\n  }\n  const keys = Object.keys(events)\n  let i = keys.length\n  while (i--) {\n    const key = keys[i]\n    let handler = events[key]\n    if (typeof handler === 'string') {\n      handler = this[handler]\n    }\n    this._setEvent(el, key, handler)\n  }\n}\n\n/**\n * set a series of members as a kind of an element\n * for example: style, attr, ...\n * if the value is a function then bind the data changes\n */\nexport function _bindDir(el, name, data) {\n  if (!data) {\n    return\n  }\n  const keys = Object.keys(data)\n  let i = keys.length\n  while (i--) {\n    const key = keys[i]\n    const value = data[key]\n    if (typeof value === 'function') {\n      const update = value\n      this._bindKey(el, name, key, update)\n    }\n    else {\n      el[SETTERS[name]](key, value)\n    }\n  }\n}\n\n/**\n * bind data changes to a certain key to a name series in an element\n */\nexport function _bindKey(el, name, key, calc) {\n  const methodName = SETTERS[name]\n  const obj = el[name]\n  // watch the calc, and returns a value by calc.call()\n  const value = this._watch(calc, (value) => {\n    function handler() {\n      el[methodName](key, value)\n    }\n    const differ = this && this._app && this._app.differ\n    if (differ) {\n      differ.append('element', el.depth, el.ref, handler)\n    }\n    else {\n      handler()\n    }\n  })\n\n  el[methodName](key, value)\n}\n\n/**\n * watch a calc function and callback if the calc value changes\n */\nexport function _watch(calc, callback) {\n  const watcher = new Watcher(this, calc, function (value, oldValue) {\n    /* istanbul ignore if */\n    if (typeof value !== 'object' && value === oldValue) {\n      return\n    }\n    callback(value)\n  })\n\n  return watcher.value\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/directive.js\n **/","/**\n * The MIT License (MIT)\n *\n * Copyright (c) 2013-2015 Yuxi Evan You\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nvar _ = require('./util')\n// var config = require('./config')\nvar Observer = require('./observer')\n// var expParser = require('./parsers/expression')\n// var batcher = require('./batcher')\nvar uid = 0\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n *\n * @param {Vue} vm\n * @param {String} expression\n * @param {Function} cb\n * @param {Object} options\n *                 - {Array} filters\n *                 - {Boolean} twoWay\n *                 - {Boolean} deep\n *                 - {Boolean} user\n *                 - {Function} [preProcess]\n * @constructor\n */\n\n// function Watcher (vm, expression, cb, options) {\nfunction Watcher (vm, update, cb) {\n  this.vm = vm\n  vm._watchers.push(this)\n  // this.expression = expression\n  this.cb = cb\n  this.id = ++uid // uid for batching\n  this.active = true\n  // options = options || {}\n  // this.deep = !!options.deep\n  // this.user = !!options.user\n  // this.twoWay = !!options.twoWay\n  // this.filters = options.filters\n  // this.preProcess = options.preProcess\n  this.deps = []\n  this.newDeps = []\n  // parse expression for getter/setter\n  // var res = expParser.parse(expression, options.twoWay)\n  // this.getter = res.get\n  // this.setter = res.set\n  this.getter = update\n  this.value = this.get()\n}\n\nvar p = Watcher.prototype\n\n/**\n * Add a dependency to this directive.\n *\n * @param {Dep} dep\n */\n\np.addDep = function (dep) {\n  var newDeps = this.newDeps\n  var old = this.deps\n  if (_.indexOf(newDeps, dep) < 0) {\n    newDeps.push(dep)\n    var i = _.indexOf(old, dep)\n    if (i < 0) {\n      dep.addSub(this)\n    } else {\n      old[i] = null\n    }\n  }\n}\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\n\np.get = function () {\n  this.beforeGet()\n  var vm = this.vm\n  var value\n  try {\n    value = this.getter.call(vm, vm)\n  } catch (e) {\n    // if (config.warnExpressionErrors) {\n    //   _.warn(\n    //     'Error when evaluating expression \"' +\n    //     this.expression + '\":\\n   ' + e\n    //   )\n    // }\n    _.warn('Error when update\"')\n  }\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value)\n  }\n  if (this.preProcess) {\n    value = this.preProcess(value)\n  }\n  if (this.filters) {\n    value = vm._applyFilters(value, null, this.filters, false)\n  }\n  this.afterGet()\n  return value\n}\n\n// /**\n//  * Set the corresponding value with the setter.\n//  *\n//  * @param {*} value\n//  */\n\n// p.set = function (value) {\n//   var vm = this.vm\n//   if (this.filters) {\n//     value = vm._applyFilters(\n//       value, this.value, this.filters, true)\n//   }\n//   try {\n//     this.setter.call(vm, vm, value)\n//   } catch (e) {\n//     // if (config.warnExpressionErrors) {\n//       _.warn(\n//         'Error when evaluating setter \"' +\n//         this.expression + '\":\\n   ' + e\n//       )\n//     // }\n//   }\n// }\n\n/**\n * Prepare for dependency collection.\n */\n\np.beforeGet = function () {\n  Observer.target = this\n}\n\n/**\n * Clean up for dependency collection.\n */\n\np.afterGet = function () {\n  Observer.target = null\n  var i = this.deps.length\n  while (i--) {\n    var dep = this.deps[i]\n    if (dep) {\n      dep.removeSub(this)\n    }\n  }\n  this.deps = this.newDeps\n  this.newDeps = []\n}\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\n\n// p.update = function () {\n//   if (!config.async || config.debug) {\n//     this.run()\n//   } else {\n//     batcher.push(this)\n//   }\n// }\n\n// /**\n//  * Batcher job interface.\n//  * Will be called by the batcher.\n//  */\n\n// p.run = function () {\np.update = function () {\n  if (this.active) {\n    var value = this.get()\n    if (\n      value !== this.value ||\n      Array.isArray(value) ||\n      this.deep\n    ) {\n      var oldValue = this.value\n      this.value = value\n      this.cb(value, oldValue)\n    }\n  }\n}\n\n/**\n * Remove self from all dependencies' subcriber list.\n */\n\np.teardown = function () {\n  if (this.active) {\n    // remove self from vm's watcher list\n    // we can skip this if the vm if being destroyed\n    // which can improve teardown performance.\n    if (!this.vm._isBeingDestroyed) {\n      this.vm._watchers.$remove(this)\n    }\n    var i = this.deps.length\n    while (i--) {\n      this.deps[i].removeSub(this)\n    }\n    this.active = false\n    this.vm = this.cb = this.value = null\n  }\n}\n\n\n/**\n * Recrusively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n *\n * @param {Object} obj\n */\n\nfunction traverse (obj) {\n  var key, val, i\n  for (key in obj) {\n    val = obj[key]\n    if (_.isArray(val)) {\n      i = val.length\n      while (i--) {traverse(val[i])}\n    } else if (_.isObject(val)) {\n      traverse(val)\n    }\n  }\n}\n\nmodule.exports = Watcher\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/watcher.js\n **/","/**\n * @fileOverview Document & Element Helpers.\n *\n * required:\n * Document#: createElement, createComment, getRef\n * Element#: appendChild, insertBefore, removeChild, nextSibling\n */\n\n/**\n * Create a body by type\n * Using this._app.doc\n *\n * @param  {string} type\n */\nexport function _createBody(type) {\n  const doc = this._app.doc\n  return doc.createBody(type)\n}\n\n/**\n * Create an element by type\n * Using this._app.doc\n *\n * @param  {string} type\n */\nexport function _createElement(type) {\n  const doc = this._app.doc\n  return doc.createElement(type)\n}\n\n/**\n * Create and return a frag block for an element.\n * The frag block has a starter, ender and the element itself.\n *\n * @param  {object} element\n */\nexport function _createBlock(element) {\n  const start = this._createBlockStart()\n  const end = this._createBlockEnd()\n  const blockId = lastestBlockId++\n  if (element.element) {\n    element.element.insertBefore(start, element.end)\n    element.element.insertBefore(end, element.end)\n    element = element.element\n  }\n  else {\n    element.appendChild(start)\n    element.appendChild(end)\n  }\n  return {start, end, element, blockId}\n}\n\nlet lastestBlockId = 1\n\n/**\n * Create and return a block starter.\n * Using this._app.doc\n */\nexport function _createBlockStart() {\n  const doc = this._app.doc\n  const anchor = doc.createComment('start')\n  return anchor\n}\n\n/**\n * Create and return a block ender.\n * Using this._app.doc\n */\nexport function _createBlockEnd() {\n  const doc = this._app.doc\n  const anchor = doc.createComment('end')\n  return anchor\n}\n\n/**\n * Attach target to a certain dest using appendChild by default.\n * If the dest is a frag block then insert before the ender.\n * If the target is a frag block then attach the starter and ender in order.\n *\n * @param  {object} target\n * @param  {object} dest\n */\nexport function _attachTarget(target, dest) {\n\n  if (dest.element) {\n    const before = dest.end\n    const after = dest.updateMark\n    // push new target for watch list update later\n    if (dest.children) {\n      dest.children.push(target)\n    }\n    // for check repeat case\n    if (after) {\n      this._moveTarget(target, after)\n      dest.updateMark = target.element ? target.end : target\n    }\n    else if (target.element) {\n      dest.element.insertBefore(target.start, before)\n      dest.element.insertBefore(target.end, before)\n    }\n    else {\n      dest.element.insertBefore(target, before)\n    }\n  }\n  else {\n    if (target.element) {\n      dest.appendChild(target.start)\n      dest.appendChild(target.end)\n    }\n    else {\n      dest.appendChild(target)\n    }\n  }\n}\n\n/**\n * Move target before a certain element. The target maybe block or element.\n *\n * @param  {object} target\n * @param  {object} before\n */\nexport function _moveTarget(target, after) {\n  if (target.element) {\n    this._moveBlock(target, after)\n  }\n  else {\n    this._moveElement(target, after)\n  }\n}\n\n/**\n * Move element before a certain element.\n *\n * @param  {object} element\n * @param  {object} before\n */\nexport function _moveElement(element, after) {\n  const doc = this._app.doc\n  const parent = doc.getRef(after.parentRef)\n\n  if (parent) {\n    parent.insertAfter(element, after)\n  }\n}\n\n/**\n * Move all elements of the block before a certain element.\n *\n * @param  {object} fragBlock\n * @param  {object} before\n */\nexport function _moveBlock(fragBlock, after) {\n  const doc = this._app.doc\n  const parent = doc.getRef(after.parentRef)\n\n  if (parent) {\n    let el = fragBlock.start\n    const group = [el]\n\n    while (el && el !== fragBlock.end) {\n      el = el.next()\n      group.push(el)\n    }\n\n    let temp = after\n    group.forEach((el) => {\n      parent.insertAfter(el, temp)\n      temp = el\n    })\n  }\n}\n\n/**\n * Remove target from DOM tree.\n * If the target is a frag block then call _removeBlock\n *\n * @param  {object} target\n */\nexport function _removeTarget(target) {\n\n  if (target.element) {\n    this._removeBlock(target)\n  }\n  else {\n    this._removeElement(target)\n  }\n}\n\n/**\n * Remove a certain element.\n * Using this._app.doc\n *\n * @param  {object} target\n */\nexport function _removeElement(target) {\n  const doc = this._app.doc\n  const parent = doc.getRef(target.parentRef)\n\n  if (parent) {\n    parent.removeChild(target)\n  }\n}\n\n/**\n * Remove a frag block.\n * The second param decides whether the block self should be removed too.\n *\n * @param  {object}  fragBlock\n * @param  {Boolean} preserveBlock=false\n */\nexport function _removeBlock(fragBlock, preserveBlock = false) {\n  const result = []\n  let el = fragBlock.start.next()\n\n  while (el && el !== fragBlock.end) {\n    result.push(el)\n    el = el.next()\n  }\n\n  if (!preserveBlock) {\n    this._removeElement(fragBlock.start)\n  }\n  result.forEach((el) => {\n    this._removeElement(el)\n  })\n  if (!preserveBlock) {\n    this._removeElement(fragBlock.end)\n  }\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/dom-helper.js\n **/","function Evt(type, detail) {\n  if (detail instanceof Evt) {\n    return detail\n  }\n\n  this.timestamp = Date.now()\n  this.detail = detail\n  this.type = type\n\n  let shouldStop = false\n  this.stop = function () {\n    shouldStop = true\n  }\n  this.hasStopped = function () {\n    return shouldStop\n  }\n}\n\nexport function $emit(type, detail) {\n  const events = this._vmEvents\n  const handlerList = events[type]\n  if (handlerList) {\n    let evt = new Evt(type, detail)\n    handlerList.forEach((handler) => {\n      handler.call(this, evt)\n    })\n  }\n}\n\nexport function $dispatch(type, detail) {\n  const evt = new Evt(type, detail)\n  this.$emit(type, evt)\n\n  if (!evt.hasStopped() && this._parent && this._parent.$dispatch) {\n    this._parent.$dispatch(type, evt)\n  }\n}\n\nexport function $broadcast(type, detail) {\n  const evt = new Evt(type, detail)\n  this.$emit(type, evt)\n\n  if (!evt.hasStopped() && this._childrenVms) {\n    this._childrenVms.forEach((subVm) => {\n      subVm.$broadcast(type, evt)\n    })\n  }\n}\n\nexport function $on(type, handler) {\n  if (!type || typeof handler !== 'function') {\n    return\n  }\n  const events = this._vmEvents\n  const handlerList = events[type] || []\n  handlerList.push(handler)\n  events[type] = handlerList\n\n  // fixed old version lifecycle design\n  if (type === 'hook:ready' && this._ready) {\n    this.$emit('hook:ready')\n  }\n}\n\nexport function $off(type, handler) {\n  if (!type) {\n    return\n  }\n  const events = this._vmEvents\n  if (!handler) {\n    delete events[type]\n    return\n  }\n  const handlerList = events[type]\n  if (!handlerList) {\n    return\n  }\n  handlerList.$remove(handler)\n}\n\nconst LIFE_CYCLE_TYPES = ['init', 'created', 'ready']\n\nexport function _initEvents(externalEvents) {\n  const options = this._options || {}\n  const events = options.events || {}\n  for (const type1 in events) {\n    this.$on(type1, events[type1])\n  }\n  for (const type2 in externalEvents) {\n    this.$on(type2, externalEvents[type2])\n  }\n  LIFE_CYCLE_TYPES.forEach((type) => {\n    this.$on(`hook:${type}`, options[type])\n  })\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/vm/events.js\n **/","let nativeModules = {}\n\nfunction assignModules(modules, ifReplace) {\n\n  for (const moduleName in modules) {\n\n    // init `modules[moduleName][]`\n    let methods = nativeModules[moduleName]\n    if (!methods) {\n      methods = {}\n      nativeModules[moduleName] = methods\n    }\n\n    // push each non-existed new method\n    modules[moduleName].forEach(function (method) {\n      if (typeof method === 'string') {\n        method = {\n          name: method\n        }\n      }\n\n      if (!methods[method.name] || ifReplace) {\n        methods[method.name] = method\n      }\n    })\n  }\n}\n\nfunction assignApis(Ctor, apis) {\n  const p = Ctor.prototype\n\n  for (const apiName in apis) {\n    if (!p.hasOwnProperty(apiName)) {\n      p[apiName] = apis[apiName]\n    }\n  }\n}\n\nexport function clearModules() {\n  nativeModules = {}\n}\n\nexport function getModule(moduleName) {\n  return nativeModules[moduleName]\n}\n\n/**\n * @context a instance of AppInstance\n */\nexport function requireModule(moduleName) {\n  const methods = nativeModules[moduleName]\n  const target = {}\n\n  for (const methodName in methods) {\n    target[methodName] = (...args) => this.callTasks({\n      module: moduleName,\n      method: methodName,\n      args: args\n    })\n  }\n\n  return target\n}\n\n/**\n * @context Vm\n */\nexport function registerModules(modules, ifReplace) {\n  assignModules(modules, ifReplace)\n}\n\n/**\n * @context Vm\n */\nexport function registerMethods(apis) {\n  assignApis(this, apis)\n}\n\n/**\n * @context a instance of AppInstance\n */\nexport function requireComponent(name) {\n  const {customComponentMap} = this\n  return customComponentMap[name]\n}\n\n/**\n * @context a instance of AppInstance\n */\nexport function registerComponent(name, exports) {\n  const {customComponentMap} = this\n\n  if (customComponentMap[name]) {\n    throw new Error(`define a component(${name}) that already exists`)\n  }\n\n  customComponentMap[name] = exports\n}\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/register.js\n **/","import semver from 'semver'\nimport {extend, isPlainObject, typof}  from '../util'\n\n/**\n * [normalizeVersion description]\n * @param  {String} Version. ie: 1, 1.0, 1.0.0\n * @return {String} Version\n */\nexport function normalizeVersion (v) {\n  const isValid = semver.valid(v) ? true : false\n  if (isValid) {\n    return v\n  }\n\n  v = typeof (v) === 'string' ? v : ''\n  const split = v.split('.')\n  let i = 0\n  let result = []\n\n  while (i < 3) {\n    const s = typeof (split[i]) === 'string' && split[i] ? split[i] : '0'\n    result.push(s)\n    i++\n  }\n\n  return result.join('.')\n}\n\nexport function getError (key, val, criteria) {\n  let result = {\n    isDowngrade: true,\n    errorType: 1,\n    code: 1000\n  }\n  let getMsg = function (key, val, criteria) {\n    return 'Downgrade[' + key + '] :: deviceInfo '\n      + val + ' matched criteria ' + criteria\n  }\n  const _key = key.toLowerCase()\n\n  result.errorMessage = getMsg(key, val, criteria)\n\n  if (_key.indexOf('osversion') >= 0) {\n    result.code = 1001\n  }else if (_key.indexOf('appversion') >= 0) {\n    result.code = 1002\n  }else if (_key.indexOf('weexversion') >= 0) {\n    result.code = 1003\n  }else if (_key.indexOf('devicemodel') >= 0) {\n    result.code = 1004\n  }\n\n  return result\n}\n\n/**\n * WEEX framework input(deviceInfo)\n * {\n *   platform: 'iOS' or 'android'\n *   osVersion: '1.0.0' or '1.0' or '1'\n *   appVersion: '1.0.0' or '1.0' or '1'\n *   weexVersion: '1.0.0' or '1.0' or '1'\n *   dDeviceModel: 'MODEL_NAME'\n * }\n *\n * downgrade config(config)\n * {\n *   ios: {\n *     osVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0'\n *     appVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0'\n *     weexVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0'\n *     deviceModel: ['modelA', 'modelB', ...]\n *   },\n *   android: {\n *     osVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0'\n *     appVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0'\n *     weexVersion: '>1.0.0' or '>=1.0.0' or '<1.0.0' or '<=1.0.0' or '1.0.0'\n *     deviceModel: ['modelA', 'modelB', ...]\n *   }\n * }\n *\n *\n * @param  {object} deviceInfo Weex SDK framework input\n * @param  {object} config     user input\n * @return {Object}            { isDowngrade: true/false, errorMessage... }\n */\nexport function check (config, deviceInfo) {\n  deviceInfo = deviceInfo || global.WXEnvironment\n  deviceInfo = isPlainObject(deviceInfo) ? deviceInfo : {}\n  config = isPlainObject(config) ? config : {}\n  const platform = deviceInfo.platform || 'unknow'\n  const dPlatform = platform.toLowerCase()\n  const cObj = config[dPlatform] || {}\n\n  let result = {\n    isDowngrade: false // defautl is pass\n  }\n\n  for (let i in deviceInfo) {\n    const key = i\n    const keyLower = key.toLowerCase()\n    const val = deviceInfo[i]\n    const isVersion = keyLower.indexOf('version') >= 0 ? true : false\n    const isDeviceModel = keyLower.indexOf('devicemodel') >= 0 ? true : false\n    const criteria = cObj[i]\n\n    if (criteria && isVersion) {\n      const c = this.normalizeVersion(criteria)\n      const d = this.normalizeVersion(deviceInfo[i])\n\n      if (semver.satisfies(d, c)) {\n        result = extend(this.getError(key, val, criteria))\n        break\n      }\n    }else if (isDeviceModel) {\n      const _criteria = typof(criteria) === 'array' ? criteria : [criteria]\n      if (_criteria.indexOf(val) >= 0) {\n        result = extend(this.getError(key, val, criteria))\n        break\n      }\n    }\n  }\n\n  return result\n}\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/downgrade.js\n **/","/**\n * @fileOverview\n * instance controls from native\n *\n * - init bundle\n * - fire event\n * - callback\n * - destroy\n *\n * corresponded with the API of instance manager (framework.js)\n */\n\nimport {\n  bind, extend\n}\nfrom '../util'\nimport * as perf from '../perf'\nimport Listener, {createAction} from './dom-listener'\n\nexport function init(code, data) {\n  var result\n  // @see: lib/app/bundle.js\n  const define = bind(this.define, this)\n  const bootstrap = (name, config, _data) => {\n    result = this.bootstrap(name, config, _data || data)\n    this.doc.listener.createFinish()\n    this.doc.close()\n  }\n\n  // backward(register/render)\n  const register = bind(this.register, this)\n  const render = (name, _data) => {\n    result = this.bootstrap(name, {}, _data)\n  }\n\n  const require = name => _data => {\n    result = this.bootstrap(name, {}, _data)\n  }\n\n  const document = this.doc\n\n  perf.start('run bundle', this.id)\n\n  let functionBody\n  /* istanbul ignore if */\n  if (typeof code === 'function') {\n    // `function () {...}` -> `{...}`\n    // not very strict\n    functionBody = code.toString().substr(12)\n  } else if (code) {\n    functionBody = code.toString()\n  }\n\n  let fn = new Function(\n    'define',\n    'require',\n    'document',\n    'bootstrap',\n    'register',\n    'render',\n    functionBody\n  )\n\n  fn(define, require, document, bootstrap, register, render)\n\n  perf.end('run bundle', this.id)\n  return result\n}\n\nexport function destroy() {\n  this.id = ''\n  this.eventManager = null\n  this.options = null\n  this.blocks = null\n  this.vm = null\n  this.doc = null\n  this.customComponentMap = null\n  this.callbacks = null\n}\n\nexport function getRootElement() {\n  const doc = this.doc || {}\n  const body = doc.body || {}\n  return body.toJSON ? body.toJSON() : {}\n}\n\nexport function updateActions(addonTasks) {\n  this.differ.flush()\n  const tasks = []\n  if (this.listener && this.listener.updates.length) {\n    tasks.push(...this.listener.updates)\n    this.listener.updates = []\n  }\n  if (addonTasks && addonTasks.length) {\n    tasks.push(...addonTasks)\n  }\n  if (tasks.length) {\n    this.callTasks(tasks)\n  }\n}\n\nexport function fireEvent(ref, type, e, domChanges) {\n  if (Array.isArray(ref)) {\n    ref.some((ref) => {\n      return this.fireEvent(ref, type, e) !== false\n    })\n    return\n  }\n\n  const el = this.doc.getRef(ref)\n\n  if (el) {\n    perf.start('manage event', ref + '-' + type)\n    e = e || {}\n    e.type = type\n    e.target = el\n    e.timestamp = Date.now()\n    if (domChanges) {\n      updateElement(el, domChanges)\n    }\n    const result = this.eventManager.fire(el, type, e)\n    perf.end('manage event', ref + '-' + type)\n    this.updateActions()\n    return result\n  }\n\n  return new Error(`invalid element reference \"${ref}\"`)\n}\n\nexport function callback(callbackId, data, ifKeepAlive) {\n  const callback = this.callbacks[callbackId]\n\n  if (typeof callback === 'function') {\n    callback(data) // data is already a object, @see: lib/framework.js\n\n    if (typeof ifKeepAlive === 'undefined' || ifKeepAlive === false) {\n      this.callbacks[callbackId] = undefined\n    }\n\n    this.updateActions()\n    return\n  }\n\n  return new Error(`invalid callback id \"${callbackId}\"`)\n}\n\nexport function refreshData(data) {\n  const vm = this.vm\n\n  if (vm && data) {\n    if (typeof vm.refreshData === 'function') {\n      vm.refreshData(data)\n    } else {\n      extend(vm, data)\n    }\n    this.updateActions([createAction('refreshFinish', [])])\n    return\n  }\n\n  return new Error(`invalid data \"${data}\"`)\n}\n\nfunction updateElement(el, changes) {\n  const attrs = changes.attrs || {}\n  for (const name in attrs) {\n    el.setAttr(name, attrs)\n  }\n  const style = changes.style || {}\n  for (const name in style) {\n    el.setStyle(name, style[name])\n  }\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/ctrl.js\n **/","export default function Listener(id, handler) {\n  this.id = id\n  this.batched = false\n  this.updates = []\n  if (typeof handler === 'function') {\n    this.handler = handler\n  }\n}\n\nListener.prototype.createFinish = function (callback) {\n  const handler = this.handler\n  handler([createAction('createFinish', [])], callback)\n}\n\nListener.prototype.createBody = function (element, ref) {\n  const actions = [createAction('createBody', [element.toJSON()])]\n  this.addActions(actions)\n}\n\nListener.prototype.addElement = function (element, ref, index) {\n  if (!(index >= 0)) {\n    index = -1\n  }\n  this.addActions(createAction('addElement', [ref, element.toJSON(), index]))\n}\n\nListener.prototype.removeElement = function (ref) {\n  if (Array.isArray(ref)) {\n    const actions = ref.map((r) => createAction('removeElement', [r]))\n    this.addActions(actions)\n  }\n  else {\n    this.addActions(createAction('removeElement', [ref]))\n  }\n}\n\nListener.prototype.moveElement = function (targetRef, parentRef, index) {\n  this.addActions(createAction('moveElement', [targetRef, parentRef, index]))\n}\n\nListener.prototype.setAttr = function (ref, key, value) {\n  const result = {}\n  result[key] = value\n  this.addActions(createAction('updateAttrs', [ref, result]))\n}\n\nListener.prototype.setStyle = function (ref, key, value) {\n  const result = {}\n  result[key] = value\n  this.addActions(createAction('updateStyle', [ref, result]))\n}\n\nListener.prototype.setStyles = function (ref, style) {\n  this.addActions(createAction('updateStyle', [ref, style]))\n}\n\nListener.prototype.addEvent = function (ref, type) {\n  this.addActions(createAction('addEvent', [ref, type]))\n}\n\nListener.prototype.removeEvent = function (ref, type) {\n  this.addActions(createAction('removeEvent', [ref, type]))\n}\n\nListener.prototype.handler = function (actions, cb) {\n  cb && cb()\n}\n\nListener.prototype.addActions = function (actions) {\n  const updates = this.updates\n  const handler = this.handler\n\n  if (!Array.isArray(actions)) {\n    actions = [actions]\n  }\n\n  if (this.batched) {\n    updates.push.apply(updates, actions)\n  }\n  else {\n    handler(actions)\n  }\n}\n\nexport function createAction(name, args) {\n  return {module: 'dom', method: name, args: args}\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/dom-listener.js\n **/","export default class Differ {\n  constructor (id) {\n    this.id = id\n    this.map = []\n    this.hooks = []\n  }\n  isEmpty () {\n    return this.map.length === 0\n  }\n  append (type, depth, ref, handler) {\n    const map = this.map\n    if (!map[depth]) {\n      map[depth] = {}\n    }\n    const group = map[depth]\n    if (!group[type]) {\n      group[type] = {}\n    }\n    if (type === 'element') {\n      if (!group[type][ref]) {\n        group[type][ref] = []\n      }\n      group[type][ref].push(handler)\n    }\n    else {\n      group[type][ref] = handler\n    }\n  }\n  flush () {\n    const map = this.map.slice()\n    this.map.length = 0\n    map.forEach((group) => {\n      callTypeMap(group, 'repeat')\n      callTypeMap(group, 'shown')\n      callTypeList(group, 'element')\n    })\n\n    const hooks = this.hooks.slice()\n    this.hooks.length = 0\n    hooks.forEach((fn) => {\n      fn()\n    })\n\n    if (!this.isEmpty()) {\n      this.flush()\n    }\n  }\n  then (fn) {\n    this.hooks.push(fn)\n  }\n}\n\nfunction callTypeMap(group, type) {\n  const map = group[type]\n  for (const ref in map) {\n    map[ref]()\n  }\n}\n\nfunction callTypeList(group, type) {\n  const map = group[type]\n  for (const ref in map) {\n    const list = map[ref]\n    list.forEach((handler) => {handler()})\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/differ.js\n **/","/**\n * @fileOverview event manager\n */\n\nimport * as _ from '../util'\n\nexport default function EventManager() {\n  this.els = []\n  this.targets = []\n}\n\nEventManager.prototype._get = function (el, force) {\n  var index = _.indexOf(this.els, el)\n  var target\n  if (index >= 0) {\n    target = this.targets[index]\n  }\n  else if (force) {\n    target = {el: el, events: {}}\n    this.els.push(el)\n    this.targets.push(target)\n  }\n  return target\n}\n\nEventManager.prototype.add = function (el, type, handler) {\n  if (typeof el !== 'object' || !el ||\n    typeof type !== 'string' || !type ||\n    typeof handler !== 'function') {\n    return\n  }\n  var target = this._get(el, true)\n  target.events[type] = handler\n}\n\nEventManager.prototype.remove = function (el, type) {\n  if (typeof el !== 'object' || !el ||\n    typeof type !== 'string' || !type) {\n    return\n  }\n  var target = this._get(el)\n  if (target) {\n    delete target.events[type]\n  }\n}\n\nEventManager.prototype.fire = function (el, type, e) {\n  var target = this._get(el)\n  var handler, el\n  if (target) {\n    el = target.el\n    handler = target.events[type]\n    if (typeof handler === 'function') {\n      return handler.call(el, e)\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/event.js\n **/","/**\n * @fileOverview\n * A simple virtual dom implementation\n */\n\nconst DEFAULT_TAG_NAME = 'div'\n\nexport const instanceMap = {}\n\nexport function Document(id) {\n  id = id ? id.toString() : ''\n  this.id = id\n  this.nextRef = 1\n  this.nodeMap = {}\n  this.listener = null\n  this.eventManager = null\n  this.closed = false\n  instanceMap[id] = this\n\n  this.createDocumentElement()\n}\n\nexport function destroyDocument(id) {\n  delete instanceMap[id]\n}\n\nDocument.prototype.open = function () {\n  this.closed = false\n  if (this.listener) {\n    this.listener.batched = false\n  }\n}\nDocument.prototype.close = function () {\n  this.closed = true\n  if (this.listener) {\n    this.listener.batched = true\n  }\n}\n\nDocument.prototype.setEventManager = function (eventManager) {\n  this.eventManager = eventManager\n}\n\nDocument.prototype.setListener = function (listener) {\n  this.listener = listener\n  listener.batched = !!this.closed\n}\n\nDocument.prototype.addRef = function (el) {\n  el.ref = this.nextRef.toString()\n  this.nodeMap[el.ref] = el\n  this.nextRef++\n}\n\nDocument.prototype.getRef = function (ref) {\n  return this.nodeMap[ref]\n}\n\nDocument.prototype.removeRef = function (ref) {\n  delete this.nodeMap[ref]\n}\n\nDocument.prototype.createDocumentElement = function (type, props) {\n  if (!this.documentElement) {\n    this.documentElement = new Element(type, props, this)\n    this.nodeMap._documentElement = this.documentElement\n    this.documentElement.ref = '_documentElement'\n    this.documentElement.attached = true\n  }\n\n  return this.documentElement\n}\n\nDocument.prototype.createBody = function (type, props) {\n  if (!this.body) {\n    this.body = new Element(type, props, this)\n    this.nodeMap._root = this.body\n    this.body.ref = '_root'\n    this.body.depth = 1\n  }\n\n  return this.body\n}\n\nDocument.prototype.createElement = function (tagName, props) {\n  return new Element(tagName, props, this)\n}\n\nDocument.prototype.createComment = function (text) {\n  return new Comment(text, this)\n}\n\nexport function Node() {\n}\n\nNode.prototype.create = function (instanceId) {\n  this.parentRef = null\n  this.attached = false\n  if (instanceId) {\n    this.instanceId = instanceId\n    const doc = instanceMap[instanceId]\n    doc.addRef(this)\n  }\n}\n\nNode.prototype.destroy = function () {\n  const ref = this.ref\n  const instanceId = this.instanceId\n  if (instanceId) {\n    const doc = instanceMap[instanceId]\n    doc.removeRef(ref)\n  }\n\n  const children = this.children || []\n  const length = children.length\n  for (let i = 0; i < length; i++) {\n    children[i].destroy()\n  }\n}\n\nNode.prototype.getRenderer = function () {\n  const doc = instanceMap[this.instanceId]\n  return doc.listener\n}\n\nNode.prototype.next = function () {\n  const instanceId = this.instanceId\n  const doc = instanceMap[instanceId]\n  const parent = doc.getRef(this.parentRef)\n  if (parent) {\n    return parent.children[parent.children.indexOf(this) + 1]\n  }\n}\n\nNode.prototype.prev = function () {\n  const instanceId = this.instanceId\n  const doc = instanceMap[instanceId]\n  const parent = doc.getRef(this.parentRef)\n  if (parent) {\n    return parent.children[parent.children.indexOf(this) - 1]\n  }\n}\n\nexport function Element(type=DEFAULT_TAG_NAME, props, ownerDocument) {\n  props = props || {}\n  this.create(ownerDocument.id)\n  this.ownerDocument = ownerDocument\n  this.type = type\n  this.attr = props.attr || {}\n  this.classStyle = props.classStyle || {}\n  this.style = props.style || {}\n  this.event = []\n  this.children = []\n  this.pureChildren = []\n}\n\nElement.prototype = new Node()\n\nElement.prototype.appendChild = function (node) {\n\n  removeIfExisted(node)\n  node.parentRef = this.ref\n  this.children.push(node)\n\n  if (this.attached) {\n    setAttached(node, this.depth)\n  }\n  else {\n    setDetached(node)\n  }\n\n  if (node instanceof Element) {\n    this.pureChildren.push(node)\n\n    if (this.attached) {\n      const renderer = this.getRenderer()\n      if (renderer) {\n        if (this.ref === '_documentElement') {\n          // if its parent is documentElement then it's a body\n          renderer.createBody(node, this.ref)\n        }\n        else {\n          renderer.addElement(node, this.ref)\n        }\n      }\n    }\n  }\n}\n\nElement.prototype.insertBefore = function (node, before) {\n\n  if (node.parentRef === this.ref) {\n    moveBefore(node, before, this.children)\n    if (node instanceof Element) {\n      const pureBeforeIndex = movePureBefore(node, before, this.pureChildren)\n      if (pureBeforeIndex >= 0 && this.attached) {\n        const renderer = this.getRenderer()\n        if (renderer) {\n          renderer.moveElement(node.ref, this.ref, pureBeforeIndex)\n        }\n      }\n    }\n    return\n  }\n\n  removeIfExisted(node)\n\n  const children = this.children\n  const index = children.indexOf(before)\n\n  node.parentRef = this.ref\n  if (this.attached) {\n    setAttached(node, this.depth)\n  }\n  else {\n    setDetached(node)\n  }\n  children.splice(index, 0, node)\n\n  if (node instanceof Element) {\n    const pureChildren = this.pureChildren\n    const pureIndex = getPureAfter(before, pureChildren)\n\n    pureChildren.splice(pureIndex, 0, node)\n\n    if (this.attached) {\n      const renderer = this.getRenderer()\n      if (renderer) {\n        renderer.addElement(node, this.ref, pureIndex)\n      }\n    }\n  }\n}\n\nElement.prototype.insertAfter = function (node, after) {\n\n  if (node.parentRef === this.ref) {\n    moveAfter(node, after, this.children)\n    if (node instanceof Element) {\n      const pureAfterIndex = movePureAfter(node, after, this.pureChildren)\n      if (pureAfterIndex >= 0 && this.attached) {\n        const renderer = this.getRenderer()\n        if (renderer) {\n          renderer.moveElement(node.ref, this.ref, pureAfterIndex)\n        }\n      }\n    }\n    return\n  }\n\n  removeIfExisted(node)\n\n  const children = this.children\n  const index = children.indexOf(after)\n\n  node.parentRef = this.ref\n  if (this.attached) {\n    setAttached(node, this.depth)\n  }\n  else {\n    setDetached(node)\n  }\n  children.splice(index + 1, 0, node)\n\n  if (node instanceof Element) {\n    const pureChildren = this.pureChildren\n    const pureIndex = getPureBefore(after, pureChildren)\n\n    pureChildren.splice(pureIndex + 1, 0, node)\n\n    if (this.attached) {\n      const renderer = this.getRenderer()\n      if (renderer) {\n        renderer.addElement(node, this.ref, pureIndex + 1)\n      }\n    }\n  }\n}\n\nElement.prototype.removeChild = function (node, preserved) {\n  const children = this.children\n  const index = children.indexOf(node)\n\n  setDetached(node)\n\n  if (index >= 0) {\n    node.parentRef = null\n    children.splice(index, 1)\n    if (!preserved) {\n      node.destroy()\n    }\n  }\n\n  if (node instanceof Element) {\n    this.pureChildren.$remove(node)\n    if (this.attached) {\n      const renderer = this.getRenderer()\n      if (renderer) {\n        renderer.removeElement(node.ref)\n      }\n    }\n  }\n}\n\nElement.prototype.clear = function () {\n  const children = this.children\n  const length = children.length\n  for (let i = 0; i < length; i++) {\n    const child = children[i]\n    child.parentRef = null\n    setDetached(child)\n    child.destroy()\n  }\n  children.length = 0\n\n  if (this.attached) {\n    const refs = this.pureChildren.map((child) => child.ref)\n    this.pureChildren.length = 0\n    const renderer = this.getRenderer()\n    if (renderer) {\n      renderer.removeElement(refs)\n    }\n  }\n}\n\nfunction moveBefore(node, before, children) {\n  const targetIndex = children.indexOf(node)\n  const beforeIndex = children.indexOf(before)\n\n  /* istanbul ignore next */\n  if (targetIndex === beforeIndex || targetIndex + 1 === beforeIndex) {\n    return -1\n  }\n\n  const newIndex = targetIndex < beforeIndex ? beforeIndex - 1 : beforeIndex\n  children.splice(targetIndex, 1)\n  children.splice(newIndex, 0, node)\n\n  return beforeIndex\n}\n\nfunction movePureBefore(node, before, pureChildren) {\n  const pureTargetIndex = pureChildren.indexOf(node)\n  const pureBeforeIndex = getPureAfter(before, pureChildren)\n\n  /* istanbul ignore next */\n  if (pureTargetIndex === pureBeforeIndex ||\n    pureTargetIndex + 1 === pureBeforeIndex) {\n    return -1\n  }\n\n  const pureNewIndex = pureTargetIndex < pureBeforeIndex\n    ? pureBeforeIndex - 1\n    : pureBeforeIndex\n\n  pureChildren.splice(pureTargetIndex, 1)\n  pureChildren.splice(pureNewIndex, 0, node)\n\n  return pureBeforeIndex\n}\n\nfunction getPureAfter(node, pureChildren) {\n  let pureIndex = pureChildren.indexOf(node)\n  while (node && pureIndex < 0) {\n    node = node.next()\n    pureIndex = pureChildren.indexOf(node)\n  }\n  if (pureIndex < 0) {\n    pureIndex = pureChildren.length\n  }\n  return pureIndex\n}\n\nfunction moveAfter(node, after, children) {\n  const targetIndex = children.indexOf(node)\n  const afterIndex = children.indexOf(after)\n\n  /* istanbul ignore next */\n  if (targetIndex === afterIndex || targetIndex === afterIndex + 1) {\n    return -1\n  }\n\n  const newIndex = targetIndex < afterIndex ? afterIndex : afterIndex + 1\n  children.splice(targetIndex, 1)\n  children.splice(newIndex, 0, node)\n\n  return afterIndex\n}\n\nfunction movePureAfter(node, after, pureChildren) {\n  const pureTargetIndex = pureChildren.indexOf(node)\n  const pureAfterIndex = getPureBefore(after, pureChildren)\n\n  /* istanbul ignore next */\n  if (pureTargetIndex === pureAfterIndex ||\n    pureTargetIndex === pureAfterIndex + 1) {\n    return -1\n  }\n\n  const pureNewIndex = pureTargetIndex < pureAfterIndex\n    ? pureAfterIndex\n    : pureAfterIndex + 1\n\n  pureChildren.splice(pureTargetIndex, 1)\n  pureChildren.splice(pureNewIndex, 0, node)\n\n  return pureAfterIndex + 1\n}\n\nfunction getPureBefore(node, pureChildren) {\n  let pureIndex = pureChildren.indexOf(node)\n  while (node && pureIndex < 0) {\n    node = node.prev()\n    pureIndex = pureChildren.indexOf(node)\n  }\n  /* istanbul ignore next */\n  if (pureIndex < 0) {\n    pureIndex = -1\n  }\n  return pureIndex\n}\n\nfunction setAttached(node, depth) {\n  if (node.ref === '_root') {\n    depth = 1\n  }\n  else {\n    depth = depth > 0 ? depth + 1 : 0\n  }\n  node.attached = true\n  node.depth = depth\n  if (node.children) {\n    node.children.forEach((sub) => {\n      setAttached(sub, depth)\n    })\n  }\n}\n\nfunction setDetached(node) {\n  node.attached = false\n  node.depth = 0\n  if (node.children) {\n    node.children.forEach((sub) => {\n      setDetached(sub)\n    })\n  }\n}\n\nfunction removeIfExisted(node) {\n  const doc = instanceMap[node.instanceId]\n  if (doc) {\n    const existedNode = doc.getRef(node.ref)\n    if (existedNode) {\n      const existedParent = doc.getRef(existedNode.parentRef)\n      if (existedParent && existedParent.removeChild) {\n        existedParent.removeChild(existedNode, true)\n      }\n    }\n  }\n}\n\nElement.prototype.setAttr = function (key, value) {\n  if (this.attr[key] === value) {\n    return\n  }\n  this.attr[key] = value\n  if (this.attached) {\n    const renderer = this.getRenderer()\n    if (renderer) {\n      renderer.setAttr(this.ref, key, value)\n    }\n  }\n}\n\nElement.prototype.setStyle = function (key, value) {\n  if (this.style[key] === value) {\n    return\n  }\n  this.style[key] = value\n  if (this.attached) {\n    const renderer = this.getRenderer()\n    if (renderer) {\n      renderer.setStyle(this.ref, key, value)\n    }\n  }\n}\n\nElement.prototype.setClassStyle = function (classStyle) {\n  this.classStyle = classStyle\n  if (this.attached) {\n    const renderer = this.getRenderer()\n    if (renderer) {\n      renderer.setStyles(this.ref, this.toStyle())\n    }\n  }\n}\n\nElement.prototype.addEvent = function (type, handler) {\n  const index = this.event.indexOf(type)\n\n  if (index < 0) {\n    this.event.push(type)\n    let eventManager = this.ownerDocument.eventManager\n    eventManager.add(this, type, handler)\n\n    if (this.attached) {\n      const renderer = this.getRenderer()\n      if (renderer) {\n        renderer.addEvent(this.ref, type)\n      }\n    }\n  }\n}\n\nElement.prototype.removeEvent = function (type) {\n  const index = this.event.indexOf(type)\n\n  if (index >= 0) {\n    this.event.splice(index, 1)\n    let eventManager = this.ownerDocument.eventManager\n    eventManager.remove(this, type)\n\n    if (this.attached) {\n      const renderer = this.getRenderer()\n      if (renderer) {\n        renderer.removeEvent(this.ref, type)\n      }\n    }\n  }\n}\n\nElement.prototype.toStyle = function () {\n  const result = {}\n  const classStyle = this.classStyle\n  const style = this.style\n  for (const name in classStyle) {\n    result[name] = classStyle[name]\n  }\n  for (const name in style) {\n    result[name] = style[name]\n  }\n  return result\n}\n\nElement.prototype.toJSON = function () {\n  const result = {\n    ref: this.ref.toString(),\n    type: this.type,\n    attr: this.attr,\n    style: this.toStyle()\n  }\n\n  if (this.event && this.event.length) {\n    result.event = this.event\n  }\n  if (this.pureChildren && this.pureChildren.length) {\n    result.children = this.pureChildren.map((child) => child.toJSON())\n  }\n\n  return result\n}\n\nElement.prototype.toString = function () {\n  return '<' + this.type +\n    ' attr=' + JSON.stringify(this.attr) +\n    ' style=' + JSON.stringify(this.toStyle()) + '>' +\n    this.pureChildren.map((child) => child.toString()).join('') +\n    '</' + this.type + '>'\n}\n\nexport function Comment(value, ownerDocument) {\n  this.create(ownerDocument.id)\n  this.type = 'comment'\n  this.value = value\n}\n\nComment.prototype = new Node()\n\nComment.prototype.toString = function () {\n  return '<!-- ' + this.value + ' -->'\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/app/dom.js\n **/","module.exports = {\n\t\"name\": \"weex-jsframework\",\n\t\"version\": \"0.13.7\",\n\t\"description\": \"JS Framework for Weex solution which is a extendable cross-platform solution for dynamic programming and publishing projects\",\n\t\"main\": \"index.js\",\n\t\"scripts\": {\n\t\t\"dev\": \"webpack --watch --config ./webpack.config.js\",\n\t\t\"build\": \"webpack --config ./webpack.config.js\",\n\t\t\"compress\": \"uglifyjs dist/index.js -o dist/index.min.js\",\n\t\t\"lint\": \"jscs --config .jscsrc polyfill/*.js polyfill/__test__/*.js lib/*.js lib/__test__/*.js lib/app/*.js lib/app/__test__/*.js lib/vm/*.js lib/vm/__test__/*.js\",\n\t\t\"test\": \"mocha --compilers js:babel-core/register polyfill/__test__/*.js lib/__test__/*.js lib/**/__test__/*.js\",\n\t\t\"cover\": \"babel-node node_modules/isparta/bin/isparta cover --report text node_modules/mocha/bin/_mocha -- --reporter dot lib/__test__/*.js lib/**/__test__/*.js\",\n\t\t\"ci\": \"npm run lint && npm run cover\"\n\t},\n\t\"repository\": {\n\t\t\"type\": \"git\",\n\t\t\"url\": \"git@github.com:alibaba/weex.git\"\n\t},\n\t\"author\": [\n\t\t{\n\t\t\t\"name\": \"jinjiang\",\n\t\t\t\"email\": \"zhaojinjiang@me.com\"\n\t\t},\n\t\t{\n\t\t\t\"name\": \"Terry King\",\n\t\t\t\"email\": \"terrykingcha@gmail.com\"\n\t\t}\n\t],\n\t\"contributors\": [\n\t\t{\n\t\t\t\"name\": \"pushiming\",\n\t\t\t\"email\": \"pushiming@gmail.com\"\n\t\t},\n\t\t{\n\t\t\t\"name\": \"iskenhuang\",\n\t\t\t\"email\": \"iskenhuang@gmail.com\"\n\t\t},\n\t\t{\n\t\t\t\"name\": \"yuanyan\",\n\t\t\t\"email\": \"yuanyan.cao@gmail.com\"\n\t\t}\n\t],\n\t\"keywords\": [\n\t\t\"weex\",\n\t\t\"mvvm\",\n\t\t\"browser\",\n\t\t\"hybrid\",\n\t\t\"framework\"\n\t],\n\t\"license\": \"Apache-2.0\",\n\t\"dependencies\": {\n\t\t\"semver\": \"~5.1.0\",\n\t\t\"core-js\": \"~2.1.1\"\n\t},\n\t\"devDependencies\": {\n\t\t\"babel-cli\": \"~6.4.5\",\n\t\t\"babel-core\": \"~6.4.5\",\n\t\t\"babel-loader\": \"~6.2.1\",\n\t\t\"babel-preset-es2015\": \"~6.3.13\",\n\t\t\"chai\": \"~3.2.0\",\n\t\t\"isparta\": \"~4.0.0\",\n\t\t\"istanbul\": \"~0.4.2\",\n\t\t\"jscs\": \"~2.9.0\",\n\t\t\"json-loader\": \"^0.5.4\",\n\t\t\"mocha\": \"~2.3.4\",\n\t\t\"sinon\": \"~1.17.2\",\n\t\t\"sinon-chai\": \"~2.8.0\",\n\t\t\"uglify-js\": \"^2.6.2\",\n\t\t\"watch-cli\": \"~0.2.1\",\n\t\t\"webpack\": \"~1.12.12\"\n\t},\n\t\"optionalDependencies\": {\n\t\t\"weex-transformer\": \"~0.3\"\n\t}\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./package.json\n ** module id = 105\n ** module chunks = 0\n **/","/**\n * @fileOverview The api for invoking with \"$\" prefix\n */\nimport {typof, extend} from '../util'\n\n/**\n * ==========================================================\n * common\n * ==========================================================\n */\n\n/**\n * @deprecated use $vm instead\n * find the vm by id\n * Note: there is only one id in whole component\n * @param  {string} id\n * @return {Vm}\n */\nexport function $(id) {\n  nativeLog('[WARNING] the Vm#$ api is deprecated, please use Vm#$vm instead')\n  const info = this._ids[id]\n  if (info) {\n    return info.vm\n  }\n}\n\n/**\n * find the element by id\n * Note: there is only one id in whole component\n * @param  {string} id\n * @return {Element}\n */\nexport function $el(id) {\n  const info = this._ids[id]\n  if (info) {\n    return info.el\n  }\n}\n\n/**\n * find the vm of the custom component by id\n * Note: there is only one id in whole component\n * @param  {string} id\n * @return {Vm}\n */\nexport function $vm(id) {\n  const info = this._ids[id]\n  if (info) {\n    return info.vm\n  }\n}\n\n/**\n * Fire when differ rendering finished\n *\n * @param  {Function} fn\n */\nexport function $renderThen(fn) {\n  const app = this._app\n  const differ = app.differ\n  return differ.then(() => {\n    fn()\n  })\n}\n\n/**\n * scroll an element specified by id into view, \n * moreover specify a number of offset optionally\n * @param  {string} id\n * @param  {number} offset\n */\nexport function $scrollTo(id, offset) {\n  const el = this.$el(id)\n  if (el) {\n    const dom = this._app.requireModule('dom')\n    dom.scrollToElement(el.ref, {offset: offset})\n  }\n}\n\n/**\n * perform transition animation on an element specified by id\n * @param  {string}   id\n * @param  {object}   options\n * @param  {object}   options.styles\n * @param  {object}   options.duration(ms)\n * @param  {object}   [options.timingFunction]\n * @param  {object}   [options.delay=0(ms)]\n * @param  {Function} callback\n */\nexport function $transition(id, options, callback) {\n  const el = this.$el(id)\n  if (el && options && options.styles) {\n    const animation = this._app.requireModule('animation')\n    animation.transition(el.ref, options, (...args) => {\n      this._setStyle(el, options.styles)\n      callback && callback(...args)\n    })\n  }\n}\n\n/**\n * get some config\n * @return {object} some config for app instance\n * @property {string} bundleUrl\n * @property {boolean} debug\n * @property {object} env\n * @property {string} env.weexVersion(ex. 1.0.0)\n * @property {string} env.appName(ex. TB/TM)\n * @property {string} env.appVersion(ex. 5.0.0)\n * @property {string} env.platform(ex. iOS/Android)\n * @property {string} env.osVersion(ex. 7.0.0)\n * @property {string} env.deviceModel **native only**\n * @property {number} env.[deviceWidth=750]\n * @property {number} env.deviceHeight\n */\nexport function $getConfig(callback) {\n  const config = extend({\n    env: global.WXEnvironment || {}\n  }, this._app.options)\n  if (typof(callback) === 'function') {\n    nativeLog('[WARNING] the callback of Vm#$getConfig(callback) is deprecated, ' +\n      'this api now can directly RETURN config info.')\n    callback(config)\n  }\n  return config\n}\n\n/**\n * request network via http protocol\n * @param  {object}   params\n * @param  {Function} callback\n */\nexport function $sendHttp(params, callback) {\n  const stream = this._app.requireModule('stream')\n  stream.sendHttp(params, callback)\n}\n\n/**\n * open a url\n * @param  {string} url\n */\nexport function $openURL(url) {\n  const event = this._app.requireModule('event')\n  event.openURL(url)\n}\n\n/**\n * set a title for page\n * @param  {string} title\n */\nexport function $setTitle(title) {\n  const pageInfo = this._app.requireModule('pageInfo')\n  pageInfo.setTitle(title)\n}\n\n/**\n * invoke a native method by specifing the name of module and method\n * @param  {string} moduleName\n * @param  {string} methodName\n * @param  {...*} the rest arguments\n */\nexport function $call(moduleName, methodName, ...args) {\n  const module = this._app.requireModule(moduleName)\n  if (module && module[methodName]) {\n    module[methodName](...args)\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./lib/api/methods.js\n **/"],"sourceRoot":""} |