Skip to content

Instantly share code, notes, and snippets.

@hden

hden/README.md

Created May 28, 2015 18:05
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save hden/e4e85e7f8ccef7799120 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save hden/e4e85e7f8ccef7799120 to your computer and use it in GitHub Desktop.
Download ZIP
reactive virtual DOM with coroutine
Raw
README.md

coroutine, channel, and virtual DOM element

This pattern is heavily inspired by golang concurrency patterns

  • each component runs within an individual coroutine
  • components communicate via channels
  • runloops are blocked until message, but the main loop remains free
/** @jsx element */
'use strict'

import co   from 'tj/co'
import make from 'brentburg/chan'
import { tree, render, element } from 'segmentio/deku'

let JustDiv = {
  propTypes: {
    chan: {
      type: 'function'
    }
  }
, initialState() {
    return { value: '' }
  }
, render({ state }) {
    return <div>{ state.value }</div>
  }
, afterMount({ props }, el, setState) {
    let { chan } = props
    // component runetime in a coroutine
    co(function* () {
      while (!chan.done()) {
        // blocked until message
        let value = yield chan
        if (value !== chan.empty) {
          setState({ value })
        }
      }
    })
  }
}

let JustInput = {
  propTypes: {
    chan: {
      type: 'function'
    }
  }
, render(component) {
    // component runtime
    let { props } = component
    let emit = () => {
      // send message via channel
      props.chan(component.getValue())
    }
    return <input type="text" onInput={emit}></input>
  }
, afterMount(component, el) {
    component.getValue = () => {
      return el.value
    }
  }
}

// main runloop
let chan = make()
let app = tree(<div><JustDiv chan={chan}></JustDiv><JustInput chan={chan}></JustInput></div>)
render(app, document.body)
Raw
browser-polyfill.js
(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<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
(function (global){
"use strict";
require("core-js/shim");
require("regenerator/runtime");
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 : {})
},{"core-js/shim":78,"regenerator/runtime":79}],2:[function(require,module,exports){
'use strict';
// false -> Array#indexOf
// true -> Array#includes
var $ = require('./$');
module.exports = function(IS_INCLUDES){
return function(el /*, fromIndex = 0 */){
var O = $.toObject(this)
, length = $.toLength(O.length)
, index = $.toIndex(arguments[1], 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;
};
};
},{"./$":21}],3:[function(require,module,exports){
'use strict';
// 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(callbackfn/*, that = undefined */){
var O = Object($.assertDefined(this))
, self = $.ES5Object(O)
, f = ctx(callbackfn, arguments[1], 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;
};
};
},{"./$":21,"./$.ctx":11}],4:[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;
},{"./$":21}],5:[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;
};
},{"./$":21,"./$.enum-keys":13}],6:[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;
},{"./$":21,"./$.wks":32}],7:[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
, isFrozen = Object.isFrozen || $.core.Object.isFrozen
, 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 == 'string' ? 'S' : 'P') + it;
// can't set id to frozen object
if(isFrozen(it))return 'F';
if(!has(it, ID)){
// 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(NAME, IS_MAP, ADDER){
function C(){
var that = assert.inst(this, C, NAME)
, iterable = arguments[0];
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);
}
$.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);
}
};
},{"./$":21,"./$.assert":4,"./$.ctx":11,"./$.for-of":14,"./$.iter":20,"./$.iter-define":18,"./$.uid":30}],8:[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":12,"./$.for-of":14}],9:[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
, isFrozen = Object.isFrozen || $.core.Object.isFrozen
, 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.call(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.call(this.array, function(it){
return it[0] === key;
});
if(~index)this.array.splice(index, 1);
return !!~index;
}
})[LEAK];
}
module.exports = {
getConstructor: function(NAME, IS_MAP, ADDER){
function C(){
$.set(assert.inst(this, C, NAME), ID, id++);
var iterable = arguments[0];
if(iterable != undefined)forOf(iterable, IS_MAP, this[ADDER], this);
}
$.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(isFrozen(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(isFrozen(key))return leakStore(this).has(key);
return _has(key, WEAK) && _has(key[WEAK], this[ID]);
}
});
return C;
},
def: function(that, key, value){
if(isFrozen(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
};
},{"./$":21,"./$.array-methods":3,"./$.assert":4,"./$.for-of":14,"./$.uid":30}],10:[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, 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, CHAIN){
var method = proto[KEY];
if($.FW)proto[KEY] = function(a, b){
var result = method.call(this, a === 0 ? 0 : a, b);
return CHAIN ? this : result;
};
}
if(!$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)){
// create collection constructor
C = common.getConstructor(NAME, IS_MAP, ADDER);
$.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 = function(){
assertInstance(this, C, NAME);
var that = new Base
, iterable = arguments[0];
if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
return that;
};
C.prototype = proto;
if($.FW)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, true);
}
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;
};
},{"./$":21,"./$.assert":4,"./$.cof":6,"./$.def":12,"./$.for-of":14,"./$.iter":20,"./$.iter-detect":19,"./$.species":27}],11:[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":4}],12:[function(require,module,exports){
var $ = require('./$')
, global = $.g
, core = $.core
, isFunction = $.isFunction;
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
, 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 = type & $def.P && isFunction(out) ? ctx(Function.call, out) : out;
// extend global
if(target && !own){
if(isGlobal)target[key] = out;
else delete target[key] && $.hide(target, key, out);
}
// export
if(exports[key] != out)$.hide(exports, key, exp);
}
}
module.exports = $def;
},{"./$":21}],13:[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;
};
},{"./$":21}],14:[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":11,"./$.iter":20,"./$.iter-call":17}],15:[function(require,module,exports){
module.exports = function($){
$.FW = true;
$.path = $.g;
return $;
};
},{}],16:[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);
};
},{}],17:[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":4}],18:[function(require,module,exports){
var $def = require('./$.def')
, $ = require('./$')
, cof = require('./$.cof')
, $iter = require('./$.iter')
, SYMBOL_ITERATOR = require('./$.wks')('iterator')
, FF_ITERATOR = '@@iterator'
, VALUES = 'values'
, Iterators = $iter.Iterators;
module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){
$iter.create(Constructor, NAME, next);
function createMethod(kind){
return function(){
return new Constructor(this, kind);
};
}
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)$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))$.hide(proto, key, methods[key]);
} else $def($def.P + $def.F * $iter.BUGGY, NAME, methods);
}
};
},{"./$":21,"./$.cof":6,"./$.def":12,"./$.iter":20,"./$.wks":32}],19:[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":32}],20:[function(require,module,exports){
'use strict';
var $ = require('./$')
, cof = require('./$.cof')
, assertObject = require('./$.assert').obj
, SYMBOL_ITERATOR = require('./$.wks')('iterator')
, FF_ITERATOR = '@@iterator'
, 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
, SYM = Symbol && Symbol.iterator || FF_ITERATOR;
return SYM in O || SYMBOL_ITERATOR in O || $.has(Iterators, cof.classof(O));
},
get: function(it){
var Symbol = $.g.Symbol
, ext = it[Symbol && Symbol.iterator || FF_ITERATOR]
, getIter = ext || it[SYMBOL_ITERATOR] || Iterators[cof.classof(it)];
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');
}
};
},{"./$":21,"./$.assert":4,"./$.cof":6,"./$.wks":32}],21:[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,
it: function(it){
return it;
},
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,
mix: function(target, src){
for(var key in src)hide(target, key, src[key]);
return target;
},
each: [].forEach
});
/* eslint-disable no-undef */
if(typeof __e != 'undefined')__e = core;
if(typeof __g != 'undefined')__g = global;
},{"./$.fw":15}],22:[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;
};
},{"./$":21}],23:[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;
};
},{"./$":21,"./$.assert":4}],24:[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);
};
};
},{"./$":21,"./$.assert":4,"./$.invoke":16}],25:[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);
};
};
},{}],26:[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
};
},{"./$":21,"./$.assert":4,"./$.ctx":11}],27:[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
});
};
},{"./$":21,"./$.wks":32}],28:[function(require,module,exports){
'use strict';
// true -> String#at
// false -> String#codePointAt
var $ = require('./$');
module.exports = function(TO_STRING){
return function(pos){
var s = String($.assertDefined(this))
, 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;
};
};
},{"./$":21}],29:[function(require,module,exports){
'use strict';
var $ = require('./$')
, ctx = require('./$.ctx')
, cof = require('./$.cof')
, invoke = require('./$.invoke')
, global = $.g
, isFunction = $.isFunction
, html = $.html
, document = global.document
, process = global.process
, setTask = global.setImmediate
, clearTask = global.clearImmediate
, postMessage = global.postMessage
, addEventListener = global.addEventListener
, 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(addEventListener && isFunction(postMessage) && !global.importScripts){
defer = function(id){
postMessage(id, '*');
};
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(document && ONREADYSTATECHANGE in document.createElement('script')){
defer = function(id){
html.appendChild(document.createElement('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
};
},{"./$":21,"./$.cof":6,"./$.ctx":11,"./$.invoke":16}],30:[function(require,module,exports){
var sid = 0;
function uid(key){
return 'Symbol(' + key + ')_' + (++sid + Math.random()).toString(36);
}
uid.safe = require('./$').g.Symbol || uid;
module.exports = uid;
},{"./$":21}],31:[function(require,module,exports){
// 22.1.3.31 Array.prototype[@@unscopables]
var $ = require('./$')
, UNSCOPABLES = require('./$.wks')('unscopables');
if($.FW && !(UNSCOPABLES in []))$.hide(Array.prototype, UNSCOPABLES, {});
module.exports = function(key){
if($.FW)[][UNSCOPABLES][key] = true;
};
},{"./$":21,"./$.wks":32}],32:[function(require,module,exports){
var global = require('./$').g
, store = {};
module.exports = function(name){
return store[name] || (store[name] =
global.Symbol && global.Symbol[name] || require('./$.uid').safe('Symbol.' + name));
};
},{"./$":21,"./$.uid":30}],33:[function(require,module,exports){
var $ = require('./$')
, 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
, A = []
, slice = A.slice
, indexOf = A.indexOf
, classof = cof.classof
, has = $.has
, defineProperty = $.setDesc
, getOwnDescriptor = $.getDesc
, defineProperties = $.setDescs
, isFunction = $.isFunction
, toObject = $.toObject
, toLength = $.toLength
, IE8_DOM_DEFINE = false;
if(!$.DESC){
try {
IE8_DOM_DEFINE = defineProperty(document.createElement('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 = document.createElement('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('<script>document.F=Object</script' + gt);
iframeDocument.close();
createDict = iframeDocument.F;
while(i--)delete createDict.prototype[keys1[i]];
return createDict();
};
function createGetKeys(names, length){
return function(object){
var O = toObject(object)
, i = 0
, result = []
, key;
for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
// Don't enum bug & hidden keys
while(length > i)if(has(O, key = names[i++])){
~indexOf.call(result, key) || result.push(key);
}
return result;
};
}
function isPrimitive(it){ return !$.isObject(it); }
function Empty(){}
$def($def.S, 'Object', {
// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
getPrototypeOf: $.getProto = $.getProto || function(O){
O = Object(assert.def(O));
if(has(O, IE_PROTO))return O[IE_PROTO];
if(isFunction(O.constructor) && O instanceof O.constructor){
return O.constructor.prototype;
} return O instanceof Object ? ObjectProto : null;
},
// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
getOwnPropertyNames: $.getNames = $.getNames || createGetKeys(keys2, keys2.length, true),
// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
create: $.create = $.create || function(O, /*?*/Properties){
var result;
if(O !== null){
Empty.prototype = assertObject(O);
result = new Empty();
Empty.prototype = null;
// add "__proto__" for Object.getPrototypeOf shim
result[IE_PROTO] = O;
} else result = createDict();
return Properties === undefined ? result : defineProperties(result, Properties);
},
// 19.1.2.14 / 15.2.3.14 Object.keys(O)
keys: $.getKeys = $.getKeys || createGetKeys(keys1, keysLen1, false),
// 19.1.2.17 / 15.2.3.8 Object.seal(O)
seal: $.it, // <- cap
// 19.1.2.5 / 15.2.3.9 Object.freeze(O)
freeze: $.it, // <- cap
// 19.1.2.15 / 15.2.3.10 Object.preventExtensions(O)
preventExtensions: $.it, // <- cap
// 19.1.2.13 / 15.2.3.11 Object.isSealed(O)
isSealed: isPrimitive, // <- cap
// 19.1.2.12 / 15.2.3.12 Object.isFrozen(O)
isFrozen: isPrimitive, // <- cap
// 19.1.2.11 / 15.2.3.13 Object.isExtensible(O)
isExtensible: $.isObject // <- cap
});
// 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...)
$def($def.P, 'Function', {
bind: function(that /*, args... */){
var fn = assert.fn(this)
, partArgs = slice.call(arguments, 1);
function bound(/* args... */){
var args = partArgs.concat(slice.call(arguments));
return invoke(fn, args, this instanceof bound ? $.create(fn.prototype) : that);
}
if(fn.prototype)bound.prototype = fn.prototype;
return bound;
}
});
// Fix for not array-like ES3 string
function arrayMethodFix(fn){
return function(){
return fn.apply($.ES5Object(this), arguments);
};
}
if(!(0 in Object('z') && 'z'[0] == 'z')){
$.ES5Object = function(it){
return cof(it) == 'String' ? it.split('') : Object(it);
};
}
$def($def.P + $def.F * ($.ES5Object != Object), 'Array', {
slice: arrayMethodFix(slice),
join: arrayMethodFix(A.join)
});
// 22.1.2.2 / 15.4.3.2 Array.isArray(arg)
$def($def.S, 'Array', {
isArray: function(arg){
return cof(arg) == 'Array';
}
});
function createArrayReduce(isRight){
return function(callbackfn, memo){
assert.fn(callbackfn);
var O = toObject(this)
, length = toLength(O.length)
, index = isRight ? length - 1 : 0
, i = isRight ? -1 : 1;
if(arguments.length < 2)for(;;){
if(index in O){
memo = O[index];
index += i;
break;
}
index += i;
assert(isRight ? index >= 0 : length > index, 'Reduce of empty array with no initial value');
}
for(;isRight ? index >= 0 : length > index; index += i)if(index in O){
memo = callbackfn(memo, O[index], index, this);
}
return memo;
};
}
$def($def.P, 'Array', {
// 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])
forEach: $.each = $.each || arrayMethod(0),
// 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])
map: arrayMethod(1),
// 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])
filter: arrayMethod(2),
// 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])
some: arrayMethod(3),
// 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])
every: arrayMethod(4),
// 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])
reduce: createArrayReduce(false),
// 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])
reduceRight: createArrayReduce(true),
// 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])
indexOf: indexOf = indexOf || require('./$.array-includes')(false),
// 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])
lastIndexOf: function(el, fromIndex /* = @[*-1] */){
var O = toObject(this)
, length = toLength(O.length)
, index = length - 1;
if(arguments.length > 1)index = Math.min(index, $.toInteger(fromIndex));
if(index < 0)index = toLength(length + index);
for(;index >= 0; index--)if(index in O)if(O[index] === el)return index;
return -1;
}
});
// 21.1.3.25 / 15.5.4.20 String.prototype.trim()
$def($def.P, 'String', {trim: require('./$.replacer')(/^\s*([\s\S]*\S)?\s*$/, '$1')});
// 20.3.3.1 / 15.9.4.4 Date.now()
$def($def.S, 'Date', {now: function(){
return +new Date;
}});
function lz(num){
return num > 9 ? num : '0' + num;
}
// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
// PhantomJS and old webkit had a broken Date implementation.
var date = new Date(-5e13 - 1)
, brokenDate = !(date.toISOString && date.toISOString() == '0385-07-25T07:06:39.999Z');
$def($def.P + $def.F * brokenDate, 'Date', {toISOString: function(){
if(!isFinite(this))throw RangeError('Invalid time value');
var d = this
, y = d.getUTCFullYear()
, m = d.getUTCMilliseconds()
, s = y < 0 ? '-' : y > 9999 ? '+' : '';
return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +
'-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +
'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +
':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
}});
if(classof(function(){ return arguments; }()) == 'Object')cof.classof = function(it){
var tag = classof(it);
return tag == 'Object' && isFunction(it.callee) ? 'Arguments' : tag;
};
},{"./$":21,"./$.array-includes":2,"./$.array-methods":3,"./$.assert":4,"./$.cof":6,"./$.def":12,"./$.invoke":16,"./$.replacer":25,"./$.uid":30}],34:[function(require,module,exports){
'use strict';
var $ = require('./$')
, $def = require('./$.def')
, toIndex = $.toIndex;
$def($def.P, 'Array', {
// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
copyWithin: function copyWithin(target/* = 0 */, start /* = 0, end = @length */){
var O = Object($.assertDefined(this))
, len = $.toLength(O.length)
, to = toIndex(target, len)
, from = toIndex(start, len)
, end = arguments[2]
, fin = end === undefined ? len : toIndex(end, len)
, count = Math.min(fin - from, len - to)
, inc = 1;
if(from < to && to < from + count){
inc = -1;
from = from + count - 1;
to = to + count - 1;
}
while(count-- > 0){
if(from in O)O[to] = O[from];
else delete O[to];
to += inc;
from += inc;
} return O;
}
});
require('./$.unscope')('copyWithin');
},{"./$":21,"./$.def":12,"./$.unscope":31}],35:[function(require,module,exports){
'use strict';
var $ = require('./$')
, $def = require('./$.def')
, toIndex = $.toIndex;
$def($def.P, 'Array', {
// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
fill: function fill(value /*, start = 0, end = @length */){
var O = Object($.assertDefined(this))
, length = $.toLength(O.length)
, index = toIndex(arguments[1], length)
, end = arguments[2]
, endPos = end === undefined ? length : toIndex(end, length);
while(endPos > index)O[index++] = value;
return O;
}
});
require('./$.unscope')('fill');
},{"./$":21,"./$.def":12,"./$.unscope":31}],36:[function(require,module,exports){
var $def = require('./$.def');
$def($def.P, 'Array', {
// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
findIndex: require('./$.array-methods')(6)
});
require('./$.unscope')('findIndex');
},{"./$.array-methods":3,"./$.def":12,"./$.unscope":31}],37:[function(require,module,exports){
var $def = require('./$.def');
$def($def.P, 'Array', {
// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
find: require('./$.array-methods')(5)
});
require('./$.unscope')('find');
},{"./$.array-methods":3,"./$.def":12,"./$.unscope":31}],38:[function(require,module,exports){
var $ = require('./$')
, ctx = require('./$.ctx')
, $def = require('./$.def')
, $iter = require('./$.iter')
, call = require('./$.iter-call');
$def($def.S + $def.F * !require('./$.iter-detect')(function(iter){ Array.from(iter); }), 'Array', {
// 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
var O = Object($.assertDefined(arrayLike))
, mapfn = arguments[1]
, mapping = mapfn !== undefined
, f = mapping ? ctx(mapfn, arguments[2], 2) : undefined
, index = 0
, length, result, step, iterator;
if($iter.is(O)){
iterator = $iter.get(O);
// strange IE quirks mode bug -> use typeof instead of isFunction
result = new (typeof this == 'function' ? this : Array);
for(; !(step = iterator.next()).done; index++){
result[index] = mapping ? call(iterator, f, [step.value, index], true) : step.value;
}
} else {
// strange IE quirks mode bug -> use typeof instead of isFunction
result = new (typeof this == 'function' ? this : Array)(length = $.toLength(O.length));
for(; length > index; index++){
result[index] = mapping ? f(O[index], index) : O[index];
}
}
result.length = index;
return result;
}
});
},{"./$":21,"./$.ctx":11,"./$.def":12,"./$.iter":20,"./$.iter-call":17,"./$.iter-detect":19}],39:[function(require,module,exports){
var $ = require('./$')
, setUnscope = require('./$.unscope')
, ITER = require('./$.uid').safe('iter')
, $iter = require('./$.iter')
, step = $iter.step
, Iterators = $iter.Iterators;
// 22.1.3.4 Array.prototype.entries()
// 22.1.3.13 Array.prototype.keys()
// 22.1.3.29 Array.prototype.values()
// 22.1.3.30 Array.prototype[@@iterator]()
require('./$.iter-define')(Array, 'Array', function(iterated, kind){
$.set(this, ITER, {o: $.toObject(iterated), i: 0, k: kind});
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
}, function(){
var iter = this[ITER]
, O = iter.o
, kind = iter.k
, index = iter.i++;
if(!O || index >= O.length){
iter.o = undefined;
return step(1);
}
if(kind == 'keys' )return step(0, index);
if(kind == 'values')return step(0, O[index]);
return step(0, [index, O[index]]);
}, 'values');
// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
Iterators.Arguments = Iterators.Array;
setUnscope('keys');
setUnscope('values');
setUnscope('entries');
},{"./$":21,"./$.iter":20,"./$.iter-define":18,"./$.uid":30,"./$.unscope":31}],40:[function(require,module,exports){
var $def = require('./$.def');
$def($def.S, 'Array', {
// 22.1.2.3 Array.of( ...items)
of: function of(/* ...args */){
var index = 0
, length = arguments.length
// strange IE quirks mode bug -> use typeof instead of isFunction
, result = new (typeof this == 'function' ? this : Array)(length);
while(length > index)result[index] = arguments[index++];
result.length = length;
return result;
}
});
},{"./$.def":12}],41:[function(require,module,exports){
require('./$.species')(Array);
},{"./$.species":27}],42:[function(require,module,exports){
'use strict';
var $ = require('./$')
, NAME = 'name'
, setDesc = $.setDesc
, FunctionProto = Function.prototype;
// 19.2.4.2 name
NAME in FunctionProto || $.FW && $.DESC && setDesc(FunctionProto, NAME, {
configurable: true,
get: function(){
var match = String(this).match(/^\s*function ([^ (]*)/)
, name = match ? match[1] : '';
$.has(this, NAME) || setDesc(this, NAME, $.desc(5, name));
return name;
},
set: function(value){
$.has(this, NAME) || setDesc(this, NAME, $.desc(0, value));
}
});
},{"./$":21}],43:[function(require,module,exports){
'use strict';
var strong = require('./$.collection-strong');
// 23.1 Map Objects
require('./$.collection')('Map', {
// 23.1.3.6 Map.prototype.get(key)
get: function get(key){
var entry = strong.getEntry(this, key);
return entry && entry.v;
},
// 23.1.3.9 Map.prototype.set(key, value)
set: function set(key, value){
return strong.def(this, key === 0 ? 0 : key, value);
}
}, strong, true);
},{"./$.collection":10,"./$.collection-strong":7}],44:[function(require,module,exports){
var Infinity = 1 / 0
, $def = require('./$.def')
, E = Math.E
, pow = Math.pow
, abs = Math.abs
, exp = Math.exp
, log = Math.log
, sqrt = Math.sqrt
, ceil = Math.ceil
, floor = Math.floor
, EPSILON = pow(2, -52)
, EPSILON32 = pow(2, -23)
, MAX32 = pow(2, 127) * (2 - EPSILON32)
, MIN32 = pow(2, -126);
function roundTiesToEven(n){
return n + 1 / EPSILON - 1 / EPSILON;
}
// 20.2.2.28 Math.sign(x)
function sign(x){
return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
}
// 20.2.2.5 Math.asinh(x)
function asinh(x){
return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log(x + sqrt(x * x + 1));
}
// 20.2.2.14 Math.expm1(x)
function expm1(x){
return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : exp(x) - 1;
}
$def($def.S, 'Math', {
// 20.2.2.3 Math.acosh(x)
acosh: function acosh(x){
return (x = +x) < 1 ? NaN : isFinite(x) ? log(x / E + sqrt(x + 1) * sqrt(x - 1) / E) + 1 : x;
},
// 20.2.2.5 Math.asinh(x)
asinh: asinh,
// 20.2.2.7 Math.atanh(x)
atanh: function atanh(x){
return (x = +x) == 0 ? x : log((1 + x) / (1 - x)) / 2;
},
// 20.2.2.9 Math.cbrt(x)
cbrt: function cbrt(x){
return sign(x = +x) * pow(abs(x), 1 / 3);
},
// 20.2.2.11 Math.clz32(x)
clz32: function clz32(x){
return (x >>>= 0) ? 31 - floor(log(x + 0.5) * Math.LOG2E) : 32;
},
// 20.2.2.12 Math.cosh(x)
cosh: function cosh(x){
return (exp(x = +x) + exp(-x)) / 2;
},
// 20.2.2.14 Math.expm1(x)
expm1: expm1,
// 20.2.2.16 Math.fround(x)
fround: function fround(x){
var $abs = abs(x)
, $sign = sign(x)
, a, result;
if($abs < MIN32)return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
a = (1 + EPSILON32 / EPSILON) * $abs;
result = a - (a - $abs);
if(result > MAX32 || result != result)return $sign * Infinity;
return $sign * result;
},
// 20.2.2.17 Math.hypot([value1[, value2[, … ]]])
hypot: function hypot(value1, value2){ // eslint-disable-line no-unused-vars
var sum = 0
, len1 = arguments.length
, len2 = len1
, args = Array(len1)
, larg = -Infinity
, arg;
while(len1--){
arg = args[len1] = +arguments[len1];
if(arg == Infinity || arg == -Infinity)return Infinity;
if(arg > larg)larg = arg;
}
larg = arg || 1;
while(len2--)sum += pow(args[len2] / larg, 2);
return larg * sqrt(sum);
},
// 20.2.2.18 Math.imul(x, y)
imul: function imul(x, y){
var UInt16 = 0xffff
, xn = +x
, yn = +y
, xl = UInt16 & xn
, yl = UInt16 & yn;
return 0 | xl * yl + ((UInt16 & xn >>> 16) * yl + xl * (UInt16 & yn >>> 16) << 16 >>> 0);
},
// 20.2.2.20 Math.log1p(x)
log1p: function log1p(x){
return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : log(1 + x);
},
// 20.2.2.21 Math.log10(x)
log10: function log10(x){
return log(x) / Math.LN10;
},
// 20.2.2.22 Math.log2(x)
log2: function log2(x){
return log(x) / Math.LN2;
},
// 20.2.2.28 Math.sign(x)
sign: sign,
// 20.2.2.30 Math.sinh(x)
sinh: function sinh(x){
return abs(x = +x) < 1 ? (expm1(x) - expm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E / 2);
},
// 20.2.2.33 Math.tanh(x)
tanh: function tanh(x){
var a = expm1(x = +x)
, b = expm1(-x);
return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
},
// 20.2.2.34 Math.trunc(x)
trunc: function trunc(it){
return (it > 0 ? floor : ceil)(it);
}
});
},{"./$.def":12}],45:[function(require,module,exports){
'use strict';
var $ = require('./$')
, isObject = $.isObject
, isFunction = $.isFunction
, NUMBER = 'Number'
, Number = $.g[NUMBER]
, Base = Number
, proto = Number.prototype;
function toPrimitive(it){
var fn, val;
if(isFunction(fn = it.valueOf) && !isObject(val = fn.call(it)))return val;
if(isFunction(fn = it.toString) && !isObject(val = fn.call(it)))return val;
throw TypeError("Can't convert object to number");
}
function toNumber(it){
if(isObject(it))it = toPrimitive(it);
if(typeof it == 'string' && it.length > 2 && it.charCodeAt(0) == 48){
var binary = false;
switch(it.charCodeAt(1)){
case 66 : case 98 : binary = true;
case 79 : case 111 : return parseInt(it.slice(2), binary ? 2 : 8);
}
} return +it;
}
if($.FW && !(Number('0o1') && Number('0b1'))){
Number = function Number(it){
return this instanceof Number ? new Base(toNumber(it)) : toNumber(it);
};
$.each.call($.DESC ? $.getNames(Base) : (
// ES3:
'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
// ES6 (in case, if modules with ES6 Number statics required before):
'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
).split(','), function(key){
if($.has(Base, key) && !$.has(Number, key)){
$.setDesc(Number, key, $.getDesc(Base, key));
}
}
);
Number.prototype = proto;
proto.constructor = Number;
$.hide($.g, NUMBER, Number);
}
},{"./$":21}],46:[function(require,module,exports){
var $ = require('./$')
, $def = require('./$.def')
, abs = Math.abs
, floor = Math.floor
, _isFinite = $.g.isFinite
, MAX_SAFE_INTEGER = 0x1fffffffffffff; // pow(2, 53) - 1 == 9007199254740991;
function isInteger(it){
return !$.isObject(it) && _isFinite(it) && floor(it) === it;
}
$def($def.S, 'Number', {
// 20.1.2.1 Number.EPSILON
EPSILON: Math.pow(2, -52),
// 20.1.2.2 Number.isFinite(number)
isFinite: function isFinite(it){
return typeof it == 'number' && _isFinite(it);
},
// 20.1.2.3 Number.isInteger(number)
isInteger: isInteger,
// 20.1.2.4 Number.isNaN(number)
isNaN: function isNaN(number){
return number != number;
},
// 20.1.2.5 Number.isSafeInteger(number)
isSafeInteger: function isSafeInteger(number){
return isInteger(number) && abs(number) <= MAX_SAFE_INTEGER;
},
// 20.1.2.6 Number.MAX_SAFE_INTEGER
MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
// 20.1.2.10 Number.MIN_SAFE_INTEGER
MIN_SAFE_INTEGER: -MAX_SAFE_INTEGER,
// 20.1.2.12 Number.parseFloat(string)
parseFloat: parseFloat,
// 20.1.2.13 Number.parseInt(string, radix)
parseInt: parseInt
});
},{"./$":21,"./$.def":12}],47:[function(require,module,exports){
// 19.1.3.1 Object.assign(target, source)
var $def = require('./$.def');
$def($def.S, 'Object', {assign: require('./$.assign')});
},{"./$.assign":5,"./$.def":12}],48:[function(require,module,exports){
// 19.1.3.10 Object.is(value1, value2)
var $def = require('./$.def');
$def($def.S, 'Object', {
is: function is(x, y){
return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
}
});
},{"./$.def":12}],49:[function(require,module,exports){
// 19.1.3.19 Object.setPrototypeOf(O, proto)
var $def = require('./$.def');
$def($def.S, 'Object', {setPrototypeOf: require('./$.set-proto').set});
},{"./$.def":12,"./$.set-proto":26}],50:[function(require,module,exports){
var $ = require('./$')
, $def = require('./$.def')
, isObject = $.isObject
, toObject = $.toObject;
function wrapObjectMethod(METHOD, MODE){
var fn = ($.core.Object || {})[METHOD] || Object[METHOD]
, f = 0
, o = {};
o[METHOD] = MODE == 1 ? function(it){
return isObject(it) ? fn(it) : it;
} : MODE == 2 ? function(it){
return isObject(it) ? fn(it) : true;
} : MODE == 3 ? function(it){
return isObject(it) ? fn(it) : false;
} : MODE == 4 ? function getOwnPropertyDescriptor(it, key){
return fn(toObject(it), key);
} : MODE == 5 ? function getPrototypeOf(it){
return fn(Object($.assertDefined(it)));
} : function(it){
return fn(toObject(it));
};
try {
fn('z');
} catch(e){
f = 1;
}
$def($def.S + $def.F * f, 'Object', o);
}
wrapObjectMethod('freeze', 1);
wrapObjectMethod('seal', 1);
wrapObjectMethod('preventExtensions', 1);
wrapObjectMethod('isFrozen', 2);
wrapObjectMethod('isSealed', 2);
wrapObjectMethod('isExtensible', 3);
wrapObjectMethod('getOwnPropertyDescriptor', 4);
wrapObjectMethod('getPrototypeOf', 5);
wrapObjectMethod('keys');
wrapObjectMethod('getOwnPropertyNames');
},{"./$":21,"./$.def":12}],51:[function(require,module,exports){
'use strict';
// 19.1.3.6 Object.prototype.toString()
var $ = require('./$')
, cof = require('./$.cof')
, tmp = {};
tmp[require('./$.wks')('toStringTag')] = 'z';
if($.FW && cof(tmp) != 'z')$.hide(Object.prototype, 'toString', function toString(){
return '[object ' + cof.classof(this) + ']';
});
},{"./$":21,"./$.cof":6,"./$.wks":32}],52:[function(require,module,exports){
'use strict';
var $ = require('./$')
, ctx = require('./$.ctx')
, cof = require('./$.cof')
, $def = require('./$.def')
, assert = require('./$.assert')
, forOf = require('./$.for-of')
, setProto = require('./$.set-proto').set
, species = require('./$.species')
, SPECIES = require('./$.wks')('species')
, RECORD = require('./$.uid').safe('record')
, PROMISE = 'Promise'
, global = $.g
, process = global.process
, asap = process && process.nextTick || require('./$.task').set
, P = global[PROMISE]
, isFunction = $.isFunction
, isObject = $.isObject
, assertFunction = assert.fn
, assertObject = assert.obj
, test;
var useNative = isFunction(P) && isFunction(P.resolve) &&
P.resolve(test = new P(function(){})) == test;
// actual Firefox has broken subclass support, test that
function P2(x){
var self = new P(x);
setProto(self, P2.prototype);
return self;
}
if(useNative){
try { // protect against bad/buggy Object.setPrototype
setProto(P2, P);
P2.prototype = $.create(P.prototype, {constructor: {value: P2}});
if(!(P2.resolve(5).then(function(){}) instanceof P2)){
useNative = false;
}
} catch(e){ useNative = false; }
}
// helpers
function getConstructor(C){
var S = assertObject(C)[SPECIES];
return S != undefined ? S : C;
}
function isThenable(it){
var then;
if(isObject(it))then = it.then;
return isFunction(then) ? then : false;
}
function notify(record){
var chain = record.c;
if(chain.length)asap(function(){
var value = record.v
, ok = record.s == 1
, i = 0;
while(chain.length > i)!function(react){
var cb = ok ? react.ok : react.fail
, ret, then;
try {
if(cb){
if(!ok)record.h = true;
ret = cb === true ? value : cb(value);
if(ret === react.P){
react.rej(TypeError('Promise-chain cycle'));
} else if(then = isThenable(ret)){
then.call(ret, react.res, react.rej);
} else react.res(ret);
} else react.rej(value);
} catch(err){
react.rej(err);
}
}(chain[i++]);
chain.length = 0;
});
}
function isUnhandled(promise){
var record = promise[RECORD]
, chain = record.a
, i = 0
, react;
if(record.h)return false;
while(chain.length > i){
react = chain[i++];
if(react.fail || !isUnhandled(react.P))return false;
} return true;
}
function $reject(value){
var record = this
, promise;
if(record.d)return;
record.d = true;
record = record.r || record; // unwrap
record.v = value;
record.s = 2;
asap(function(){
setTimeout(function(){
if(isUnhandled(promise = record.p)){
if(cof(process) == 'process'){
process.emit('unhandledRejection', value, promise);
} else if(global.console && isFunction(console.error)){
console.error('Unhandled promise rejection', value);
}
}
}, 1);
});
notify(record);
}
function $resolve(value){
var record = this
, then, wrapper;
if(record.d)return;
record.d = true;
record = record.r || record; // unwrap
try {
if(then = isThenable(value)){
wrapper = {r: record, d: false}; // wrap
then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
} else {
record.v = value;
record.s = 1;
notify(record);
}
} catch(err){
$reject.call(wrapper || {r: record, d: false}, err); // wrap
}
}
// constructor polyfill
if(!useNative){
// 25.4.3.1 Promise(executor)
P = function Promise(executor){
assertFunction(executor);
var record = {
p: assert.inst(this, P, PROMISE), // <- promise
c: [], // <- awaiting reactions
a: [], // <- all reactions
s: 0, // <- state
d: false, // <- done
v: undefined, // <- value
h: false // <- handled rejection
};
$.hide(this, RECORD, record);
try {
executor(ctx($resolve, record, 1), ctx($reject, record, 1));
} catch(err){
$reject.call(record, err);
}
};
$.mix(P.prototype, {
// 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
then: function then(onFulfilled, onRejected){
var S = assertObject(assertObject(this).constructor)[SPECIES];
var react = {
ok: isFunction(onFulfilled) ? onFulfilled : true,
fail: isFunction(onRejected) ? onRejected : false
};
var promise = react.P = new (S != undefined ? S : P)(function(res, rej){
react.res = assertFunction(res);
react.rej = assertFunction(rej);
});
var record = this[RECORD];
record.a.push(react);
record.c.push(react);
record.s && notify(record);
return promise;
},
// 25.4.5.1 Promise.prototype.catch(onRejected)
'catch': function(onRejected){
return this.then(undefined, onRejected);
}
});
}
// export
$def($def.G + $def.W + $def.F * !useNative, {Promise: P});
cof.set(P, PROMISE);
species(P);
species($.core[PROMISE]); // for wrapper
// statics
$def($def.S + $def.F * !useNative, PROMISE, {
// 25.4.4.5 Promise.reject(r)
reject: function reject(r){
return new (getConstructor(this))(function(res, rej){
rej(r);
});
},
// 25.4.4.6 Promise.resolve(x)
resolve: function resolve(x){
return isObject(x) && RECORD in x && $.getProto(x) === this.prototype
? x : new (getConstructor(this))(function(res){
res(x);
});
}
});
$def($def.S + $def.F * !(useNative && require('./$.iter-detect')(function(iter){
P.all(iter)['catch'](function(){});
})), PROMISE, {
// 25.4.4.1 Promise.all(iterable)
all: function all(iterable){
var C = getConstructor(this)
, values = [];
return new C(function(res, rej){
forOf(iterable, false, values.push, values);
var remaining = values.length
, results = Array(remaining);
if(remaining)$.each.call(values, function(promise, index){
C.resolve(promise).then(function(value){
results[index] = value;
--remaining || res(results);
}, rej);
});
else res(results);
});
},
// 25.4.4.4 Promise.race(iterable)
race: function race(iterable){
var C = getConstructor(this);
return new C(function(res, rej){
forOf(iterable, false, function(promise){
C.resolve(promise).then(res, rej);
});
});
}
});
},{"./$":21,"./$.assert":4,"./$.cof":6,"./$.ctx":11,"./$.def":12,"./$.for-of":14,"./$.iter-detect":19,"./$.set-proto":26,"./$.species":27,"./$.task":29,"./$.uid":30,"./$.wks":32}],53:[function(require,module,exports){
var $ = require('./$')
, $def = require('./$.def')
, setProto = require('./$.set-proto')
, $iter = require('./$.iter')
, ITER = require('./$.uid').safe('iter')
, step = $iter.step
, assert = require('./$.assert')
, isObject = $.isObject
, getDesc = $.getDesc
, setDesc = $.setDesc
, getProto = $.getProto
, apply = Function.apply
, assertObject = assert.obj
, _isExtensible = Object.isExtensible || $.it;
function Enumerate(iterated){
$.set(this, ITER, {o: iterated, k: undefined, i: 0});
}
$iter.create(Enumerate, 'Object', function(){
var iter = this[ITER]
, keys = iter.k
, key;
if(keys == undefined){
iter.k = keys = [];
for(key in iter.o)keys.push(key);
}
do {
if(iter.i >= keys.length)return step(1);
} while(!((key = keys[iter.i++]) in iter.o));
return step(0, key);
});
function wrap(fn){
return function(it){
assertObject(it);
try {
fn.apply(undefined, arguments);
return true;
} catch(e){
return false;
}
};
}
function get(target, propertyKey/*, receiver*/){
var receiver = arguments.length < 3 ? target : arguments[2]
, desc = getDesc(assertObject(target), propertyKey), proto;
if(desc)return $.has(desc, 'value')
? desc.value
: desc.get === undefined
? undefined
: desc.get.call(receiver);
return isObject(proto = getProto(target))
? get(proto, propertyKey, receiver)
: undefined;
}
function set(target, propertyKey, V/*, receiver*/){
var receiver = arguments.length < 4 ? target : arguments[3]
, ownDesc = getDesc(assertObject(target), propertyKey)
, existingDescriptor, proto;
if(!ownDesc){
if(isObject(proto = getProto(target))){
return set(proto, propertyKey, V, receiver);
}
ownDesc = $.desc(0);
}
if($.has(ownDesc, 'value')){
if(ownDesc.writable === false || !isObject(receiver))return false;
existingDescriptor = getDesc(receiver, propertyKey) || $.desc(0);
existingDescriptor.value = V;
setDesc(receiver, propertyKey, existingDescriptor);
return true;
}
return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
}
var reflect = {
// 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
apply: require('./$.ctx')(Function.call, apply, 3),
// 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
construct: function construct(target, argumentsList /*, newTarget*/){
var proto = assert.fn(arguments.length < 3 ? target : arguments[2]).prototype
, instance = $.create(isObject(proto) ? proto : Object.prototype)
, result = apply.call(target, instance, argumentsList);
return isObject(result) ? result : instance;
},
// 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
defineProperty: wrap(setDesc),
// 26.1.4 Reflect.deleteProperty(target, propertyKey)
deleteProperty: function deleteProperty(target, propertyKey){
var desc = getDesc(assertObject(target), propertyKey);
return desc && !desc.configurable ? false : delete target[propertyKey];
},
// 26.1.5 Reflect.enumerate(target)
enumerate: function enumerate(target){
return new Enumerate(assertObject(target));
},
// 26.1.6 Reflect.get(target, propertyKey [, receiver])
get: get,
// 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey){
return getDesc(assertObject(target), propertyKey);
},
// 26.1.8 Reflect.getPrototypeOf(target)
getPrototypeOf: function getPrototypeOf(target){
return getProto(assertObject(target));
},
// 26.1.9 Reflect.has(target, propertyKey)
has: function has(target, propertyKey){
return propertyKey in target;
},
// 26.1.10 Reflect.isExtensible(target)
isExtensible: function isExtensible(target){
return !!_isExtensible(assertObject(target));
},
// 26.1.11 Reflect.ownKeys(target)
ownKeys: require('./$.own-keys'),
// 26.1.12 Reflect.preventExtensions(target)
preventExtensions: wrap(Object.preventExtensions || $.it),
// 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
set: set
};
// 26.1.14 Reflect.setPrototypeOf(target, proto)
if(setProto)reflect.setPrototypeOf = function setPrototypeOf(target, proto){
setProto.check(target, proto);
try {
setProto.set(target, proto);
return true;
} catch(e){
return false;
}
};
$def($def.G, {Reflect: {}});
$def($def.S, 'Reflect', reflect);
},{"./$":21,"./$.assert":4,"./$.ctx":11,"./$.def":12,"./$.iter":20,"./$.own-keys":23,"./$.set-proto":26,"./$.uid":30}],54:[function(require,module,exports){
var $ = require('./$')
, cof = require('./$.cof')
, RegExp = $.g.RegExp
, Base = RegExp
, proto = RegExp.prototype;
function regExpBroken() {
try {
var a = /a/g;
// "new" creates a new object
if (a === new RegExp(a)) { return true; }
// RegExp allows a regex with flags as the pattern
return RegExp(/a/g, 'i') != '/a/i';
} catch(e) {
return true;
}
}
if($.FW && $.DESC){
if(regExpBroken()) {
RegExp = function RegExp(pattern, flags){
return new Base(cof(pattern) == 'RegExp' ? pattern.source : pattern,
flags === undefined ? pattern.flags : flags);
};
$.each.call($.getNames(Base), function(key){
key in RegExp || $.setDesc(RegExp, key, {
configurable: true,
get: function(){ return Base[key]; },
set: function(it){ Base[key] = it; }
});
});
proto.constructor = RegExp;
RegExp.prototype = proto;
$.hide($.g, 'RegExp', RegExp);
}
// 21.2.5.3 get RegExp.prototype.flags()
if(/./g.flags != 'g')$.setDesc(proto, 'flags', {
configurable: true,
get: require('./$.replacer')(/^.*\/(\w*)$/, '$1')
});
}
require('./$.species')(RegExp);
},{"./$":21,"./$.cof":6,"./$.replacer":25,"./$.species":27}],55:[function(require,module,exports){
'use strict';
var strong = require('./$.collection-strong');
// 23.2 Set Objects
require('./$.collection')('Set', {
// 23.2.3.1 Set.prototype.add(value)
add: function add(value){
return strong.def(this, value = value === 0 ? 0 : value, value);
}
}, strong);
},{"./$.collection":10,"./$.collection-strong":7}],56:[function(require,module,exports){
var $def = require('./$.def');
$def($def.P, 'String', {
// 21.1.3.3 String.prototype.codePointAt(pos)
codePointAt: require('./$.string-at')(false)
});
},{"./$.def":12,"./$.string-at":28}],57:[function(require,module,exports){
'use strict';
var $ = require('./$')
, cof = require('./$.cof')
, $def = require('./$.def')
, toLength = $.toLength;
$def($def.P, 'String', {
// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])
endsWith: function endsWith(searchString /*, endPosition = @length */){
if(cof(searchString) == 'RegExp')throw TypeError();
var that = String($.assertDefined(this))
, endPosition = arguments[1]
, len = toLength(that.length)
, end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
searchString += '';
return that.slice(end - searchString.length, end) === searchString;
}
});
},{"./$":21,"./$.cof":6,"./$.def":12}],58:[function(require,module,exports){
var $def = require('./$.def')
, toIndex = require('./$').toIndex
, fromCharCode = String.fromCharCode;
$def($def.S, 'String', {
// 21.1.2.2 String.fromCodePoint(...codePoints)
fromCodePoint: function fromCodePoint(x){ // eslint-disable-line no-unused-vars
var res = []
, len = arguments.length
, i = 0
, code;
while(len > i){
code = +arguments[i++];
if(toIndex(code, 0x10ffff) !== code)throw RangeError(code + ' is not a valid code point');
res.push(code < 0x10000
? fromCharCode(code)
: fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
);
} return res.join('');
}
});
},{"./$":21,"./$.def":12}],59:[function(require,module,exports){
'use strict';
var $ = require('./$')
, cof = require('./$.cof')
, $def = require('./$.def');
$def($def.P, 'String', {
// 21.1.3.7 String.prototype.includes(searchString, position = 0)
includes: function includes(searchString /*, position = 0 */){
if(cof(searchString) == 'RegExp')throw TypeError();
return !!~String($.assertDefined(this)).indexOf(searchString, arguments[1]);
}
});
},{"./$":21,"./$.cof":6,"./$.def":12}],60:[function(require,module,exports){
var set = require('./$').set
, at = require('./$.string-at')(true)
, ITER = require('./$.uid').safe('iter')
, $iter = require('./$.iter')
, step = $iter.step;
// 21.1.3.27 String.prototype[@@iterator]()
require('./$.iter-define')(String, 'String', function(iterated){
set(this, ITER, {o: String(iterated), i: 0});
// 21.1.5.2.1 %StringIteratorPrototype%.next()
}, function(){
var iter = this[ITER]
, O = iter.o
, index = iter.i
, point;
if(index >= O.length)return step(1);
point = at.call(O, index);
iter.i += point.length;
return step(0, point);
});
},{"./$":21,"./$.iter":20,"./$.iter-define":18,"./$.string-at":28,"./$.uid":30}],61:[function(require,module,exports){
var $ = require('./$')
, $def = require('./$.def');
$def($def.S, 'String', {
// 21.1.2.4 String.raw(callSite, ...substitutions)
raw: function raw(callSite){
var tpl = $.toObject(callSite.raw)
, len = $.toLength(tpl.length)
, sln = arguments.length
, res = []
, i = 0;
while(len > i){
res.push(String(tpl[i++]));
if(i < sln)res.push(String(arguments[i]));
} return res.join('');
}
});
},{"./$":21,"./$.def":12}],62:[function(require,module,exports){
'use strict';
var $ = require('./$')
, $def = require('./$.def');
$def($def.P, 'String', {
// 21.1.3.13 String.prototype.repeat(count)
repeat: 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;
}
});
},{"./$":21,"./$.def":12}],63:[function(require,module,exports){
'use strict';
var $ = require('./$')
, cof = require('./$.cof')
, $def = require('./$.def');
$def($def.P, 'String', {
// 21.1.3.18 String.prototype.startsWith(searchString [, position ])
startsWith: function startsWith(searchString /*, position = 0 */){
if(cof(searchString) == 'RegExp')throw TypeError();
var that = String($.assertDefined(this))
, index = $.toLength(Math.min(arguments[1], that.length));
searchString += '';
return that.slice(index, index + searchString.length) === searchString;
}
});
},{"./$":21,"./$.cof":6,"./$.def":12}],64:[function(require,module,exports){
'use strict';
// ECMAScript 6 symbols shim
var $ = require('./$')
, setTag = require('./$.cof').set
, uid = require('./$.uid')
, $def = require('./$.def')
, keyOf = require('./$.keyof')
, enumKeys = require('./$.enum-keys')
, assertObject = require('./$.assert').obj
, has = $.has
, $create = $.create
, getDesc = $.getDesc
, setDesc = $.setDesc
, desc = $.desc
, getNames = $.getNames
, toObject = $.toObject
, Symbol = $.g.Symbol
, setter = false
, TAG = uid('tag')
, HIDDEN = uid('hidden')
, SymbolRegistry = {}
, AllSymbols = {}
, useNative = $.isFunction(Symbol);
function wrap(tag){
var sym = AllSymbols[tag] = $.set($create(Symbol.prototype), TAG, tag);
$.DESC && setter && setDesc(Object.prototype, tag, {
configurable: true,
set: function(value){
if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
setDesc(this, tag, desc(1, value));
}
});
return sym;
}
function defineProperty(it, key, D){
if(D && has(AllSymbols, key)){
if(!D.enumerable){
if(!has(it, HIDDEN))setDesc(it, HIDDEN, desc(1, {}));
it[HIDDEN][key] = true;
} else {
if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
D.enumerable = false;
}
} return setDesc(it, key, D);
}
function defineProperties(it, P){
assertObject(it);
var keys = enumKeys(P = toObject(P))
, i = 0
, l = keys.length
, key;
while(l > i)defineProperty(it, key = keys[i++], P[key]);
return it;
}
function create(it, P){
return P === undefined ? $create(it) : defineProperties($create(it), P);
}
function getOwnPropertyDescriptor(it, key){
var D = getDesc(it = toObject(it), key);
if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
return D;
}
function getOwnPropertyNames(it){
var names = getNames(toObject(it))
, result = []
, i = 0
, key;
while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
return result;
}
function getOwnPropertySymbols(it){
var names = getNames(toObject(it))
, result = []
, i = 0
, key;
while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
return result;
}
// 19.4.1.1 Symbol([description])
if(!useNative){
Symbol = function Symbol(description){
if(this instanceof Symbol)throw TypeError('Symbol is not a constructor');
return wrap(uid(description));
};
$.hide(Symbol.prototype, 'toString', function(){
return this[TAG];
});
$.create = create;
$.setDesc = defineProperty;
$.getDesc = getOwnPropertyDescriptor;
$.setDescs = defineProperties;
$.getNames = getOwnPropertyNames;
$.getSymbols = getOwnPropertySymbols;
}
var symbolStatics = {
// 19.4.2.1 Symbol.for(key)
'for': function(key){
return has(SymbolRegistry, key += '')
? SymbolRegistry[key]
: SymbolRegistry[key] = Symbol(key);
},
// 19.4.2.5 Symbol.keyFor(sym)
keyFor: function keyFor(key){
return keyOf(SymbolRegistry, key);
},
useSetter: function(){ setter = true; },
useSimple: function(){ setter = false; }
};
// 19.4.2.2 Symbol.hasInstance
// 19.4.2.3 Symbol.isConcatSpreadable
// 19.4.2.4 Symbol.iterator
// 19.4.2.6 Symbol.match
// 19.4.2.8 Symbol.replace
// 19.4.2.9 Symbol.search
// 19.4.2.10 Symbol.species
// 19.4.2.11 Symbol.split
// 19.4.2.12 Symbol.toPrimitive
// 19.4.2.13 Symbol.toStringTag
// 19.4.2.14 Symbol.unscopables
$.each.call((
'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
'species,split,toPrimitive,toStringTag,unscopables'
).split(','), function(it){
var sym = require('./$.wks')(it);
symbolStatics[it] = useNative ? sym : wrap(sym);
}
);
setter = true;
$def($def.G + $def.W, {Symbol: Symbol});
$def($def.S, 'Symbol', symbolStatics);
$def($def.S + $def.F * !useNative, 'Object', {
// 19.1.2.2 Object.create(O [, Properties])
create: create,
// 19.1.2.4 Object.defineProperty(O, P, Attributes)
defineProperty: defineProperty,
// 19.1.2.3 Object.defineProperties(O, Properties)
defineProperties: defineProperties,
// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
getOwnPropertyDescriptor: getOwnPropertyDescriptor,
// 19.1.2.7 Object.getOwnPropertyNames(O)
getOwnPropertyNames: getOwnPropertyNames,
// 19.1.2.8 Object.getOwnPropertySymbols(O)
getOwnPropertySymbols: getOwnPropertySymbols
});
// 19.4.3.5 Symbol.prototype[@@toStringTag]
setTag(Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
setTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
setTag($.g.JSON, 'JSON', true);
},{"./$":21,"./$.assert":4,"./$.cof":6,"./$.def":12,"./$.enum-keys":13,"./$.keyof":22,"./$.uid":30,"./$.wks":32}],65:[function(require,module,exports){
'use strict';
var $ = require('./$')
, weak = require('./$.collection-weak')
, leakStore = weak.leakStore
, ID = weak.ID
, WEAK = weak.WEAK
, has = $.has
, isObject = $.isObject
, isFrozen = Object.isFrozen || $.core.Object.isFrozen
, tmp = {};
// 23.3 WeakMap Objects
var WeakMap = require('./$.collection')('WeakMap', {
// 23.3.3.3 WeakMap.prototype.get(key)
get: function get(key){
if(isObject(key)){
if(isFrozen(key))return leakStore(this).get(key);
if(has(key, WEAK))return key[WEAK][this[ID]];
}
},
// 23.3.3.5 WeakMap.prototype.set(key, value)
set: function set(key, value){
return weak.def(this, key, value);
}
}, weak, true, true);
// IE11 WeakMap frozen keys fix
if($.FW && new WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
$.each.call(['delete', 'has', 'get', 'set'], function(key){
var method = WeakMap.prototype[key];
WeakMap.prototype[key] = function(a, b){
// store frozen objects on leaky map
if(isObject(a) && isFrozen(a)){
var result = leakStore(this)[key](a, b);
return key == 'set' ? this : result;
// store all the rest on native weakmap
} return method.call(this, a, b);
};
});
}
},{"./$":21,"./$.collection":10,"./$.collection-weak":9}],66:[function(require,module,exports){
'use strict';
var weak = require('./$.collection-weak');
// 23.4 WeakSet Objects
require('./$.collection')('WeakSet', {
// 23.4.3.1 WeakSet.prototype.add(value)
add: function add(value){
return weak.def(this, value, true);
}
}, weak, false, true);
},{"./$.collection":10,"./$.collection-weak":9}],67:[function(require,module,exports){
// https://github.com/domenic/Array.prototype.includes
var $def = require('./$.def');
$def($def.P, 'Array', {
includes: require('./$.array-includes')(true)
});
require('./$.unscope')('includes');
},{"./$.array-includes":2,"./$.def":12,"./$.unscope":31}],68:[function(require,module,exports){
// https://github.com/DavidBruant/Map-Set.prototype.toJSON
require('./$.collection-to-json')('Map');
},{"./$.collection-to-json":8}],69:[function(require,module,exports){
// https://gist.github.com/WebReflection/9353781
var $ = require('./$')
, $def = require('./$.def')
, ownKeys = require('./$.own-keys');
$def($def.S, 'Object', {
getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object){
var O = $.toObject(object)
, result = {};
$.each.call(ownKeys(O), function(key){
$.setDesc(result, key, $.desc(0, $.getDesc(O, key)));
});
return result;
}
});
},{"./$":21,"./$.def":12,"./$.own-keys":23}],70:[function(require,module,exports){
// http://goo.gl/XkBrjD
var $ = require('./$')
, $def = require('./$.def');
function createObjectToArray(isEntries){
return function(object){
var O = $.toObject(object)
, keys = $.getKeys(O)
, length = keys.length
, i = 0
, result = Array(length)
, key;
if(isEntries)while(length > i)result[i] = [key = keys[i++], O[key]];
else while(length > i)result[i] = O[keys[i++]];
return result;
};
}
$def($def.S, 'Object', {
values: createObjectToArray(false),
entries: createObjectToArray(true)
});
},{"./$":21,"./$.def":12}],71:[function(require,module,exports){
// https://gist.github.com/kangax/9698100
var $def = require('./$.def');
$def($def.S, 'RegExp', {
escape: require('./$.replacer')(/([\\\-[\]{}()*+?.,^$|])/g, '\\$1', true)
});
},{"./$.def":12,"./$.replacer":25}],72:[function(require,module,exports){
// https://github.com/DavidBruant/Map-Set.prototype.toJSON
require('./$.collection-to-json')('Set');
},{"./$.collection-to-json":8}],73:[function(require,module,exports){
// https://github.com/mathiasbynens/String.prototype.at
var $def = require('./$.def');
$def($def.P, 'String', {
at: require('./$.string-at')(true)
});
},{"./$.def":12,"./$.string-at":28}],74:[function(require,module,exports){
// JavaScript 1.6 / Strawman array statics shim
var $ = require('./$')
, $def = require('./$.def')
, $Array = $.core.Array || Array
, statics = {};
function setStatics(keys, length){
$.each.call(keys.split(','), function(key){
if(length == undefined && key in $Array)statics[key] = $Array[key];
else if(key in [])statics[key] = require('./$.ctx')(Function.call, [][key], length);
});
}
setStatics('pop,reverse,shift,keys,values,entries', 1);
setStatics('indexOf,every,some,forEach,map,filter,find,findIndex,includes', 3);
setStatics('join,slice,concat,push,splice,unshift,sort,lastIndexOf,' +
'reduce,reduceRight,copyWithin,fill,turn');
$def($def.S, 'Array', statics);
},{"./$":21,"./$.ctx":11,"./$.def":12}],75:[function(require,module,exports){
require('./es6.array.iterator');
var $ = require('./$')
, Iterators = require('./$.iter').Iterators
, ITERATOR = require('./$.wks')('iterator')
, ArrayValues = Iterators.Array
, NodeList = $.g.NodeList;
if($.FW && NodeList && !(ITERATOR in NodeList.prototype)){
$.hide(NodeList.prototype, ITERATOR, ArrayValues);
}
Iterators.NodeList = ArrayValues;
},{"./$":21,"./$.iter":20,"./$.wks":32,"./es6.array.iterator":39}],76:[function(require,module,exports){
var $def = require('./$.def')
, $task = require('./$.task');
$def($def.G + $def.B, {
setImmediate: $task.set,
clearImmediate: $task.clear
});
},{"./$.def":12,"./$.task":29}],77:[function(require,module,exports){
// ie9- setTimeout & setInterval additional parameters fix
var $ = require('./$')
, $def = require('./$.def')
, invoke = require('./$.invoke')
, partial = require('./$.partial')
, navigator = $.g.navigator
, MSIE = !!navigator && /MSIE .\./.test(navigator.userAgent); // <- dirty ie9- check
function wrap(set){
return MSIE ? function(fn, time /*, ...args */){
return set(invoke(
partial,
[].slice.call(arguments, 2),
$.isFunction(fn) ? fn : Function(fn)
), time);
} : set;
}
$def($def.G + $def.B + $def.F * MSIE, {
setTimeout: wrap($.g.setTimeout),
setInterval: wrap($.g.setInterval)
});
},{"./$":21,"./$.def":12,"./$.invoke":16,"./$.partial":24}],78:[function(require,module,exports){
require('./modules/es5');
require('./modules/es6.symbol');
require('./modules/es6.object.assign');
require('./modules/es6.object.is');
require('./modules/es6.object.set-prototype-of');
require('./modules/es6.object.to-string');
require('./modules/es6.object.statics-accept-primitives');
require('./modules/es6.function.name');
require('./modules/es6.number.constructor');
require('./modules/es6.number.statics');
require('./modules/es6.math');
require('./modules/es6.string.from-code-point');
require('./modules/es6.string.raw');
require('./modules/es6.string.iterator');
require('./modules/es6.string.code-point-at');
require('./modules/es6.string.ends-with');
require('./modules/es6.string.includes');
require('./modules/es6.string.repeat');
require('./modules/es6.string.starts-with');
require('./modules/es6.array.from');
require('./modules/es6.array.of');
require('./modules/es6.array.iterator');
require('./modules/es6.array.species');
require('./modules/es6.array.copy-within');
require('./modules/es6.array.fill');
require('./modules/es6.array.find');
require('./modules/es6.array.find-index');
require('./modules/es6.regexp');
require('./modules/es6.promise');
require('./modules/es6.map');
require('./modules/es6.set');
require('./modules/es6.weak-map');
require('./modules/es6.weak-set');
require('./modules/es6.reflect');
require('./modules/es7.array.includes');
require('./modules/es7.string.at');
require('./modules/es7.regexp.escape');
require('./modules/es7.object.get-own-property-descriptors');
require('./modules/es7.object.to-array');
require('./modules/es7.map.to-json');
require('./modules/es7.set.to-json');
require('./modules/js.array.statics');
require('./modules/web.timers');
require('./modules/web.immediate');
require('./modules/web.dom.iterable');
module.exports = require('./modules/$').core;
},{"./modules/$":21,"./modules/es5":33,"./modules/es6.array.copy-within":34,"./modules/es6.array.fill":35,"./modules/es6.array.find":37,"./modules/es6.array.find-index":36,"./modules/es6.array.from":38,"./modules/es6.array.iterator":39,"./modules/es6.array.of":40,"./modules/es6.array.species":41,"./modules/es6.function.name":42,"./modules/es6.map":43,"./modules/es6.math":44,"./modules/es6.number.constructor":45,"./modules/es6.number.statics":46,"./modules/es6.object.assign":47,"./modules/es6.object.is":48,"./modules/es6.object.set-prototype-of":49,"./modules/es6.object.statics-accept-primitives":50,"./modules/es6.object.to-string":51,"./modules/es6.promise":52,"./modules/es6.reflect":53,"./modules/es6.regexp":54,"./modules/es6.set":55,"./modules/es6.string.code-point-at":56,"./modules/es6.string.ends-with":57,"./modules/es6.string.from-code-point":58,"./modules/es6.string.includes":59,"./modules/es6.string.iterator":60,"./modules/es6.string.raw":61,"./modules/es6.string.repeat":62,"./modules/es6.string.starts-with":63,"./modules/es6.symbol":64,"./modules/es6.weak-map":65,"./modules/es6.weak-set":66,"./modules/es7.array.includes":67,"./modules/es7.map.to-json":68,"./modules/es7.object.get-own-property-descriptors":69,"./modules/es7.object.to-array":70,"./modules/es7.regexp.escape":71,"./modules/es7.set.to-json":72,"./modules/es7.string.at":73,"./modules/js.array.statics":74,"./modules/web.dom.iterable":75,"./modules/web.immediate":76,"./modules/web.timers":77}],79:[function(require,module,exports){
(function (global){
/**
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
!(function(global) {
"use strict";
var hasOwn = Object.prototype.hasOwnProperty;
var undefined; // More compressible than void 0.
var iteratorSymbol =
typeof Symbol === "function" && Symbol.iterator || "@@iterator";
var inModule = typeof module === "object";
var runtime = global.regeneratorRuntime;
if (runtime) {
if (inModule) {
// If regeneratorRuntime is defined globally and we're in a module,
// make the exports object identical to regeneratorRuntime.
module.exports = runtime;
}
// Don't bother evaluating the rest of this file if the runtime was
// already defined globally.
return;
}
// Define the runtime globally (as expected by generated code) as either
// module.exports (if we're in a module) or a new, empty object.
runtime = global.regeneratorRuntime = inModule ? module.exports : {};
function wrap(innerFn, outerFn, self, tryLocsList) {
// If outerFn provided, then outerFn.prototype instanceof Generator.
var generator = Object.create((outerFn || Generator).prototype);
generator._invoke = makeInvokeMethod(
innerFn, self || null,
new Context(tryLocsList || [])
);
return generator;
}
runtime.wrap = wrap;
// Try/catch helper to minimize deoptimizations. Returns a completion
// record like context.tryEntries[i].completion. This interface could
// have been (and was previously) designed to take a closure to be
// invoked without arguments, but in all the cases we care about we
// already have an existing method we want to call, so there's no need
// to create a new function object. We can even get away with assuming
// the method takes exactly one argument, since that happens to be true
// in every case, so we don't have to touch the arguments object. The
// only additional allocation required is the completion record, which
// has a stable shape and so hopefully should be cheap to allocate.
function tryCatch(fn, obj, arg) {
try {
return { type: "normal", arg: fn.call(obj, arg) };
} catch (err) {
return { type: "throw", arg: err };
}
}
var GenStateSuspendedStart = "suspendedStart";
var GenStateSuspendedYield = "suspendedYield";
var GenStateExecuting = "executing";
var GenStateCompleted = "completed";
// Returning this object from the innerFn has the same effect as
// breaking out of the dispatch switch statement.
var ContinueSentinel = {};
// Dummy constructor functions that we use as the .constructor and
// .constructor.prototype properties for functions that return Generator
// objects. For full spec compliance, you may wish to configure your
// minifier not to mangle the names of these two functions.
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;
GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
GeneratorFunctionPrototype.constructor = GeneratorFunction;
GeneratorFunction.displayName = "GeneratorFunction";
runtime.isGeneratorFunction = function(genFun) {
var ctor = typeof genFun === "function" && genFun.constructor;
return ctor
? ctor === GeneratorFunction ||
// For the native GeneratorFunction constructor, the best we can
// do is to check its .name property.
(ctor.displayName || ctor.name) === "GeneratorFunction"
: false;
};
runtime.mark = function(genFun) {
genFun.__proto__ = GeneratorFunctionPrototype;
genFun.prototype = Object.create(Gp);
return genFun;
};
runtime.async = function(innerFn, outerFn, self, tryLocsList) {
return new Promise(function(resolve, reject) {
var generator = wrap(innerFn, outerFn, self, tryLocsList);
var callNext = step.bind(generator, "next");
var callThrow = step.bind(generator, "throw");
function step(method, arg) {
var record = tryCatch(generator[method], generator, arg);
if (record.type === "throw") {
reject(record.arg);
return;
}
var info = record.arg;
if (info.done) {
resolve(info.value);
} else {
Promise.resolve(info.value).then(callNext, callThrow);
}
}
callNext();
});
};
function makeInvokeMethod(innerFn, self, context) {
var state = GenStateSuspendedStart;
return function invoke(method, arg) {
if (state === GenStateExecuting) {
throw new Error("Generator is already running");
}
if (state === GenStateCompleted) {
// Be forgiving, per 25.3.3.3.3 of the spec:
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult();
}
while (true) {
var delegate = context.delegate;
if (delegate) {
if (method === "return" ||
(method === "throw" && delegate.iterator[method] === undefined)) {
// A return or throw (when the delegate iterator has no throw
// method) always terminates the yield* loop.
context.delegate = null;
// If the delegate iterator has a return method, give it a
// chance to clean up.
var returnMethod = delegate.iterator["return"];
if (returnMethod) {
var record = tryCatch(returnMethod, delegate.iterator, arg);
if (record.type === "throw") {
// If the return method threw an exception, let that
// exception prevail over the original return or throw.
method = "throw";
arg = record.arg;
continue;
}
}
if (method === "return") {
// Continue with the outer return, now that the delegate
// iterator has been terminated.
continue;
}
}
var record = tryCatch(
delegate.iterator[method],
delegate.iterator,
arg
);
if (record.type === "throw") {
context.delegate = null;
// Like returning generator.throw(uncaught), but without the
// overhead of an extra function call.
method = "throw";
arg = record.arg;
continue;
}
// Delegate generator ran and handled its own exceptions so
// regardless of what the method was, we continue as if it is
// "next" with an undefined arg.
method = "next";
arg = undefined;
var info = record.arg;
if (info.done) {
context[delegate.resultName] = info.value;
context.next = delegate.nextLoc;
} else {
state = GenStateSuspendedYield;
return info;
}
context.delegate = null;
}
if (method === "next") {
if (state === GenStateSuspendedYield) {
context.sent = arg;
} else {
delete context.sent;
}
} else if (method === "throw") {
if (state === GenStateSuspendedStart) {
state = GenStateCompleted;
throw arg;
}
if (context.dispatchException(arg)) {
// If the dispatched exception was caught by a catch block,
// then let that catch block handle the exception normally.
method = "next";
arg = undefined;
}
} else if (method === "return") {
context.abrupt("return", arg);
}
state = GenStateExecuting;
var record = tryCatch(innerFn, self, context);
if (record.type === "normal") {
// If an exception is thrown from innerFn, we leave state ===
// GenStateExecuting and loop back for another invocation.
state = context.done
? GenStateCompleted
: GenStateSuspendedYield;
var info = {
value: record.arg,
done: context.done
};
if (record.arg === ContinueSentinel) {
if (context.delegate && method === "next") {
// Deliberately forget the last sent value so that we don't
// accidentally pass it on to the delegate.
arg = undefined;
}
} else {
return info;
}
} else if (record.type === "throw") {
state = GenStateCompleted;
// Dispatch the exception by looping back around to the
// context.dispatchException(arg) call above.
method = "throw";
arg = record.arg;
}
}
};
}
function defineGeneratorMethod(method) {
Gp[method] = function(arg) {
return this._invoke(method, arg);
};
}
defineGeneratorMethod("next");
defineGeneratorMethod("throw");
defineGeneratorMethod("return");
Gp[iteratorSymbol] = function() {
return this;
};
Gp.toString = function() {
return "[object Generator]";
};
function pushTryEntry(locs) {
var entry = { tryLoc: locs[0] };
if (1 in locs) {
entry.catchLoc = locs[1];
}
if (2 in locs) {
entry.finallyLoc = locs[2];
entry.afterLoc = locs[3];
}
this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal";
delete record.arg;
entry.completion = record;
}
function Context(tryLocsList) {
// The root entry object (effectively a try statement without a catch
// or a finally block) gives us a place to store values thrown from
// locations where there is no enclosing try statement.
this.tryEntries = [{ tryLoc: "root" }];
tryLocsList.forEach(pushTryEntry, this);
this.reset();
}
runtime.keys = function(object) {
var keys = [];
for (var key in object) {
keys.push(key);
}
keys.reverse();
// Rather than returning an object with a next method, we keep
// things simple and return the next function itself.
return function next() {
while (keys.length) {
var key = keys.pop();
if (key in object) {
next.value = key;
next.done = false;
return next;
}
}
// To avoid creating an additional object, we just hang the .value
// and .done properties off the next function object itself. This
// also ensures that the minifier will not anonymize the function.
next.done = true;
return next;
};
};
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) {
return iteratorMethod.call(iterable);
}
if (typeof iterable.next === "function") {
return iterable;
}
if (!isNaN(iterable.length)) {
var i = -1, next = function next() {
while (++i < iterable.length) {
if (hasOwn.call(iterable, i)) {
next.value = iterable[i];
next.done = false;
return next;
}
}
next.value = undefined;
next.done = true;
return next;
};
return next.next = next;
}
}
// Return an iterator with no values.
return { next: doneResult };
}
runtime.values = values;
function doneResult() {
return { value: undefined, done: true };
}
Context.prototype = {
constructor: Context,
reset: function() {
this.prev = 0;
this.next = 0;
this.sent = undefined;
this.done = false;
this.delegate = null;
this.tryEntries.forEach(resetTryEntry);
// Pre-initialize at least 20 temporary variables to enable hidden
// class optimizations for simple generators.
for (var tempIndex = 0, tempName;
hasOwn.call(this, tempName = "t" + tempIndex) || tempIndex < 20;
++tempIndex) {
this[tempName] = null;
}
},
stop: function() {
this.done = true;
var rootEntry = this.tryEntries[0];
var rootRecord = rootEntry.completion;
if (rootRecord.type === "throw") {
throw rootRecord.arg;
}
return this.rval;
},
dispatchException: function(exception) {
if (this.done) {
throw exception;
}
var context = this;
function handle(loc, caught) {
record.type = "throw";
record.arg = exception;
context.next = loc;
return !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
var record = entry.completion;
if (entry.tryLoc === "root") {
// Exception thrown outside of any try block that could handle
// it, so set the completion value of the entire function to
// throw the exception.
return handle("end");
}
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc");
var hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
} else if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else if (hasCatch) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
}
} else if (hasFinally) {
if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else {
throw new Error("try statement without catch or finally");
}
}
}
},
abrupt: function(type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev &&
hasOwn.call(entry, "finallyLoc") &&
this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
if (finallyEntry &&
(type === "break" ||
type === "continue") &&
finallyEntry.tryLoc <= arg &&
arg <= finallyEntry.finallyLoc) {
// Ignore the finally entry if control is not jumping to a
// location outside the try/catch block.
finallyEntry = null;
}
var record = finallyEntry ? finallyEntry.completion : {};
record.type = type;
record.arg = arg;
if (finallyEntry) {
this.next = finallyEntry.finallyLoc;
} else {
this.complete(record);
}
return ContinueSentinel;
},
complete: function(record, afterLoc) {
if (record.type === "throw") {
throw record.arg;
}
if (record.type === "break" ||
record.type === "continue") {
this.next = record.arg;
} else if (record.type === "return") {
this.rval = record.arg;
this.next = "end";
} else if (record.type === "normal" && afterLoc) {
this.next = afterLoc;
}
},
finish: function(finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) {
this.complete(entry.completion, entry.afterLoc);
resetTryEntry(entry);
return ContinueSentinel;
}
}
},
"catch": function(tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if (record.type === "throw") {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
// The context.catch method must only be called with a location
// argument that corresponds to a known catch block.
throw new Error("illegal catch attempt");
},
delegateYield: function(iterable, resultName, nextLoc) {
this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
};
return ContinueSentinel;
}
};
})(
// Among the various tricks for obtaining a reference to the global
// object, this seems to be the most reliable technique that does not
// use indirect eval (which violates Content Security Policy).
typeof global === "object" ? global :
typeof window === "object" ? window :
typeof self === "object" ? self : this
);
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}]},{},[1]);
Raw
index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>title</title>
<script src="browser-polyfill.js"></script>
</head>
<body>
<script src="script.js"></script>
</body>
</html>
Raw
script.js
(function outer(modules, cache, entries){
/**
* Global
*/
var global = (function(){ return this; })();
/**
* Require `name`.
*
* @param {String} name
* @param {Boolean} jumped
* @api public
*/
function require(name, jumped){
if (cache[name]) return cache[name].exports;
if (modules[name]) return call(name, require);
throw new Error('cannot find module "' + name + '"');
}
/**
* Call module `id` and cache it.
*
* @param {Number} id
* @param {Function} require
* @return {Function}
* @api private
*/
function call(id, require){
var m = { exports: {} };
var mod = modules[id];
var name = mod[2];
var fn = mod[0];
fn.call(m.exports, function(req){
var dep = modules[id][1][req];
return require(dep || req);
}, m, m.exports, outer, modules, cache, entries);
// store to cache after successful resolve
cache[id] = m;
// expose as `name`.
if (name) cache[name] = cache[id];
return cache[id].exports;
}
/**
* Require all entries exposing them on global if needed.
*/
for (var id in entries) {
if (entries[id]) {
global[entries[id]] = require(id);
} else {
require(id);
}
}
/**
* Duo flag.
*/
require.duo = true;
/**
* Expose cache.
*/
require.cache = cache;
/**
* Expose modules
*/
require.modules = modules;
/**
* Return newest require.
*/
return require;
})({
1: [function(require, module, exports) {
/** @jsx element */
'use strict';
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
var _tjCo = require('tj/co');
var _tjCo2 = _interopRequireDefault(_tjCo);
var _brentburgChan = require('brentburg/chan');
var _brentburgChan2 = _interopRequireDefault(_brentburgChan);
var _segmentioDeku = require('segmentio/deku');
var JustDiv = {
propTypes: {
chan: {
type: 'function'
}
},
initialState: function initialState() {
return { value: '' };
},
render: function render(_ref) {
var state = _ref.state;
return (0, _segmentioDeku.element)(
'div',
null,
state.value
);
},
afterMount: function afterMount(_ref2, el, setState) {
var props = _ref2.props;
var chan = props.chan;
// component runetime in a coroutine
(0, _tjCo2['default'])(regeneratorRuntime.mark(function callee$1$0() {
var value;
return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
while (1) switch (context$2$0.prev = context$2$0.next) {
case 0:
if (chan.done()) {
context$2$0.next = 7;
break;
}
context$2$0.next = 3;
return chan;
case 3:
value = context$2$0.sent;
if (value !== chan.empty) {
setState({ value: value });
}
context$2$0.next = 0;
break;
case 7:
case 'end':
return context$2$0.stop();
}
}, callee$1$0, this);
}));
}
};
var JustInput = {
propTypes: {
chan: {
type: 'function'
}
},
render: function render(component) {
var props = component.props;
var emit = function emit() {
props.chan(component.getValue());
};
return (0, _segmentioDeku.element)('input', { type: 'text', onInput: emit });
},
afterMount: function afterMount(component, el) {
component.getValue = function () {
return el.value;
};
}
};
// main app runtime
var chan = (0, _brentburgChan2['default'])();
var app = (0, _segmentioDeku.tree)((0, _segmentioDeku.element)(
'div',
null,
(0, _segmentioDeku.element)(JustDiv, { chan: chan }),
(0, _segmentioDeku.element)(JustInput, { chan: chan })
));
(0, _segmentioDeku.render)(app, document.body);
}, {"tj/co":2,"brentburg/chan":3,"segmentio/deku":4}],
2: [function(require, module, exports) {
/**
* slice() reference.
*/
'use strict';
var slice = Array.prototype.slice;
/**
* Expose `co`.
*/
module.exports = co['default'] = co.co = co;
/**
* Wrap the given generator `fn` into a
* function that returns a promise.
* This is a separate function so that
* every `co()` call doesn't create a new,
* unnecessary closure.
*
* @param {GeneratorFunction} fn
* @return {Function}
* @api public
*/
co.wrap = function (fn) {
createPromise.__generatorFunction__ = fn;
return createPromise;
function createPromise() {
return co.call(this, fn.apply(this, arguments));
}
};
/**
* Execute the generator function or a generator
* and return a promise.
*
* @param {Function} fn
* @return {Promise}
* @api public
*/
function co(gen) {
var ctx = this;
// we wrap everything in a promise to avoid promise chaining,
// which leads to memory leak errors.
// see https://github.com/tj/co/issues/180
return new Promise(function (resolve, reject) {
if (typeof gen === 'function') gen = gen.call(ctx);
if (!gen || typeof gen.next !== 'function') return resolve(gen);
onFulfilled();
/**
* @param {Mixed} res
* @return {Promise}
* @api private
*/
function onFulfilled(res) {
var ret;
try {
ret = gen.next(res);
} catch (e) {
return reject(e);
}
next(ret);
}
/**
* @param {Error} err
* @return {Promise}
* @api private
*/
function onRejected(err) {
var ret;
try {
ret = gen['throw'](err);
} catch (e) {
return reject(e);
}
next(ret);
}
/**
* Get the next value in the generator,
* return a promise.
*
* @param {Object} ret
* @return {Promise}
* @api private
*/
function next(ret) {
if (ret.done) return resolve(ret.value);
var value = toPromise.call(ctx, ret.value);
if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, ' + 'but the following object was passed: "' + String(ret.value) + '"'));
}
});
}
/**
* Convert a `yield`ed value into a promise.
*
* @param {Mixed} obj
* @return {Promise}
* @api private
*/
function toPromise(obj) {
if (!obj) return obj;
if (isPromise(obj)) return obj;
if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
if ('function' == typeof obj) return thunkToPromise.call(this, obj);
if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
if (isObject(obj)) return objectToPromise.call(this, obj);
return obj;
}
/**
* Convert a thunk to a promise.
*
* @param {Function}
* @return {Promise}
* @api private
*/
function thunkToPromise(fn) {
var ctx = this;
return new Promise(function (resolve, reject) {
fn.call(ctx, function (err, res) {
if (err) return reject(err);
if (arguments.length > 2) res = slice.call(arguments, 1);
resolve(res);
});
});
}
/**
* Convert an array of "yieldables" to a promise.
* Uses `Promise.all()` internally.
*
* @param {Array} obj
* @return {Promise}
* @api private
*/
function arrayToPromise(obj) {
return Promise.all(obj.map(toPromise, this));
}
/**
* Convert an object of "yieldables" to a promise.
* Uses `Promise.all()` internally.
*
* @param {Object} obj
* @return {Promise}
* @api private
*/
function objectToPromise(obj) {
var results = new obj.constructor();
var keys = Object.keys(obj);
var promises = [];
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var promise = toPromise.call(this, obj[key]);
if (promise && isPromise(promise)) defer(promise, key);else results[key] = obj[key];
}
return Promise.all(promises).then(function () {
return results;
});
function defer(promise, key) {
// predefine the key in the result
results[key] = undefined;
promises.push(promise.then(function (res) {
results[key] = res;
}));
}
}
/**
* Check if `obj` is a promise.
*
* @param {Object} obj
* @return {Boolean}
* @api private
*/
function isPromise(obj) {
return 'function' == typeof obj.then;
}
/**
* Check if `obj` is a generator.
*
* @param {Mixed} obj
* @return {Boolean}
* @api private
*/
function isGenerator(obj) {
return 'function' == typeof obj.next && 'function' == typeof obj['throw'];
}
/**
* Check if `obj` is a generator function.
*
* @param {Mixed} obj
* @return {Boolean}
* @api private
*/
function isGeneratorFunction(obj) {
var constructor = obj.constructor;
if (!constructor) return false;
if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
return isGenerator(constructor.prototype);
}
/**
* Check for plain object.
*
* @param {Mixed} val
* @return {Boolean}
* @api private
*/
function isObject(val) {
return Object == val.constructor;
}
}, {}],
3: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var make = require('./lib/make');
var select = require('./lib/select');
var timeout = require('./lib/timeout');
var interval = require('./lib/interval');
/**
* Expose `make`.
*/
module.exports = make;
/**
* Expose `select`.
*/
module.exports.select = select;
/**
* Expose `interval`.
*/
module.exports.interval = interval;
/**
* Expose `timeout`.
*/
module.exports.timeout = timeout;
}, {"./lib/make":5,"./lib/select":6,"./lib/timeout":7,"./lib/interval":8}],
5: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var Channel = require('./channel');
var async = require('./async');
/**
* Expose `make`.
*/
module.exports = make;
/**
* Make a channel.
*
* @param {Number} bufferSize optional default=0
* @return {Function}
* @api public
*/
function make(bufferSize) {
var chan = new Channel(bufferSize);
var func = function func(a, b) {
// yielded
if (typeof a === 'function') {
return chan.get(a);
}
// (err, res)
if (a === null && typeof b !== 'undefined') {
a = b;
}
// value
return chan.add(a);
};
// expose public channel methods
func.close = chan.close.bind(chan);
func.done = chan.done.bind(chan);
// bind async helper
func.async = async.bind(null, func);
// expose empty value
func.empty = chan.empty;
// cross reference the channel object and function for internal use
func.__chan = chan;
chan.func = func;
return func;
}
}, {"./channel":9,"./async":10}],
9: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var Receiver = require('./receiver');
/**
* Expose `Channel`.
*/
module.exports = Channel;
/**
* Constants.
*/
var CLOSED_ERROR_MSG = 'Cannot add to closed channel';
/**
* Initialize a `Channel`.
*
* @param {Function|Object} [empty=Object]
* @api private
*/
function Channel(bufferSize) {
this.pendingAdds = [];
this.pendingGets = [];
this.items = [];
this.bufferSize = parseInt(bufferSize, 10) || 0;
this.isClosed = false;
this.isDone = false;
this.empty = {};
}
/**
* Static reference to the most recently called callback
*/
Channel.lastCalled = null;
/**
* Get an item with `cb`.
*
* @param {Function} cb
* @api private
*/
Channel.prototype.get = function (cb) {
if (this.done()) {
this.callEmpty(cb);
} else if (this.items.length > 0 || this.pendingAdds.length > 0) {
this.call(cb, this.nextItem());
} else {
this.pendingGets.push(cb);
}
};
/**
* Remove `cb` from the queue.
*
* @param {Function} cb
* @api private
*/
Channel.prototype.removeGet = function (cb) {
var idx = this.pendingGets.indexOf(cb);
if (idx > -1) {
this.pendingGets.splice(idx, 1);
}
};
/**
* Get the next item and pull from pendingAdds to fill the buffer.
*
* @return {Mixed}
* @api private
*/
Channel.prototype.nextItem = function () {
if (this.pendingAdds.length > 0) {
this.items.push(this.pendingAdds.shift().add());
}
return this.items.shift();
};
/**
* Add `val` to the channel.
*
* @param {Mixed} val
* @return {Function} thunk
* @api private
*/
Channel.prototype.add = function (val) {
var receiver = new Receiver(val);
if (this.isClosed) {
receiver.error(Error(CLOSED_ERROR_MSG));
} else if (this.pendingGets.length > 0) {
this.call(this.pendingGets.shift(), receiver.add());
} else if (this.items.length < this.bufferSize) {
this.items.push(receiver.add());
} else {
this.pendingAdds.push(receiver);
}
return function (cb) {
receiver.callback(cb);
};
};
/**
* Invoke `cb` with `val` facilitate both
* `chan(value)` and the `chan(error, value)`
* use-cases.
*
* @param {Function} cb
* @param {Mixed} val
* @api private
*/
Channel.prototype.call = function (cb, val) {
Channel.lastCalled = this.func;
if (val instanceof Error) {
cb(val);
} else {
cb(null, val);
}
this.done();
};
/**
* Invoke `cb` callback with the empty value.
*
* @param {Function} cb
* @api private
*/
Channel.prototype.callEmpty = function (cb) {
this.call(cb, this.empty);
};
/**
* Prevennt future values from being added to
* the channel.
*
* @return {Boolean}
* @api public
*/
Channel.prototype.close = function () {
this.isClosed = true;
var receiver;
while (receiver = this.pendingAdds.shift()) {
receiver.error(Error(CLOSED_ERROR_MSG));
}
return this.done();
};
/**
* Check to see if the channel is done and
* call pending callbacks if necessary.
*
* @return {Boolean}
* @api private
*/
Channel.prototype.done = function () {
if (!this.isDone && this.isClosed && this.items.length === 0) {
this.isDone = true;
// call each pending callback with the empty value
this.pendingGets.forEach(function (cb) {
this.callEmpty(cb);
}, this);
}
return this.isDone;
};
}, {"./receiver":11}],
11: [function(require, module, exports) {
/**
* Expose `Receiver`.
*/
"use strict";
module.exports = Receiver;
/**
* Initialize a `Receiver`.
*
* @param {Mixed} val
* @api private
*/
function Receiver(val) {
this.val = val;
this.isAdded = false;
this.err = null;
this.cb = null;
this.isDone = false;
}
/**
* Call the callback if the pending add is complete.
*
* @api private
*/
Receiver.prototype.attemptNotify = function () {
if ((this.isAdded || this.err) && this.cb && !this.isDone) {
this.isDone = true;
setImmediate((function () {
this.cb(this.err);
}).bind(this));
}
};
/**
* Reject the pending add with an error.
*
* @param {Error} err
* @api private
*/
Receiver.prototype.error = function (err) {
this.err = err;
this.attemptNotify();
};
/**
* Get the `val` and set the state of the value to added
*
* @return {Mixed} val
* @api private
*/
Receiver.prototype.add = function () {
this.isAdded = true;
this.attemptNotify();
return this.val;
};
/**
* Register the callback.
*
* @api private
*/
Receiver.prototype.callback = function (cb) {
this.cb = cb;
this.attemptNotify();
};
}, {}],
10: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var Receiver = require('./receiver');
/**
* Expose `async`.
*/
module.exports = async;
/**
* Add value to channel via node-style async function.
*
* @param {Function} channel
* @param {Function|Object} fn async function or object with async method
* @param {String} method name only if fn is an object
* @param {mixed} args async function arguments without callback
* @return {Function} thunk
*/
function async(ch, fn /*, args...*/) {
var args = [].slice.call(arguments, 2);
var receiver = new Receiver();
var context = null;
if (typeof fn === 'object') {
context = fn;
fn = fn[args.shift()];
}
args.push(function (err, val) {
if (arguments.length > 2) {
val = [].slice.call(arguments, 1);
}
ch(err, val)(function (err) {
receiver[err ? 'error' : 'add'](err);
});
});
fn.apply(context, args);
return function (cb) {
receiver.callback(cb);
};
}
}, {"./receiver":11}],
6: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var make = require('./make');
var Channel = require('./channel');
/**
* Expose `select`.
*/
module.exports = select;
/**
* Return the first of the given channels with a value.
*
* @param {Function} channels...
* @return {Function}
* @api public
*/
function select() {
var selectCh = make(arguments.length);
var chans = [].slice.call(arguments, 0);
var remaining = chans.length;
// get all channels with values waiting
var full = chans.filter(function (ch) {
return ch.__chan.items.length + ch.__chan.pendingAdds.length > 0;
});
// define get callback
var get = function get(err, value) {
var args = arguments;
var ch = Channel.lastCalled;
// don't select an channel returning an empty value, unless it is last
if (value === ch.empty && --remaining > 0) {
return;
}
// remove get callback from all selected channels
chans.forEach(function (ch) {
ch.__chan.removeGet(get);
});
// add temporary selected yieldable function
ch.selected = function (cb) {
delete ch.selected;
cb.apply(null, args);
};
// added the selected channel to the select channel
selectCh(null, ch);
selectCh.close();
};
if (full.length > 1) {
// multiple channels with waiting values, pick one at random
full[Math.floor(Math.random() * full.length)](get);
} else {
// add get callback to all channels
chans.forEach(function (ch) {
ch(get);
});
}
return selectCh;
}
/*channels...*/
}, {"./make":5,"./channel":9}],
7: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var make = require('./make');
/**
* Expose `timeoutChan`.
*/
module.exports = timeoutChan;
/**
* Make a timeout channel that receives `true` after a number of milliseconds.
*
* @param {Number} ms
* @returns {Function} channel
* @api public
*/
function timeoutChan(ms) {
var ch = make();
setTimeout(function () {
try {
ch(true);
ch.close();
} catch (err) {}
}, ms);
return ch;
}
}, {"./make":5}],
8: [function(require, module, exports) {
/**
* Module dependencies.
*/
'use strict';
var make = require('./make');
/**
* Expose `intervalChan`.
*/
module.exports = intervalChan;
/**
* Make a interval channel that receives a count every number of milliseconds.
*
* @param {Number} ms
* @returns {Function} channel
* @api public
*/
function intervalChan(ms) {
var ch = make();
var count = 0;
var int = setInterval(function () {
try {
ch(++count);
} catch (err) {
clearInterval(int);
}
}, ms);
return ch;
}
}, {"./make":5}],
4: [function(require, module, exports) {
"use strict";
!(function (e) {
if ("object" == typeof exports && "undefined" != typeof module) module.exports = e();else if ("function" == typeof define && define.amd) define([], e);else {
var f;"undefined" != typeof window ? f = window : "undefined" != typeof global ? f = global : "undefined" != typeof self && (f = self), f.deku = e();
}
})(function () {
var define, module, exports;return (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 < r.length; o++) s(r[o]);return s;
})({ 1: [function (_require, module, exports) {
/**
* Module dependencies.
*/
var Emitter = _require("component-emitter");
/**
* Expose `scene`.
*/
module.exports = Application;
/**
* Create a new `Application`.
*
* @param {Object} element Optional initial element
*/
function Application(element) {
if (!(this instanceof Application)) return new Application(element);
this.options = {};
this.sources = {};
this.element = element;
}
/**
* Mixin `Emitter`.
*/
Emitter(Application.prototype);
/**
* Add a plugin
*
* @param {Function} plugin
*/
Application.prototype.use = function (plugin) {
plugin(this);
return this;
};
/**
* Set an option
*
* @param {String} name
*/
Application.prototype.option = function (name, val) {
this.options[name] = val;
return this;
};
/**
* Set value used somewhere in the IO network.
*/
Application.prototype.set = function (name, data) {
this.sources[name] = data;
this.emit("source", name, data);
return this;
};
/**
* Mount a virtual element.
*
* @param {VirtualElement} element
*/
Application.prototype.mount = function (element) {
this.element = element;
this.emit("mount", element);
return this;
};
/**
* Remove the world. Unmount everything.
*/
Application.prototype.unmount = function () {
if (!this.element) return;
this.element = null;
this.emit("unmount");
return this;
};
}, { "component-emitter": 9 }], 2: [function (_require, module, exports) {
/**
* Create the application.
*/
exports.tree = exports.scene = exports.deku = _require("./application");
/**
* Render scenes to the DOM.
*/
if (typeof document !== "undefined") {
exports.render = _require("./render");
}
/**
* Render scenes to a string
*/
exports.renderString = _require("./stringify");
/**
* Create virtual elements.
*/
exports.element = exports.dom = _require("./virtual");
}, { "./application": 1, "./render": 3, "./stringify": 4, "./virtual": 7 }], 3: [function (_require, module, exports) {
/**
* Dependencies.
*/
var raf = _require("component-raf");
var Pool = _require("dom-pool");
var walk = _require("dom-walk");
var isDom = _require("is-dom");
var uid = _require("get-uid");
var throttle = _require("per-frame");
var keypath = _require("object-path");
var type = _require("component-type");
var utils = _require("./utils");
var svg = _require("./svg");
var defaults = utils.defaults;
var forEach = _require("fast.js/forEach");
var assign = _require("fast.js/object/assign");
var reduce = _require("fast.js/reduce");
var isPromise = _require("is-promise");
/**
* All of the events can bind to
*/
var events = {
onBlur: "blur",
onChange: "change",
onClick: "click",
onContextMenu: "contextmenu",
onCopy: "copy",
onCut: "cut",
onDoubleClick: "dblclick",
onDrag: "drag",
onDragEnd: "dragend",
onDragEnter: "dragenter",
onDragExit: "dragexit",
onDragLeave: "dragleave",
onDragOver: "dragover",
onDragStart: "dragstart",
onDrop: "drop",
onFocus: "focus",
onInput: "input",
onKeyDown: "keydown",
onKeyUp: "keyup",
onMouseDown: "mousedown",
onMouseEnter: "mouseenter",
onMouseLeave: "mouseleave",
onMouseMove: "mousemove",
onMouseOut: "mouseout",
onMouseOver: "mouseover",
onMouseUp: "mouseup",
onPaste: "paste",
onScroll: "scroll",
onSubmit: "submit",
onTouchCancel: "touchcancel",
onTouchEnd: "touchend",
onTouchMove: "touchmove",
onTouchStart: "touchstart"
};
/**
* These elements won't be pooled
*/
var avoidPooling = ["input", "textarea"];
/**
* Expose `dom`.
*/
module.exports = render;
/**
* Render an app to the DOM
*
* @param {Application} app
* @param {HTMLElement} container
* @param {Object} opts
*
* @return {Object}
*/
function render(app, container, opts) {
var frameId;
var isRendering;
var rootId = "root";
var currentElement;
var currentNativeElement;
var connections = {};
var components = {};
var entities = {};
var pools = {};
var handlers = {};
var mountQueue = [];
var children = {};
children[rootId] = {};
if (!isDom(container)) {
throw new Error("Container element must be a DOM element");
}
/**
* Rendering options. Batching is only ever really disabled
* when running tests, and pooling can be disabled if the user
* is doing something stupid with the DOM in their components.
*/
var options = defaults(assign({}, app.options || {}, opts || {}), {
pooling: true,
batching: true,
validateProps: false
});
/**
* Listen to DOM events
*/
addNativeEventListeners();
/**
* Watch for changes to the app so that we can update
* the DOM as needed.
*/
app.on("unmount", onunmount);
app.on("mount", onmount);
app.on("source", onupdate);
/**
* If the app has already mounted an element, we can just
* render that straight away.
*/
if (app.element) render();
/**
* Teardown the DOM rendering so that it stops
* rendering and everything can be garbage collected.
*/
function teardown() {
removeNativeEventListeners();
removeNativeElement();
app.off("unmount", onunmount);
app.off("mount", onmount);
app.off("source", onupdate);
}
/**
* Swap the current rendered node with a new one that is rendered
* from the new virtual element mounted on the app.
*
* @param {VirtualElement} element
*/
function onmount() {
invalidate();
}
/**
* If the app unmounts an element, we should clear out the current
* rendered element. This will remove all the entities.
*/
function onunmount() {
removeNativeElement();
currentElement = null;
}
/**
* Update all components that are bound to the source
*
* @param {String} name
* @param {*} data
*/
function onupdate(name, data) {
if (!connections[name]) return;
connections[name].forEach(function (update) {
update(data);
});
}
/**
* Render and mount a component to the native dom.
*
* @param {Entity} entity
* @return {HTMLElement}
*/
function mountEntity(entity) {
register(entity);
setSources(entity);
children[entity.id] = {};
entities[entity.id] = entity;
// commit initial state and props.
commit(entity);
// callback before mounting.
trigger("beforeMount", entity, [entity.context]);
trigger("beforeRender", entity, [entity.context]);
// render virtual element.
var virtualElement = renderEntity(entity);
// create native element.
var nativeElement = toNative(entity.id, "0", virtualElement);
entity.virtualElement = virtualElement;
entity.nativeElement = nativeElement;
// Fire afterRender and afterMount hooks at the end
// of the render cycle
mountQueue.push(entity.id);
return nativeElement;
}
/**
* Remove a component from the native dom.
*
* @param {Entity} entity
*/
function unmountEntity(entityId) {
var entity = entities[entityId];
if (!entity) return;
trigger("beforeUnmount", entity, [entity.context, entity.nativeElement]);
unmountChildren(entityId);
removeAllEvents(entityId);
var componentEntities = components[entityId].entities;
delete componentEntities[entityId];
delete components[entityId];
delete entities[entityId];
delete children[entityId];
}
/**
* Render the entity and make sure it returns a node
*
* @param {Entity} entity
*
* @return {VirtualTree}
*/
function renderEntity(entity) {
var component = entity.component;
if (!component.render) throw new Error("Component needs a render function");
var result = component.render(entity.context, setState(entity));
if (!result) throw new Error("Render function must return an element.");
return result;
}
/**
* Whenever setState or setProps is called, we mark the entity
* as dirty in the renderer. This lets us optimize the re-rendering
* and skip components that definitely haven't changed.
*
* @param {Entity} entity
*
* @return {Function} A curried function for updating the state of an entity
*/
function setState(entity) {
return function (nextState) {
updateEntityStateAsync(entity, nextState);
};
}
/**
* Tell the app it's dirty and needs to re-render. If batching is disabled
* we can just trigger a render immediately, otherwise we'll wait until
* the next available frame.
*/
function invalidate() {
if (!options.batching) {
if (!isRendering) render();
} else {
if (!frameId) frameId = raf(render);
}
}
/**
* Update the DOM. If the update fails we stop the loop
* so we don't get errors on every frame.
*
* @api public
*/
function render() {
// If this is called synchronously we need to
// cancel any pending future updates
clearFrame();
// If the rendering from the previous frame is still going,
// we'll just wait until the next frame. Ideally renders should
// not take over 16ms to stay within a single frame, but this should
// catch it if it does.
if (isRendering) {
frameId = raf(render);
return;
} else {
isRendering = true;
}
// 1. If there isn't a native element rendered for the current mounted element
// then we need to create it from scratch.
// 2. If a new element has been mounted, we should diff them.
// 3. We should update check all child components for changes.
if (!currentNativeElement) {
currentElement = app.element;
currentNativeElement = toNative(rootId, "0", currentElement);
if (container.children.length > 0) {
console.info("deku: The container element is not empty. These elements will be removed. Read more: http://cl.ly/b0Sr");
}
if (container === document.body) {
console.warn("deku: Using document.body is allowed but it can cause some issues. Read more: http://cl.ly/b0SC");
}
removeAllChildren(container);
container.appendChild(currentNativeElement);
} else if (currentElement !== app.element) {
currentNativeElement = patch(rootId, currentElement, app.element, currentNativeElement);
currentElement = app.element;
updateChildren(rootId);
} else {
updateChildren(rootId);
}
// Call mount events on all new entities
flushMountQueue();
// Allow rendering again.
isRendering = false;
}
/**
* Call hooks for all new entities that have been created in
* the last render from the bottom up.
*/
function flushMountQueue() {
var entityId;
while (entityId = mountQueue.pop()) {
var entity = entities[entityId];
trigger("afterRender", entity, [entity.context, entity.nativeElement]);
triggerUpdate("afterMount", entity, [entity.context, entity.nativeElement, setState(entity)]);
}
}
/**
* Clear the current scheduled frame
*/
function clearFrame() {
if (!frameId) return;
raf.cancel(frameId);
frameId = 0;
}
/**
* Update a component.
*
* The entity is just the data object for a component instance.
*
* @param {String} id Component instance id.
*/
function updateEntity(entityId) {
var entity = entities[entityId];
setSources(entity);
if (!shouldUpdate(entity)) return updateChildren(entityId);
var currentTree = entity.virtualElement;
var nextProps = entity.pendingProps;
var nextState = entity.pendingState;
var previousState = entity.context.state;
var previousProps = entity.context.props;
// hook before rendering. could modify state just before the render occurs.
trigger("beforeUpdate", entity, [entity.context, nextProps, nextState]);
trigger("beforeRender", entity, [entity.context]);
// commit state and props.
commit(entity);
// re-render.
var nextTree = renderEntity(entity);
// if the tree is the same we can just skip this component
// but we should still check the children to see if they're dirty.
// This allows us to memoize the render function of components.
if (nextTree === currentTree) return updateChildren(entityId);
// apply new virtual tree to native dom.
entity.nativeElement = patch(entityId, currentTree, nextTree, entity.nativeElement);
entity.virtualElement = nextTree;
updateChildren(entityId);
// trigger render hook
trigger("afterRender", entity, [entity.context, entity.nativeElement]);
// trigger afterUpdate after all children have updated.
triggerUpdate("afterUpdate", entity, [entity.context, previousProps, previousState]);
}
/**
* Update all the children of an entity.
*
* @param {String} id Component instance id.
*/
function updateChildren(entityId) {
forEach(children[entityId], function (childId) {
updateEntity(childId);
});
}
/**
* Remove all of the child entities of an entity
*
* @param {Entity} entity
*/
function unmountChildren(entityId) {
forEach(children[entityId], function (childId) {
unmountEntity(childId);
});
}
/**
* Remove the root element. If this is called synchronously we need to
* cancel any pending future updates.
*/
function removeNativeElement() {
clearFrame();
removeElement(rootId, "0", currentNativeElement);
currentNativeElement = null;
}
/**
* Create a native element from a virtual element.
*
* @param {String} entityId
* @param {String} path
* @param {Object} vnode
*
* @return {HTMLDocumentFragment}
*/
function toNative(entityId, path, vnode) {
switch (vnode.type) {
case "text":
return toNativeText(vnode);
case "element":
return toNativeElement(entityId, path, vnode);
case "component":
return toNativeComponent(entityId, path, vnode);
}
}
/**
* Create a native text element from a virtual element.
*
* @param {Object} vnode
*/
function toNativeText(vnode) {
return document.createTextNode(vnode.data);
}
/**
* Create a native element from a virtual element.
*/
function toNativeElement(entityId, path, vnode) {
var attributes = vnode.attributes;
var children = vnode.children;
var tagName = vnode.tagName;
var el;
// create element either from pool or fresh.
if (!options.pooling || !canPool(tagName)) {
if (svg.isElement(tagName)) {
el = document.createElementNS(svg.namespace, tagName);
} else {
el = document.createElement(tagName);
}
} else {
var pool = getPool(tagName);
el = cleanup(pool.pop());
if (el.parentNode) el.parentNode.removeChild(el);
}
// set attributes.
forEach(attributes, function (value, name) {
setAttribute(entityId, path, el, name, value);
});
// store keys on the native element for fast event handling.
el.__entity__ = entityId;
el.__path__ = path;
// add children.
forEach(children, function (child, i) {
var childEl = toNative(entityId, path + "." + i, child);
if (!childEl.parentNode) el.appendChild(childEl);
});
return el;
}
/**
* Create a native element from a component.
*/
function toNativeComponent(entityId, path, vnode) {
var child = new Entity(vnode.component, vnode.props, entityId);
children[entityId][path] = child.id;
return mountEntity(child);
}
/**
* Patch an element with the diff from two trees.
*/
function patch(entityId, prev, next, el) {
return diffNode("0", entityId, prev, next, el);
}
/**
* Create a diff between two trees of nodes.
*/
function diffNode(path, entityId, prev, next, el) {
// Type changed. This could be from element->text, text->ComponentA,
// ComponentA->ComponentB etc. But NOT div->span. These are the same type
// (ElementNode) but different tag name.
if (prev.type !== next.type) return replaceElement(entityId, path, el, next);
switch (next.type) {
case "text":
return diffText(prev, next, el);
case "element":
return diffElement(path, entityId, prev, next, el);
case "component":
return diffComponent(path, entityId, prev, next, el);
}
}
/**
* Diff two text nodes and update the element.
*/
function diffText(previous, current, el) {
if (current.data !== previous.data) el.data = current.data;
return el;
}
/**
* Diff the children of an ElementNode.
*/
function diffChildren(path, entityId, prev, next, el) {
var positions = [];
var hasKeys = false;
var childNodes = Array.prototype.slice.apply(el.childNodes);
var leftKeys = reduce(prev.children, keyMapReducer, {});
var rightKeys = reduce(next.children, keyMapReducer, {});
var currentChildren = assign({}, children[entityId]);
function keyMapReducer(acc, child) {
if (child.key != null) {
acc[child.key] = child;
hasKeys = true;
}
return acc;
}
// Diff all of the nodes that have keys. This lets us re-used elements
// instead of overriding them and lets us move them around.
if (hasKeys) {
// Removals
forEach(leftKeys, function (leftNode, key) {
if (rightKeys[key] == null) {
var leftPath = path + "." + leftNode.index;
removeElement(entityId, leftPath, childNodes[leftNode.index]);
}
});
// Update nodes
forEach(rightKeys, function (rightNode, key) {
var leftNode = leftKeys[key];
// We only want updates for now
if (leftNode == null) return;
var leftPath = path + "." + leftNode.index;
// Updated
positions[rightNode.index] = diffNode(leftPath, entityId, leftNode, rightNode, childNodes[leftNode.index]);
});
// Update the positions of all child components and event handlers
forEach(rightKeys, function (rightNode, key) {
var leftNode = leftKeys[key];
// We just want elements that have moved around
if (leftNode == null || leftNode.index === rightNode.index) return;
var rightPath = path + "." + rightNode.index;
var leftPath = path + "." + leftNode.index;
// Update all the child component path positions to match
// the latest positions if they've changed. This is a bit hacky.
forEach(currentChildren, function (childId, childPath) {
if (leftPath === childPath) {
delete children[entityId][childPath];
children[entityId][rightPath] = childId;
}
});
});
// Now add all of the new nodes last in case their path
// would have conflicted with one of the previous paths.
forEach(rightKeys, function (rightNode, key) {
var rightPath = path + "." + rightNode.index;
if (leftKeys[key] == null) {
positions[rightNode.index] = toNative(entityId, rightPath, rightNode);
}
});
} else {
var maxLength = Math.max(prev.children.length, next.children.length);
// Now diff all of the nodes that don't have keys
for (var i = 0; i < maxLength; i++) {
var leftNode = prev.children[i];
var rightNode = next.children[i];
// Removals
if (rightNode == null) {
removeElement(entityId, path + "." + leftNode.index, childNodes[leftNode.index]);
}
// New Node
if (leftNode == null) {
positions[rightNode.index] = toNative(entityId, path + "." + rightNode.index, rightNode);
}
// Updated
if (leftNode && rightNode) {
positions[leftNode.index] = diffNode(path + "." + leftNode.index, entityId, leftNode, rightNode, childNodes[leftNode.index]);
}
}
}
// Reposition all the elements
forEach(positions, function (childEl, newPosition) {
var target = el.childNodes[newPosition];
if (childEl !== target) {
if (target) {
el.insertBefore(childEl, target);
} else {
el.appendChild(childEl);
}
}
});
}
/**
* Diff the attributes and add/remove them.
*/
function diffAttributes(prev, next, el, entityId, path) {
var nextAttrs = next.attributes;
var prevAttrs = prev.attributes;
// add new attrs
forEach(nextAttrs, function (value, name) {
if (events[name] || !(name in prevAttrs) || prevAttrs[name] !== value) {
setAttribute(entityId, path, el, name, value);
}
});
// remove old attrs
forEach(prevAttrs, function (value, name) {
if (!(name in nextAttrs)) {
removeAttribute(entityId, path, el, name);
}
});
}
/**
* Update a component with the props from the next node. If
* the component type has changed, we'll just remove the old one
* and replace it with the new component.
*/
function diffComponent(path, entityId, prev, next, el) {
if (next.component !== prev.component) {
return replaceElement(entityId, path, el, next);
} else {
var targetId = children[entityId][path];
// This is a hack for now
if (targetId) {
updateEntityProps(targetId, next.props);
}
return el;
}
}
/**
* Diff two element nodes.
*/
function diffElement(path, entityId, prev, next, el) {
if (next.tagName !== prev.tagName) return replaceElement(entityId, path, el, next);
diffAttributes(prev, next, el, entityId, path);
diffChildren(path, entityId, prev, next, el);
return el;
}
/**
* Removes an element from the DOM and unmounts and components
* that are within that branch
*
* side effects:
* - removes element from the DOM
* - removes internal references
*
* @param {String} entityId
* @param {String} path
* @param {HTMLElement} el
*/
function removeElement(entityId, path, el) {
var childrenByPath = children[entityId];
var childId = childrenByPath[path];
var entityHandlers = handlers[entityId] || {};
var removals = [];
// If the path points to a component we should use that
// components element instead, because it might have moved it.
if (childId) {
var child = entities[childId];
el = child.nativeElement;
unmountEntity(childId);
removals.push(path);
} else {
// Just remove the text node
if (!isElement(el)) return el.parentNode.removeChild(el);
// Then we need to find any components within this
// branch and unmount them.
forEach(childrenByPath, function (childId, childPath) {
if (childPath === path || isWithinPath(path, childPath)) {
unmountEntity(childId);
removals.push(childPath);
}
});
// Remove all events at this path or below it
forEach(entityHandlers, function (fn, handlerPath) {
if (handlerPath === path || isWithinPath(path, handlerPath)) {
removeEvent(entityId, handlerPath);
}
});
}
// Remove the paths from the object without touching the
// old object. This keeps the object using fast properties.
forEach(removals, function (path) {
delete children[entityId][path];
});
// Remove it from the DOM
el.parentNode.removeChild(el);
// Return all of the elements in this node tree to the pool
// so that the elements can be re-used.
if (options.pooling) {
walk(el, function (node) {
if (!isElement(node) || !canPool(node.tagName)) return;
getPool(node.tagName.toLowerCase()).push(node);
});
}
}
/**
* Replace an element in the DOM. Removing all components
* within that element and re-rendering the new virtual node.
*
* @param {Entity} entity
* @param {String} path
* @param {HTMLElement} el
* @param {Object} vnode
*
* @return {void}
*/
function replaceElement(entityId, path, el, vnode) {
var parent = el.parentNode;
var index = Array.prototype.indexOf.call(parent.childNodes, el);
// remove the previous element and all nested components. This
// needs to happen before we create the new element so we don't
// get clashes on the component paths.
removeElement(entityId, path, el);
// then add the new element in there
var newEl = toNative(entityId, path, vnode);
var target = parent.childNodes[index];
if (target) {
parent.insertBefore(newEl, target);
} else {
parent.appendChild(newEl);
}
// walk up the tree and update all `entity.nativeElement` references.
if (entityId !== "root" && path === "0") {
updateNativeElement(entityId, newEl);
}
return newEl;
}
/**
* Update all entities in a branch that have the same nativeElement. This
* happens when a component has another component as it's root node.
*
* @param {String} entityId
* @param {HTMLElement} newEl
*
* @return {void}
*/
function updateNativeElement(entityId, newEl) {
var target = entities[entityId];
if (target.ownerId === "root") return;
if (children[target.ownerId]["0"] === entityId) {
entities[target.ownerId].nativeElement = newEl;
updateNativeElement(target.ownerId, newEl);
}
}
/**
* Set the attribute of an element, performing additional transformations
* dependning on the attribute name
*
* @param {HTMLElement} el
* @param {String} name
* @param {String} value
*/
function setAttribute(entityId, path, el, name, value) {
if (events[name]) {
addEvent(entityId, path, events[name], value);
return;
}
switch (name) {
case "checked":
case "disabled":
case "selected":
el[name] = true;
break;
case "innerHTML":
case "value":
el[name] = value;
break;
case svg.isAttribute(name):
el.setAttributeNS(svg.namespace, name, value);
break;
default:
el.setAttribute(name, value);
break;
}
}
/**
* Remove an attribute, performing additional transformations
* dependning on the attribute name
*
* @param {HTMLElement} el
* @param {String} name
*/
function removeAttribute(entityId, path, el, name) {
if (events[name]) {
removeEvent(entityId, path, events[name]);
return;
}
switch (name) {
case "checked":
case "disabled":
case "selected":
el[name] = false;
break;
case "innerHTML":
case "value":
el[name] = "";
break;
default:
el.removeAttribute(name);
break;
}
}
/**
* Checks to see if one tree path is within
* another tree path. Example:
*
* 0.1 vs 0.1.1 = true
* 0.2 vs 0.3.5 = false
*
* @param {String} target
* @param {String} path
*
* @return {Boolean}
*/
function isWithinPath(target, path) {
return path.indexOf(target + ".") === 0;
}
/**
* Is the DOM node an element node
*
* @param {HTMLElement} el
*
* @return {Boolean}
*/
function isElement(el) {
return !!el.tagName;
}
/**
* Get the pool for a tagName, creating it if it
* doesn't exist.
*
* @param {String} tagName
*
* @return {Pool}
*/
function getPool(tagName) {
var pool = pools[tagName];
if (!pool) {
var poolOpts = svg.isElement(tagName) ? { namespace: svg.namespace, tagName: tagName } : { tagName: tagName };
pool = pools[tagName] = new Pool(poolOpts);
}
return pool;
}
/**
* Clean up previously used native element for reuse.
*
* @param {HTMLElement} el
*/
function cleanup(el) {
removeAllChildren(el);
removeAllAttributes(el);
return el;
}
/**
* Remove all the attributes from a node
*
* @param {HTMLElement} el
*/
function removeAllAttributes(el) {
for (var i = el.attributes.length - 1; i >= 0; i--) {
var name = el.attributes[i].name;
el.removeAttribute(name);
}
}
/**
* Remove all the child nodes from an element
*
* @param {HTMLElement} el
*/
function removeAllChildren(el) {
while (el.firstChild) el.removeChild(el.firstChild);
}
/**
* Trigger a hook on a component.
*
* @param {String} name Name of hook.
* @param {Entity} entity The component instance.
* @param {Array} args To pass along to hook.
*/
function trigger(name, entity, args) {
if (typeof entity.component[name] !== "function") return;
return entity.component[name].apply(null, args);
}
/**
* Trigger a hook on the component and allow state to be
* updated too.
*
* @param {String} name
* @param {Object} entity
* @param {Array} args
*
* @return {void}
*/
function triggerUpdate(name, entity, args) {
var update = setState(entity);
args.push(update);
var result = trigger(name, entity, args);
if (result) {
updateEntityStateAsync(entity, result);
}
}
/**
* Update the entity state using a promise
*
* @param {Entity} entity
* @param {Promise} promise
*/
function updateEntityStateAsync(entity, value) {
if (isPromise(value)) {
value.then(function (newState) {
updateEntityState(entity, newState);
});
} else {
updateEntityState(entity, value);
}
}
/**
* Update an entity to match the latest rendered vode. We always
* replace the props on the component when composing them. This
* will trigger a re-render on all children below this point.
*
* @param {Entity} entity
* @param {String} path
* @param {Object} vnode
*
* @return {void}
*/
function updateEntityProps(entityId, nextProps) {
var entity = entities[entityId];
entity.pendingProps = nextProps;
entity.dirty = true;
invalidate();
}
/**
* Update component instance state.
*/
function updateEntityState(entity, nextState) {
entity.pendingState = assign(entity.pendingState, nextState);
entity.dirty = true;
invalidate();
}
/**
* Commit props and state changes to an entity.
*/
function commit(entity) {
entity.context = {
state: entity.pendingState,
props: entity.pendingProps,
id: entity.id
};
entity.pendingState = assign({}, entity.context.state);
entity.pendingProps = assign({}, entity.context.props);
validateProps(entity.context.props, entity.propTypes);
entity.dirty = false;
}
/**
* Try to avoid creating new virtual dom if possible.
*
* Later we may expose this so you can override, but not there yet.
*/
function shouldUpdate(entity) {
if (!entity.dirty) return false;
if (!entity.component.shouldUpdate) return true;
var nextProps = entity.pendingProps;
var nextState = entity.pendingState;
var bool = entity.component.shouldUpdate(entity.context, nextProps, nextState);
return bool;
}
/**
* Register an entity.
*
* This is mostly to pre-preprocess component properties and values chains.
*
* The end result is for every component that gets mounted,
* you create a set of IO nodes in the network from the `value` definitions.
*
* @param {Component} component
*/
function register(entity) {
var component = entity.component;
// all entities for this component type.
var entities = component.entities = component.entities || {};
// add entity to component list
entities[entity.id] = entity;
// map to component so you can remove later.
components[entity.id] = component;
// get 'class-level' sources.
var sources = component.sources;
if (sources) return;
var map = component.sourceToPropertyName = {};
component.sources = sources = [];
var propTypes = component.propTypes;
for (var name in propTypes) {
var data = propTypes[name];
if (!data) continue;
if (!data.source) continue;
sources.push(data.source);
map[data.source] = name;
}
// send value updates to all component instances.
sources.forEach(function (source) {
connections[source] = connections[source] || [];
connections[source].push(update);
function update(data) {
var prop = map[source];
for (var entityId in entities) {
var entity = entities[entityId];
var changes = {};
changes[prop] = data;
updateEntityProps(entityId, assign(entity.pendingProps, changes));
}
}
});
}
/**
* Set the initial source value on the entity
*
* @param {Entity} entity
*/
function setSources(entity) {
var component = entity.component;
var map = component.sourceToPropertyName;
var sources = component.sources;
sources.forEach(function (source) {
var name = map[source];
if (entity.pendingProps[name] != null) return;
entity.pendingProps[name] = app.sources[source] // get latest value plugged into global store
;
});
}
/**
* Add all of the DOM event listeners
*/
function addNativeEventListeners() {
forEach(events, function (eventType) {
document.body.addEventListener(eventType, handleEvent, true);
});
}
/**
* Add all of the DOM event listeners
*/
function removeNativeEventListeners() {
forEach(events, function (eventType) {
document.body.removeEventListener(eventType, handleEvent, true);
});
}
/**
* Handle an event that has occured within the container
*
* @param {Event} event
*/
function handleEvent(event) {
var target = event.target;
var entityId = target.__entity__;
var eventType = event.type;
// Walk up the DOM tree and see if there is a handler
// for this event type higher up.
while (target && target.__entity__ === entityId) {
var fn = keypath.get(handlers, [entityId, target.__path__, eventType]);
if (fn) {
event.delegateTarget = target;
fn(event);
break;
}
target = target.parentNode;
}
}
/**
* Bind events for an element, and all it's rendered child elements.
*
* @param {String} path
* @param {String} event
* @param {Function} fn
*/
function addEvent(entityId, path, eventType, fn) {
keypath.set(handlers, [entityId, path, eventType], throttle(function (e) {
var entity = entities[entityId];
if (entity) {
var update = setState(entity);
var result = fn.call(null, e, entity.context, update);
if (result) {
updateEntityStateAsync(entity, result);
}
} else {
fn.call(null, e);
}
}));
}
/**
* Unbind events for a entityId
*
* @param {String} entityId
*/
function removeEvent(entityId, path, eventType) {
var args = [entityId];
if (path) args.push(path);
if (eventType) args.push(eventType);
keypath.del(handlers, args);
}
/**
* Unbind all events from an entity
*
* @param {Entity} entity
*/
function removeAllEvents(entityId) {
keypath.del(handlers, [entityId]);
}
/**
* Validate the current properties. These simple validations
* make it easier to ensure the correct props are passed in.
*
* Available rules include:
*
* type: {String} string | array | object | boolean | number | date | function
* {Array} An array of types mentioned above
* {Function} fn(value) should return `true` to pass in
* expects: [] An array of values this prop could equal
* optional: Boolean
*/
function validateProps(props, rules, optPrefix) {
var prefix = optPrefix || "";
if (!options.validateProps) return;
forEach(rules, function (options, name) {
if (!options) {
throw new Error("deku: propTypes should have an options object for each type");
}
var propName = prefix ? prefix + "." + name : name;
var value = keypath.get(props, name);
var valueType = type(value);
var typeFormat = type(options.type);
var optional = options.optional === true;
// If it's optional and doesn't exist
if (optional && value == null) {
return;
}
// If it's required and doesn't exist
if (!optional && value == null) {
throw new TypeError("Missing property: " + propName);
}
// It's a nested type
if (typeFormat === "object") {
validateProps(value, options.type, propName);
return;
}
// If it's the incorrect type
if (typeFormat === "string" && valueType !== options.type) {
throw new TypeError("Invalid property type: " + propName);
}
// If type is validate function
if (typeFormat === "function" && !options.type(value)) {
throw new TypeError("Invalid property type: " + propName);
}
// if type is array of possible types
if (typeFormat === "array" && options.type.indexOf(valueType) < 0) {
throw new TypeError("Invalid property type: " + propName);
}
// If it's an invalid value
if (options.expects && options.expects.indexOf(value) < 0) {
throw new TypeError("Invalid property value: " + propName);
}
});
// Now check for props that haven't been defined
forEach(props, function (value, key) {
// props.children is always passed in, even if it's not defined
if (key === "children") return;
if (!rules[key]) throw new Error("Unexpected property: " + key);
});
}
/**
* Used for debugging to inspect the current state without
* us needing to explicitly manage storing/updating references.
*
* @return {Object}
*/
function inspect() {
return {
entities: entities,
pools: pools,
handlers: handlers,
connections: connections,
currentElement: currentElement,
options: options,
app: app,
container: container,
children: children
};
}
/**
* Return an object that lets us completely remove the automatic
* DOM rendering and export debugging tools.
*/
return {
remove: teardown,
inspect: inspect
};
}
/**
* A rendered component instance.
*
* This manages the lifecycle, props and state of the component.
* It's basically just a data object for more straightfoward lookup.
*
* @param {Component} component
* @param {Object} props
*/
function Entity(component, props, ownerId) {
this.id = uid();
this.ownerId = ownerId;
this.component = component;
this.propTypes = component.propTypes || {};
this.context = {};
this.context.id = this.id;
this.context.props = defaults(props || {}, component.defaultProps || {});
this.context.state = this.component.initialState ? this.component.initialState(this.context.props) : {};
this.pendingProps = assign({}, this.context.props);
this.pendingState = assign({}, this.context.state);
this.dirty = false;
this.virtualElement = null;
this.nativeElement = null;
this.displayName = component.name || "Component";
}
/**
* Should we pool an element?
*/
function canPool(tagName) {
return avoidPooling.indexOf(tagName) < 0;
}
/**
* Get a nested node using a path
*
* @param {HTMLElement} el The root node '0'
* @param {String} path The path string eg. '0.2.43'
*/
function getNodeAtPath(el, path) {
var parts = path.split(".");
parts.shift();
while (parts.length) {
el = el.childNodes[parts.pop()];
}
return el;
}
}, { "./svg": 5, "./utils": 6, "component-raf": 10, "component-type": 11, "dom-pool": 12, "dom-walk": 13, "fast.js/forEach": 17, "fast.js/object/assign": 20, "fast.js/reduce": 23, "get-uid": 24, "is-dom": 25, "is-promise": 26, "object-path": 27, "per-frame": 28 }], 4: [function (_require, module, exports) {
var utils = _require("./utils");
var defaults = utils.defaults;
/**
* Expose `stringify`.
*/
module.exports = function (app) {
if (!app.element) {
throw new Error("No element mounted");
}
/**
* Render to string.
*
* @param {Component} component
* @param {Object} [props]
* @return {String}
*/
function stringify(component, optProps) {
var propTypes = component.propTypes || {};
var props = defaults(optProps || {}, component.defaultProps || {});
var state = component.initialState ? component.initialState(props) : {};
for (var name in propTypes) {
var options = propTypes[name];
if (options.source) {
props[name] = app.sources[options.source];
}
}
if (component.beforeMount) component.beforeMount({ props: props, state: state });
if (component.beforeRender) component.beforeRender({ props: props, state: state });
var node = component.render({ props: props, state: state });
return stringifyNode(node, "0");
}
/**
* Render a node to a string
*
* @param {Node} node
* @param {Tree} tree
*
* @return {String}
*/
function stringifyNode(node, path) {
switch (node.type) {
case "text":
return node.data;
case "element":
var children = node.children;
var attributes = node.attributes;
var tagName = node.tagName;
var innerHTML = attributes.innerHTML;
var str = "<" + tagName + attrs(attributes) + ">";
if (innerHTML) {
str += innerHTML;
} else {
for (var i = 0, n = children.length; i < n; i++) {
str += stringifyNode(children[i], path + "." + i);
}
}
str += "</" + tagName + ">";
return str;
case "component":
return stringify(node.component, node.props);
}
throw new Error("Invalid type");
}
return stringifyNode(app.element, "0");
};
/**
* HTML attributes to string.
*
* @param {Object} attributes
* @return {String}
* @api private
*/
function attrs(attributes) {
var str = "";
for (var key in attributes) {
if (key === "innerHTML") continue;
str += attr(key, attributes[key]);
}
return str;
}
/**
* HTML attribute to string.
*
* @param {String} key
* @param {String} val
* @return {String}
* @api private
*/
function attr(key, val) {
return " " + key + "=\"" + val + "\"";
}
}, { "./utils": 6 }], 5: [function (_require, module, exports) {
var indexOf = _require("fast.js/array/indexOf");
/**
* This file lists the supported SVG elements used by the
* renderer. We may add better SVG support in the future
* that doesn't require whitelisting elements.
*/
exports.namespace = "http://www.w3.org/2000/svg";
/**
* Supported SVG elements
*
* @type {Array}
*/
exports.elements = ["circle", "defs", "ellipse", "g", "line", "linearGradient", "mask", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "stop", "svg", "text", "tspan"];
/**
* Supported SVG attributes
*/
exports.attributes = ["cx", "cy", "d", "dx", "dy", "fill", "fillOpacity", "fontFamily", "fontSize", "fx", "fy", "gradientTransform", "gradientUnits", "markerEnd", "markerMid", "markerStart", "offset", "opacity", "patternContentUnits", "patternUnits", "points", "preserveAspectRatio", "r", "rx", "ry", "spreadMethod", "stopColor", "stopOpacity", "stroke", "strokeDasharray", "strokeLinecap", "strokeOpacity", "strokeWidth", "textAnchor", "transform", "version", "viewBox", "x1", "x2", "x", "y1", "y2", "y"];
/**
* Is element's namespace SVG?
*
* @param {String} name
*/
exports.isElement = function (name) {
return indexOf(exports.elements, name) !== -1;
};
/**
* Are element's attributes SVG?
*
* @param {String} attr
*/
exports.isAttribute = function (attr) {
return indexOf(exports.attributes, attr) !== -1;
};
}, { "fast.js/array/indexOf": 15 }], 6: [function (_require, module, exports) {
/**
* The npm 'defaults' module but without clone because
* it was requiring the 'Buffer' module which is huge.
*
* @param {Object} options
* @param {Object} defaults
*
* @return {Object}
*/
exports.defaults = function (options, defaults) {
Object.keys(defaults).forEach(function (key) {
if (typeof options[key] === "undefined") {
options[key] = defaults[key];
}
});
return options;
};
}, {}], 7: [function (_require, module, exports) {
/**
* Module dependencies.
*/
var type = _require("component-type");
var slice = _require("sliced");
var flatten = _require("array-flatten");
/**
* This function lets us create virtual nodes using a simple
* syntax. It is compatible with JSX transforms so you can use
* JSX to write nodes that will compile to this function.
*
* let node = virtual('div', { id: 'foo' }, [
* virtual('a', { href: 'http://google.com' }, 'Google')
* ])
*
* You can leave out the attributes or the children if either
* of them aren't needed and it will figure out what you're
* trying to do.
*/
module.exports = virtual;
/**
* Create virtual DOM trees.
*
* This creates the nicer API for the user.
* It translates that friendly API into an actual tree of nodes.
*
* @param {String|Function} type
* @param {Object} props
* @param {Array} children
* @return {Node}
* @api public
*/
function virtual(type, props, children) {
// Default to div with no args
if (!type) {
throw new Error("deku: Element needs a type. Read more: http://cl.ly/b0KZ");
}
// Skipped adding attributes and we're passing
// in children instead.
if (arguments.length === 2 && (typeof props === "string" || Array.isArray(props))) {
children = props;
props = {};
}
// Account for JSX putting the children as multiple arguments.
// This is essentially just the ES6 rest param
if (arguments.length > 2 && Array.isArray(arguments[2]) === false) {
children = slice(arguments, 2);
}
children = children || [];
props = props || {};
// passing in a single child, you can skip
// using the array
if (!Array.isArray(children)) {
children = [children];
}
children = flatten(children, 1).reduce(normalize, []);
// pull the key out from the data.
var key = "key" in props ? String(props.key) : null;
delete props["key"];
// if you pass in a function, it's a `Component` constructor.
// otherwise it's an element.
var node;
if (typeof type === "string") {
node = new ElementNode(type, props, key, children);
} else {
node = new ComponentNode(type, props, key, children);
}
// set the unique ID
node.index = 0;
return node;
}
/**
* Parse nodes into real `Node` objects.
*
* @param {Mixed} node
* @param {Integer} index
* @return {Node}
* @api private
*/
function normalize(acc, node) {
if (node == null) {
return acc;
}
if (typeof node === "string" || typeof node === "number") {
var newNode = new TextNode(String(node));
newNode.index = acc.length;
acc.push(newNode);
} else {
node.index = acc.length;
acc.push(node);
}
return acc;
}
/**
* Initialize a new `ComponentNode`.
*
* @param {Component} component
* @param {Object} props
* @param {String} key Used for sorting/replacing during diffing.
* @param {Array} children Child virtual nodes
* @api public
*/
function ComponentNode(component, props, key, children) {
this.key = key;
this.props = props;
this.type = "component";
this.component = component;
this.props.children = children || [];
}
/**
* Initialize a new `ElementNode`.
*
* @param {String} tagName
* @param {Object} attributes
* @param {String} key Used for sorting/replacing during diffing.
* @param {Array} children Child virtual dom nodes.
* @api public
*/
function ElementNode(tagName, attributes, key, children) {
this.type = "element";
this.attributes = parseAttributes(attributes);
this.tagName = tagName;
this.children = children || [];
this.key = key;
}
/**
* Initialize a new `TextNode`.
*
* This is just a virtual HTML text object.
*
* @param {String} text
* @api public
*/
function TextNode(text) {
this.type = "text";
this.data = String(text);
}
/**
* Parse attributes for some special cases.
*
* TODO: This could be more functional and allow hooks
* into the processing of the attributes at a component-level
*
* @param {Object} attributes
*
* @return {Object}
*/
function parseAttributes(attributes) {
// style: { 'text-align': 'left' }
if (attributes.style) {
attributes.style = parseStyle(attributes.style);
}
// class: { foo: true, bar: false, baz: true }
// class: ['foo', 'bar', 'baz']
if (attributes["class"]) {
attributes["class"] = parseClass(attributes["class"]);
}
// Remove attributes with false values
var filteredAttributes = {};
for (var key in attributes) {
var value = attributes[key];
if (value == null || value === false) continue;
filteredAttributes[key] = value;
}
return filteredAttributes;
}
/**
* Parse a block of styles into a string.
*
* TODO: this could do a lot more with vendor prefixing,
* number values etc. Maybe there's a way to allow users
* to hook into this?
*
* @param {Object} styles
*
* @return {String}
*/
function parseStyle(styles) {
if (type(styles) === "string") {
return styles;
}
var str = "";
for (var name in styles) {
var value = styles[name];
str = str + name + ":" + value + ";";
}
return str;
}
/**
* Parse the class attribute so it's able to be
* set in a more user-friendly way
*
* @param {String|Object|Array} value
*
* @return {String}
*/
function parseClass(value) {
// { foo: true, bar: false, baz: true }
if (type(value) === "object") {
var matched = [];
for (var key in value) {
if (value[key]) matched.push(key);
}
value = matched;
}
// ['foo', 'bar', 'baz']
if (type(value) === "array") {
if (value.length === 0) {
return;
}
value = value.join(" ");
}
return value;
}
}, { "array-flatten": 8, "component-type": 11, "sliced": 29 }], 8: [function (_require, module, exports) {
/**
* Recursive flatten function with depth.
*
* @param {Array} array
* @param {Array} result
* @param {Number} depth
* @return {Array}
*/
function flattenDepth(array, result, depth) {
for (var i = 0; i < array.length; i++) {
var value = array[i];
if (depth > 0 && Array.isArray(value)) {
flattenDepth(value, result, depth - 1);
} else {
result.push(value);
}
}
return result;
}
/**
* Recursive flatten function. Omitting depth is slightly faster.
*
* @param {Array} array
* @param {Array} result
* @return {Array}
*/
function flattenForever(array, result) {
for (var i = 0; i < array.length; i++) {
var value = array[i];
if (Array.isArray(value)) {
flattenForever(value, result);
} else {
result.push(value);
}
}
return result;
}
/**
* Flatten an array, with the ability to define a depth.
*
* @param {Array} array
* @param {Number} depth
* @return {Array}
*/
module.exports = function (array, depth) {
if (depth == null) {
return flattenForever(array, []);
}
return flattenDepth(array, [], depth);
};
}, {}], 9: [function (_require, module, exports) {
/**
* Expose `Emitter`.
*/
module.exports = Emitter;
/**
* Initialize a new `Emitter`.
*
* @api public
*/
function Emitter(obj) {
if (obj) return mixin(obj);
};
/**
* Mixin the emitter properties.
*
* @param {Object} obj
* @return {Object}
* @api private
*/
function mixin(obj) {
for (var key in Emitter.prototype) {
obj[key] = Emitter.prototype[key];
}
return obj;
}
/**
* Listen on the given `event` with `fn`.
*
* @param {String} event
* @param {Function} fn
* @return {Emitter}
* @api public
*/
Emitter.prototype.on = Emitter.prototype.addEventListener = function (event, fn) {
this._callbacks = this._callbacks || {};
(this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn);
return this;
};
/**
* Adds an `event` listener that will be invoked a single
* time then automatically removed.
*
* @param {String} event
* @param {Function} fn
* @return {Emitter}
* @api public
*/
Emitter.prototype.once = function (event, fn) {
function on() {
this.off(event, on);
fn.apply(this, arguments);
}
on.fn = fn;
this.on(event, on);
return this;
};
/**
* Remove the given callback for `event` or all
* registered callbacks.
*
* @param {String} event
* @param {Function} fn
* @return {Emitter}
* @api public
*/
Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function (event, fn) {
this._callbacks = this._callbacks || {};
// all
if (0 == arguments.length) {
this._callbacks = {};
return this;
}
// specific event
var callbacks = this._callbacks["$" + event];
if (!callbacks) return this;
// remove all handlers
if (1 == arguments.length) {
delete this._callbacks["$" + event];
return this;
}
// remove specific handler
var cb;
for (var i = 0; i < callbacks.length; i++) {
cb = callbacks[i];
if (cb === fn || cb.fn === fn) {
callbacks.splice(i, 1);
break;
}
}
return this;
};
/**
* Emit `event` with the given args.
*
* @param {String} event
* @param {Mixed} ...
* @return {Emitter}
*/
Emitter.prototype.emit = function (event) {
this._callbacks = this._callbacks || {};
var args = [].slice.call(arguments, 1),
callbacks = this._callbacks["$" + event];
if (callbacks) {
callbacks = callbacks.slice(0);
for (var i = 0, len = callbacks.length; i < len; ++i) {
callbacks[i].apply(this, args);
}
}
return this;
};
/**
* Return array of callbacks for `event`.
*
* @param {String} event
* @return {Array}
* @api public
*/
Emitter.prototype.listeners = function (event) {
this._callbacks = this._callbacks || {};
return this._callbacks["$" + event] || [];
};
/**
* Check if this emitter has `event` handlers.
*
* @param {String} event
* @return {Boolean}
* @api public
*/
Emitter.prototype.hasListeners = function (event) {
return !!this.listeners(event).length;
};
}, {}], 10: [function (_require, module, exports) {
/**
* Expose `requestAnimationFrame()`.
*/
exports = module.exports = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || fallback;
/**
* Fallback implementation.
*/
var prev = new Date().getTime();
function fallback(fn) {
var curr = new Date().getTime();
var ms = Math.max(0, 16 - (curr - prev));
var req = setTimeout(fn, ms);
prev = curr;
return req;
}
/**
* Cancel.
*/
var cancel = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.clearTimeout;
exports.cancel = function (id) {
cancel.call(window, id);
};
}, {}], 11: [function (_require, module, exports) {
/**
* toString ref.
*/
var toString = Object.prototype.toString;
/**
* Return the type of `val`.
*
* @param {Mixed} val
* @return {String}
* @api public
*/
module.exports = function (val) {
switch (toString.call(val)) {
case "[object Date]":
return "date";
case "[object RegExp]":
return "regexp";
case "[object Arguments]":
return "arguments";
case "[object Array]":
return "array";
case "[object Error]":
return "error";
}
if (val === null) return "null";
if (val === undefined) return "undefined";
if (val !== val) return "nan";
if (val && val.nodeType === 1) return "element";
val = val.valueOf ? val.valueOf() : Object.prototype.valueOf.apply(val);
return typeof val;
};
}, {}], 12: [function (_require, module, exports) {
function Pool(params) {
if (typeof params !== "object") {
throw new Error("Please pass parameters. Example -> new Pool({ tagName: \"div\" })");
}
if (typeof params.tagName !== "string") {
throw new Error("Please specify a tagName. Example -> new Pool({ tagName: \"div\" })");
}
this.storage = [];
this.tagName = params.tagName.toLowerCase();
this.namespace = params.namespace;
}
Pool.prototype.push = function (el) {
if (el.tagName.toLowerCase() !== this.tagName) {
return;
}
this.storage.push(el);
};
Pool.prototype.pop = function (argument) {
if (this.storage.length === 0) {
return this.create();
} else {
return this.storage.pop();
}
};
Pool.prototype.create = function () {
if (this.namespace) {
return document.createElementNS(this.namespace, this.tagName);
} else {
return document.createElement(this.tagName);
}
};
Pool.prototype.allocate = function (size) {
if (this.storage.length >= size) {
return;
}
var difference = size - this.storage.length;
for (var poolAllocIter = 0; poolAllocIter < difference; poolAllocIter++) {
this.storage.push(this.create());
}
};
if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
module.exports = Pool;
}
}, {}], 13: [function (_require, module, exports) {
var slice = Array.prototype.slice;
module.exports = iterativelyWalk;
function iterativelyWalk(nodes, cb) {
if (!("length" in nodes)) {
nodes = [nodes];
}
nodes = slice.call(nodes);
while (nodes.length) {
var node = nodes.shift(),
ret = cb(node);
if (ret) {
return ret;
}
if (node.childNodes && node.childNodes.length) {
nodes = slice.call(node.childNodes).concat(nodes);
}
}
}
}, {}], 14: [function (_require, module, exports) {
"use strict";
var bindInternal3 = _require("../function/bindInternal3");
/**
* # For Each
*
* A fast `.forEach()` implementation.
*
* @param {Array} subject The array (or array-like) to iterate over.
* @param {Function} fn The visitor function.
* @param {Object} thisContext The context for the visitor.
*/
module.exports = function fastForEach(subject, fn, thisContext) {
var length = subject.length,
iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
i;
for (i = 0; i < length; i++) {
iterator(subject[i], i, subject);
}
};
}, { "../function/bindInternal3": 18 }], 15: [function (_require, module, exports) {
"use strict";
/**
* # Index Of
*
* A faster `Array.prototype.indexOf()` implementation.
*
* @param {Array} subject The array (or array-like) to search within.
* @param {mixed} target The target item to search for.
* @param {Number} fromIndex The position to start searching from, if known.
* @return {Number} The position of the target in the subject, or -1 if it does not exist.
*/
module.exports = function fastIndexOf(subject, target, fromIndex) {
var length = subject.length,
i = 0;
if (typeof fromIndex === "number") {
i = fromIndex;
if (i < 0) {
i += length;
if (i < 0) {
i = 0;
}
}
}
for (; i < length; i++) {
if (subject[i] === target) {
return i;
}
}
return -1;
};
}, {}], 16: [function (_require, module, exports) {
"use strict";
var bindInternal4 = _require("../function/bindInternal4");
/**
* # Reduce
*
* A fast `.reduce()` implementation.
*
* @param {Array} subject The array (or array-like) to reduce.
* @param {Function} fn The reducer function.
* @param {mixed} initialValue The initial value for the reducer, defaults to subject[0].
* @param {Object} thisContext The context for the reducer.
* @return {mixed} The final result.
*/
module.exports = function fastReduce(subject, fn, initialValue, thisContext) {
var length = subject.length,
iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
i,
result;
if (initialValue === undefined) {
i = 1;
result = subject[0];
} else {
i = 0;
result = initialValue;
}
for (; i < length; i++) {
result = iterator(result, subject[i], i, subject);
}
return result;
};
}, { "../function/bindInternal4": 19 }], 17: [function (_require, module, exports) {
"use strict";
var forEachArray = _require("./array/forEach"),
forEachObject = _require("./object/forEach");
/**
* # ForEach
*
* A fast `.forEach()` implementation.
*
* @param {Array|Object} subject The array or object to iterate over.
* @param {Function} fn The visitor function.
* @param {Object} thisContext The context for the visitor.
*/
module.exports = function fastForEach(subject, fn, thisContext) {
if (subject instanceof Array) {
return forEachArray(subject, fn, thisContext);
} else {
return forEachObject(subject, fn, thisContext);
}
};
}, { "./array/forEach": 14, "./object/forEach": 21 }], 18: [function (_require, module, exports) {
"use strict";
/**
* Internal helper to bind a function known to have 3 arguments
* to a given context.
*/
module.exports = function bindInternal3(func, thisContext) {
return function (a, b, c) {
return func.call(thisContext, a, b, c);
};
};
}, {}], 19: [function (_require, module, exports) {
"use strict";
/**
* Internal helper to bind a function known to have 4 arguments
* to a given context.
*/
module.exports = function bindInternal4(func, thisContext) {
return function (a, b, c, d) {
return func.call(thisContext, a, b, c, d);
};
};
}, {}], 20: [function (_require, module, exports) {
"use strict";
/**
* Analogue of Object.assign().
* Copies properties from one or more source objects to
* a target object. Existing keys on the target object will be overwritten.
*
* > Note: This differs from spec in some important ways:
* > 1. Will throw if passed non-objects, including `undefined` or `null` values.
* > 2. Does not support the curious Exception handling behavior, exceptions are thrown immediately.
* > For more details, see:
* > https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
*
*
*
* @param {Object} target The target object to copy properties to.
* @param {Object} source, ... The source(s) to copy properties from.
* @return {Object} The updated target object.
*/
module.exports = function fastAssign(target) {
var totalArgs = arguments.length,
source,
i,
totalKeys,
keys,
key,
j;
for (i = 1; i < totalArgs; i++) {
source = arguments[i];
keys = Object.keys(source);
totalKeys = keys.length;
for (j = 0; j < totalKeys; j++) {
key = keys[j];
target[key] = source[key];
}
}
return target;
};
}, {}], 21: [function (_require, module, exports) {
"use strict";
var bindInternal3 = _require("../function/bindInternal3");
/**
* # For Each
*
* A fast object `.forEach()` implementation.
*
* @param {Object} subject The object to iterate over.
* @param {Function} fn The visitor function.
* @param {Object} thisContext The context for the visitor.
*/
module.exports = function fastForEachObject(subject, fn, thisContext) {
var keys = Object.keys(subject),
length = keys.length,
iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
key,
i;
for (i = 0; i < length; i++) {
key = keys[i];
iterator(subject[key], key, subject);
}
};
}, { "../function/bindInternal3": 18 }], 22: [function (_require, module, exports) {
"use strict";
var bindInternal4 = _require("../function/bindInternal4");
/**
* # Reduce
*
* A fast object `.reduce()` implementation.
*
* @param {Object} subject The object to reduce over.
* @param {Function} fn The reducer function.
* @param {mixed} initialValue The initial value for the reducer, defaults to subject[0].
* @param {Object} thisContext The context for the reducer.
* @return {mixed} The final result.
*/
module.exports = function fastReduceObject(subject, fn, initialValue, thisContext) {
var keys = Object.keys(subject),
length = keys.length,
iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
i,
key,
result;
if (initialValue === undefined) {
i = 1;
result = subject[keys[0]];
} else {
i = 0;
result = initialValue;
}
for (; i < length; i++) {
key = keys[i];
result = iterator(result, subject[key], key, subject);
}
return result;
};
}, { "../function/bindInternal4": 19 }], 23: [function (_require, module, exports) {
"use strict";
var reduceArray = _require("./array/reduce"),
reduceObject = _require("./object/reduce");
/**
* # Reduce
*
* A fast `.reduce()` implementation.
*
* @param {Array|Object} subject The array or object to reduce over.
* @param {Function} fn The reducer function.
* @param {mixed} initialValue The initial value for the reducer, defaults to subject[0].
* @param {Object} thisContext The context for the reducer.
* @return {Array|Object} The array or object containing the results.
*/
module.exports = function fastReduce(subject, fn, initialValue, thisContext) {
if (subject instanceof Array) {
return reduceArray(subject, fn, initialValue, thisContext);
} else {
return reduceObject(subject, fn, initialValue, thisContext);
}
};
}, { "./array/reduce": 16, "./object/reduce": 22 }], 24: [function (_require, module, exports) {
/** generate unique id for selector */
var counter = Date.now() % 1000000000;
module.exports = function getUid() {
return (Math.random() * 1000000000 >>> 0) + counter++;
};
}, {}], 25: [function (_require, module, exports) {
/*global window*/
/**
* Check if object is dom node.
*
* @param {Object} val
* @return {Boolean}
* @api public
*/
module.exports = function isNode(val) {
if (!val || typeof val !== "object") return false;
if (window && "object" == typeof window.Node) return val instanceof window.Node;
return "number" == typeof val.nodeType && "string" == typeof val.nodeName;
};
}, {}], 26: [function (_require, module, exports) {
module.exports = isPromise;
function isPromise(obj) {
return obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
}
}, {}], 27: [function (_require, module, exports) {
(function (root, factory) {
"use strict";
/*istanbul ignore next:cant test*/
if (typeof module === "object" && typeof module.exports === "object") {
module.exports = factory();
} else if (typeof define === "function" && define.amd) {
// AMD. Register as an anonymous module.
define([], factory);
} else {
// Browser globals
root.objectPath = factory();
}
})(this, function () {
"use strict";
var toStr = Object.prototype.toString,
_hasOwnProperty = Object.prototype.hasOwnProperty;
function isEmpty(value) {
if (!value) {
return true;
}
if (isArray(value) && value.length === 0) {
return true;
} else {
for (var i in value) {
if (_hasOwnProperty.call(value, i)) {
return false;
}
}
return true;
}
}
function toString(type) {
return toStr.call(type);
}
function isNumber(value) {
return typeof value === "number" || toString(value) === "[object Number]";
}
function isString(obj) {
return typeof obj === "string" || toString(obj) === "[object String]";
}
function isObject(obj) {
return typeof obj === "object" && toString(obj) === "[object Object]";
}
function isArray(obj) {
return typeof obj === "object" && typeof obj.length === "number" && toString(obj) === "[object Array]";
}
function isBoolean(obj) {
return typeof obj === "boolean" || toString(obj) === "[object Boolean]";
}
function getKey(key) {
var intKey = parseInt(key);
if (intKey.toString() === key) {
return intKey;
}
return key;
}
function set(_x, _x2, _x3, _x4) {
var _again = true;
_function: while (_again) {
var obj = _x,
path = _x2,
value = _x3,
doNotReplace = _x4;
currentPath = oldVal = undefined;
_again = false;
if (isNumber(path)) {
path = [path];
}
if (isEmpty(path)) {
return obj;
}
if (isString(path)) {
_x = obj;
_x2 = path.split(".").map(getKey);
_x3 = value;
_x4 = doNotReplace;
_again = true;
continue _function;
}
var currentPath = path[0];
if (path.length === 1) {
var oldVal = obj[currentPath];
if (oldVal === void 0 || !doNotReplace) {
obj[currentPath] = value;
}
return oldVal;
}
if (obj[currentPath] === void 0) {
//check if we assume an array
if (isNumber(path[1])) {
obj[currentPath] = [];
} else {
obj[currentPath] = {};
}
}
_x = obj[currentPath];
_x2 = path.slice(1);
_x3 = value;
_x4 = doNotReplace;
_again = true;
continue _function;
}
}
function del(_x5, _x6) {
var _again2 = true;
_function2: while (_again2) {
var obj = _x5,
path = _x6;
currentPath = oldVal = undefined;
_again2 = false;
if (isNumber(path)) {
path = [path];
}
if (isEmpty(obj)) {
return void 0;
}
if (isEmpty(path)) {
return obj;
}
if (isString(path)) {
_x5 = obj;
_x6 = path.split(".");
_again2 = true;
continue _function2;
}
var currentPath = getKey(path[0]);
var oldVal = obj[currentPath];
if (path.length === 1) {
if (oldVal !== void 0) {
if (isArray(obj)) {
obj.splice(currentPath, 1);
} else {
delete obj[currentPath];
}
}
} else {
if (obj[currentPath] !== void 0) {
_x5 = obj[currentPath];
_x6 = path.slice(1);
_again2 = true;
continue _function2;
}
}
return obj;
}
}
var objectPath = {};
objectPath.has = function (obj, path) {
if (isEmpty(obj)) {
return false;
}
if (isNumber(path)) {
path = [path];
} else if (isString(path)) {
path = path.split(".");
}
if (isEmpty(path) || path.length === 0) {
return false;
}
for (var i = 0; i < path.length; i++) {
var j = path[i];
if ((isObject(obj) || isArray(obj)) && _hasOwnProperty.call(obj, j)) {
obj = obj[j];
} else {
return false;
}
}
return true;
};
objectPath.ensureExists = function (obj, path, value) {
return set(obj, path, value, true);
};
objectPath.set = function (obj, path, value, doNotReplace) {
return set(obj, path, value, doNotReplace);
};
objectPath.insert = function (obj, path, value, at) {
var arr = objectPath.get(obj, path);
at = ~ ~at;
if (!isArray(arr)) {
arr = [];
objectPath.set(obj, path, arr);
}
arr.splice(at, 0, value);
};
objectPath.empty = function (obj, path) {
if (isEmpty(path)) {
return obj;
}
if (isEmpty(obj)) {
return void 0;
}
var value, i;
if (!(value = objectPath.get(obj, path))) {
return obj;
}
if (isString(value)) {
return objectPath.set(obj, path, "");
} else if (isBoolean(value)) {
return objectPath.set(obj, path, false);
} else if (isNumber(value)) {
return objectPath.set(obj, path, 0);
} else if (isArray(value)) {
value.length = 0;
} else if (isObject(value)) {
for (i in value) {
if (_hasOwnProperty.call(value, i)) {
delete value[i];
}
}
} else {
return objectPath.set(obj, path, null);
}
};
objectPath.push = function (obj, path /*, values */) {
var arr = objectPath.get(obj, path);
if (!isArray(arr)) {
arr = [];
objectPath.set(obj, path, arr);
}
arr.push.apply(arr, Array.prototype.slice.call(arguments, 2));
};
objectPath.coalesce = function (obj, paths, defaultValue) {
var value;
for (var i = 0, len = paths.length; i < len; i++) {
if ((value = objectPath.get(obj, paths[i])) !== void 0) {
return value;
}
}
return defaultValue;
};
objectPath.get = function (obj, path, defaultValue) {
if (isNumber(path)) {
path = [path];
}
if (isEmpty(path)) {
return obj;
}
if (isEmpty(obj)) {
return defaultValue;
}
if (isString(path)) {
return objectPath.get(obj, path.split("."), defaultValue);
}
var currentPath = getKey(path[0]);
if (path.length === 1) {
if (obj[currentPath] === void 0) {
return defaultValue;
}
return obj[currentPath];
}
return objectPath.get(obj[currentPath], path.slice(1), defaultValue);
};
objectPath.del = function (obj, path) {
return del(obj, path);
};
return objectPath;
});
}, {}], 28: [function (_require, module, exports) {
/**
* Module Dependencies.
*/
var raf = _require("raf");
/**
* Export `throttle`.
*/
module.exports = throttle;
/**
* Executes a function at most once per animation frame. Kind of like
* throttle, but it throttles at ~60Hz.
*
* @param {Function} fn - the Function to throttle once per animation frame
* @return {Function}
* @public
*/
function throttle(fn) {
var rtn;
var ignoring = false;
return function queue() {
if (ignoring) return rtn;
ignoring = true;
raf(function () {
ignoring = false;
});
rtn = fn.apply(this, arguments);
return rtn;
};
}
}, { "raf": 10 }], 29: [function (_require, module, exports) {
module.exports = exports = _require("./lib/sliced");
}, { "./lib/sliced": 30 }], 30: [function (_require, module, exports) {
/**
* An Array.prototype.slice.call(arguments) alternative
*
* @param {Object} args something with a length
* @param {Number} slice
* @param {Number} sliceEnd
* @api public
*/
module.exports = function (args, slice, sliceEnd) {
var ret = [];
var len = args.length;
if (0 === len) return ret;
var start = slice < 0 ? Math.max(0, slice + len) : slice || 0;
if (sliceEnd !== undefined) {
len = sliceEnd < 0 ? sliceEnd + len : sliceEnd;
}
while (len-- > start) {
ret[len - start] = args[len];
}
return ret;
};
}, {}] }, {}, [2])(2);
});
}, {}]}, {}, {"1":""})
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment