You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@weex.apache.org by ac...@apache.org on 2017/09/21 13:38:47 UTC
[20/50] [abbrv] incubator-weex git commit: lifecycle event
http://git-wip-us.apache.org/repos/asf/incubator-weex/blob/c4662c64/pre-build/native-bundle-main.js
----------------------------------------------------------------------
diff --git a/pre-build/native-bundle-main.js b/pre-build/native-bundle-main.js
index a8f2dc5..0dbf526 100644
--- a/pre-build/native-bundle-main.js
+++ b/pre-build/native-bundle-main.js
@@ -1,5 +1,6 @@
-(this.nativeLog || function(s) {console.log(s)})('START JS FRAMEWORK 0.22.0-beta.2, Build 2017-09-15 15:41.');
-(this.getJSFMVersion = function(){return "0.22.0-beta.2"});var global = this, process = { env: {} };var setTimeout = global.setTimeout;
+(this.nativeLog || function(s) {console.log(s)})('START JS FRAMEWORK 0.21.11, Build 2017-09-19 15:53.');
+;(this.getJSFMVersion = function(){return "0.21.11"});
+var global = this, process = { env: {} };var setTimeout = global.setTimeout;
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
@@ -7,6 +8,8 @@
(factory());
}(this, (function () { 'use strict';
+var subversion = {"browser":"0.5.0","framework":"0.21.11","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
@@ -25,115 +28,94 @@
* specific language governing permissions and limitations
* under the License.
*/
-var config = {};
-
-var instanceMap = {};
-
-function init$1 (cfg) {
- config.Document = cfg.Document;
- config.Element = cfg.Element;
- config.Comment = cfg.Comment;
- config.sendTasks = cfg.sendTasks;
-}
-
-function createInstance (id, code, options, data, serviceObjects) {
- if ( options === void 0 ) options = {};
- if ( data === void 0 ) data = {};
- if ( serviceObjects === void 0 ) serviceObjects = {};
-
- var document = new config.Document(id, options.bundleUrl);
- var callbacks = {};
- var instance = { id: id, data: data, document: document, callbacks: callbacks };
- var lastCallbackId = 0;
- document.addCallback = function (func) {
- lastCallbackId++;
- callbacks[lastCallbackId] = func;
- return lastCallbackId
- };
- document.handleCallback = function (funcId, data, ifLast) {
- var callback = callbacks[funcId];
- if (ifLast) {
- delete callbacks[funcId];
- }
- return callback(data)
- };
- instanceMap[id] = instance;
+/* eslint-disable */
- var globalObjects = Object.assign({
- Document: config.Document,
- Element: config.Element,
- Comment: config.Comment,
- sendTasks: function (tasks) { return config.sendTasks(id, tasks, -1); },
- options: options,
- document: document
- }, serviceObjects);
+// Production steps of ECMA-262, Edition 6, 22.1.2.1
+// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
- var globalKeys = [];
- var globalValues = [];
- for (var key in globalObjects) {
- globalKeys.push(key);
- globalValues.push(globalObjects[key]);
- }
- globalKeys.push(code);
+/* 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);
+ };
- var result = new (Function.prototype.bind.apply( Function, [ null ].concat( globalKeys) ));
- result.apply(void 0, globalValues);
+ // 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;
- config.sendTasks(id, [{ module: 'dom', method: 'createFinish', args: [] }], -1);
+ // 2. Let items be ToObject(arrayLike).
+ var items = Object(arrayLike);
- return instance
-}
+ // 3. ReturnIfAbrupt(items).
+ if (arrayLike == null) {
+ throw new TypeError('Array.from requires an array-like object - not null or undefined');
+ }
-function destroyInstance (id) {
- delete instanceMap[id];
-}
+ // 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');
+ }
-function getRoot (id) {
- return instanceMap[id].document.body.toJSON()
-}
+ // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ if (arguments.length > 2) {
+ T = arguments[2];
+ }
+ }
-function receiveTasks (id, tasks) {
- var jsHandlers = {
- fireEvent: function (id, ref, type, data, domChanges) {
- var ref$1 = instanceMap[id];
- var document = ref$1.document;
- var el = document.getRef(ref);
- return document.fireEvent(el, type, data, domChanges)
- },
+ // 10. Let lenValue be Get(items, "length").
+ // 11. Let len be ToLength(lenValue).
+ var len = toLength(items.length);
- callback: function (id, funcId, data, ifLast) {
- var ref = instanceMap[id];
- var document = ref.document;
- return document.handleCallback(funcId, data, ifLast)
- }
- };
+ // 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);
- var ref = instanceMap[id] || {};
- var document = ref.document;
- if (document && Array.isArray(tasks)) {
- var results = [];
- tasks.forEach(function (task) {
- var handler = jsHandlers[task.method];
- var args = [].concat( task.args );
- if (typeof handler === 'function') {
- args.unshift(id);
- results.push(handler.apply(void 0, args));
+ // 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;
}
- });
- return results
- }
+ // 18. Let putStatus be Put(A, "length", len, true).
+ A.length = len;
+ // 20. Return A.
+ return A;
+ };
+ }());
}
-
-var Vanilla = Object.freeze({
- init: init$1,
- createInstance: createInstance,
- destroyInstance: destroyInstance,
- getRoot: getRoot,
- receiveTasks: receiveTasks
-});
-
var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -146,13083 +128,12049 @@ function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
-var factory = createCommonjsModule(function (module) {
-'use strict';
-
-module.exports = function weexFactory (exports, renderer) {
+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
+});
-// these helpers produces better vm code in JS engines due to their
-// explicitness and function inlining
-function isUndef (v) {
- return v === undefined || v === null
-}
+var _isObject = function (it) {
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
-function isDef (v) {
- return v !== undefined && v !== null
-}
+var isObject = _isObject;
+var _anObject = function (it) {
+ if (!isObject(it)) { throw TypeError(it + ' is not an object!'); }
+ return it;
+};
-function isTrue (v) {
- return v === true
-}
+var _fails = function (exec) {
+ try {
+ return !!exec();
+ } catch (e) {
+ return true;
+ }
+};
-function isFalse (v) {
- return v === false
-}
+// Thank's IE8 for his funny defineProperty
+var _descriptors = !_fails(function () {
+ return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
+});
-/**
- * Check if value is primitive
- */
-function isPrimitive (value) {
- return (
- typeof value === 'string' ||
- typeof value === 'number' ||
- typeof value === 'boolean'
- )
-}
+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) : {};
+};
-/**
- * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject (obj) {
- return obj !== null && typeof obj === 'object'
-}
+var _ie8DomDefine = !_descriptors && !_fails(function () {
+ return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;
+});
-var _toString = Object.prototype.toString;
+// 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");
+};
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject (obj) {
- return _toString.call(obj) === '[object Object]'
-}
+var anObject = _anObject;
+var IE8_DOM_DEFINE = _ie8DomDefine;
+var toPrimitive = _toPrimitive;
+var dP$1 = Object.defineProperty;
-function isRegExp (v) {
- return _toString.call(v) === '[object RegExp]'
-}
+var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if (IE8_DOM_DEFINE) { try {
+ return dP$1(O, P, Attributes);
+ } catch (e) { /* empty */ } }
+ if ('get' in Attributes || 'set' in Attributes) { throw TypeError('Accessors not supported!'); }
+ if ('value' in Attributes) { O[P] = Attributes.value; }
+ return O;
+};
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex (val) {
- var n = parseFloat(val);
- return n >= 0 && Math.floor(n) === n && isFinite(val)
-}
-
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString (val) {
- return val == null
- ? ''
- : typeof val === 'object'
- ? JSON.stringify(val, null, 2)
- : String(val)
-}
-
-/**
- * Convert a input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber (val) {
- var n = parseFloat(val);
- return isNaN(n) ? val : n
-}
+var _objectDp = {
+ f: f
+};
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap (
- str,
- expectsLowerCase
-) {
- var map = Object.create(null);
- var list = str.split(',');
- for (var i = 0; i < list.length; i++) {
- map[list[i]] = true;
- }
- return expectsLowerCase
- ? function (val) { return map[val.toLowerCase()]; }
- : function (val) { return map[val]; }
-}
+var _propertyDesc = function (bitmap, value) {
+ return {
+ enumerable: !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable: !(bitmap & 4),
+ value: value
+ };
+};
-/**
- * Check if a tag is a built-in tag.
- */
-var isBuiltInTag = makeMap('slot,component', true);
+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;
+};
-/**
- * Check if a attribute is a reserved attribute.
- */
-var isReservedAttribute = makeMap('key,ref,slot,is');
+var hasOwnProperty = {}.hasOwnProperty;
+var _has = function (it, key) {
+ return hasOwnProperty.call(it, key);
+};
-/**
- * Remove an item from an array
- */
-function remove (arr, item) {
- if (arr.length) {
- var index = arr.indexOf(item);
- if (index > -1) {
- return arr.splice(index, 1)
- }
- }
-}
+var id = 0;
+var px = Math.random();
+var _uid = function (key) {
+ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
-/**
- * Check whether the object has the property.
- */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
- return hasOwnProperty.call(obj, key)
-}
+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);
-/**
- * Create a cached version of a pure function.
- */
-function cached (fn) {
- var cache = Object.create(null);
- return (function cachedFn (str) {
- var hit = cache[str];
- return hit || (cache[str] = fn(str))
- })
-}
+_core.inspectSource = function (it) {
+ return $toString.call(it);
+};
-/**
- * Camelize a hyphen-delimited string.
- */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
- return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+(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);
});
-
-/**
- * Capitalize a string.
- */
-var capitalize = cached(function (str) {
- return str.charAt(0).toUpperCase() + str.slice(1)
});
-/**
- * Hyphenate a camelCase string.
- */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
- return str.replace(hyphenateRE, '-$1').toLowerCase()
-});
+var _aFunction = function (it) {
+ if (typeof it != 'function') { throw TypeError(it + ' is not a function!'); }
+ return it;
+};
-/**
- * Simple bind, faster than native
- */
-function bind (fn, ctx) {
- function boundFn (a) {
- var l = arguments.length;
- return l
- ? l > 1
- ? fn.apply(ctx, arguments)
- : fn.call(ctx, a)
- : fn.call(ctx)
+// 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);
+ };
}
- // record original fn length
- boundFn._length = fn.length;
- return boundFn
-}
+ return function (/* ...args */) {
+ return fn.apply(that, arguments);
+ };
+};
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray (list, start) {
- start = start || 0;
- var i = list.length - start;
- var ret = new Array(i);
- while (i--) {
- ret[i] = list[i + start];
- }
- return ret
-}
+var global$1 = _global;
+var core = _core;
+var hide = _hide;
+var redefine = _redefine;
+var ctx = _ctx;
+var PROTOTYPE = 'prototype';
-/**
- * Mix properties into target object.
- */
-function extend (to, _from) {
- for (var key in _from) {
- to[key] = _from[key];
+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; }
}
- return to
-}
+};
+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;
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject (arr) {
- var res = {};
- for (var i = 0; i < arr.length; i++) {
- if (arr[i]) {
- extend(res, arr[i]);
- }
- }
- return res
-}
+var toString$1 = {}.toString;
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
- */
-function noop (a, b, c) {}
+var _cof = function (it) {
+ return toString$1.call(it).slice(8, -1);
+};
-/**
- * Always return false.
- */
-var no = function (a, b, c) { return false; };
+// 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);
+};
-/**
- * Return same value
- */
-var identity = function (_) { return _; };
+// 7.2.1 RequireObjectCoercible(argument)
+var _defined = function (it) {
+ if (it == undefined) { throw TypeError("Can't call method on " + it); }
+ return it;
+};
-/**
- * Generate a static keys string from compiler modules.
- */
+// 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);
+};
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual (a, b) {
- if (a === b) { return true }
- var isObjectA = isObject(a);
- var isObjectB = isObject(b);
- if (isObjectA && isObjectB) {
- try {
- var isArrayA = Array.isArray(a);
- var isArrayB = Array.isArray(b);
- if (isArrayA && isArrayB) {
- return a.length === b.length && a.every(function (e, i) {
- return looseEqual(e, b[i])
- })
- } else if (!isArrayA && !isArrayB) {
- var keysA = Object.keys(a);
- var keysB = Object.keys(b);
- return keysA.length === keysB.length && keysA.every(function (key) {
- return looseEqual(a[key], b[key])
- })
- } else {
- /* istanbul ignore next */
- return false
- }
- } catch (e) {
- /* istanbul ignore next */
- return false
- }
- } else if (!isObjectA && !isObjectB) {
- return String(a) === String(b)
- } else {
- return false
- }
-}
+// 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
+};
-function looseIndexOf (arr, val) {
- for (var i = 0; i < arr.length; i++) {
- if (looseEqual(arr[i], val)) { return i }
- }
- return -1
-}
+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);
+};
-/**
- * Ensure a function is called only once.
- */
-function once (fn) {
- var called = false;
- return function () {
- if (!called) {
- called = true;
- fn.apply(this, arguments);
- }
- }
-}
+// 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 SSR_ATTR = 'data-server-rendered';
+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 ASSET_TYPES = [
- 'component',
- 'directive',
- 'filter'
-];
+var shared = _shared('keys');
+var uid = _uid;
+var _sharedKey = function (key) {
+ return shared[key] || (shared[key] = uid(key));
+};
-var LIFECYCLE_HOOKS = [
- 'beforeCreate',
- 'created',
- 'beforeMount',
- 'mounted',
- 'beforeUpdate',
- 'updated',
- 'beforeDestroy',
- 'destroyed',
- 'activated',
- 'deactivated'
-];
+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;
+};
-var config = ({
- /**
- * Option merge strategies (used in core/util/options)
- */
- optionMergeStrategies: Object.create(null),
+// IE 8- don't enum bug keys
+var _enumBugKeys = (
+ 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+).split(',');
- /**
- * Whether to suppress warnings.
- */
- silent: false,
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys = _objectKeysInternal;
+var enumBugKeys = _enumBugKeys;
- /**
- * Show production mode tip message on boot?
- */
- productionTip: "development" !== 'production',
+var _objectKeys = Object.keys || function keys(O) {
+ return $keys(O, enumBugKeys);
+};
- /**
- * Whether to enable devtools
- */
- devtools: "development" !== 'production',
+var f$1 = Object.getOwnPropertySymbols;
- /**
- * Whether to record perf
- */
- performance: false,
+var _objectGops = {
+ f: f$1
+};
- /**
- * Error handler for watcher errors
- */
- errorHandler: null,
+var f$2 = {}.propertyIsEnumerable;
- /**
- * Warn handler for watcher warns
- */
- warnHandler: null,
+var _objectPie = {
+ f: f$2
+};
- /**
- * Ignore certain custom elements
- */
- ignoredElements: [],
+// 7.1.13 ToObject(argument)
+var defined$1 = _defined;
+var _toObject = function (it) {
+ return Object(defined$1(it));
+};
- /**
- * Custom user key aliases for v-on
- */
- keyCodes: Object.create(null),
+// 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;
- /**
- * Check if a tag is reserved so that it cannot be registered as a
- * component. This is platform-dependent and may be overwritten.
- */
- isReservedTag: no,
-
- /**
- * Check if an attribute is reserved so that it cannot be used as a component
- * prop. This is platform-dependent and may be overwritten.
- */
- isReservedAttr: no,
-
- /**
- * Check if a tag is an unknown element.
- * Platform-dependent.
- */
- isUnknownElement: no,
+// 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;
- /**
- * Get the namespace of an element
- */
- getTagNamespace: noop,
+// 19.1.3.1 Object.assign(target, source)
+var $export = _export;
- /**
- * Parse the real tag name for the specific platform.
- */
- parsePlatformTagName: identity,
+$export($export.S + $export.F, 'Object', { assign: _objectAssign });
- /**
- * Check if an attribute must be bound using property, e.g. value
- * Platform-dependent.
- */
- mustUseProp: no,
+/*
+ * 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.
+ */
- /**
- * Exposed for legacy reasons
- */
- _lifecycleHooks: LIFECYCLE_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.
+ */
-/* */
+/* eslint-disable */
-var emptyObject = Object.freeze({});
+// https://gist.github.com/WebReflection/5593554
-/**
- * Check if a string starts with $ or _
- */
-function isReserved (str) {
- var c = (str + '').charCodeAt(0);
- return c === 0x24 || c === 0x5F
+/* 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__'));
}
-/**
- * Define a property.
+/*
+ * 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 def (obj, key, val, enumerable) {
- Object.defineProperty(obj, key, {
- value: val,
- enumerable: !!enumerable,
- writable: true,
- configurable: true
- });
-}
-/**
- * Parse simple path.
- */
-var bailRE = /[^\w.$]/;
-function parsePath (path) {
- if (bailRE.test(path)) {
- return
- }
- var segments = path.split('.');
- return function (obj) {
- for (var i = 0; i < segments.length; i++) {
- if (!obj) { return }
- obj = obj[segments[i]];
- }
- return obj
- }
-}
+// 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;
-var warn = noop;
-var tip = noop;
-var formatComponentName = (null); // work around flow check
+/* istanbul ignore next */
+if (WXEnvironment$1 && WXEnvironment$1.platform === 'iOS') {
+ commonjsGlobal.Promise = undefined;
+}
-{
- var hasConsole = typeof console !== 'undefined';
- var classifyRE = /(?:^|[-_])(\w)/g;
- var classify = function (str) { return str
- .replace(classifyRE, function (c) { return c.toUpperCase(); })
- .replace(/[-_]/g, ''); };
+var _wks = createCommonjsModule(function (module) {
+var store = _shared('wks');
+var uid = _uid;
+var Symbol = _global.Symbol;
+var USE_SYMBOL = typeof Symbol == 'function';
- warn = function (msg, vm) {
- var trace = vm ? generateComponentTrace(vm) : '';
+var $exports = module.exports = function (name) {
+ return store[name] || (store[name] =
+ USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
+};
- if (config.warnHandler) {
- config.warnHandler.call(null, msg, vm, trace);
- } else if (hasConsole && (!config.silent)) {
- console.error(("[Vue warn]: " + msg + trace));
- }
- };
+$exports.store = store;
+});
- tip = function (msg, vm) {
- if (hasConsole && (!config.silent)) {
- console.warn("[Vue tip]: " + msg + (
- vm ? generateComponentTrace(vm) : ''
- ));
- }
- };
+// 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';
- formatComponentName = function (vm, includeFile) {
- if (vm.$root === vm) {
- return '<Root>'
- }
- var name = typeof vm === 'string'
- ? vm
- : typeof vm === 'function' && vm.options
- ? vm.options.name
- : vm._isVue
- ? vm.$options.name || vm.$options._componentTag
- : vm.name;
-
- var file = vm._isVue && vm.$options.__file;
- if (!name && file) {
- var match = file.match(/([^/\\]+)\.vue$/);
- name = match && match[1];
- }
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+ try {
+ return it[key];
+ } catch (e) { /* empty */ }
+};
- return (
- (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
- (file && includeFile !== false ? (" at " + file) : '')
- )
- };
+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;
+};
- var repeat = function (str, n) {
- var res = '';
- while (n) {
- if (n % 2 === 1) { res += str; }
- if (n > 1) { str += str; }
- n >>= 1;
- }
- return res
- };
+// 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 generateComponentTrace = function (vm) {
- if (vm._isVue && vm.$parent) {
- var tree = [];
- var currentRecursiveSequence = 0;
- while (vm) {
- if (tree.length > 0) {
- var last = tree[tree.length - 1];
- if (last.constructor === vm.constructor) {
- currentRecursiveSequence++;
- vm = vm.$parent;
- continue
- } else if (currentRecursiveSequence > 0) {
- tree[tree.length - 1] = [last, currentRecursiveSequence];
- currentRecursiveSequence = 0;
- }
- }
- tree.push(vm);
- vm = vm.$parent;
- }
- return '\n\nfound in\n\n' + tree
- .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
- ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
- : formatComponentName(vm))); })
- .join('\n')
- } else {
- return ("\n\n(found in " + (formatComponentName(vm)) + ")")
- }
+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;
-function handleError (err, vm, info) {
- if (config.errorHandler) {
- config.errorHandler.call(null, err, vm, info);
- } else {
- {
- warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
- }
- /* istanbul ignore else */
- if (inBrowser && typeof console !== 'undefined') {
- console.error(err);
- } else {
- throw err
- }
- }
-}
+var _iterators = {};
-/* */
-/* globals MutationObserver */
+var dP$2 = _objectDp;
+var anObject$2 = _anObject;
+var getKeys$1 = _objectKeys;
-// can we use __proto__?
-var hasProto = '__proto__' in {};
+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;
+};
-// Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = UA && UA.indexOf('android') > 0;
-var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
+var document$2 = _global.document;
+var _html = document$2 && document$2.documentElement;
-// Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// 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';
-var supportsPassive = false;
-if (inBrowser) {
- try {
- var opts = {};
- Object.defineProperty(opts, 'passive', ({
- get: function get () {
- /* istanbul ignore next */
- supportsPassive = true;
- }
- })); // https://github.com/facebook/flow/issues/285
- window.addEventListener('test-passive', null, opts);
- } catch (e) {}
-}
+// 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();
+};
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
- if (_isServer === undefined) {
- /* istanbul ignore if */
- if (!inBrowser && typeof commonjsGlobal !== 'undefined') {
- // detect presence of vue-server-renderer and avoid
- // Webpack shimming the process
- _isServer = commonjsGlobal['process'].env.VUE_ENV === 'server';
- } else {
- _isServer = false;
- }
- }
- return _isServer
+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);
};
-// detect devtools
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+var def = _objectDp.f;
+var has$3 = _has;
+var TAG$1 = _wks('toStringTag');
-/* istanbul ignore next */
-function isNative (Ctor) {
- return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
+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 hasSymbol =
- typeof Symbol !== 'undefined' && isNative(Symbol) &&
- typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
+var create$1 = _objectCreate;
+var descriptor = _propertyDesc;
+var setToStringTag$1 = _setToStringTag;
+var IteratorPrototype = {};
-/**
- * Defer a task to execute it asynchronously.
- */
-var nextTick = (function () {
- var callbacks = [];
- var pending = false;
- var timerFunc;
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+_hide(IteratorPrototype, _wks('iterator'), function () { return this; });
- function nextTickHandler () {
- pending = false;
- var copies = callbacks.slice(0);
- callbacks.length = 0;
- for (var i = 0; i < copies.length; i++) {
- copies[i]();
- }
- }
+var _iterCreate = function (Constructor, NAME, next) {
+ Constructor.prototype = create$1(IteratorPrototype, { next: descriptor(1, next) });
+ setToStringTag$1(Constructor, NAME + ' Iterator');
+};
- // the nextTick behavior leverages the microtask queue, which can be accessed
- // via either native Promise.then or MutationObserver.
- // MutationObserver has wider support, however it is seriously bugged in
- // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
- // completely stops working after triggering a few times... so, if native
- // Promise is available, we will use it:
- /* istanbul ignore if */
- if (typeof Promise !== 'undefined' && isNative(Promise)) {
- var p = Promise.resolve();
- var logError = function (err) { console.error(err); };
- timerFunc = function () {
- p.then(nextTickHandler).catch(logError);
- // in problematic UIWebViews, Promise.then doesn't completely break, but
- // it can get stuck in a weird state where callbacks are pushed into the
- // microtask queue but the queue isn't being flushed, until the browser
- // needs to do some other work, e.g. handle a timer. Therefore we can
- // "force" the microtask queue to be flushed by adding an empty timer.
- if (isIOS) { setTimeout(noop); }
- };
- } else if (!isIE && typeof MutationObserver !== 'undefined' && (
- isNative(MutationObserver) ||
- // PhantomJS and iOS 7.x
- MutationObserver.toString() === '[object MutationObserverConstructor]'
- )) {
- // use MutationObserver where native Promise is not available,
- // e.g. PhantomJS, iOS7, Android 4.4
- var counter = 1;
- var observer = new MutationObserver(nextTickHandler);
- var textNode = document.createTextNode(String(counter));
- observer.observe(textNode, {
- characterData: true
- });
- timerFunc = function () {
- counter = (counter + 1) % 2;
- textNode.data = String(counter);
- };
- } else {
- // fallback to setTimeout
- /* istanbul ignore next */
- timerFunc = function () {
- setTimeout(nextTickHandler, 0);
- };
- }
+// 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;
- return function queueNextTick (cb, ctx) {
- var _resolve;
- callbacks.push(function () {
- if (cb) {
- try {
- cb.call(ctx);
- } catch (e) {
- handleError(e, ctx, 'nextTick');
- }
- } else if (_resolve) {
- _resolve(ctx);
- }
- });
- if (!pending) {
- pending = true;
- timerFunc();
- }
- if (!cb && typeof Promise !== 'undefined') {
- return new Promise(function (resolve, reject) {
- _resolve = resolve;
- })
- }
- }
-})();
+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 _Set;
-/* istanbul ignore if */
-if (typeof Set !== 'undefined' && isNative(Set)) {
- // use native Set when available.
- _Set = Set;
-} else {
- // a non-standard Set polyfill that only works with primitive keys.
- _Set = (function () {
- function Set () {
- this.set = Object.create(null);
- }
- Set.prototype.has = function has (key) {
- return this.set[key] === true
- };
- Set.prototype.add = function add (key) {
- this.set[key] = true;
- };
- Set.prototype.clear = function clear () {
- this.set = Object.create(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';
- return Set;
- }());
-}
+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);
-var uid$1 = 0;
+// 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 };
+});
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-var Dep = function Dep () {
- this.id = uid$1++;
- this.subs = [];
+// 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;
};
-Dep.prototype.addSub = function addSub (sub) {
- this.subs.push(sub);
+var _iterStep = function (done, value) {
+ return { value: value, done: !!done };
};
-Dep.prototype.removeSub = function removeSub (sub) {
- remove(this.subs, sub);
-};
+var addToUnscopables = _addToUnscopables;
+var step = _iterStep;
+var Iterators$2 = _iterators;
+var toIObject$2 = _toIobject;
-Dep.prototype.depend = function depend () {
- if (Dep.target) {
- Dep.target.addDep(this);
+// 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');
-Dep.prototype.notify = function notify () {
- // stabilize the subscriber list first
- var subs = this.subs.slice();
- for (var i = 0, l = subs.length; i < l; i++) {
- subs[i].update();
- }
-};
+// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+Iterators$2.Arguments = Iterators$2.Array;
-// the current target watcher being evaluated.
-// this is globally unique because there could be only one
-// watcher being evaluated at any time.
-Dep.target = null;
-var targetStack = [];
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
-function pushTarget (_target) {
- if (Dep.target) { targetStack.push(Dep.target); }
- Dep.target = _target;
-}
+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;
-function popTarget () {
- Dep.target = targetStack.pop();
-}
+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
+};
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
+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 arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);[
- 'push',
- 'pop',
- 'shift',
- 'unshift',
- 'splice',
- 'sort',
- 'reverse'
-]
-.forEach(function (method) {
- // cache original method
- var original = arrayProto[method];
- def(arrayMethods, method, function mutator () {
- var arguments$1 = arguments;
+var _anInstance = function (it, Constructor, name, forbiddenField) {
+ if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
+ throw TypeError(name + ': incorrect invocation!');
+ } return it;
+};
- var args = [], len = arguments.length;
- while ( len-- ) { args[ len ] = arguments$1[ len ]; }
+// 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;
+ }
+};
- var result = original.apply(this, args);
- var ob = this.__ob__;
- var inserted;
- switch (method) {
- case 'push':
- case 'unshift':
- inserted = args;
- break
- case 'splice':
- inserted = args.slice(2);
- break
- }
- if (inserted) { ob.observeArray(inserted); }
- // notify change
- ob.dep.notify();
- return result
- });
-});
+// 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 arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+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)]; }
+};
-/**
- * By default, when a reactive property is set, the new value is
- * also converted to become reactive. However when passing down props,
- * we don't want to force conversion because the value may be a nested value
- * under a frozen data structure. Converting it would defeat the optimization.
- */
-var observerState = {
- shouldConvert: true
+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;
+});
-/**
- * Observer class that are attached to each observed
- * object. Once attached, the observer converts target
- * object's property keys into getter/setters that
- * collect dependencies and dispatches updates.
- */
-var Observer = function Observer (value) {
- this.value = value;
- this.dep = new Dep();
- this.vmCount = 0;
- def(value, '__ob__', this);
- if (Array.isArray(value)) {
- var augment = hasProto
- ? protoAugment
- : copyAugment;
- augment(value, arrayMethods, arrayKeys);
- this.observeArray(value);
- } else {
- this.walk(value);
- }
+// 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);
};
-/**
- * Walk through each property and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
- var keys = Object.keys(obj);
- for (var i = 0; i < keys.length; i++) {
- defineReactive$$1(obj, keys[i], obj[keys[i]]);
- }
+// 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);
};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
- for (var i = 0, l = items.length; i < l; i++) {
- observe(items[i]);
+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;
-// helpers
-
-/**
- * Augment an target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment (target, src, keys) {
- /* eslint-disable no-proto */
- target.__proto__ = src;
- /* eslint-enable no-proto */
-}
-
-/**
- * Augment an target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment (target, src, keys) {
- for (var i = 0, l = keys.length; i < l; i++) {
- var key = keys[i];
- def(target, key, src[key]);
+ 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
+};
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe (value, asRootData) {
- if (!isObject(value)) {
- return
- }
- var ob;
- if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
- ob = value.__ob__;
- } else if (
- observerState.shouldConvert &&
- !isServerRendering() &&
- (Array.isArray(value) || isPlainObject(value)) &&
- Object.isExtensible(value) &&
- !value._isVue
- ) {
- ob = new Observer(value);
- }
- if (asRootData && ob) {
- ob.vmCount++;
- }
- return ob
-}
+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';
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive$$1 (
- obj,
- key,
- val,
- customSetter,
- shallow
-) {
- var dep = new Dep();
+var _microtask = function () {
+ var head, last, notify;
- var property = Object.getOwnPropertyDescriptor(obj, key);
- if (property && property.configurable === false) {
- return
+ 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);
+ };
}
- // cater for pre-defined getter/setters
- var getter = property && property.get;
- var setter = property && property.set;
+ return function (fn) {
+ var task = { fn: fn, next: undefined };
+ if (last) { last.next = task; }
+ if (!head) {
+ head = task;
+ notify();
+ } last = task;
+ };
+};
- var childOb = !shallow && observe(val);
- Object.defineProperty(obj, key, {
- enumerable: true,
- configurable: true,
- get: function reactiveGetter () {
- var value = getter ? getter.call(obj) : val;
- if (Dep.target) {
- dep.depend();
- if (childOb) {
- childOb.dep.depend();
- if (Array.isArray(value)) {
- dependArray(value);
- }
- }
- }
- return value
- },
- set: function reactiveSetter (newVal) {
- var value = getter ? getter.call(obj) : val;
- /* eslint-disable no-self-compare */
- if (newVal === value || (newVal !== newVal && value !== value)) {
- return
- }
- /* eslint-enable no-self-compare */
- if ("development" !== 'production' && customSetter) {
- customSetter();
- }
- if (setter) {
- setter.call(obj, newVal);
- } else {
- val = newVal;
- }
- childOb = !shallow && observe(newVal);
- dep.notify();
- }
+// 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);
}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set (target, key, val) {
- if (Array.isArray(target) && isValidArrayIndex(key)) {
- target.length = Math.max(target.length, key);
- target.splice(key, 1, val);
- return val
- }
- if (hasOwn(target, key)) {
- target[key] = val;
- return val
- }
- var ob = (target).__ob__;
- if (target._isVue || (ob && ob.vmCount)) {
- "development" !== 'production' && warn(
- 'Avoid adding reactive properties to a Vue instance or its root $data ' +
- 'at runtime - declare it upfront in the data option.'
- );
- return val
- }
- if (!ob) {
- target[key] = val;
- return val
+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 };
}
- defineReactive$$1(ob.value, key, val);
- ob.dep.notify();
- return val
-}
+};
-/**
- * Delete a property and trigger change if necessary.
- */
-function del (target, key) {
- if (Array.isArray(target) && isValidArrayIndex(key)) {
- target.splice(key, 1);
- return
- }
- var ob = (target).__ob__;
- if (target._isVue || (ob && ob.vmCount)) {
- "development" !== 'production' && warn(
- 'Avoid deleting properties on a Vue instance or its root $data ' +
- '- just set it to null.'
- );
- return
- }
- if (!hasOwn(target, key)) {
- return
- }
- delete target[key];
- if (!ob) {
- return
- }
- ob.dep.notify();
-}
-
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray (value) {
- for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
- e = value[i];
- e && e.__ob__ && e.__ob__.dep.depend();
- if (Array.isArray(e)) {
- dependArray(e);
- }
- }
-}
-
-/* */
+var newPromiseCapability$1 = _newPromiseCapability;
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-var strats = config.optionMergeStrategies;
+var _promiseResolve = function (C, x) {
+ var promiseCapability = newPromiseCapability$1.f(C);
+ var resolve = promiseCapability.resolve;
+ resolve(x);
+ return promiseCapability.promise;
+};
-/**
- * Options with restrictions
- */
-{
- strats.el = strats.propsData = function (parent, child, vm, key) {
- if (!vm) {
- warn(
- "option \"" + key + "\" can only be used during instance " +
- 'creation with the `new` keyword.'
- );
- }
- return defaultStrat(parent, child)
- };
-}
+var redefine$3 = _redefine;
+var _redefineAll = function (target, src, safe) {
+ for (var key in src) { redefine$3(target, key, src[key], safe); }
+ return target;
+};
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData (to, from) {
- if (!from) { return to }
- var key, toVal, fromVal;
- var keys = Object.keys(from);
- for (var i = 0; i < keys.length; i++) {
- key = keys[i];
- toVal = to[key];
- fromVal = from[key];
- if (!hasOwn(to, key)) {
- set(to, key, fromVal);
- } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
- mergeData(toVal, fromVal);
- }
- }
- return to
-}
+var global$7 = _global;
+var dP$3 = _objectDp;
+var DESCRIPTORS = _descriptors;
+var SPECIES$1 = _wks('species');
-/**
- * Data
- */
-function mergeDataOrFn (
- parentVal,
- childVal,
- vm
-) {
- if (!vm) {
- // in a Vue.extend merge, both should be functions
- if (!childVal) {
- return parentVal
- }
- if (!parentVal) {
- return childVal
- }
- // when parentVal & childVal are both present,
- // we need to return a function that returns the
- // merged result of both functions... no need to
- // check if parentVal is a function here because
- // it has to be a function to pass previous merges.
- return function mergedDataFn () {
- return mergeData(
- typeof childVal === 'function' ? childVal.call(this) : childVal,
- typeof parentVal === 'function' ? parentVal.call(this) : parentVal
- )
- }
- } else if (parentVal || childVal) {
- return function mergedInstanceDataFn () {
- // instance merge
- var instanceData = typeof childVal === 'function'
- ? childVal.call(vm)
- : childVal;
- var defaultData = typeof parentVal === 'function'
- ? parentVal.call(vm)
- : parentVal;
- if (instanceData) {
- return mergeData(instanceData, defaultData)
- } else {
- return defaultData
- }
- }
- }
-}
+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; }
+ }); }
+};
-strats.data = function (
- parentVal,
- childVal,
- vm
-) {
- if (!vm) {
- if (childVal && typeof childVal !== 'function') {
- "development" !== 'production' && warn(
- 'The "data" option should be a function ' +
- 'that returns a per-instance value in component ' +
- 'definitions.',
- vm
- );
+var ITERATOR$4 = _wks('iterator');
+var SAFE_CLOSING = false;
- return parentVal
- }
- return mergeDataOrFn.call(this, parentVal, childVal)
- }
+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 */ }
- return mergeDataOrFn(parentVal, childVal, vm)
+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;
};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook (
- parentVal,
- childVal
-) {
- return childVal
- ? parentVal
- ? parentVal.concat(childVal)
- : Array.isArray(childVal)
- ? childVal
- : [childVal]
- : parentVal
-}
-
-LIFECYCLE_HOOKS.forEach(function (hook) {
- strats[hook] = mergeHook;
-});
+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;
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets (parentVal, childVal) {
- var res = Object.create(parentVal || null);
- return childVal
- ? extend(res, childVal)
- : res
-}
+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 */ }
+}();
-ASSET_TYPES.forEach(function (type) {
- strats[type + 's'] = mergeAssets;
-});
-
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal) {
- // work around Firefox's Object.prototype.watch...
- if (parentVal === nativeWatch) { parentVal = undefined; }
- if (childVal === nativeWatch) { childVal = undefined; }
- /* istanbul ignore if */
- if (!childVal) { return Object.create(parentVal || null) }
- if (!parentVal) { return childVal }
- var ret = {};
- extend(ret, parentVal);
- for (var key in childVal) {
- var parent = ret[key];
- var child = childVal[key];
- if (parent && !Array.isArray(parent)) {
- parent = [parent];
- }
- ret[key] = parent
- ? parent.concat(child)
- : Array.isArray(child) ? child : [child];
- }
- return ret
-};
-
-/**
- * Other object hashes.
- */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (parentVal, childVal) {
- if (!parentVal) { return childVal }
- var ret = Object.create(null);
- extend(ret, parentVal);
- if (childVal) { extend(ret, childVal); }
- return ret
+// 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;
};
-strats.provide = mergeDataOrFn;
-
-/**
- * Default strategy.
- */
-var defaultStrat = function (parentVal, childVal) {
- return childVal === undefined
- ? parentVal
- : childVal
+var isThenable = function (it) {
+ var then;
+ return isObject$3(it) && typeof (then = it.then) == 'function' ? then : false;
};
-
-/**
- * Validate component names
- */
-function checkComponents (options) {
- for (var key in options.components) {
- var lower = key.toLowerCase();
- if (isBuiltInTag(lower) || config.isReservedTag(lower)) {
- warn(
- 'Do not use built-in or reserved HTML elements as component ' +
- 'id: ' + key
- );
- }
- }
-}
-
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps (options) {
- var props = options.props;
- if (!props) { return }
- var res = {};
- var i, val, name;
- if (Array.isArray(props)) {
- i = props.length;
- while (i--) {
- val = props[i];
- if (typeof val === 'string') {
- name = camelize(val);
- res[name] = { type: null };
- } else {
- warn('props must be strings when using array syntax.');
+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 });
}
- } else if (isPlainObject(props)) {
- for (var key in props) {
- val = props[key];
- name = camelize(key);
- res[name] = isPlainObject(val)
- ? val
- : { type: val };
- }
- }
- options.props = res;
-}
-
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject (options) {
- var inject = options.inject;
- if (Array.isArray(inject)) {
- var normalized = options.inject = {};
- for (var i = 0; i < inject.length; i++) {
- normalized[inject[i]] = inject[i];
+ });
+};
+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
}
-}
+};
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives (options) {
- var dirs = options.directives;
- if (dirs) {
- for (var key in dirs) {
- var def = dirs[key];
- if (typeof def === 'function') {
- dirs[key] = { bind: def, update: def };
- }
+// 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);
}
- }
-}
-
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions (
- parent,
- child,
- vm
-) {
- {
- checkComponents(child);
- }
+ };
+ // 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);
+ };
+}
- if (typeof child === 'function') {
- child = child.options;
- }
+$export$3($export$3.G + $export$3.W + $export$3.F * !USE_NATIVE, { Promise: $Promise });
+_setToStringTag($Promise, PROMISE);
+_setSpecies(PROMISE);
+Wrapper = _core[PROMISE];
- normalizeProps(child);
- normalizeInject(child);
- normalizeDirectives(child);
- var extendsFrom = child.extends;
- if (extendsFrom) {
- parent = mergeOptions(parent, extendsFrom, vm);
- }
- if (child.mixins) {
- for (var i = 0, l = child.mixins.length; i < l; i++) {
- parent = mergeOptions(parent, child.mixins[i], vm);
- }
- }
- var options = {};
- var key;
- for (key in parent) {
- mergeField(key);
+// 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;
}
- for (key in child) {
- if (!hasOwn(parent, key)) {
- mergeField(key);
- }
+});
+$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);
}
- function mergeField (key) {
- var strat = strats[key] || defaultStrat;
- options[key] = strat(parent[key], child[key], vm, key);
+});
+$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;
}
- return options
-}
+});
+
+/*
+ * 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 yo
<TRUNCATED>