Eli Manning to Return to New York Giants in 2019: Pat Shurmur

true
*
* _.isString(1);
* // => false
*/
function isString(value)
return typeof value == ‘string’

module.exports = isString;
}, “./isArray”:34,”./isObjectLike”:634,”./_baseGetTag”:624];
window.modules[“105”] = [function(require,module,exports)
/**
* Expose `parse`.
*/

module.exports = parse;

/**
* Tests for browser support.
*/

var innerHTMLBug = false;
var bugTestDiv;
if (typeof document !== ‘undefined’)
bugTestDiv = document.createElement(‘div’);
// Setup
bugTestDiv.innerHTML = ‘ a‘;
// Make sure that link elements get serialized correctly by innerHTML
// This requires a wrapper element in IE
innerHTMLBug = !bugTestDiv.getElementsByTagName(‘link’).length;
bugTestDiv = undefined;

/**
* Wrap map from jquery.
*/

var map =
legend: [1, ‘

‘, ‘

‘],
tr: [2, ”],
col: [2, ”],
// for script/link/style tags to work in IE6-8, you have to wrap
// in a div with a non-whitespace character in front, ha!
_default: innerHTMLBug ? [1, ‘X

‘, ‘

‘] : [0, ”, ”]
;

map.td =
map.th = [3, ”];

map.option =
map.optgroup = [1, ‘‘, ‘‘];

map.thead =
map.tbody =
map.colgroup =
map.caption =
map.tfoot = [1, ”];

map.polyline =
map.ellipse =
map.polygon =
map.circle =
map.text =
map.line =
map.path =
map.rect =
map.g = [1, ‘‘];

/**
* Parse `html` and return a DOM Node instance, which could be a TextNode,
* HTML DOM Node of some kind (

for example), or a DocumentFragment
* instance, depending on the contents of the `html` string.
*
* @param String html – HTML string to “domify”
* @param Document doc – The `document` instance to create the Node for
* @return DOMNode the TextNode, DOM Node, or DocumentFragment instance
* @api private
*/

function parse(html, doc)
if (‘string’ != typeof html) throw new TypeError(‘String expected’);

// default to the global `document` object
if (!doc) doc = document;

// tag name
var m = /= O.length) return value: undefined, done: true ;
point = $at(O, index);
this._i += point.length;
return value: point, done: false ;
);
, “./_string-at”:255,”./_iter-define”:199];
window.modules[“153”] = [function(require,module,exports)var core = module.exports = version: ‘2.5.7’ ;
if (typeof __e == ‘number’) __e = core; // eslint-disable-line no-undef
, ];
window.modules[“154”] = [function(require,module,exports){‘use strict’;
var ctx = require(‘./_ctx’);
var $export = require(‘./_export’);
var toObject = require(‘./_to-object’);
var call = require(‘./_iter-call’);
var isArrayIter = require(‘./_is-array-iter’);
var toLength = require(‘./_to-length’);
var createProperty = require(‘./_create-property’);
var getIterFn = require(‘./core.get-iterator-method’);

$export($export.S + $export.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 = toObject(arrayLike);
var C = typeof this == ‘function’ ? this : Array;
var aLen = arguments.length;
var mapfn = aLen > 1 ? arguments[1] : undefined;
var mapping = mapfn !== undefined;
var index = 0;
var iterFn = getIterFn(O);
var length, result, step, iterator;
if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
// if object isn’t iterable or it’s array with default iterator – use simple case
if (iterFn != undefined && !(C == Array && isArrayIter(iterFn)))
for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++)
createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);

else
length = toLength(O.length);
for (result = new C(length); length > index; index++)
createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);

result.length = index;
return result;

);
}, “./_ctx”:187,”./_export”:209,”./_to-object”:189,”./_iter-call”:224,”./_is-array-iter”:225,”./_to-length”:184,”./core.get-iterator-method”:223,”./_iter-detect”:234,”./_create-property”:213];
window.modules[“155”] = [function(require,module,exports)require(‘./es6.array.iterator’);
var global = require(‘./_global’);
var hide = require(‘./_hide’);
var Iterators = require(‘./_iterators’);
var TO_STRING_TAG = require(‘./_wks’)(‘toStringTag’);

var DOMIterables = (‘CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,’ +
‘DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,’ +
‘MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,’ +
‘SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,’ +
‘TextTrackList,TouchList’).split(‘,’);

for (var i = 0; i i) run(chain[i++]); // variable length – can’t use forEach
promise._c = [];
promise._n = false;
if (isReject && !promise._h) onUnhandled(promise);
);
};
var onUnhandled = function (promise) {
task.call(global, function () {
var value = promise._v;
var unhandled = isUnhandled(promise);
var result, handler, console;
if (unhandled) isUnhandled(promise) ? 2 : 1;
promise._a = undefined;
if (unhandled && result.e) throw result.v;
});
};
var isUnhandled = function (promise) ;
var onHandleUnhandled = function (promise)
task.call(global, function ()
var handler;
if (isNode)
process.emit(‘rejectionHandled’, promise);
else if (handler = global.onrejectionhandled)
handler( promise: promise, reason: promise._v );

);
;
var $reject = function (value)
var promise = this;
if (promise._d) return;
promise._d = true;
promise = promise._w ;
var $resolve = function (value) {
var promise = this;
var then;
if (promise._d) return;
promise._d = true;
promise = promise._w || promise; // unwrap
try
if (promise === value) throw TypeError(“Promise can’t be resolved itself”);
if (then = isThenable(value))
microtask(function ()
var wrapper = _w: promise, _d: false ; // wrap
try
then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
catch (e)
$reject.call(wrapper, e);

);
else
promise._v = value;
promise._s = 1;
notify(promise, false);

catch (e)
$reject.call( _w: promise, _d: false , e); // wrap

};

// constructor polyfill
if (!USE_NATIVE)
// 25.4.3.1 Promise(executor)
$Promise = function Promise(executor)
anInstance(this, $Promise, PROMISE, ‘_h’);
aFunction(executor);
Internal.call(this);
try
executor(ctx($resolve, this, 1), ctx($reject, this, 1));
catch (err)
$reject.call(this, err);

;
// eslint-disable-next-line no-unused-vars
Internal = function Promise(executor)
this._c = []; // index; index++) result === RETURN) return result;
else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;)
;
exports.BREAK = BREAK;
exports.RETURN = RETURN;
, “./_ctx”:187,”./_an-object”:178,”./core.get-iterator-method”:223,”./_iter-call”:224,”./_is-array-iter”:225,”./_to-length”:184];
window.modules[“182”] = [function(require,module,exports)// false -> Array#indexOf
// true -> Array#includes
var toIObject = require(‘./_to-iobject’);
var toLength = require(‘./_to-length’);
var toAbsoluteIndex = require(‘./_to-absolute-index’);
module.exports = function (IS_INCLUDES)
return function ($this, el, fromIndex)
var O = toIObject($this);
var length = toLength(O.length);
var index = toAbsoluteIndex(fromIndex, length);
var value;
// Array#includes uses SameValueZero equality algorithm
// eslint-disable-next-line no-self-compare
if (IS_INCLUDES && el != el) while (length > index)
value = O[index++];
// eslint-disable-next-line no-self-compare
if (value != value) return true;
// Array#indexOf ignores holes, Array#includes – not
else for (;length > index; index++) if (IS_INCLUDES ;
;
, “./_to-iobject”:183,”./_to-length”:184,”./_to-absolute-index”:185];
window.modules[“183”] = [function(require,module,exports)// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = require(‘./_iobject’);
var defined = require(‘./_defined’);
module.exports = function (it)
return IObject(defined(it));
;
, “./_defined”:215,”./_iobject”:188];
window.modules[“184”] = [function(require,module,exports)// 7.1.15 ToLength
var toInteger = require(‘./_to-integer’);
var min = Math.min;
module.exports = function (it)
return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) – 1 == 9007199254740991
;
, “./_to-integer”:256];
window.modules[“185”] = [function(require,module,exports), “./_an-object”:178,”./_shared-key”:240,”./_dom-create”:216,”./_html”:226,”./_enum-bug-keys”:217,”./_object-dps”:241];
window.modules[“208”] = [function(require,module,exports)// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != ‘undefined’ && window.Math == Math
? window : typeof self != ‘undefined’ && self.Math == Math ? self
// eslint-disable-next-line no-new-func
: Function(‘return this’)();
if (typeof __g == ‘number’) __g = global; // eslint-disable-line no-undef
, ];
window.modules[“209”] = [function(require,module,exports){var global = require(‘./_global’);
var core = require(‘./_core’);
var ctx = require(‘./_ctx’);
var hide = require(‘./_hide’);
var has = require(‘./_has’);
var PROTOTYPE = ‘prototype’;

var $export = function (type, name, source) {
var IS_FORCED = type & $export.F;
var IS_GLOBAL = type & $export.G;
var IS_STATIC = type & $export.S;
var IS_PROTO = type & $export.P;
var IS_BIND = type & $export.B;
var IS_WRAP = type & $export.W;
var exports = IS_GLOBAL ? core : core[name] || (core[name] = );
var expProto = exports[PROTOTYPE];
var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || )[PROTOTYPE];
var key, own, out;
if (IS_GLOBAL) source = name;
for (key in source) {
// contains in native
own = !IS_FORCED && target && target[key] !== undefined;
if (own && has(exports, key)) continue;
// export native or passed
out = own ? target[key] : source[key];
// prevent global pollution for namespaces
exports[key] = IS_GLOBAL && typeof target[key] != ‘function’ ? source[key]
// bind timers to global for call from export context
: IS_BIND && own ? ctx(out, global)
// wrap global constructors for prevent change them in library
: IS_WRAP && target[key] == out ? (function (C)
var F = function (a, b, c)
if (this instanceof C)
switch (arguments.length)
case 0: return new C();
case 1: return new C(a);
case 2: return new C(a, b);
return new C(a, b, c);
return C.apply(this, arguments);
;
F[PROTOTYPE] = C[PROTOTYPE];
return F;
// make static versions for prototype methods
)(out) : IS_PROTO && typeof out == ‘function’ ? ctx(Function.call, out) : out;
// export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
if (IS_PROTO)
(exports.virtual
}
};
// type bitmap
$export.F = 1; // forced
$export.G = 2; // global
$export.S = 4; // static
$export.P = 8; // proto
$export.B = 16; // bind
$export.W = 32; // wrap
$export.U = 64; // safe
$export.R = 128; // real proto method for `library`
module.exports = $export;
}, “./_global”:208,”./_core”:153,”./_ctx”:187,”./_hide”:210,”./_has”:222];
window.modules[“210”] = [function(require,module,exports)var dP = require(‘./_object-dp’);
var createDesc = require(‘./_property-desc’);
module.exports = require(‘./_descriptors’) ? function (object, key, value)
return dP.f(object, key, createDesc(1, value));
: function (object, key, value)
object[key] = value;
return object;
;
, “./_property-desc”:214,”./_descriptors”:202,”./_object-dp”:197];
window.modules[“211”] = [function(require,module,exports)var def = require(‘./_object-dp’).f;
var has = require(‘./_has’);
var TAG = require(‘./_wks’)(‘toStringTag’);

module.exports = function (it, tag, stat)
if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, configurable: true, value: tag );
;
, “./_object-dp”:197,”./_has”:222,”./_wks”:193];
window.modules[“212”] = [function(require,module,exports)module.exports = function (exec)
try
return !!exec();
catch (e)
return true;

;
, ];
window.modules[“213”] = [function(require,module,exports)’use strict’;
var $defineProperty = require(‘./_object-dp’);
var createDesc = require(‘./_property-desc’);

module.exports = function (object, index, value)
if (index in object) $defineProperty.f(object, index, createDesc(0, value));
else object[index] = value;
;
, “./_object-dp”:197,”./_property-desc”:214];
window.modules[“214”] = [function(require,module,exports)module.exports = function (bitmap, value)
return
enumerable: !(bitmap & 1),
configurable: !(bitmap & 2),
writable: !(bitmap & 4),
value: value
;
;
, ];
window.modules[“215”] = [function(require,module,exports)// 7.2.1 RequireObjectCoercible(argument)
module.exports = function (it)
if (it == undefined) throw TypeError(“Can’t call method on ” + it);
return it;
;
, ];
window.modules[“216”] = [function(require,module,exports)var isObject = require(‘./_is-object’);
var document = require(‘./_global’).document;
// typeof document.createElement is ‘object’ in old IE
var is = isObject(document) && isObject(document.createElement);
module.exports = function (it)
return is ? document.createElement(it) : ;
;
, “./_is-object”:179,”./_global”:208];
window.modules[“217”] = [function(require,module,exports)// IE 8- don’t enum bug keys
module.exports = (
‘constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf’
).split(‘,’);
, ];
window.modules[“219”] = [function(require,module,exports), “./_enum-bug-keys”:217,”./_object-keys-internal”:246];
window.modules[“222”] = [function(require,module,exports)var hasOwnProperty = .hasOwnProperty;
module.exports = function (it, key)
return hasOwnProperty.call(it, key);
;
, ];
window.modules[“223”] = [function(require,module,exports)var classof = require(‘./_classof’);
var ITERATOR = require(‘./_wks’)(‘iterator’);
var Iterators = require(‘./_iterators’);
module.exports = require(‘./_core’).getIteratorMethod = function (it) Iterators[classof(it)];
;
, “./_classof”:194,”./_wks”:193,”./_iterators”:229,”./_core”:153];
window.modules[“224”] = [function(require,module,exports)// call something on iterator step with safe closing on error
var anObject = require(‘./_an-object’);
module.exports = function (iterator, fn, value, entries)
try
return entries ? fn(anObject(value)[0], value[1]) : fn(value);
// 7.4.6 IteratorClose(iterator, completion)
catch (e)
var ret = iterator[‘return’];
if (ret !== undefined) anObject(ret.call(iterator));
throw e;

;
, “./_an-object”:178];
window.modules[“225”] = [function(require,module,exports)// check on default Array iterator
var Iterators = require(‘./_iterators’);
var ITERATOR = require(‘./_wks’)(‘iterator’);
var ArrayProto = Array.prototype;

module.exports = function (it) ArrayProto[ITERATOR] === it);
;
, “./_iterators”:229,”./_wks”:193];
window.modules[“226”] = [function(require,module,exports)var document = require(‘./_global’).document;
module.exports = document && document.documentElement;
, “./_global”:208];
window.modules[“227”] = [function(require,module,exports)module.exports = !require(‘./_descriptors’) && !require(‘./_fails’)(function ()
return Object.defineProperty(require(‘./_dom-create’)(‘div’), ‘a’, get: function () return 7; ).a != 7;
);
, “./_descriptors”:202,”./_fails”:212,”./_dom-create”:216];
window.modules[“228”] = [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]);
return fn.apply(that, args);
;
, ];
window.modules[“229”] = [function(require,module,exports)module.exports = ;
, ];
window.modules[“230”] = [function(require,module,exports)’use strict’;
var create = require(‘./_object-create’);
var descriptor = require(‘./_property-desc’);
var setToStringTag = require(‘./_set-to-string-tag’);
var IteratorPrototype = ;

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
require(‘./_hide’)(IteratorPrototype, require(‘./_wks’)(‘iterator’), function () return this; );

module.exports = function (Constructor, NAME, next)
Constructor.prototype = create(IteratorPrototype, next: descriptor(1, next) );
setToStringTag(Constructor, NAME + ‘ Iterator’);
;
, “./_object-create”:205,”./_property-desc”:214,”./_set-to-string-tag”:211,”./_hide”:210,”./_wks”:193];
window.modules[“231”] = [function(require,module,exports)module.exports = true;
, ];
window.modules[“232”] = [function(require,module,exports)module.exports = require(‘./_hide’);
, “./_hide”:210];
window.modules[“233”] = [function(require,module,exports)// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
var has = require(‘./_has’);
var toObject = require(‘./_to-object’);
var IE_PROTO = require(‘./_shared-key’)(‘IE_PROTO’);
var ObjectProto = Object.prototype;

module.exports = Object.getPrototypeOf , “./_has”:222,”./_to-object”:189,”./_shared-key”:240];
window.modules[“234”] = [function(require,module,exports){var ITERATOR = require(‘./_wks’)(‘iterator’);
var SAFE_CLOSING = false;

try
var riter = [7][ITERATOR]();
riter[‘return’] = function () SAFE_CLOSING = true; ;
// eslint-disable-next-line no-throw-literal
Array.from(riter, function () throw 2; );
catch (e) /* empty */

module.exports = function (exec, skipClosing)
if (!skipClosing && !SAFE_CLOSING) return false;
var safe = false;
try
var arr = [7];
var iter = arr[ITERATOR]();
iter.next = function () return done: safe = true ; ;
arr[ITERATOR] = function () return iter; ;
exec(arr);
catch (e) /* empty */
return safe;
;
}, “./_wks”:193];
window.modules[“235″] = [function(require,module,exports)var id = 0;
var px = Math.random();
module.exports = function (key)
return ‘Symbol(‘.concat(key === undefined ? ” : key, ‘)_’, (++id + px).toString(36));
;
, ];
window.modules[“236″] = [function(require,module,exports){var global = require(‘./_global’);
var macrotask = require(‘./_task’).set;
var Observer = global.MutationObserver || global.WebKitMutationObserver;
var process = global.process;
var Promise = global.Promise;
var isNode = require(‘./_cof’)(process) == ‘process’;

module.exports = function ()
var head, last, notify;

var flush = function ()
var parent, fn;
if (isNode && (parent = process.domain)) parent.exit();
while (head)
fn = head.fn;
head = head.next;
try
fn();
catch (e)
if (head) notify();
else last = undefined;
throw e;

last = undefined;
if (parent) parent.enter();
;

// Node.js
if (isNode)
notify = function ()
process.nextTick(flush);
;
// browsers with MutationObserver, except iOS Safari – https://github.com/zloirock/core-js/issues/339
else if (Observer && !(global.navigator && global.navigator.standalone))
var toggle = true;
var node = document.createTextNode(”);
new Observer(flush).observe(node, characterData: true ); // eslint-disable-line no-new
notify = function ()
node.data = toggle = !toggle;
;
// environments with maybe non-completely correct, but existent Promise
else if (Promise && Promise.resolve)
// Promise.resolve without an argument throws an error in LG WebOS 2
var promise = Promise.resolve(undefined);
notify = function ()
promise.then(flush);
;
// for other environments – macrotask based on:
// – setImmediate
// – MessageChannel
// – window.postMessag
// – onreadystatechange
// – setTimeout
else
notify = function ()
// strange IE + webpack dev server bug – use .call(global)
macrotask.call(global, flush);
;

return function (fn)
var task = fn: fn, next: undefined ;
if (last) last.next = task;
if (!head)
head = task;
notify();
last = task;
;
;
}, “./_global”:208,”./_task”:237,”./_cof”:195];
window.modules[“237″] = [function(require,module,exports){var ctx = require(‘./_ctx’);
var invoke = require(‘./_invoke’);
var html = require(‘./_html’);
var cel = require(‘./_dom-create’);
var global = require(‘./_global’);
var process = global.process;
var setTask = global.setImmediate;
var clearTask = global.clearImmediate;
var MessageChannel = global.MessageChannel;
var Dispatch = global.Dispatch;
var counter = 0;
var queue = ;
var ONREADYSTATECHANGE = ‘onreadystatechange’;
var defer, channel, port;
var run = function ()
var id = +this;
// eslint-disable-next-line no-prototype-builtins
if (queue.hasOwnProperty(id))
var fn = queue[id];
delete queue[id];
fn();

;
var listener = function (event)
run.call(event.data);
;
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
if (!setTask || !clearTask)
setTask = function setImmediate(fn)
var args = [];
var i = 1;
while (arguments.length > i) args.push(arguments[i++]);
queue[++counter] = function ()
// eslint-disable-next-line no-new-func
invoke(typeof fn == ‘function’ ? fn : Function(fn), args);
;
defer(counter);
return counter;
;
clearTask = function clearImmediate(id)
delete queue[id];
;
// Node.js 0.8-
if (require(‘./_cof’)(process) == ‘process’)
defer = function (id)
process.nextTick(ctx(run, id, 1));
;
// Sphere (JS game engine) Dispatch API
else if (Dispatch && Dispatch.now)
defer = function (id)
Dispatch.now(ctx(run, id, 1));
;
// Browsers with MessageChannel, includes WebWorkers
else if (MessageChannel)
channel = new MessageChannel();
port = channel.port2;
channel.port1.onmessage = listener;
defer = ctx(port.postMessage, port, 1);
// Browsers with postMessage, skip WebWorkers
// IE8 has postMessage, but it’s sync & typeof its postMessage is ‘object’
else if (global.addEventListener && typeof postMessage == ‘function’ && !global.importScripts)
defer = function (id)
global.postMessage(id + ”, ‘*’);
;
global.addEventListener(‘message’, listener, false);
// IE8-
else if (ONREADYSTATECHANGE in cel(‘script’))
defer = function (id)
html.appendChild(cel(‘script’))[ONREADYSTATECHANGE] = function ()
html.removeChild(this);
run.call(id);
;
;
// Rest old browsers
else
defer = function (id)
setTimeout(ctx(run, id, 1), 0);
;

module.exports =
set: setTask,
clear: clearTask
;
}, “./_ctx”:187,”./_global”:208,”./_cof”:195,”./_invoke”:228,”./_html”:226,”./_dom-create”:216];
window.modules[“238”] = [function(require,module,exports)’use strict’;
// 25.4.1.5 NewPromiseCapability(C)
var aFunction = require(‘./_a-function’);

function PromiseCapability(C)
var resolve, reject;
this.promise = new C(function ($$resolve, $$reject) );
this.resolve = aFunction(resolve);
this.reject = aFunction(reject);

module.exports.f = function (C)
return new PromiseCapability(C);
;
, “./_a-function”:175];
window.modules[“240”] = [function(require,module,exports)var shared = require(‘./_shared’)(‘keys’);
var uid = require(‘./_uid’);
module.exports = function (key)
return shared[key] ;
, “./_shared”:253,”./_uid”:235];
window.modules[“241”] = [function(require,module,exports)var dP = require(‘./_object-dp’);
var anObject = require(‘./_an-object’);
var getKeys = require(‘./_object-keys’);

module.exports = require(‘./_descriptors’) ? Object.defineProperties : function defineProperties(O, Properties)
anObject(O);
var keys = getKeys(Properties);
var length = keys.length;
var i = 0;
var P;
while (length > i) dP.f(O, P = keys[i++], Properties[P]);
return O;
;
, “./_object-dp”:197,”./_an-object”:178,”./_object-keys”:219,”./_descriptors”:202];
window.modules[“242”] = [function(require,module,exports)// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = require(‘./_is-object’);
// instead of the ES6 spec version, we didn’t implement @@toPrimitive case
// and the second argument – flag – preferred type is a string
module.exports = function (it, S)
if (!isObject(it)) return it;
var fn, val;
if (S && typeof (fn = it.toString) == ‘function’ && !isObject(val = fn.call(it))) return val;
if (typeof (fn = it.valueOf) == ‘function’ && !isObject(val = fn.call(it))) return val;
if (!S && typeof (fn = it.toString) == ‘function’ && !isObject(val = fn.call(it))) return val;
throw TypeError(“Can’t convert object to primitive value”);
;
, “./_is-object”:179];
window.modules[“246”] = [function(require,module,exports)var has = require(‘./_has’);
var toIObject = require(‘./_to-iobject’);
var arrayIndexOf = require(‘./_array-includes’)(false);
var IE_PROTO = require(‘./_shared-key’)(‘IE_PROTO’);

module.exports = function (object, names)
var O = toIObject(object);
var i = 0;
var result = [];
var key;
for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
// Don’t enum bug & hidden keys
while (names.length > i) if (has(O, key = names[i++])) result.push(key);

return result;
;
, “./_has”:222,”./_to-iobject”:183,”./_shared-key”:240,”./_array-includes”:182];
window.modules[“247”] = [function(require,module,exports)// most Object methods by ES6 should accept primitives
var $export = require(‘./_export’);
var core = require(‘./_core’);
var fails = require(‘./_fails’);
module.exports = function (KEY, exec) Object[KEY];
var exp = ;
exp[KEY] = exec(fn);
$export($export.S + $export.F * fails(function () fn(1); ), ‘Object’, exp);
;
, “./_export”:209,”./_core”:153,”./_fails”:212];
window.modules[“249”] = [function(require,module,exports)module.exports = function (exec)
try
return e: false, v: exec() ;
catch (e)
return e: true, v: e ;

;
, ];
window.modules[“250”] = [function(require,module,exports)var anObject = require(‘./_an-object’);
var isObject = require(‘./_is-object’);
var newPromiseCapability = require(‘./_new-promise-capability’);

module.exports = function (C, x)
anObject(C);
if (isObject(x) && x.constructor === C) return x;
var promiseCapability = newPromiseCapability.f(C);
var resolve = promiseCapability.resolve;
resolve(x);
return promiseCapability.promise;
;
, “./_an-object”:178,”./_is-object”:179,”./_new-promise-capability”:238];
window.modules[“253”] = [function(require,module,exports)var core = require(‘./_core’);
var global = require(‘./_global’);
var SHARED = ‘__core-js_shared__’;
var store = global[SHARED] , “./_core”:153,”./_global”:208,”./_library”:231];
window.modules[“254”] = [function(require,module,exports)// 7.3.20 SpeciesConstructor(O, defaultConstructor)
var anObject = require(‘./_an-object’);
var aFunction = require(‘./_a-function’);
var SPECIES = require(‘./_wks’)(‘species’);
module.exports = function (O, D)
var C = anObject(O).constructor;
var S;
return C === undefined ;
, “./_an-object”:178,”./_a-function”:175,”./_wks”:193];
window.modules[“255″] = [function(require,module,exports){var toInteger = require(‘./_to-integer’);
var defined = require(‘./_defined’);
// true -> String#at
// false -> String#codePointAt
module.exports = function (TO_STRING)
return function (that, pos)
var s = String(defined(that));
var i = toInteger(pos);
var l = s.length;
var a, b;
if (i = l) return TO_STRING ? ” : undefined;
a = s.charCodeAt(i);
return a 0xdbff ;
, ];
window.modules[“257”] = [function(require,module,exports), “./_global”:208];
window.modules[“259”] = [function(require,module,exports)’use strict’;
var addToUnscopables = require(‘./_add-to-unscopables’);
var step = require(‘./_iter-step’);
var Iterators = require(‘./_iterators’);
var toIObject = require(‘./_to-iobject’);

// 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]()
module.exports = require(‘./_iter-define’)(Array, ‘Array’, function (iterated, kind)
this._t = toIObject(iterated); // target
this._i = 0; // next index
this._k = kind; // kind
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
, function ()
var O = this._t;
var kind = this._k;
var index = this._i++;
if (!O , ‘values’);

// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
Iterators.Arguments = Iterators.Array;

addToUnscopables(‘keys’);
addToUnscopables(‘values’);
addToUnscopables(‘entries’);
, “./_iterators”:229,”./_iter-define”:199,”./_add-to-unscopables”:176,”./_iter-step”:200,”./_to-iobject”:183];
window.modules[“260”] = [function(require,module,exports)/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/

// This method of obtaining a reference to the global object needs to be
// kept identical to the way it is obtained in runtime.js
var g = (function() return this )() , “./runtime”:881];
window.modules[“262”] = [function(require,module,exports), ];
window.modules[“263”] = [function(require,module,exports), ];
window.modules[“269”] = [function(require,module,exports){(function (setImmediate,clearImmediate){
var nextTick = require(‘process/browser.js’).nextTick;
var apply = Function.prototype.apply;
var slice = Array.prototype.slice;
var immediateIds = ;
var nextImmediateId = 0;

// DOM APIs, for completeness

exports.setTimeout = function()
return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
;
exports.setInterval = function()
return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
;
exports.clearTimeout =
exports.clearInterval = function(timeout) timeout.close(); ;

function Timeout(id, clearFn)
this._id = id;
this._clearFn = clearFn;

Timeout.prototype.unref = Timeout.prototype.ref = function() ;
Timeout.prototype.close = function()
this._clearFn.call(window, this._id);
;

// Does not start the time, just sets up the members needed.
exports.enroll = function(item, msecs)
clearTimeout(item._idleTimeoutId);
item._idleTimeout = msecs;
;

exports.unenroll = function(item)
clearTimeout(item._idleTimeoutId);
item._idleTimeout = -1;
;

exports._unrefActive = exports.active = function(item)
clearTimeout(item._idleTimeoutId);

var msecs = item._idleTimeout;
if (msecs >= 0)
item._idleTimeoutId = setTimeout(function onTimeout()
if (item._onTimeout)
item._onTimeout();
, msecs);

;

// That’s not how node.js implements it but the exposed api is the same.
exports.setImmediate = typeof setImmediate === “function” ? setImmediate : function(fn) {
var id = nextImmediateId++;
var args = arguments.length
// Copyright(c) 2013 Nicolas Perriault

// MIT Licensed

// A module that can be mixed in to *any object* in order to provide it with
// custom events. You may bind with `on` or remove with `off` callback functions
// to an event; trigger`-ing an event fires all callbacks in succession.
//
// var object = ;
// Eventify.enable(object);
// object.on(‘expand’, function() alert(‘expanded’); );
// object.trigger(‘expand’);
(function (name, global, definition)
if (typeof module !== ‘undefined’)
module.exports = definition(name, global);
else if (typeof define === ‘function’ && typeof define.amd === ‘object’)
define(definition);
else
// global[name] = definition(name, global);
var self = definition(),

// Save the previous value of the `Eventify` variable.
prev = global[name];

// Run Eventify in *noConflict* mode, returning the `Eventify`
// variable to its previous owner. Returns a reference to
// the Eventify object.
self.noConflict = function ()
global[name] = prev;
return self;
;

global[name] = self;

(this.localEventifyLibraryName || “Eventify”, this, function () {
‘use strict’;

// Eventify, based on Backbone.Events
// —————–

function uniqueId(prefix)
idCounter = idCounter + 1;
var id = idCounter + ”;
return prefix ? prefix + id : id;

function once(func)
var ran = false,
memo;
return function ()
if (ran)
return memo;

var args = (arguments.length === 1 ?
[arguments[0]] : Array.apply(null, arguments));
ran = true;
memo = func.apply(this, args);
func = null;
return memo;
;

var EventifyInstance,
listenMethods =
listenTo: ‘on’,
listenToOnce: ‘once’
,
slice = Array.prototype.slice,
idCounter = 0,

// Regular expression used to split event strings
eventSplitter = /s+/,

// Defines the name of the local variable the Eventify library will use
// this is specially useful if window.Eventify is already being used
// by your application and you want a different name. For example:
// // Declare before including the Eventify library
// var localEventifyLibraryName = ‘EventManager’;

// Create a safe reference to the Eventify object for use below.
Eventify = function ()
return this;
;

Eventify.prototype = {

// Event Functions
// —————–

// Bind an event to a `callback` function. Passing `”all”` will bind
// the callback to all events fired.
on: function (name, callback, context) !callback)
return this;

this._events = this._events ,

// Bind an event to only be triggered a single time. After the first time
// the callback is invoked, it will be removed.
once: function (name, callback, context) ,

// Remove one or many callbacks. If `context` is null, removes all
// callbacks with that function. If `callback` is null, removes all
// callbacks for the event. If `name` is null, removes all bound
// callbacks for all events.
off: function (name, callback, context)
var retain, ev, events, names, i, l, j, k;
if (!this._events ,
PartialBlockStatement: function PartialBlockStatement(partialBlock)
this.PartialStatement(partialBlock);
,

MustacheStatement: function MustacheStatement(mustache)
this.SubExpression(mustache);

if (mustache.escaped && !this.options.noEscape)
this.opcode(‘appendEscaped’);
else
this.opcode(‘append’);

,
Decorator: function Decorator(decorator)
this.DecoratorBlock(decorator);
,

ContentStatement: function ContentStatement(content)
if (content.value)
this.opcode(‘appendContent’, content.value);

,

CommentStatement: function CommentStatement() ,

SubExpression: function SubExpression(sexpr)
transformLiteralToPath(sexpr);
var type = this.classifySexpr(sexpr);

if (type === ‘simple’)
this.simpleSexpr(sexpr);
else if (type === ‘helper’)
this.helperSexpr(sexpr);
else
this.ambiguousSexpr(sexpr);

,
ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse)
var path = sexpr.path,
name = path.parts[0],
isBlock = program != null ,

simpleSexpr: function simpleSexpr(sexpr)
var path = sexpr.path;
path.strict = true;
this.accept(path);
this.opcode(‘resolvePossibleLambda’);
,

helperSexpr: function helperSexpr(sexpr, program, inverse)
var params = this.setupFullMustacheParams(sexpr, program, inverse),
path = sexpr.path,
name = path.parts[0];

if (this.options.knownHelpers[name])
this.opcode(‘invokeKnownHelper’, params.length, name);
else if (this.options.knownHelpersOnly)
throw new _exception2[‘default’](‘You specified knownHelpersOnly, but used the unknown helper ‘ + name, sexpr);
else
path.strict = true;
path.falsy = true;

this.accept(path);
this.opcode(‘invokeHelper’, params.length, path.original, _ast2[‘default’].helpers.simpleId(path));

,

PathExpression: function PathExpression(path)
this.addDepth(path.depth);
this.opcode(‘getContext’, path.depth);

var name = path.parts[0],
scoped = _ast2[‘default’].helpers.scopedId(path),
blockParamId = !path.depth && !scoped && this.blockParamIndex(name);

if (blockParamId)
this.opcode(‘lookupBlockParam’, blockParamId, path.parts);
else if (!name)
// Context reference, i.e. `foo .` or `foo ..`
this.opcode(‘pushContext’);
else if (path.data)
this.options.data = true;
this.opcode(‘lookupData’, path.depth, path.parts, path.strict);
else
this.opcode(‘lookupOnContext’, path.parts, path.falsy, path.strict, scoped);

,

StringLiteral: function StringLiteral(string)
this.opcode(‘pushString’, string.value);
,

NumberLiteral: function NumberLiteral(number)
this.opcode(‘pushLiteral’, number.value);
,

BooleanLiteral: function BooleanLiteral(bool)
this.opcode(‘pushLiteral’, bool.value);
,

UndefinedLiteral: function UndefinedLiteral()
this.opcode(‘pushLiteral’, ‘undefined’);
,

NullLiteral: function NullLiteral()
this.opcode(‘pushLiteral’, ‘null’);
,

Hash: function Hash(hash)
var pairs = hash.pairs,
i = 0,
l = pairs.length;

this.opcode(‘pushHash’);

for (; i = 0)
return [depth, param];

}
};

function precompile(input, options, env)

function compile(input, options, env)

function argEquals(a, b) {
if (a === b)
return true;

if (_utils.isArray(a) && _utils.isArray(b) && a.length === b.length) this.useDepths)
params.push(‘blockParams’);

if (this.useDepths)
params.push(‘depths’);

// Perform a second pass over the output to merge content when possible
var source = this.mergeSource(varDeclarations);

if (asObject)
params.push(source);

return Function.apply(this, params);
else
return this.source.wrap([‘function(‘, params.join(‘,’), ‘) n ‘, source, ”]);

,
mergeSource: function mergeSource(varDeclarations) {
var isSimple = this.environment.isSimple,
appendOnly = !this.forceBuffer,
appendFirst = undefined,
sourceSeen = undefined,
bufferStart = undefined,
bufferEnd = undefined;
this.source.each(function (line)
if (line.appendToBuffer)
if (bufferStart)
line.prepend(‘ + ‘);
else
bufferStart = line;

bufferEnd = line;
else
if (bufferStart)
if (!sourceSeen)
appendFirst = true;
else
bufferStart.prepend(‘buffer += ‘);

bufferEnd.add(‘;’);
bufferStart = bufferEnd = undefined;

sourceSeen = true;
if (!isSimple)
appendOnly = false;

);

if (appendOnly)
if (bufferStart)
bufferStart.prepend(‘return ‘);
bufferEnd.add(‘;’);
else if (!sourceSeen)
this.source.push(‘return “”;’);

else
varDeclarations += ‘, buffer = ‘ + (appendFirst ? ” : this.initializeBuffer());

if (bufferStart)
bufferStart.prepend(‘return buffer + ‘);
bufferEnd.add(‘;’);
else
this.source.push(‘return buffer;’);

if (varDeclarations)
this.source.prepend(‘var ‘ + varDeclarations.substring(2) + (appendFirst ? ” : ‘;n’));

return this.source.merge();
},

// [blockValue]
//
// On stack, before: hash, inverse, program, value
// On stack, after: return value of blockHelperMissing
//
// The purpose of this opcode is to take a block of the form
// `#this.foo…/this.foo`, resolve the value of `foo`, and
// replace it on the stack with the result of properly
// invoking blockHelperMissing.
blockValue: function blockValue(name)
var blockHelperMissing = this.aliasable(‘helpers.blockHelperMissing’),
params = [this.contextName(0)];
this.setupHelperArgs(name, 0, params);

var blockName = this.popStack();
params.splice(1, 0, blockName);

this.push(this.source.functionCall(blockHelperMissing, ‘call’, params));
,

// [ambiguousBlockValue]
//
// On stack, before: hash, inverse, program, value
// Compiler value, before: lastHelper=value of last found helper, if any
// On stack, after, if no lastHelper: same as [blockValue]
// On stack, after, if lastHelper: value
ambiguousBlockValue: function ambiguousBlockValue()
// We’re being a bit cheeky and reusing the options value from the prior exec
var blockHelperMissing = this.aliasable(‘helpers.blockHelperMissing’),
params = [this.contextName(0)];
this.setupHelperArgs(”, 0, params, true);

this.flushInline();

var current = this.topStack();
params.splice(1, 0, current);

this.pushSource([‘if (!’, this.lastHelper, ‘) ‘, current, ‘ = ‘, this.source.functionCall(blockHelperMissing, ‘call’, params), ”]);
,

// [appendContent]
//
// On stack, before: …
// On stack, after: …
//
// Appends the string value of `content` to the current buffer
appendContent: function appendContent(content)
if (this.pendingContent)
content = this.pendingContent + content;
else
this.pendingLocation = this.source.currentLocation;

this.pendingContent = content;
,

// [append]
//
// On stack, before: value, …
// On stack, after: …
//
// Coerces `value` to a String and appends it to the current buffer.
//
// If `value` is truthy, or 0, it is coerced into a string and appended
// Otherwise, the empty string is appended
append: function append()
if (this.isInline())
this.replaceStack(function (current)
return [‘ != null ? ‘, current, ‘ : “”‘];
);

this.pushSource(this.appendToBuffer(this.popStack()));
else
var local = this.popStack();
this.pushSource([‘if (‘, local, ‘ != null) ‘, this.appendToBuffer(local, undefined, true), ‘ ‘]);
if (this.environment.isSimple)
this.pushSource([‘else ‘, this.appendToBuffer(“””, undefined, true), ‘ ‘]);

,

// [appendEscaped]
//
// On stack, before: value, …
// On stack, after: …
//
// Escape `value` and append it to the buffer
appendEscaped: function appendEscaped()
this.pushSource(this.appendToBuffer([this.aliasable(‘container.escapeExpression’), ‘(‘, this.popStack(), ‘)’]));
,

// [getContext]
//
// On stack, before: …
// On stack, after: …
// Compiler value, after: lastContext=depth
//
// Set the value of the `lastContext` compiler value to the depth
getContext: function getContext(depth)
this.lastContext = depth;
,

// [pushContext]
//
// On stack, before: …
// On stack, after: currentContext, …
//
// Pushes the value of the current context onto the stack.
pushContext: function pushContext()
this.pushStackLiteral(this.contextName(this.lastContext));
,

// [lookupOnContext]
//
// On stack, before: …
// On stack, after: currentContext[name], …
//
// Looks up the value of `name` on the current context and pushes
// it onto the stack.
lookupOnContext: function lookupOnContext(parts, falsy, strict, scoped)
var i = 0;

if (!scoped && this.options.compat && !this.lastContext)
// The depthed query is expected to handle the undefined logic for the root level that
// is implemented below, so we evaluate that directly in compat mode
this.push(this.depthedLookup(parts[i++]));
else
this.pushContext();

this.resolvePath(‘context’, parts, i, falsy, strict);
,

// [lookupBlockParam]
//
// On stack, before: …
// On stack, after: blockParam[name], …
//
// Looks up the value of `parts` on the given block param and pushes
// it onto the stack.
lookupBlockParam: function lookupBlockParam(blockParamId, parts)
this.useBlockParams = true;

this.push([‘blockParams[‘, blockParamId[0], ‘][‘, blockParamId[1], ‘]’]);
this.resolvePath(‘context’, parts, 1);
,

// [lookupData]
//
// On stack, before: …
// On stack, after: data, …
//
// Push the data lookup operator
lookupData: function lookupData(depth, parts, strict)
if (!depth)
this.pushStackLiteral(‘data’);
else
this.pushStackLiteral(‘container.data(data, ‘ + depth + ‘)’);

this.resolvePath(‘data’, parts, 0, true, strict);
,

resolvePath: function resolvePath(type, parts, i, falsy, strict)
// istanbul ignore next

var _this = this;

if (this.options.strict ,
topStackName: function topStackName()
return ‘stack’ + this.stackSlot;
,
flushInline: function flushInline()
var inlineStack = this.inlineStack;
this.inlineStack = [];
for (var i = 0, len = inlineStack.length; i ‘: ‘>’,
‘”‘: ‘”‘,
“‘”: ”’,
‘`’: ‘`’,
‘=’: ‘=’
;

var badChars = /[&”‘`=]/g,
possible = /[&”‘`=]/;

function escapeChar(chr)
return escape[chr];

function extend(obj /* , …source */)
for (var i = 1; i = 2.0.0-beta.1’,
7: ‘>= 4.0.0’
;

exports.REVISION_CHANGES = REVISION_CHANGES;
var objectType = ‘[object Object]’;

function HandlebarsEnvironment(helpers, partials, decorators) ;
this.decorators = decorators

HandlebarsEnvironment.prototype =
constructor: HandlebarsEnvironment,

logger: _logger2[‘default’],
log: _logger2[‘default’].log,

registerHelper: function registerHelper(name, fn)
if (_utils.toString.call(name) === objectType)
if (fn)
throw new _exception2[‘default’](‘Arg not supported with multiple helpers’);

_utils.extend(this.helpers, name);
else
this.helpers[name] = fn;

,
unregisterHelper: function unregisterHelper(name)
delete this.helpers[name];
,

registerPartial: function registerPartial(name, partial)
if (_utils.toString.call(name) === objectType)
_utils.extend(this.partials, name);
else
if (typeof partial === ‘undefined’)
throw new _exception2[‘default’](‘Attempting to register a partial called “‘ + name + ‘” as undefined’);

this.partials[name] = partial;

,
unregisterPartial: function unregisterPartial(name)
delete this.partials[name];
,

registerDecorator: function registerDecorator(name, fn)
if (_utils.toString.call(name) === objectType)
if (fn)
throw new _exception2[‘default’](‘Arg not supported with multiple decorators’);

_utils.extend(this.decorators, name);
else
this.decorators[name] = fn;

,
unregisterDecorator: function unregisterDecorator(name)
delete this.decorators[name];

;

var log = _logger2[‘default’].log;

exports.log = log;
exports.createFrame = _utils.createFrame;
exports.logger = _logger2[‘default’];

}, “./utils”:464,”./exception”:463,”./logger”:467,”./helpers”:468,”./decorators”:469];
window.modules[“467”] = [function(require,module,exports){‘use strict’;

exports.__esModule = true;

var _utils = require(‘./utils’);

var logger =
methodMap: [‘debug’, ‘info’, ‘warn’, ‘error’],
level: ‘info’,

// Maps a given level value to the `methodMap` indexes above.
lookupLevel: function lookupLevel(level)
if (typeof level === ‘string’)
var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
if (levelMap >= 0)
level = levelMap;
else
level = parseInt(level, 10);

return level;
,

// Can be overridden in the host environment
log: function log(level)
level = logger.lookupLevel(level);

if (typeof console !== ‘undefined’ && logger.lookupLevel(logger.level) 1 ? _len – 1 : 0), _key = 1; _key 2)
expected.push(“‘” + this.terminals_[p] + “‘”);

if (this.lexer.showPosition) symbol) + “‘”;
else symbol) + “‘”);

this.parseError(errStr, symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected );

if (action[0] instanceof Array && action.length > 1)
throw new Error(“Parse Error: multiple actions possible at state: ” + state + “, token: ” + symbol);

switch (action[0])
case 1:
stack.push(symbol);
vstack.push(this.lexer.yytext);
lstack.push(this.lexer.yylloc);
stack.push(action[1]);
symbol = null;
if (!preErrorSymbol)
yyleng = this.lexer.yyleng;
yytext = this.lexer.yytext;
yylineno = this.lexer.yylineno;
yyloc = this.lexer.yylloc;
if (recovering > 0) recovering–;
else
symbol = preErrorSymbol;
preErrorSymbol = null;

break;
case 2:
len = this.productions_[action[1]][1];
yyval.$ = vstack[vstack.length – len];
yyval._$ = first_line: lstack[lstack.length – (len ;
if (ranges) 1)].range[0], lstack[lstack.length – 1].range[1]];

r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
if (typeof r !== “undefined”)
return r;

if (len)
stack = stack.slice(0, -1 * len * 2);
vstack = vstack.slice(0, -1 * len);
lstack = lstack.slice(0, -1 * len);

stack.push(this.productions_[action[1]][0]);
vstack.push(yyval.$);
lstack.push(yyval._$);
newState = table[stack[stack.length – 2]][stack[stack.length – 1]];
stack.push(newState);
break;
case 3:
return true;

}
return true;
}
};
/* Jison generated lexer */
var lexer = (function ()
var lexer = EOF: 1,
parseError: function parseError(str, hash)
if (this.yy.parser)
this.yy.parser.parseError(str, hash);
else
throw new Error(str);

,
setInput: function setInput(input)
this._input = input;
this._more = this._less = this.done = false;
this.yylineno = this.yyleng = 0;
this.yytext = this.matched = this.match = ”;
this.conditionStack = [‘INITIAL’];
this.yylloc = first_line: 1, first_column: 0, last_line: 1, last_column: 0 ;
if (this.options.ranges) this.yylloc.range = [0, 0];
this.offset = 0;
return this;
,
input: function input() n).*/g);
if (lines)
this.yylineno++;
this.yylloc.last_line++;
else
this.yylloc.last_column++;

if (this.options.ranges) this.yylloc.range[1]++;

this._input = this._input.slice(1);
return ch;
,
unput: function unput(ch)
var len = ch.length;
var lines = ch.split(/(?:rn?,
more: function more()
this._more = true;
return this;
,
less: function less(n)
this.unput(this.match.slice(n));
,
pastInput: function pastInput()
var past = this.matched.substr(0, this.matched.length – this.match.length);
return (past.length > 20 ? ‘…’ : ”) + past.substr(-20).replace(/n/g, “”);
,
upcomingInput: function upcomingInput()
var next = this.match;
if (next.length 20 ? ‘…’ : ”)).replace(/n/g, “”);
,
showPosition: function showPosition()
var pre = this.pastInput();
var c = new Array(pre.length + 1).join(“-“);
return pre + this.upcomingInput() + “n” + c + “^”;
,
next: function next()
if (this.done)
return this.EOF;

if (!this._input) this.done = true;

var token, match, tempMatch, index, col, lines;
if (!this._more)
this.yytext = ”;
this.match = ”;

var rules = this._currentRules();
for (var i = 0; i match[0].length))
match = tempMatch;
index = i;
if (!this.options.flex) break;

if (match) n).*/g);
if (lines) this.yylineno += lines.length;
this.yylloc = first_line: this.yylloc.last_line,
last_line: this.yylineno + 1,
first_column: this.yylloc.last_column,
last_column: lines ? lines[lines.length – 1].length – lines[lines.length – 1].match(/r?n?/)[0].length : this.yylloc.last_column + match[0].length ;
this.yytext += match[0];
this.match += match[0];
this.matches = match;
this.yyleng = this.yytext.length;
if (this.options.ranges)
this.yylloc.range = [this.offset, this.offset += this.yyleng];

this._more = false;
this._input = this._input.slice(match[0].length);
this.matched += match[0];
token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length – 1]);
if (this.done && this._input) this.done = false;
if (token) return token;else return;

if (this._input === “”)
return this.EOF;
else
return this.parseError(‘Lexical error on line ‘ + (this.yylineno + 1) + ‘. Unrecognized text.n’ + this.showPosition(), text: “”, token: null, line: this.yylineno );

,
lex: function lex()
var r = this.next();
if (typeof r !== ‘undefined’)
return r;
else
return this.lex();

,
begin: function begin(condition)
this.conditionStack.push(condition);
,
popState: function popState()
return this.conditionStack.pop();
,
_currentRules: function _currentRules()
return this.conditions[this.conditionStack[this.conditionStack.length – 1]].rules;
,
topState: function topState()
return this.conditionStack[this.conditionStack.length – 2];
,
pushState: function begin(condition)
this.begin(condition);
;
lexer.options = ;
lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START
/*“*/)

function strip(start, end)
return yy_.yytext = yy_.yytext.substr(start, yy_.yyleng – end);

var YYSTATE = YY_START;
switch ($avoiding_name_collisions)
case 0:
if (yy_.yytext.slice(-2) === “\\”)
strip(0, 1);
this.begin(“mu”);
else if (yy_.yytext.slice(-1) === “\”)
strip(0, 1);
this.begin(“emu”);
else
this.begin(“mu”);

if (yy_.yytext) return 15;

break;
case 1:
return 15;
break;
case 2:
this.popState();
return 15;

break;
case 3:
this.begin(‘raw’);return 15;
break;
case 4:
this.popState();
// Should be using `this.topState()` below, but it currently
// returns the second top instead of the first top. Opened an
// issue about it at https://github.com/zaach/jison/issues/291
if (this.conditionStack[this.conditionStack.length – 1] === ‘raw’)
return 15;
else
yy_.yytext = yy_.yytext.substr(5, yy_.yyleng – 9);
return ‘END_RAW_BLOCK’;

break;
case 5:
return 15;
break;
case 6:
this.popState();
return 14;

break;
case 7:
return 65;
break;
case 8:
return 68;
break;
case 9:
return 19;
break;
case 10:
this.popState();
this.begin(‘raw’);
return 23;

break;
case 11:
return 55;
break;
case 12:
return 60;
break;
case 13:
return 29;
break;
case 14:
return 47;
break;
case 15:
this.popState();return 44;
break;
case 16:
this.popState();return 44;
break;
case 17:
return 34;
break;
case 18:
return 39;
break;
case 19:
return 51;
break;
case 20:
return 48;
break;
case 21:
this.unput(yy_.yytext);
this.popState();
this.begin(‘com’);

break;
case 22:
this.popState();
return 14;

break;
case 23:
return 48;
break;
case 24:
return 73;
break;
case 25:
return 72;
break;
case 26:
return 72;
break;
case 27:
return 87;
break;
case 28:
// ignore whitespace
break;
case 29:
this.popState();return 54;
break;
case 30:
this.popState();return 33;
break;
case 31:
yy_.yytext = strip(1, 2).replace(/\”/g, ‘”‘);return 80;
break;
case 32:
yy_.yytext = strip(1, 2).replace(/\’/g, “‘”);return 80;
break;
case 33:
return 85;
break;
case 34:
return 82;
break;
case 35:
return 82;
break;
case 36:
return 83;
break;
case 37:
return 84;
break;
case 38:
return 81;
break;
case 39:
return 75;
break;
case 40:
return 77;
break;
case 41:
return 72;
break;
case 42:
yy_.yytext = yy_.yytext.replace(/\([\]])/g, ‘$1’);return 72;
break;
case 43:
return ‘INVALID’;
break;
case 44:
return 5;
break;

;
lexer.rules = [/^(?:[^x00]*?(?=({{)))/, /^(?:[^x00]+)/, /^(?:[^x00]2,?(?=({{|\{{|\\{{|$)))/, /^(?:{{{{(?=[^/]))/, /^(?:{\\/[^s!”#%-,./;->@[-^`-~]+(?=[=s/.])\\})/, /^(?:[^x00]*?(?=({{\)))/, /^(?:[sS]*?–(~)?\)/, /^(?:()/, /^(?:))/, /^(?:\\)/, /^(?:\\)/, /^(?:{{(~)?>)/, /^(?:{{(~)?#>)/, /^(?:{{(~)?#*?)/, /^(?:{{(~)?/)/, /^(?:\(~)?^s*(~)?\)/, /^(?:\(~)?s*elses*(~)?\)/, /^(?:{{(~)?^)/, /^(?:{{(~)?s*elseb)/, /^(?:{{(~)?{)/, /^(?:{{(~)?&)/, /^(?:\(~)?!–)/, /^(?:\(~)?![sS]*?\)/, /^(?:])))/, /^(?:[/.])/, /^(?:s+)/, /^(?:(~)?\)/, /^(?:(~)?}})/, /^(?:”(\[“]|[^”])*”)/, /^(?:'(\[‘]|[^’])*’)/, /^(?:@)/, /^(?:true(?=([~}s)])))/, /^(?:false(?=([~}s)])))/, /^(?:undefined(?=([~}s)])))/, /^(?:null(?=([~}s)])))/, /^(?:-?[0-9]+(?:.[0-9]+)?(?=([~}s)])))/, /^(?:ass+|)/, /^(?:|)/, /^(?:([^s!”#%-,./;->@[-^`-~]+(?=([=~s/.)|]))))/, /^(?:[(\]|[^]])*])/, /^(?:.)/, /^(?:$)/];
lexer.conditions = “mu”: “rules”: [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44], “inclusive”: false , “emu”: “rules”: [2], “inclusive”: false , “com”: “rules”: [6], “inclusive”: false , “raw”: “rules”: [3, 4, 5], “inclusive”: false , “INITIAL”: “rules”: [0, 1, 44], “inclusive”: true ;
return lexer;
})();
parser.lexer = lexer;
function Parser()
this.yy = ;
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();
})();exports[“default”] = handlebars;
module.exports = exports[“default”];

}, ];
window.modules[“471″] = [function(require,module,exports)’use strict’;

exports.__esModule = true;
exports.SourceLocation = SourceLocation;
exports.id = id;
exports.stripFlags = stripFlags;
exports.stripComment = stripComment;
exports.preparePath = preparePath;
exports.prepareMustache = prepareMustache;
exports.prepareRawBlock = prepareRawBlock;
exports.prepareBlock = prepareBlock;
exports.prepareProgram = prepareProgram;
exports.preparePartialBlock = preparePartialBlock;
// istanbul ignore next

function _interopRequireDefault(obj) return obj && obj.__esModule ? obj : ‘default’: obj ;

var _exception = require(‘../exception’);

var _exception2 = _interopRequireDefault(_exception);

function validateClose(open, close)
close = close.path ? close.path.original : close;

if (open.path.original !== close)
var errorNode = loc: open.path.loc ;

throw new _exception2[‘default’](open.path.original + ” doesn’t match ” + close, errorNode);

function SourceLocation(source, locInfo)
this.source = source;
this.start =
line: locInfo.first_line,
column: locInfo.first_column
;
this.end =
line: locInfo.last_line,
column: locInfo.last_column
;

function id(token)
if (/^[.*]$/.test(token))
return token.substr(1, token.length – 2);
else
return token;

function stripFlags(open, close)
return
open: open.charAt(2) === ‘~’,
close: close.charAt(close.length – 3) === ‘~’
;

function stripComment(comment)
return comment.replace(/^\~?!-?-?/, ”).replace(/-?-?~?\$/, ”);

function preparePath(data, parts, loc)
loc = this.locInfo(loc);

var original = data ? ‘@’ : ”,
dig = [],
depth = 0;

for (var i = 0, l = parts.length; i 0)
throw new _exception2[‘default’](‘Invalid path: ‘ + original, loc: loc );
else if (part === ‘..’)
depth++;

else
dig.push(part);

return
type: ‘PathExpression’,
data: data,
depth: depth,
parts: dig,
original: original,
loc: loc
;
}

function prepareMustache(path, params, hash, open, strip, locInfo) {
// Must use charAt to support IE pre-10
var escapeFlag = open.charAt(3) || open.charAt(2),
escaped = escapeFlag !== ” && escapeFlag !== ‘&’;

var decorator = /*/.test(open);
return
type: decorator ? ‘Decorator’ : ‘MustacheStatement’,
path: path,
params: params,
hash: hash,
escaped: escaped,
strip: strip,
loc: this.locInfo(locInfo)
;

function prepareRawBlock(openRawBlock, contents, close, locInfo)
validateClose(openRawBlock, close);

locInfo = this.locInfo(locInfo);
var program =
type: ‘Program’,
body: contents,
strip: ,
loc: locInfo
;

return
type: ‘BlockStatement’,
path: openRawBlock.path,
params: openRawBlock.params,
hash: openRawBlock.hash,
program: program,
openStrip: ,
inverseStrip: ,
closeStrip: ,
loc: locInfo
;

function prepareBlock(openBlock, program, inverseAndProgram, close, inverted, locInfo)
if (close && close.path)
validateClose(openBlock, close);

var decorator = /*/.test(openBlock.open);

program.blockParams = openBlock.blockParams;

var inverse = undefined,
inverseStrip = undefined;

if (inverseAndProgram)
if (decorator)
throw new _exception2[‘default’](‘Unexpected inverse block on decorator’, inverseAndProgram);

if (inverseAndProgram.chain)
inverseAndProgram.program.body[0].closeStrip = close.strip;

inverseStrip = inverseAndProgram.strip;
inverse = inverseAndProgram.program;

if (inverted)
inverted = inverse;
inverse = program;
program = inverted;

return
type: decorator ? ‘DecoratorBlock’ : ‘BlockStatement’,
path: openBlock.path,
params: openBlock.params,
hash: openBlock.hash,
program: program,
inverse: inverse,
openStrip: openBlock.strip,
inverseStrip: inverseStrip,
closeStrip: close && close.strip,
loc: this.locInfo(locInfo)
;

function prepareProgram(statements, loc) {
if (!loc && statements.length)
var firstLoc = statements[0].loc,
lastLoc = statements[statements.length – 1].loc;

/* istanbul ignore else */
if (firstLoc && lastLoc)
loc =
source: firstLoc.source,
start:
line: firstLoc.start.line,
column: firstLoc.start.column
,
end:
line: lastLoc.end.line,
column: lastLoc.end.column

;

return
type: ‘Program’,
body: statements,
strip: ,
loc: loc
;
}

function preparePartialBlock(open, program, close, locInfo)
validateClose(open, close);

return
type: ‘PartialBlockStatement’,
name: open.path,
params: open.params,
hash: open.hash,
program: program,
openStrip: open.strip,
closeStrip: close && close.strip,
loc: this.locInfo(locInfo)
;

}, “../exception”:463];
window.modules[“472”] = [function(require,module,exports)’use strict’;

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) return obj && obj.__esModule ? obj : ‘default’: obj ;

var _visitor = require(‘./visitor’);

var _visitor2 = _interopRequireDefault(_visitor);

function WhitespaceControl()
var options = arguments.length ‘ + content + ‘ ‘);
};
PrintVisitor.prototype.PartialBlockStatement = function (partial)
var content = ‘PARTIAL BLOCK:’ + partial.name.original;
if (partial.params[0])
content += ‘ ‘ + this.accept(partial.params[0]);

if (partial.hash)
content += ‘ ‘ + this.accept(partial.hash);

content += ‘ ‘ + this.pad(‘PROGRAM:’);
this.padding++;
content += this.accept(partial.program);
this.padding–;

return this.pad(‘> ‘ + content + ‘ ‘);
;

PrintVisitor.prototype.ContentStatement = function (content)
return this.pad(“CONTENT[ ‘” + content.value + “‘ ]”);
;

PrintVisitor.prototype.CommentStatement = function (comment)
return this.pad(“! ‘” + comment.value + “‘ “);
;

PrintVisitor.prototype.SubExpression = function (sexpr)
var params = sexpr.params,
paramStrings = [],
hash = undefined;

for (var i = 0, l = params.length; i 0)
if (options.ids)
options.ids = [options.name];

return instance.helpers.each(context, options);
else
return inverse(this);

else
if (options.data && options.ids)
var data = _utils.createFrame(options.data);
data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
options = data: data ;

return fn(context, options);

});
};

module.exports = exports[‘default’];

}, “../utils”:464];
window.modules[“480″] = [function(require,module,exports){‘use strict’;

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) return obj && obj.__esModule ? obj : ‘default’: obj ;

var _utils = require(‘../utils’);

var _exception = require(‘../exception’);

var _exception2 = _interopRequireDefault(_exception);

exports[‘default’] = function (instance) {
instance.registerHelper(‘each’, function (context, options) {
if (!options)
throw new _exception2[‘default’](‘Must pass iterator to #each’);

var fn = options.fn,
inverse = options.inverse,
i = 0,
ret = ”,
data = undefined,
contextPath = undefined;

if (options.data && options.ids)
contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + ‘.’;

if (_utils.isFunction(context))
context = context.call(this);

if (options.data)
data = _utils.createFrame(options.data);

function execIteration(field, index, last)
if (data)
data.key = field;
data.index = index;
data.first = index === 0;
data.last = !!last;

if (contextPath)
data.contextPath = contextPath + field;

ret = ret + fn(context[field],
data: data,
blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
);

if (context && typeof context === ‘object’)
if (_utils.isArray(context))
for (var j = context.length; i = 0)
return idx;

else
var sStr = util.toSetString(aStr);
if (has.call(this._set, sStr))
return this._set[sStr];

throw new Error(‘”‘ + aStr + ‘” is not in the set.’);
;

/**
* What is the element at the given index?
*
* @param Number aIdx
*/
ArraySet.prototype.at = function ArraySet_at(aIdx) {
if (aIdx >= 0 && aIdx /..’ parts.
*
* Based on code in the Node.js ‘path’ core module.
*
* @param aPath The path or url to normalize.
*/
function normalize(aPath)
var path = aPath;
var url = urlParse(aPath);
if (url)
if (!url.path)
return aPath;

path = url.path;

var isAbsolute = exports.isAbsolute(path);

var parts = path.split(//+/);
for (var part, up = 0, i = parts.length – 1; i >= 0; i–)
part = parts[i];
if (part === ‘.’)
parts.splice(i, 1);
else if (part === ‘..’)
up++;
else if (up > 0)
if (part === ”)
// The first part is blank if the path is absolute. Trying to go
// above the root is a no-op. Therefore we can remove all ‘..’ parts
// directly after the root.
parts.splice(i + 1, up);
up = 0;
else
parts.splice(i, 2);
up–;

path = parts.join(‘/’);

if (path === ”)
path = isAbsolute ? ‘/’ : ‘.’;

if (url)
url.path = path;
return urlGenerate(url);

return path;

exports.normalize = normalize;

/**
* Joins two paths/URLs.
*
* @param aRoot The root path or URL.
* @param aPath The path or URL to be joined with the root.
*
* – If aPath is a URL or a data URI, aPath is returned, unless aPath is a
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
* first.
* – Otherwise aPath is a path. If aRoot is a URL, then its path portion
* is updated with the result and aRoot is returned. Otherwise the result
* is returned.
* – If aPath is absolute, the result is aPath.
* – Otherwise the two paths are joined with a slash.
* – Joining for example ‘http://’ and ‘www.example.com’ is also supported.
*/
function join(aRoot, aPath) aPath.match(dataUrlRegexp))
return aPath;

// `join(‘http://’, ‘www.example.com’)`
if (aRootUrl && !aRootUrl.host && !aRootUrl.path)
aRootUrl.host = aPath;
return urlGenerate(aRootUrl);

var joined = aPath.charAt(0) === ‘/’
? aPath
: normalize(aRoot.replace(//+$/, ”) + ‘/’ + aPath);

if (aRootUrl)
aRootUrl.path = joined;
return urlGenerate(aRootUrl);

return joined;

exports.join = join;

exports.isAbsolute = function (aPath) ;

/**
* Make a path relative to a URL or another path.
*
* @param aRoot The root path or URL.
* @param aPath The path or URL to be made relative to aRoot.
*/
function relative(aRoot, aPath)
if (aRoot === “”)
aRoot = “.”;

aRoot = aRoot.replace(//$/, ”);

// It is possible for the path to be above the root. In this case, simply
// checking whether the root is a prefix of the path won’t work. Instead, we
// need to remove components from the root one by one, until either we find
// a prefix that fits, or we run out of components to remove.
var level = 0;
while (aPath.indexOf(aRoot + ‘/’) !== 0)
var index = aRoot.lastIndexOf(“/”);
if (index = 0; i–)
if (s.charCodeAt(i) !== 36 /* ‘$’ */)
return false;

return true;

/**
* Comparator between two mappings where the original positions are compared.
*
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
* mappings with the same original source/line/column, but different generated
* line and column the same. Useful when searching for a mapping with a
* stubbed out mapping.
*/
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal)
exports.compareByOriginalPositions = compareByOriginalPositions;

/**
* Comparator between two mappings with deflated source and name indices where
* the generated positions are compared.
*
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
* mappings with the same generated line and column, but different
* source/name/original line and column the same. Useful when searching for a
* mapping with a stubbed out mapping.
*/
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) onlyCompareGenerated)
return cmp;

cmp = strcmp(mappingA.source, mappingB.source);
if (cmp !== 0)
return cmp;

cmp = mappingA.originalLine – mappingB.originalLine;
if (cmp !== 0)
return cmp;

cmp = mappingA.originalColumn – mappingB.originalColumn;
if (cmp !== 0)
return cmp;

return strcmp(mappingA.name, mappingB.name);

exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;

function strcmp(aStr1, aStr2)
if (aStr1 === aStr2)
return 0;

if (aStr1 === null)
return 1; // aStr2 !== null

if (aStr2 === null)
return -1; // aStr1 !== null

if (aStr1 > aStr2)
return 1;

return -1;

/**
* Comparator between two mappings with inflated source and name strings where
* the generated positions are compared.
*/
function compareByGeneratedPositionsInflated(mappingA, mappingB)
var cmp = mappingA.generatedLine – mappingB.generatedLine;
if (cmp !== 0)
return cmp;

cmp = mappingA.generatedColumn – mappingB.generatedColumn;
if (cmp !== 0)
return cmp;

cmp = strcmp(mappingA.source, mappingB.source);
if (cmp !== 0)
return cmp;

cmp = mappingA.originalLine – mappingB.originalLine;
if (cmp !== 0)
return cmp;

cmp = mappingA.originalColumn – mappingB.originalColumn;
if (cmp !== 0)
return cmp;

return strcmp(mappingA.name, mappingB.name);

exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;

/**
* Strip any JSON XSSI avoidance prefix from the string (as documented
* in the source maps specification), and then parse the string as
* JSON.
*/
function parseSourceMapInput(str)
return JSON.parse(str.replace(/^)]'[^n]*n/, ”));

exports.parseSourceMapInput = parseSourceMapInput;

/**
* Compute the URL of a source given the the source root, the source’s
* URL, and the source map’s URL.
*/
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL)
sourceURL = sourceURL
exports.computeSourceURL = computeSourceURL;
}, ];
window.modules[“486”] = [function(require,module,exports) Sign
//

/**
* Returns the base 64 VLQ encoded value.
*/
exports.encode = function base64VLQ_encode(aValue)
var encoded = “”;
var digit;

var vlq = toVLQSigned(aValue);

do
digit = vlq & VLQ_BASE_MASK;
vlq >>>= VLQ_BASE_SHIFT;
if (vlq > 0)
// There are still more digits in this value, so we must make sure the
// continuation bit is marked.
digit
encoded += base64.encode(digit);
while (vlq > 0);

return encoded;
;

/**
* Decodes the next base 64 VLQ value from the given string and returns the
* value and the rest of the string via the out parameter.
*/
exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
var strLen = aStr.length;
var result = 0;
var shift = 0;
var continuation, digit;

do {
if (aIndex >= strLen)
throw new Error(“Expected more digits in base 64 VLQ value.”);

digit = base64.decode(aStr.charCodeAt(aIndex++));
if (digit === -1)
throw new Error(“Invalid base64 digit: ” + aStr.charAt(aIndex – 1));

continuation = !!(digit & VLQ_CONTINUATION_BIT);
digit &= VLQ_BASE_MASK;
result = result + (digit 0) {
// Our needle is greater than aHaystack[mid].
if (aHigh – mid > 1)
// The element is in the upper half.
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);

// The exact needle element was not found in this haystack. Determine if
// we are in termination case (3) or (2) and return the appropriate thing.
if (aBias == exports.LEAST_UPPER_BOUND)
return aHigh 1)
// The element is in the lower half.
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);

// we are in termination case (3) or (2) and return the appropriate thing.
if (aBias == exports.LEAST_UPPER_BOUND)
return mid;
else
return aLow = 0)
if (aCompare(aHaystack[index], aHaystack[index – 1], true) !== 0)
break;

–index;

return index;
;
, ];
window.modules[“489”] = [function(require,module,exports){/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2014 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/

var util = require(‘./util’);

/**
* Determine whether mappingB is after mappingA with respect to generated
* position.
*/
function generatedPositionAfter(mappingA, mappingB) {
// Optimized for most common case
var lineA = mappingA.generatedLine;
var lineB = mappingB.generatedLine;
var columnA = mappingA.generatedColumn;
var columnB = mappingB.generatedColumn;
return lineB > lineA || lineB == lineA && columnB >= columnA ||
util.compareByGeneratedPositionsInflated(mappingA, mappingB) = 0)
var mapping = this._originalMappings[index];

if (aArgs.column === undefined)
var originalLine = mapping.originalLine;

// Iterate until either we run out of mappings, or we run into
// a mapping for a different line than the one we found. Since
// mappings are sorted, this is guaranteed to find all mappings for
// the line we found.
while (mapping && mapping.originalLine === originalLine)
mappings.push(
line: util.getArg(mapping, ‘generatedLine’, null),
column: util.getArg(mapping, ‘generatedColumn’, null),
lastColumn: util.getArg(mapping, ‘lastGeneratedColumn’, null)
);

mapping = this._originalMappings[++index];

else
var originalColumn = mapping.originalColumn;

// Iterate until either we run out of mappings, or we run into
// a mapping for a different line than the one we were searching for.
// Since mappings are sorted, this is guaranteed to find all mappings for
// the line we are searching for.
while (mapping &&
mapping.originalLine === line &&
mapping.originalColumn == originalColumn)
mappings.push(
line: util.getArg(mapping, ‘generatedLine’, null),
column: util.getArg(mapping, ‘generatedColumn’, null),
lastColumn: util.getArg(mapping, ‘lastGeneratedColumn’, null)
);

mapping = this._originalMappings[++index];

return mappings;
};

exports.SourceMapConsumer = SourceMapConsumer;

/**
* A BasicSourceMapConsumer instance represents a parsed source map which we can
* query for information about the original file positions by giving it a file
* position in the generated source.
*
* The first parameter is the raw source map (either as a JSON string, or
* already parsed to an object). According to the spec, source maps have the
* following attributes:
*
* – version: Which version of the source map spec this map is following.
* – sources: An array of URLs to the original source files.
* – names: An array of identifiers which can be referrenced by individual mappings.
* – sourceRoot: Optional. The URL root from which all sources are relative.
* – sourcesContent: Optional. An array of contents of the original source files.
* – mappings: A string of base64 VLQs which contain the actual mappings.
* – file: Optional. The generated file this source map is associated with.
*
* Here is an example source map, taken from the source map spec[0]:
*
*
* version : 3,
* file: “out.js”,
* sourceRoot : “”,
* sources: [“foo.js”, “bar.js”],
* names: [“src”, “maps”, “are”, “fun”],
* mappings: “AA,AB;;ABCDE;”
*
*
* The second parameter, if given, is a string whose value is the URL
* at which the source map was found. This URL is used to compute the
* sources array.
*
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
*/
function BasicSourceMapConsumer(aSourceMap, aSourceMapURL)
var sourceMap = aSourceMap;
if (typeof aSourceMap === ‘string’)
sourceMap = util.parseSourceMapInput(aSourceMap);

var version = util.getArg(sourceMap, ‘version’);
var sources = util.getArg(sourceMap, ‘sources’);
// Sass 3.3 leaves out the ‘names’ array, so we deviate from the spec (which
// requires the array) to play nice here.
var names = util.getArg(sourceMap, ‘names’, []);
var sourceRoot = util.getArg(sourceMap, ‘sourceRoot’, null);
var sourcesContent = util.getArg(sourceMap, ‘sourcesContent’, null);
var mappings = util.getArg(sourceMap, ‘mappings’);
var file = util.getArg(sourceMap, ‘file’, null);

// Once again, Sass deviates from the spec and supplies the version as a
// string rather than a number, so we use loose equality checking here.
if (version != this._version)
throw new Error(‘Unsupported version: ‘ + version);

if (sourceRoot)
sourceRoot = util.normalize(sourceRoot);

sources = sources
.map(String)
// Some source maps produce relative source paths like “./foo.js” instead of
// “foo.js”. Normalize these first so that future comparisons will succeed.
// See bugzil.la/1090768.
.map(util.normalize)
// Always ensure that absolute sources are internally stored relative to
// the source root, if the source root is absolute. Not doing this would
// be particularly problematic when the source root is a prefix of the
// source (valid, but why??). See github issue #199 and bugzil.la/1188982.
.map(function (source)
return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
? util.relative(sourceRoot, source)
: source;
);

// Pass `true` below to allow duplicate names and sources. While source maps
// are intended to be compressed and deduplicated, the TypeScript compiler
// sometimes generates source maps with duplicates in them. See Github issue
// #72 and bugzil.la/889492.
this._names = ArraySet.fromArray(names.map(String), true);
this._sources = ArraySet.fromArray(sources, true);

this._absoluteSources = this._sources.toArray().map(function (s)
return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
);

this.sourceRoot = sourceRoot;
this.sourcesContent = sourcesContent;
this._mappings = mappings;
this._sourceMapURL = aSourceMapURL;
this.file = file;

BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;

/**
* Utility function to find the index of a source. Returns -1 if not
* found.
*/
BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource)
var relativeSource = aSource;
if (this.sourceRoot != null)
relativeSource = util.relative(this.sourceRoot, relativeSource);

if (this._sources.has(relativeSource))
return this._sources.indexOf(relativeSource);

// Maybe aSource is an absolute URL as returned by
}

quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
this.__generatedMappings = generatedMappings;

quickSort(originalMappings, util.compareByOriginalPositions);
this.__originalMappings = originalMappings;
};

/**
* Find the mapping that best matches the hypothetical “needle” mapping that
* we are searching for in the given “haystack” of mappings.
*/
BasicSourceMapConsumer.prototype._findMapping =
function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
aColumnName, aComparator, aBias)
// To return the position we are searching for, we must first find the
// mapping for the given position and then return the opposite position it
// points to. Because the mappings are sorted, we can use binary search to
// find the best mapping.

if (aNeedle[aLineName] = 0)
var mapping = this._generatedMappings[index];

if (mapping.generatedLine === needle.generatedLine)
var source = util.getArg(mapping, ‘source’, null);
if (source !== null)
source = this._sources.at(source);
source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);

var name = util.getArg(mapping, ‘name’, null);
if (name !== null)
name = this._names.at(name);

return
source: source,
line: util.getArg(mapping, ‘originalLine’, null),
column: util.getArg(mapping, ‘originalColumn’, null),
name: name
;

return
source: null,
line: null,
column: null,
name: null
;
;

/**
* Return true if we have the source content for every source in the source
* map, false otherwise.
*/
BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
function BasicSourceMapConsumer_hasContentsOfAllSources()
if (!this.sourcesContent)
return false;

return this.sourcesContent.length >= this._sources.size() &&
!this.sourcesContent.some(function (sc) return sc == null; );
;

/**
* Returns the original source content. The only argument is the url of the
* original source file. Returns null if no original source content is
* available.
*/
BasicSourceMapConsumer.prototype.sourceContentFor =
function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing)
if (!this.sourcesContent)
return null;

var index = this._findSourceIndex(aSource);
if (index >= 0)
return this.sourcesContent[index];

var relativeSource = aSource;
if (this.sourceRoot != null)
relativeSource = util.relative(this.sourceRoot, relativeSource);

var url;
if (this.sourceRoot != null
&& (url = util.urlParse(this.sourceRoot))) url.path == “/”)
&& this._sources.has(“/” + relativeSource))
return this.sourcesContent[this._sources.indexOf(“/” + relativeSource)];

// This function is used recursively from
// IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
// don’t want to throw if we can’t find the source – we just want to
// return null, so we provide a flag to exit gracefully.
if (nullOnMissing)
return null;

else
throw new Error(‘”‘ + relativeSource + ‘” is not in the SourceMap.’);

;

/**
* Returns the generated line and column information for the original source,
* line, and column positions provided. The only argument is an object with
* the following properties:
*
* – source: The filename of the original source.
* – line: The line number in the original source. The line number
* is 1-based.
* – column: The column number in the original source. The column
* number is 0-based.
* – bias: Either ‘SourceMapConsumer.GREATEST_LOWER_BOUND’ or
* ‘SourceMapConsumer.LEAST_UPPER_BOUND’. Specifies whether to return the
* closest element that is smaller than or greater than the one we are
* searching for, respectively, if the exact element cannot be found.
* Defaults to ‘SourceMapConsumer.GREATEST_LOWER_BOUND’.
*
* and an object is returned with the following properties:
*
* – line: The line number in the generated source, or null. The
* line number is 1-based.
* – column: The column number in the generated source, or null.
* The column number is 0-based.
*/
BasicSourceMapConsumer.prototype.generatedPositionFor =
function SourceMapConsumer_generatedPositionFor(aArgs)
var source = util.getArg(aArgs, ‘source’);
source = this._findSourceIndex(source);
if (source = 0)
var mapping = this._originalMappings[index];

if (mapping.source === needle.source)
return
line: util.getArg(mapping, ‘generatedLine’, null),
column: util.getArg(mapping, ‘generatedColumn’, null),
lastColumn: util.getArg(mapping, ‘lastGeneratedColumn’, null)
;

return
line: null,
column: null,
lastColumn: null
;
;

exports.BasicSourceMapConsumer = BasicSourceMapConsumer;

/**
* An IndexedSourceMapConsumer instance represents a parsed source map which
* we can query for information. It differs from BasicSourceMapConsumer in
* that it takes “indexed” source maps (i.e. ones with a “sections” field) as
* input.
*
* The first parameter is a raw source map (either as a JSON string, or already
* parsed to an object). According to the spec for indexed source maps, they
* have the following attributes:
*
* – version: Which version of the source map spec this map is following.
* – file: Optional. The generated file this source map is associated with.
* – sections: A list of section definitions.
*
* Each value under the “sections” field has two fields:
* – offset: The offset into the original specified at which this section
* begins to apply, defined as an object with a “line” and “column”
* field.
* – map: A source map definition. This source map could also be indexed,
* but doesn’t have to be.
*
* Instead of the “map” field, it’s also possible to have a “url” field
* specifying a URL to retrieve a source map from, but that’s currently
* unsupported.
*
* Here’s an example source map, taken from the source map spec[0], but
* modified to omit a section which uses the “url” field.
*
*
* version : 3,
* file: “app.js”,
* sections: [
* offset: line:100, column:10,
* map:
* version : 3,
* file: “section.js”,
* sources: [“foo.js”, “bar.js”],
* names: [“src”, “maps”, “are”, “fun”],
* mappings: “AAAA,E;;ABCDE;”
*
* ],
*
*
* The second parameter, if given, is a string whose value is the URL
* at which the source map was found. This URL is used to compute the
* sources array.
*
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
*/
function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL)
var sourceMap = aSourceMap;
if (typeof aSourceMap === ‘string’)
sourceMap = util.parseSourceMapInput(aSourceMap);

var version = util.getArg(sourceMap, ‘version’);
var sections = util.getArg(sourceMap, ‘sections’);

if (version != this._version)
throw new Error(‘Unsupported version: ‘ + version);

this._sources = new ArraySet();
this._names = new ArraySet();

var lastOffset =
line: -1,
column: 0
;
this._sections = sections.map(function (s)
if (s.url)
// The url field will require support for asynchronicity.
// See https://github.com/mozilla/source-map/issues/16
throw new Error(‘Support for url field in sections not implemented.’);

var offset = util.getArg(s, ‘offset’);
var offsetLine = util.getArg(offset, ‘line’);
var offsetColumn = util.getArg(offset, ‘column’);

if (offsetLine 0 && aGenerated.column >= 0
&& !aOriginal && !aSource && !aName)
// Case 1.
return;

else if (aGenerated && ‘line’ in aGenerated && ‘column’ in aGenerated
&& aOriginal && ‘line’ in aOriginal && ‘column’ in aOriginal
&& aGenerated.line > 0 && aGenerated.column >= 0
&& aOriginal.line > 0 && aOriginal.column >= 0
&& aSource)
// Cases 2 and 3.
return;

else
throw new Error(‘Invalid mapping: ‘ + JSON.stringify(
generated: aGenerated,
source: aSource,
original: aOriginal,
name: aName
));

;

/**
* Serialize the accumulated mappings in to the stream of base 64 VLQs
* specified by the source map format.
*/
SourceMapGenerator.prototype._serializeMappings =
function SourceMapGenerator_serializeMappings()
var previousGeneratedColumn = 0;
var previousGeneratedLine = 1;
var previousOriginalColumn = 0;
var previousOriginalLine = 0;
var previousName = 0;
var previousSource = 0;
var result = ”;
var next;
var mapping;
var nameIdx;
var sourceIdx;

var mappings = this._mappings.toArray();
for (var i = 0, len = mappings.length; i 0)
if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i – 1]))
continue;

next += ‘,’;

next += base64VLQ.encode(mapping.generatedColumn
– previousGeneratedColumn);
previousGeneratedColumn = mapping.generatedColumn;

if (mapping.source != null)
sourceIdx = this._sources.indexOf(mapping.source);
next += base64VLQ.encode(sourceIdx – previousSource);
previousSource = sourceIdx;

// lines are stored 0-based in SourceMap spec version 3
next += base64VLQ.encode(mapping.originalLine – 1
– previousOriginalLine);
previousOriginalLine = mapping.originalLine – 1;

next += base64VLQ.encode(mapping.originalColumn
– previousOriginalColumn);
previousOriginalColumn = mapping.originalColumn;

if (mapping.name != null)
nameIdx = this._names.indexOf(mapping.name);
next += base64VLQ.encode(nameIdx – previousName);
previousName = nameIdx;

result += next;

return result;
};

SourceMapGenerator.prototype._generateSourcesContent =
function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot)
return aSources.map(function (source)
if (!this._sourcesContents)
return null;

if (aSourceRoot != null)
source = util.relative(aSourceRoot, source);

var key = util.toSetString(source);
return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
? this._sourcesContents[key]
: null;
, this);
;

/**
* Externalize the source map.
*/
SourceMapGenerator.prototype.toJSON =
function SourceMapGenerator_toJSON()
var map =
version: this._version,
sources: this._sources.toArray(),
names: this._names.toArray(),
mappings: this._serializeMappings()
;
if (this._file != null)
map.file = this._file;

if (this._sourceRoot != null)
map.sourceRoot = this._sourceRoot;

if (this._sourcesContents)
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);

return map;
;

/**
* Render the source map being generated to a string.
*/
SourceMapGenerator.prototype.toString =
function SourceMapGenerator_toString()
return JSON.stringify(this.toJSON());
;

exports.SourceMapGenerator = SourceMapGenerator;
}, “./util”:485,”./array-set”:484,”./mapping-list”:489,”./base64-vlq”:486];
window.modules[“493”] = [function(require,module,exports){/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/

var SourceMapGenerator = require(‘./source-map-generator’).SourceMapGenerator;
var util = require(‘./util’);

// Matches a Windows-style `rn` newline or a `n` newline used by all other
// operating systems these days (capturing the result).
var REGEX_NEWLINE = /(r?n)/;

// Newline character code for charCodeAt() comparisons
var NEWLINE_CODE = 10;

// Private symbol for identifying `SourceNode`s when multiple versions of
// the source-map library are loaded. This MUST NOT CHANGE across
// versions!
var isSourceNode = “$$$isSourceNode$$$”;

/**
* SourceNodes provide a way to abstract over interpolating/concatenating
* snippets of generated JavaScript source code while maintaining the line and
* column information associated with the original source code.
*
* @param aLine The original line number.
* @param aColumn The original column number.
* @param aSource The original source’s filename.
* @param aChunks Optional. An array of strings which are snippets of
* generated JS, or other SourceNodes.
* @param aName The original identifier.
*/
function SourceNode(aLine, aColumn, aSource, aChunks, aName)
this.children = [];
this.sourceContents = ;
this.line = aLine == null ? null : aLine;
this.column = aColumn == null ? null : aColumn;
this.source = aSource == null ? null : aSource;
this.name = aName == null ? null : aName;
this[isSourceNode] = true;
if (aChunks != null) this.add(aChunks);

/**
* Creates a SourceNode from generated code and a SourceMapConsumer.
*
* @param aGeneratedCode The generated code
* @param aSourceMapConsumer The SourceMap for the generated code
* @param aRelativePath Optional. The path that relative sources in the
* SourceMapConsumer should be relative to.
*/
SourceNode.fromStringWithSourceMap =
function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
// The SourceNode we want to fill with the generated code
// and the SourceMap
var node = new SourceNode();

// All even indices of this array are one line of the generated code,
// while all odd indices are the newlines between two adjacent lines
// (since `REGEX_NEWLINE` captures its match).
// Processed fragments are accessed by calling `shiftNextLine`.
var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
var remainingLinesIndex = 0;
var shiftNextLine = function() ;

/**
* Walk over the tree of JS snippets in this node and its children. The
* walking function is called once for each snippet of JS and is passed that
* snippet and the its original associated source’s line/column location.
*
* @param aFn The traversal function.
*/
SourceNode.prototype.walk = function SourceNode_walk(aFn)
var chunk;
for (var i = 0, len = this.children.length; i 0)
newChildren = [];
for (i = 0; i -1
;

function normalizeName(name)
if (typeof name !== ‘string’)
name = String(name);

if (/[^a-z0-9-#$%&’*+.^_`

function normalizeValue(value)
if (typeof value !== ‘string’)
value = String(value);

return value

// Build a destructive iterator for the value list
function iteratorFor(items)
var iterator =
next: function()
var value = items.shift();
return done: value === undefined, value: value

;

if (support.iterable)
iterator[Symbol.iterator] = function()
return iterator
;

return iterator

function Headers(headers)
this.map = ;

if (headers instanceof Headers)
headers.forEach(function(value, name)
this.append(name, value);
, this);
else if (Array.isArray(headers))
headers.forEach(function(header)
this.append(header[0], header[1]);
, this);
else if (headers)
Object.getOwnPropertyNames(headers).forEach(function(name)
this.append(name, headers[name]);
, this);

Headers.prototype.append = function(name, value)
name = normalizeName(name);
value = normalizeValue(value);
var oldValue = this.map[name];
this.map[name] = oldValue ? oldValue + ‘, ‘ + value : value;
;

Headers.prototype[‘delete’] = function(name)
delete this.map[normalizeName(name)];
;

Headers.prototype.get = function(name)
name = normalizeName(name);
return this.has(name) ? this.map[name] : null
;

Headers.prototype.has = function(name)
return this.map.hasOwnProperty(normalizeName(name))
;

Headers.prototype.set = function(name, value)
this.map[normalizeName(name)] = normalizeValue(value);
;

Headers.prototype.forEach = function(callback, thisArg)
for (var name in this.map)
if (this.map.hasOwnProperty(name))
callback.call(thisArg, this.map[name], name, this);

;

Headers.prototype.keys = function()
var items = [];
this.forEach(function(value, name)
items.push(name);
);
return iteratorFor(items)
;

Headers.prototype.values = function()
var items = [];
this.forEach(function(value)
items.push(value);
);
return iteratorFor(items)
;

Headers.prototype.entries = function()
var items = [];
this.forEach(function(value, name)
items.push([name, value]);
);
return iteratorFor(items)
;

if (support.iterable)
Headers.prototype[Symbol.iterator] = Headers.prototype.entries;

function consumed(body)
if (body.bodyUsed)
return Promise.reject(new TypeError(‘Already read’))

body.bodyUsed = true;

function fileReaderReady(reader)
return new Promise(function(resolve, reject)
reader.onload = function()
resolve(reader.result);
;
reader.onerror = function()
reject(reader.error);
;
)

function readBlobAsArrayBuffer(blob)
var reader = new FileReader();
var promise = fileReaderReady(reader);
reader.readAsArrayBuffer(blob);
return promise

function readBlobAsText(blob)
var reader = new FileReader();
var promise = fileReaderReady(reader);
reader.readAsText(blob);
return promise

function readArrayBufferAsText(buf)
var view = new Uint8Array(buf);
var chars = new Array(view.length);

for (var i = 0; i -1 ? upcased : method

function Request(input, options)

Request.prototype.clone = function()
return new Request(this, body: this._bodyInit)
;

function decode(body)
var form = new FormData();
body
.trim()
.split(‘&’)
.forEach(function(bytes)
if (bytes)
var split = bytes.split(‘=’);
var name = split.shift().replace(/+/g, ‘ ‘);
var value = split.join(‘=’).replace(/+/g, ‘ ‘);
form.append(decodeURIComponent(name), decodeURIComponent(value));

);
return form

function parseHeaders(rawHeaders)
var headers = new Headers();
// Replace instances of rn and n followed by at least one space or horizontal tab with a space
// https://tools.ietf.org/html/rfc7230#section-3.2
var preProcessedHeaders = rawHeaders.replace(/r?n[t ]+/g, ‘ ‘);
preProcessedHeaders.split(/r?n/).forEach(function(line)
var parts = line.split(‘:’);
var key = parts.shift().trim();
if (key)
var value = parts.join(‘:’).trim();
headers.append(key, value);

);
return headers

Body.call(Request.prototype);

function Response(bodyInit, options) {
if (!options)
options = ;

this.type = ‘default’;
this.status = options.status === undefined ? 200 : options.status;
this.ok = this.status >= 200 && this.status
// MIT Licensed

(function (root) {
‘use strict’;

var
// Save the previous value of the `jsonpClient` variable.
previousJsonpClient = root.jsonpClient,
is_browser = (typeof process !== ‘undefined’) ?
// We are on a common js environment, we might be using browserify
process.browser :
(typeof window !== ‘undefined’),
getJsonpBrowser,
getJsonp,
CALLBACK_REGEXP = /[\?|&]callback=([a-z0-9_]+)/i,

// Create a safe reference to the jsonpClient object for use below.
jsonpClient = function ()
var args = Array.prototype.slice.apply(arguments),
callback,
urls = args.slice(0, -1),
i = 0,
error,
results = [],
addUrl, returnResult;

// Don’t allows sync calls
try
callback = args.slice(-1)[0];
if (typeof callback !== ‘function’)
throw new Error(‘Callback not found’);

catch (e)
throw new Error(‘jsonpClient expects a callback’);

// URL’s provided as an array on the first parameter
if (typeof urls[0] !== ‘string’)
urls = urls[0];

// Returns the results in the right order
returnResult = function ()
var i = 0;
results = results.sort(function (a, b)
return a.position > b.position;
);
for (i = 0; results.length > i; i = i + 1)
results[i] = results[i].data;

results.unshift(null);
callback.apply(null, results);
;

// Adds a URL to the queue
addUrl = function (url, position)
getJsonp(urls[i], function (err, data)
if (error)
return;

error = err;
if (err)
return callback(err);

results.push(
data: data,
position: position
);
if (results.length === urls.length)
returnResult();

);
;

// Pushes files to fetch
for (i = 0; urls.length > i; i = i + 1)
addUrl(urls[i] + ”, i);

;

// Run jsonpClient in *noConflict* mode, returning the `jsonpClient`
// variable to its previous owner. Returns a reference to
// the jsonpClient object.
jsonpClient.noConflict = function ()
root.jsonpClient = previousJsonpClient;
return jsonpClient;
;

// Browser only logic for including jsonp on the page
getJsonpBrowser = function () {
var getCallbackFromUrl,
loadScript,
head = document.getElementsByTagName(‘head’)[0];

loadScript = function (url, callback)
var script = document.createElement(‘script’),
done = false;
script.src = url;
script.async = true;
script.onload = script.onreadystatechange = function () this.readyState === ‘loaded’ ;
head.appendChild(script);
;

getCallbackFromUrl = function (url, callback)
var matches = url.match(CALLBACK_REGEXP);
if (!matches)
return callback(new Error(‘Could not find callback on URL’));

callback(null, matches[1]);
;

return function (url, callback) {
getCallbackFromUrl(url, function (err, callbackName)
var data,
originalCallback = window[callbackName];
if (err)
return callback(err);

window[callbackName] = function (jsonp_data)
data = jsonp_data;
;
loadScript(url, function (err)
if (!err && !data)
err = new Error(‘Calling to ‘ + callbackName +
‘ did not returned a JSON response.’ +
‘Make sure the callback ‘ + callbackName +
‘ exists and is properly formatted.’);

if (originalCallback)
window[callbackName] = originalCallback;
else
// Repeated calls to the same jsonp callback should be avoided
// Unique callback names should be used.
// Also, the try, catch here is to support issues in IE8/IE7 where
// you can not use delete on window.
try
delete window[callbackName];

catch (ex)
window[callbackName] = undefined;

callback(err, data);
);
);
};
};

getJsonp = is_browser ? getJsonpBrowser() : require(‘./jsonp-node.js’);

// Export the jsonpClient object for **Node.js**, with
// backwards-compatibility for the old `require()` API. If we’re in
// the browser, add `jsonpClient` as a global object via a string identifier,
// for Closure Compiler ‘advanced’ mode.
if (typeof module !== ‘undefined’ && module.exports)
module.exports = jsonpClient;
else
// Set jsonpClient on the browser window
root.jsonpClient = jsonpClient;

// Establish the root object, `window` in the browser, or `global` on the
// server.
}(this));
}).call(this,require(‘_process’))}, “_process”:12,”./jsonp-node.js”:522];
window.modules[“522″] = [function(require,module,exports){(function (process,global){
‘use strict’;

var request = require(‘superagent’),
vm = require(‘vm’),
fs = require(‘fs’),
parensRegex = /(^(|);?s*$)/,
functionRegex = /^[a-zd_]*(/i,
functionNameRegex = /([wd_]*)(/,
evalJsonp,
parseJsonp,
evalOrParseJavascript,
fetchRemoteJsonp,
fetchUrl,
fetchLocalJsonp,
enableLocalFileSupport =
window.process.env.NODE_ENV === ‘test’ ||
window.process.env.JSONP_CLIENT_ENABLE_LOCAL_SUPPORT;

// Allow mocking superagent requests on test environments
if (window.process.env.NODE_ENV === ‘test’ && window.process.env.SUPERAGENT_MOCK)

// Lazy JSONp extraction by JSON.parsing the callback argument
parseJsonp = function (javascript, callback)
var err = null,
jsonString, json;
try
// chomp off anything that looks like a function name, remove parenthesis
jsonString = javascript.replace(functionRegex, ”).replace(parensRegex, ”);
json = JSON.parse(jsonString);
catch (error)
err = error;

callback(err, json);
;

// Creates a JavaScript VM in order to evaluate
// javascript from jsonp calls. This is expensive
// so make sure you cache the results
evalJsonp = function (javascript, cb) ;

// Given a javascript buffer this method will attempt
// to parse it as a string or it will attempt to run it
// on a vm
evalOrParseJavascript = function (javascript, callback)
javascript = javascript.toString();
parseJsonp(javascript, function (err, json)
if (err)
return evalJsonp(javascript, function (err, json)
callback(err, json);
);

callback(err, json);
);
;

// Fetches a URL and returns a buffer with the response
fetchUrl = function (url_to_fetch, callback)
request
.get(url_to_fetch)
.buffer(true)
.accept(‘application/javascript’)
.parse(function (res, fn)
res.text = ”;
res.setEncoding(‘utf8’);
res.on(‘data’, function (chunk)
res.text = res.text + chunk;
);
res.on(‘end’, fn);
)
.end(function (err, res) ‘cb()’);
);
;

// Fetches a jsonp response from a remote service
// Make sure you cache the responses as this process
// creates a JavaScript VM to safely evaluate the javascript
fetchRemoteJsonp = function (remote_url, callback)
fetchUrl(remote_url, function (err, body)
if (err)
return callback(err);

evalOrParseJavascript(body, callback);
);
;

// Retrieves a local file and evaluates the JSON script on a JS VM
// this is only available for when NODE_ENV is set to ‘test’
fetchLocalJsonp = enableLocalFileSupport ?
function (file_path, callback)
file_path = file_path.split(‘?’)[0];
fs.readFile(file_path, function (err, jsonp)
if (err) return callback(err);
evalOrParseJavascript(jsonp, callback);
);
:
fetchRemoteJsonp;

module.exports = function (jsonp_path_or_url, callback)
if (jsonp_path_or_url.match(/^http/))
fetchRemoteJsonp(jsonp_path_or_url, callback);
else
fetchLocalJsonp(jsonp_path_or_url, callback);

;

}).call(this,require(‘_process’),typeof global !== “undefined” ? global : typeof self !== “undefined” ? self : typeof window !== “undefined” ? window : )}, “_process”:12,”fs”:263,”superagent-mock”:262,”superagent”:262,”vm”:523];
window.modules[“523”] = [function(require,module,exports){var indexOf = function (xs, item)
if (xs.indexOf) return xs.indexOf(item);
else for (var i = 0; i true
*
* _.isArguments([1, 2, 3]);
* // => false
*/
var isArguments = baseIsArguments(function() return arguments; ()) ? baseIsArguments : function(value)
return isObjectLike(value) && hasOwnProperty.call(value, ‘callee’) &&
!propertyIsEnumerable.call(value, ‘callee’);
;

module.exports = isArguments;
, “./isObjectLike”:634,”./_baseIsArguments”:633];
window.modules[“572”] = [function(require,module,exports) stubFalse;

module.exports = isBuffer;
, “./_root”:525,”./stubFalse”:741];
window.modules[“573”] = [function(require,module,exports){/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]d*)$/;

/**
* Checks if `value` is a valid array-like index.
*
* @private
* @param * value The value to check.
* @param number [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
* @returns boolean Returns `true` if `value` is a valid index, else `false`.
*/
function isIndex(value, length)
(type != ‘symbol’ && reIsUint.test(value))) &&
(value > -1 && value % 1 == 0 && value true
*
* _.isTypedArray([]);
* // => false
*/
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

module.exports = isTypedArray;
, “./_baseUnary”:631,”./_nodeUtil”:729,”./_baseIsTypedArray”:647];
window.modules[“575”] = [function(require,module,exports){/**
* The base implementation of `_.times` without support for iteratee shorthands
* or max array length checks.
*
* @private
* @param number n The number of times to invoke `iteratee`.
* @param Function iteratee The function invoked per iteration.
* @returns Array Returns the array of results.
*/
function baseTimes(n, iteratee)
var index = -1,
result = Array(n);

while (++index true
*
* _.eq(object, other);
* // => false
*
* _.eq(‘a’, ‘a’);
* // => true
*
* _.eq(‘a’, Object(‘a’));
* // => false
*
* _.eq(NaN, NaN);
* // => true
*/
function eq(value, other)

module.exports = eq;
, ];
window.modules[“589”] = [function(require,module,exports)var arrayLikeKeys = require(‘./_arrayLikeKeys’),
baseKeys = require(‘./_baseKeys’),
isArrayLike = require(‘./isArrayLike’);

/**
* Creates an array of the own enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects. See the
* [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* for more details.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param Object object The object to query.
* @returns Array Returns the array of property names.
* @example
*
* function Foo()
* this.a = 1;
* this.b = 2;
*
*
* Foo.prototype.c = 3;
*
* _.keys(new Foo);
* // => [‘a’, ‘b’] (iteration order is not guaranteed)
*
* _.keys(‘hi’);
* // => [‘0’, ‘1’]
*/
function keys(object)
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);

module.exports = keys;
, “./isArrayLike”:660,”./_arrayLikeKeys”:570,”./_baseKeys”:654];
window.modules[“591”] = [function(require,module,exports)var arrayLikeKeys = require(‘./_arrayLikeKeys’),
baseKeysIn = require(‘./_baseKeysIn’),
isArrayLike = require(‘./isArrayLike’);

/**
* Creates an array of the own and inherited enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Object
* @param Object object The object to query.
* @returns Array Returns the array of property names.
* @example
*
* function Foo()
* this.a = 1;
* this.b = 2;
*
*
* Foo.prototype.c = 3;
*
* _.keysIn(new Foo);
* // => [‘a’, ‘b’, ‘c’] (iteration order is not guaranteed)
*/
function keysIn(object)
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);

module.exports = keysIn;
, “./_arrayLikeKeys”:570,”./isArrayLike”:660,”./_baseKeysIn”:657];
window.modules[“592″] = [function(require,module,exports)var getNative = require(‘./_getNative’);

var defineProperty = (function()
try
var func = getNative(Object, ‘defineProperty’);
func(, ”, );
return func;
catch (e)
());

module.exports = defineProperty;
, “./_getNative”:526];
window.modules[“595″] = [function(require,module,exports)/**
* Checks if `value` is the
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String(”)`)
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject();
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(_.noop);
* // => true
*
* _.isObject(null);
* // => false
*/
function isObject(value)
var type = typeof value;
return value != null && (type == ‘object’

module.exports = isObject;
, ];
window.modules[“607”] = [function(require,module,exports)var baseForOwn = require(‘./_baseForOwn’),
createBaseEach = require(‘./_createBaseEach’);

/**
* The base implementation of `_.forEach` without support for iteratee shorthands.
*
* @private
* @param Object collection The collection to iterate over.
* @param Function iteratee The function invoked per iteration.
* @returns Object Returns `collection`.
*/
var baseEach = createBaseEach(baseForOwn);

module.exports = baseEach;
, “./_baseForOwn”:608,”./_createBaseEach”:609];
window.modules[“608”] = [function(require,module,exports)var baseFor = require(‘./_baseFor’),
keys = require(‘./keys’);

/**
* The base implementation of `_.forOwn` without support for iteratee shorthands.
*
* @private
* @param Object object The object to iterate over.
* @param Function iteratee The function invoked per iteration.
* @returns Object Returns `object`.
*/
function baseForOwn(object, iteratee)
return object && baseFor(object, iteratee, keys);

module.exports = baseForOwn;
, “./keys”:589,”./_baseFor”:617];
window.modules[“609”] = [function(require,module,exports){var isArrayLike = require(‘./isArrayLike’);

/**
* Creates a `baseEach` or `baseEachRight` function.
*
* @private
* @param Function eachFunc The function to iterate over a collection.
* @param boolean [fromRight] Specify iterating from right to left.
* @returns Function Returns the new base function.
*/
function createBaseEach(eachFunc, fromRight) {
return function(collection, iteratee)
if (collection == null)
return collection;

if (!isArrayLike(collection))
return eachFunc(collection, iteratee);

var length = collection.length,
index = fromRight ? length : -1,
iterable = Object(collection);

while ((fromRight ? index– : ++index true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value)
return value != null && typeof value == ‘object’;

module.exports = isObjectLike;
, ];
window.modules[“642”] = [function(require,module,exports)var isFunction = require(‘./isFunction’),
isMasked = require(‘./_isMasked’),
isObject = require(‘./isObject’),
toSource = require(‘./_toSource’);

/**
* Used to match `RegExp`
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
*/
var reRegExpChar = /[\^$.*+?()[], “./isFunction”:643,”./isObject”:595,”./_toSource”:644,”./_isMasked”:645];
window.modules[“643”] = [function(require,module,exports)var baseGetTag = require(‘./_baseGetTag’),
isObject = require(‘./isObject’);

/** `Object#toString` result references. */
var asyncTag = ‘[object AsyncFunction]’,
funcTag = ‘[object Function]’,
genTag = ‘[object GeneratorFunction]’,
proxyTag = ‘[object Proxy]’;

/**
* Checks if `value` is classified as a `Function` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is a function, else `false`.
* @example
*
* _.isFunction(_);
* // => true
*
* _.isFunction(/abc/);
* // => false
*/
function isFunction(value)

module.exports = isFunction;
, “./_baseGetTag”:624,”./isObject”:595];
window.modules[“644″] = [function(require,module,exports)/** Used for built-in method references. */
var funcProto = Function.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/**
* Converts `func` to its source code.
*
* @private
* @param Function func The function to convert.
* @returns string Returns the source code.
*/
function toSource(func)
if (func != null)
try
return funcToString.call(func);
catch (e)
try
return (func + ”);
catch (e)

return ”;

module.exports = toSource;
, ];
window.modules[“645”] = [function(require,module,exports)var coreJsData = require(‘./_coreJsData’);

/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() ());

/**
* Checks if `func` has its source masked.
*
* @private
* @param Function func The function to check.
* @returns boolean Returns `true` if `func` is masked, else `false`.
*/
function isMasked(func)
return !!maskSrcKey && (maskSrcKey in func);

module.exports = isMasked;
, “./_coreJsData”:695];
window.modules[“647”] = [function(require,module,exports)var baseGetTag = require(‘./_baseGetTag’),
isLength = require(‘./isLength’),
isObjectLike = require(‘./isObjectLike’);

/** `Object#toString` result references. */
var argsTag = ‘[object Arguments]’,
arrayTag = ‘[object Array]’,
boolTag = ‘[object Boolean]’,
dateTag = ‘[object Date]’,
errorTag = ‘[object Error]’,
funcTag = ‘[object Function]’,
mapTag = ‘[object Map]’,
numberTag = ‘[object Number]’,
objectTag = ‘[object Object]’,
regexpTag = ‘[object RegExp]’,
setTag = ‘[object Set]’,
stringTag = ‘[object String]’,
weakMapTag = ‘[object WeakMap]’;

var arrayBufferTag = ‘[object ArrayBuffer]’,
dataViewTag = ‘[object DataView]’,
float32Tag = ‘[object Float32Array]’,
float64Tag = ‘[object Float64Array]’,
int8Tag = ‘[object Int8Array]’,
int16Tag = ‘[object Int16Array]’,
int32Tag = ‘[object Int32Array]’,
uint8Tag = ‘[object Uint8Array]’,
uint8ClampedTag = ‘[object Uint8ClampedArray]’,
uint16Tag = ‘[object Uint16Array]’,
uint32Tag = ‘[object Uint32Array]’;

/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = ;
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;

/**
* The base implementation of `_.isTypedArray` without Node.js optimizations.
*
* @private
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is a typed array, else `false`.
*/
function baseIsTypedArray(value)
return isObjectLike(value) &&
isLength(value.length) && !!typedArrayTags[baseGetTag(value)];

module.exports = baseIsTypedArray;
, “./_baseGetTag”:624,”./isLength”:648,”./isObjectLike”:634];
window.modules[“648”] = [function(require,module,exports){/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/**
* Checks if `value` is a valid array-like length.
*
* **Note:** This method is loosely based on
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is a valid length, else `false`.
* @example
*
* _.isLength(3);
* // => true
*
* _.isLength(Number.MIN_VALUE);
* // => false
*
* _.isLength(Infinity);
* // => false
*
* _.isLength(‘3’);
* // => false
*/
function isLength(value)
return typeof value == ‘number’ &&
value > -1 && value % 1 == 0 && value true
*/
function identity(value)
return value;

module.exports = identity;
, ];
window.modules[“654”] = [function(require,module,exports)var isPrototype = require(‘./_isPrototype’),
nativeKeys = require(‘./_nativeKeys’);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
* The base implementation of `_.keys` which doesn’t treat sparse arrays as dense.
*
* @private
* @param Object object The object to query.
* @returns Array Returns the array of property names.
*/
function baseKeys(object)
if (!isPrototype(object))
return nativeKeys(object);

var result = [];
for (var key in Object(object))
if (hasOwnProperty.call(object, key) && key != ‘constructor’)
result.push(key);

return result;

module.exports = baseKeys;
, “./_isPrototype”:655,”./_nativeKeys”:656];
window.modules[“655”] = [function(require,module,exports)/** Used for built-in method references. */
var objectProto = Object.prototype;

/**
* Checks if `value` is likely a prototype object.
*
* @private
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is a prototype, else `false`.
*/
function isPrototype(value) objectProto;

return value === proto;

module.exports = isPrototype;
, ];
window.modules[“656”] = [function(require,module,exports)var overArg = require(‘./_overArg’);

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeKeys = overArg(Object.keys, Object);

module.exports = nativeKeys;
, “./_overArg”:721];
window.modules[“657”] = [function(require,module,exports)var isObject = require(‘./isObject’),
isPrototype = require(‘./_isPrototype’),
nativeKeysIn = require(‘./_nativeKeysIn’);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
* The base implementation of `_.keysIn` which doesn’t treat sparse arrays as dense.
*
* @private
* @param Object object The object to query.
* @returns Array Returns the array of property names.
*/
function baseKeysIn(object)
if (!isObject(object))
return nativeKeysIn(object);

var isProto = isPrototype(object),
result = [];

for (var key in object) !hasOwnProperty.call(object, key))))
result.push(key);

return result;

module.exports = baseKeysIn;
, “./isObject”:595,”./_isPrototype”:655,”./_nativeKeysIn”:658];
window.modules[“658”] = [function(require,module,exports)/**
* This function is like
* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* except that it includes inherited enumerable properties.
*
* @private
* @param Object object The object to query.
* @returns Array Returns the array of property names.
*/
function nativeKeysIn(object)
var result = [];
if (object != null)
for (var key in Object(object))
result.push(key);

return result;

module.exports = nativeKeysIn;
, ];
window.modules[“660”] = [function(require,module,exports)var isFunction = require(‘./isFunction’),
isLength = require(‘./isLength’);

/**
* Checks if `value` is array-like. A value is considered array-like if it’s
* not a function and has a `value.length` that’s an integer greater than or
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is array-like, else `false`.
* @example
*
* _.isArrayLike([1, 2, 3]);
* // => true
*
* _.isArrayLike(document.body.children);
* // => true
*
* _.isArrayLike(‘abc’);
* // => true
*
* _.isArrayLike(_.noop);
* // => false
*/
function isArrayLike(value)
return value != null && isLength(value.length) && !isFunction(value);

module.exports = isArrayLike;
, “./isLength”:648,”./isFunction”:643];
window.modules[“672″] = [function(require,module,exports)var identity = require(‘./identity’),
overRest = require(‘./_overRest’),
setToString = require(‘./_setToString’);

/**
* The base implementation of `_.rest` which doesn’t validate or coerce arguments.
*
* @private
* @param Function func The function to apply a rest parameter to.
* @param number [start=func.length-1] The start position of the rest parameter.
* @returns Function Returns the new function.
*/
function baseRest(func, start)
return setToString(overRest(func, start, identity), func + ”);

module.exports = baseRest;
, “./identity”:650,”./_overRest”:673,”./_setToString”:674];
window.modules[“673”] = [function(require,module,exports){var apply = require(‘./_apply’);

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max;

/**
* A specialized version of `baseRest` which transforms the rest array.
*
* @private
* @param Function func The function to apply a rest parameter to.
* @param number [start=func.length-1] The start position of the rest parameter.
* @param Function transform The rest array transform.
* @returns Function Returns the new function.
*/
function overRest(func, start, transform) {
start = nativeMax(start === undefined ? (func.length – 1) : start, 0);
return function()
var args = arguments,
index = -1,
length = nativeMax(args.length – start, 0),
array = Array(length);

while (++index [ ‘a’: 1 , ‘a’: 1 ]
*
* console.log(objects[0] === objects[1]);
* // => true
*/
function constant(value)
return function()
return value;
;

module.exports = constant;
, ];
window.modules[“680”] = [function(require,module,exports)var baseGetTag = require(‘./_baseGetTag’),
isObjectLike = require(‘./isObjectLike’);

/** `Object#toString` result references. */
var symbolTag = ‘[object Symbol]’;

/**
* Checks if `value` is classified as a `Symbol` primitive or object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param * value The value to check.
* @returns boolean Returns `true` if `value` is a symbol, else `false`.
* @example
*
* _.isSymbol(Symbol.iterator);
* // => true
*
* _.isSymbol(‘abc’);
* // => false
*/
function isSymbol(value)
return typeof value == ‘symbol’

module.exports = isSymbol;
, “./_baseGetTag”:624,”./isObjectLike”:634];
window.modules[“681”] = [function(require,module,exports)var arrayMap = require(‘./_arrayMap’);

/**
* The base implementation of `_.values` and `_.valuesIn` which creates an
* array of `object` property values corresponding to the property names
* of `props`.
*
* @private
* @param Object object The object to query.
* @param Array props The property names to get values for.
* @returns Object Returns the array of property values.
*/
function baseValues(object, props)
return arrayMap(props, function(key)
return object[key];
);

module.exports = baseValues;
, “./_arrayMap”:576];
window.modules[“684”] = [function(require,module,exports)var identity = require(‘./identity’);

/**
* Casts `value` to `identity` if it’s not a function.
*
* @private
* @param * value The value to inspect.
* @returns Function Returns cast function.
*/
function castFunction(value)
return typeof value == ‘function’ ? value : identity;

module.exports = castFunction;
, “./identity”:650];
window.modules[“695”] = [function(require,module,exports)var root = require(‘./_root’);

/** Used to detect overreaching core-js shims. */
var coreJsData = root[‘__core-js_shared__’];

module.exports = coreJsData;
, “./_root”:525];
window.modules[“697”] = [function(require,module,exports)var eq = require(‘./eq’),
isArrayLike = require(‘./isArrayLike’),
isIndex = require(‘./_isIndex’),
isObject = require(‘./isObject’);

/**
* Checks if the given arguments are from an iteratee call.
*
* @private
* @param * value The potential iteratee value argument.
* @param * index The potential iteratee index or key argument.
* @param * object The potential iteratee object argument.
* @returns boolean Returns `true` if the arguments are from an iteratee call,
* else `false`.
*/
function isIterateeCall(value, index, object)
if (!isObject(object))
return false;

var type = typeof index;
if (type == ‘number’
? (isArrayLike(object) && isIndex(index, object.length))
: (type == ‘string’ && index in object)
)
return eq(object[index], value);

return false;

module.exports = isIterateeCall;
, “./eq”:584,”./isArrayLike”:660,”./_isIndex”:573,”./isObject”:595];
window.modules[“714”] = [function(require,module,exports)(function (global)
/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == ‘object’ && global && global.Object === Object && global;

module.exports = freeGlobal;

).call(this,typeof global !== “undefined” ? global : typeof self !== “undefined” ? self : typeof window !== “undefined” ? window : ), ];
window.modules[“719”] = [function(require,module,exports)/**
* Gets the value at `key` of `object`.
*
* @private
* @param Object [object] The object to query.
* @param string key The key of the property to get.
* @returns * Returns the property value.
*/
function getValue(object, key)
return object == null ? undefined : object[key];

module.exports = getValue;
, ];
window.modules[“721”] = [function(require,module,exports)/**
* Creates a unary function that invokes `func` with its argument transformed.
*
* @private
* @param Function func The function to wrap.
* @param Function transform The argument transform.
* @returns Function Returns the new function.
*/
function overArg(func, transform)
return function(arg)
return func(transform(arg));
;

module.exports = overArg;
, ];
window.modules[“729”] = [function(require,module,exports){var freeGlobal = require(‘./_freeGlobal’);

/** Detect free variable `exports`. */
var freeExports = typeof exports == ‘object’ && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == ‘object’ && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;

/** Detect free variable `process` from Node.js. */
var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */
var nodeUtil = (function()
try
// Use `util.types` for Node.js 10+.
var types = freeModule && freeModule.require && freeModule.require(‘util’).types;

if (types)
return types;

// Legacy `process.binding(‘util’)` for Node.js 0)
if (++count >= HOT_COUNT)
return arguments[0];

else
count = 0;

return func.apply(undefined, arguments);
;

module.exports = shortOut;
}, ];
window.modules[“735”] = [function(require,module,exports){var baseRest = require(‘./_baseRest’),
eq = require(‘./eq’),
isIterateeCall = require(‘./_isIterateeCall’),
keysIn = require(‘./keysIn’);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
* Assigns own and inherited enumerable string keyed properties of source
* objects to the destination object for all destination properties that
* resolve to `undefined`. Source objects are applied from left to right.
* Once a property is set, additional values of the same property are ignored.
*
* **Note:** This method mutates `object`.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param Object object The destination object.
* @param …Object [sources] The source objects.
* @returns Object Returns `object`.
* @see _.defaultsDeep
* @example
*
* _.defaults( ‘a’: 1 , ‘b’: 2 , ‘a’: 3 );
* // => ‘a’: 1, ‘b’: 2
*/
var defaults = baseRest(function(object, sources)
object = Object(object);

var index = -1;
var length = sources.length;
var guard = length > 2 ? sources[2] : undefined;

if (guard && isIterateeCall(sources[0], sources[1], guard))
length = 1;

while (++index Logs `1` then `2`.
*
* _.forEach( ‘a’: 1, ‘b’: 2 , function(value, key)
* console.log(key);
* );
* // => Logs ‘a’ then ‘b’ (iteration order is not guaranteed).
*/
function forEach(collection, iteratee)
var func = isArray(collection) ? arrayEach : baseEach;
return func(collection, castFunction(iteratee));

module.exports = forEach;
, “./_arrayEach”:565,”./_baseEach”:607,”./isArray”:34,”./_castFunction”:684];
window.modules[“737”] = [function(require,module,exports)var toFinite = require(‘./toFinite’);

/**
* Converts `value` to an integer.
*
* **Note:** This method is loosely based on
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param * value The value to convert.
* @returns number Returns the converted integer.
* @example
*
* _.toInteger(3.2);
* // => 3
*
* _.toInteger(Number.MIN_VALUE);
* // => 0
*
* _.toInteger(Infinity);
* // => 1.7976931348623157e+308
*
* _.toInteger(‘3.2’);
* // => 3
*/
function toInteger(value)
var result = toFinite(value),
remainder = result % 1;

return result === result ? (remainder ? result – remainder : result) : 0;

module.exports = toInteger;
, “./toFinite”:747];
window.modules[“739”] = [function(require,module,exports)var baseValues = require(‘./_baseValues’),
keys = require(‘./keys’);

/**
* Creates an array of the own enumerable string keyed property values of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param Object object The object to query.
* @returns Array Returns the array of property values.
* @example
*
* function Foo()
* this.a = 1;
* this.b = 2;
*
*
* Foo.prototype.c = 3;
*
* _.values(new Foo);
* // => [1, 2] (iteration order is not guaranteed)
*
* _.values(‘hi’);
* // => [‘h’, ‘i’]
*/
function values(object)
return object == null ? [] : baseValues(object, keys(object));

module.exports = values;
, “./keys”:589,”./_baseValues”:681];
window.modules[“741”] = [function(require,module,exports)/**
* This method returns `false`.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns boolean Returns `false`.
* @example
*
* _.times(2, _.stubFalse);
* // => [false, false]
*/
function stubFalse()
return false;

module.exports = stubFalse;
, ];
window.modules[“747”] = [function(require,module,exports){var toNumber = require(‘./toNumber’);

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0,
MAX_INTEGER = 1.7976931348623157e+308;

/**
* Converts `value` to a finite number.
*
* @static
* @memberOf _
* @since 4.12.0
* @category Lang
* @param * value The value to convert.
* @returns number Returns the converted number.
* @example
*
* _.toFinite(3.2);
* // => 3.2
*
* _.toFinite(Number.MIN_VALUE);
* // => 5e-324
*
* _.toFinite(Infinity);
* // => 1.7976931348623157e+308
*
* _.toFinite(‘3.2’);
* // => 3.2
*/
function toFinite(value) {
if (!value)
return value === 0 ? value : 0;

value = toNumber(value);
if (value === INFINITY || value === -INFINITY)
var sign = (value 3.2
*
* _.toNumber(Number.MIN_VALUE);
* // => 5e-324
*
* _.toNumber(Infinity);
* // => Infinity
*
* _.toNumber(‘3.2’);
* // => 3.2
*/
function toNumber(value) reIsOctal.test(value))
? freeParseInt(value.slice(2), isBinary ? 2 : 8)
: (reIsBadHex.test(value) ? NAN : +value);

module.exports = toNumber;
, “./isObject”:595,”./isSymbol”:680];
window.modules[“865″] = [function(require,module,exports){‘use strict’;

var has = Object.prototype.hasOwnProperty
, undef;

/**
* Decode a URI encoded string.
*
* @param String input The URI encoded string.
* @returns String The decoded string.
* @api private
*/
function decode(input)
return decodeURIComponent(input.replace(/+/g, ‘ ‘));

/**
* Simple query string parser.
*
* @param String query The query string that needs to be parsed.
* @returns Object
* @api public
*/
function querystring(query)
var parser = /([^=?&]+)=?([^&]*)/g
, result =
, part;

while (part = parser.exec(query))
var key = decode(part[1])
, value = decode(part[2]);

//
// Prevent overriding of existing properties. This ensures that build-in
// methods like `toString` or __proto__ are not overriden by malicious
// querystrings.
//
if (key in result) continue;
result[key] = value;

return result;

/**
* Transform a query string to an object.
*
* @param Object obj Object that should be transformed.
* @param String prefix Optional prefix.
* @returns String
* @api public
*/
function querystringify(obj, prefix) ”;

var pairs = []
, value
, key;

//
// Optionally prefix with a ‘?’ if needed
//
if (‘string’ !== typeof prefix) prefix = ‘?’;

for (key in obj)
if (has.call(obj, key))

return pairs.length ? prefix + pairs.join(‘&’) : ”;

//
// Expose the module.
//
exports.stringify = querystringify;
exports.parse = querystring;
}, ];
window.modules[“881”] = [function(require,module,exports){/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/

!(function(global) {
“use strict”;

var Op = Object.prototype;
var hasOwn = Op.hasOwnProperty;
var undefined; // More compressible than void 0.
var $Symbol = typeof Symbol === “function” ? Symbol : ;
var iteratorSymbol = $Symbol.iterator || “@@iterator”;
var asyncIteratorSymbol = $Symbol.asyncIterator || “@@asyncIterator”;
var toStringTagSymbol = $Symbol.toStringTag || “@@toStringTag”;

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 and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
var generator = Object.create(protoGenerator.prototype);
var context = new Context(tryLocsList
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()

// This is a polyfill for %IteratorPrototype% for environments that
// don’t natively support it.
var IteratorPrototype = ;
IteratorPrototype[iteratorSymbol] = function ()
return this;
;

var getProto = Object.getPrototypeOf;
var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
if (NativeIteratorPrototype &&
NativeIteratorPrototype !== Op &&
hasOwn.call(NativeIteratorPrototype, iteratorSymbol))
// This environment has a native %IteratorPrototype%; use it instead
// of the polyfill.
IteratorPrototype = NativeIteratorPrototype;

var Gp = GeneratorFunctionPrototype.prototype =
Generator.prototype = Object.create(IteratorPrototype);
GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
GeneratorFunctionPrototype.constructor = GeneratorFunction;
GeneratorFunctionPrototype[toStringTagSymbol] =
GeneratorFunction.displayName = “GeneratorFunction”;

// Helper for defining the .next, .throw, and .return methods of the
// Iterator interface in terms of a single ._invoke method.
function defineIteratorMethods(prototype)
[“next”, “throw”, “return”].forEach(function(method)
prototype[method] = function(arg)
return this._invoke(method, arg);
;
);

runtime.isGeneratorFunction = function(genFun) ;

runtime.mark = function(genFun)
if (Object.setPrototypeOf)
Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
else
genFun.__proto__ = GeneratorFunctionPrototype;
if (!(toStringTagSymbol in genFun))
genFun[toStringTagSymbol] = “GeneratorFunction”;

genFun.prototype = Object.create(Gp);
return genFun;
;

// Within the body of any async function, `await x` is transformed to
// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
// `hasOwn.call(value, “__await”)` to determine if the yielded value is
// meant to be awaited.
runtime.awrap = function(arg)
return __await: arg ;
;

function AsyncIterator(generator) {
function invoke(method, arg, resolve, reject)
var record = tryCatch(generator[method], generator, arg);
if (record.type === “throw”)
reject(record.arg);
else
var result = record.arg;
var value = result.value;
if (value &&
typeof value === “object” &&
hasOwn.call(value, “__await”))
return Promise.resolve(value.__await).then(function(value)
invoke(“next”, value, resolve, reject);
, function(err)
invoke(“throw”, err, resolve, reject);
);

return Promise.resolve(value).then(function(unwrapped)
// When a yielded Promise is resolved, its final value becomes
// the .value of the Promise result for the
// current iteration. If the Promise is rejected, however, the
// result for this iteration will be rejected with the same
// reason. Note that rejections of yielded Promises are not
// thrown back into the generator function, as is the case
// when an awaited Promise is rejected. This difference in
// behavior between yield and await is important, because it
// allows the consumer to decide what to do with the yielded
// rejection (swallow it and continue, manually .throw it back
// into the generator, abandon iteration, whatever). With
// await, by contrast, there is no opportunity to examine the
// rejection reason outside the generator function, so the
// only option is to throw it from the await expression, and
// let the generator function handle the exception.
result.value = unwrapped;
resolve(result);
, reject);

var previousPromise;

function enqueue(method, arg)
function callInvokeWithMethodAndArg()
return new Promise(function(resolve, reject)
invoke(method, arg, resolve, reject);
);

return previousPromise =
// If enqueue has been called before, then we want to wait until
// all previous Promises have been resolved before calling invoke,
// so that results are always delivered in the correct order. If
// enqueue has not been called before, then it is important to
// call invoke immediately, without waiting on a callback to fire,
// so that the async generator function has the opportunity to do
// any necessary setup in a predictable way. This predictability
// is why the Promise constructor synchronously invokes its
// executor callback, and why async functions synchronously
// execute code before the first await. Since we implement simple
// async functions in terms of async generators, it is especially
// important to get this right, even though it requires care.
previousPromise ? previousPromise.then(
callInvokeWithMethodAndArg,
// Avoid propagating failures to Promises returned by later
// invocations of the iterator.
callInvokeWithMethodAndArg
) : callInvokeWithMethodAndArg();

// Define the unified helper method that is used to implement .next,
// .throw, and .return (see defineIteratorMethods).
this._invoke = enqueue;
}

defineIteratorMethods(AsyncIterator.prototype);
AsyncIterator.prototype[asyncIteratorSymbol] = function ()
return this;
;
runtime.AsyncIterator = AsyncIterator;

// Note that simple async functions are implemented on top of
// AsyncIterator objects; they just return a Promise for the value of
// the final result produced by the iterator.
runtime.async = function(innerFn, outerFn, self, tryLocsList)
var iter = new AsyncIterator(
wrap(innerFn, outerFn, self, tryLocsList)
);

return runtime.isGeneratorFunction(outerFn)
? iter // If outerFn is a generator, return the full iterator.
: iter.next().then(function(result)
return result.done ? result.value : iter.next();
);
;

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)
if (method === “throw”)
throw arg;

// Be forgiving, per 25.3.3.3.3 of the spec:
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult();

context.method = method;
context.arg = arg;

while (true)
var delegate = context.delegate;
if (delegate)
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult)
if (delegateResult === ContinueSentinel) continue;
return delegateResult;

if (context.method === “next”)
// Setting context._sent for legacy support of Babel’s
// function.sent implementation.
context.sent = context._sent = context.arg;

else if (context.method === “throw”)
if (state === GenStateSuspendedStart)
state = GenStateCompleted;
throw context.arg;

context.dispatchException(context.arg);

else if (context.method === “return”)
context.abrupt(“return”, context.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;

if (record.arg === ContinueSentinel)
continue;

return
value: record.arg,
done: context.done
;

else if (record.type === “throw”)
state = GenStateCompleted;
// Dispatch the exception by looping back around to the
// context.dispatchException(context.arg) call above.
context.method = “throw”;
context.arg = record.arg;

;
}

// Call delegate.iterator[context.method](context.arg) and handle the
// result, either by returning a value, done result from the
// delegate iterator, or by modifying context.method and context.arg,
// setting context.delegate to null, and returning the ContinueSentinel.
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (method === undefined)
// A .throw or .return when the delegate iterator has no .throw
// method always terminates the yield* loop.
context.delegate = null;

if (context.method === “throw”)
if (delegate.iterator.return)
// If the delegate iterator has a return method, give it a
// chance to clean up.
context.method = “return”;
context.arg = undefined;
maybeInvokeDelegate(delegate, context);

if (context.method === “throw”)
// If maybeInvokeDelegate(context) changed context.method from
// “return” to “throw”, let that override the TypeError below.
return ContinueSentinel;

context.method = “throw”;
context.arg = new TypeError(
“The iterator does not provide a ‘throw’ method”);

return ContinueSentinel;

var record = tryCatch(method, delegate.iterator, context.arg);

if (record.type === “throw”)
context.method = “throw”;
context.arg = record.arg;
context.delegate = null;
return ContinueSentinel;

var info = record.arg;

if (! info)
context.method = “throw”;
context.arg = new TypeError(“iterator result is not an object”);
context.delegate = null;
return ContinueSentinel;

if (info.done)
// Assign the result of the finished delegate to the temporary
// variable specified by delegate.resultName (see delegateYield).
context[delegate.resultName] = info.value;

// Resume execution at the desired location (see delegateYield).
context.next = delegate.nextLoc;

// If context.method was “throw” but the delegate handled the
// exception, let the outer generator proceed normally. If
// context.method was “next”, forget context.arg since it has been
// “consumed” by the delegate iterator. If context.method was
// “return”, allow the original .return call to continue in the
// outer generator.
if (context.method !== “return”)
context.method = “next”;
context.arg = undefined;

else
// Re-yield the result returned by the delegate method.
return info;

// The delegate iterator is finished, so forget it and continue with
// the outer generator.
context.delegate = null;
return ContinueSentinel;
}

// Define Generator.prototype.next,throw,return in terms of the
// unified ._invoke helper method.
defineIteratorMethods(Gp);

Gp[toStringTagSymbol] = “Generator”;

// A Generator should always return itself as the iterator object when the
// @@iterator function is called on it. Some browsers’ implementations of the
// iterator prototype chain incorrectly implement this, causing the Generator
// object to not be returned from this call. This ensures that doesn’t happen.
// See https://github.com/facebook/regenerator/issues/274 for more details.
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

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(true);

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 = 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 = 0; –i)
var entry = this.tryEntries[i];
if (entry.tryLoc = 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
;

if (this.method === “next”)
// Deliberately forget the last sent value so that we don’t
// accidentally pass it on to the delegate.
this.arg = undefined;

return ContinueSentinel;

};
})(
// In sloppy mode, unbound `this` refers to the global object, fallback to
// Function constructor if we’re in global strict mode. That is sadly a form
// of indirect eval which violates Content Security Policy.
(function() return this )() || Function(“return this”)()
);
}, ];
window.modules[“882”] = [function(require,module,exports)’use strict’;

/**
* Check if we’re required to add a port number.
*
* @see https://url.spec.whatwg.org/#default-port
* @param Number port Port number we need to check
* @param String protocol Protocol we need to check against.
* @returns Boolean Is it a default port for the given protocol
* @api private
*/
module.exports = function required(port, protocol)
protocol = protocol.split(‘:’)[0];
port = +port;

if (!port) return false;

switch (protocol)
case ‘http’:
case ‘ws’:
return port !== 80;

case ‘https’:
case ‘wss’:
return port !== 443;

case ‘ftp’:
return port !== 21;

case ‘gopher’:
return port !== 70;

case ‘file’:
return false;

return port !== 0;
;
, ];
window.modules[“article.client”] = [function(require,module,exports)’use strict’;

function Constructor()
var sidebar = document.getElementsByClassName(‘content__sidebar’)[0],
articleBody = document.getElementsByClassName(‘article__body’)[0];

this.repositionRightRail(sidebar, articleBody);

Constructor.prototype =
/**
* Repositions the right rail under the article headline &
* subheadline so that it is in line with the article body.
* @function
* @param object sidebar
* @param object articleBody
*/
repositionRightRail: function repositionRightRail(sidebar, articleBody)
sidebar.style.marginTop = articleBody.offsetTop + ‘px’;
sidebar.style.position = ‘relative’;
sidebar.style.visibility = ‘visible’;

;

module.exports = function ()
return new Constructor();
;
, ];
window.modules[“brightcove.client”] = [function(require,module,exports){‘use strict’;

// Polyfill

require(‘intersection-observer’);
var videoObserver = new IntersectionObserver(videoIsInView, ),
_require = require(‘../../services/client/mobile’),
isMobileWidth = _require.isMobileWidth;

var activePlayers = [];

// Listener for dismount to delete videos
document.addEventListener(‘brightcove-dismount’, function ()
activePlayers = [];
);

/**
* Check if the video has gone out of view
*
* @param array changes
*/
function videoIsInView(changes)
changes.forEach(function (change)
if (change.intersectionRatio === 0)
pausePlayer(videojs.getPlayer(change.target.getAttribute(‘id’)));

);
;

/**
* Pause the player
*
* @param object player
*/
function pausePlayer(player)
if (typeof player.ima3.adsManager !== ‘undefined’)
player.ima3.adsManager.pause();

player.pause();

/**
* Loop over all players on page and pause them if it’s not the video in question
*/
function pauseOtherActivePlayers()
var player = this;

// Loop over all players on the current page
activePlayers.forEach(function (playerOnPage)
if (player.id() !== playerOnPage.id())
pausePlayer(playerOnPage);

);

function Constructor(brightcoveComponent)
var videoPlayer = brightcoveComponent.querySelector(‘video-js’),
id = videoPlayer.getAttribute(‘id’),
brightcoveAccount = videoPlayer.getAttribute(‘data-account’),
brightcovePlayerId = videoPlayer.getAttribute(‘data-player’);
// Add and execute the player script tag
var s = document.createElement(‘script’);

s.src = ‘//players.brightcove.net/’ + brightcoveAccount + ‘/’ + brightcovePlayerId + ‘_default/index.min.js’;
// Add the script tag to the document
document.body.appendChild(s);
// Call a function to play the video once player’s JavaScript loaded
s.onload = function ()
var player = bc(id);

// Keep track of all videos on page
activePlayers.push(player);

// Observe video for if it goes out of view
videoObserver.observe(player.el(), threshold: 0 );

// When a video begins playing trigger a stop on all others on page (must track video and ad events)
player.on(‘play’, pauseOtherActivePlayers);
player.on(‘ads-play’, pauseOtherActivePlayers);

if (brightcoveComponent.closest(‘.body__header .lead’) && !isMobileWidth())
// autoplay muted
player.on(‘loadedmetadata’, function ()
player.muted(true);
player.play();
);

;

module.exports = function (el)
return new Constructor(el);
;
}, “../../services/client/mobile”:4,”intersection-observer”:5];
window.modules[“facebook-post.client”] = [function(require,module,exports){‘use strict’;

var $visibility = require(‘../../services/client/visibility’),
LAZY_LOAD_MINIMUM = 3,

// Facebook cmpt’s vertical space must be a certain distance from the viewport for the embed to load
SHOWN_THRESHOLD = 0.01,
totalEmbeds = document.querySelectorAll(‘.facebook-post’).length,
lazyLoadEmbeds = totalEmbeds >= LAZY_LOAD_MINIMUM,
fbSdkUrl = ‘//connect.facebook.net/en_US/all.js#xfbml=1&version=v2.3’;
// The number of Facebook cmpts that must be on the page to activate lazy loading.
// Without lazy loading, a high number of Facebook embeds may slow page load time tremendously.

function Constructor(el)
var _this = this;

// Process FB post if SDK is available otherwise Mount FB SDK then process.
if (window.FB)
this.processFbPost(el);
else if (!document.querySelector(‘script[src=”‘ + fbSdkUrl + ‘”]’))
this.mountFacebookSdk(function (error)
if (error)
throw error;
else
_this.processFbPost(el);

);

Constructor.prototype = {
/**
* Includes the Facebook SDK on the page.
* @param function callback – FB SDK