http://git-wip-us.apache.org/repos/asf/incubator-weex/blob/678ecb85/pre-build/weex-main-jsfm.js ---------------------------------------------------------------------- diff --git a/pre-build/weex-main-jsfm.js b/pre-build/weex-main-jsfm.js new file mode 100644 index 0000000..8a2c243 --- /dev/null +++ b/pre-build/weex-main-jsfm.js @@ -0,0 +1,18867 @@ +(this.nativeLog || function(s) {console.log(s)})('START JS FRAMEWORK 0.24.1, Build 2018-01-11 19:55. (Vue: 2.5.11-weex.2, Rax: 0.4.20)'); +;(this.getJSFMVersion = function(){return "0.24.1"}); +var global = this; var 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'; + +/* + * 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; + }; + }()); +} + +function unwrapExports (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? 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 + // eslint-disable-next-line no-new-func + : 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.5.3' }; +if (typeof __e == 'number') { __e = core; } // eslint-disable-line no-undef +}); + +var _core_1 = _core.version; + +var _isObject = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; + +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 document$1 = _global.document; +// typeof document.createElement is 'object' in old IE +var is = _isObject(document$1) && _isObject(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]) + +// 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(it)) { return it; } + var fn, val; + if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) { return val; } + if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) { return val; } + if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) { return val; } + throw TypeError("Can't convert object to primitive value"); +}; + +var dP = Object.defineProperty; + +var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) { + _anObject(O); + P = _toPrimitive(P, true); + _anObject(Attributes); + if (_ie8DomDefine) { try { + return dP(O, P, Attributes); + } catch (e) { /* empty */ } } + if ('get' in Attributes || 'set' in Attributes) { throw TypeError('Accessors not supported!'); } + if ('value' in Attributes) { O[P] = Attributes.value; } + return O; +}; + +var _objectDp = { + f: f +}; + +var _propertyDesc = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var _hide = _descriptors ? function (object, key, value) { + return _objectDp.f(object, key, _propertyDesc(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 SRC = _uid('src'); +var TO_STRING = 'toString'; +var $toString = Function[TO_STRING]; +var 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 _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 PROTOTYPE = 'prototype'; + +var $export = function (type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE]; + var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {}); + var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}); + var key, own, out, exp; + if (IS_GLOBAL) { source = name; } + for (key in source) { + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + // export native or passed + out = (own ? target : source)[key]; + // bind timers to global for call from export context + exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out; + // extend global + if (target) { _redefine(target, key, out, type & $export.U); } + // export + if (exports[key] != out) { _hide(exports, key, exp); } + if (IS_PROTO && expProto[key] != out) { expProto[key] = out; } + } +}; +_global.core = _core; +// type bitmap +$export.F = 1; // forced +$export.G = 2; // global +$export.S = 4; // static +$export.P = 8; // proto +$export.B = 16; // bind +$export.W = 32; // wrap +$export.U = 64; // safe +$export.R = 128; // real proto method for `library` +var _export = $export; + +var toString = {}.toString; + +var _cof = function (it) { + return toString.call(it).slice(8, -1); +}; + +// fallback for non-array-like ES3 and non-enumerable old V8 strings + +// eslint-disable-next-line no-prototype-builtins +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 _toIobject = function (it) { + return _iobject(_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 min = Math.min; +var _toLength = function (it) { + return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 +}; + +var max = Math.max; +var min$1 = Math.min; +var _toAbsoluteIndex = function (index, length) { + index = _toInteger(index); + return index < 0 ? max(index + length, 0) : min$1(index, length); +}; + +// false -> Array#indexOf +// true -> Array#includes + + + +var _arrayIncludes = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = _toIobject($this); + var length = _toLength(O.length); + var index = _toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare + if (IS_INCLUDES && el != el) { while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare + if (value != value) { return true; } + // Array#indexOf ignores holes, Array#includes - not + } } else { for (;length > index; index++) { if (IS_INCLUDES || index in O) { + if (O[index] === el) { return IS_INCLUDES || index || 0; } + } } } return !IS_INCLUDES && -1; + }; +}; + +var SHARED = '__core-js_shared__'; +var store = _global[SHARED] || (_global[SHARED] = {}); +var _shared = function (key) { + return store[key] || (store[key] = {}); +}; + +var shared$2 = _shared('keys'); + +var _sharedKey = function (key) { + return shared$2[key] || (shared$2[key] = _uid(key)); +}; + +var arrayIndexOf = _arrayIncludes(false); +var IE_PROTO = _sharedKey('IE_PROTO'); + +var _objectKeysInternal = function (object, names) { + var O = _toIobject(object); + var i = 0; + var result = []; + var key; + for (key in O) { if (key != IE_PROTO) { _has(O, key) && result.push(key); } } + // Don't enum bug & hidden keys + while (names.length > i) { if (_has(O, key = names[i++])) { + ~arrayIndexOf(result, key) || result.push(key); + } } + return result; +}; + +// 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 _objectKeys = Object.keys || function keys(O) { + return _objectKeysInternal(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 _toObject = function (it) { + return Object(_defined(it)); +}; + +// 19.1.2.1 Object.assign(target, source, ...) + + + + + +var $assign = Object.assign; + +// should work with symbols and should have deterministic property order (V8 bug) +var _objectAssign = !$assign || _fails(function () { + var A = {}; + var B = {}; + // eslint-disable-next-line no-undef + var S = Symbol(); + var K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function (k) { B[k] = k; }); + return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; +}) ? function assign(target, source) { + var arguments$1 = arguments; + // eslint-disable-line no-unused-vars + var T = _toObject(target); + var aLen = arguments.length; + var index = 1; + var getSymbols = _objectGops.f; + var isEnum = _objectPie.f; + while (aLen > index) { + var S = _iobject(arguments$1[index++]); + var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S); + var length = keys.length; + var j = 0; + var 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) + + +_export(_export.S + _export.F, 'Object', { assign: _objectAssign }); + +var assign = _core.Object.assign; + +/* + * 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 WXEnvironment$1 = global.WXEnvironment; + +/* istanbul ignore next */ +if (WXEnvironment$1 && WXEnvironment$1.platform === 'iOS') { + global.Promise = undefined; +} + +var _wks = createCommonjsModule(function (module) { +var store = _shared('wks'); + +var Symbol = _global.Symbol; +var USE_SYMBOL = typeof Symbol == 'function'; + +var $exports = module.exports = function (name) { + return store[name] || (store[name] = + USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : _uid)('Symbol.' + name)); +}; + +$exports.store = store; +}); + +// getting tag from 19.1.3.6 Object.prototype.toString() + +var TAG = _wks('toStringTag'); +// ES3 wrong here +var ARG = _cof(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (e) { /* empty */ } +}; + +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(O) + // ES3 arguments fallback + : (B = _cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; +}; + +// 19.1.3.6 Object.prototype.toString() + +var test = {}; +test[_wks('toStringTag')] = 'z'; +if (test + '' != '[object z]') { + _redefine(Object.prototype, 'toString', function toString() { + return '[object ' + _classof(this) + ']'; + }, true); +} + +// true -> String#at +// false -> String#codePointAt +var _stringAt = function (TO_STRING) { + return function (that, pos) { + var s = String(_defined(that)); + var i = _toInteger(pos); + var l = s.length; + var a, b; + if (i < 0 || i >= l) { return TO_STRING ? '' : undefined; } + a = s.charCodeAt(i); + return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff + ? TO_STRING ? s.charAt(i) : a + : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; + }; +}; + +var _library = false; + +var _iterators = {}; + +var _objectDps = _descriptors ? Object.defineProperties : function defineProperties(O, Properties) { + _anObject(O); + var keys = _objectKeys(Properties); + var length = keys.length; + var i = 0; + var P; + while (length > i) { _objectDp.f(O, P = keys[i++], Properties[P]); } + return O; +}; + +var document$2 = _global.document; +var _html = document$2 && document$2.documentElement; + +// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) + + + +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'); + var i = _enumBugKeys.length; + var lt = '<'; + var gt = '>'; + var 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[i]]; } + return createDict(); +}; + +var _objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + Empty[PROTOTYPE$1] = _anObject(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 : _objectDps(result, Properties); +}; + +var def = _objectDp.f; + +var TAG$1 = _wks('toStringTag'); + +var _setToStringTag = function (it, tag, stat) { + if (it && !_has(it = stat ? it : it.prototype, TAG$1)) { def(it, TAG$1, { configurable: true, value: tag }); } +}; + +var IteratorPrototype = {}; + +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +_hide(IteratorPrototype, _wks('iterator'), function () { return this; }); + +var _iterCreate = function (Constructor, NAME, next) { + Constructor.prototype = _objectCreate(IteratorPrototype, { next: _propertyDesc(1, next) }); + _setToStringTag(Constructor, NAME + ' Iterator'); +}; + +// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) + + +var IE_PROTO$2 = _sharedKey('IE_PROTO'); +var ObjectProto = Object.prototype; + +var _objectGpo = Object.getPrototypeOf || function (O) { + O = _toObject(O); + if (_has(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 ITERATOR = _wks('iterator'); +var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next` +var FF_ITERATOR = '@@iterator'; +var KEYS = 'keys'; +var VALUES = 'values'; + +var returnThis = function () { return this; }; + +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'; + var DEF_VALUES = DEFAULT == VALUES; + var VALUES_BUG = false; + var proto = Base.prototype; + var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]; + var $default = (!BUGGY && $native) || getMethod(DEFAULT); + var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined; + var $anyNative = NAME == 'Array' ? proto.entries || $native : $native; + var methods, key, IteratorPrototype; + // Fix native + if ($anyNative) { + IteratorPrototype = _objectGpo($anyNative.call(new Base())); + if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) { + // Set @@toStringTag to native iterators + _setToStringTag(IteratorPrototype, TAG, true); + // fix for some old engines + if (!_library && !_has(IteratorPrototype, ITERATOR)) { _hide(IteratorPrototype, ITERATOR, returnThis); } + } + } + // fix Array#{values, @@iterator}.name in V8 / FF + if (DEF_VALUES && $native && $native.name !== VALUES) { + VALUES_BUG = true; + $default = function values() { return $native.call(this); }; + } + // Define iterator + if ((!_library || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) { + _hide(proto, ITERATOR, $default); + } + // Plug for library + _iterators[NAME] = $default; + _iterators[TAG] = returnThis; + if (DEFAULT) { + methods = { + values: DEF_VALUES ? $default : getMethod(VALUES), + keys: IS_SET ? $default : getMethod(KEYS), + entries: $entries + }; + if (FORCED) { for (key in methods) { + if (!(key in proto)) { _redefine(proto, key, methods[key]); } + } } else { _export(_export.P + _export.F * (BUGGY || VALUES_BUG), NAME, methods); } + } + return methods; +}; + +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; + var index = this._i; + var point; + if (index >= O.length) { return { value: undefined, done: true }; } + point = $at(O, index); + this._i += point.length; + return { value: point, done: false }; +}); + +// 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 }; +}; + +// 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(iterated); // target + this._i = 0; // next index + this._k = kind; // kind +// 22.1.5.2.1 %ArrayIteratorPrototype%.next() +}, function () { + var O = this._t; + var kind = this._k; + var index = this._i++; + if (!O || index >= O.length) { + this._t = undefined; + return _iterStep(1); + } + if (kind == 'keys') { return _iterStep(0, index); } + if (kind == 'values') { return _iterStep(0, O[index]); } + return _iterStep(0, [index, O[index]]); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) +_iterators.Arguments = _iterators.Array; + +_addToUnscopables('keys'); +_addToUnscopables('values'); +_addToUnscopables('entries'); + +var ITERATOR$1 = _wks('iterator'); +var TO_STRING_TAG = _wks('toStringTag'); +var ArrayValues = _iterators.Array; + +var DOMIterables = { + CSSRuleList: true, // TODO: Not spec compliant, should be false. + CSSStyleDeclaration: false, + CSSValueList: false, + ClientRectList: false, + DOMRectList: false, + DOMStringList: false, + DOMTokenList: true, + DataTransferItemList: false, + FileList: false, + HTMLAllCollection: false, + HTMLCollection: false, + HTMLFormElement: false, + HTMLSelectElement: false, + MediaList: true, // TODO: Not spec compliant, should be false. + MimeTypeArray: false, + NamedNodeMap: false, + NodeList: true, + PaintRequestList: false, + Plugin: false, + PluginArray: false, + SVGLengthList: false, + SVGNumberList: false, + SVGPathSegList: false, + SVGPointList: false, + SVGStringList: false, + SVGTransformList: false, + SourceBufferList: false, + StyleSheetList: true, // TODO: Not spec compliant, should be false. + TextTrackCueList: false, + TextTrackList: false, + TouchList: false +}; + +for (var collections = _objectKeys(DOMIterables), i = 0; i < collections.length; i++) { + var NAME = collections[i]; + var explicit = DOMIterables[NAME]; + var Collection = _global[NAME]; + var proto = Collection && Collection.prototype; + var key; + if (proto) { + if (!proto[ITERATOR$1]) { _hide(proto, ITERATOR$1, ArrayValues); } + if (!proto[TO_STRING_TAG]) { _hide(proto, TO_STRING_TAG, NAME); } + _iterators[NAME] = ArrayValues; + if (explicit) { for (key in es6_array_iterator) { if (!proto[key]) { _redefine(proto, key, es6_array_iterator[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 _iterCall = function (iterator, fn, value, entries) { + try { + return entries ? fn(_anObject(value)[0], value[1]) : fn(value); + // 7.4.6 IteratorClose(iterator, completion) + } catch (e) { + var ret = iterator['return']; + if (ret !== undefined) { _anObject(ret.call(iterator)); } + throw e; + } +}; + +// check on default Array iterator + +var ITERATOR$2 = _wks('iterator'); +var ArrayProto$1 = Array.prototype; + +var _isArrayIter = function (it) { + return it !== undefined && (_iterators.Array === it || ArrayProto$1[ITERATOR$2] === it); +}; + +var ITERATOR$3 = _wks('iterator'); + +var core_getIteratorMethod = _core.getIteratorMethod = function (it) { + if (it != undefined) { return it[ITERATOR$3] + || it['@@iterator'] + || _iterators[_classof(it)]; } +}; + +var _forOf = createCommonjsModule(function (module) { +var BREAK = {}; +var RETURN = {}; +var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) { + var iterFn = ITERATOR ? function () { return iterable; } : core_getIteratorMethod(iterable); + var f = _ctx(fn, that, entries ? 2 : 1); + var index = 0; + var 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 = _iterCall(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 SPECIES = _wks('species'); +var _speciesConstructor = function (O, D) { + var C = _anObject(O).constructor; + var S; + return C === undefined || (S = _anObject(C)[SPECIES]) == undefined ? D : _aFunction(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 process$2 = _global.process; +var setTask = _global.setImmediate; +var clearTask = _global.clearImmediate; +var MessageChannel$1 = _global.MessageChannel; +var Dispatch = _global.Dispatch; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var defer; +var channel; +var port; +var run = function () { + var id = +this; + // eslint-disable-next-line no-prototype-builtins + if (queue.hasOwnProperty(id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; +var listener = function (event) { + run.call(event.data); +}; +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!setTask || !clearTask) { + setTask = function setImmediate(fn) { + var arguments$1 = arguments; + + var args = []; + var i = 1; + while (arguments.length > i) { args.push(arguments$1[i++]); } + queue[++counter] = function () { + // eslint-disable-next-line no-new-func + _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(run, id, 1)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(_ctx(run, id, 1)); + }; + // Browsers with MessageChannel, includes WebWorkers + } else if (MessageChannel$1) { + channel = new MessageChannel$1(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = _ctx(port.postMessage, port, 1); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if (_global.addEventListener && typeof postMessage == 'function' && !_global.importScripts) { + defer = function (id) { + _global.postMessage(id + '', '*'); + }; + _global.addEventListener('message', listener, false); + // IE8- + } else if (ONREADYSTATECHANGE in _domCreate('script')) { + defer = function (id) { + _html.appendChild(_domCreate('script'))[ONREADYSTATECHANGE] = function () { + _html.removeChild(this); + run.call(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(_ctx(run, id, 1), 0); + }; + } +} +var _task = { + set: setTask, + clear: clearTask +}; + +var macrotask = _task.set; +var Observer = _global.MutationObserver || _global.WebKitMutationObserver; +var process$3 = _global.process; +var Promise$1 = _global.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, except iOS Safari - https://github.com/zloirock/core-js/issues/339 + } else if (Observer && !(_global.navigator && _global.navigator.standalone)) { + var toggle = true; + var 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, flush); + }; + } + + return function (fn) { + var task = { fn: fn, next: undefined }; + if (last) { last.next = task; } + if (!head) { + head = task; + notify(); + } last = task; + }; +}; + +// 25.4.1.5 NewPromiseCapability(C) + + +function PromiseCapability(C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) { throw TypeError('Bad Promise constructor'); } + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = _aFunction(resolve); + this.reject = _aFunction(reject); +} + +var f$3 = function (C) { + return new PromiseCapability(C); +}; + +var _newPromiseCapability = { + f: f$3 +}; + +var _perform = function (exec) { + try { + return { e: false, v: exec() }; + } catch (e) { + return { e: true, v: e }; + } +}; + +var _promiseResolve = function (C, x) { + _anObject(C); + if (_isObject(x) && x.constructor === C) { return x; } + var promiseCapability = _newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var _redefineAll = function (target, src, safe) { + for (var key in src) { _redefine(target, key, src[key], safe); } + return target; +}; + +var SPECIES$1 = _wks('species'); + +var _setSpecies = function (KEY) { + var C = _global[KEY]; + if (_descriptors && C && !C[SPECIES$1]) { _objectDp.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; }; + // eslint-disable-next-line no-throw-literal + +} catch (e) { /* empty */ } + +var _iterDetect = function (exec, skipClosing) { + if (!skipClosing && !SAFE_CLOSING) { return false; } + var safe = false; + try { + var arr = [7]; + var 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 task = _task.set; +var microtask = _microtask(); + + + +var PROMISE = 'Promise'; +var TypeError$1 = _global.TypeError; +var process$1 = _global.process; +var $Promise = _global[PROMISE]; +var isNode = _classof(process$1) == 'process'; +var empty = function () { /* empty */ }; +var Internal; +var newGenericPromiseCapability; +var OwnPromiseCapability; +var Wrapper; +var newPromiseCapability = newGenericPromiseCapability = _newPromiseCapability.f; + +var USE_NATIVE = !!function () { + try { + // correct subclassing with @@species support + var promise = $Promise.resolve(1); + var 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 isThenable = function (it) { + var then; + return _isObject(it) && typeof (then = it.then) == 'function' ? then : false; +}; +var notify = function (promise, isReject) { + if (promise._n) { return; } + promise._n = true; + var chain = promise._c; + microtask(function () { + var value = promise._v; + var ok = promise._s == 1; + var i = 0; + var run = function (reaction) { + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var 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, function () { + var value = promise._v; + var unhandled = isUnhandled(promise); + var result, handler, console; + if (unhandled) { + result = _perform(function () { + if (isNode) { + process$1.emit('unhandledRejection', value, promise); + } else if (handler = _global.onunhandledrejection) { + handler({ promise: promise, reason: value }); + } else if ((console = _global.console) && console.error) { + console.error('Unhandled promise rejection', value); + } + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + promise._h = isNode || isUnhandled(promise) ? 2 : 1; + } promise._a = undefined; + if (unhandled && result.e) { throw result.v; } + }); +}; +var isUnhandled = function (promise) { + return promise._h !== 1 && (promise._a || promise._c).length === 0; +}; +var onHandleUnhandled = function (promise) { + task.call(_global, function () { + var handler; + if (isNode) { + process$1.emit('rejectionHandled', promise); + } else if (handler = _global.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(promise, true); +}; +var $resolve = function (value) { + var promise = this; + var 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($resolve, wrapper, 1), _ctx($reject, wrapper, 1)); + } catch (e) { + $reject.call(wrapper, e); + } + }); + } else { + promise._v = value; + promise._s = 1; + notify(promise, false); + } + } catch (e) { + $reject.call({ _w: promise, _d: false }, e); // wrap + } +}; + +// constructor polyfill +if (!USE_NATIVE) { + // 25.4.3.1 Promise(executor) + $Promise = function Promise(executor) { + _anInstance(this, $Promise, PROMISE, '_h'); + _aFunction(executor); + Internal.call(this); + try { + executor(_ctx($resolve, this, 1), _ctx($reject, this, 1)); + } catch (err) { + $reject.call(this, err); + } + }; + // eslint-disable-next-line no-unused-vars + 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(this, false); } + return reaction.promise; + }, + // 25.4.5.1 Promise.prototype.catch(onRejected) + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + OwnPromiseCapability = function () { + var promise = new Internal(); + this.promise = promise; + this.resolve = _ctx($resolve, promise, 1); + this.reject = _ctx($reject, promise, 1); + }; + _newPromiseCapability.f = newPromiseCapability = function (C) { + return C === $Promise || C === Wrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; +} + +_export(_export.G + _export.W + _export.F * !USE_NATIVE, { Promise: $Promise }); +_setToStringTag($Promise, PROMISE); +_setSpecies(PROMISE); +Wrapper = _core[PROMISE]; + +// statics +_export(_export.S + _export.F * !USE_NATIVE, PROMISE, { + // 25.4.4.5 Promise.reject(r) + reject: function reject(r) { + var capability = newPromiseCapability(this); + var $$reject = capability.reject; + $$reject(r); + return capability.promise; + } +}); +_export(_export.S + _export.F * (_library || !USE_NATIVE), PROMISE, { + // 25.4.4.6 Promise.resolve(x) + resolve: function resolve(x) { + return _promiseResolve(_library && this === Wrapper ? $Promise : this, x); + } +}); +_export(_export.S + _export.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; + var capability = newPromiseCapability(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = _perform(function () { + var values = []; + var index = 0; + var remaining = 1; + _forOf(iterable, false, function (promise) { + var $index = index++; + var 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 (result.e) { reject(result.v); } + return capability.promise; + }, + // 25.4.4.4 Promise.race(iterable) + race: function race(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var reject = capability.reject; + var result = _perform(function () { + _forOf(iterable, false, function (promise) { + C.resolve(promise).then(capability.resolve, reject); + }); + }); + if (result.e) { reject(result.v); } + 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 */ + + +/** + * 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 */ + + +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 () { + 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. + */ + +/* + * 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. + */ + +setNativeConsole(); + +var subversion = {"framework":"0.24.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. + */ + +function getHookKey (componentId, type, hookName) { + return (type + "@" + hookName + "#" + componentId) +} + +/** + * 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 = String(instanceId); + this.lastCallbackId = 0; + this.callbacks = {}; + this.hooks = {}; +}; +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]; + delete this.callbacks[callbackId]; + return callback +}; +CallbackManager.prototype.registerHook = function registerHook (componentId, type, hookName, hookFunction) { + // TODO: validate arguments + var key = getHookKey(componentId, type, hookName); + if (this.hooks[key]) { + console.warn(("[JS Framework] Override an existing component hook \"" + key + "\".")); + } + this.hooks[key] = hookFunction; +}; +CallbackManager.prototype.triggerHook = function triggerHook (componentId, type, hookName, args) { + // TODO: validate arguments + var key = getHookKey(componentId, type, hookName); + var hookFunction = this.hooks[key]; + if (typeof hookFunction !== 'function') { + console.error(("[JS Framework] Invalid hook function type (" + (typeof hookFunction) + ") on \"" + key + "\".")); + return null + } + var result = null; + try { + result = hookFunction.apply(null, args || []); + } + catch (e) { + console.error(("[JS Framework] Failed to execute the hook function on \"" + key + "\".")); + } + return result +}; +CallbackManager.prototype.consume = function consume (callbackId, data, ifKeepAlive) { + var callback = this.callbacks[callbackId]; + if (typeof ifKeepAlive === 'undefined' || ifKeepAlive === false) { + delete this.callbacks[callbackId]; + } + if (typeof callback === 'function') { + return callback(data) + } + return new Error(("invalid callback id \"" + callbackId + "\"")) +}; +CallbackManager.prototype.close = function close () { + this.callbacks = {}; + this.hooks = {}; +}; + +/* + * 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. + */ + +/** + * Get a unique id. + */ +var nextNodeRef = 1; +function uniqueId () { + return (nextNodeRef++).toString() +} + +function typof (v) { + var s = Object.prototype.toString.call(v); + return s.substring(8, s.length - 1) +} + +function bufferToBase64 (buffer) { + if (typeof btoa !== 'function') { + return '' + } + var string = Array.prototype.map.call( + new Uint8Array(buffer), + function (code) { return String.fromCharCode(code); } + ).join(''); + return btoa(string) // eslint-disable-line no-undef +} + + + +/** + * Detect if the param is falsy or empty + * @param {any} any + */ +function isEmpty (any) { + if (!any || typeof any !== 'object') { + return true + } + + for (var key in any) { + if (Object.prototype.hasOwnProperty.call(any, key)) { + return false + } + } + return true +} + +/* + * 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 +} + +/** + * 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(); + if (doc && doc.taskCenter && typeof doc.taskCenter.send === 'function') { + doc.taskCenter.send('dom', { action: 'createBody' }, [body]); + } +} + +/** + * 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. + */ + +var Node = 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 destroy () { + 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$2; + +function setElement (El) { + Element$2 = El; +} + +/** + * A map which stores all type of elements. + * @type {Object} + */ +var registeredElements = {}; + +/** + * 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 WeexElement = (function (Element) { + function WeexElement () { + Element.apply(this, arguments); + }if ( Element ) WeexElement.__proto__ = Element; + WeexElement.prototype = Object.create( Element && Element.prototype ); + WeexElement.prototype.constructor = WeexElement; + + + + return WeexElement; + }(Element$2)); + + // Add methods to prototype. + methods.forEach(function (methodName) { + WeexElement.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. + registeredElements[type] = WeexElement; +} + + + +function getWeexElement (type) { + return registeredElements[type] +} + + + +/** + * 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. + */ + +var DEFAULT_TAG_NAME = 'div'; +var BUBBLE_EVENTS = [ + 'click', 'longpress', 'touchstart', 'touchmove', 'touchend', + 'panstart', 'panmove', 'panend', 'horizontalpan', 'verticalpan', 'swipe' +]; + +function registerNode (docId, node) { + var doc = getDoc(docId); + doc.nodeMap[node.nodeId] = node; +} + +var Element = (function (Node$$1) { + function Element (type, props, isExtended) { + if ( type === void 0 ) type = DEFAULT_TAG_NAME; + + Node$$1.call(this); + + var WeexElement = getWeexElement(type); + if (WeexElement && !isExtended) { + return new WeexElement(type, props, true) + } + + 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.classList = props.classList || []; + this.event = {}; + this.children = []; + this.pureChildren = []; + } + + if ( Node$$1 ) Element.__proto__ = Node$$1; + Element.prototype = Object.create( Node$$1 && Node$$1.prototype ); + Element.prototype.constructor = Element; + + /** + * Append a child node. + * @param {object} node + * @return {undefined | number} the signal sent by native + */ + Element.prototype.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 + */ + Element.prototype.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 + */ + Element.prototype.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 + */ + Element.prototype.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. + */ + Element.prototype.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 + */ + Element.prototype.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 batched attributes. + * @param {object} batchedAttrs + * @param {boolean} silent + */ + Element.prototype.setAttrs = function setAttrs (batchedAttrs, silent) { + var this$1 = this; + + if (isEmpty(batchedAttrs)) { return } + var mutations = {}; + for (var key in batchedAttrs) { + if (this$1.attr[key] !== batchedAttrs[key]) { + this$1.attr[key] = batchedAttrs[key]; + mutations[key] = batchedAttrs[key]; + } + } + if (!isEmpty(mutations)) { + var taskCenter = getTaskCenter(this.docId); + if (!silent && taskCenter) { + taskCenter.send( + 'dom', + { action: 'updateAttrs' }, + [this.ref, mutations] + ); + } + } + }; + + /** + * Set a style property, and decide whether the task should be send to native. + * @param {string} key + * @param {string | number} value + * @param {boolean} silent + */ + Element.prototype.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 batched style properties. + * @param {object} batchedStyles + * @param {boolean} silent + */ + Element.prototype.setStyles = function setStyles (batchedStyles, silent) { + var this$1 = this; + + if (isEmpty(batchedStyles)) { return } + var mutations = {}; + for (var key in batchedStyles) { + if (this$1.style[key] !== batchedStyles[key]) { + this$1.style[key] = batchedStyles[key]; + mutations[key] = batchedStyles[key]; + } + } + if (!isEmpty(mutations)) { + var taskCenter = getTaskCenter(this.docId); + if (!silent && taskCenter) { + taskCenter.send( + 'dom', + { action: 'updateStyle' }, + [this.ref, mutations] + ); + } + } + }; + + /** + * TODO: deprecated + * Set style properties from class. + * @param {object} classStyle + */ + Element.prototype.setClassStyle = function setClassStyle (classStyle) { + var this$1 = this; + + // reset previous class style to empty string + for (var key in this$1.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()] + ); + } + }; + + /** + * Set class list. + * @param {array} classList + */ + // setClassList (classList) { + // const classes = typeof classList === 'string' + // ? classList.split(/\s+/) + //
<TRUNCATED>
