You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@weex.apache.org by da...@apache.org on 2017/08/17 03:59:55 UTC
[38/43] incubator-weex git commit: * [build] build
weex-js-framework@0.21.9
http://git-wip-us.apache.org/repos/asf/incubator-weex/blob/e9f9df58/packages/weex-html5/index.js
----------------------------------------------------------------------
diff --git a/packages/weex-html5/index.js b/packages/weex-html5/index.js
new file mode 100644
index 0000000..a83ffe3
--- /dev/null
+++ b/packages/weex-html5/index.js
@@ -0,0 +1,38779 @@
+(this.nativeLog || function(s) {console.log(s)})('START WEEX HTML5: 0.5.0, Build 2017-08-14 14:07.');
+;(this.getJSFMVersion = function(){return "0.21.9"});
+var global = this, process = { env: {} };var setTimeout = global.setTimeout;
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global.Weex = factory());
+}(this, (function () { 'use strict';
+
+function __$styleInject(css, returnValue) {
+ if (typeof document === 'undefined') {
+ return returnValue;
+ }
+ css = css || '';
+ var head = document.head || document.getElementsByTagName('head')[0];
+ var style = document.createElement('style');
+ style.type = 'text/css';
+ head.appendChild(style);
+
+ if (style.styleSheet){
+ style.styleSheet.cssText = css;
+ } else {
+ style.appendChild(document.createTextNode(css));
+ }
+ return returnValue;
+}
+__$styleInject("* {\n margin: 0;\n padding: 0;\n text-size-adjust: none;\n}\n\nul, ol {\n list-style: none;\n}\n\n.weex-container {\n box-sizing: border-box;\n display: -webkit-box;\n display: -webkit-flex;\n display: flex;\n -webkit-box-orient: vertical;\n -webkit-flex-direction: column;\n flex-direction: column;\n -webkit-flex-shrink: 0;\n flex-shrink: 0;\n -webkit-flex-grow: 0;\n flex-grow: 0;\n -webkit-flex-basis: auto;\n flex-basis: auto;\n align-items: stretch;\n box-align: stretch;\n align-content: flex-start;\n position: relative;\n border: 0 solid black;\n margin: 0;\n padding: 0;\n min-width: 0;\n}\n\n.weex-element {\n box-sizing: border-box;\n position: relative;\n -webkit-flex-shrink: 0;\n flex-shrink: 0;\n -webkit-flex-grow: 0;\n flex-grow: 0;\n -webkit-flex-basis: auto;\n flex-basis: auto;\n border: 0 solid black;\n margin: 0;\n padding: 0;\n min-width: 0;\n}\n",undefined);
+
+var subversion = {"browser":"0.5.0","framework":"0.21.9","vue-render":"0.12.3","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
+ // 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.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;
+// typeof document.createElement is 'object' in old IE
+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$1 = _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$1
+};
+
+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;
+var hide = _hide;
+var has = _has;
+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 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;
+ var IS_GLOBAL = type & $export$1.G;
+ var IS_STATIC = type & $export$1.S;
+ var IS_PROTO = type & $export$1.P;
+ var IS_BIND = type & $export$1.B;
+ var target = IS_GLOBAL ? global$1 : IS_STATIC ? global$1[name] || (global$1[name] = {}) : (global$1[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$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;
+// 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 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 _toAbsoluteIndex = 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 toAbsoluteIndex = _toAbsoluteIndex;
+var _arrayIncludes = function (IS_INCLUDES) {
+ return function ($this, el, fromIndex) {
+ var O = toIObject$1($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 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);
+ var i = 0;
+ var result = [];
+ var 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$2 = Object.getOwnPropertySymbols;
+
+var _objectGops = {
+ f: f$2
+};
+
+var f$3 = {}.propertyIsEnumerable;
+
+var _objectPie = {
+ f: f$3
+};
+
+// 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 = {};
+ 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 = gOPS.f;
+ var isEnum = pIE.f;
+ while (aLen > index) {
+ var S = IObject(arguments$1[index++]);
+ var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(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)
+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');
+var uid = _uid;
+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 cof$1 = _cof;
+var TAG = _wks('toStringTag');
+// ES3 wrong here
+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));
+ var i = toInteger$2(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 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);
+ var length = keys.length;
+ var i = 0;
+ var P;
+ while (length > i) { dP$2.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 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');
+ var i = enumBugKeys$1.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$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()); // 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 = $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 = getPrototypeOf($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$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;
+ 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 };
+};
+
+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;
+ var kind = this._k;
+ var 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 getKeys$2 = _objectKeys;
+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;
+
+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 = getKeys$2(DOMIterables), i = 0; i < collections.length; i++) {
+ var NAME = collections[i];
+ var explicit = DOMIterables[NAME];
+ var Collection = global$3[NAME];
+ var proto = Collection && Collection.prototype;
+ var 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;
+ if (explicit) { 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;
+var call = _iterCall;
+var isArrayIter = _isArrayIter;
+var anObject = _anObject;
+var toLength = _toLength;
+var getIterFn = core_getIteratorMethod;
+var BREAK = {};
+var RETURN = {};
+var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
+ var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(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 = 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;
+ var 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 Dispatch = global$5.Dispatch;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var defer;
+var channel;
+var port;
+var run$1 = 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$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 = [];
+ 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$2(run$1, id, 1));
+ };
+ // Sphere (JS game engine) Dispatch API
+ } else if (Dispatch && Dispatch.now) {
+ defer = function (id) {
+ Dispatch.now(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;
+ 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$6, 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)
+var aFunction$3 = _aFunction;
+
+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$3(resolve);
+ this.reject = aFunction$3(reject);
+}
+
+var f$4 = function (C) {
+ return new PromiseCapability(C);
+};
+
+var _newPromiseCapability = {
+ f: f$4
+};
+
+var _perform = function (exec) {
+ try {
+ return { e: false, v: exec() };
+ } catch (e) {
+ return { e: true, v: e };
+ }
+};
+
+var newPromiseCapability$1 = _newPromiseCapability;
+
+var _promiseResolve = function (C, x) {
+ var promiseCapability = newPromiseCapability$1.f(C);
+ var resolve = promiseCapability.resolve;
+ resolve(x);
+ return promiseCapability.promise;
+};
+
+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; };
+ // eslint-disable-next-line no-throw-literal
+ 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];
+ 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 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 newPromiseCapabilityModule = _newPromiseCapability;
+var perform = _perform;
+var promiseResolve = _promiseResolve;
+var PROMISE = 'Promise';
+var TypeError$1 = global$4.TypeError;
+var process$1 = global$4.process;
+var $Promise = global$4[PROMISE];
+var isNode = classof$1(process$1) == 'process';
+var empty = function () { /* empty */ };
+var Internal;
+var newGenericPromiseCapability;
+var OwnPromiseCapability;
+var Wrapper;
+var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.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 sameConstructor = LIBRARY$1 ? function (a, b) {
+ // with library wrapper special case
+ return a === b || a === $Promise && b === Wrapper;
+} : function (a, b) {
+ return a === b;
+};
+var isThenable = function (it) {
+ var then;
+ return isObject$3(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var notify$1 = 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$4, 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$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 (unhandled && result.e) { throw result.v; }
+ });
+};
+var isUnhandled = function (promise) {
+ if (promise._h == 1) { return false; }
+ var chain = promise._a || promise._c;
+ var i = 0;
+ var 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;
+ 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$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);
+ }
+ };
+ // 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$1(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$1($resolve, promise, 1);
+ this.reject = ctx$1($reject, promise, 1);
+ };
+ newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+ return sameConstructor($Promise, C)
+ ? new OwnPromiseCapability(C)
+ : newGenericPromiseCapability(C);
+ };
+}
+
+$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);
+ var $$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; }
+ return promiseResolve(this, x);
+ }
+});
+$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;
+ 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 */
+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
+
+/**
+ * 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
+}
+
+function base64ToBuffer (base64) {
+ if (typeof atob !== 'function') {
+ return new ArrayBuffer(0)
+ }
+ var string = atob(base64); // eslint-disable-line no-undef
+ var array = new Uint8Array(string.length);
+ Array.prototype.forEach.call(string, function (ch, i) {
+ array[i] = ch.charCodeAt(0);
+ });
+ return array.buffer
+}
+
+/**
+ * Normalize a primitive value.
+ * @param {any} v
+ * @return {primitive}
+ */
+function normalizePrimitive (v) {
+ var type = typof(v);
+
+ switch (type) {
+ case 'Undefined':
+ case 'Null':
+ return ''
+
+ case 'RegExp':
+ return v.toString()
+ case 'Date':
+ return v.toISOString()
+
+ case 'Number':
+ case 'String':
+ case 'Boolean':
+ case 'Array':
+ case 'Object':
+ return v
+
+ case 'ArrayBuffer':
+ return {
+ '@type': 'binary',
+ dataType: type,
+ base64: bufferToBase64(v)
+ }
+
+ case 'Int8Array':
+ case 'Uint8Array':
+ case 'Uint8ClampedArray':
+ case 'Int16Array':
+ case 'Uint16Array':
+ case 'Int32Array':
+ case 'Uint32Array':
+ case 'Float32Array':
+ case 'Float64Array':
+ return {
+ '@type': 'binary',
+ dataType: type,
+ base64: bufferToBase64(v.buffer)
+ }
+
+ default:
+ return JSON.stringify(v)
+ }
+}
+
+function decodePrimitive (data) {
+ if (typof(data) === 'Object') {
+ // decode base64 into binary
+ if (data['@type'] && data['@type'] === 'binary') {
+ return base64ToBuffer(data.base64 || '')
+ }
+
+ var realData = {};
+ for (var key in data) {
+ realData[key] = decodePrimitive(data[key]);
+ }
+ return realData
+ }
+ if (typof(data) === 'Array') {
+ return data.map(decodePrimitive)
+ }
+ return data
+}
+
+/*
+ * 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];
+ delete this.callbacks[callbackId];
+ return callback
+};
+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(decodePrimitive(data))
+ }
+ return new Error(("invalid callback id \"" + callbackId + "\""))
+};
+CallbackManager.prototype.close = function close () {
+ this.callbacks = {};
+};
+
+/*
+ * 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();
+ 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.
+ */
+
+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.
+ */
+
+// match the binding delimiter
+var delimiterRE = /\[\[((?:.|\n)+?)\]\]/g;
+
+function generateBinding (text) {
+ if (typof(text) === 'String') {
+ return { '@binding': text }
+ }
+ return text
+}
+
+function parseString (string) {
+ var tokens = [];
+ var lastIndex = delimiterRE.lastIndex = 0;
+ var match, index;
+ while ((match = delimiterRE.exec(string))) {
+ index = match.index;
+ if (index > lastIndex) {
+ tokens.push(string.slice(lastIndex, index));
+ }
+ var binding = generateBinding(match[1].trim());
+ tokens.push(binding);
+ lastIndex = index + match[0].length;
+ }
+ if (lastIndex < string.length) {
+ tokens.push(string.slice(lastIndex));
+ }
+ if (tokens.length === 1) {
+ return tokens[0]
+ }
+ return tokens
+}
+
+function filterDirective (value) {
+ if (typof(value) === 'String' && delimiterRE.test(value)) {
+ return parseString(value)
+ }
+ if (typof(value) === 'Object') {
+ var realData = {};
+ for (var key in value) {
+ realData[key] = filterDirective(value[key]);
+ }
+ return realData
+ }
+ if (typof(value) === 'Array') {
+ return value.map(filterDirective)
+ }
+ 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.
+ */
+
+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(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 = [];
+ }
+
+ 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.pureChild
<TRUNCATED>