You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@weex.apache.org by ac...@apache.org on 2017/08/08 08:55:35 UTC
[23/39] incubator-weex git commit: + [build] add weex-js-framework
and weex-js-runtime packages
http://git-wip-us.apache.org/repos/asf/incubator-weex/blob/0d8f8595/packages/weex-js-framework/index.js
----------------------------------------------------------------------
diff --git a/packages/weex-js-framework/index.js b/packages/weex-js-framework/index.js
new file mode 100644
index 0000000..21afb62
--- /dev/null
+++ b/packages/weex-js-framework/index.js
@@ -0,0 +1,25150 @@
+(this.nativeLog || function(s) {console.log(s)})('START JS FRAMEWORK 0.20.6, Build 2017-08-01 19:09.');
+;(this.getJSFMVersion = function(){return "0.20.6"});
+var global = this, process = { env: {} };var setTimeout = global.setTimeout;
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (factory());
+}(this, (function () { 'use strict';
+
+var subversion = {"browser":"0.5.0","framework":"0.20.6","vue-render":"0.12.1","transformer":">=0.1.5 <0.5"};
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* eslint-disable */
+
+// Production steps of ECMA-262, Edition 6, 22.1.2.1
+// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
+
+/* istanbul ignore if */
+if (!Array.from) {
+ Array.from = (function() {
+ var toStr = Object.prototype.toString;
+ var isCallable = function(fn) {
+ return typeof fn === 'function' || toStr.call(fn) === '[object Function]';
+ };
+ var toInteger = function(value) {
+ var number = Number(value);
+ if (isNaN(number)) {
+ return 0;
+ }
+ if (number === 0 || !isFinite(number)) {
+ return number;
+ }
+ return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+ };
+ var maxSafeInteger = Math.pow(2, 53) - 1;
+ var toLength = function(value) {
+ var len = toInteger(value);
+ return Math.min(Math.max(len, 0), maxSafeInteger);
+ };
+
+ // The length property of the from method is 1.
+ return function from(arrayLike/*, mapFn, thisArg */) {
+ // 1. Let C be the this value.
+ var C = this;
+
+ // 2. Let items be ToObject(arrayLike).
+ var items = Object(arrayLike);
+
+ // 3. ReturnIfAbrupt(items).
+ if (arrayLike == null) {
+ throw new TypeError('Array.from requires an array-like object - not null or undefined');
+ }
+
+ // 4. If mapfn is undefined, then let mapping be false.
+ var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
+ var T;
+ if (typeof mapFn !== 'undefined') {
+ // 5. else
+ // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
+ if (!isCallable(mapFn)) {
+ throw new TypeError('Array.from: when provided, the second argument must be a function');
+ }
+
+ // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ if (arguments.length > 2) {
+ T = arguments[2];
+ }
+ }
+
+ // 10. Let lenValue be Get(items, "length").
+ // 11. Let len be ToLength(lenValue).
+ var len = toLength(items.length);
+
+ // 13. If IsConstructor(C) is true, then
+ // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len.
+ // 14. a. Else, Let A be ArrayCreate(len).
+ var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+
+ // 16. Let k be 0.
+ var k = 0;
+ // 17. Repeat, while k < len… (also steps a - h)
+ var kValue;
+ while (k < len) {
+ kValue = items[k];
+ if (mapFn) {
+ A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
+ } else {
+ A[k] = kValue;
+ }
+ k += 1;
+ }
+ // 18. Let putStatus be Put(A, "length", len, true).
+ A.length = len;
+ // 20. Return A.
+ return A;
+ };
+ }());
+}
+
+var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+
+
+function unwrapExports (x) {
+ return x && x.__esModule ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var _global = createCommonjsModule(function (module) {
+// 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
+});
+
+var _core = createCommonjsModule(function (module) {
+var core = module.exports = {version: '2.4.0'};
+if(typeof __e == 'number'){ __e = core; } // eslint-disable-line no-undef
+});
+
+var _isObject = function(it){
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+
+var isObject = _isObject;
+var _anObject = function(it){
+ if(!isObject(it)){ throw TypeError(it + ' is not an object!'); }
+ return it;
+};
+
+var _fails = function(exec){
+ try {
+ return !!exec();
+ } catch(e){
+ return true;
+ }
+};
+
+// Thank's IE8 for his funny defineProperty
+var _descriptors = !_fails(function(){
+ return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
+});
+
+var isObject$1 = _isObject;
+var document$1 = _global.document;
+var is = isObject$1(document$1) && isObject$1(document$1.createElement);
+var _domCreate = function(it){
+ return is ? document$1.createElement(it) : {};
+};
+
+var _ie8DomDefine = !_descriptors && !_fails(function(){
+ return Object.defineProperty(_domCreate('div'), 'a', {get: function(){ return 7; }}).a != 7;
+});
+
+// 7.1.1 ToPrimitive(input [, PreferredType])
+var isObject$2 = _isObject;
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+var _toPrimitive = function(it, S){
+ if(!isObject$2(it)){ return it; }
+ var fn, val;
+ if(S && typeof (fn = it.toString) == 'function' && !isObject$2(val = fn.call(it))){ return val; }
+ if(typeof (fn = it.valueOf) == 'function' && !isObject$2(val = fn.call(it))){ return val; }
+ if(!S && typeof (fn = it.toString) == 'function' && !isObject$2(val = fn.call(it))){ return val; }
+ throw TypeError("Can't convert object to primitive value");
+};
+
+var anObject = _anObject;
+var IE8_DOM_DEFINE = _ie8DomDefine;
+var toPrimitive = _toPrimitive;
+var dP$1 = Object.defineProperty;
+
+var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes){
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if(IE8_DOM_DEFINE){ try {
+ return dP$1(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;
+};
+
+var _objectDp = {
+ f: f
+};
+
+var _propertyDesc = function(bitmap, value){
+ return {
+ enumerable : !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable : !(bitmap & 4),
+ value : value
+ };
+};
+
+var dP = _objectDp;
+var createDesc = _propertyDesc;
+var _hide = _descriptors ? function(object, key, value){
+ return dP.f(object, key, createDesc(1, value));
+} : function(object, key, value){
+ object[key] = value;
+ return object;
+};
+
+var hasOwnProperty = {}.hasOwnProperty;
+var _has = function(it, key){
+ return hasOwnProperty.call(it, key);
+};
+
+var id = 0;
+var px = Math.random();
+var _uid = function(key){
+ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
+
+var _redefine = createCommonjsModule(function (module) {
+var global = _global
+ , hide = _hide
+ , has = _has
+ , SRC = _uid('src')
+ , TO_STRING = 'toString'
+ , $toString = Function[TO_STRING]
+ , TPL = ('' + $toString).split(TO_STRING);
+
+_core.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);
+});
+});
+
+var _aFunction = function(it){
+ if(typeof it != 'function'){ throw TypeError(it + ' is not a function!'); }
+ return it;
+};
+
+// optional / simple context binding
+var aFunction = _aFunction;
+var _ctx = 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);
+ };
+};
+
+var global$1 = _global;
+var core = _core;
+var hide = _hide;
+var redefine = _redefine;
+var ctx = _ctx;
+var PROTOTYPE = 'prototype';
+
+var $export$1 = function(type, name, source){
+ var IS_FORCED = type & $export$1.F
+ , IS_GLOBAL = type & $export$1.G
+ , IS_STATIC = type & $export$1.S
+ , IS_PROTO = type & $export$1.P
+ , IS_BIND = type & $export$1.B
+ , target = IS_GLOBAL ? global$1 : IS_STATIC ? global$1[name] || (global$1[name] = {}) : (global$1[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$1) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+ // extend global
+ if(target){ redefine(target, key, out, type & $export$1.U); }
+ // export
+ if(exports[key] != out){ hide(exports, key, exp); }
+ if(IS_PROTO && expProto[key] != out){ expProto[key] = out; }
+ }
+};
+global$1.core = core;
+// type bitmap
+$export$1.F = 1; // forced
+$export$1.G = 2; // global
+$export$1.S = 4; // static
+$export$1.P = 8; // proto
+$export$1.B = 16; // bind
+$export$1.W = 32; // wrap
+$export$1.U = 64; // safe
+$export$1.R = 128; // real proto method for `library`
+var _export = $export$1;
+
+var toString$1 = {}.toString;
+
+var _cof = function(it){
+ return toString$1.call(it).slice(8, -1);
+};
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var cof = _cof;
+var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function(it){
+ return cof(it) == 'String' ? it.split('') : Object(it);
+};
+
+// 7.2.1 RequireObjectCoercible(argument)
+var _defined = function(it){
+ if(it == undefined){ throw TypeError("Can't call method on " + it); }
+ return it;
+};
+
+// to indexed object, toObject with fallback for non-array-like ES3 strings
+var IObject$1 = _iobject;
+var defined = _defined;
+var _toIobject = function(it){
+ return IObject$1(defined(it));
+};
+
+// 7.1.4 ToInteger
+var ceil = Math.ceil;
+var floor = Math.floor;
+var _toInteger = function(it){
+ return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+};
+
+// 7.1.15 ToLength
+var toInteger = _toInteger;
+var min = Math.min;
+var _toLength = function(it){
+ return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+};
+
+var toInteger$1 = _toInteger;
+var max = Math.max;
+var min$1 = Math.min;
+var _toIndex = function(index, length){
+ index = toInteger$1(index);
+ return index < 0 ? max(index + length, 0) : min$1(index, length);
+};
+
+// false -> Array#indexOf
+// true -> Array#includes
+var toIObject$1 = _toIobject;
+var toLength = _toLength;
+var toIndex = _toIndex;
+var _arrayIncludes = function(IS_INCLUDES){
+ return function($this, el, fromIndex){
+ var O = toIObject$1($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 || 0; }
+ } } } return !IS_INCLUDES && -1;
+ };
+};
+
+var global$2 = _global;
+var SHARED = '__core-js_shared__';
+var store = global$2[SHARED] || (global$2[SHARED] = {});
+var _shared = function(key){
+ return store[key] || (store[key] = {});
+};
+
+var shared = _shared('keys');
+var uid = _uid;
+var _sharedKey = function(key){
+ return shared[key] || (shared[key] = uid(key));
+};
+
+var has$1 = _has;
+var toIObject = _toIobject;
+var arrayIndexOf = _arrayIncludes(false);
+var IE_PROTO = _sharedKey('IE_PROTO');
+
+var _objectKeysInternal = function(object, names){
+ var O = toIObject(object)
+ , i = 0
+ , result = []
+ , key;
+ for(key in O){ if(key != IE_PROTO){ has$1(O, key) && result.push(key); } }
+ // Don't enum bug & hidden keys
+ while(names.length > i){ if(has$1(O, key = names[i++])){
+ ~arrayIndexOf(result, key) || result.push(key);
+ } }
+ return result;
+};
+
+// IE 8- don't enum bug keys
+var _enumBugKeys = (
+ 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+).split(',');
+
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys = _objectKeysInternal;
+var enumBugKeys = _enumBugKeys;
+
+var _objectKeys = Object.keys || function keys(O){
+ return $keys(O, enumBugKeys);
+};
+
+var f$1 = Object.getOwnPropertySymbols;
+
+var _objectGops = {
+ f: f$1
+};
+
+var f$2 = {}.propertyIsEnumerable;
+
+var _objectPie = {
+ f: f$2
+};
+
+// 7.1.13 ToObject(argument)
+var defined$1 = _defined;
+var _toObject = function(it){
+ return Object(defined$1(it));
+};
+
+// 19.1.2.1 Object.assign(target, source, ...)
+var getKeys = _objectKeys;
+var gOPS = _objectGops;
+var pIE = _objectPie;
+var toObject = _toObject;
+var IObject = _iobject;
+var $assign = Object.assign;
+
+// should work with symbols and should have deterministic property order (V8 bug)
+var _objectAssign = !$assign || _fails(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){
+ var arguments$1 = arguments;
+ // 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$1[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;
+
+// 19.1.3.1 Object.assign(target, source)
+var $export = _export;
+
+$export($export.S + $export.F, 'Object', {assign: _objectAssign});
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* eslint-disable */
+
+// https://gist.github.com/WebReflection/5593554
+
+/* istanbul ignore if */
+if (!Object.setPrototypeOf) {
+ Object.setPrototypeOf = (function(Object, magic) {
+ var set;
+ function setPrototypeOf(O, proto) {
+ set.call(O, proto);
+ return O;
+ }
+ try {
+ // this works already in Firefox and Safari
+ set = Object.getOwnPropertyDescriptor(Object.prototype, magic).set;
+ set.call({}, null);
+ } catch (e) {
+ if (
+ // IE < 11 cannot be shimmed
+ Object.prototype !== {}[magic] ||
+ // neither can any browser that actually
+ // implemented __proto__ correctly
+ // (all but old V8 will return here)
+ {__proto__: null}.__proto__ === void 0
+ // this case means null objects cannot be passed
+ // through setPrototypeOf in a reliable way
+ // which means here a **Sham** is needed instead
+ ) {
+ return;
+ }
+ // nodejs 0.8 and 0.10 are (buggy and..) fine here
+ // probably Chrome or some old Mobile stock browser
+ set = function(proto) {
+ this[magic] = proto;
+ };
+ // please note that this will **not** work
+ // in those browsers that do not inherit
+ // __proto__ by mistake from Object.prototype
+ // in these cases we should probably throw an error
+ // or at least be informed about the issue
+ setPrototypeOf.polyfill = setPrototypeOf(
+ setPrototypeOf({}, null),
+ Object.prototype
+ ) instanceof Object;
+ // setPrototypeOf.polyfill === true means it works as meant
+ // setPrototypeOf.polyfill === false means it's not 100% reliable
+ // setPrototypeOf.polyfill === undefined
+ // or
+ // setPrototypeOf.polyfill == null means it's not a polyfill
+ // which means it works as expected
+ // we can even delete Object.prototype.__proto__;
+ }
+ return setPrototypeOf;
+ }(Object, '__proto__'));
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// fix Promise Problem on JSContext of iOS7~8
+// @see https://bugs.webkit.org/show_bug.cgi?id=135866
+
+var ref = commonjsGlobal;
+var WXEnvironment$1 = ref.WXEnvironment;
+
+/* istanbul ignore next */
+if (WXEnvironment$1 && WXEnvironment$1.platform === 'iOS') {
+ commonjsGlobal.Promise = undefined;
+}
+
+var _wks = createCommonjsModule(function (module) {
+var store = _shared('wks')
+ , uid = _uid
+ , Symbol = _global.Symbol
+ , USE_SYMBOL = typeof Symbol == 'function';
+
+var $exports = module.exports = function(name){
+ return store[name] || (store[name] =
+ USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
+};
+
+$exports.store = store;
+});
+
+// getting tag from 19.1.3.6 Object.prototype.toString()
+var cof$1 = _cof;
+var TAG = _wks('toStringTag');
+var ARG = cof$1(function(){ return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function(it, key){
+ try {
+ return it[key];
+ } catch(e){ /* empty */ }
+};
+
+var _classof = 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$1(O)
+ // ES3 arguments fallback
+ : (B = cof$1(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+
+// 19.1.3.6 Object.prototype.toString()
+var classof = _classof;
+var test = {};
+test[_wks('toStringTag')] = 'z';
+if(test + '' != '[object z]'){
+ _redefine(Object.prototype, 'toString', function toString(){
+ return '[object ' + classof(this) + ']';
+ }, true);
+}
+
+var toInteger$2 = _toInteger;
+var defined$2 = _defined;
+// true -> String#at
+// false -> String#codePointAt
+var _stringAt = function(TO_STRING){
+ return function(that, pos){
+ var s = String(defined$2(that))
+ , i = toInteger$2(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;
+ };
+};
+
+var _library = false;
+
+var _iterators = {};
+
+var dP$2 = _objectDp;
+var anObject$2 = _anObject;
+var getKeys$1 = _objectKeys;
+
+var _objectDps = _descriptors ? Object.defineProperties : function defineProperties(O, Properties){
+ anObject$2(O);
+ var keys = getKeys$1(Properties)
+ , length = keys.length
+ , i = 0
+ , P;
+ while(length > i){ dP$2.f(O, P = keys[i++], Properties[P]); }
+ return O;
+};
+
+var _html = _global.document && document.documentElement;
+
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+var anObject$1 = _anObject;
+var dPs = _objectDps;
+var enumBugKeys$1 = _enumBugKeys;
+var IE_PROTO$1 = _sharedKey('IE_PROTO');
+var Empty = function(){ /* empty */ };
+var PROTOTYPE$1 = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var createDict = function(){
+ // Thrash, waste and sodomy: IE GC bug
+ var iframe = _domCreate('iframe')
+ , i = enumBugKeys$1.length
+ , lt = '<'
+ , gt = '>'
+ , iframeDocument;
+ iframe.style.display = 'none';
+ _html.appendChild(iframe);
+ iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+ // createDict = iframe.contentWindow.Object;
+ // html.removeChild(iframe);
+ iframeDocument = iframe.contentWindow.document;
+ iframeDocument.open();
+ iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+ iframeDocument.close();
+ createDict = iframeDocument.F;
+ while(i--){ delete createDict[PROTOTYPE$1][enumBugKeys$1[i]]; }
+ return createDict();
+};
+
+var _objectCreate = Object.create || function create(O, Properties){
+ var result;
+ if(O !== null){
+ Empty[PROTOTYPE$1] = anObject$1(O);
+ result = new Empty;
+ Empty[PROTOTYPE$1] = null;
+ // add "__proto__" for Object.getPrototypeOf polyfill
+ result[IE_PROTO$1] = O;
+ } else { result = createDict(); }
+ return Properties === undefined ? result : dPs(result, Properties);
+};
+
+var def = _objectDp.f;
+var has$3 = _has;
+var TAG$1 = _wks('toStringTag');
+
+var _setToStringTag = function(it, tag, stat){
+ if(it && !has$3(it = stat ? it : it.prototype, TAG$1)){ def(it, TAG$1, {configurable: true, value: tag}); }
+};
+
+var create$1 = _objectCreate;
+var descriptor = _propertyDesc;
+var setToStringTag$1 = _setToStringTag;
+var IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+_hide(IteratorPrototype, _wks('iterator'), function(){ return this; });
+
+var _iterCreate = function(Constructor, NAME, next){
+ Constructor.prototype = create$1(IteratorPrototype, {next: descriptor(1, next)});
+ setToStringTag$1(Constructor, NAME + ' Iterator');
+};
+
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+var has$4 = _has;
+var toObject$1 = _toObject;
+var IE_PROTO$2 = _sharedKey('IE_PROTO');
+var ObjectProto = Object.prototype;
+
+var _objectGpo = Object.getPrototypeOf || function(O){
+ O = toObject$1(O);
+ if(has$4(O, IE_PROTO$2)){ return O[IE_PROTO$2]; }
+ if(typeof O.constructor == 'function' && O instanceof O.constructor){
+ return O.constructor.prototype;
+ } return O instanceof Object ? ObjectProto : null;
+};
+
+var LIBRARY = _library;
+var $export$2 = _export;
+var redefine$1 = _redefine;
+var hide$1 = _hide;
+var has$2 = _has;
+var Iterators = _iterators;
+var $iterCreate = _iterCreate;
+var setToStringTag = _setToStringTag;
+var getPrototypeOf = _objectGpo;
+var ITERATOR = _wks('iterator');
+var BUGGY = !([].keys && 'next' in [].keys());
+var FF_ITERATOR = '@@iterator';
+var KEYS = 'keys';
+var VALUES = 'values';
+
+var returnThis = function(){ return this; };
+
+var _iterDefine = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
+ $iterCreate(Constructor, NAME, next);
+ var getMethod = function(kind){
+ if(!BUGGY && kind in proto){ return proto[kind]; }
+ switch(kind){
+ case KEYS: return function keys(){ return new Constructor(this, kind); };
+ case VALUES: return function values(){ return new Constructor(this, kind); };
+ } return function entries(){ return new Constructor(this, kind); };
+ };
+ var TAG = NAME + ' Iterator'
+ , 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$2(IteratorPrototype, ITERATOR)){ hide$1(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$1(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$1(proto, key, methods[key]); }
+ } } else { $export$2($export$2.P + $export$2.F * (BUGGY || VALUES_BUG), NAME, methods); }
+ }
+ return methods;
+};
+
+var $at = _stringAt(true);
+
+// 21.1.3.27 String.prototype[@@iterator]()
+_iterDefine(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};
+});
+
+// 22.1.3.31 Array.prototype[@@unscopables]
+var UNSCOPABLES = _wks('unscopables');
+var ArrayProto = Array.prototype;
+if(ArrayProto[UNSCOPABLES] == undefined){ _hide(ArrayProto, UNSCOPABLES, {}); }
+var _addToUnscopables = function(key){
+ ArrayProto[UNSCOPABLES][key] = true;
+};
+
+var _iterStep = function(done, value){
+ return {value: value, done: !!done};
+};
+
+var addToUnscopables = _addToUnscopables;
+var step = _iterStep;
+var Iterators$2 = _iterators;
+var toIObject$2 = _toIobject;
+
+// 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]()
+var es6_array_iterator = _iterDefine(Array, 'Array', function(iterated, kind){
+ this._t = toIObject$2(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$2.Arguments = Iterators$2.Array;
+
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+
+var $iterators = es6_array_iterator;
+var redefine$2 = _redefine;
+var global$3 = _global;
+var hide$2 = _hide;
+var Iterators$1 = _iterators;
+var wks = _wks;
+var ITERATOR$1 = wks('iterator');
+var TO_STRING_TAG = wks('toStringTag');
+var ArrayValues = Iterators$1.Array;
+
+for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
+ var NAME = collections[i]
+ , Collection = global$3[NAME]
+ , proto = Collection && Collection.prototype
+ , key;
+ if(proto){
+ if(!proto[ITERATOR$1]){ hide$2(proto, ITERATOR$1, ArrayValues); }
+ if(!proto[TO_STRING_TAG]){ hide$2(proto, TO_STRING_TAG, NAME); }
+ Iterators$1[NAME] = ArrayValues;
+ for(key in $iterators){ if(!proto[key]){ redefine$2(proto, key, $iterators[key], true); } }
+ }
+}
+
+var _anInstance = function(it, Constructor, name, forbiddenField){
+ if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){
+ throw TypeError(name + ': incorrect invocation!');
+ } return it;
+};
+
+// call something on iterator step with safe closing on error
+var anObject$3 = _anObject;
+var _iterCall = function(iterator, fn, value, entries){
+ try {
+ return entries ? fn(anObject$3(value)[0], value[1]) : fn(value);
+ // 7.4.6 IteratorClose(iterator, completion)
+ } catch(e){
+ var ret = iterator['return'];
+ if(ret !== undefined){ anObject$3(ret.call(iterator)); }
+ throw e;
+ }
+};
+
+// check on default Array iterator
+var Iterators$3 = _iterators;
+var ITERATOR$2 = _wks('iterator');
+var ArrayProto$1 = Array.prototype;
+
+var _isArrayIter = function(it){
+ return it !== undefined && (Iterators$3.Array === it || ArrayProto$1[ITERATOR$2] === it);
+};
+
+var classof$2 = _classof;
+var ITERATOR$3 = _wks('iterator');
+var Iterators$4 = _iterators;
+var core_getIteratorMethod = _core.getIteratorMethod = function(it){
+ if(it != undefined){ return it[ITERATOR$3]
+ || it['@@iterator']
+ || Iterators$4[classof$2(it)]; }
+};
+
+var _forOf = createCommonjsModule(function (module) {
+var ctx = _ctx
+ , call = _iterCall
+ , isArrayIter = _isArrayIter
+ , anObject = _anObject
+ , toLength = _toLength
+ , getIterFn = core_getIteratorMethod
+ , BREAK = {}
+ , RETURN = {};
+var exports = 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, result;
+ 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++){
+ result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
+ if(result === BREAK || result === RETURN){ return result; }
+ } } else { for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
+ result = call(iterator, f, step.value, entries);
+ if(result === BREAK || result === RETURN){ return result; }
+ } }
+};
+exports.BREAK = BREAK;
+exports.RETURN = RETURN;
+});
+
+// 7.3.20 SpeciesConstructor(O, defaultConstructor)
+var anObject$4 = _anObject;
+var aFunction$2 = _aFunction;
+var SPECIES = _wks('species');
+var _speciesConstructor = function(O, D){
+ var C = anObject$4(O).constructor, S;
+ return C === undefined || (S = anObject$4(C)[SPECIES]) == undefined ? D : aFunction$2(S);
+};
+
+// fast apply, http://jsperf.lnkit.com/fast-apply/5
+var _invoke = 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);
+};
+
+var ctx$2 = _ctx;
+var invoke = _invoke;
+var html = _html;
+var cel = _domCreate;
+var global$5 = _global;
+var process$2 = global$5.process;
+var setTask = global$5.setImmediate;
+var clearTask = global$5.clearImmediate;
+var MessageChannel = global$5.MessageChannel;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var defer;
+var channel;
+var port;
+var run$1 = function(){
+ var id = +this;
+ if(queue.hasOwnProperty(id)){
+ var fn = queue[id];
+ delete queue[id];
+ fn();
+ }
+};
+var listener = function(event){
+ run$1.call(event.data);
+};
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if(!setTask || !clearTask){
+ setTask = function setImmediate(fn){
+ var arguments$1 = arguments;
+
+ var args = [], i = 1;
+ while(arguments.length > i){ args.push(arguments$1[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(_cof(process$2) == 'process'){
+ defer = function(id){
+ process$2.nextTick(ctx$2(run$1, id, 1));
+ };
+ // Browsers with MessageChannel, includes WebWorkers
+ } else if(MessageChannel){
+ channel = new MessageChannel;
+ port = channel.port2;
+ channel.port1.onmessage = listener;
+ defer = ctx$2(port.postMessage, port, 1);
+ // Browsers with postMessage, skip WebWorkers
+ // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+ } else if(global$5.addEventListener && typeof postMessage == 'function' && !global$5.importScripts){
+ defer = function(id){
+ global$5.postMessage(id + '', '*');
+ };
+ global$5.addEventListener('message', listener, false);
+ // IE8-
+ } else if(ONREADYSTATECHANGE in cel('script')){
+ defer = function(id){
+ html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
+ html.removeChild(this);
+ run$1.call(id);
+ };
+ };
+ // Rest old browsers
+ } else {
+ defer = function(id){
+ setTimeout(ctx$2(run$1, id, 1), 0);
+ };
+ }
+}
+var _task = {
+ set: setTask,
+ clear: clearTask
+};
+
+var global$6 = _global;
+var macrotask = _task.set;
+var Observer = global$6.MutationObserver || global$6.WebKitMutationObserver;
+var process$3 = global$6.process;
+var Promise$1 = global$6.Promise;
+var isNode$1 = _cof(process$3) == 'process';
+
+var _microtask = function(){
+ var head, last, notify;
+
+ var flush = function(){
+ var parent, fn;
+ if(isNode$1 && (parent = process$3.domain)){ parent.exit(); }
+ while(head){
+ fn = head.fn;
+ head = head.next;
+ try {
+ fn();
+ } catch(e){
+ if(head){ notify(); }
+ else { last = undefined; }
+ throw e;
+ }
+ } last = undefined;
+ if(parent){ parent.enter(); }
+ };
+
+ // Node.js
+ if(isNode$1){
+ notify = function(){
+ process$3.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(){
+ node.data = toggle = !toggle;
+ };
+ // environments with maybe non-completely correct, but existent Promise
+ } else if(Promise$1 && Promise$1.resolve){
+ var promise = Promise$1.resolve();
+ notify = function(){
+ promise.then(flush);
+ };
+ // for other environments - macrotask based on:
+ // - setImmediate
+ // - MessageChannel
+ // - window.postMessag
+ // - onreadystatechange
+ // - setTimeout
+ } else {
+ notify = function(){
+ // strange IE + webpack dev server bug - use .call(global)
+ macrotask.call(global$6, flush);
+ };
+ }
+
+ return function(fn){
+ var task = {fn: fn, next: undefined};
+ if(last){ last.next = task; }
+ if(!head){
+ head = task;
+ notify();
+ } last = task;
+ };
+};
+
+var redefine$3 = _redefine;
+var _redefineAll = function(target, src, safe){
+ for(var key in src){ redefine$3(target, key, src[key], safe); }
+ return target;
+};
+
+var global$7 = _global;
+var dP$3 = _objectDp;
+var DESCRIPTORS = _descriptors;
+var SPECIES$1 = _wks('species');
+
+var _setSpecies = function(KEY){
+ var C = global$7[KEY];
+ if(DESCRIPTORS && C && !C[SPECIES$1]){ dP$3.f(C, SPECIES$1, {
+ configurable: true,
+ get: function(){ return this; }
+ }); }
+};
+
+var ITERATOR$4 = _wks('iterator');
+var SAFE_CLOSING = false;
+
+try {
+ var riter = [7][ITERATOR$4]();
+ riter['return'] = function(){ SAFE_CLOSING = true; };
+ Array.from(riter, function(){ throw 2; });
+} catch(e){ /* empty */ }
+
+var _iterDetect = function(exec, skipClosing){
+ if(!skipClosing && !SAFE_CLOSING){ return false; }
+ var safe = false;
+ try {
+ var arr = [7]
+ , iter = arr[ITERATOR$4]();
+ iter.next = function(){ return {done: safe = true}; };
+ arr[ITERATOR$4] = function(){ return iter; };
+ exec(arr);
+ } catch(e){ /* empty */ }
+ return safe;
+};
+
+var LIBRARY$1 = _library;
+var global$4 = _global;
+var ctx$1 = _ctx;
+var classof$1 = _classof;
+var $export$3 = _export;
+var isObject$3 = _isObject;
+var aFunction$1 = _aFunction;
+var anInstance = _anInstance;
+var forOf = _forOf;
+var speciesConstructor = _speciesConstructor;
+var task = _task.set;
+var microtask = _microtask();
+var PROMISE = 'Promise';
+var TypeError$1 = global$4.TypeError;
+var process$1 = global$4.process;
+var $Promise = global$4[PROMISE];
+var process$1 = global$4.process;
+var isNode = classof$1(process$1) == 'process';
+var empty = function(){ /* empty */ };
+var Internal;
+var GenericPromiseCapability;
+var Wrapper;
+
+var USE_NATIVE = !!function(){
+ try {
+ // correct subclassing with @@species support
+ var promise = $Promise.resolve(1)
+ , FakePromise = (promise.constructor = {})[_wks('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(a, b){
+ // with library wrapper special case
+ return a === b || a === $Promise && b === Wrapper;
+};
+var isThenable = function(it){
+ var then;
+ return isObject$3(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var newPromiseCapability = function(C){
+ return sameConstructor($Promise, C)
+ ? new PromiseCapability(C)
+ : new GenericPromiseCapability(C);
+};
+var PromiseCapability = GenericPromiseCapability = function(C){
+ var resolve, reject;
+ this.promise = new C(function($$resolve, $$reject){
+ if(resolve !== undefined || reject !== undefined){ throw TypeError$1('Bad Promise constructor'); }
+ resolve = $$resolve;
+ reject = $$reject;
+ });
+ this.resolve = aFunction$1(resolve);
+ this.reject = aFunction$1(reject);
+};
+var perform = function(exec){
+ try {
+ exec();
+ } catch(e){
+ return {error: e};
+ }
+};
+var notify$1 = function(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(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$1('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(promise){
+ task.call(global$4, function(){
+ var value = promise._v
+ , abrupt, handler, console;
+ if(isUnhandled(promise)){
+ abrupt = perform(function(){
+ if(isNode){
+ process$1.emit('unhandledRejection', value, promise);
+ } else if(handler = global$4.onunhandledrejection){
+ handler({promise: promise, reason: value});
+ } else if((console = global$4.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(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(promise){
+ task.call(global$4, function(){
+ var handler;
+ if(isNode){
+ process$1.emit('rejectionHandled', promise);
+ } else if(handler = global$4.onrejectionhandled){
+ handler({promise: promise, reason: promise._v});
+ }
+ });
+};
+var $reject = function(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$1(promise, true);
+};
+var $resolve = function(value){
+ var promise = this
+ , then;
+ if(promise._d){ return; }
+ promise._d = true;
+ promise = promise._w || promise; // unwrap
+ try {
+ if(promise === value){ throw TypeError$1("Promise can't be resolved itself"); }
+ if(then = isThenable(value)){
+ microtask(function(){
+ var wrapper = {_w: promise, _d: false}; // wrap
+ try {
+ then.call(value, ctx$1($resolve, wrapper, 1), ctx$1($reject, wrapper, 1));
+ } catch(e){
+ $reject.call(wrapper, e);
+ }
+ });
+ } else {
+ promise._v = value;
+ promise._s = 1;
+ notify$1(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$1(executor);
+ Internal.call(this);
+ try {
+ executor(ctx$1($resolve, this, 1), ctx$1($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 = _redefineAll($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$1.domain : undefined;
+ this._c.push(reaction);
+ if(this._a){ this._a.push(reaction); }
+ if(this._s){ notify$1(this, false); }
+ return reaction.promise;
+ },
+ // 25.4.5.1 Promise.prototype.catch(onRejected)
+ 'catch': function(onRejected){
+ return this.then(undefined, onRejected);
+ }
+ });
+ PromiseCapability = function(){
+ var promise = new Internal;
+ this.promise = promise;
+ this.resolve = ctx$1($resolve, promise, 1);
+ this.reject = ctx$1($reject, promise, 1);
+ };
+}
+
+$export$3($export$3.G + $export$3.W + $export$3.F * !USE_NATIVE, {Promise: $Promise});
+_setToStringTag($Promise, PROMISE);
+_setSpecies(PROMISE);
+Wrapper = _core[PROMISE];
+
+// statics
+$export$3($export$3.S + $export$3.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$3($export$3.S + $export$3.F * (LIBRARY$1 || !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$3($export$3.S + $export$3.F * !(USE_NATIVE && _iterDetect(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;
+ }
+});
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * @fileOverview
+ * This file will hack `console` methods by `WXEnvironment.logLevel`.
+ * So we can control how many and which messages will be sent by change the log level.
+ * Additionally in native platform the message content must be primitive values and
+ * using `nativeLog(...args, logLevelMark)` so we create a new `console` object in
+ * global add a format process for its methods.
+ */
+
+var LEVELS = ['off', 'error', 'warn', 'info', 'log', 'debug'];
+var levelMap = {};
+
+var originalConsole = global.console;
+
+/**
+ * Hack console for native environment.
+ */
+function setNativeConsole () {
+ generateLevelMap();
+
+ /* istanbul ignore next */
+ // mock console in native environment
+ if (global.WXEnvironment && global.WXEnvironment.platform !== 'Web') {
+ global.console = {
+ debug: function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('debug')) { global.nativeLog.apply(global, format(args).concat( ['__DEBUG'] )); }
+ },
+ log: function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('log')) { global.nativeLog.apply(global, format(args).concat( ['__LOG'] )); }
+ },
+ info: function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('info')) { global.nativeLog.apply(global, format(args).concat( ['__INFO'] )); }
+ },
+ warn: function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('warn')) { global.nativeLog.apply(global, format(args).concat( ['__WARN'] )); }
+ },
+ error: function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('error')) { global.nativeLog.apply(global, format(args).concat( ['__ERROR'] )); }
+ }
+ };
+ }
+
+ // Web or Node
+ else {
+ var debug = console.debug;
+ var log = console.log;
+ var info = console.info;
+ var warn = console.warn;
+ var error = console.error;
+ console.__ori__ = { debug: debug, log: log, info: info, warn: warn, error: error };
+ console.debug = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('debug')) { console.__ori__.debug.apply(console, args); }
+ };
+ console.log = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('log')) { console.__ori__.log.apply(console, args); }
+ };
+ console.info = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('info')) { console.__ori__.info.apply(console, args); }
+ };
+ console.warn = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('warn')) { console.__ori__.warn.apply(console, args); }
+ };
+ console.error = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ if (checkLevel('error')) { console.__ori__.error.apply(console, args); }
+ };
+ }
+}
+
+/**
+ * Reset hacked console to original.
+ */
+/* istanbul ignore next */
+function resetNativeConsole () {
+ levelMap = {};
+ global.console = originalConsole;
+}
+
+/**
+ * Generate map for which types of message will be sent in a certain message level
+ * as the order of LEVELS.
+ */
+function generateLevelMap () {
+ LEVELS.forEach(function (level) {
+ var levelIndex = LEVELS.indexOf(level);
+ levelMap[level] = {};
+ LEVELS.forEach(function (type) {
+ var typeIndex = LEVELS.indexOf(type);
+ if (typeIndex <= levelIndex) {
+ levelMap[level][type] = true;
+ }
+ });
+ });
+}
+
+/**
+ * Check if a certain type of message will be sent in current log level of env.
+ * @param {string} type
+ * @return {boolean}
+ */
+function checkLevel (type) {
+ var logLevel = (global.WXEnvironment && global.WXEnvironment.logLevel) || 'log';
+ return levelMap[logLevel] && levelMap[logLevel][type]
+}
+
+/**
+ * Convert all log arguments into primitive values.
+ * @param {array} args
+ * @return {array}
+ */
+/* istanbul ignore next */
+function format (args) {
+ return args.map(function (v) {
+ var type = Object.prototype.toString.call(v);
+ if (type.toLowerCase() === '[object object]') {
+ v = JSON.stringify(v);
+ }
+ else {
+ v = String(v);
+ }
+ return v
+ })
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * @fileOverview
+ * Polyfill `setTimeout` on Android V8 using native method
+ * `setTimeoutNative(callbackId, time)` and JS method
+ * `setTimeoutCallback(callbackId)`.
+ * This polyfill is only used in virtual-DOM diff & flush agorithm. Not
+ * accessed by JS Bundle code (The timer APIs polyfill for JS Bundle is in
+ * `html5/default/app/ctrl.js`).
+ */
+
+var originalSetTimeout = global.setTimeout;
+var setTimeoutNative = global.setTimeoutNative;
+
+/**
+ * Set up native timer
+ */
+/* istanbul ignore next */
+function setNativeTimer () {
+ if (typeof setTimeout === 'undefined' &&
+ typeof setTimeoutNative === '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];
+ }
+ };
+ }
+}
+
+/* istanbul ignore next */
+function resetNativeTimer () {
+ global.setTimeout = originalSetTimeout;
+ global.setTimeoutCallback = null;
+}
+
+setNativeTimer();
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Freeze the prototype of javascript build-in objects.
+ */
+/* istanbul ignore next */
+function freezePrototype$1 () {
+ Object.freeze(Object);
+ Object.freeze(Array);
+
+ // Object.freeze(Object.prototype)
+ freezeObjectProto();
+ Object.freeze(Array.prototype);
+ Object.freeze(String.prototype);
+ Object.freeze(Number.prototype);
+ Object.freeze(Boolean.prototype);
+
+ // Object.freeze(Error.prototype)
+ freezeErrorProto();
+ Object.freeze(Date.prototype);
+ Object.freeze(RegExp.prototype);
+}
+
+function freezeObjectProto () {
+ var proto = Object.prototype;
+ var protoName = 'Object.prototype';
+ freezeProtoProperty(proto, '__defineGetter__', protoName);
+ freezeProtoProperty(proto, '__defineSetter__', protoName);
+ freezeProtoProperty(proto, '__lookupGetter__', protoName);
+ freezeProtoProperty(proto, '__lookupSetter__', protoName);
+ freezeProtoProperty(proto, 'constructor', protoName);
+ freezeProtoProperty(proto, 'hasOwnProperty', protoName);
+ freezeProtoProperty(proto, 'isPrototypeOf', protoName);
+ freezeProtoProperty(proto, 'propertyIsEnumerable', protoName);
+ freezeProtoProperty(proto, 'toLocaleString', protoName);
+ freezeProtoProperty(proto, 'toString', protoName);
+ freezeProtoProperty(proto, 'valueOf', protoName);
+ Object.seal(proto);
+}
+
+function freezeErrorProto () {
+ var proto = Error.prototype;
+ var protoName = 'Error.prototype';
+ freezeProtoProperty(proto, 'name', protoName);
+ freezeProtoProperty(proto, 'message', protoName);
+ freezeProtoProperty(proto, 'toString', protoName);
+ freezeProtoProperty(proto, 'constructor', protoName);
+ Object.seal(proto);
+}
+
+function freezeProtoProperty (proto, propertyName, protoName) {
+ if (!proto.hasOwnProperty(propertyName)) {
+ return
+ }
+
+ var origin = proto[propertyName];
+ Object.defineProperty(proto, propertyName, {
+ get: function () {
+ return origin
+ },
+ set: function (value) {
+ if (this === proto) {
+ throw Error(("Cannot assign to read only property " + propertyName + " of " + protoName))
+ }
+
+ Object.defineProperty(this, propertyName, {
+ value: value,
+ writable: true
+ });
+
+ return value
+ }
+ });
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+// import promise hack and polyfills
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * For general callback management of a certain Weex instance.
+ * Because function can not passed into native, so we create callback
+ * callback id for each function and pass the callback id into native
+ * in fact. And when a callback called from native, we can find the real
+ * callback through the callback id we have passed before.
+ */
+var CallbackManager = function CallbackManager (instanceId) {
+ this.instanceId = instanceId;
+ this.lastCallbackId = 0;
+ this.callbacks = [];
+};
+CallbackManager.prototype.add = function add (callback) {
+ this.lastCallbackId++;
+ this.callbacks[this.lastCallbackId] = callback;
+ return this.lastCallbackId
+};
+CallbackManager.prototype.remove = function remove (callbackId) {
+ var callback = this.callbacks[callbackId];
+ this.callbacks[callbackId] = undefined;
+ return callback
+};
+CallbackManager.prototype.consume = function consume (callbackId, data, ifKeepAlive) {
+ var callback = this.callbacks[callbackId];
+ if (typeof ifKeepAlive === 'undefined' || ifKeepAlive === false) {
+ this.callbacks[callbackId] = undefined;
+ }
+ if (typeof callback === 'function') {
+ return callback(data)
+ }
+ return new Error(("invalid callback id \"" + callbackId + "\""))
+};
+CallbackManager.prototype.close = function close () {
+ this.callbacks = this.callbacks.map(function (cb) { return undefined; });
+};
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+var docMap = {};
+
+/**
+ * Add a document object into docMap.
+ * @param {string} id
+ * @param {object} document
+ */
+function addDoc (id, doc) {
+ if (id) {
+ docMap[id] = doc;
+ }
+}
+
+/**
+ * Get the document object by id.
+ * @param {string} id
+ */
+function getDoc (id) {
+ return docMap[id]
+}
+
+/**
+ * Remove the document from docMap by id.
+ * @param {string} id
+ */
+function removeDoc (id) {
+ delete docMap[id];
+}
+
+/**
+ * @deprecated
+ * Get listener by document id.
+ * @param {string} id
+ * @return {object} listener
+ */
+
+
+/**
+ * Get TaskCenter instance by id.
+ * @param {string} id
+ * @return {object} TaskCenter
+ */
+function getTaskCenter (id) {
+ var doc = docMap[id];
+ if (doc && doc.taskCenter) {
+ return doc.taskCenter
+ }
+ return null
+}
+
+/**
+ * Get a unique id.
+ */
+var nextNodeRef = 1;
+function uniqueId () {
+ return (nextNodeRef++).toString()
+}
+
+/**
+ * Append body node to documentElement.
+ * @param {object} document
+ * @param {object} node
+ * @param {object} before
+ */
+function appendBody (doc, node, before) {
+ var documentElement = doc.documentElement;
+
+ if (documentElement.pureChildren.length > 0 || node.parentNode) {
+ return
+ }
+ var children = documentElement.children;
+ var beforeIndex = children.indexOf(before);
+ if (beforeIndex < 0) {
+ children.push(node);
+ }
+ else {
+ children.splice(beforeIndex, 0, node);
+ }
+
+ if (node.nodeType === 1) {
+ if (node.role === 'body') {
+ node.docId = doc.id;
+ node.ownerDocument = doc;
+ node.parentNode = documentElement;
+ linkParent(node, documentElement);
+ }
+ else {
+ node.children.forEach(function (child) {
+ child.parentNode = node;
+ });
+ setBody(doc, node);
+ node.docId = doc.id;
+ node.ownerDocument = doc;
+ linkParent(node, documentElement);
+ delete doc.nodeMap[node.nodeId];
+ }
+ documentElement.pureChildren.push(node);
+ sendBody(doc, node);
+ }
+ else {
+ node.parentNode = documentElement;
+ doc.nodeMap[node.ref] = node;
+ }
+}
+
+function sendBody (doc, node) {
+ var body = node.toJSON();
+ var children = body.children;
+ delete body.children;
+ var result = doc.taskCenter.send('dom', { action: 'createBody' }, [body]);
+ if (children) {
+ children.forEach(function (child) {
+ result = doc.taskCenter.send('dom', { action: 'addElement' }, [body.ref, child, -1]);
+ });
+ }
+ return result
+}
+
+/**
+ * Set up body node.
+ * @param {object} document
+ * @param {object} element
+ */
+function setBody (doc, el) {
+ el.role = 'body';
+ el.depth = 1;
+ delete doc.nodeMap[el.nodeId];
+ el.ref = '_root';
+ doc.nodeMap._root = el;
+ doc.body = el;
+}
+
+/**
+ * Establish the connection between parent and child node.
+ * @param {object} child node
+ * @param {object} parent node
+ */
+function linkParent (node, parent) {
+ node.parentNode = parent;
+ if (parent.docId) {
+ node.docId = parent.docId;
+ node.ownerDocument = parent.ownerDocument;
+ node.ownerDocument.nodeMap[node.nodeId] = node;
+ node.depth = parent.depth + 1;
+ }
+ node.children.forEach(function (child) {
+ linkParent(child, node);
+ });
+}
+
+/**
+ * Get the next sibling element.
+ * @param {object} node
+ */
+function nextElement (node) {
+ while (node) {
+ if (node.nodeType === 1) {
+ return node
+ }
+ node = node.nextSibling;
+ }
+}
+
+/**
+ * Get the previous sibling element.
+ * @param {object} node
+ */
+function previousElement (node) {
+ while (node) {
+ if (node.nodeType === 1) {
+ return node
+ }
+ node = node.previousSibling;
+ }
+}
+
+/**
+ * Insert a node into list at the specified index.
+ * @param {object} target node
+ * @param {array} list
+ * @param {number} newIndex
+ * @param {boolean} changeSibling
+ * @return {number} newIndex
+ */
+function insertIndex (target, list, newIndex, changeSibling) {
+ /* istanbul ignore next */
+ if (newIndex < 0) {
+ newIndex = 0;
+ }
+ var before = list[newIndex - 1];
+ var after = list[newIndex];
+ list.splice(newIndex, 0, target);
+ if (changeSibling) {
+ before && (before.nextSibling = target);
+ target.previousSibling = before;
+ target.nextSibling = after;
+ after && (after.previousSibling = target);
+ }
+ return newIndex
+}
+
+/**
+ * Move the node to a new index in list.
+ * @param {object} target node
+ * @param {array} list
+ * @param {number} newIndex
+ * @param {boolean} changeSibling
+ * @return {number} newIndex
+ */
+function moveIndex (target, list, newIndex, changeSibling) {
+ var index = list.indexOf(target);
+ /* istanbul ignore next */
+ if (index < 0) {
+ return -1
+ }
+ if (changeSibling) {
+ var before = list[index - 1];
+ var after = list[index + 1];
+ before && (before.nextSibling = after);
+ after && (after.previousSibling = before);
+ }
+ list.splice(index, 1);
+ var newIndexAfter = newIndex;
+ if (index <= newIndex) {
+ newIndexAfter = newIndex - 1;
+ }
+ var beforeNew = list[newIndexAfter - 1];
+ var afterNew = list[newIndexAfter];
+ list.splice(newIndexAfter, 0, target);
+ if (changeSibling) {
+ beforeNew && (beforeNew.nextSibling = target);
+ target.previousSibling = beforeNew;
+ target.nextSibling = afterNew;
+ afterNew && (afterNew.previousSibling = target);
+ }
+ if (index === newIndexAfter) {
+ return -1
+ }
+ return newIndex
+}
+
+/**
+ * Remove the node from list.
+ * @param {object} target node
+ * @param {array} list
+ * @param {boolean} changeSibling
+ */
+function removeIndex (target, list, changeSibling) {
+ var index = list.indexOf(target);
+ /* istanbul ignore next */
+ if (index < 0) {
+ return
+ }
+ if (changeSibling) {
+ var before = list[index - 1];
+ var after = list[index + 1];
+ before && (before.nextSibling = after);
+ after && (after.previousSibling = before);
+ }
+ list.splice(index, 1);
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * @fileOverview
+ * Virtual-DOM Node. It's the supper class of Element and Comment.
+ */
+
+function Node () {
+ this.nodeId = uniqueId();
+ this.ref = this.nodeId;
+ this.children = [];
+ this.pureChildren = [];
+ this.parentNode = null;
+ this.nextSibling = null;
+ this.previousSibling = null;
+}
+
+/**
+ * Destroy current node, and remove itself form nodeMap.
+ */
+Node.prototype.destroy = function () {
+ var doc = getDoc(this.docId);
+ if (doc) {
+ delete this.docId;
+ delete doc.nodeMap[this.nodeId];
+ }
+ this.children.forEach(function (child) {
+ child.destroy();
+ });
+};
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var Element$1;
+
+function setElement (El) {
+ Element$1 = El;
+}
+
+/**
+ * A map which stores all type of elements.
+ * @type {Object}
+ */
+var elementTypes = {};
+
+/**
+ * Register an extended element type with component methods.
+ * @param {string} type component type
+ * @param {array} methods a list of method names
+ */
+function registerElement (type, methods) {
+ // Skip when no special component methods.
+ if (!methods || !methods.length) {
+ return
+ }
+
+ // Init constructor.
+ var XElement = function (props) {
+ Element$1.call(this, type, props, true);
+ };
+
+ // Init prototype.
+ XElement.prototype = Object.create(Element$1.prototype);
+ Object.defineProperty(XElement.prototype, 'constructor', {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: Element$1
+ });
+
+ // Add methods to prototype.
+ methods.forEach(function (methodName) {
+ XElement.prototype[methodName] = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ return taskCenter.send('component', {
+ ref: this.ref,
+ component: type,
+ method: methodName
+ }, args)
+ }
+ };
+ });
+
+ // Add to element type map.
+ elementTypes[type] = XElement;
+}
+
+/**
+ * Clear all element types. Only for testing.
+ */
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * @fileOverview
+ * Virtual-DOM Element.
+ */
+
+var DEFAULT_TAG_NAME = 'div';
+var BUBBLE_EVENTS = ['click', 'longpress', 'touchstart', 'touchmove', 'touchend', 'panstart', 'panmove', 'panend', 'horizontalpan', 'verticalpan', 'swipe'];
+
+function Element (type, props, isExtended) {
+ if ( type === void 0 ) type = DEFAULT_TAG_NAME;
+
+ var XElement = elementTypes[type];
+ if (XElement && !isExtended) {
+ return new XElement(props)
+ }
+ props = props || {};
+ this.nodeType = 1;
+ this.nodeId = uniqueId();
+ this.ref = this.nodeId;
+ this.type = type;
+ this.attr = props.attr || {};
+ this.style = props.style || {};
+ this.classStyle = props.classStyle || {};
+ this.event = {};
+ this.children = [];
+ this.pureChildren = [];
+}
+
+Element.prototype = Object.create(Node.prototype);
+Element.prototype.constructor = Element;
+
+function registerNode (docId, node) {
+ var doc = getDoc(docId);
+ doc.nodeMap[node.nodeId] = node;
+}
+
+setElement(Element);
+
+Object.assign(Element.prototype, {
+ /**
+ * Append a child node.
+ * @param {object} node
+ * @return {undefined | number} the signal sent by native
+ */
+ appendChild: function appendChild (node) {
+ if (node.parentNode && node.parentNode !== this) {
+ return
+ }
+ /* istanbul ignore else */
+ if (!node.parentNode) {
+ linkParent(node, this);
+ insertIndex(node, this.children, this.children.length, true);
+ if (this.docId) {
+ registerNode(this.docId, node);
+ }
+ if (node.nodeType === 1) {
+ insertIndex(node, this.pureChildren, this.pureChildren.length);
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ return taskCenter.send(
+ 'dom',
+ { action: 'addElement' },
+ [this.ref, node.toJSON(), -1]
+ )
+ }
+ }
+ }
+ else {
+ moveIndex(node, this.children, this.children.length, true);
+ if (node.nodeType === 1) {
+ var index = moveIndex(node, this.pureChildren, this.pureChildren.length);
+ var taskCenter$1 = getTaskCenter(this.docId);
+ if (taskCenter$1 && index >= 0) {
+ return taskCenter$1.send(
+ 'dom',
+ { action: 'moveElement' },
+ [node.ref, this.ref, index]
+ )
+ }
+ }
+ }
+ },
+
+ /**
+ * Insert a node before specified node.
+ * @param {object} node
+ * @param {object} before
+ * @return {undefined | number} the signal sent by native
+ */
+ insertBefore: function insertBefore (node, before) {
+ if (node.parentNode && node.parentNode !== this) {
+ return
+ }
+ if (node === before || (node.nextSibling && node.nextSibling === before)) {
+ return
+ }
+ if (!node.parentNode) {
+ linkParent(node, this);
+ insertIndex(node, this.children, this.children.indexOf(before), true);
+ if (this.docId) {
+ registerNode(this.docId, node);
+ }
+ if (node.nodeType === 1) {
+ var pureBefore = nextElement(before);
+ var index = insertIndex(
+ node,
+ this.pureChildren,
+ pureBefore
+ ? this.pureChildren.indexOf(pureBefore)
+ : this.pureChildren.length
+ );
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ return taskCenter.send(
+ 'dom',
+ { action: 'addElement' },
+ [this.ref, node.toJSON(), index]
+ )
+ }
+ }
+ }
+ else {
+ moveIndex(node, this.children, this.children.indexOf(before), true);
+ if (node.nodeType === 1) {
+ var pureBefore$1 = nextElement(before);
+ /* istanbul ignore next */
+ var index$1 = moveIndex(
+ node,
+ this.pureChildren,
+ pureBefore$1
+ ? this.pureChildren.indexOf(pureBefore$1)
+ : this.pureChildren.length
+ );
+ var taskCenter$1 = getTaskCenter(this.docId);
+ if (taskCenter$1 && index$1 >= 0) {
+ return taskCenter$1.send(
+ 'dom',
+ { action: 'moveElement' },
+ [node.ref, this.ref, index$1]
+ )
+ }
+ }
+ }
+ },
+
+ /**
+ * Insert a node after specified node.
+ * @param {object} node
+ * @param {object} after
+ * @return {undefined | number} the signal sent by native
+ */
+ insertAfter: function insertAfter (node, after) {
+ if (node.parentNode && node.parentNode !== this) {
+ return
+ }
+ if (node === after || (node.previousSibling && node.previousSibling === after)) {
+ return
+ }
+ if (!node.parentNode) {
+ linkParent(node, this);
+ insertIndex(node, this.children, this.children.indexOf(after) + 1, true);
+ /* istanbul ignore else */
+ if (this.docId) {
+ registerNode(this.docId, node);
+ }
+ if (node.nodeType === 1) {
+ var index = insertIndex(
+ node,
+ this.pureChildren,
+ this.pureChildren.indexOf(previousElement(after)) + 1
+ );
+ var taskCenter = getTaskCenter(this.docId);
+ /* istanbul ignore else */
+ if (taskCenter) {
+ return taskCenter.send(
+ 'dom',
+ { action: 'addElement' },
+ [this.ref, node.toJSON(), index]
+ )
+ }
+ }
+ }
+ else {
+ moveIndex(node, this.children, this.children.indexOf(after) + 1, true);
+ if (node.nodeType === 1) {
+ var index$1 = moveIndex(
+ node,
+ this.pureChildren,
+ this.pureChildren.indexOf(previousElement(after)) + 1
+ );
+ var taskCenter$1 = getTaskCenter(this.docId);
+ if (taskCenter$1 && index$1 >= 0) {
+ return taskCenter$1.send(
+ 'dom',
+ { action: 'moveElement' },
+ [node.ref, this.ref, index$1]
+ )
+ }
+ }
+ }
+ },
+
+ /**
+ * Remove a child node, and decide whether it should be destroyed.
+ * @param {object} node
+ * @param {boolean} preserved
+ */
+ removeChild: function removeChild (node, preserved) {
+ if (node.parentNode) {
+ removeIndex(node, this.children, true);
+ if (node.nodeType === 1) {
+ removeIndex(node, this.pureChildren);
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ taskCenter.send(
+ 'dom',
+ { action: 'removeElement' },
+ [node.ref]
+ );
+ }
+ }
+ }
+ if (!preserved) {
+ node.destroy();
+ }
+ },
+
+ /**
+ * Clear all child nodes.
+ */
+ clear: function clear () {
+ var taskCenter = getTaskCenter(this.docId);
+ /* istanbul ignore else */
+ if (taskCenter) {
+ this.pureChildren.forEach(function (node) {
+ taskCenter.send(
+ 'dom',
+ { action: 'removeElement' },
+ [node.ref]
+ );
+ });
+ }
+ this.children.forEach(function (node) {
+ node.destroy();
+ });
+ this.children.length = 0;
+ this.pureChildren.length = 0;
+ },
+
+ /**
+ * Set an attribute, and decide whether the task should be send to native.
+ * @param {string} key
+ * @param {string | number} value
+ * @param {boolean} silent
+ */
+ setAttr: function setAttr (key, value, silent) {
+ if (this.attr[key] === value && silent !== false) {
+ return
+ }
+ this.attr[key] = value;
+ var taskCenter = getTaskCenter(this.docId);
+ if (!silent && taskCenter) {
+ var result = {};
+ result[key] = value;
+ taskCenter.send(
+ 'dom',
+ { action: 'updateAttrs' },
+ [this.ref, result]
+ );
+ }
+ },
+
+ /**
+ * Set a style property, and decide whether the task should be send to native.
+ * @param {string} key
+ * @param {string | number} value
+ * @param {boolean} silent
+ */
+ setStyle: function setStyle (key, value, silent) {
+ if (this.style[key] === value && silent !== false) {
+ return
+ }
+ this.style[key] = value;
+ var taskCenter = getTaskCenter(this.docId);
+ if (!silent && taskCenter) {
+ var result = {};
+ result[key] = value;
+ taskCenter.send(
+ 'dom',
+ { action: 'updateStyle' },
+ [this.ref, result]
+ );
+ }
+ },
+
+ /**
+ * Set style properties from class.
+ * @param {object} classStyle
+ */
+ setClassStyle: function setClassStyle (classStyle) {
+ var this$1 = this;
+
+ // reset previous class style to empty string
+ for (var key in this.classStyle) {
+ this$1.classStyle[key] = '';
+ }
+
+ Object.assign(this.classStyle, classStyle);
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ taskCenter.send(
+ 'dom',
+ { action: 'updateStyle' },
+ [this.ref, this.toStyle()]
+ );
+ }
+ },
+
+ /**
+ * Add an event handler.
+ * @param {string} event type
+ * @param {function} event handler
+ */
+ addEvent: function addEvent (type, handler) {
+ if (!this.event[type]) {
+ this.event[type] = handler;
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ taskCenter.send(
+ 'dom',
+ { action: 'addEvent' },
+ [this.ref, type]
+ );
+ }
+ }
+ },
+
+ /**
+ * Remove an event handler.
+ * @param {string} event type
+ */
+ removeEvent: function removeEvent (type) {
+ if (this.event[type]) {
+ delete this.event[type];
+ var taskCenter = getTaskCenter(this.docId);
+ if (taskCenter) {
+ taskCenter.send(
+ 'dom',
+ { action: 'removeEvent' },
+ [this.ref, type]
+ );
+ }
+ }
+ },
+
+ /**
+ * Fire an event manually.
+ * @param {string} type type
+ * @param {function} e handler
+ * @param {boolean} isBubble whether or not event bubble
+ * @return {} anything returned by handler function
+ */
+ fireEvent: function fireEvent (type, e, isBubble) {
+ var isStopPropagation = false;
+ var handler = this.event[type];
+ if (handler && e) {
+ e.stopPropagation = function () {
+ isStopPropagation = true;
+ };
+ handler.call(this, e);
+ }
+
+ if (isStopPropagation) {
+ return
+ }
+
+ if (isBubble && BUBBLE_EVENTS.includes(type) && this.parentNode && this.parentNode.fireEvent) {
+ e.currentTarget = this.parentNode;
+ this.parentNode.fireEvent(type, e, isBubble);
+ }
+ },
+
+ /**
+ * Get all styles of current element.
+ * @return {object} style
+ */
+ toStyle: function toStyle () {
+ return Object.assign({}, this.classStyle, this.style)
+ },
+
+ /**
+ * Convert current element to JSON like object.
+ * @return {object} element
+ */
+ toJSON: function toJSON () {
+ var result = {
+ ref: this.ref.toString(),
+ type: this.type,
+ attr: this.attr,
+ style: this.toStyle()
+ };
+ var event = Object.keys(this.event);
+ if (event.length) {
+ result.event = event;
+ }
+ if (this.pureChildren.length) {
+ result.children = this.pureChildren.map(function (child) { return child.toJSON(); });
+ }
+ return result
+ },
+
+ /**
+ * Convert to HTML element tag string.
+ * @return {stirng} html
+ */
+ toString: function toString () {
+ return '<' + this.type +
+ ' attr=' + JSON.stringify(this.attr) +
+ ' style=' + JSON.stringify(this.toStyle()) + '>' +
+ this.pureChildren.map(function (child) { return child.toString(); }).join('') +
+ '</' + this.type + '>'
+ }
+});
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var fallback = function () {};
+
+// The API of TaskCenter would be re-design.
+var TaskCenter = function TaskCenter (id, sendTasks) {
+ Object.defineProperty(this, 'instanceId', {
+ enumerable: true,
+ value: id
+ });
+ Object.defineProperty(th
<TRUNCATED>