From 0bfbe973448c96f05e12df90108f6ab8f0701689 Mon Sep 17 00:00:00 2001 From: Bala Clark Date: Wed, 15 Jul 2015 09:10:09 +0200 Subject: [PATCH] basic image preloading --- app/comic-book.js | 40 +- dist/comicbook.js | 7943 +++++++++++++++++++++++++------------ dist/comicbook.js.map | 202 +- dist/comicbook.min.js | 9 +- dist/comicbook.min.js.map | 2 +- npm-shrinkwrap.json | 2 +- package.json | 10 +- test/comic-book.test.js | 48 + 8 files changed, 5713 insertions(+), 2543 deletions(-) create mode 100644 test/comic-book.test.js diff --git a/app/comic-book.js b/app/comic-book.js index 25dbd8d..8e1e77c 100644 --- a/app/comic-book.js +++ b/app/comic-book.js @@ -1,11 +1,39 @@ -module.exports = ComicBook +let EventEmitter = require('events').EventEmitter +let LoadIndicator = require('./view/load-indicator') -let loadIndicator = require('./view/load-indicator') +module.exports = class ComicBook extends EventEmitter { -function ComicBook () { - return { - replace (selector) { - console.log(selector, loadIndicator()) + constructor (srcs) { + super() + + // requested image srcs + this.srcs = new Set(srcs) + + // loaded image objects + this.pages = new Map() + + this.loadIndicator = new LoadIndicator() + } + + preload () { + this.emit('preload:start') + this.srcs.forEach(loadImage.bind(this)) + } +} + +function loadImage (src, pageIndex) { + let self = this + let image = new window.Image() + + image.src = src + image.onload = setImage + + function setImage () { + self.pages.set(pageIndex, this) + self.emit('preload:image', this) + + if (self.pages.size === self.srcs.size) { + self.emit('preload:finish') } } } diff --git a/dist/comicbook.js b/dist/comicbook.js index 3a64328..b59efdf 100644 --- a/dist/comicbook.js +++ b/dist/comicbook.js @@ -1,27 +1,68 @@ -(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.0.0-beta.1"],"main":function(depth0,helpers,partials,data) { - return "\"use strict\";\n
\n"; + return "
\n"; },"useData":true}); -},{"handlebars/runtime":13}],5:[function(require,module,exports){ +},{"handlebars/runtime":105}],5:[function(require,module,exports){ +(function (global){ +"use strict"; + +var _toolsProtectJs2 = require("./tools/protect.js"); + +var _toolsProtectJs3 = _interopRequireDefault(_toolsProtectJs2); + +require("core-js/shim"); + +require("regenerator/runtime"); + +_toolsProtectJs3["default"](module); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +if (global._babelPolyfill) { + throw new Error("only one instance of babel/polyfill is allowed"); +} +global._babelPolyfill = true; +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"./tools/protect.js":6,"core-js/shim":96,"regenerator/runtime":109}],6:[function(require,module,exports){ +(function (__dirname){ +"use strict"; + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var _path = require("path"); + +var _path2 = _interopRequireDefault(_path); + +var root = _path2["default"].resolve(__dirname, "../../../"); + +/** + * Protect Babel internals from being hotlinked by other tools. + * Sorry, not sorry. + */ + +exports["default"] = function (module) { + if (module.parent && module.parent.filename.indexOf(root) !== 0) { + throw new Error("Don't hotlink internal Babel files."); + } +}; + +module.exports = exports["default"]; +}).call(this,"/node_modules/babel-core/lib/babel/tools") + +},{"path":107}],7:[function(require,module,exports){ +module.exports = require("./lib/babel/polyfill"); + +},{"./lib/babel/polyfill":5}],8:[function(require,module,exports){ +// false -> Array#indexOf +// true -> Array#includes +var $ = require('./$'); +module.exports = function(IS_INCLUDES){ + return function($this, el, fromIndex){ + var O = $.toObject($this) + , length = $.toLength(O.length) + , index = $.toIndex(fromIndex, length) + , value; + if(IS_INCLUDES && el != el)while(length > index){ + value = O[index++]; + if(value != value)return true; + } else for(;length > index; index++)if(IS_INCLUDES || index in O){ + if(O[index] === el)return IS_INCLUDES || index; + } return !IS_INCLUDES && -1; + }; +}; +},{"./$":29}],9:[function(require,module,exports){ +// 0 -> Array#forEach +// 1 -> Array#map +// 2 -> Array#filter +// 3 -> Array#some +// 4 -> Array#every +// 5 -> Array#find +// 6 -> Array#findIndex +var $ = require('./$') + , ctx = require('./$.ctx'); +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 = Object($.assertDefined($this)) + , self = $.ES5Object(O) + , f = ctx(callbackfn, that, 3) + , length = $.toLength(self.length) + , index = 0 + , result = IS_MAP ? Array(length) : IS_FILTER ? [] : 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; + }; +}; +},{"./$":29,"./$.ctx":17}],10:[function(require,module,exports){ +var $ = require('./$'); +function assert(condition, msg1, msg2){ + if(!condition)throw TypeError(msg2 ? msg1 + msg2 : msg1); +} +assert.def = $.assertDefined; +assert.fn = function(it){ + if(!$.isFunction(it))throw TypeError(it + ' is not a function!'); + return it; +}; +assert.obj = function(it){ + if(!$.isObject(it))throw TypeError(it + ' is not an object!'); + return it; +}; +assert.inst = function(it, Constructor, name){ + if(!(it instanceof Constructor))throw TypeError(name + ": use the 'new' operator!"); + return it; +}; +module.exports = assert; +},{"./$":29}],11:[function(require,module,exports){ +var $ = require('./$') + , enumKeys = require('./$.enum-keys'); +// 19.1.2.1 Object.assign(target, source, ...) +/* eslint-disable no-unused-vars */ +module.exports = Object.assign || function assign(target, source){ +/* eslint-enable no-unused-vars */ + var T = Object($.assertDefined(target)) + , l = arguments.length + , i = 1; + while(l > i){ + var S = $.ES5Object(arguments[i++]) + , keys = enumKeys(S) + , length = keys.length + , j = 0 + , key; + while(length > j)T[key = keys[j++]] = S[key]; + } + return T; +}; +},{"./$":29,"./$.enum-keys":20}],12:[function(require,module,exports){ +var $ = require('./$') + , TAG = require('./$.wks')('toStringTag') + , toString = {}.toString; +function cof(it){ + return toString.call(it).slice(8, -1); +} +cof.classof = function(it){ + var O, T; + return it == undefined ? it === undefined ? 'Undefined' : 'Null' + : typeof (T = (O = Object(it))[TAG]) == 'string' ? T : cof(O); +}; +cof.set = function(it, tag, stat){ + if(it && !$.has(it = stat ? it : it.prototype, TAG))$.hide(it, TAG, tag); +}; +module.exports = cof; +},{"./$":29,"./$.wks":47}],13:[function(require,module,exports){ +'use strict'; +var $ = require('./$') + , ctx = require('./$.ctx') + , safe = require('./$.uid').safe + , assert = require('./$.assert') + , forOf = require('./$.for-of') + , step = require('./$.iter').step + , $has = $.has + , set = $.set + , isObject = $.isObject + , hide = $.hide + , isExtensible = Object.isExtensible || isObject + , ID = safe('id') + , O1 = safe('O1') + , LAST = safe('last') + , FIRST = safe('first') + , ITER = safe('iter') + , SIZE = $.DESC ? safe('size') : 'size' + , id = 0; + +function fastKey(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]; +} + +function getEntry(that, key){ + // fast case + var index = fastKey(key), entry; + if(index !== 'F')return that[O1][index]; + // frozen object case + for(entry = that[FIRST]; 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){ + assert.inst(that, C, NAME); + set(that, O1, $.create(null)); + set(that, SIZE, 0); + set(that, LAST, undefined); + set(that, FIRST, undefined); + if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); + }); + require('./$.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[O1], entry = that[FIRST]; entry; entry = entry.n){ + entry.r = true; + if(entry.p)entry.p = entry.p.n = undefined; + delete data[entry.i]; + } + that[FIRST] = that[LAST] = 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[O1][entry.i]; + entry.r = true; + if(prev)prev.n = next; + if(next)next.p = prev; + if(that[FIRST] == entry)that[FIRST] = next; + if(that[LAST] == entry)that[LAST] = 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[1], 3) + , entry; + while(entry = entry ? entry.n : this[FIRST]){ + 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($.DESC)$.setDesc(C.prototype, 'size', { + get: function(){ + return assert.def(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[LAST] = entry = { + i: index = fastKey(key, true), // <- index + k: key, // <- key + v: value, // <- value + p: prev = that[LAST], // <- previous entry + n: undefined, // <- next entry + r: false // <- removed + }; + if(!that[FIRST])that[FIRST] = entry; + if(prev)prev.n = entry; + that[SIZE]++; + // add to index + if(index !== 'F')that[O1][index] = entry; + } return that; + }, + getEntry: getEntry, + // 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 + setIter: function(C, NAME, IS_MAP){ + require('./$.iter-define')(C, NAME, function(iterated, kind){ + set(this, ITER, {o: iterated, k: kind}); + }, function(){ + var iter = this[ITER] + , kind = iter.k + , entry = iter.l; + // revert to the last existing entry + while(entry && entry.r)entry = entry.p; + // get next entry + if(!iter.o || !(iter.l = entry = entry ? entry.n : iter.o[FIRST])){ + // or finish the iteration + iter.o = 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); + } +}; +},{"./$":29,"./$.assert":10,"./$.ctx":17,"./$.for-of":21,"./$.iter":28,"./$.iter-define":26,"./$.mix":31,"./$.uid":45}],14:[function(require,module,exports){ +// https://github.com/DavidBruant/Map-Set.prototype.toJSON +var $def = require('./$.def') + , forOf = require('./$.for-of'); +module.exports = function(NAME){ + $def($def.P, NAME, { + toJSON: function toJSON(){ + var arr = []; + forOf(this, false, arr.push, arr); + return arr; + } + }); +}; +},{"./$.def":18,"./$.for-of":21}],15:[function(require,module,exports){ +'use strict'; +var $ = require('./$') + , safe = require('./$.uid').safe + , assert = require('./$.assert') + , forOf = require('./$.for-of') + , $has = $.has + , isObject = $.isObject + , hide = $.hide + , isExtensible = Object.isExtensible || isObject + , id = 0 + , ID = safe('id') + , WEAK = safe('weak') + , LEAK = safe('leak') + , method = require('./$.array-methods') + , find = method(5) + , findIndex = method(6); +function findFrozen(store, key){ + return find(store.array, function(it){ + return it[0] === key; + }); +} +// fallback for frozen keys +function leakStore(that){ + return that[LEAK] || hide(that, LEAK, { + array: [], + 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.array.push([key, value]); + }, + 'delete': function(key){ + var index = findIndex(this.array, function(it){ + return it[0] === key; + }); + if(~index)this.array.splice(index, 1); + return !!~index; + } + })[LEAK]; +} + +module.exports = { + getConstructor: function(wrapper, NAME, IS_MAP, ADDER){ + var C = wrapper(function(that, iterable){ + $.set(assert.inst(that, C, NAME), ID, id++); + if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); + }); + require('./$.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 leakStore(this)['delete'](key); + return $has(key, WEAK) && $has(key[WEAK], this[ID]) && delete key[WEAK][this[ID]]; + }, + // 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 leakStore(this).has(key); + return $has(key, WEAK) && $has(key[WEAK], this[ID]); + } + }); + return C; + }, + def: function(that, key, value){ + if(!isExtensible(assert.obj(key))){ + leakStore(that).set(key, value); + } else { + $has(key, WEAK) || hide(key, WEAK, {}); + key[WEAK][that[ID]] = value; + } return that; + }, + leakStore: leakStore, + WEAK: WEAK, + ID: ID +}; +},{"./$":29,"./$.array-methods":9,"./$.assert":10,"./$.for-of":21,"./$.mix":31,"./$.uid":45}],16:[function(require,module,exports){ +'use strict'; +var $ = require('./$') + , $def = require('./$.def') + , BUGGY = require('./$.iter').BUGGY + , forOf = require('./$.for-of') + , species = require('./$.species') + , assertInstance = require('./$.assert').inst; + +module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){ + var Base = $.g[NAME] + , C = Base + , ADDER = IS_MAP ? 'set' : 'add' + , proto = C && C.prototype + , O = {}; + function fixMethod(KEY){ + var fn = proto[KEY]; + require('./$.redef')(proto, KEY, + KEY == 'delete' ? function(a){ return fn.call(this, a === 0 ? 0 : a); } + : KEY == 'has' ? function has(a){ return fn.call(this, a === 0 ? 0 : a); } + : KEY == 'get' ? function get(a){ return 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(!$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)){ + // create collection constructor + C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER); + require('./$.mix')(C.prototype, methods); + } else { + var inst = new C + , chain = inst[ADDER](IS_WEAK ? {} : -0, 1) + , buggyZero; + // wrap for init collections from iterable + if(!require('./$.iter-detect')(function(iter){ new C(iter); })){ // eslint-disable-line no-new + C = wrapper(function(target, iterable){ + assertInstance(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 || inst.forEach(function(val, key){ + buggyZero = 1 / key === -Infinity; + }); + // fix converting -0 key to +0 + if(buggyZero){ + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + // + fix .add & .set for chaining + if(buggyZero || chain !== inst)fixMethod(ADDER); + } + + require('./$.cof').set(C, NAME); + + O[NAME] = C; + $def($def.G + $def.W + $def.F * (C != Base), O); + species(C); + species($.core[NAME]); // for wrapper + + if(!IS_WEAK)common.setIter(C, NAME, IS_MAP); + + return C; +}; +},{"./$":29,"./$.assert":10,"./$.cof":12,"./$.def":18,"./$.for-of":21,"./$.iter":28,"./$.iter-detect":27,"./$.mix":31,"./$.redef":34,"./$.species":39}],17:[function(require,module,exports){ +// Optional / simple context binding +var assertFunction = require('./$.assert').fn; +module.exports = function(fn, that, length){ + assertFunction(fn); + if(~length && 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); + }; +}; +},{"./$.assert":10}],18:[function(require,module,exports){ +var $ = require('./$') + , global = $.g + , core = $.core + , isFunction = $.isFunction + , $redef = require('./$.redef'); +function ctx(fn, that){ + return function(){ + return fn.apply(that, arguments); + }; +} +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 +function $def(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] || {}).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 && isFunction(out) ? 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; + } +} +module.exports = $def; +},{"./$":29,"./$.redef":34}],19:[function(require,module,exports){ +var $ = require('./$') + , document = $.g.document + , isObject = $.isObject + // in old IE typeof document.createElement is 'object' + , is = isObject(document) && isObject(document.createElement); +module.exports = function(it){ + return is ? document.createElement(it) : {}; +}; +},{"./$":29}],20:[function(require,module,exports){ +var $ = require('./$'); +module.exports = function(it){ + var keys = $.getKeys(it) + , getDesc = $.getDesc + , getSymbols = $.getSymbols; + if(getSymbols)$.each.call(getSymbols(it), function(key){ + if(getDesc(it, key).enumerable)keys.push(key); + }); + return keys; +}; +},{"./$":29}],21:[function(require,module,exports){ +var ctx = require('./$.ctx') + , get = require('./$.iter').get + , call = require('./$.iter-call'); +module.exports = function(iterable, entries, fn, that){ + var iterator = get(iterable) + , f = ctx(fn, that, entries ? 2 : 1) + , step; + while(!(step = iterator.next()).done){ + if(call(iterator, f, step.value, entries) === false){ + return call.close(iterator); + } + } +}; +},{"./$.ctx":17,"./$.iter":28,"./$.iter-call":25}],22:[function(require,module,exports){ +module.exports = function($){ + $.FW = true; + $.path = $.g; + return $; +}; +},{}],23:[function(require,module,exports){ +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +var $ = require('./$') + , toString = {}.toString + , getNames = $.getNames; + +var windowNames = typeof window == 'object' && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +function getWindowNames(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($.toObject(it)); +}; +},{"./$":29}],24:[function(require,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]); + case 5: return un ? fn(args[0], args[1], args[2], args[3], args[4]) + : fn.call(that, args[0], args[1], args[2], args[3], args[4]); + } return fn.apply(that, args); +}; +},{}],25:[function(require,module,exports){ +var assertObject = require('./$.assert').obj; +function close(iterator){ + var ret = iterator['return']; + if(ret !== undefined)assertObject(ret.call(iterator)); +} +function call(iterator, fn, value, entries){ + try { + return entries ? fn(assertObject(value)[0], value[1]) : fn(value); + } catch(e){ + close(iterator); + throw e; + } +} +call.close = close; +module.exports = call; +},{"./$.assert":10}],26:[function(require,module,exports){ +var $def = require('./$.def') + , $redef = require('./$.redef') + , $ = require('./$') + , cof = require('./$.cof') + , $iter = require('./$.iter') + , SYMBOL_ITERATOR = require('./$.wks')('iterator') + , FF_ITERATOR = '@@iterator' + , KEYS = 'keys' + , VALUES = 'values' + , Iterators = $iter.Iterators; +module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){ + $iter.create(Constructor, NAME, next); + function createMethod(kind){ + function $$(that){ + return new Constructor(that, kind); + } + switch(kind){ + case KEYS: return function keys(){ return $$(this); }; + case VALUES: return function values(){ return $$(this); }; + } return function entries(){ return $$(this); }; + } + var TAG = NAME + ' Iterator' + , proto = Base.prototype + , _native = proto[SYMBOL_ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT] + , _default = _native || createMethod(DEFAULT) + , methods, key; + // Fix native + if(_native){ + var IteratorPrototype = $.getProto(_default.call(new Base)); + // Set @@toStringTag to native iterators + cof.set(IteratorPrototype, TAG, true); + // FF fix + if($.FW && $.has(proto, FF_ITERATOR))$iter.set(IteratorPrototype, $.that); + } + // Define iterator + if($.FW || FORCE)$iter.set(proto, _default); + // Plug for library + Iterators[NAME] = _default; + Iterators[TAG] = $.that; + if(DEFAULT){ + methods = { + keys: IS_SET ? _default : createMethod(KEYS), + values: DEFAULT == VALUES ? _default : createMethod(VALUES), + entries: DEFAULT != VALUES ? _default : createMethod('entries') + }; + if(FORCE)for(key in methods){ + if(!(key in proto))$redef(proto, key, methods[key]); + } else $def($def.P + $def.F * $iter.BUGGY, NAME, methods); + } +}; +},{"./$":29,"./$.cof":12,"./$.def":18,"./$.iter":28,"./$.redef":34,"./$.wks":47}],27:[function(require,module,exports){ +var SYMBOL_ITERATOR = require('./$.wks')('iterator') + , SAFE_CLOSING = false; +try { + var riter = [7][SYMBOL_ITERATOR](); + riter['return'] = function(){ SAFE_CLOSING = true; }; + Array.from(riter, function(){ throw 2; }); +} catch(e){ /* empty */ } +module.exports = function(exec){ + if(!SAFE_CLOSING)return false; + var safe = false; + try { + var arr = [7] + , iter = arr[SYMBOL_ITERATOR](); + iter.next = function(){ safe = true; }; + arr[SYMBOL_ITERATOR] = function(){ return iter; }; + exec(arr); + } catch(e){ /* empty */ } + return safe; +}; +},{"./$.wks":47}],28:[function(require,module,exports){ +'use strict'; +var $ = require('./$') + , cof = require('./$.cof') + , classof = cof.classof + , assert = require('./$.assert') + , assertObject = assert.obj + , SYMBOL_ITERATOR = require('./$.wks')('iterator') + , FF_ITERATOR = '@@iterator' + , Iterators = require('./$.shared')('iterators') + , IteratorPrototype = {}; +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +setIterator(IteratorPrototype, $.that); +function setIterator(O, value){ + $.hide(O, SYMBOL_ITERATOR, value); + // Add iterator for FF iterator protocol + if(FF_ITERATOR in [])$.hide(O, FF_ITERATOR, value); +} + +module.exports = { + // Safari has buggy iterators w/o `next` + BUGGY: 'keys' in [] && !('next' in [].keys()), + Iterators: Iterators, + step: function(done, value){ + return {value: value, done: !!done}; + }, + is: function(it){ + var O = Object(it) + , Symbol = $.g.Symbol; + return (Symbol && Symbol.iterator || FF_ITERATOR) in O + || SYMBOL_ITERATOR in O + || $.has(Iterators, classof(O)); + }, + get: function(it){ + var Symbol = $.g.Symbol + , getIter; + if(it != undefined){ + getIter = it[Symbol && Symbol.iterator || FF_ITERATOR] + || it[SYMBOL_ITERATOR] + || Iterators[classof(it)]; + } + assert($.isFunction(getIter), it, ' is not iterable!'); + return assertObject(getIter.call(it)); + }, + set: setIterator, + create: function(Constructor, NAME, next, proto){ + Constructor.prototype = $.create(proto || IteratorPrototype, {next: $.desc(1, next)}); + cof.set(Constructor, NAME + ' Iterator'); + } +}; +},{"./$":29,"./$.assert":10,"./$.cof":12,"./$.shared":38,"./$.wks":47}],29:[function(require,module,exports){ +'use strict'; +var global = typeof self != 'undefined' ? self : Function('return this')() + , core = {} + , defineProperty = Object.defineProperty + , hasOwnProperty = {}.hasOwnProperty + , ceil = Math.ceil + , floor = Math.floor + , max = Math.max + , min = Math.min; +// The engine works fine with descriptors? Thank's IE8 for his funny defineProperty. +var DESC = !!function(){ + try { + return defineProperty({}, 'a', {get: function(){ return 2; }}).a == 2; + } catch(e){ /* empty */ } +}(); +var hide = createDefiner(1); +// 7.1.4 ToInteger +function toInteger(it){ + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); +} +function desc(bitmap, value){ + return { + enumerable : !(bitmap & 1), + configurable: !(bitmap & 2), + writable : !(bitmap & 4), + value : value + }; +} +function simpleSet(object, key, value){ + object[key] = value; + return object; +} +function createDefiner(bitmap){ + return DESC ? function(object, key, value){ + return $.setDesc(object, key, desc(bitmap, value)); + } : simpleSet; +} + +function isObject(it){ + return it !== null && (typeof it == 'object' || typeof it == 'function'); +} +function isFunction(it){ + return typeof it == 'function'; +} +function assertDefined(it){ + if(it == undefined)throw TypeError("Can't call method on " + it); + return it; +} + +var $ = module.exports = require('./$.fw')({ + g: global, + core: core, + html: global.document && document.documentElement, + // http://jsperf.com/core-js-isobject + isObject: isObject, + isFunction: isFunction, + that: function(){ + return this; + }, + // 7.1.4 ToInteger + toInteger: toInteger, + // 7.1.15 ToLength + toLength: function(it){ + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 + }, + toIndex: function(index, length){ + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }, + has: function(it, key){ + return hasOwnProperty.call(it, key); + }, + create: Object.create, + getProto: Object.getPrototypeOf, + DESC: DESC, + desc: desc, + getDesc: Object.getOwnPropertyDescriptor, + setDesc: defineProperty, + setDescs: Object.defineProperties, + getKeys: Object.keys, + getNames: Object.getOwnPropertyNames, + getSymbols: Object.getOwnPropertySymbols, + assertDefined: assertDefined, + // Dummy, fix for not array-like ES3 string in es5 module + ES5Object: Object, + toObject: function(it){ + return $.ES5Object(assertDefined(it)); + }, + hide: hide, + def: createDefiner(0), + set: global.Symbol ? simpleSet : hide, + each: [].forEach +}); +/* eslint-disable no-undef */ +if(typeof __e != 'undefined')__e = core; +if(typeof __g != 'undefined')__g = global; +},{"./$.fw":22}],30:[function(require,module,exports){ +var $ = require('./$'); +module.exports = function(object, el){ + var O = $.toObject(object) + , keys = $.getKeys(O) + , length = keys.length + , index = 0 + , key; + while(length > index)if(O[key = keys[index++]] === el)return key; +}; +},{"./$":29}],31:[function(require,module,exports){ +var $redef = require('./$.redef'); +module.exports = function(target, src){ + for(var key in src)$redef(target, key, src[key]); + return target; +}; +},{"./$.redef":34}],32:[function(require,module,exports){ +var $ = require('./$') + , assertObject = require('./$.assert').obj; +module.exports = function ownKeys(it){ + assertObject(it); + var keys = $.getNames(it) + , getSymbols = $.getSymbols; + return getSymbols ? keys.concat(getSymbols(it)) : keys; +}; +},{"./$":29,"./$.assert":10}],33:[function(require,module,exports){ +'use strict'; +var $ = require('./$') + , invoke = require('./$.invoke') + , assertFunction = require('./$.assert').fn; +module.exports = function(/* ...pargs */){ + var fn = assertFunction(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 + , _length = arguments.length + , j = 0, k = 0, args; + if(!holder && !_length)return invoke(fn, pargs, that); + args = pargs.slice(); + if(holder)for(;length > j; j++)if(args[j] === _)args[j] = arguments[k++]; + while(_length > k)args.push(arguments[k++]); + return invoke(fn, args, that); + }; +}; +},{"./$":29,"./$.assert":10,"./$.invoke":24}],34:[function(require,module,exports){ +var $ = require('./$') + , tpl = String({}.hasOwnProperty) + , SRC = require('./$.uid').safe('src') + , _toString = Function.toString; + +function $redef(O, key, val, safe){ + if($.isFunction(val)){ + var base = O[key]; + $.hide(val, SRC, base ? String(base) : tpl.replace(/hasOwnProperty/, String(key))); + if(!('name' in val))val.name = key; + } + if(O === $.g){ + O[key] = val; + } else { + if(!safe)delete O[key]; + $.hide(O, key, val); + } +} + +// add fake Function#toString for correct work wrapped methods / constructors +// with methods similar to LoDash isNative +$redef(Function.prototype, 'toString', function toString(){ + return $.has(this, SRC) ? this[SRC] : _toString.call(this); +}); + +$.core.inspectSource = function(it){ + return _toString.call(it); +}; + +module.exports = $redef; +},{"./$":29,"./$.uid":45}],35:[function(require,module,exports){ +'use strict'; +module.exports = function(regExp, replace, isStatic){ + var replacer = replace === Object(replace) ? function(part){ + return replace[part]; + } : replace; + return function(it){ + return String(isStatic ? it : this).replace(regExp, replacer); + }; +}; +},{}],36:[function(require,module,exports){ +module.exports = Object.is || function is(x, y){ + return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; +}; +},{}],37:[function(require,module,exports){ +// Works with __proto__ only. Old v8 can't work with null proto objects. +/* eslint-disable no-proto */ +var $ = require('./$') + , assert = require('./$.assert'); +function check(O, proto){ + assert.obj(O); + assert(proto === null || $.isObject(proto), proto, ": can't set as prototype!"); +} +module.exports = { + set: Object.setPrototypeOf || ('__proto__' in {} // eslint-disable-line + ? function(buggy, set){ + try { + set = require('./$.ctx')(Function.call, $.getDesc(Object.prototype, '__proto__').set, 2); + set({}, []); + } catch(e){ buggy = true; } + return function setPrototypeOf(O, proto){ + check(O, proto); + if(buggy)O.__proto__ = proto; + else set(O, proto); + return O; + }; + }() + : undefined), + check: check +}; +},{"./$":29,"./$.assert":10,"./$.ctx":17}],38:[function(require,module,exports){ +var $ = require('./$') + , SHARED = '__core-js_shared__' + , store = $.g[SHARED] || ($.g[SHARED] = {}); +module.exports = function(key){ + return store[key] || (store[key] = {}); +}; +},{"./$":29}],39:[function(require,module,exports){ +var $ = require('./$') + , SPECIES = require('./$.wks')('species'); +module.exports = function(C){ + if($.DESC && !(SPECIES in C))$.setDesc(C, SPECIES, { + configurable: true, + get: $.that + }); +}; +},{"./$":29,"./$.wks":47}],40:[function(require,module,exports){ +// true -> String#at +// false -> String#codePointAt +var $ = require('./$'); +module.exports = function(TO_STRING){ + return function(that, pos){ + var s = String($.assertDefined(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; + }; +}; +},{"./$":29}],41:[function(require,module,exports){ +// http://wiki.ecmascript.org/doku.php?id=strawman:string_padding +var $ = require('./$') + , repeat = require('./$.string-repeat'); + +module.exports = function(that, minLength, fillChar, left){ + // 1. Let O be CheckObjectCoercible(this value). + // 2. Let S be ToString(O). + var S = String($.assertDefined(that)); + // 4. If intMinLength is undefined, return S. + if(minLength === undefined)return S; + // 4. Let intMinLength be ToInteger(minLength). + var intMinLength = $.toInteger(minLength); + // 5. Let fillLen be the number of characters in S minus intMinLength. + var fillLen = intMinLength - S.length; + // 6. If fillLen < 0, then throw a RangeError exception. + // 7. If fillLen is +∞, then throw a RangeError exception. + if(fillLen < 0 || fillLen === Infinity){ + throw new RangeError('Cannot satisfy string length ' + minLength + ' for string: ' + S); + } + // 8. Let sFillStr be the string represented by fillStr. + // 9. If sFillStr is undefined, let sFillStr be a space character. + var sFillStr = fillChar === undefined ? ' ' : String(fillChar); + // 10. Let sFillVal be a String made of sFillStr, repeated until fillLen is met. + var sFillVal = repeat.call(sFillStr, Math.ceil(fillLen / sFillStr.length)); + // truncate if we overflowed + if(sFillVal.length > fillLen)sFillVal = left + ? sFillVal.slice(sFillVal.length - fillLen) + : sFillVal.slice(0, fillLen); + // 11. Return a string made from sFillVal, followed by S. + // 11. Return a String made from S, followed by sFillVal. + return left ? sFillVal.concat(S) : S.concat(sFillVal); +}; +},{"./$":29,"./$.string-repeat":42}],42:[function(require,module,exports){ +'use strict'; +var $ = require('./$'); + +module.exports = function repeat(count){ + var str = String($.assertDefined(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; +}; +},{"./$":29}],43:[function(require,module,exports){ +'use strict'; +var $ = require('./$') + , ctx = require('./$.ctx') + , cof = require('./$.cof') + , invoke = require('./$.invoke') + , cel = require('./$.dom-create') + , global = $.g + , isFunction = $.isFunction + , html = $.html + , process = global.process + , setTask = global.setImmediate + , clearTask = global.clearImmediate + , MessageChannel = global.MessageChannel + , counter = 0 + , queue = {} + , ONREADYSTATECHANGE = 'onreadystatechange' + , defer, channel, port; +function run(){ + var id = +this; + if($.has(queue, id)){ + var fn = queue[id]; + delete queue[id]; + fn(); + } +} +function listner(event){ + run.call(event.data); +} +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if(!isFunction(setTask) || !isFunction(clearTask)){ + setTask = function(fn){ + var args = [], i = 1; + while(arguments.length > i)args.push(arguments[i++]); + queue[++counter] = function(){ + invoke(isFunction(fn) ? fn : Function(fn), args); + }; + defer(counter); + return counter; + }; + clearTask = function(id){ + delete queue[id]; + }; + // Node.js 0.8- + if(cof(process) == 'process'){ + defer = function(id){ + process.nextTick(ctx(run, id, 1)); + }; + // Modern browsers, skip implementation for WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is object + } else if(global.addEventListener && isFunction(global.postMessage) && !global.importScripts){ + defer = function(id){ + global.postMessage(id, '*'); + }; + global.addEventListener('message', listner, false); + // WebWorkers + } else if(isFunction(MessageChannel)){ + channel = new MessageChannel; + port = channel.port2; + channel.port1.onmessage = listner; + defer = ctx(port.postMessage, port, 1); + // 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 +}; +},{"./$":29,"./$.cof":12,"./$.ctx":17,"./$.dom-create":19,"./$.invoke":24}],44:[function(require,module,exports){ +module.exports = function(exec){ + try { + exec(); + return false; + } catch(e){ + return true; + } +}; +},{}],45:[function(require,module,exports){ +var sid = 0; +function uid(key){ + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++sid + Math.random()).toString(36)); +} +uid.safe = require('./$').g.Symbol || uid; +module.exports = uid; +},{"./$":29}],46:[function(require,module,exports){ +// 22.1.3.31 Array.prototype[@@unscopables] +var UNSCOPABLES = require('./$.wks')('unscopables'); +if(!(UNSCOPABLES in []))require('./$').hide(Array.prototype, UNSCOPABLES, {}); +module.exports = function(key){ + [][UNSCOPABLES][key] = true; +}; +},{"./$":29,"./$.wks":47}],47:[function(require,module,exports){ +var global = require('./$').g + , store = require('./$.shared')('wks'); +module.exports = function(name){ + return store[name] || (store[name] = + global.Symbol && global.Symbol[name] || require('./$.uid').safe('Symbol.' + name)); +}; +},{"./$":29,"./$.shared":38,"./$.uid":45}],48:[function(require,module,exports){ +var $ = require('./$') + , cel = require('./$.dom-create') + , cof = require('./$.cof') + , $def = require('./$.def') + , invoke = require('./$.invoke') + , arrayMethod = require('./$.array-methods') + , IE_PROTO = require('./$.uid').safe('__proto__') + , assert = require('./$.assert') + , assertObject = assert.obj + , ObjectProto = Object.prototype + , html = $.html + , A = [] + , _slice = A.slice + , _join = A.join + , classof = cof.classof + , has = $.has + , defineProperty = $.setDesc + , getOwnDescriptor = $.getDesc + , defineProperties = $.setDescs + , isFunction = $.isFunction + , isObject = $.isObject + , toObject = $.toObject + , toLength = $.toLength + , toIndex = $.toIndex + , IE8_DOM_DEFINE = false + , $indexOf = require('./$.array-includes')(false) + , $forEach = arrayMethod(0) + , $map = arrayMethod(1) + , $filter = arrayMethod(2) + , $some = arrayMethod(3) + , $every = arrayMethod(4); + +if(!$.DESC){ + try { + IE8_DOM_DEFINE = defineProperty(cel('div'), 'x', + {get: function(){ return 8; }} + ).x == 8; + } catch(e){ /* empty */ } + $.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)assertObject(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 $.desc(!ObjectProto.propertyIsEnumerable.call(O, P), O[P]); + }; + $.setDescs = defineProperties = function(O, Properties){ + assertObject(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 * !$.DESC, '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('