From e34fab394badcff746d9952a1d73a3e6ea2779d1 Mon Sep 17 00:00:00 2001 From: Roman Hotsiy Date: Mon, 18 Jan 2016 17:56:48 +0200 Subject: [PATCH] Release v0.1.0 --- dist/redoc.full.js | 23751 +++++++++++++++++------------------ dist/redoc.full.js.map | 2 +- dist/redoc.full.min.js | 1025 +- dist/redoc.full.min.js.map | 2 +- 4 files changed, 12648 insertions(+), 12132 deletions(-) diff --git a/dist/redoc.full.js b/dist/redoc.full.js index 9626d5af..d5277f6d 100644 --- a/dist/redoc.full.js +++ b/dist/redoc.full.js @@ -2150,9 +2150,9 @@ MERCHANTABLITY OR NON-INFRINGEMENT. See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ +"use strict"; var Reflect; (function (Reflect) { - "use strict"; // Load global or shim versions of Map, Set, and WeakMap var functionPrototype = Object.getPrototypeOf(Function); var _Map = typeof Map === "function" ? Map : CreateMapPolyfill(); @@ -2290,7 +2290,7 @@ var Reflect; if (!IsConstructor(target)) { throw new TypeError(); } - OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, /*targetKey*/ undefined); + OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, undefined); } } return decorator; @@ -2649,7 +2649,7 @@ var Reflect; targetKey = ToPropertyKey(targetKey); } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#deletemetadata-metadatakey-p- - var metadataMap = GetOrCreateMetadataMap(target, targetKey, /*create*/ false); + var metadataMap = GetOrCreateMetadataMap(target, targetKey, false); if (IsUndefined(metadataMap)) { return false; } @@ -2734,7 +2734,7 @@ var Reflect; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasownmetadata--metadatakey-o-p- function OrdinaryHasOwnMetadata(MetadataKey, O, P) { - var metadataMap = GetOrCreateMetadataMap(O, P, /*create*/ false); + var metadataMap = GetOrCreateMetadataMap(O, P, false); if (metadataMap === undefined) { return false; } @@ -2754,7 +2754,7 @@ var Reflect; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetownmetadata--metadatakey-o-p- function OrdinaryGetOwnMetadata(MetadataKey, O, P) { - var metadataMap = GetOrCreateMetadataMap(O, P, /*create*/ false); + var metadataMap = GetOrCreateMetadataMap(O, P, false); if (metadataMap === undefined) { return undefined; } @@ -2762,7 +2762,7 @@ var Reflect; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarydefineownmetadata--metadatakey-metadatavalue-o-p- function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { - var metadataMap = GetOrCreateMetadataMap(O, P, /*create*/ true); + var metadataMap = GetOrCreateMetadataMap(O, P, true); metadataMap.set(MetadataKey, MetadataValue); } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarymetadatakeys--o-p- @@ -2801,7 +2801,7 @@ var Reflect; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryownmetadatakeys--o-p- function OrdinaryOwnMetadataKeys(target, targetKey) { - var metadataMap = GetOrCreateMetadataMap(target, targetKey, /*create*/ false); + var metadataMap = GetOrCreateMetadataMap(target, targetKey, false); var keys = []; if (metadataMap) { metadataMap.forEach(function (_, key) { return keys.push(key); }); @@ -2984,26 +2984,26 @@ var Reflect; } WeakMap.prototype = { has: function (target) { - var table = GetOrCreateWeakMapTable(target, /*create*/ false); + var table = GetOrCreateWeakMapTable(target, false); if (table) { return this._key in table; } return false; }, get: function (target) { - var table = GetOrCreateWeakMapTable(target, /*create*/ false); + var table = GetOrCreateWeakMapTable(target, false); if (table) { return table[this._key]; } return undefined; }, set: function (target, value) { - var table = GetOrCreateWeakMapTable(target, /*create*/ true); + var table = GetOrCreateWeakMapTable(target, true); table[this._key] = value; return this; }, delete: function (target) { - var table = GetOrCreateWeakMapTable(target, /*create*/ false); + var table = GetOrCreateWeakMapTable(target, false); if (table && this._key in table) { return delete table[this._key]; } @@ -3098,497 +3098,4381 @@ var Reflect; Function("return this;")()); })(Reflect || (Reflect = {})); -"format amd"; -(function(global) { +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 2 ? $$[2] : undefined + , count = Math.min((end === undefined ? len : toIndex(end, len)) - from, len - to) + , inc = 1; + if(from < to && to < from + count){ + inc = -1; + from += count - 1; + to += count - 1; + } + while(count-- > 0){ + if(from in O)O[to] = O[from]; + else delete O[to]; + to += inc; + from += inc; + } return O; +}; +},{"77":77,"80":80,"81":81}],7:[function(_dereq_,module,exports){ +// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length) +'use strict'; +var toObject = _dereq_(81) + , toIndex = _dereq_(77) + , toLength = _dereq_(80); +module.exports = [].fill || function fill(value /*, start = 0, end = @length */){ + var O = toObject(this, true) + , length = toLength(O.length) + , $$ = arguments + , $$len = $$.length + , index = toIndex($$len > 1 ? $$[1] : undefined, length) + , end = $$len > 2 ? $$[2] : undefined + , endPos = end === undefined ? length : toIndex(end, length); + while(endPos > index)O[index++] = value; + return O; +}; +},{"77":77,"80":80,"81":81}],8:[function(_dereq_,module,exports){ +// false -> Array#indexOf +// true -> Array#includes +var toIObject = _dereq_(79) + , toLength = _dereq_(80) + , toIndex = _dereq_(77); +module.exports = function(IS_INCLUDES){ + return function($this, el, fromIndex){ + var O = toIObject($this) + , length = toLength(O.length) + , index = toIndex(fromIndex, length) + , value; + // Array#includes uses SameValueZero equality algorithm + if(IS_INCLUDES && el != el)while(length > index){ + value = O[index++]; + if(value != value)return true; + // Array#toIndex ignores holes, Array#includes - not + } else for(;length > index; index++)if(IS_INCLUDES || index in O){ + if(O[index] === el)return IS_INCLUDES || index; + } return !IS_INCLUDES && -1; + }; +}; +},{"77":77,"79":79,"80":80}],9:[function(_dereq_,module,exports){ +// 0 -> Array#forEach +// 1 -> Array#map +// 2 -> Array#filter +// 3 -> Array#some +// 4 -> Array#every +// 5 -> Array#find +// 6 -> Array#findIndex +var ctx = _dereq_(18) + , IObject = _dereq_(35) + , toObject = _dereq_(81) + , toLength = _dereq_(80) + , asc = _dereq_(10); +module.exports = function(TYPE){ + var IS_MAP = TYPE == 1 + , IS_FILTER = TYPE == 2 + , IS_SOME = TYPE == 3 + , IS_EVERY = TYPE == 4 + , IS_FIND_INDEX = TYPE == 6 + , NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + return function($this, callbackfn, that){ + var O = toObject($this) + , self = IObject(O) + , f = ctx(callbackfn, that, 3) + , length = toLength(self.length) + , index = 0 + , result = IS_MAP ? asc($this, length) : IS_FILTER ? asc($this, 0) : undefined + , val, res; + for(;length > index; index++)if(NO_HOLES || index in self){ + val = self[index]; + res = f(val, index, O); + if(TYPE){ + if(IS_MAP)result[index] = res; // map + else if(res)switch(TYPE){ + case 3: return true; // some + case 5: return val; // find + case 6: return index; // findIndex + case 2: result.push(val); // filter + } else if(IS_EVERY)return false; // every + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result; + }; +}; +},{"10":10,"18":18,"35":35,"80":80,"81":81}],10:[function(_dereq_,module,exports){ +// 9.4.2.3 ArraySpeciesCreate(originalArray, length) +var isObject = _dereq_(39) + , isArray = _dereq_(37) + , SPECIES = _dereq_(84)('species'); +module.exports = function(original, length){ + var C; + if(isArray(original)){ + C = original.constructor; + // cross-realm fallback + if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined; + if(isObject(C)){ + C = C[SPECIES]; + if(C === null)C = undefined; + } + } return new (C === undefined ? Array : C)(length); +}; +},{"37":37,"39":39,"84":84}],11:[function(_dereq_,module,exports){ +// getting tag from 19.1.3.6 Object.prototype.toString() +var cof = _dereq_(12) + , TAG = _dereq_(84)('toStringTag') + // ES3 wrong here + , ARG = cof(function(){ return arguments; }()) == 'Arguments'; + +module.exports = function(it){ + var O, T, B; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (T = (O = Object(it))[TAG]) == 'string' ? T + // builtinTag case + : ARG ? cof(O) + // ES3 arguments fallback + : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; +}; +},{"12":12,"84":84}],12:[function(_dereq_,module,exports){ +var toString = {}.toString; + +module.exports = function(it){ + return toString.call(it).slice(8, -1); +}; +},{}],13:[function(_dereq_,module,exports){ +'use strict'; +var $ = _dereq_(47) + , hide = _dereq_(32) + , mix = _dereq_(54) + , ctx = _dereq_(18) + , strictNew = _dereq_(70) + , defined = _dereq_(20) + , forOf = _dereq_(28) + , $iterDefine = _dereq_(43) + , step = _dereq_(45) + , ID = _dereq_(83)('id') + , $has = _dereq_(31) + , isObject = _dereq_(39) + , setSpecies = _dereq_(66) + , DESCRIPTORS = _dereq_(21) + , isExtensible = Object.isExtensible || isObject + , SIZE = DESCRIPTORS ? '_s' : 'size' + , id = 0; + +var fastKey = function(it, create){ + // return primitive with prefix + if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if(!$has(it, ID)){ + // can't set id to frozen object + if(!isExtensible(it))return 'F'; + // not necessary to add id + if(!create)return 'E'; + // add missing object id + hide(it, ID, ++id); + // return object id with prefix + } return 'O' + it[ID]; +}; + +var getEntry = function(that, key){ + // fast case + var index = fastKey(key), entry; + if(index !== 'F')return that._i[index]; + // frozen object case + for(entry = that._f; entry; entry = entry.n){ + if(entry.k == key)return entry; + } +}; + +module.exports = { + getConstructor: function(wrapper, NAME, IS_MAP, ADDER){ + var C = wrapper(function(that, iterable){ + strictNew(that, C, NAME); + that._i = $.create(null); // index + that._f = undefined; // first entry + that._l = undefined; // last entry + that[SIZE] = 0; // size + if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); + }); + mix(C.prototype, { + // 23.1.3.1 Map.prototype.clear() + // 23.2.3.2 Set.prototype.clear() + clear: function clear(){ + for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){ + entry.r = true; + if(entry.p)entry.p = entry.p.n = undefined; + delete data[entry.i]; + } + that._f = that._l = undefined; + that[SIZE] = 0; + }, + // 23.1.3.3 Map.prototype.delete(key) + // 23.2.3.4 Set.prototype.delete(value) + 'delete': function(key){ + var that = this + , entry = getEntry(that, key); + if(entry){ + var next = entry.n + , prev = entry.p; + delete that._i[entry.i]; + entry.r = true; + if(prev)prev.n = next; + if(next)next.p = prev; + if(that._f == entry)that._f = next; + if(that._l == entry)that._l = prev; + that[SIZE]--; + } return !!entry; + }, + // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) + // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) + forEach: function forEach(callbackfn /*, that = undefined */){ + var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3) + , entry; + while(entry = entry ? entry.n : this._f){ + f(entry.v, entry.k, this); + // revert to the last existing entry + while(entry && entry.r)entry = entry.p; + } + }, + // 23.1.3.7 Map.prototype.has(key) + // 23.2.3.7 Set.prototype.has(value) + has: function has(key){ + return !!getEntry(this, key); + } + }); + if(DESCRIPTORS)$.setDesc(C.prototype, 'size', { + get: function(){ + return defined(this[SIZE]); + } + }); + return C; + }, + def: function(that, key, value){ + var entry = getEntry(that, key) + , prev, index; + // change existing entry + if(entry){ + entry.v = value; + // create new entry + } else { + that._l = entry = { + i: index = fastKey(key, true), // <- index + k: key, // <- key + v: value, // <- value + p: prev = that._l, // <- previous entry + n: undefined, // <- next entry + r: false // <- removed + }; + if(!that._f)that._f = entry; + if(prev)prev.n = entry; + that[SIZE]++; + // add to index + if(index !== 'F')that._i[index] = entry; + } return that; + }, + getEntry: getEntry, + setStrong: function(C, NAME, IS_MAP){ + // add .keys, .values, .entries, [@@iterator] + // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 + $iterDefine(C, NAME, function(iterated, kind){ + this._t = iterated; // target + this._k = kind; // kind + this._l = undefined; // previous + }, function(){ + var that = this + , kind = that._k + , entry = that._l; + // revert to the last existing entry + while(entry && entry.r)entry = entry.p; + // get next entry + if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){ + // or finish the iteration + that._t = undefined; + return step(1); + } + // return step by kind + if(kind == 'keys' )return step(0, entry.k); + if(kind == 'values')return step(0, entry.v); + return step(0, [entry.k, entry.v]); + }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true); + + // add [@@species], 23.1.2.2, 23.2.2.2 + setSpecies(NAME); + } +}; +},{"18":18,"20":20,"21":21,"28":28,"31":31,"32":32,"39":39,"43":43,"45":45,"47":47,"54":54,"66":66,"70":70,"83":83}],14:[function(_dereq_,module,exports){ +// https://github.com/DavidBruant/Map-Set.prototype.toJSON +var forOf = _dereq_(28) + , classof = _dereq_(11); +module.exports = function(NAME){ + return function toJSON(){ + if(classof(this) != NAME)throw TypeError(NAME + "#toJSON isn't generic"); + var arr = []; + forOf(this, false, arr.push, arr); + return arr; + }; +}; +},{"11":11,"28":28}],15:[function(_dereq_,module,exports){ +'use strict'; +var hide = _dereq_(32) + , mix = _dereq_(54) + , anObject = _dereq_(5) + , strictNew = _dereq_(70) + , forOf = _dereq_(28) + , method = _dereq_(9) + , WEAK = _dereq_(83)('weak') + , isObject = _dereq_(39) + , $has = _dereq_(31) + , isExtensible = Object.isExtensible || isObject + , find = method(5) + , findIndex = method(6) + , id = 0; + +// fallback for frozen keys +var frozenStore = function(that){ + return that._l || (that._l = new FrozenStore); +}; +var FrozenStore = function(){ + this.a = []; +}; +var findFrozen = function(store, key){ + return find(store.a, function(it){ + return it[0] === key; + }); +}; +FrozenStore.prototype = { + get: function(key){ + var entry = findFrozen(this, key); + if(entry)return entry[1]; + }, + has: function(key){ + return !!findFrozen(this, key); + }, + set: function(key, value){ + var entry = findFrozen(this, key); + if(entry)entry[1] = value; + else this.a.push([key, value]); + }, + 'delete': function(key){ + var index = findIndex(this.a, function(it){ + return it[0] === key; + }); + if(~index)this.a.splice(index, 1); + return !!~index; + } +}; + +module.exports = { + getConstructor: function(wrapper, NAME, IS_MAP, ADDER){ + var C = wrapper(function(that, iterable){ + strictNew(that, C, NAME); + that._i = id++; // collection id + that._l = undefined; // leak store for frozen objects + if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); + }); + mix(C.prototype, { + // 23.3.3.2 WeakMap.prototype.delete(key) + // 23.4.3.3 WeakSet.prototype.delete(value) + 'delete': function(key){ + if(!isObject(key))return false; + if(!isExtensible(key))return frozenStore(this)['delete'](key); + return $has(key, WEAK) && $has(key[WEAK], this._i) && delete key[WEAK][this._i]; + }, + // 23.3.3.4 WeakMap.prototype.has(key) + // 23.4.3.4 WeakSet.prototype.has(value) + has: function has(key){ + if(!isObject(key))return false; + if(!isExtensible(key))return frozenStore(this).has(key); + return $has(key, WEAK) && $has(key[WEAK], this._i); + } + }); + return C; + }, + def: function(that, key, value){ + if(!isExtensible(anObject(key))){ + frozenStore(that).set(key, value); + } else { + $has(key, WEAK) || hide(key, WEAK, {}); + key[WEAK][that._i] = value; + } return that; + }, + frozenStore: frozenStore, + WEAK: WEAK +}; +},{"28":28,"31":31,"32":32,"39":39,"5":5,"54":54,"70":70,"83":83,"9":9}],16:[function(_dereq_,module,exports){ +'use strict'; +var global = _dereq_(30) + , $def = _dereq_(19) + , $redef = _dereq_(62) + , mix = _dereq_(54) + , forOf = _dereq_(28) + , strictNew = _dereq_(70) + , isObject = _dereq_(39) + , fails = _dereq_(25) + , $iterDetect = _dereq_(44) + , setToStringTag = _dereq_(67); + +module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){ + var Base = global[NAME] + , C = Base + , ADDER = IS_MAP ? 'set' : 'add' + , proto = C && C.prototype + , O = {}; + var fixMethod = function(KEY){ + var fn = proto[KEY]; + $redef(proto, KEY, + KEY == 'delete' ? function(a){ + return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); + } : KEY == 'has' ? function has(a){ + return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); + } : KEY == 'get' ? function get(a){ + return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a); + } : KEY == 'add' ? function add(a){ fn.call(this, a === 0 ? 0 : a); return this; } + : function set(a, b){ fn.call(this, a === 0 ? 0 : a, b); return this; } + ); + }; + if(typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){ + new C().entries().next(); + }))){ + // create collection constructor + C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER); + mix(C.prototype, methods); + } else { + var instance = new C + // early implementations not supports chaining + , HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); }) + // most early implementations doesn't supports iterables, most modern - not close it correctly + , ACCEPT_ITERABLES = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new + // for early implementations -0 and +0 not the same + , BUGGY_ZERO; + if(!ACCEPT_ITERABLES){ + C = wrapper(function(target, iterable){ + strictNew(target, C, NAME); + var that = new Base; + if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); + return that; + }); + C.prototype = proto; + proto.constructor = C; + } + IS_WEAK || instance.forEach(function(val, key){ + BUGGY_ZERO = 1 / key === -Infinity; + }); + if(THROWS_ON_PRIMITIVES || BUGGY_ZERO){ + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + if(BUGGY_ZERO || HASNT_CHAINING)fixMethod(ADDER); + // weak collections should not contains .clear method + if(IS_WEAK && proto.clear)delete proto.clear; + } + + setToStringTag(C, NAME); + + O[NAME] = C; + $def($def.G + $def.W + $def.F * (C != Base), O); + + if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP); + + return C; +}; +},{"19":19,"25":25,"28":28,"30":30,"39":39,"44":44,"54":54,"62":62,"67":67,"70":70}],17:[function(_dereq_,module,exports){ +var core = module.exports = {version: '1.2.5'}; +if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef +},{}],18:[function(_dereq_,module,exports){ +// optional / simple context binding +var aFunction = _dereq_(3); +module.exports = 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); + }; +}; +},{"3":3}],19:[function(_dereq_,module,exports){ +var global = _dereq_(30) + , core = _dereq_(17) + , hide = _dereq_(32) + , $redef = _dereq_(62) + , PROTOTYPE = 'prototype'; +var ctx = function(fn, that){ + return function(){ + return fn.apply(that, arguments); + }; +}; +var $def = function(type, name, source){ + var key, own, out, exp + , isGlobal = type & $def.G + , isProto = type & $def.P + , target = isGlobal ? global : type & $def.S + ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE] + , exports = isGlobal ? core : core[name] || (core[name] = {}); + if(isGlobal)source = name; + for(key in source){ + // contains in native + own = !(type & $def.F) && target && key in target; + // export native or passed + out = (own ? target : source)[key]; + // bind timers to global for call from export context + if(type & $def.B && own)exp = ctx(out, global); + else exp = isProto && typeof out == 'function' ? ctx(Function.call, out) : out; + // extend global + if(target && !own)$redef(target, key, out); + // export + if(exports[key] != out)hide(exports, key, exp); + if(isProto)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out; + } +}; +global.core = core; +// type bitmap +$def.F = 1; // forced +$def.G = 2; // global +$def.S = 4; // static +$def.P = 8; // proto +$def.B = 16; // bind +$def.W = 32; // wrap +module.exports = $def; +},{"17":17,"30":30,"32":32,"62":62}],20:[function(_dereq_,module,exports){ +// 7.2.1 RequireObjectCoercible(argument) +module.exports = function(it){ + if(it == undefined)throw TypeError("Can't call method on " + it); + return it; +}; +},{}],21:[function(_dereq_,module,exports){ +// Thank's IE8 for his funny defineProperty +module.exports = !_dereq_(25)(function(){ + return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7; +}); +},{"25":25}],22:[function(_dereq_,module,exports){ +var isObject = _dereq_(39) + , document = _dereq_(30).document + // in old IE typeof document.createElement is 'object' + , is = isObject(document) && isObject(document.createElement); +module.exports = function(it){ + return is ? document.createElement(it) : {}; +}; +},{"30":30,"39":39}],23:[function(_dereq_,module,exports){ +// all enumerable object keys, includes symbols +var $ = _dereq_(47); +module.exports = function(it){ + var keys = $.getKeys(it) + , getSymbols = $.getSymbols; + if(getSymbols){ + var symbols = getSymbols(it) + , isEnum = $.isEnum + , i = 0 + , key; + while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key); + } + return keys; +}; +},{"47":47}],24:[function(_dereq_,module,exports){ +var MATCH = _dereq_(84)('match'); +module.exports = function(KEY){ + var re = /./; + try { + '/./'[KEY](re); + } catch(e){ + try { + re[MATCH] = false; + return !'/./'[KEY](re); + } catch(f){ /* empty */ } + } return true; +}; +},{"84":84}],25:[function(_dereq_,module,exports){ +module.exports = function(exec){ + try { + return !!exec(); + } catch(e){ + return true; + } +}; +},{}],26:[function(_dereq_,module,exports){ +'use strict'; +var hide = _dereq_(32) + , redef = _dereq_(62) + , fails = _dereq_(25) + , defined = _dereq_(20) + , wks = _dereq_(84); +module.exports = function(KEY, length, exec){ + var SYMBOL = wks(KEY) + , original = ''[KEY]; + if(fails(function(){ + var O = {}; + O[SYMBOL] = function(){ return 7; }; + return ''[KEY](O) != 7; + })){ + redef(String.prototype, KEY, exec(defined, SYMBOL, original)); + hide(RegExp.prototype, SYMBOL, length == 2 + // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) + // 21.2.5.11 RegExp.prototype[@@split](string, limit) + ? function(string, arg){ return original.call(string, this, arg); } + // 21.2.5.6 RegExp.prototype[@@match](string) + // 21.2.5.9 RegExp.prototype[@@search](string) + : function(string){ return original.call(string, this); } + ); + } +}; +},{"20":20,"25":25,"32":32,"62":62,"84":84}],27:[function(_dereq_,module,exports){ +'use strict'; +// 21.2.5.3 get RegExp.prototype.flags +var anObject = _dereq_(5); +module.exports = function(){ + var that = anObject(this) + , result = ''; + if(that.global) result += 'g'; + if(that.ignoreCase) result += 'i'; + if(that.multiline) result += 'm'; + if(that.unicode) result += 'u'; + if(that.sticky) result += 'y'; + return result; +}; +},{"5":5}],28:[function(_dereq_,module,exports){ +var ctx = _dereq_(18) + , call = _dereq_(41) + , isArrayIter = _dereq_(36) + , anObject = _dereq_(5) + , toLength = _dereq_(80) + , getIterFn = _dereq_(85); +module.exports = function(iterable, entries, fn, that){ + var iterFn = getIterFn(iterable) + , f = ctx(fn, that, entries ? 2 : 1) + , index = 0 + , length, step, iterator; + 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++){ + entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); + } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){ + call(iterator, f, step.value, entries); + } +}; +},{"18":18,"36":36,"41":41,"5":5,"80":80,"85":85}],29:[function(_dereq_,module,exports){ +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +var toString = {}.toString + , toIObject = _dereq_(79) + , getNames = _dereq_(47).getNames; + +var windowNames = typeof window == 'object' && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function(it){ + try { + return getNames(it); + } catch(e){ + return windowNames.slice(); + } +}; + +module.exports.get = function getOwnPropertyNames(it){ + if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it); + return getNames(toIObject(it)); +}; +},{"47":47,"79":79}],30:[function(_dereq_,module,exports){ +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); +if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef +},{}],31:[function(_dereq_,module,exports){ +var hasOwnProperty = {}.hasOwnProperty; +module.exports = function(it, key){ + return hasOwnProperty.call(it, key); +}; +},{}],32:[function(_dereq_,module,exports){ +var $ = _dereq_(47) + , createDesc = _dereq_(61); +module.exports = _dereq_(21) ? function(object, key, value){ + return $.setDesc(object, key, createDesc(1, value)); +} : function(object, key, value){ + object[key] = value; + return object; +}; +},{"21":21,"47":47,"61":61}],33:[function(_dereq_,module,exports){ +module.exports = _dereq_(30).document && document.documentElement; +},{"30":30}],34:[function(_dereq_,module,exports){ +// fast apply, http://jsperf.lnkit.com/fast-apply/5 +module.exports = 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); +}; +},{}],35:[function(_dereq_,module,exports){ +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var cof = _dereq_(12); +module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ + return cof(it) == 'String' ? it.split('') : Object(it); +}; +},{"12":12}],36:[function(_dereq_,module,exports){ +// check on default Array iterator +var Iterators = _dereq_(46) + , ITERATOR = _dereq_(84)('iterator') + , ArrayProto = Array.prototype; + +module.exports = function(it){ + return (Iterators.Array || ArrayProto[ITERATOR]) === it; +}; +},{"46":46,"84":84}],37:[function(_dereq_,module,exports){ +// 7.2.2 IsArray(argument) +var cof = _dereq_(12); +module.exports = Array.isArray || function(arg){ + return cof(arg) == 'Array'; +}; +},{"12":12}],38:[function(_dereq_,module,exports){ +// 20.1.2.3 Number.isInteger(number) +var isObject = _dereq_(39) + , floor = Math.floor; +module.exports = function isInteger(it){ + return !isObject(it) && isFinite(it) && floor(it) === it; +}; +},{"39":39}],39:[function(_dereq_,module,exports){ +module.exports = function(it){ + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; +},{}],40:[function(_dereq_,module,exports){ +// 7.2.8 IsRegExp(argument) +var isObject = _dereq_(39) + , cof = _dereq_(12) + , MATCH = _dereq_(84)('match'); +module.exports = function(it){ + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp'); +}; +},{"12":12,"39":39,"84":84}],41:[function(_dereq_,module,exports){ +// call something on iterator step with safe closing on error +var anObject = _dereq_(5); +module.exports = function(iterator, fn, value, entries){ + try { + return entries ? fn(anObject(value)[0], value[1]) : fn(value); + // 7.4.6 IteratorClose(iterator, completion) + } catch(e){ + var ret = iterator['return']; + if(ret !== undefined)anObject(ret.call(iterator)); + throw e; + } +}; +},{"5":5}],42:[function(_dereq_,module,exports){ +'use strict'; +var $ = _dereq_(47) + , descriptor = _dereq_(61) + , setToStringTag = _dereq_(67) + , IteratorPrototype = {}; + +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +_dereq_(32)(IteratorPrototype, _dereq_(84)('iterator'), function(){ return this; }); + +module.exports = function(Constructor, NAME, next){ + Constructor.prototype = $.create(IteratorPrototype, {next: descriptor(1, next)}); + setToStringTag(Constructor, NAME + ' Iterator'); +}; +},{"32":32,"47":47,"61":61,"67":67,"84":84}],43:[function(_dereq_,module,exports){ +'use strict'; +var LIBRARY = _dereq_(49) + , $def = _dereq_(19) + , $redef = _dereq_(62) + , hide = _dereq_(32) + , has = _dereq_(31) + , SYMBOL_ITERATOR = _dereq_(84)('iterator') + , Iterators = _dereq_(46) + , $iterCreate = _dereq_(42) + , setToStringTag = _dereq_(67) + , getProto = _dereq_(47).getProto + , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next` + , FF_ITERATOR = '@@iterator' + , KEYS = 'keys' + , VALUES = 'values'; +var returnThis = function(){ return this; }; +module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){ + $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' + , proto = Base.prototype + , _native = proto[SYMBOL_ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT] + , _default = _native || getMethod(DEFAULT) + , methods, key; + // Fix native + if(_native){ + var IteratorPrototype = getProto(_default.call(new Base)); + // Set @@toStringTag to native iterators + setToStringTag(IteratorPrototype, TAG, true); + // FF fix + if(!LIBRARY && has(proto, FF_ITERATOR))hide(IteratorPrototype, SYMBOL_ITERATOR, returnThis); + } + // Define iterator + if((!LIBRARY || FORCE) && (BUGGY || !(SYMBOL_ITERATOR in proto))){ + hide(proto, SYMBOL_ITERATOR, _default); + } + // Plug for library + Iterators[NAME] = _default; + Iterators[TAG] = returnThis; + if(DEFAULT){ + methods = { + values: DEFAULT == VALUES ? _default : getMethod(VALUES), + keys: IS_SET ? _default : getMethod(KEYS), + entries: DEFAULT != VALUES ? _default : getMethod('entries') + }; + if(FORCE)for(key in methods){ + if(!(key in proto))$redef(proto, key, methods[key]); + } else $def($def.P + $def.F * BUGGY, NAME, methods); + } + return methods; +}; +},{"19":19,"31":31,"32":32,"42":42,"46":46,"47":47,"49":49,"62":62,"67":67,"84":84}],44:[function(_dereq_,module,exports){ +var ITERATOR = _dereq_(84)('iterator') + , SAFE_CLOSING = false; + +try { + var riter = [7][ITERATOR](); + riter['return'] = function(){ SAFE_CLOSING = true; }; + Array.from(riter, function(){ throw 2; }); +} catch(e){ /* empty */ } + +module.exports = function(exec, skipClosing){ + if(!skipClosing && !SAFE_CLOSING)return false; + var safe = false; + try { + var arr = [7] + , iter = arr[ITERATOR](); + iter.next = function(){ safe = true; }; + arr[ITERATOR] = function(){ return iter; }; + exec(arr); + } catch(e){ /* empty */ } + return safe; +}; +},{"84":84}],45:[function(_dereq_,module,exports){ +module.exports = function(done, value){ + return {value: value, done: !!done}; +}; +},{}],46:[function(_dereq_,module,exports){ +module.exports = {}; +},{}],47:[function(_dereq_,module,exports){ +var $Object = Object; +module.exports = { + create: $Object.create, + getProto: $Object.getPrototypeOf, + isEnum: {}.propertyIsEnumerable, + getDesc: $Object.getOwnPropertyDescriptor, + setDesc: $Object.defineProperty, + setDescs: $Object.defineProperties, + getKeys: $Object.keys, + getNames: $Object.getOwnPropertyNames, + getSymbols: $Object.getOwnPropertySymbols, + each: [].forEach +}; +},{}],48:[function(_dereq_,module,exports){ +var $ = _dereq_(47) + , toIObject = _dereq_(79); +module.exports = function(object, el){ + var O = toIObject(object) + , keys = $.getKeys(O) + , length = keys.length + , index = 0 + , key; + while(length > index)if(O[key = keys[index++]] === el)return key; +}; +},{"47":47,"79":79}],49:[function(_dereq_,module,exports){ +module.exports = false; +},{}],50:[function(_dereq_,module,exports){ +// 20.2.2.14 Math.expm1(x) +module.exports = Math.expm1 || function expm1(x){ + return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1; +}; +},{}],51:[function(_dereq_,module,exports){ +// 20.2.2.20 Math.log1p(x) +module.exports = Math.log1p || function log1p(x){ + return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x); +}; +},{}],52:[function(_dereq_,module,exports){ +// 20.2.2.28 Math.sign(x) +module.exports = Math.sign || function sign(x){ + return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; +}; +},{}],53:[function(_dereq_,module,exports){ +var global = _dereq_(30) + , macrotask = _dereq_(76).set + , Observer = global.MutationObserver || global.WebKitMutationObserver + , process = global.process + , isNode = _dereq_(12)(process) == 'process' + , head, last, notify; + +var flush = function(){ + var parent, domain; + if(isNode && (parent = process.domain)){ + process.domain = null; + parent.exit(); + } + while(head){ + domain = head.domain; + if(domain)domain.enter(); + head.fn.call(); // <- currently we use it only for Promise - try / catch not required + if(domain)domain.exit(); + head = head.next; + } last = undefined; + if(parent)parent.enter(); +}; + +// Node.js +if(isNode){ + notify = function(){ + process.nextTick(flush); + }; +// browsers with MutationObserver +} else if(Observer){ + var toggle = 1 + , node = document.createTextNode(''); + new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new + notify = function(){ + node.data = toggle = -toggle; + }; +// for other environments - macrotask based on: +// - setImmediate +// - MessageChannel +// - window.postMessag +// - onreadystatechange +// - setTimeout +} else { + notify = function(){ + // strange IE + webpack dev server bug - use .call(global) + macrotask.call(global, flush); + }; +} + +module.exports = function asap(fn){ + var task = {fn: fn, next: undefined, domain: isNode && process.domain}; + if(last)last.next = task; + if(!head){ + head = task; + notify(); + } last = task; +}; +},{"12":12,"30":30,"76":76}],54:[function(_dereq_,module,exports){ +var $redef = _dereq_(62); +module.exports = function(target, src){ + for(var key in src)$redef(target, key, src[key]); + return target; +}; +},{"62":62}],55:[function(_dereq_,module,exports){ +// 19.1.2.1 Object.assign(target, source, ...) +var $ = _dereq_(47) + , toObject = _dereq_(81) + , IObject = _dereq_(35); + +// should work with symbols and should have deterministic property order (V8 bug) +module.exports = _dereq_(25)(function(){ + var a = Object.assign + , A = {} + , B = {} + , S = Symbol() + , K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function(k){ B[k] = k; }); + return a({}, A)[S] != 7 || Object.keys(a({}, B)).join('') != K; +}) ? function assign(target, source){ // eslint-disable-line no-unused-vars + var T = toObject(target) + , $$ = arguments + , $$len = $$.length + , index = 1 + , getKeys = $.getKeys + , getSymbols = $.getSymbols + , isEnum = $.isEnum; + while($$len > index){ + var S = IObject($$[index++]) + , keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S) + , length = keys.length + , j = 0 + , key; + while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key]; + } + return T; +} : Object.assign; +},{"25":25,"35":35,"47":47,"81":81}],56:[function(_dereq_,module,exports){ +// most Object methods by ES6 should accept primitives +var $def = _dereq_(19) + , core = _dereq_(17) + , fails = _dereq_(25); +module.exports = function(KEY, exec){ + var $def = _dereq_(19) + , fn = (core.Object || {})[KEY] || Object[KEY] + , exp = {}; + exp[KEY] = exec(fn); + $def($def.S + $def.F * fails(function(){ fn(1); }), 'Object', exp); +}; +},{"17":17,"19":19,"25":25}],57:[function(_dereq_,module,exports){ +var $ = _dereq_(47) + , toIObject = _dereq_(79) + , isEnum = $.isEnum; +module.exports = function(isEntries){ + return function(it){ + var O = toIObject(it) + , keys = $.getKeys(O) + , length = keys.length + , i = 0 + , result = [] + , key; + while(length > i)if(isEnum.call(O, key = keys[i++])){ + result.push(isEntries ? [key, O[key]] : O[key]); + } return result; + }; +}; +},{"47":47,"79":79}],58:[function(_dereq_,module,exports){ +// all object keys, includes non-enumerable and symbols +var $ = _dereq_(47) + , anObject = _dereq_(5) + , Reflect = _dereq_(30).Reflect; +module.exports = Reflect && Reflect.ownKeys || function ownKeys(it){ + var keys = $.getNames(anObject(it)) + , getSymbols = $.getSymbols; + return getSymbols ? keys.concat(getSymbols(it)) : keys; +}; +},{"30":30,"47":47,"5":5}],59:[function(_dereq_,module,exports){ +'use strict'; +var path = _dereq_(60) + , invoke = _dereq_(34) + , aFunction = _dereq_(3); +module.exports = function(/* ...pargs */){ + var fn = aFunction(this) + , length = arguments.length + , pargs = Array(length) + , i = 0 + , _ = path._ + , holder = false; + while(length > i)if((pargs[i] = arguments[i++]) === _)holder = true; + return function(/* ...args */){ + var that = this + , $$ = arguments + , $$len = $$.length + , j = 0, k = 0, args; + if(!holder && !$$len)return invoke(fn, pargs, that); + args = pargs.slice(); + if(holder)for(;length > j; j++)if(args[j] === _)args[j] = $$[k++]; + while($$len > k)args.push($$[k++]); + return invoke(fn, args, that); + }; +}; +},{"3":3,"34":34,"60":60}],60:[function(_dereq_,module,exports){ +module.exports = _dereq_(30); +},{"30":30}],61:[function(_dereq_,module,exports){ +module.exports = function(bitmap, value){ + return { + enumerable : !(bitmap & 1), + configurable: !(bitmap & 2), + writable : !(bitmap & 4), + value : value + }; +}; +},{}],62:[function(_dereq_,module,exports){ +// add fake Function#toString +// for correct work wrapped methods / constructors with methods like LoDash isNative +var global = _dereq_(30) + , hide = _dereq_(32) + , SRC = _dereq_(83)('src') + , TO_STRING = 'toString' + , $toString = Function[TO_STRING] + , TPL = ('' + $toString).split(TO_STRING); + +_dereq_(17).inspectSource = function(it){ + return $toString.call(it); +}; + +(module.exports = function(O, key, val, safe){ + if(typeof val == 'function'){ + val.hasOwnProperty(SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); + val.hasOwnProperty('name') || hide(val, 'name', key); + } + if(O === global){ + O[key] = val; + } else { + if(!safe)delete O[key]; + hide(O, key, val); + } +})(Function.prototype, TO_STRING, function toString(){ + return typeof this == 'function' && this[SRC] || $toString.call(this); +}); +},{"17":17,"30":30,"32":32,"83":83}],63:[function(_dereq_,module,exports){ +module.exports = function(regExp, replace){ + var replacer = replace === Object(replace) ? function(part){ + return replace[part]; + } : replace; + return function(it){ + return String(it).replace(regExp, replacer); + }; +}; +},{}],64:[function(_dereq_,module,exports){ +// 7.2.9 SameValue(x, y) +module.exports = Object.is || function is(x, y){ + return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; +}; +},{}],65:[function(_dereq_,module,exports){ +// Works with __proto__ only. Old v8 can't work with null proto objects. +/* eslint-disable no-proto */ +var getDesc = _dereq_(47).getDesc + , isObject = _dereq_(39) + , anObject = _dereq_(5); +var check = function(O, proto){ + anObject(O); + if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!"); +}; +module.exports = { + set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line + function(test, buggy, set){ + try { + set = _dereq_(18)(Function.call, getDesc(Object.prototype, '__proto__').set, 2); + set(test, []); + buggy = !(test instanceof Array); + } catch(e){ buggy = true; } + return function setPrototypeOf(O, proto){ + check(O, proto); + if(buggy)O.__proto__ = proto; + else set(O, proto); + return O; + }; + }({}, false) : undefined), + check: check +}; +},{"18":18,"39":39,"47":47,"5":5}],66:[function(_dereq_,module,exports){ +'use strict'; +var global = _dereq_(30) + , $ = _dereq_(47) + , DESCRIPTORS = _dereq_(21) + , SPECIES = _dereq_(84)('species'); + +module.exports = function(KEY){ + var C = global[KEY]; + if(DESCRIPTORS && C && !C[SPECIES])$.setDesc(C, SPECIES, { + configurable: true, + get: function(){ return this; } + }); +}; +},{"21":21,"30":30,"47":47,"84":84}],67:[function(_dereq_,module,exports){ +var def = _dereq_(47).setDesc + , has = _dereq_(31) + , TAG = _dereq_(84)('toStringTag'); + +module.exports = function(it, tag, stat){ + if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag}); +}; +},{"31":31,"47":47,"84":84}],68:[function(_dereq_,module,exports){ +var global = _dereq_(30) + , SHARED = '__core-js_shared__' + , store = global[SHARED] || (global[SHARED] = {}); +module.exports = function(key){ + return store[key] || (store[key] = {}); +}; +},{"30":30}],69:[function(_dereq_,module,exports){ +// 7.3.20 SpeciesConstructor(O, defaultConstructor) +var anObject = _dereq_(5) + , aFunction = _dereq_(3) + , SPECIES = _dereq_(84)('species'); +module.exports = function(O, D){ + var C = anObject(O).constructor, S; + return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S); +}; +},{"3":3,"5":5,"84":84}],70:[function(_dereq_,module,exports){ +module.exports = function(it, Constructor, name){ + if(!(it instanceof Constructor))throw TypeError(name + ": use the 'new' operator!"); + return it; +}; +},{}],71:[function(_dereq_,module,exports){ +var toInteger = _dereq_(78) + , defined = _dereq_(20); +// true -> String#at +// false -> String#codePointAt +module.exports = function(TO_STRING){ + return function(that, pos){ + var s = String(defined(that)) + , i = toInteger(pos) + , l = s.length + , a, b; + if(i < 0 || i >= l)return TO_STRING ? '' : undefined; + a = s.charCodeAt(i); + return a < 0xd800 || a > 0xdbff || i + 1 === l + || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff + ? TO_STRING ? s.charAt(i) : a + : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; + }; +}; +},{"20":20,"78":78}],72:[function(_dereq_,module,exports){ +// helper for String#{startsWith, endsWith, includes} +var isRegExp = _dereq_(40) + , defined = _dereq_(20); + +module.exports = function(that, searchString, NAME){ + if(isRegExp(searchString))throw TypeError('String#' + NAME + " doesn't accept regex!"); + return String(defined(that)); +}; +},{"20":20,"40":40}],73:[function(_dereq_,module,exports){ +// https://github.com/ljharb/proposal-string-pad-left-right +var toLength = _dereq_(80) + , repeat = _dereq_(74) + , defined = _dereq_(20); + +module.exports = function(that, maxLength, fillString, left){ + var S = String(defined(that)) + , stringLength = S.length + , fillStr = fillString === undefined ? ' ' : String(fillString) + , intMaxLength = toLength(maxLength); + if(intMaxLength <= stringLength)return S; + if(fillStr == '')fillStr = ' '; + var fillLen = intMaxLength - stringLength + , stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length)); + if(stringFiller.length > fillLen)stringFiller = stringFiller.slice(0, fillLen); + return left ? stringFiller + S : S + stringFiller; +}; +},{"20":20,"74":74,"80":80}],74:[function(_dereq_,module,exports){ +'use strict'; +var toInteger = _dereq_(78) + , defined = _dereq_(20); + +module.exports = function repeat(count){ + var str = String(defined(this)) + , res = '' + , n = toInteger(count); + if(n < 0 || n == Infinity)throw RangeError("Count can't be negative"); + for(;n > 0; (n >>>= 1) && (str += str))if(n & 1)res += str; + return res; +}; +},{"20":20,"78":78}],75:[function(_dereq_,module,exports){ +var $def = _dereq_(19) + , defined = _dereq_(20) + , fails = _dereq_(25) + , spaces = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF' + , space = '[' + spaces + ']' + , non = '\u200b\u0085' + , ltrim = RegExp('^' + space + space + '*') + , rtrim = RegExp(space + space + '*$'); + +var $export = function(KEY, exec){ + var exp = {}; + exp[KEY] = exec(trim); + $def($def.P + $def.F * fails(function(){ + return !!spaces[KEY]() || non[KEY]() != non; + }), 'String', exp); +}; + +// 1 -> String#trimLeft +// 2 -> String#trimRight +// 3 -> String#trim +var trim = $export.trim = function(string, TYPE){ + string = String(defined(string)); + if(TYPE & 1)string = string.replace(ltrim, ''); + if(TYPE & 2)string = string.replace(rtrim, ''); + return string; +}; + +module.exports = $export; +},{"19":19,"20":20,"25":25}],76:[function(_dereq_,module,exports){ +'use strict'; +var ctx = _dereq_(18) + , invoke = _dereq_(34) + , html = _dereq_(33) + , cel = _dereq_(22) + , global = _dereq_(30) + , process = global.process + , setTask = global.setImmediate + , clearTask = global.clearImmediate + , MessageChannel = global.MessageChannel + , counter = 0 + , queue = {} + , ONREADYSTATECHANGE = 'onreadystatechange' + , defer, channel, port; +var run = function(){ + var id = +this; + if(queue.hasOwnProperty(id)){ + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; +var listner = function(event){ + run.call(event.data); +}; +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if(!setTask || !clearTask){ + setTask = function setImmediate(fn){ + var args = [], i = 1; + while(arguments.length > i)args.push(arguments[i++]); + queue[++counter] = function(){ + invoke(typeof fn == 'function' ? fn : Function(fn), args); + }; + defer(counter); + return counter; + }; + clearTask = function clearImmediate(id){ + delete queue[id]; + }; + // Node.js 0.8- + if(_dereq_(12)(process) == 'process'){ + defer = function(id){ + process.nextTick(ctx(run, id, 1)); + }; + // Browsers with MessageChannel, includes WebWorkers + } else if(MessageChannel){ + channel = new MessageChannel; + port = channel.port2; + channel.port1.onmessage = listner; + defer = ctx(port.postMessage, port, 1); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){ + defer = function(id){ + global.postMessage(id + '', '*'); + }; + global.addEventListener('message', listner, false); + // IE8- + } else if(ONREADYSTATECHANGE in cel('script')){ + defer = function(id){ + html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){ + html.removeChild(this); + run.call(id); + }; + }; + // Rest old browsers + } else { + defer = function(id){ + setTimeout(ctx(run, id, 1), 0); + }; + } +} +module.exports = { + set: setTask, + clear: clearTask +}; +},{"12":12,"18":18,"22":22,"30":30,"33":33,"34":34}],77:[function(_dereq_,module,exports){ +var toInteger = _dereq_(78) + , max = Math.max + , min = Math.min; +module.exports = function(index, length){ + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); +}; +},{"78":78}],78:[function(_dereq_,module,exports){ +// 7.1.4 ToInteger +var ceil = Math.ceil + , floor = Math.floor; +module.exports = function(it){ + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); +}; +},{}],79:[function(_dereq_,module,exports){ +// to indexed object, toObject with fallback for non-array-like ES3 strings +var IObject = _dereq_(35) + , defined = _dereq_(20); +module.exports = function(it){ + return IObject(defined(it)); +}; +},{"20":20,"35":35}],80:[function(_dereq_,module,exports){ +// 7.1.15 ToLength +var toInteger = _dereq_(78) + , min = Math.min; +module.exports = function(it){ + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 +}; +},{"78":78}],81:[function(_dereq_,module,exports){ +// 7.1.13 ToObject(argument) +var defined = _dereq_(20); +module.exports = function(it){ + return Object(defined(it)); +}; +},{"20":20}],82:[function(_dereq_,module,exports){ +// 7.1.1 ToPrimitive(input [, PreferredType]) +var isObject = _dereq_(39); +// instead of the ES6 spec version, we didn't implement @@toPrimitive case +// and the second argument - flag - preferred type is a string +module.exports = function(it, S){ + if(!isObject(it))return it; + var fn, val; + if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val; + if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + throw TypeError("Can't convert object to primitive value"); +}; +},{"39":39}],83:[function(_dereq_,module,exports){ +var id = 0 + , px = Math.random(); +module.exports = function(key){ + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); +}; +},{}],84:[function(_dereq_,module,exports){ +var store = _dereq_(68)('wks') + , uid = _dereq_(83) + , Symbol = _dereq_(30).Symbol; +module.exports = function(name){ + return store[name] || (store[name] = + Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name)); +}; +},{"30":30,"68":68,"83":83}],85:[function(_dereq_,module,exports){ +var classof = _dereq_(11) + , ITERATOR = _dereq_(84)('iterator') + , Iterators = _dereq_(46); +module.exports = _dereq_(17).getIteratorMethod = function(it){ + if(it != undefined)return it[ITERATOR] + || it['@@iterator'] + || Iterators[classof(it)]; +}; +},{"11":11,"17":17,"46":46,"84":84}],86:[function(_dereq_,module,exports){ +'use strict'; +var $ = _dereq_(47) + , DESCRIPTORS = _dereq_(21) + , createDesc = _dereq_(61) + , html = _dereq_(33) + , cel = _dereq_(22) + , has = _dereq_(31) + , cof = _dereq_(12) + , $def = _dereq_(19) + , invoke = _dereq_(34) + , arrayMethod = _dereq_(9) + , IE_PROTO = _dereq_(83)('__proto__') + , isObject = _dereq_(39) + , anObject = _dereq_(5) + , aFunction = _dereq_(3) + , toObject = _dereq_(81) + , toIObject = _dereq_(79) + , toInteger = _dereq_(78) + , toIndex = _dereq_(77) + , toLength = _dereq_(80) + , IObject = _dereq_(35) + , fails = _dereq_(25) + , ObjectProto = Object.prototype + , A = [] + , _slice = A.slice + , _join = A.join + , defineProperty = $.setDesc + , getOwnDescriptor = $.getDesc + , defineProperties = $.setDescs + , $indexOf = _dereq_(8)(false) + , factories = {} + , IE8_DOM_DEFINE; + +if(!DESCRIPTORS){ + IE8_DOM_DEFINE = !fails(function(){ + return defineProperty(cel('div'), 'a', {get: function(){ return 7; }}).a != 7; + }); + $.setDesc = function(O, P, Attributes){ + if(IE8_DOM_DEFINE)try { + return defineProperty(O, P, Attributes); + } catch(e){ /* empty */ } + if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!'); + if('value' in Attributes)anObject(O)[P] = Attributes.value; + return O; + }; + $.getDesc = function(O, P){ + if(IE8_DOM_DEFINE)try { + return getOwnDescriptor(O, P); + } catch(e){ /* empty */ } + if(has(O, P))return createDesc(!ObjectProto.propertyIsEnumerable.call(O, P), O[P]); + }; + $.setDescs = defineProperties = function(O, Properties){ + anObject(O); + var keys = $.getKeys(Properties) + , length = keys.length + , i = 0 + , P; + while(length > i)$.setDesc(O, P = keys[i++], Properties[P]); + return O; + }; +} +$def($def.S + $def.F * !DESCRIPTORS, 'Object', { + // 19.1.2.6 / 15.2.3.3 Object.getOwnPropertyDescriptor(O, P) + getOwnPropertyDescriptor: $.getDesc, + // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) + defineProperty: $.setDesc, + // 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties) + defineProperties: defineProperties +}); + + // IE 8- don't enum bug keys +var keys1 = ('constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,' + + 'toLocaleString,toString,valueOf').split(',') + // Additional keys for getOwnPropertyNames + , keys2 = keys1.concat('length', 'prototype') + , keysLen1 = keys1.length; + +// Create object with `null` prototype: use iframe Object with cleared prototype +var createDict = function(){ + // Thrash, waste and sodomy: IE GC bug + var iframe = cel('iframe') + , i = keysLen1 + , gt = '>' + , iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + iframe.src = 'javascript:'; // eslint-disable-line no-script-url + // createDict = iframe.contentWindow.Object; + // html.removeChild(iframe); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write('