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>