[theano] 16/23: handled some Javascript libraries
Daniel Stender
stender at moszumanska.debian.org
Tue Jul 12 10:54:34 UTC 2016
This is an automated email from the git hooks/post-receive script.
stender pushed a commit to branch master
in repository theano.
commit e2b44582f8c1669d5f4ea86b4185dde3a6f5d3c5
Author: Daniel Stender <stender at debian.org>
Date: Tue Jul 12 00:01:53 2016 +0200
handled some Javascript libraries
---
debian/changelog | 7 +-
debian/copyright | 19 +
debian/missing-source/README.txt | 24 +
debian/missing-source/d3.js | 9503 +++++++
debian/missing-source/dagre-d3.js | 25569 ++++++++++++++++++
debian/missing-source/graphlib-dot.js | 44345 ++++++++++++++++++++++++++++++++
debian/source.lintian-overrides | 23 +
7 files changed, 79488 insertions(+), 2 deletions(-)
diff --git a/debian/changelog b/debian/changelog
index 4231ea3..21e5619 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -15,9 +15,12 @@ theano (0.8.2-1) UNRELEASED; urgency=medium
+ rearranged logically.
* deb/source/options:
+ added ignore for egg-info.
- * add deb/README.Debian (with info on disabling compilation).
+ * add:
+ + deb/README.Debian (with info on disabling compilation).
+ + deb/missing-source (d3.js, dagre-d3.js, graphlib-dot.js).
+ + deb/source.lintian-overrides.
- -- Daniel Stender <stender at debian.org> Mon, 11 Jul 2016 19:00:20 +0200
+ -- Daniel Stender <stender at debian.org> Tue, 12 Jul 2016 00:00:17 +0200
theano (0.7-5) unstable; urgency=medium
diff --git a/debian/copyright b/debian/copyright
index ed79510..7c836cc 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -5,6 +5,7 @@ Source: https://github.com/Theano/Theano
Files-Excluded: .gitignore
doc/.templates/layout.html
+
Files: *
Copyright: 2008-2016 Theano Development Team <theano-dev at googlegroups.com>
License: BSD-3-Clause
@@ -22,6 +23,13 @@ Files: theano/sandbox/cuda/cnmem.cpp
Copyright: 2015 NVIDIA Corporation
License: BSD-3-Clause
+Files: theano/d3viz/js/d3.v3.min.js
+ doc/library/d3viz/examples/d3viz/js/d3.v3.min.js
+ debian/missing-source/d3.js
+Copyright: 2010-2016 Mike Bostock <mike at ocks.org>
+Comment: https://github.com/d3/d3
+License: BSD-3-Clause
+
License: BSD-3-Clause
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
@@ -50,6 +58,17 @@ Files: theano/compat/six.py
Copyright: 2010-2012 Benjamin Peterson
License: Expat
+Files: theano/d3viz/js/graphlib-dot.min.js
+ doc/library/d3viz/examples/d3viz/js/graphlib-dot.min.js
+ debian/missing-source/graphlib-dot.js
+ theano/d3viz/js/dagre-d3.min.js
+ doc/library/d3viz/examples/d3viz/js/dagre-d3.min.js
+ debian/missing-source/dagre-d3.js
+Copyright: 2012-2015 Chris Pettitt <cpettitt at gmail.com>
+Comment: https://github.com/cpettitt/graphlib-dot
+ https://github.com/cpettitt/dagre-d3
+License: Expat
+
Files: theano/gof/sched.py
Copyright: 2008-2015 Theano Development Team
2012 Oren Tirosh
diff --git a/debian/missing-source/README.txt b/debian/missing-source/README.txt
new file mode 100644
index 0000000..0235876
--- /dev/null
+++ b/debian/missing-source/README.txt
@@ -0,0 +1,24 @@
+Non-minified sources of minified Javascript files in the source tarball:
+
+1) d3.js
+
+origin: https://github.com/d3/d3 (release 3.5.6)
+
+theano/d3viz/js/d3.v3.min.js
+doc/library/d3viz/examples/d3viz/js/d3.v3.min.js
+
+2) dagre-d3.js
+
+origin: https://github.com/cpettitt/dagre-d3 (supposingly release 0.4.5)
+
+theano/d3viz/js/dagre-d3.min.js
+doc/library/d3viz/examples/d3viz/js/dagre-d3.min.js
+
+3) graphlib-dot.js
+
+origin: https://github.com/cpettitt/graphlib-dot/tree/master/dist (20150728.b3192e8)
+
+theano/d3viz/js/graphlib-dot.min.js
+doc/library/d3viz/examples/d3viz/js/graphlib-dot.min.js
+
+Daniel Stender <stender at debian.org> 2015-07-11
diff --git a/debian/missing-source/d3.js b/debian/missing-source/d3.js
new file mode 100644
index 0000000..e4d8664
--- /dev/null
+++ b/debian/missing-source/d3.js
@@ -0,0 +1,9503 @@
+!function() {
+ var d3 = {
+ version: "3.5.6"
+ };
+ var d3_arraySlice = [].slice, d3_array = function(list) {
+ return d3_arraySlice.call(list);
+ };
+ var d3_document = this.document;
+ function d3_documentElement(node) {
+ return node && (node.ownerDocument || node.document || node).documentElement;
+ }
+ function d3_window(node) {
+ return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);
+ }
+ if (d3_document) {
+ try {
+ d3_array(d3_document.documentElement.childNodes)[0].nodeType;
+ } catch (e) {
+ d3_array = function(list) {
+ var i = list.length, array = new Array(i);
+ while (i--) array[i] = list[i];
+ return array;
+ };
+ }
+ }
+ if (!Date.now) Date.now = function() {
+ return +new Date();
+ };
+ if (d3_document) {
+ try {
+ d3_document.createElement("DIV").style.setProperty("opacity", 0, "");
+ } catch (error) {
+ var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
+ d3_element_prototype.setAttribute = function(name, value) {
+ d3_element_setAttribute.call(this, name, value + "");
+ };
+ d3_element_prototype.setAttributeNS = function(space, local, value) {
+ d3_element_setAttributeNS.call(this, space, local, value + "");
+ };
+ d3_style_prototype.setProperty = function(name, value, priority) {
+ d3_style_setProperty.call(this, name, value + "", priority);
+ };
+ }
+ }
+ d3.ascending = d3_ascending;
+ function d3_ascending(a, b) {
+ return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+ }
+ d3.descending = function(a, b) {
+ return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+ };
+ d3.min = function(array, f) {
+ var i = -1, n = array.length, a, b;
+ if (arguments.length === 1) {
+ while (++i < n) if ((b = array[i]) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = array[i]) != null && a > b) a = b;
+ } else {
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
+ }
+ return a;
+ };
+ d3.max = function(array, f) {
+ var i = -1, n = array.length, a, b;
+ if (arguments.length === 1) {
+ while (++i < n) if ((b = array[i]) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = array[i]) != null && b > a) a = b;
+ } else {
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
+ }
+ return a;
+ };
+ d3.extent = function(array, f) {
+ var i = -1, n = array.length, a, b, c;
+ if (arguments.length === 1) {
+ while (++i < n) if ((b = array[i]) != null && b >= b) {
+ a = c = b;
+ break;
+ }
+ while (++i < n) if ((b = array[i]) != null) {
+ if (a > b) a = b;
+ if (c < b) c = b;
+ }
+ } else {
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+ a = c = b;
+ break;
+ }
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
+ if (a > b) a = b;
+ if (c < b) c = b;
+ }
+ }
+ return [ a, c ];
+ };
+ function d3_number(x) {
+ return x === null ? NaN : +x;
+ }
+ function d3_numeric(x) {
+ return !isNaN(x);
+ }
+ d3.sum = function(array, f) {
+ var s = 0, n = array.length, a, i = -1;
+ if (arguments.length === 1) {
+ while (++i < n) if (d3_numeric(a = +array[i])) s += a;
+ } else {
+ while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a;
+ }
+ return s;
+ };
+ d3.mean = function(array, f) {
+ var s = 0, n = array.length, a, i = -1, j = n;
+ if (arguments.length === 1) {
+ while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;
+ } else {
+ while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;
+ }
+ if (j) return s / j;
+ };
+ d3.quantile = function(values, p) {
+ var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;
+ return e ? v + e * (values[h] - v) : v;
+ };
+ d3.median = function(array, f) {
+ var numbers = [], n = array.length, a, i = -1;
+ if (arguments.length === 1) {
+ while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);
+ } else {
+ while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);
+ }
+ if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);
+ };
+ d3.variance = function(array, f) {
+ var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0;
+ if (arguments.length === 1) {
+ while (++i < n) {
+ if (d3_numeric(a = d3_number(array[i]))) {
+ d = a - m;
+ m += d / ++j;
+ s += d * (a - m);
+ }
+ }
+ } else {
+ while (++i < n) {
+ if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {
+ d = a - m;
+ m += d / ++j;
+ s += d * (a - m);
+ }
+ }
+ }
+ if (j > 1) return s / (j - 1);
+ };
+ d3.deviation = function() {
+ var v = d3.variance.apply(this, arguments);
+ return v ? Math.sqrt(v) : v;
+ };
+ function d3_bisector(compare) {
+ return {
+ left: function(a, x, lo, hi) {
+ if (arguments.length < 3) lo = 0;
+ if (arguments.length < 4) hi = a.length;
+ while (lo < hi) {
+ var mid = lo + hi >>> 1;
+ if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;
+ }
+ return lo;
+ },
+ right: function(a, x, lo, hi) {
+ if (arguments.length < 3) lo = 0;
+ if (arguments.length < 4) hi = a.length;
+ while (lo < hi) {
+ var mid = lo + hi >>> 1;
+ if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;
+ }
+ return lo;
+ }
+ };
+ }
+ var d3_bisect = d3_bisector(d3_ascending);
+ d3.bisectLeft = d3_bisect.left;
+ d3.bisect = d3.bisectRight = d3_bisect.right;
+ d3.bisector = function(f) {
+ return d3_bisector(f.length === 1 ? function(d, x) {
+ return d3_ascending(f(d), x);
+ } : f);
+ };
+ d3.shuffle = function(array, i0, i1) {
+ if ((m = arguments.length) < 3) {
+ i1 = array.length;
+ if (m < 2) i0 = 0;
+ }
+ var m = i1 - i0, t, i;
+ while (m) {
+ i = Math.random() * m-- | 0;
+ t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;
+ }
+ return array;
+ };
+ d3.permute = function(array, indexes) {
+ var i = indexes.length, permutes = new Array(i);
+ while (i--) permutes[i] = array[indexes[i]];
+ return permutes;
+ };
+ d3.pairs = function(array) {
+ var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);
+ while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];
+ return pairs;
+ };
+ d3.zip = function() {
+ if (!(n = arguments.length)) return [];
+ for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) {
+ for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) {
+ zip[j] = arguments[j][i];
+ }
+ }
+ return zips;
+ };
+ function d3_zipLength(d) {
+ return d.length;
+ }
+ d3.transpose = function(matrix) {
+ return d3.zip.apply(d3, matrix);
+ };
+ d3.keys = function(map) {
+ var keys = [];
+ for (var key in map) keys.push(key);
+ return keys;
+ };
+ d3.values = function(map) {
+ var values = [];
+ for (var key in map) values.push(map[key]);
+ return values;
+ };
+ d3.entries = function(map) {
+ var entries = [];
+ for (var key in map) entries.push({
+ key: key,
+ value: map[key]
+ });
+ return entries;
+ };
+ d3.merge = function(arrays) {
+ var n = arrays.length, m, i = -1, j = 0, merged, array;
+ while (++i < n) j += arrays[i].length;
+ merged = new Array(j);
+ while (--n >= 0) {
+ array = arrays[n];
+ m = array.length;
+ while (--m >= 0) {
+ merged[--j] = array[m];
+ }
+ }
+ return merged;
+ };
+ var abs = Math.abs;
+ d3.range = function(start, stop, step) {
+ if (arguments.length < 3) {
+ step = 1;
+ if (arguments.length < 2) {
+ stop = start;
+ start = 0;
+ }
+ }
+ if ((stop - start) / step === Infinity) throw new Error("infinite range");
+ var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;
+ start *= k, stop *= k, step *= k;
+ if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);
+ return range;
+ };
+ function d3_range_integerScale(x) {
+ var k = 1;
+ while (x * k % 1) k *= 10;
+ return k;
+ }
+ function d3_class(ctor, properties) {
+ for (var key in properties) {
+ Object.defineProperty(ctor.prototype, key, {
+ value: properties[key],
+ enumerable: false
+ });
+ }
+ }
+ d3.map = function(object, f) {
+ var map = new d3_Map();
+ if (object instanceof d3_Map) {
+ object.forEach(function(key, value) {
+ map.set(key, value);
+ });
+ } else if (Array.isArray(object)) {
+ var i = -1, n = object.length, o;
+ if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o);
+ } else {
+ for (var key in object) map.set(key, object[key]);
+ }
+ return map;
+ };
+ function d3_Map() {
+ this._ = Object.create(null);
+ }
+ var d3_map_proto = "__proto__", d3_map_zero = "\x00";
+ d3_class(d3_Map, {
+ has: d3_map_has,
+ get: function(key) {
+ return this._[d3_map_escape(key)];
+ },
+ set: function(key, value) {
+ return this._[d3_map_escape(key)] = value;
+ },
+ remove: d3_map_remove,
+ keys: d3_map_keys,
+ values: function() {
+ var values = [];
+ for (var key in this._) values.push(this._[key]);
+ return values;
+ },
+ entries: function() {
+ var entries = [];
+ for (var key in this._) entries.push({
+ key: d3_map_unescape(key),
+ value: this._[key]
+ });
+ return entries;
+ },
+ size: d3_map_size,
+ empty: d3_map_empty,
+ forEach: function(f) {
+ for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]);
+ }
+ });
+ function d3_map_escape(key) {
+ return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
+ }
+ function d3_map_unescape(key) {
+ return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
+ }
+ function d3_map_has(key) {
+ return d3_map_escape(key) in this._;
+ }
+ function d3_map_remove(key) {
+ return (key = d3_map_escape(key)) in this._ && delete this._[key];
+ }
+ function d3_map_keys() {
+ var keys = [];
+ for (var key in this._) keys.push(d3_map_unescape(key));
+ return keys;
+ }
+ function d3_map_size() {
+ var size = 0;
+ for (var key in this._) ++size;
+ return size;
+ }
+ function d3_map_empty() {
+ for (var key in this._) return false;
+ return true;
+ }
+ d3.nest = function() {
+ var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
+ function map(mapType, array, depth) {
+ if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
+ var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
+ while (++i < n) {
+ if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
+ values.push(object);
+ } else {
+ valuesByKey.set(keyValue, [ object ]);
+ }
+ }
+ if (mapType) {
+ object = mapType();
+ setter = function(keyValue, values) {
+ object.set(keyValue, map(mapType, values, depth));
+ };
+ } else {
+ object = {};
+ setter = function(keyValue, values) {
+ object[keyValue] = map(mapType, values, depth);
+ };
+ }
+ valuesByKey.forEach(setter);
+ return object;
+ }
+ function entries(map, depth) {
+ if (depth >= keys.length) return map;
+ var array = [], sortKey = sortKeys[depth++];
+ map.forEach(function(key, keyMap) {
+ array.push({
+ key: key,
+ values: entries(keyMap, depth)
+ });
+ });
+ return sortKey ? array.sort(function(a, b) {
+ return sortKey(a.key, b.key);
+ }) : array;
+ }
+ nest.map = function(array, mapType) {
+ return map(mapType, array, 0);
+ };
+ nest.entries = function(array) {
+ return entries(map(d3.map, array, 0), 0);
+ };
+ nest.key = function(d) {
+ keys.push(d);
+ return nest;
+ };
+ nest.sortKeys = function(order) {
+ sortKeys[keys.length - 1] = order;
+ return nest;
+ };
+ nest.sortValues = function(order) {
+ sortValues = order;
+ return nest;
+ };
+ nest.rollup = function(f) {
+ rollup = f;
+ return nest;
+ };
+ return nest;
+ };
+ d3.set = function(array) {
+ var set = new d3_Set();
+ if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);
+ return set;
+ };
+ function d3_Set() {
+ this._ = Object.create(null);
+ }
+ d3_class(d3_Set, {
+ has: d3_map_has,
+ add: function(key) {
+ this._[d3_map_escape(key += "")] = true;
+ return key;
+ },
+ remove: d3_map_remove,
+ values: d3_map_keys,
+ size: d3_map_size,
+ empty: d3_map_empty,
+ forEach: function(f) {
+ for (var key in this._) f.call(this, d3_map_unescape(key));
+ }
+ });
+ d3.behavior = {};
+ function d3_identity(d) {
+ return d;
+ }
+ d3.rebind = function(target, source) {
+ var i = 1, n = arguments.length, method;
+ while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
+ return target;
+ };
+ function d3_rebind(target, source, method) {
+ return function() {
+ var value = method.apply(source, arguments);
+ return value === source ? target : value;
+ };
+ }
+ function d3_vendorSymbol(object, name) {
+ if (name in object) return name;
+ name = name.charAt(0).toUpperCase() + name.slice(1);
+ for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
+ var prefixName = d3_vendorPrefixes[i] + name;
+ if (prefixName in object) return prefixName;
+ }
+ }
+ var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ];
+ function d3_noop() {}
+ d3.dispatch = function() {
+ var dispatch = new d3_dispatch(), i = -1, n = arguments.length;
+ while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+ return dispatch;
+ };
+ function d3_dispatch() {}
+ d3_dispatch.prototype.on = function(type, listener) {
+ var i = type.indexOf("."), name = "";
+ if (i >= 0) {
+ name = type.slice(i + 1);
+ type = type.slice(0, i);
+ }
+ if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
+ if (arguments.length === 2) {
+ if (listener == null) for (type in this) {
+ if (this.hasOwnProperty(type)) this[type].on(name, null);
+ }
+ return this;
+ }
+ };
+ function d3_dispatch_event(dispatch) {
+ var listeners = [], listenerByName = new d3_Map();
+ function event() {
+ var z = listeners, i = -1, n = z.length, l;
+ while (++i < n) if (l = z[i].on) l.apply(this, arguments);
+ return dispatch;
+ }
+ event.on = function(name, listener) {
+ var l = listenerByName.get(name), i;
+ if (arguments.length < 2) return l && l.on;
+ if (l) {
+ l.on = null;
+ listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
+ listenerByName.remove(name);
+ }
+ if (listener) listeners.push(listenerByName.set(name, {
+ on: listener
+ }));
+ return dispatch;
+ };
+ return event;
+ }
+ d3.event = null;
+ function d3_eventPreventDefault() {
+ d3.event.preventDefault();
+ }
+ function d3_eventSource() {
+ var e = d3.event, s;
+ while (s = e.sourceEvent) e = s;
+ return e;
+ }
+ function d3_eventDispatch(target) {
+ var dispatch = new d3_dispatch(), i = 0, n = arguments.length;
+ while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+ dispatch.of = function(thiz, argumentz) {
+ return function(e1) {
+ try {
+ var e0 = e1.sourceEvent = d3.event;
+ e1.target = target;
+ d3.event = e1;
+ dispatch[e1.type].apply(thiz, argumentz);
+ } finally {
+ d3.event = e0;
+ }
+ };
+ };
+ return dispatch;
+ }
+ d3.requote = function(s) {
+ return s.replace(d3_requote_re, "\\$&");
+ };
+ var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
+ var d3_subclass = {}.__proto__ ? function(object, prototype) {
+ object.__proto__ = prototype;
+ } : function(object, prototype) {
+ for (var property in prototype) object[property] = prototype[property];
+ };
+ function d3_selection(groups) {
+ d3_subclass(groups, d3_selectionPrototype);
+ return groups;
+ }
+ var d3_select = function(s, n) {
+ return n.querySelector(s);
+ }, d3_selectAll = function(s, n) {
+ return n.querySelectorAll(s);
+ }, d3_selectMatches = function(n, s) {
+ var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];
+ d3_selectMatches = function(n, s) {
+ return d3_selectMatcher.call(n, s);
+ };
+ return d3_selectMatches(n, s);
+ };
+ if (typeof Sizzle === "function") {
+ d3_select = function(s, n) {
+ return Sizzle(s, n)[0] || null;
+ };
+ d3_selectAll = Sizzle;
+ d3_selectMatches = Sizzle.matchesSelector;
+ }
+ d3.selection = function() {
+ return d3.select(d3_document.documentElement);
+ };
+ var d3_selectionPrototype = d3.selection.prototype = [];
+ d3_selectionPrototype.select = function(selector) {
+ var subgroups = [], subgroup, subnode, group, node;
+ selector = d3_selection_selector(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ subgroups.push(subgroup = []);
+ subgroup.parentNode = (group = this[j]).parentNode;
+ for (var i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ subgroup.push(subnode = selector.call(node, node.__data__, i, j));
+ if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
+ } else {
+ subgroup.push(null);
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ function d3_selection_selector(selector) {
+ return typeof selector === "function" ? selector : function() {
+ return d3_select(selector, this);
+ };
+ }
+ d3_selectionPrototype.selectAll = function(selector) {
+ var subgroups = [], subgroup, node;
+ selector = d3_selection_selectorAll(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
+ subgroup.parentNode = node;
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ function d3_selection_selectorAll(selector) {
+ return typeof selector === "function" ? selector : function() {
+ return d3_selectAll(selector, this);
+ };
+ }
+ var d3_nsPrefix = {
+ svg: "http://www.w3.org/2000/svg",
+ xhtml: "http://www.w3.org/1999/xhtml",
+ xlink: "http://www.w3.org/1999/xlink",
+ xml: "http://www.w3.org/XML/1998/namespace",
+ xmlns: "http://www.w3.org/2000/xmlns/"
+ };
+ d3.ns = {
+ prefix: d3_nsPrefix,
+ qualify: function(name) {
+ var i = name.indexOf(":"), prefix = name;
+ if (i >= 0) {
+ prefix = name.slice(0, i);
+ name = name.slice(i + 1);
+ }
+ return d3_nsPrefix.hasOwnProperty(prefix) ? {
+ space: d3_nsPrefix[prefix],
+ local: name
+ } : name;
+ }
+ };
+ d3_selectionPrototype.attr = function(name, value) {
+ if (arguments.length < 2) {
+ if (typeof name === "string") {
+ var node = this.node();
+ name = d3.ns.qualify(name);
+ return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);
+ }
+ for (value in name) this.each(d3_selection_attr(value, name[value]));
+ return this;
+ }
+ return this.each(d3_selection_attr(name, value));
+ };
+ function d3_selection_attr(name, value) {
+ name = d3.ns.qualify(name);
+ function attrNull() {
+ this.removeAttribute(name);
+ }
+ function attrNullNS() {
+ this.removeAttributeNS(name.space, name.local);
+ }
+ function attrConstant() {
+ this.setAttribute(name, value);
+ }
+ function attrConstantNS() {
+ this.setAttributeNS(name.space, name.local, value);
+ }
+ function attrFunction() {
+ var x = value.apply(this, arguments);
+ if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);
+ }
+ function attrFunctionNS() {
+ var x = value.apply(this, arguments);
+ if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);
+ }
+ return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;
+ }
+ function d3_collapse(s) {
+ return s.trim().replace(/\s+/g, " ");
+ }
+ d3_selectionPrototype.classed = function(name, value) {
+ if (arguments.length < 2) {
+ if (typeof name === "string") {
+ var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;
+ if (value = node.classList) {
+ while (++i < n) if (!value.contains(name[i])) return false;
+ } else {
+ value = node.getAttribute("class");
+ while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
+ }
+ return true;
+ }
+ for (value in name) this.each(d3_selection_classed(value, name[value]));
+ return this;
+ }
+ return this.each(d3_selection_classed(name, value));
+ };
+ function d3_selection_classedRe(name) {
+ return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
+ }
+ function d3_selection_classes(name) {
+ return (name + "").trim().split(/^|\s+/);
+ }
+ function d3_selection_classed(name, value) {
+ name = d3_selection_classes(name).map(d3_selection_classedName);
+ var n = name.length;
+ function classedConstant() {
+ var i = -1;
+ while (++i < n) name[i](this, value);
+ }
+ function classedFunction() {
+ var i = -1, x = value.apply(this, arguments);
+ while (++i < n) name[i](this, x);
+ }
+ return typeof value === "function" ? classedFunction : classedConstant;
+ }
+ function d3_selection_classedName(name) {
+ var re = d3_selection_classedRe(name);
+ return function(node, value) {
+ if (c = node.classList) return value ? c.add(name) : c.remove(name);
+ var c = node.getAttribute("class") || "";
+ if (value) {
+ re.lastIndex = 0;
+ if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
+ } else {
+ node.setAttribute("class", d3_collapse(c.replace(re, " ")));
+ }
+ };
+ }
+ d3_selectionPrototype.style = function(name, value, priority) {
+ var n = arguments.length;
+ if (n < 3) {
+ if (typeof name !== "string") {
+ if (n < 2) value = "";
+ for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
+ return this;
+ }
+ if (n < 2) {
+ var node = this.node();
+ return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);
+ }
+ priority = "";
+ }
+ return this.each(d3_selection_style(name, value, priority));
+ };
+ function d3_selection_style(name, value, priority) {
+ function styleNull() {
+ this.style.removeProperty(name);
+ }
+ function styleConstant() {
+ this.style.setProperty(name, value, priority);
+ }
+ function styleFunction() {
+ var x = value.apply(this, arguments);
+ if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);
+ }
+ return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
+ }
+ d3_selectionPrototype.property = function(name, value) {
+ if (arguments.length < 2) {
+ if (typeof name === "string") return this.node()[name];
+ for (value in name) this.each(d3_selection_property(value, name[value]));
+ return this;
+ }
+ return this.each(d3_selection_property(name, value));
+ };
+ function d3_selection_property(name, value) {
+ function propertyNull() {
+ delete this[name];
+ }
+ function propertyConstant() {
+ this[name] = value;
+ }
+ function propertyFunction() {
+ var x = value.apply(this, arguments);
+ if (x == null) delete this[name]; else this[name] = x;
+ }
+ return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
+ }
+ d3_selectionPrototype.text = function(value) {
+ return arguments.length ? this.each(typeof value === "function" ? function() {
+ var v = value.apply(this, arguments);
+ this.textContent = v == null ? "" : v;
+ } : value == null ? function() {
+ this.textContent = "";
+ } : function() {
+ this.textContent = value;
+ }) : this.node().textContent;
+ };
+ d3_selectionPrototype.html = function(value) {
+ return arguments.length ? this.each(typeof value === "function" ? function() {
+ var v = value.apply(this, arguments);
+ this.innerHTML = v == null ? "" : v;
+ } : value == null ? function() {
+ this.innerHTML = "";
+ } : function() {
+ this.innerHTML = value;
+ }) : this.node().innerHTML;
+ };
+ d3_selectionPrototype.append = function(name) {
+ name = d3_selection_creator(name);
+ return this.select(function() {
+ return this.appendChild(name.apply(this, arguments));
+ });
+ };
+ function d3_selection_creator(name) {
+ function create() {
+ var document = this.ownerDocument, namespace = this.namespaceURI;
+ return namespace ? document.createElementNS(namespace, name) : document.createElement(name);
+ }
+ function createNS() {
+ return this.ownerDocument.createElementNS(name.space, name.local);
+ }
+ return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create;
+ }
+ d3_selectionPrototype.insert = function(name, before) {
+ name = d3_selection_creator(name);
+ before = d3_selection_selector(before);
+ return this.select(function() {
+ return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
+ });
+ };
+ d3_selectionPrototype.remove = function() {
+ return this.each(d3_selectionRemove);
+ };
+ function d3_selectionRemove() {
+ var parent = this.parentNode;
+ if (parent) parent.removeChild(this);
+ }
+ d3_selectionPrototype.data = function(value, key) {
+ var i = -1, n = this.length, group, node;
+ if (!arguments.length) {
+ value = new Array(n = (group = this[0]).length);
+ while (++i < n) {
+ if (node = group[i]) {
+ value[i] = node.__data__;
+ }
+ }
+ return value;
+ }
+ function bind(group, groupData) {
+ var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;
+ if (key) {
+ var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;
+ for (i = -1; ++i < n; ) {
+ if (nodeByKeyValue.has(keyValue = key.call(node = group[i], node.__data__, i))) {
+ exitNodes[i] = node;
+ } else {
+ nodeByKeyValue.set(keyValue, node);
+ }
+ keyValues[i] = keyValue;
+ }
+ for (i = -1; ++i < m; ) {
+ if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {
+ enterNodes[i] = d3_selection_dataNode(nodeData);
+ } else if (node !== true) {
+ updateNodes[i] = node;
+ node.__data__ = nodeData;
+ }
+ nodeByKeyValue.set(keyValue, true);
+ }
+ for (i = -1; ++i < n; ) {
+ if (nodeByKeyValue.get(keyValues[i]) !== true) {
+ exitNodes[i] = group[i];
+ }
+ }
+ } else {
+ for (i = -1; ++i < n0; ) {
+ node = group[i];
+ nodeData = groupData[i];
+ if (node) {
+ node.__data__ = nodeData;
+ updateNodes[i] = node;
+ } else {
+ enterNodes[i] = d3_selection_dataNode(nodeData);
+ }
+ }
+ for (;i < m; ++i) {
+ enterNodes[i] = d3_selection_dataNode(groupData[i]);
+ }
+ for (;i < n; ++i) {
+ exitNodes[i] = group[i];
+ }
+ }
+ enterNodes.update = updateNodes;
+ enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;
+ enter.push(enterNodes);
+ update.push(updateNodes);
+ exit.push(exitNodes);
+ }
+ var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
+ if (typeof value === "function") {
+ while (++i < n) {
+ bind(group = this[i], value.call(group, group.parentNode.__data__, i));
+ }
+ } else {
+ while (++i < n) {
+ bind(group = this[i], value);
+ }
+ }
+ update.enter = function() {
+ return enter;
+ };
+ update.exit = function() {
+ return exit;
+ };
+ return update;
+ };
+ function d3_selection_dataNode(data) {
+ return {
+ __data__: data
+ };
+ }
+ d3_selectionPrototype.datum = function(value) {
+ return arguments.length ? this.property("__data__", value) : this.property("__data__");
+ };
+ d3_selectionPrototype.filter = function(filter) {
+ var subgroups = [], subgroup, group, node;
+ if (typeof filter !== "function") filter = d3_selection_filter(filter);
+ for (var j = 0, m = this.length; j < m; j++) {
+ subgroups.push(subgroup = []);
+ subgroup.parentNode = (group = this[j]).parentNode;
+ for (var i = 0, n = group.length; i < n; i++) {
+ if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
+ subgroup.push(node);
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ function d3_selection_filter(selector) {
+ return function() {
+ return d3_selectMatches(this, selector);
+ };
+ }
+ d3_selectionPrototype.order = function() {
+ for (var j = -1, m = this.length; ++j < m; ) {
+ for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
+ if (node = group[i]) {
+ if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
+ next = node;
+ }
+ }
+ }
+ return this;
+ };
+ d3_selectionPrototype.sort = function(comparator) {
+ comparator = d3_selection_sortComparator.apply(this, arguments);
+ for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);
+ return this.order();
+ };
+ function d3_selection_sortComparator(comparator) {
+ if (!arguments.length) comparator = d3_ascending;
+ return function(a, b) {
+ return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
+ };
+ }
+ d3_selectionPrototype.each = function(callback) {
+ return d3_selection_each(this, function(node, i, j) {
+ callback.call(node, node.__data__, i, j);
+ });
+ };
+ function d3_selection_each(groups, callback) {
+ for (var j = 0, m = groups.length; j < m; j++) {
+ for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
+ if (node = group[i]) callback(node, i, j);
+ }
+ }
+ return groups;
+ }
+ d3_selectionPrototype.call = function(callback) {
+ var args = d3_array(arguments);
+ callback.apply(args[0] = this, args);
+ return this;
+ };
+ d3_selectionPrototype.empty = function() {
+ return !this.node();
+ };
+ d3_selectionPrototype.node = function() {
+ for (var j = 0, m = this.length; j < m; j++) {
+ for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+ var node = group[i];
+ if (node) return node;
+ }
+ }
+ return null;
+ };
+ d3_selectionPrototype.size = function() {
+ var n = 0;
+ d3_selection_each(this, function() {
+ ++n;
+ });
+ return n;
+ };
+ function d3_selection_enter(selection) {
+ d3_subclass(selection, d3_selection_enterPrototype);
+ return selection;
+ }
+ var d3_selection_enterPrototype = [];
+ d3.selection.enter = d3_selection_enter;
+ d3.selection.enter.prototype = d3_selection_enterPrototype;
+ d3_selection_enterPrototype.append = d3_selectionPrototype.append;
+ d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
+ d3_selection_enterPrototype.node = d3_selectionPrototype.node;
+ d3_selection_enterPrototype.call = d3_selectionPrototype.call;
+ d3_selection_enterPrototype.size = d3_selectionPrototype.size;
+ d3_selection_enterPrototype.select = function(selector) {
+ var subgroups = [], subgroup, subnode, upgroup, group, node;
+ for (var j = -1, m = this.length; ++j < m; ) {
+ upgroup = (group = this[j]).update;
+ subgroups.push(subgroup = []);
+ subgroup.parentNode = group.parentNode;
+ for (var i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));
+ subnode.__data__ = node.__data__;
+ } else {
+ subgroup.push(null);
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ d3_selection_enterPrototype.insert = function(name, before) {
+ if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
+ return d3_selectionPrototype.insert.call(this, name, before);
+ };
+ function d3_selection_enterInsertBefore(enter) {
+ var i0, j0;
+ return function(d, i, j) {
+ var group = enter[j].update, n = group.length, node;
+ if (j != j0) j0 = j, i0 = 0;
+ if (i >= i0) i0 = i + 1;
+ while (!(node = group[i0]) && ++i0 < n) ;
+ return node;
+ };
+ }
+ d3.select = function(node) {
+ var group;
+ if (typeof node === "string") {
+ group = [ d3_select(node, d3_document) ];
+ group.parentNode = d3_document.documentElement;
+ } else {
+ group = [ node ];
+ group.parentNode = d3_documentElement(node);
+ }
+ return d3_selection([ group ]);
+ };
+ d3.selectAll = function(nodes) {
+ var group;
+ if (typeof nodes === "string") {
+ group = d3_array(d3_selectAll(nodes, d3_document));
+ group.parentNode = d3_document.documentElement;
+ } else {
+ group = nodes;
+ group.parentNode = null;
+ }
+ return d3_selection([ group ]);
+ };
+ d3_selectionPrototype.on = function(type, listener, capture) {
+ var n = arguments.length;
+ if (n < 3) {
+ if (typeof type !== "string") {
+ if (n < 2) listener = false;
+ for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
+ return this;
+ }
+ if (n < 2) return (n = this.node()["__on" + type]) && n._;
+ capture = false;
+ }
+ return this.each(d3_selection_on(type, listener, capture));
+ };
+ function d3_selection_on(type, listener, capture) {
+ var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;
+ if (i > 0) type = type.slice(0, i);
+ var filter = d3_selection_onFilters.get(type);
+ if (filter) type = filter, wrap = d3_selection_onFilter;
+ function onRemove() {
+ var l = this[name];
+ if (l) {
+ this.removeEventListener(type, l, l.$);
+ delete this[name];
+ }
+ }
+ function onAdd() {
+ var l = wrap(listener, d3_array(arguments));
+ onRemove.call(this);
+ this.addEventListener(type, this[name] = l, l.$ = capture);
+ l._ = listener;
+ }
+ function removeAll() {
+ var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
+ for (var name in this) {
+ if (match = name.match(re)) {
+ var l = this[name];
+ this.removeEventListener(match[1], l, l.$);
+ delete this[name];
+ }
+ }
+ }
+ return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
+ }
+ var d3_selection_onFilters = d3.map({
+ mouseenter: "mouseover",
+ mouseleave: "mouseout"
+ });
+ if (d3_document) {
+ d3_selection_onFilters.forEach(function(k) {
+ if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
+ });
+ }
+ function d3_selection_onListener(listener, argumentz) {
+ return function(e) {
+ var o = d3.event;
+ d3.event = e;
+ argumentz[0] = this.__data__;
+ try {
+ listener.apply(this, argumentz);
+ } finally {
+ d3.event = o;
+ }
+ };
+ }
+ function d3_selection_onFilter(listener, argumentz) {
+ var l = d3_selection_onListener(listener, argumentz);
+ return function(e) {
+ var target = this, related = e.relatedTarget;
+ if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
+ l.call(target, e);
+ }
+ };
+ }
+ var d3_event_dragSelect, d3_event_dragId = 0;
+ function d3_event_dragSuppress(node) {
+ var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window(node)).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault);
+ if (d3_event_dragSelect == null) {
+ d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect");
+ }
+ if (d3_event_dragSelect) {
+ var style = d3_documentElement(node).style, select = style[d3_event_dragSelect];
+ style[d3_event_dragSelect] = "none";
+ }
+ return function(suppressClick) {
+ w.on(name, null);
+ if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
+ if (suppressClick) {
+ var off = function() {
+ w.on(click, null);
+ };
+ w.on(click, function() {
+ d3_eventPreventDefault();
+ off();
+ }, true);
+ setTimeout(off, 0);
+ }
+ };
+ }
+ d3.mouse = function(container) {
+ return d3_mousePoint(container, d3_eventSource());
+ };
+ var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
+ function d3_mousePoint(container, e) {
+ if (e.changedTouches) e = e.changedTouches[0];
+ var svg = container.ownerSVGElement || container;
+ if (svg.createSVGPoint) {
+ var point = svg.createSVGPoint();
+ if (d3_mouse_bug44083 < 0) {
+ var window = d3_window(container);
+ if (window.scrollX || window.scrollY) {
+ svg = d3.select("body").append("svg").style({
+ position: "absolute",
+ top: 0,
+ left: 0,
+ margin: 0,
+ padding: 0,
+ border: "none"
+ }, "important");
+ var ctm = svg[0][0].getScreenCTM();
+ d3_mouse_bug44083 = !(ctm.f || ctm.e);
+ svg.remove();
+ }
+ }
+ if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX,
+ point.y = e.clientY;
+ point = point.matrixTransform(container.getScreenCTM().inverse());
+ return [ point.x, point.y ];
+ }
+ var rect = container.getBoundingClientRect();
+ return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];
+ }
+ d3.touch = function(container, touches, identifier) {
+ if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
+ if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
+ if ((touch = touches[i]).identifier === identifier) {
+ return d3_mousePoint(container, touch);
+ }
+ }
+ };
+ d3.behavior.drag = function() {
+ var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend");
+ function drag() {
+ this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);
+ }
+ function dragstart(id, position, subject, move, end) {
+ return function() {
+ var that = this, target = d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId);
+ if (origin) {
+ dragOffset = origin.apply(that, arguments);
+ dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ];
+ } else {
+ dragOffset = [ 0, 0 ];
+ }
+ dispatch({
+ type: "dragstart"
+ });
+ function moved() {
+ var position1 = position(parent, dragId), dx, dy;
+ if (!position1) return;
+ dx = position1[0] - position0[0];
+ dy = position1[1] - position0[1];
+ dragged |= dx | dy;
+ position0 = position1;
+ dispatch({
+ type: "drag",
+ x: position1[0] + dragOffset[0],
+ y: position1[1] + dragOffset[1],
+ dx: dx,
+ dy: dy
+ });
+ }
+ function ended() {
+ if (!position(parent, dragId)) return;
+ dragSubject.on(move + dragName, null).on(end + dragName, null);
+ dragRestore(dragged && d3.event.target === target);
+ dispatch({
+ type: "dragend"
+ });
+ }
+ };
+ }
+ drag.origin = function(x) {
+ if (!arguments.length) return origin;
+ origin = x;
+ return drag;
+ };
+ return d3.rebind(drag, event, "on");
+ };
+ function d3_behavior_dragTouchId() {
+ return d3.event.changedTouches[0].identifier;
+ }
+ d3.touches = function(container, touches) {
+ if (arguments.length < 2) touches = d3_eventSource().touches;
+ return touches ? d3_array(touches).map(function(touch) {
+ var point = d3_mousePoint(container, touch);
+ point.identifier = touch.identifier;
+ return point;
+ }) : [];
+ };
+ var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π;
+ function d3_sgn(x) {
+ return x > 0 ? 1 : x < 0 ? -1 : 0;
+ }
+ function d3_cross2d(a, b, c) {
+ return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+ }
+ function d3_acos(x) {
+ return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
+ }
+ function d3_asin(x) {
+ return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
+ }
+ function d3_sinh(x) {
+ return ((x = Math.exp(x)) - 1 / x) / 2;
+ }
+ function d3_cosh(x) {
+ return ((x = Math.exp(x)) + 1 / x) / 2;
+ }
+ function d3_tanh(x) {
+ return ((x = Math.exp(2 * x)) - 1) / (x + 1);
+ }
+ function d3_haversin(x) {
+ return (x = Math.sin(x / 2)) * x;
+ }
+ var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;
+ d3.interpolateZoom = function(p0, p1) {
+ var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2];
+ var dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1), dr = r1 - r0, S = (dr || Math.log(w1 / w0)) / ρ;
+ function interpolate(t) {
+ var s = t * S;
+ if (dr) {
+ var coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));
+ return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];
+ }
+ return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * s) ];
+ }
+ interpolate.duration = S * 1e3;
+ return interpolate;
+ };
+ d3.behavior.zoom = function() {
+ var view = {
+ x: 0,
+ y: 0,
+ k: 1
+ }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;
+ if (!d3_behavior_zoomWheel) {
+ d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+ return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
+ }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+ return d3.event.wheelDelta;
+ }, "mousewheel") : (d3_behavior_zoomDelta = function() {
+ return -d3.event.detail;
+ }, "MozMousePixelScroll");
+ }
+ function zoom(g) {
+ g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);
+ }
+ zoom.event = function(g) {
+ g.each(function() {
+ var dispatch = event.of(this, arguments), view1 = view;
+ if (d3_transitionInheritId) {
+ d3.select(this).transition().each("start.zoom", function() {
+ view = this.__chart__ || {
+ x: 0,
+ y: 0,
+ k: 1
+ };
+ zoomstarted(dispatch);
+ }).tween("zoom:zoom", function() {
+ var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]);
+ return function(t) {
+ var l = i(t), k = dx / l[2];
+ this.__chart__ = view = {
+ x: cx - l[0] * k,
+ y: cy - l[1] * k,
+ k: k
+ };
+ zoomed(dispatch);
+ };
+ }).each("interrupt.zoom", function() {
+ zoomended(dispatch);
+ }).each("end.zoom", function() {
+ zoomended(dispatch);
+ });
+ } else {
+ this.__chart__ = view;
+ zoomstarted(dispatch);
+ zoomed(dispatch);
+ zoomended(dispatch);
+ }
+ });
+ };
+ zoom.translate = function(_) {
+ if (!arguments.length) return [ view.x, view.y ];
+ view = {
+ x: +_[0],
+ y: +_[1],
+ k: view.k
+ };
+ rescale();
+ return zoom;
+ };
+ zoom.scale = function(_) {
+ if (!arguments.length) return view.k;
+ view = {
+ x: view.x,
+ y: view.y,
+ k: +_
+ };
+ rescale();
+ return zoom;
+ };
+ zoom.scaleExtent = function(_) {
+ if (!arguments.length) return scaleExtent;
+ scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];
+ return zoom;
+ };
+ zoom.center = function(_) {
+ if (!arguments.length) return center;
+ center = _ && [ +_[0], +_[1] ];
+ return zoom;
+ };
+ zoom.size = function(_) {
+ if (!arguments.length) return size;
+ size = _ && [ +_[0], +_[1] ];
+ return zoom;
+ };
+ zoom.duration = function(_) {
+ if (!arguments.length) return duration;
+ duration = +_;
+ return zoom;
+ };
+ zoom.x = function(z) {
+ if (!arguments.length) return x1;
+ x1 = z;
+ x0 = z.copy();
+ view = {
+ x: 0,
+ y: 0,
+ k: 1
+ };
+ return zoom;
+ };
+ zoom.y = function(z) {
+ if (!arguments.length) return y1;
+ y1 = z;
+ y0 = z.copy();
+ view = {
+ x: 0,
+ y: 0,
+ k: 1
+ };
+ return zoom;
+ };
+ function location(p) {
+ return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ];
+ }
+ function point(l) {
+ return [ l[0] * view.k + view.x, l[1] * view.k + view.y ];
+ }
+ function scaleTo(s) {
+ view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
+ }
+ function translateTo(p, l) {
+ l = point(l);
+ view.x += p[0] - l[0];
+ view.y += p[1] - l[1];
+ }
+ function zoomTo(that, p, l, k) {
+ that.__chart__ = {
+ x: view.x,
+ y: view.y,
+ k: view.k
+ };
+ scaleTo(Math.pow(2, k));
+ translateTo(center0 = p, l);
+ that = d3.select(that);
+ if (duration > 0) that = that.transition().duration(duration);
+ that.call(zoom.event);
+ }
+ function rescale() {
+ if (x1) x1.domain(x0.range().map(function(x) {
+ return (x - view.x) / view.k;
+ }).map(x0.invert));
+ if (y1) y1.domain(y0.range().map(function(y) {
+ return (y - view.y) / view.k;
+ }).map(y0.invert));
+ }
+ function zoomstarted(dispatch) {
+ if (!zooming++) dispatch({
+ type: "zoomstart"
+ });
+ }
+ function zoomed(dispatch) {
+ rescale();
+ dispatch({
+ type: "zoom",
+ scale: view.k,
+ translate: [ view.x, view.y ]
+ });
+ }
+ function zoomended(dispatch) {
+ if (!--zooming) dispatch({
+ type: "zoomend"
+ }), center0 = null;
+ }
+ function mousedowned() {
+ var that = this, target = d3.event.target, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that);
+ d3_selection_interrupt.call(that);
+ zoomstarted(dispatch);
+ function moved() {
+ dragged = 1;
+ translateTo(d3.mouse(that), location0);
+ zoomed(dispatch);
+ }
+ function ended() {
+ subject.on(mousemove, null).on(mouseup, null);
+ dragRestore(dragged && d3.event.target === target);
+ zoomended(dispatch);
+ }
+ }
+ function touchstarted() {
+ var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that);
+ started();
+ zoomstarted(dispatch);
+ subject.on(mousedown, null).on(touchstart, started);
+ function relocate() {
+ var touches = d3.touches(that);
+ scale0 = view.k;
+ touches.forEach(function(t) {
+ if (t.identifier in locations0) locations0[t.identifier] = location(t);
+ });
+ return touches;
+ }
+ function started() {
+ var target = d3.event.target;
+ d3.select(target).on(touchmove, moved).on(touchend, ended);
+ targets.push(target);
+ var changed = d3.event.changedTouches;
+ for (var i = 0, n = changed.length; i < n; ++i) {
+ locations0[changed[i].identifier] = null;
+ }
+ var touches = relocate(), now = Date.now();
+ if (touches.length === 1) {
+ if (now - touchtime < 500) {
+ var p = touches[0];
+ zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
+ d3_eventPreventDefault();
+ }
+ touchtime = now;
+ } else if (touches.length > 1) {
+ var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1];
+ distance0 = dx * dx + dy * dy;
+ }
+ }
+ function moved() {
+ var touches = d3.touches(that), p0, l0, p1, l1;
+ d3_selection_interrupt.call(that);
+ for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
+ p1 = touches[i];
+ if (l1 = locations0[p1.identifier]) {
+ if (l0) break;
+ p0 = p1, l0 = l1;
+ }
+ }
+ if (l1) {
+ var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);
+ p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];
+ l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];
+ scaleTo(scale1 * scale0);
+ }
+ touchtime = null;
+ translateTo(p0, l0);
+ zoomed(dispatch);
+ }
+ function ended() {
+ if (d3.event.touches.length) {
+ var changed = d3.event.changedTouches;
+ for (var i = 0, n = changed.length; i < n; ++i) {
+ delete locations0[changed[i].identifier];
+ }
+ for (var identifier in locations0) {
+ return void relocate();
+ }
+ }
+ d3.selectAll(targets).on(zoomName, null);
+ subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
+ dragRestore();
+ zoomended(dispatch);
+ }
+ }
+ function mousewheeled() {
+ var dispatch = event.of(this, arguments);
+ if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this),
+ translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch);
+ mousewheelTimer = setTimeout(function() {
+ mousewheelTimer = null;
+ zoomended(dispatch);
+ }, 50);
+ d3_eventPreventDefault();
+ scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
+ translateTo(center0, translate0);
+ zoomed(dispatch);
+ }
+ function dblclicked() {
+ var p = d3.mouse(this), k = Math.log(view.k) / Math.LN2;
+ zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1);
+ }
+ return d3.rebind(zoom, event, "on");
+ };
+ var d3_behavior_zoomInfinity = [ 0, Infinity ], d3_behavior_zoomDelta, d3_behavior_zoomWheel;
+ d3.color = d3_color;
+ function d3_color() {}
+ d3_color.prototype.toString = function() {
+ return this.rgb() + "";
+ };
+ d3.hsl = d3_hsl;
+ function d3_hsl(h, s, l) {
+ return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l);
+ }
+ var d3_hslPrototype = d3_hsl.prototype = new d3_color();
+ d3_hslPrototype.brighter = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ return new d3_hsl(this.h, this.s, this.l / k);
+ };
+ d3_hslPrototype.darker = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ return new d3_hsl(this.h, this.s, k * this.l);
+ };
+ d3_hslPrototype.rgb = function() {
+ return d3_hsl_rgb(this.h, this.s, this.l);
+ };
+ function d3_hsl_rgb(h, s, l) {
+ var m1, m2;
+ h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;
+ s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;
+ l = l < 0 ? 0 : l > 1 ? 1 : l;
+ m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
+ m1 = 2 * l - m2;
+ function v(h) {
+ if (h > 360) h -= 360; else if (h < 0) h += 360;
+ if (h < 60) return m1 + (m2 - m1) * h / 60;
+ if (h < 180) return m2;
+ if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
+ return m1;
+ }
+ function vv(h) {
+ return Math.round(v(h) * 255);
+ }
+ return new d3_rgb(vv(h + 120), vv(h), vv(h - 120));
+ }
+ d3.hcl = d3_hcl;
+ function d3_hcl(h, c, l) {
+ return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l);
+ }
+ var d3_hclPrototype = d3_hcl.prototype = new d3_color();
+ d3_hclPrototype.brighter = function(k) {
+ return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
+ };
+ d3_hclPrototype.darker = function(k) {
+ return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
+ };
+ d3_hclPrototype.rgb = function() {
+ return d3_hcl_lab(this.h, this.c, this.l).rgb();
+ };
+ function d3_hcl_lab(h, c, l) {
+ if (isNaN(h)) h = 0;
+ if (isNaN(c)) c = 0;
+ return new d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
+ }
+ d3.lab = d3_lab;
+ function d3_lab(l, a, b) {
+ return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.h, l.c, l.l) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b);
+ }
+ var d3_lab_K = 18;
+ var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
+ var d3_labPrototype = d3_lab.prototype = new d3_color();
+ d3_labPrototype.brighter = function(k) {
+ return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
+ };
+ d3_labPrototype.darker = function(k) {
+ return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
+ };
+ d3_labPrototype.rgb = function() {
+ return d3_lab_rgb(this.l, this.a, this.b);
+ };
+ function d3_lab_rgb(l, a, b) {
+ var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
+ x = d3_lab_xyz(x) * d3_lab_X;
+ y = d3_lab_xyz(y) * d3_lab_Y;
+ z = d3_lab_xyz(z) * d3_lab_Z;
+ return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z));
+ }
+ function d3_lab_hcl(l, a, b) {
+ return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l);
+ }
+ function d3_lab_xyz(x) {
+ return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
+ }
+ function d3_xyz_lab(x) {
+ return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
+ }
+ function d3_xyz_rgb(r) {
+ return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));
+ }
+ d3.rgb = d3_rgb;
+ function d3_rgb(r, g, b) {
+ return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b);
+ }
+ function d3_rgbNumber(value) {
+ return new d3_rgb(value >> 16, value >> 8 & 255, value & 255);
+ }
+ function d3_rgbString(value) {
+ return d3_rgbNumber(value) + "";
+ }
+ var d3_rgbPrototype = d3_rgb.prototype = new d3_color();
+ d3_rgbPrototype.brighter = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ var r = this.r, g = this.g, b = this.b, i = 30;
+ if (!r && !g && !b) return new d3_rgb(i, i, i);
+ if (r && r < i) r = i;
+ if (g && g < i) g = i;
+ if (b && b < i) b = i;
+ return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k));
+ };
+ d3_rgbPrototype.darker = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ return new d3_rgb(k * this.r, k * this.g, k * this.b);
+ };
+ d3_rgbPrototype.hsl = function() {
+ return d3_rgb_hsl(this.r, this.g, this.b);
+ };
+ d3_rgbPrototype.toString = function() {
+ return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
+ };
+ function d3_rgb_hex(v) {
+ return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
+ }
+ function d3_rgb_parse(format, rgb, hsl) {
+ var r = 0, g = 0, b = 0, m1, m2, color;
+ m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase());
+ if (m1) {
+ m2 = m1[2].split(",");
+ switch (m1[1]) {
+ case "hsl":
+ {
+ return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
+ }
+
+ case "rgb":
+ {
+ return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
+ }
+ }
+ }
+ if (color = d3_rgb_names.get(format)) {
+ return rgb(color.r, color.g, color.b);
+ }
+ if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.slice(1), 16))) {
+ if (format.length === 4) {
+ r = (color & 3840) >> 4;
+ r = r >> 4 | r;
+ g = color & 240;
+ g = g >> 4 | g;
+ b = color & 15;
+ b = b << 4 | b;
+ } else if (format.length === 7) {
+ r = (color & 16711680) >> 16;
+ g = (color & 65280) >> 8;
+ b = color & 255;
+ }
+ }
+ return rgb(r, g, b);
+ }
+ function d3_rgb_hsl(r, g, b) {
+ var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2;
+ if (d) {
+ s = l < .5 ? d / (max + min) : d / (2 - max - min);
+ if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4;
+ h *= 60;
+ } else {
+ h = NaN;
+ s = l > 0 && l < 1 ? 0 : h;
+ }
+ return new d3_hsl(h, s, l);
+ }
+ function d3_rgb_lab(r, g, b) {
+ r = d3_rgb_xyz(r);
+ g = d3_rgb_xyz(g);
+ b = d3_rgb_xyz(b);
+ var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z);
+ return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
+ }
+ function d3_rgb_xyz(r) {
+ return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);
+ }
+ function d3_rgb_parseNumber(c) {
+ var f = parseFloat(c);
+ return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
+ }
+ var d3_rgb_names = d3.map({
+ aliceblue: 15792383,
+ antiquewhite: 16444375,
+ aqua: 65535,
+ aquamarine: 8388564,
+ azure: 15794175,
+ beige: 16119260,
+ bisque: 16770244,
+ black: 0,
+ blanchedalmond: 16772045,
+ blue: 255,
+ blueviolet: 9055202,
+ brown: 10824234,
+ burlywood: 14596231,
+ cadetblue: 6266528,
+ chartreuse: 8388352,
+ chocolate: 13789470,
+ coral: 16744272,
+ cornflowerblue: 6591981,
+ cornsilk: 16775388,
+ crimson: 14423100,
+ cyan: 65535,
+ darkblue: 139,
+ darkcyan: 35723,
+ darkgoldenrod: 12092939,
+ darkgray: 11119017,
+ darkgreen: 25600,
+ darkgrey: 11119017,
+ darkkhaki: 12433259,
+ darkmagenta: 9109643,
+ darkolivegreen: 5597999,
+ darkorange: 16747520,
+ darkorchid: 10040012,
+ darkred: 9109504,
+ darksalmon: 15308410,
+ darkseagreen: 9419919,
+ darkslateblue: 4734347,
+ darkslategray: 3100495,
+ darkslategrey: 3100495,
+ darkturquoise: 52945,
+ darkviolet: 9699539,
+ deeppink: 16716947,
+ deepskyblue: 49151,
+ dimgray: 6908265,
+ dimgrey: 6908265,
+ dodgerblue: 2003199,
+ firebrick: 11674146,
+ floralwhite: 16775920,
+ forestgreen: 2263842,
+ fuchsia: 16711935,
+ gainsboro: 14474460,
+ ghostwhite: 16316671,
+ gold: 16766720,
+ goldenrod: 14329120,
+ gray: 8421504,
+ green: 32768,
+ greenyellow: 11403055,
+ grey: 8421504,
+ honeydew: 15794160,
+ hotpink: 16738740,
+ indianred: 13458524,
+ indigo: 4915330,
+ ivory: 16777200,
+ khaki: 15787660,
+ lavender: 15132410,
+ lavenderblush: 16773365,
+ lawngreen: 8190976,
+ lemonchiffon: 16775885,
+ lightblue: 11393254,
+ lightcoral: 15761536,
+ lightcyan: 14745599,
+ lightgoldenrodyellow: 16448210,
+ lightgray: 13882323,
+ lightgreen: 9498256,
+ lightgrey: 13882323,
+ lightpink: 16758465,
+ lightsalmon: 16752762,
+ lightseagreen: 2142890,
+ lightskyblue: 8900346,
+ lightslategray: 7833753,
+ lightslategrey: 7833753,
+ lightsteelblue: 11584734,
+ lightyellow: 16777184,
+ lime: 65280,
+ limegreen: 3329330,
+ linen: 16445670,
+ magenta: 16711935,
+ maroon: 8388608,
+ mediumaquamarine: 6737322,
+ mediumblue: 205,
+ mediumorchid: 12211667,
+ mediumpurple: 9662683,
+ mediumseagreen: 3978097,
+ mediumslateblue: 8087790,
+ mediumspringgreen: 64154,
+ mediumturquoise: 4772300,
+ mediumvioletred: 13047173,
+ midnightblue: 1644912,
+ mintcream: 16121850,
+ mistyrose: 16770273,
+ moccasin: 16770229,
+ navajowhite: 16768685,
+ navy: 128,
+ oldlace: 16643558,
+ olive: 8421376,
+ olivedrab: 7048739,
+ orange: 16753920,
+ orangered: 16729344,
+ orchid: 14315734,
+ palegoldenrod: 15657130,
+ palegreen: 10025880,
+ paleturquoise: 11529966,
+ palevioletred: 14381203,
+ papayawhip: 16773077,
+ peachpuff: 16767673,
+ peru: 13468991,
+ pink: 16761035,
+ plum: 14524637,
+ powderblue: 11591910,
+ purple: 8388736,
+ rebeccapurple: 6697881,
+ red: 16711680,
+ rosybrown: 12357519,
+ royalblue: 4286945,
+ saddlebrown: 9127187,
+ salmon: 16416882,
+ sandybrown: 16032864,
+ seagreen: 3050327,
+ seashell: 16774638,
+ sienna: 10506797,
+ silver: 12632256,
+ skyblue: 8900331,
+ slateblue: 6970061,
+ slategray: 7372944,
+ slategrey: 7372944,
+ snow: 16775930,
+ springgreen: 65407,
+ steelblue: 4620980,
+ tan: 13808780,
+ teal: 32896,
+ thistle: 14204888,
+ tomato: 16737095,
+ turquoise: 4251856,
+ violet: 15631086,
+ wheat: 16113331,
+ white: 16777215,
+ whitesmoke: 16119285,
+ yellow: 16776960,
+ yellowgreen: 10145074
+ });
+ d3_rgb_names.forEach(function(key, value) {
+ d3_rgb_names.set(key, d3_rgbNumber(value));
+ });
+ function d3_functor(v) {
+ return typeof v === "function" ? v : function() {
+ return v;
+ };
+ }
+ d3.functor = d3_functor;
+ d3.xhr = d3_xhrType(d3_identity);
+ function d3_xhrType(response) {
+ return function(url, mimeType, callback) {
+ if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType,
+ mimeType = null;
+ return d3_xhr(url, mimeType, response, callback);
+ };
+ }
+ function d3_xhr(url, mimeType, response, callback) {
+ var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;
+ if (this.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
+ "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
+ request.readyState > 3 && respond();
+ };
+ function respond() {
+ var status = request.status, result;
+ if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
+ try {
+ result = response.call(xhr, request);
+ } catch (e) {
+ dispatch.error.call(xhr, e);
+ return;
+ }
+ dispatch.load.call(xhr, result);
+ } else {
+ dispatch.error.call(xhr, request);
+ }
+ }
+ request.onprogress = function(event) {
+ var o = d3.event;
+ d3.event = event;
+ try {
+ dispatch.progress.call(xhr, request);
+ } finally {
+ d3.event = o;
+ }
+ };
+ xhr.header = function(name, value) {
+ name = (name + "").toLowerCase();
+ if (arguments.length < 2) return headers[name];
+ if (value == null) delete headers[name]; else headers[name] = value + "";
+ return xhr;
+ };
+ xhr.mimeType = function(value) {
+ if (!arguments.length) return mimeType;
+ mimeType = value == null ? null : value + "";
+ return xhr;
+ };
+ xhr.responseType = function(value) {
+ if (!arguments.length) return responseType;
+ responseType = value;
+ return xhr;
+ };
+ xhr.response = function(value) {
+ response = value;
+ return xhr;
+ };
+ [ "get", "post" ].forEach(function(method) {
+ xhr[method] = function() {
+ return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));
+ };
+ });
+ xhr.send = function(method, data, callback) {
+ if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
+ request.open(method, url, true);
+ if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
+ if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
+ if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
+ if (responseType != null) request.responseType = responseType;
+ if (callback != null) xhr.on("error", callback).on("load", function(request) {
+ callback(null, request);
+ });
+ dispatch.beforesend.call(xhr, request);
+ request.send(data == null ? null : data);
+ return xhr;
+ };
+ xhr.abort = function() {
+ request.abort();
+ return xhr;
+ };
+ d3.rebind(xhr, dispatch, "on");
+ return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
+ }
+ function d3_xhr_fixCallback(callback) {
+ return callback.length === 1 ? function(error, request) {
+ callback(error == null ? request : null);
+ } : callback;
+ }
+ function d3_xhrHasResponse(request) {
+ var type = request.responseType;
+ return type && type !== "text" ? request.response : request.responseText;
+ }
+ d3.dsv = function(delimiter, mimeType) {
+ var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
+ function dsv(url, row, callback) {
+ if (arguments.length < 3) callback = row, row = null;
+ var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
+ xhr.row = function(_) {
+ return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;
+ };
+ return xhr;
+ }
+ function response(request) {
+ return dsv.parse(request.responseText);
+ }
+ function typedResponse(f) {
+ return function(request) {
+ return dsv.parse(request.responseText, f);
+ };
+ }
+ dsv.parse = function(text, f) {
+ var o;
+ return dsv.parseRows(text, function(row, i) {
+ if (o) return o(row, i - 1);
+ var a = new Function("d", "return {" + row.map(function(name, i) {
+ return JSON.stringify(name) + ": d[" + i + "]";
+ }).join(",") + "}");
+ o = f ? function(row, i) {
+ return f(a(row), i);
+ } : a;
+ });
+ };
+ dsv.parseRows = function(text, f) {
+ var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;
+ function token() {
+ if (I >= N) return EOF;
+ if (eol) return eol = false, EOL;
+ var j = I;
+ if (text.charCodeAt(j) === 34) {
+ var i = j;
+ while (i++ < N) {
+ if (text.charCodeAt(i) === 34) {
+ if (text.charCodeAt(i + 1) !== 34) break;
+ ++i;
+ }
+ }
+ I = i + 2;
+ var c = text.charCodeAt(i + 1);
+ if (c === 13) {
+ eol = true;
+ if (text.charCodeAt(i + 2) === 10) ++I;
+ } else if (c === 10) {
+ eol = true;
+ }
+ return text.slice(j + 1, i).replace(/""/g, '"');
+ }
+ while (I < N) {
+ var c = text.charCodeAt(I++), k = 1;
+ if (c === 10) eol = true; else if (c === 13) {
+ eol = true;
+ if (text.charCodeAt(I) === 10) ++I, ++k;
+ } else if (c !== delimiterCode) continue;
+ return text.slice(j, I - k);
+ }
+ return text.slice(j);
+ }
+ while ((t = token()) !== EOF) {
+ var a = [];
+ while (t !== EOL && t !== EOF) {
+ a.push(t);
+ t = token();
+ }
+ if (f && (a = f(a, n++)) == null) continue;
+ rows.push(a);
+ }
+ return rows;
+ };
+ dsv.format = function(rows) {
+ if (Array.isArray(rows[0])) return dsv.formatRows(rows);
+ var fieldSet = new d3_Set(), fields = [];
+ rows.forEach(function(row) {
+ for (var field in row) {
+ if (!fieldSet.has(field)) {
+ fields.push(fieldSet.add(field));
+ }
+ }
+ });
+ return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {
+ return fields.map(function(field) {
+ return formatValue(row[field]);
+ }).join(delimiter);
+ })).join("\n");
+ };
+ dsv.formatRows = function(rows) {
+ return rows.map(formatRow).join("\n");
+ };
+ function formatRow(row) {
+ return row.map(formatValue).join(delimiter);
+ }
+ function formatValue(text) {
+ return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
+ }
+ return dsv;
+ };
+ d3.csv = d3.dsv(",", "text/csv");
+ d3.tsv = d3.dsv(" ", "text/tab-separated-values");
+ var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_active, d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) {
+ setTimeout(callback, 17);
+ };
+ d3.timer = function(callback, delay, then) {
+ var n = arguments.length;
+ if (n < 2) delay = 0;
+ if (n < 3) then = Date.now();
+ var time = then + delay, timer = {
+ c: callback,
+ t: time,
+ f: false,
+ n: null
+ };
+ if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;
+ d3_timer_queueTail = timer;
+ if (!d3_timer_interval) {
+ d3_timer_timeout = clearTimeout(d3_timer_timeout);
+ d3_timer_interval = 1;
+ d3_timer_frame(d3_timer_step);
+ }
+ };
+ function d3_timer_step() {
+ var now = d3_timer_mark(), delay = d3_timer_sweep() - now;
+ if (delay > 24) {
+ if (isFinite(delay)) {
+ clearTimeout(d3_timer_timeout);
+ d3_timer_timeout = setTimeout(d3_timer_step, delay);
+ }
+ d3_timer_interval = 0;
+ } else {
+ d3_timer_interval = 1;
+ d3_timer_frame(d3_timer_step);
+ }
+ }
+ d3.timer.flush = function() {
+ d3_timer_mark();
+ d3_timer_sweep();
+ };
+ function d3_timer_mark() {
+ var now = Date.now();
+ d3_timer_active = d3_timer_queueHead;
+ while (d3_timer_active) {
+ if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t);
+ d3_timer_active = d3_timer_active.n;
+ }
+ return now;
+ }
+ function d3_timer_sweep() {
+ var t0, t1 = d3_timer_queueHead, time = Infinity;
+ while (t1) {
+ if (t1.f) {
+ t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
+ } else {
+ if (t1.t < time) time = t1.t;
+ t1 = (t0 = t1).n;
+ }
+ }
+ d3_timer_queueTail = t0;
+ return time;
+ }
+ function d3_format_precision(x, p) {
+ return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);
+ }
+ d3.round = function(x, n) {
+ return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);
+ };
+ var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);
+ d3.formatPrefix = function(value, precision) {
+ var i = 0;
+ if (value) {
+ if (value < 0) value *= -1;
+ if (precision) value = d3.round(value, d3_format_precision(value, precision));
+ i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
+ i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));
+ }
+ return d3_formatPrefixes[8 + i / 3];
+ };
+ function d3_formatPrefix(d, i) {
+ var k = Math.pow(10, abs(8 - i) * 3);
+ return {
+ scale: i > 8 ? function(d) {
+ return d / k;
+ } : function(d) {
+ return d * k;
+ },
+ symbol: d
+ };
+ }
+ function d3_locale_numberFormat(locale) {
+ var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping && locale_thousands ? function(value, width) {
+ var i = value.length, t = [], j = 0, g = locale_grouping[0], length = 0;
+ while (i > 0 && g > 0) {
+ if (length + g + 1 > width) g = Math.max(1, width - length);
+ t.push(value.substring(i -= g, i + g));
+ if ((length += g + 1) > width) break;
+ g = locale_grouping[j = (j + 1) % locale_grouping.length];
+ }
+ return t.reverse().join(locale_thousands);
+ } : d3_identity;
+ return function(specifier) {
+ var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "-", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false, exponent = true;
+ if (precision) precision = +precision.substring(1);
+ if (zfill || fill === "0" && align === "=") {
+ zfill = fill = "0";
+ align = "=";
+ }
+ switch (type) {
+ case "n":
+ comma = true;
+ type = "g";
+ break;
+
+ case "%":
+ scale = 100;
+ suffix = "%";
+ type = "f";
+ break;
+
+ case "p":
+ scale = 100;
+ suffix = "%";
+ type = "r";
+ break;
+
+ case "b":
+ case "o":
+ case "x":
+ case "X":
+ if (symbol === "#") prefix = "0" + type.toLowerCase();
+
+ case "c":
+ exponent = false;
+
+ case "d":
+ integer = true;
+ precision = 0;
+ break;
+
+ case "s":
+ scale = -1;
+ type = "r";
+ break;
+ }
+ if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1];
+ if (type == "r" && !precision) type = "g";
+ if (precision != null) {
+ if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision));
+ }
+ type = d3_format_types.get(type) || d3_format_typeDefault;
+ var zcomma = zfill && comma;
+ return function(value) {
+ var fullSuffix = suffix;
+ if (integer && value % 1) return "";
+ var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign === "-" ? "" : sign;
+ if (scale < 0) {
+ var unit = d3.formatPrefix(value, precision);
+ value = unit.scale(value);
+ fullSuffix = unit.symbol + suffix;
+ } else {
+ value *= scale;
+ }
+ value = type(value, precision);
+ var i = value.lastIndexOf("."), before, after;
+ if (i < 0) {
+ var j = exponent ? value.lastIndexOf("e") : -1;
+ if (j < 0) before = value, after = ""; else before = value.substring(0, j), after = value.substring(j);
+ } else {
+ before = value.substring(0, i);
+ after = locale_decimal + value.substring(i + 1);
+ }
+ if (!zfill && comma) before = formatGroup(before, Infinity);
+ var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";
+ if (zcomma) before = formatGroup(padding + before, padding.length ? width - after.length : Infinity);
+ negative += prefix;
+ value = before + after;
+ return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix;
+ };
+ };
+ }
+ var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;
+ var d3_format_types = d3.map({
+ b: function(x) {
+ return x.toString(2);
+ },
+ c: function(x) {
+ return String.fromCharCode(x);
+ },
+ o: function(x) {
+ return x.toString(8);
+ },
+ x: function(x) {
+ return x.toString(16);
+ },
+ X: function(x) {
+ return x.toString(16).toUpperCase();
+ },
+ g: function(x, p) {
+ return x.toPrecision(p);
+ },
+ e: function(x, p) {
+ return x.toExponential(p);
+ },
+ f: function(x, p) {
+ return x.toFixed(p);
+ },
+ r: function(x, p) {
+ return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p))));
+ }
+ });
+ function d3_format_typeDefault(x) {
+ return x + "";
+ }
+ var d3_time = d3.time = {}, d3_date = Date;
+ function d3_date_utc() {
+ this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);
+ }
+ d3_date_utc.prototype = {
+ getDate: function() {
+ return this._.getUTCDate();
+ },
+ getDay: function() {
+ return this._.getUTCDay();
+ },
+ getFullYear: function() {
+ return this._.getUTCFullYear();
+ },
+ getHours: function() {
+ return this._.getUTCHours();
+ },
+ getMilliseconds: function() {
+ return this._.getUTCMilliseconds();
+ },
+ getMinutes: function() {
+ return this._.getUTCMinutes();
+ },
+ getMonth: function() {
+ return this._.getUTCMonth();
+ },
+ getSeconds: function() {
+ return this._.getUTCSeconds();
+ },
+ getTime: function() {
+ return this._.getTime();
+ },
+ getTimezoneOffset: function() {
+ return 0;
+ },
+ valueOf: function() {
+ return this._.valueOf();
+ },
+ setDate: function() {
+ d3_time_prototype.setUTCDate.apply(this._, arguments);
+ },
+ setDay: function() {
+ d3_time_prototype.setUTCDay.apply(this._, arguments);
+ },
+ setFullYear: function() {
+ d3_time_prototype.setUTCFullYear.apply(this._, arguments);
+ },
+ setHours: function() {
+ d3_time_prototype.setUTCHours.apply(this._, arguments);
+ },
+ setMilliseconds: function() {
+ d3_time_prototype.setUTCMilliseconds.apply(this._, arguments);
+ },
+ setMinutes: function() {
+ d3_time_prototype.setUTCMinutes.apply(this._, arguments);
+ },
+ setMonth: function() {
+ d3_time_prototype.setUTCMonth.apply(this._, arguments);
+ },
+ setSeconds: function() {
+ d3_time_prototype.setUTCSeconds.apply(this._, arguments);
+ },
+ setTime: function() {
+ d3_time_prototype.setTime.apply(this._, arguments);
+ }
+ };
+ var d3_time_prototype = Date.prototype;
+ function d3_time_interval(local, step, number) {
+ function round(date) {
+ var d0 = local(date), d1 = offset(d0, 1);
+ return date - d0 < d1 - date ? d0 : d1;
+ }
+ function ceil(date) {
+ step(date = local(new d3_date(date - 1)), 1);
+ return date;
+ }
+ function offset(date, k) {
+ step(date = new d3_date(+date), k);
+ return date;
+ }
+ function range(t0, t1, dt) {
+ var time = ceil(t0), times = [];
+ if (dt > 1) {
+ while (time < t1) {
+ if (!(number(time) % dt)) times.push(new Date(+time));
+ step(time, 1);
+ }
+ } else {
+ while (time < t1) times.push(new Date(+time)), step(time, 1);
+ }
+ return times;
+ }
+ function range_utc(t0, t1, dt) {
+ try {
+ d3_date = d3_date_utc;
+ var utc = new d3_date_utc();
+ utc._ = t0;
+ return range(utc, t1, dt);
+ } finally {
+ d3_date = Date;
+ }
+ }
+ local.floor = local;
+ local.round = round;
+ local.ceil = ceil;
+ local.offset = offset;
+ local.range = range;
+ var utc = local.utc = d3_time_interval_utc(local);
+ utc.floor = utc;
+ utc.round = d3_time_interval_utc(round);
+ utc.ceil = d3_time_interval_utc(ceil);
+ utc.offset = d3_time_interval_utc(offset);
+ utc.range = range_utc;
+ return local;
+ }
+ function d3_time_interval_utc(method) {
+ return function(date, k) {
+ try {
+ d3_date = d3_date_utc;
+ var utc = new d3_date_utc();
+ utc._ = date;
+ return method(utc, k)._;
+ } finally {
+ d3_date = Date;
+ }
+ };
+ }
+ d3_time.year = d3_time_interval(function(date) {
+ date = d3_time.day(date);
+ date.setMonth(0, 1);
+ return date;
+ }, function(date, offset) {
+ date.setFullYear(date.getFullYear() + offset);
+ }, function(date) {
+ return date.getFullYear();
+ });
+ d3_time.years = d3_time.year.range;
+ d3_time.years.utc = d3_time.year.utc.range;
+ d3_time.day = d3_time_interval(function(date) {
+ var day = new d3_date(2e3, 0);
+ day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+ return day;
+ }, function(date, offset) {
+ date.setDate(date.getDate() + offset);
+ }, function(date) {
+ return date.getDate() - 1;
+ });
+ d3_time.days = d3_time.day.range;
+ d3_time.days.utc = d3_time.day.utc.range;
+ d3_time.dayOfYear = function(date) {
+ var year = d3_time.year(date);
+ return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5);
+ };
+ [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) {
+ i = 7 - i;
+ var interval = d3_time[day] = d3_time_interval(function(date) {
+ (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);
+ return date;
+ }, function(date, offset) {
+ date.setDate(date.getDate() + Math.floor(offset) * 7);
+ }, function(date) {
+ var day = d3_time.year(date).getDay();
+ return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);
+ });
+ d3_time[day + "s"] = interval.range;
+ d3_time[day + "s"].utc = interval.utc.range;
+ d3_time[day + "OfYear"] = function(date) {
+ var day = d3_time.year(date).getDay();
+ return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7);
+ };
+ });
+ d3_time.week = d3_time.sunday;
+ d3_time.weeks = d3_time.sunday.range;
+ d3_time.weeks.utc = d3_time.sunday.utc.range;
+ d3_time.weekOfYear = d3_time.sundayOfYear;
+ function d3_locale_timeFormat(locale) {
+ var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
+ function d3_time_format(template) {
+ var n = template.length;
+ function format(date) {
+ var string = [], i = -1, j = 0, c, p, f;
+ while (++i < n) {
+ if (template.charCodeAt(i) === 37) {
+ string.push(template.slice(j, i));
+ if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i);
+ if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p);
+ string.push(c);
+ j = i + 1;
+ }
+ }
+ string.push(template.slice(j, i));
+ return string.join("");
+ }
+ format.parse = function(string) {
+ var d = {
+ y: 1900,
+ m: 0,
+ d: 1,
+ H: 0,
+ M: 0,
+ S: 0,
+ L: 0,
+ Z: null
+ }, i = d3_time_parse(d, template, string, 0);
+ if (i != string.length) return null;
+ if ("p" in d) d.H = d.H % 12 + d.p * 12;
+ var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();
+ if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("w" in d && ("W" in d || "U" in d)) {
+ date.setFullYear(d.y, 0, 1);
+ date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);
+ } else date.setFullYear(d.y, d.m, d.d);
+ date.setHours(d.H + (d.Z / 100 | 0), d.M + d.Z % 100, d.S, d.L);
+ return localZ ? date._ : date;
+ };
+ format.toString = function() {
+ return template;
+ };
+ return format;
+ }
+ function d3_time_parse(date, template, string, j) {
+ var c, p, t, i = 0, n = template.length, m = string.length;
+ while (i < n) {
+ if (j >= m) return -1;
+ c = template.charCodeAt(i++);
+ if (c === 37) {
+ t = template.charAt(i++);
+ p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t];
+ if (!p || (j = p(date, string, j)) < 0) return -1;
+ } else if (c != string.charCodeAt(j++)) {
+ return -1;
+ }
+ }
+ return j;
+ }
+ d3_time_format.utc = function(template) {
+ var local = d3_time_format(template);
+ function format(date) {
+ try {
+ d3_date = d3_date_utc;
+ var utc = new d3_date();
+ utc._ = date;
+ return local(utc);
+ } finally {
+ d3_date = Date;
+ }
+ }
+ format.parse = function(string) {
+ try {
+ d3_date = d3_date_utc;
+ var date = local.parse(string);
+ return date && date._;
+ } finally {
+ d3_date = Date;
+ }
+ };
+ format.toString = local.toString;
+ return format;
+ };
+ d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti;
+ var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(loca [...]
+ locale_periods.forEach(function(p, i) {
+ d3_time_periodLookup.set(p.toLowerCase(), i);
+ });
+ var d3_time_formats = {
+ a: function(d) {
+ return locale_shortDays[d.getDay()];
+ },
+ A: function(d) {
+ return locale_days[d.getDay()];
+ },
+ b: function(d) {
+ return locale_shortMonths[d.getMonth()];
+ },
+ B: function(d) {
+ return locale_months[d.getMonth()];
+ },
+ c: d3_time_format(locale_dateTime),
+ d: function(d, p) {
+ return d3_time_formatPad(d.getDate(), p, 2);
+ },
+ e: function(d, p) {
+ return d3_time_formatPad(d.getDate(), p, 2);
+ },
+ H: function(d, p) {
+ return d3_time_formatPad(d.getHours(), p, 2);
+ },
+ I: function(d, p) {
+ return d3_time_formatPad(d.getHours() % 12 || 12, p, 2);
+ },
+ j: function(d, p) {
+ return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3);
+ },
+ L: function(d, p) {
+ return d3_time_formatPad(d.getMilliseconds(), p, 3);
+ },
+ m: function(d, p) {
+ return d3_time_formatPad(d.getMonth() + 1, p, 2);
+ },
+ M: function(d, p) {
+ return d3_time_formatPad(d.getMinutes(), p, 2);
+ },
+ p: function(d) {
+ return locale_periods[+(d.getHours() >= 12)];
+ },
+ S: function(d, p) {
+ return d3_time_formatPad(d.getSeconds(), p, 2);
+ },
+ U: function(d, p) {
+ return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2);
+ },
+ w: function(d) {
+ return d.getDay();
+ },
+ W: function(d, p) {
+ return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2);
+ },
+ x: d3_time_format(locale_date),
+ X: d3_time_format(locale_time),
+ y: function(d, p) {
+ return d3_time_formatPad(d.getFullYear() % 100, p, 2);
+ },
+ Y: function(d, p) {
+ return d3_time_formatPad(d.getFullYear() % 1e4, p, 4);
+ },
+ Z: d3_time_zone,
+ "%": function() {
+ return "%";
+ }
+ };
+ var d3_time_parsers = {
+ a: d3_time_parseWeekdayAbbrev,
+ A: d3_time_parseWeekday,
+ b: d3_time_parseMonthAbbrev,
+ B: d3_time_parseMonth,
+ c: d3_time_parseLocaleFull,
+ d: d3_time_parseDay,
+ e: d3_time_parseDay,
+ H: d3_time_parseHour24,
+ I: d3_time_parseHour24,
+ j: d3_time_parseDayOfYear,
+ L: d3_time_parseMilliseconds,
+ m: d3_time_parseMonthNumber,
+ M: d3_time_parseMinutes,
+ p: d3_time_parseAmPm,
+ S: d3_time_parseSeconds,
+ U: d3_time_parseWeekNumberSunday,
+ w: d3_time_parseWeekdayNumber,
+ W: d3_time_parseWeekNumberMonday,
+ x: d3_time_parseLocaleDate,
+ X: d3_time_parseLocaleTime,
+ y: d3_time_parseYear,
+ Y: d3_time_parseFullYear,
+ Z: d3_time_parseZone,
+ "%": d3_time_parseLiteralPercent
+ };
+ function d3_time_parseWeekdayAbbrev(date, string, i) {
+ d3_time_dayAbbrevRe.lastIndex = 0;
+ var n = d3_time_dayAbbrevRe.exec(string.slice(i));
+ return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseWeekday(date, string, i) {
+ d3_time_dayRe.lastIndex = 0;
+ var n = d3_time_dayRe.exec(string.slice(i));
+ return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseMonthAbbrev(date, string, i) {
+ d3_time_monthAbbrevRe.lastIndex = 0;
+ var n = d3_time_monthAbbrevRe.exec(string.slice(i));
+ return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseMonth(date, string, i) {
+ d3_time_monthRe.lastIndex = 0;
+ var n = d3_time_monthRe.exec(string.slice(i));
+ return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseLocaleFull(date, string, i) {
+ return d3_time_parse(date, d3_time_formats.c.toString(), string, i);
+ }
+ function d3_time_parseLocaleDate(date, string, i) {
+ return d3_time_parse(date, d3_time_formats.x.toString(), string, i);
+ }
+ function d3_time_parseLocaleTime(date, string, i) {
+ return d3_time_parse(date, d3_time_formats.X.toString(), string, i);
+ }
+ function d3_time_parseAmPm(date, string, i) {
+ var n = d3_time_periodLookup.get(string.slice(i, i += 2).toLowerCase());
+ return n == null ? -1 : (date.p = n, i);
+ }
+ return d3_time_format;
+ }
+ var d3_time_formatPads = {
+ "-": "",
+ _: " ",
+ "0": "0"
+ }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/;
+ function d3_time_formatPad(value, fill, width) {
+ var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
+ return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+ }
+ function d3_time_formatRe(names) {
+ return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i");
+ }
+ function d3_time_formatLookup(names) {
+ var map = new d3_Map(), i = -1, n = names.length;
+ while (++i < n) map.set(names[i].toLowerCase(), i);
+ return map;
+ }
+ function d3_time_parseWeekdayNumber(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 1));
+ return n ? (date.w = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseWeekNumberSunday(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i));
+ return n ? (date.U = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseWeekNumberMonday(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i));
+ return n ? (date.W = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseFullYear(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 4));
+ return n ? (date.y = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseYear(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1;
+ }
+ function d3_time_parseZone(date, string, i) {
+ return /^[+-]\d{4}$/.test(string = string.slice(i, i + 5)) ? (date.Z = -string,
+ i + 5) : -1;
+ }
+ function d3_time_expandYear(d) {
+ return d + (d > 68 ? 1900 : 2e3);
+ }
+ function d3_time_parseMonthNumber(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.m = n[0] - 1, i + n[0].length) : -1;
+ }
+ function d3_time_parseDay(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.d = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseDayOfYear(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 3));
+ return n ? (date.j = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseHour24(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.H = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseMinutes(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.M = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseSeconds(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.S = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseMilliseconds(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 3));
+ return n ? (date.L = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_zone(d) {
+ var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = abs(z) / 60 | 0, zm = abs(z) % 60;
+ return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2);
+ }
+ function d3_time_parseLiteralPercent(date, string, i) {
+ d3_time_percentRe.lastIndex = 0;
+ var n = d3_time_percentRe.exec(string.slice(i, i + 1));
+ return n ? i + n[0].length : -1;
+ }
+ function d3_time_formatMulti(formats) {
+ var n = formats.length, i = -1;
+ while (++i < n) formats[i][0] = this(formats[i][0]);
+ return function(date) {
+ var i = 0, f = formats[i];
+ while (!f[1](date)) f = formats[++i];
+ return f[0](date);
+ };
+ }
+ d3.locale = function(locale) {
+ return {
+ numberFormat: d3_locale_numberFormat(locale),
+ timeFormat: d3_locale_timeFormat(locale)
+ };
+ };
+ var d3_locale_enUS = d3.locale({
+ decimal: ".",
+ thousands: ",",
+ grouping: [ 3 ],
+ currency: [ "$", "" ],
+ dateTime: "%a %b %e %X %Y",
+ date: "%m/%d/%Y",
+ time: "%H:%M:%S",
+ periods: [ "AM", "PM" ],
+ days: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
+ shortDays: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ],
+ months: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ],
+ shortMonths: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
+ });
+ d3.format = d3_locale_enUS.numberFormat;
+ d3.geo = {};
+ function d3_adder() {}
+ d3_adder.prototype = {
+ s: 0,
+ t: 0,
+ add: function(y) {
+ d3_adderSum(y, this.t, d3_adderTemp);
+ d3_adderSum(d3_adderTemp.s, this.s, this);
+ if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t;
+ },
+ reset: function() {
+ this.s = this.t = 0;
+ },
+ valueOf: function() {
+ return this.s;
+ }
+ };
+ var d3_adderTemp = new d3_adder();
+ function d3_adderSum(a, b, o) {
+ var x = o.s = a + b, bv = x - a, av = x - bv;
+ o.t = a - av + (b - bv);
+ }
+ d3.geo.stream = function(object, listener) {
+ if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
+ d3_geo_streamObjectType[object.type](object, listener);
+ } else {
+ d3_geo_streamGeometry(object, listener);
+ }
+ };
+ function d3_geo_streamGeometry(geometry, listener) {
+ if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
+ d3_geo_streamGeometryType[geometry.type](geometry, listener);
+ }
+ }
+ var d3_geo_streamObjectType = {
+ Feature: function(feature, listener) {
+ d3_geo_streamGeometry(feature.geometry, listener);
+ },
+ FeatureCollection: function(object, listener) {
+ var features = object.features, i = -1, n = features.length;
+ while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
+ }
+ };
+ var d3_geo_streamGeometryType = {
+ Sphere: function(object, listener) {
+ listener.sphere();
+ },
+ Point: function(object, listener) {
+ object = object.coordinates;
+ listener.point(object[0], object[1], object[2]);
+ },
+ MultiPoint: function(object, listener) {
+ var coordinates = object.coordinates, i = -1, n = coordinates.length;
+ while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
+ },
+ LineString: function(object, listener) {
+ d3_geo_streamLine(object.coordinates, listener, 0);
+ },
+ MultiLineString: function(object, listener) {
+ var coordinates = object.coordinates, i = -1, n = coordinates.length;
+ while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
+ },
+ Polygon: function(object, listener) {
+ d3_geo_streamPolygon(object.coordinates, listener);
+ },
+ MultiPolygon: function(object, listener) {
+ var coordinates = object.coordinates, i = -1, n = coordinates.length;
+ while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
+ },
+ GeometryCollection: function(object, listener) {
+ var geometries = object.geometries, i = -1, n = geometries.length;
+ while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
+ }
+ };
+ function d3_geo_streamLine(coordinates, listener, closed) {
+ var i = -1, n = coordinates.length - closed, coordinate;
+ listener.lineStart();
+ while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
+ listener.lineEnd();
+ }
+ function d3_geo_streamPolygon(coordinates, listener) {
+ var i = -1, n = coordinates.length;
+ listener.polygonStart();
+ while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
+ listener.polygonEnd();
+ }
+ d3.geo.area = function(object) {
+ d3_geo_areaSum = 0;
+ d3.geo.stream(object, d3_geo_area);
+ return d3_geo_areaSum;
+ };
+ var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder();
+ var d3_geo_area = {
+ sphere: function() {
+ d3_geo_areaSum += 4 * π;
+ },
+ point: d3_noop,
+ lineStart: d3_noop,
+ lineEnd: d3_noop,
+ polygonStart: function() {
+ d3_geo_areaRingSum.reset();
+ d3_geo_area.lineStart = d3_geo_areaRingStart;
+ },
+ polygonEnd: function() {
+ var area = 2 * d3_geo_areaRingSum;
+ d3_geo_areaSum += area < 0 ? 4 * π + area : area;
+ d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
+ }
+ };
+ function d3_geo_areaRingStart() {
+ var λ00, φ00, λ0, cosφ0, sinφ0;
+ d3_geo_area.point = function(λ, φ) {
+ d3_geo_area.point = nextPoint;
+ λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4),
+ sinφ0 = Math.sin(φ);
+ };
+ function nextPoint(λ, φ) {
+ λ *= d3_radians;
+ φ = φ * d3_radians / 2 + π / 4;
+ var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ);
+ d3_geo_areaRingSum.add(Math.atan2(v, u));
+ λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
+ }
+ d3_geo_area.lineEnd = function() {
+ nextPoint(λ00, φ00);
+ };
+ }
+ function d3_geo_cartesian(spherical) {
+ var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ);
+ return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ];
+ }
+ function d3_geo_cartesianDot(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+ }
+ function d3_geo_cartesianCross(a, b) {
+ return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ];
+ }
+ function d3_geo_cartesianAdd(a, b) {
+ a[0] += b[0];
+ a[1] += b[1];
+ a[2] += b[2];
+ }
+ function d3_geo_cartesianScale(vector, k) {
+ return [ vector[0] * k, vector[1] * k, vector[2] * k ];
+ }
+ function d3_geo_cartesianNormalize(d) {
+ var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+ d[0] /= l;
+ d[1] /= l;
+ d[2] /= l;
+ }
+ function d3_geo_spherical(cartesian) {
+ return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ];
+ }
+ function d3_geo_sphericalEqual(a, b) {
+ return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
+ }
+ d3.geo.bounds = function() {
+ var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range;
+ var bound = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ bound.point = ringPoint;
+ bound.lineStart = ringStart;
+ bound.lineEnd = ringEnd;
+ dλSum = 0;
+ d3_geo_area.polygonStart();
+ },
+ polygonEnd: function() {
+ d3_geo_area.polygonEnd();
+ bound.point = point;
+ bound.lineStart = lineStart;
+ bound.lineEnd = lineEnd;
+ if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90;
+ range[0] = λ0, range[1] = λ1;
+ }
+ };
+ function point(λ, φ) {
+ ranges.push(range = [ λ0 = λ, λ1 = λ ]);
+ if (φ < φ0) φ0 = φ;
+ if (φ > φ1) φ1 = φ;
+ }
+ function linePoint(λ, φ) {
+ var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]);
+ if (p0) {
+ var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal);
+ d3_geo_cartesianNormalize(inflection);
+ inflection = d3_geo_spherical(inflection);
+ var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180;
+ if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+ var φi = inflection[1] * d3_degrees;
+ if (φi > φ1) φ1 = φi;
+ } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+ var φi = -inflection[1] * d3_degrees;
+ if (φi < φ0) φ0 = φi;
+ } else {
+ if (φ < φ0) φ0 = φ;
+ if (φ > φ1) φ1 = φ;
+ }
+ if (antimeridian) {
+ if (λ < λ_) {
+ if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+ } else {
+ if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+ }
+ } else {
+ if (λ1 >= λ0) {
+ if (λ < λ0) λ0 = λ;
+ if (λ > λ1) λ1 = λ;
+ } else {
+ if (λ > λ_) {
+ if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+ } else {
+ if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+ }
+ }
+ }
+ } else {
+ point(λ, φ);
+ }
+ p0 = p, λ_ = λ;
+ }
+ function lineStart() {
+ bound.point = linePoint;
+ }
+ function lineEnd() {
+ range[0] = λ0, range[1] = λ1;
+ bound.point = point;
+ p0 = null;
+ }
+ function ringPoint(λ, φ) {
+ if (p0) {
+ var dλ = λ - λ_;
+ dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
+ } else λ__ = λ, φ__ = φ;
+ d3_geo_area.point(λ, φ);
+ linePoint(λ, φ);
+ }
+ function ringStart() {
+ d3_geo_area.lineStart();
+ }
+ function ringEnd() {
+ ringPoint(λ__, φ__);
+ d3_geo_area.lineEnd();
+ if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
+ range[0] = λ0, range[1] = λ1;
+ p0 = null;
+ }
+ function angle(λ0, λ1) {
+ return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1;
+ }
+ function compareRanges(a, b) {
+ return a[0] - b[0];
+ }
+ function withinRange(x, range) {
+ return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+ }
+ return function(feature) {
+ φ1 = λ1 = -(λ0 = φ0 = Infinity);
+ ranges = [];
+ d3.geo.stream(feature, bound);
+ var n = ranges.length;
+ if (n) {
+ ranges.sort(compareRanges);
+ for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) {
+ b = ranges[i];
+ if (withinRange(b[0], a) || withinRange(b[1], a)) {
+ if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+ if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+ } else {
+ merged.push(a = b);
+ }
+ }
+ var best = -Infinity, dλ;
+ for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
+ b = merged[i];
+ if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
+ }
+ }
+ ranges = range = null;
+ return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ];
+ };
+ }();
+ d3.geo.centroid = function(object) {
+ d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+ d3.geo.stream(object, d3_geo_centroid);
+ var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z;
+ if (m < ε2) {
+ x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
+ if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
+ m = x * x + y * y + z * z;
+ if (m < ε2) return [ NaN, NaN ];
+ }
+ return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ];
+ };
+ var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2;
+ var d3_geo_centroid = {
+ sphere: d3_noop,
+ point: d3_geo_centroidPoint,
+ lineStart: d3_geo_centroidLineStart,
+ lineEnd: d3_geo_centroidLineEnd,
+ polygonStart: function() {
+ d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
+ },
+ polygonEnd: function() {
+ d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
+ }
+ };
+ function d3_geo_centroidPoint(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians);
+ d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
+ }
+ function d3_geo_centroidPointXYZ(x, y, z) {
+ ++d3_geo_centroidW0;
+ d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
+ d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
+ d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
+ }
+ function d3_geo_centroidLineStart() {
+ var x0, y0, z0;
+ d3_geo_centroid.point = function(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians);
+ x0 = cosφ * Math.cos(λ);
+ y0 = cosφ * Math.sin(λ);
+ z0 = Math.sin(φ);
+ d3_geo_centroid.point = nextPoint;
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ };
+ function nextPoint(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
+ d3_geo_centroidW1 += w;
+ d3_geo_centroidX1 += w * (x0 + (x0 = x));
+ d3_geo_centroidY1 += w * (y0 + (y0 = y));
+ d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ }
+ }
+ function d3_geo_centroidLineEnd() {
+ d3_geo_centroid.point = d3_geo_centroidPoint;
+ }
+ function d3_geo_centroidRingStart() {
+ var λ00, φ00, x0, y0, z0;
+ d3_geo_centroid.point = function(λ, φ) {
+ λ00 = λ, φ00 = φ;
+ d3_geo_centroid.point = nextPoint;
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians);
+ x0 = cosφ * Math.cos(λ);
+ y0 = cosφ * Math.sin(λ);
+ z0 = Math.sin(φ);
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ };
+ d3_geo_centroid.lineEnd = function() {
+ nextPoint(λ00, φ00);
+ d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
+ d3_geo_centroid.point = d3_geo_centroidPoint;
+ };
+ function nextPoint(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u);
+ d3_geo_centroidX2 += v * cx;
+ d3_geo_centroidY2 += v * cy;
+ d3_geo_centroidZ2 += v * cz;
+ d3_geo_centroidW1 += w;
+ d3_geo_centroidX1 += w * (x0 + (x0 = x));
+ d3_geo_centroidY1 += w * (y0 + (y0 = y));
+ d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ }
+ }
+ function d3_geo_compose(a, b) {
+ function compose(x, y) {
+ return x = a(x, y), b(x[0], x[1]);
+ }
+ if (a.invert && b.invert) compose.invert = function(x, y) {
+ return x = b.invert(x, y), x && a.invert(x[0], x[1]);
+ };
+ return compose;
+ }
+ function d3_true() {
+ return true;
+ }
+ function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
+ var subject = [], clip = [];
+ segments.forEach(function(segment) {
+ if ((n = segment.length - 1) <= 0) return;
+ var n, p0 = segment[0], p1 = segment[n];
+ if (d3_geo_sphericalEqual(p0, p1)) {
+ listener.lineStart();
+ for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
+ listener.lineEnd();
+ return;
+ }
+ var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
+ a.o = b;
+ subject.push(a);
+ clip.push(b);
+ a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
+ b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
+ a.o = b;
+ subject.push(a);
+ clip.push(b);
+ });
+ clip.sort(compare);
+ d3_geo_clipPolygonLinkCircular(subject);
+ d3_geo_clipPolygonLinkCircular(clip);
+ if (!subject.length) return;
+ for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
+ clip[i].e = entry = !entry;
+ }
+ var start = subject[0], points, point;
+ while (1) {
+ var current = start, isSubject = true;
+ while (current.v) if ((current = current.n) === start) return;
+ points = current.z;
+ listener.lineStart();
+ do {
+ current.v = current.o.v = true;
+ if (current.e) {
+ if (isSubject) {
+ for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
+ } else {
+ interpolate(current.x, current.n.x, 1, listener);
+ }
+ current = current.n;
+ } else {
+ if (isSubject) {
+ points = current.p.z;
+ for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
+ } else {
+ interpolate(current.x, current.p.x, -1, listener);
+ }
+ current = current.p;
+ }
+ current = current.o;
+ points = current.z;
+ isSubject = !isSubject;
+ } while (!current.v);
+ listener.lineEnd();
+ }
+ }
+ function d3_geo_clipPolygonLinkCircular(array) {
+ if (!(n = array.length)) return;
+ var n, i = 0, a = array[0], b;
+ while (++i < n) {
+ a.n = b = array[i];
+ b.p = a;
+ a = b;
+ }
+ a.n = b = array[0];
+ b.p = a;
+ }
+ function d3_geo_clipPolygonIntersection(point, points, other, entry) {
+ this.x = point;
+ this.z = points;
+ this.o = other;
+ this.e = entry;
+ this.v = false;
+ this.n = this.p = null;
+ }
+ function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
+ return function(rotate, listener) {
+ var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
+ var clip = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ clip.point = pointRing;
+ clip.lineStart = ringStart;
+ clip.lineEnd = ringEnd;
+ segments = [];
+ polygon = [];
+ },
+ polygonEnd: function() {
+ clip.point = point;
+ clip.lineStart = lineStart;
+ clip.lineEnd = lineEnd;
+ segments = d3.merge(segments);
+ var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
+ if (segments.length) {
+ if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+ d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
+ } else if (clipStartInside) {
+ if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+ listener.lineStart();
+ interpolate(null, null, 1, listener);
+ listener.lineEnd();
+ }
+ if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
+ segments = polygon = null;
+ },
+ sphere: function() {
+ listener.polygonStart();
+ listener.lineStart();
+ interpolate(null, null, 1, listener);
+ listener.lineEnd();
+ listener.polygonEnd();
+ }
+ };
+ function point(λ, φ) {
+ var point = rotate(λ, φ);
+ if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
+ }
+ function pointLine(λ, φ) {
+ var point = rotate(λ, φ);
+ line.point(point[0], point[1]);
+ }
+ function lineStart() {
+ clip.point = pointLine;
+ line.lineStart();
+ }
+ function lineEnd() {
+ clip.point = point;
+ line.lineEnd();
+ }
+ var segments;
+ var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring;
+ function pointRing(λ, φ) {
+ ring.push([ λ, φ ]);
+ var point = rotate(λ, φ);
+ ringListener.point(point[0], point[1]);
+ }
+ function ringStart() {
+ ringListener.lineStart();
+ ring = [];
+ }
+ function ringEnd() {
+ pointRing(ring[0][0], ring[0][1]);
+ ringListener.lineEnd();
+ var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length;
+ ring.pop();
+ polygon.push(ring);
+ ring = null;
+ if (!n) return;
+ if (clean & 1) {
+ segment = ringSegments[0];
+ var n = segment.length - 1, i = -1, point;
+ if (n > 0) {
+ if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+ listener.lineStart();
+ while (++i < n) listener.point((point = segment[i])[0], point[1]);
+ listener.lineEnd();
+ }
+ return;
+ }
+ if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+ segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
+ }
+ return clip;
+ };
+ }
+ function d3_geo_clipSegmentLength1(segment) {
+ return segment.length > 1;
+ }
+ function d3_geo_clipBufferListener() {
+ var lines = [], line;
+ return {
+ lineStart: function() {
+ lines.push(line = []);
+ },
+ point: function(λ, φ) {
+ line.push([ λ, φ ]);
+ },
+ lineEnd: d3_noop,
+ buffer: function() {
+ var buffer = lines;
+ lines = [];
+ line = null;
+ return buffer;
+ },
+ rejoin: function() {
+ if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+ }
+ };
+ }
+ function d3_geo_clipSort(a, b) {
+ return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
+ }
+ var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, [ -π, -π / 2 ]);
+ function d3_geo_clipAntimeridianLine(listener) {
+ var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean;
+ return {
+ lineStart: function() {
+ listener.lineStart();
+ clean = 1;
+ },
+ point: function(λ1, φ1) {
+ var sλ1 = λ1 > 0 ? π : -π, dλ = abs(λ1 - λ0);
+ if (abs(dλ - π) < ε) {
+ listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
+ listener.point(sλ0, φ0);
+ listener.lineEnd();
+ listener.lineStart();
+ listener.point(sλ1, φ0);
+ listener.point(λ1, φ0);
+ clean = 0;
+ } else if (sλ0 !== sλ1 && dλ >= π) {
+ if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
+ if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
+ φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
+ listener.point(sλ0, φ0);
+ listener.lineEnd();
+ listener.lineStart();
+ listener.point(sλ1, φ0);
+ clean = 0;
+ }
+ listener.point(λ0 = λ1, φ0 = φ1);
+ sλ0 = sλ1;
+ },
+ lineEnd: function() {
+ listener.lineEnd();
+ λ0 = φ0 = NaN;
+ },
+ clean: function() {
+ return 2 - clean;
+ }
+ };
+ }
+ function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
+ var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1);
+ return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2;
+ }
+ function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
+ var φ;
+ if (from == null) {
+ φ = direction * halfπ;
+ listener.point(-π, φ);
+ listener.point(0, φ);
+ listener.point(π, φ);
+ listener.point(π, 0);
+ listener.point(π, -φ);
+ listener.point(0, -φ);
+ listener.point(-π, -φ);
+ listener.point(-π, 0);
+ listener.point(-π, φ);
+ } else if (abs(from[0] - to[0]) > ε) {
+ var s = from[0] < to[0] ? π : -π;
+ φ = direction * s / 2;
+ listener.point(-s, φ);
+ listener.point(0, φ);
+ listener.point(s, φ);
+ } else {
+ listener.point(to[0], to[1]);
+ }
+ }
+ function d3_geo_pointInPolygon(point, polygon) {
+ var meridian = point[0], parallel = point[1], meridianNormal = [ Math.sin(meridian), -Math.cos(meridian), 0 ], polarAngle = 0, winding = 0;
+ d3_geo_areaRingSum.reset();
+ for (var i = 0, n = polygon.length; i < n; ++i) {
+ var ring = polygon[i], m = ring.length;
+ if (!m) continue;
+ var point0 = ring[0], λ0 = point0[0], φ0 = point0[1] / 2 + π / 4, sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), j = 1;
+ while (true) {
+ if (j === m) j = 0;
+ point = ring[j];
+ var λ = point[0], φ = point[1] / 2 + π / 4, sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, antimeridian = adλ > π, k = sinφ0 * sinφ;
+ d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ)));
+ polarAngle += antimeridian ? dλ + sdλ * τ : dλ;
+ if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
+ var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
+ d3_geo_cartesianNormalize(arc);
+ var intersection = d3_geo_cartesianCross(meridianNormal, arc);
+ d3_geo_cartesianNormalize(intersection);
+ var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
+ if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) {
+ winding += antimeridian ^ dλ >= 0 ? 1 : -1;
+ }
+ }
+ if (!j++) break;
+ λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
+ }
+ }
+ return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < 0) ^ winding & 1;
+ }
+ function d3_geo_clipCircle(radius) {
+ var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
+ return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]);
+ function visible(λ, φ) {
+ return Math.cos(λ) * Math.cos(φ) > cr;
+ }
+ function clipLine(listener) {
+ var point0, c0, v0, v00, clean;
+ return {
+ lineStart: function() {
+ v00 = v0 = false;
+ clean = 1;
+ },
+ point: function(λ, φ) {
+ var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
+ if (!point0 && (v00 = v0 = v)) listener.lineStart();
+ if (v !== v0) {
+ point2 = intersect(point0, point1);
+ if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
+ point1[0] += ε;
+ point1[1] += ε;
+ v = visible(point1[0], point1[1]);
+ }
+ }
+ if (v !== v0) {
+ clean = 0;
+ if (v) {
+ listener.lineStart();
+ point2 = intersect(point1, point0);
+ listener.point(point2[0], point2[1]);
+ } else {
+ point2 = intersect(point0, point1);
+ listener.point(point2[0], point2[1]);
+ listener.lineEnd();
+ }
+ point0 = point2;
+ } else if (notHemisphere && point0 && smallRadius ^ v) {
+ var t;
+ if (!(c & c0) && (t = intersect(point1, point0, true))) {
+ clean = 0;
+ if (smallRadius) {
+ listener.lineStart();
+ listener.point(t[0][0], t[0][1]);
+ listener.point(t[1][0], t[1][1]);
+ listener.lineEnd();
+ } else {
+ listener.point(t[1][0], t[1][1]);
+ listener.lineEnd();
+ listener.lineStart();
+ listener.point(t[0][0], t[0][1]);
+ }
+ }
+ }
+ if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
+ listener.point(point1[0], point1[1]);
+ }
+ point0 = point1, v0 = v, c0 = c;
+ },
+ lineEnd: function() {
+ if (v0) listener.lineEnd();
+ point0 = null;
+ },
+ clean: function() {
+ return clean | (v00 && v0) << 1;
+ }
+ };
+ }
+ function intersect(a, b, two) {
+ var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b);
+ var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
+ if (!determinant) return !two && a;
+ var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2);
+ d3_geo_cartesianAdd(A, B);
+ var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
+ if (t2 < 0) return;
+ var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu);
+ d3_geo_cartesianAdd(q, A);
+ q = d3_geo_spherical(q);
+ if (!two) return q;
+ var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z;
+ if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
+ var δλ = λ1 - λ0, polar = abs(δλ - π) < ε, meridian = polar || δλ < ε;
+ if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
+ if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
+ var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
+ d3_geo_cartesianAdd(q1, A);
+ return [ q, d3_geo_spherical(q1) ];
+ }
+ }
+ function code(λ, φ) {
+ var r = smallRadius ? radius : π - radius, code = 0;
+ if (λ < -r) code |= 1; else if (λ > r) code |= 2;
+ if (φ < -r) code |= 4; else if (φ > r) code |= 8;
+ return code;
+ }
+ }
+ function d3_geom_clipLine(x0, y0, x1, y1) {
+ return function(line) {
+ var a = line.a, b = line.b, ax = a.x, ay = a.y, bx = b.x, by = b.y, t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r;
+ r = x0 - ax;
+ if (!dx && r > 0) return;
+ r /= dx;
+ if (dx < 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ } else if (dx > 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ }
+ r = x1 - ax;
+ if (!dx && r < 0) return;
+ r /= dx;
+ if (dx < 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ } else if (dx > 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ }
+ r = y0 - ay;
+ if (!dy && r > 0) return;
+ r /= dy;
+ if (dy < 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ } else if (dy > 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ }
+ r = y1 - ay;
+ if (!dy && r < 0) return;
+ r /= dy;
+ if (dy < 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ } else if (dy > 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ }
+ if (t0 > 0) line.a = {
+ x: ax + t0 * dx,
+ y: ay + t0 * dy
+ };
+ if (t1 < 1) line.b = {
+ x: ax + t1 * dx,
+ y: ay + t1 * dy
+ };
+ return line;
+ };
+ }
+ var d3_geo_clipExtentMAX = 1e9;
+ d3.geo.clipExtent = function() {
+ var x0, y0, x1, y1, stream, clip, clipExtent = {
+ stream: function(output) {
+ if (stream) stream.valid = false;
+ stream = clip(output);
+ stream.valid = true;
+ return stream;
+ },
+ extent: function(_) {
+ if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
+ clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
+ if (stream) stream.valid = false, stream = null;
+ return clipExtent;
+ }
+ };
+ return clipExtent.extent([ [ 0, 0 ], [ 960, 500 ] ]);
+ };
+ function d3_geo_clipExtent(x0, y0, x1, y1) {
+ return function(listener) {
+ var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring;
+ var clip = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ listener = bufferListener;
+ segments = [];
+ polygon = [];
+ clean = true;
+ },
+ polygonEnd: function() {
+ listener = listener_;
+ segments = d3.merge(segments);
+ var clipStartInside = insidePolygon([ x0, y1 ]), inside = clean && clipStartInside, visible = segments.length;
+ if (inside || visible) {
+ listener.polygonStart();
+ if (inside) {
+ listener.lineStart();
+ interpolate(null, null, 1, listener);
+ listener.lineEnd();
+ }
+ if (visible) {
+ d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
+ }
+ listener.polygonEnd();
+ }
+ segments = polygon = ring = null;
+ }
+ };
+ function insidePolygon(p) {
+ var wn = 0, n = polygon.length, y = p[1];
+ for (var i = 0; i < n; ++i) {
+ for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
+ b = v[j];
+ if (a[1] <= y) {
+ if (b[1] > y && d3_cross2d(a, b, p) > 0) ++wn;
+ } else {
+ if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
+ }
+ a = b;
+ }
+ }
+ return wn !== 0;
+ }
+ function interpolate(from, to, direction, listener) {
+ var a = 0, a1 = 0;
+ if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) {
+ do {
+ listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
+ } while ((a = (a + direction + 4) % 4) !== a1);
+ } else {
+ listener.point(to[0], to[1]);
+ }
+ }
+ function pointVisible(x, y) {
+ return x0 <= x && x <= x1 && y0 <= y && y <= y1;
+ }
+ function point(x, y) {
+ if (pointVisible(x, y)) listener.point(x, y);
+ }
+ var x__, y__, v__, x_, y_, v_, first, clean;
+ function lineStart() {
+ clip.point = linePoint;
+ if (polygon) polygon.push(ring = []);
+ first = true;
+ v_ = false;
+ x_ = y_ = NaN;
+ }
+ function lineEnd() {
+ if (segments) {
+ linePoint(x__, y__);
+ if (v__ && v_) bufferListener.rejoin();
+ segments.push(bufferListener.buffer());
+ }
+ clip.point = point;
+ if (v_) listener.lineEnd();
+ }
+ function linePoint(x, y) {
+ x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
+ y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
+ var v = pointVisible(x, y);
+ if (polygon) ring.push([ x, y ]);
+ if (first) {
+ x__ = x, y__ = y, v__ = v;
+ first = false;
+ if (v) {
+ listener.lineStart();
+ listener.point(x, y);
+ }
+ } else {
+ if (v && v_) listener.point(x, y); else {
+ var l = {
+ a: {
+ x: x_,
+ y: y_
+ },
+ b: {
+ x: x,
+ y: y
+ }
+ };
+ if (clipLine(l)) {
+ if (!v_) {
+ listener.lineStart();
+ listener.point(l.a.x, l.a.y);
+ }
+ listener.point(l.b.x, l.b.y);
+ if (!v) listener.lineEnd();
+ clean = false;
+ } else if (v) {
+ listener.lineStart();
+ listener.point(x, y);
+ clean = false;
+ }
+ }
+ }
+ x_ = x, y_ = y, v_ = v;
+ }
+ return clip;
+ };
+ function corner(p, direction) {
+ return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
+ }
+ function compare(a, b) {
+ return comparePoints(a.x, b.x);
+ }
+ function comparePoints(a, b) {
+ var ca = corner(a, 1), cb = corner(b, 1);
+ return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0];
+ }
+ }
+ function d3_geo_conic(projectAt) {
+ var φ0 = 0, φ1 = π / 3, m = d3_geo_projectionMutator(projectAt), p = m(φ0, φ1);
+ p.parallels = function(_) {
+ if (!arguments.length) return [ φ0 / π * 180, φ1 / π * 180 ];
+ return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
+ };
+ return p;
+ }
+ function d3_geo_conicEqualArea(φ0, φ1) {
+ var sinφ0 = Math.sin(φ0), n = (sinφ0 + Math.sin(φ1)) / 2, C = 1 + sinφ0 * (2 * n - sinφ0), ρ0 = Math.sqrt(C) / n;
+ function forward(λ, φ) {
+ var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
+ return [ ρ * Math.sin(λ *= n), ρ0 - ρ * Math.cos(λ) ];
+ }
+ forward.invert = function(x, y) {
+ var ρ0_y = ρ0 - y;
+ return [ Math.atan2(x, ρ0_y) / n, d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) ];
+ };
+ return forward;
+ }
+ (d3.geo.conicEqualArea = function() {
+ return d3_geo_conic(d3_geo_conicEqualArea);
+ }).raw = d3_geo_conicEqualArea;
+ d3.geo.albers = function() {
+ return d3.geo.conicEqualArea().rotate([ 96, 0 ]).center([ -.6, 38.7 ]).parallels([ 29.5, 45.5 ]).scale(1070);
+ };
+ d3.geo.albersUsa = function() {
+ var lower48 = d3.geo.albers();
+ var alaska = d3.geo.conicEqualArea().rotate([ 154, 0 ]).center([ -2, 58.5 ]).parallels([ 55, 65 ]);
+ var hawaii = d3.geo.conicEqualArea().rotate([ 157, 0 ]).center([ -3, 19.9 ]).parallels([ 8, 18 ]);
+ var point, pointStream = {
+ point: function(x, y) {
+ point = [ x, y ];
+ }
+ }, lower48Point, alaskaPoint, hawaiiPoint;
+ function albersUsa(coordinates) {
+ var x = coordinates[0], y = coordinates[1];
+ point = null;
+ (lower48Point(x, y), point) || (alaskaPoint(x, y), point) || hawaiiPoint(x, y);
+ return point;
+ }
+ albersUsa.invert = function(coordinates) {
+ var k = lower48.scale(), t = lower48.translate(), x = (coordinates[0] - t[0]) / k, y = (coordinates[1] - t[1]) / k;
+ return (y >= .12 && y < .234 && x >= -.425 && x < -.214 ? alaska : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii : lower48).invert(coordinates);
+ };
+ albersUsa.stream = function(stream) {
+ var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
+ return {
+ point: function(x, y) {
+ lower48Stream.point(x, y);
+ alaskaStream.point(x, y);
+ hawaiiStream.point(x, y);
+ },
+ sphere: function() {
+ lower48Stream.sphere();
+ alaskaStream.sphere();
+ hawaiiStream.sphere();
+ },
+ lineStart: function() {
+ lower48Stream.lineStart();
+ alaskaStream.lineStart();
+ hawaiiStream.lineStart();
+ },
+ lineEnd: function() {
+ lower48Stream.lineEnd();
+ alaskaStream.lineEnd();
+ hawaiiStream.lineEnd();
+ },
+ polygonStart: function() {
+ lower48Stream.polygonStart();
+ alaskaStream.polygonStart();
+ hawaiiStream.polygonStart();
+ },
+ polygonEnd: function() {
+ lower48Stream.polygonEnd();
+ alaskaStream.polygonEnd();
+ hawaiiStream.polygonEnd();
+ }
+ };
+ };
+ albersUsa.precision = function(_) {
+ if (!arguments.length) return lower48.precision();
+ lower48.precision(_);
+ alaska.precision(_);
+ hawaii.precision(_);
+ return albersUsa;
+ };
+ albersUsa.scale = function(_) {
+ if (!arguments.length) return lower48.scale();
+ lower48.scale(_);
+ alaska.scale(_ * .35);
+ hawaii.scale(_);
+ return albersUsa.translate(lower48.translate());
+ };
+ albersUsa.translate = function(_) {
+ if (!arguments.length) return lower48.translate();
+ var k = lower48.scale(), x = +_[0], y = +_[1];
+ lower48Point = lower48.translate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
+ alaskaPoint = alaska.translate([ x - .307 * k, y + .201 * k ]).clipExtent([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
+ hawaiiPoint = hawaii.translate([ x - .205 * k, y + .212 * k ]).clipExtent([ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
+ return albersUsa;
+ };
+ return albersUsa.scale(1070);
+ };
+ var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
+ point: d3_noop,
+ lineStart: d3_noop,
+ lineEnd: d3_noop,
+ polygonStart: function() {
+ d3_geo_pathAreaPolygon = 0;
+ d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
+ },
+ polygonEnd: function() {
+ d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
+ d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
+ }
+ };
+ function d3_geo_pathAreaRingStart() {
+ var x00, y00, x0, y0;
+ d3_geo_pathArea.point = function(x, y) {
+ d3_geo_pathArea.point = nextPoint;
+ x00 = x0 = x, y00 = y0 = y;
+ };
+ function nextPoint(x, y) {
+ d3_geo_pathAreaPolygon += y0 * x - x0 * y;
+ x0 = x, y0 = y;
+ }
+ d3_geo_pathArea.lineEnd = function() {
+ nextPoint(x00, y00);
+ };
+ }
+ var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
+ var d3_geo_pathBounds = {
+ point: d3_geo_pathBoundsPoint,
+ lineStart: d3_noop,
+ lineEnd: d3_noop,
+ polygonStart: d3_noop,
+ polygonEnd: d3_noop
+ };
+ function d3_geo_pathBoundsPoint(x, y) {
+ if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
+ if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
+ if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
+ if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
+ }
+ function d3_geo_pathBuffer() {
+ var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
+ var stream = {
+ point: point,
+ lineStart: function() {
+ stream.point = pointLineStart;
+ },
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ stream.lineEnd = lineEndPolygon;
+ },
+ polygonEnd: function() {
+ stream.lineEnd = lineEnd;
+ stream.point = point;
+ },
+ pointRadius: function(_) {
+ pointCircle = d3_geo_pathBufferCircle(_);
+ return stream;
+ },
+ result: function() {
+ if (buffer.length) {
+ var result = buffer.join("");
+ buffer = [];
+ return result;
+ }
+ }
+ };
+ function point(x, y) {
+ buffer.push("M", x, ",", y, pointCircle);
+ }
+ function pointLineStart(x, y) {
+ buffer.push("M", x, ",", y);
+ stream.point = pointLine;
+ }
+ function pointLine(x, y) {
+ buffer.push("L", x, ",", y);
+ }
+ function lineEnd() {
+ stream.point = point;
+ }
+ function lineEndPolygon() {
+ buffer.push("Z");
+ }
+ return stream;
+ }
+ function d3_geo_pathBufferCircle(radius) {
+ return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z";
+ }
+ var d3_geo_pathCentroid = {
+ point: d3_geo_pathCentroidPoint,
+ lineStart: d3_geo_pathCentroidLineStart,
+ lineEnd: d3_geo_pathCentroidLineEnd,
+ polygonStart: function() {
+ d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
+ },
+ polygonEnd: function() {
+ d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+ d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
+ d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
+ }
+ };
+ function d3_geo_pathCentroidPoint(x, y) {
+ d3_geo_centroidX0 += x;
+ d3_geo_centroidY0 += y;
+ ++d3_geo_centroidZ0;
+ }
+ function d3_geo_pathCentroidLineStart() {
+ var x0, y0;
+ d3_geo_pathCentroid.point = function(x, y) {
+ d3_geo_pathCentroid.point = nextPoint;
+ d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+ };
+ function nextPoint(x, y) {
+ var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+ d3_geo_centroidX1 += z * (x0 + x) / 2;
+ d3_geo_centroidY1 += z * (y0 + y) / 2;
+ d3_geo_centroidZ1 += z;
+ d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+ }
+ }
+ function d3_geo_pathCentroidLineEnd() {
+ d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+ }
+ function d3_geo_pathCentroidRingStart() {
+ var x00, y00, x0, y0;
+ d3_geo_pathCentroid.point = function(x, y) {
+ d3_geo_pathCentroid.point = nextPoint;
+ d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
+ };
+ function nextPoint(x, y) {
+ var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+ d3_geo_centroidX1 += z * (x0 + x) / 2;
+ d3_geo_centroidY1 += z * (y0 + y) / 2;
+ d3_geo_centroidZ1 += z;
+ z = y0 * x - x0 * y;
+ d3_geo_centroidX2 += z * (x0 + x);
+ d3_geo_centroidY2 += z * (y0 + y);
+ d3_geo_centroidZ2 += z * 3;
+ d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+ }
+ d3_geo_pathCentroid.lineEnd = function() {
+ nextPoint(x00, y00);
+ };
+ }
+ function d3_geo_pathContext(context) {
+ var pointRadius = 4.5;
+ var stream = {
+ point: point,
+ lineStart: function() {
+ stream.point = pointLineStart;
+ },
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ stream.lineEnd = lineEndPolygon;
+ },
+ polygonEnd: function() {
+ stream.lineEnd = lineEnd;
+ stream.point = point;
+ },
+ pointRadius: function(_) {
+ pointRadius = _;
+ return stream;
+ },
+ result: d3_noop
+ };
+ function point(x, y) {
+ context.moveTo(x + pointRadius, y);
+ context.arc(x, y, pointRadius, 0, τ);
+ }
+ function pointLineStart(x, y) {
+ context.moveTo(x, y);
+ stream.point = pointLine;
+ }
+ function pointLine(x, y) {
+ context.lineTo(x, y);
+ }
+ function lineEnd() {
+ stream.point = point;
+ }
+ function lineEndPolygon() {
+ context.closePath();
+ }
+ return stream;
+ }
+ function d3_geo_resample(project) {
+ var δ2 = .5, cosMinDistance = Math.cos(30 * d3_radians), maxDepth = 16;
+ function resample(stream) {
+ return (maxDepth ? resampleRecursive : resampleNone)(stream);
+ }
+ function resampleNone(stream) {
+ return d3_geo_transformPoint(stream, function(x, y) {
+ x = project(x, y);
+ stream.point(x[0], x[1]);
+ });
+ }
+ function resampleRecursive(stream) {
+ var λ00, φ00, x00, y00, a00, b00, c00, λ0, x0, y0, a0, b0, c0;
+ var resample = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ stream.polygonStart();
+ resample.lineStart = ringStart;
+ },
+ polygonEnd: function() {
+ stream.polygonEnd();
+ resample.lineStart = lineStart;
+ }
+ };
+ function point(x, y) {
+ x = project(x, y);
+ stream.point(x[0], x[1]);
+ }
+ function lineStart() {
+ x0 = NaN;
+ resample.point = linePoint;
+ stream.lineStart();
+ }
+ function linePoint(λ, φ) {
+ var c = d3_geo_cartesian([ λ, φ ]), p = project(λ, φ);
+ resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+ stream.point(x0, y0);
+ }
+ function lineEnd() {
+ resample.point = point;
+ stream.lineEnd();
+ }
+ function ringStart() {
+ lineStart();
+ resample.point = ringPoint;
+ resample.lineEnd = ringEnd;
+ }
+ function ringPoint(λ, φ) {
+ linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+ resample.point = linePoint;
+ }
+ function ringEnd() {
+ resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
+ resample.lineEnd = lineEnd;
+ lineEnd();
+ }
+ return resample;
+ }
+ function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
+ var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy;
+ if (d2 > 4 * δ2 && depth--) {
+ var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2;
+ if (dz * dz / d2 > δ2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+ resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
+ stream.point(x2, y2);
+ resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
+ }
+ }
+ }
+ resample.precision = function(_) {
+ if (!arguments.length) return Math.sqrt(δ2);
+ maxDepth = (δ2 = _ * _) > 0 && 16;
+ return resample;
+ };
+ return resample;
+ }
+ d3.geo.path = function() {
+ var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
+ function path(object) {
+ if (object) {
+ if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+ if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
+ d3.geo.stream(object, cacheStream);
+ }
+ return contextStream.result();
+ }
+ path.area = function(object) {
+ d3_geo_pathAreaSum = 0;
+ d3.geo.stream(object, projectStream(d3_geo_pathArea));
+ return d3_geo_pathAreaSum;
+ };
+ path.centroid = function(object) {
+ d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+ d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
+ return d3_geo_centroidZ2 ? [ d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2 ] : d3_geo_centroidZ1 ? [ d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1 ] : d3_geo_centroidZ0 ? [ d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0 ] : [ NaN, NaN ];
+ };
+ path.bounds = function(object) {
+ d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
+ d3.geo.stream(object, projectStream(d3_geo_pathBounds));
+ return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
+ };
+ path.projection = function(_) {
+ if (!arguments.length) return projection;
+ projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
+ return reset();
+ };
+ path.context = function(_) {
+ if (!arguments.length) return context;
+ contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
+ if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+ return reset();
+ };
+ path.pointRadius = function(_) {
+ if (!arguments.length) return pointRadius;
+ pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
+ return path;
+ };
+ function reset() {
+ cacheStream = null;
+ return path;
+ }
+ return path.projection(d3.geo.albersUsa()).context(null);
+ };
+ function d3_geo_pathProjectStream(project) {
+ var resample = d3_geo_resample(function(x, y) {
+ return project([ x * d3_degrees, y * d3_degrees ]);
+ });
+ return function(stream) {
+ return d3_geo_projectionRadians(resample(stream));
+ };
+ }
+ d3.geo.transform = function(methods) {
+ return {
+ stream: function(stream) {
+ var transform = new d3_geo_transform(stream);
+ for (var k in methods) transform[k] = methods[k];
+ return transform;
+ }
+ };
+ };
+ function d3_geo_transform(stream) {
+ this.stream = stream;
+ }
+ d3_geo_transform.prototype = {
+ point: function(x, y) {
+ this.stream.point(x, y);
+ },
+ sphere: function() {
+ this.stream.sphere();
+ },
+ lineStart: function() {
+ this.stream.lineStart();
+ },
+ lineEnd: function() {
+ this.stream.lineEnd();
+ },
+ polygonStart: function() {
+ this.stream.polygonStart();
+ },
+ polygonEnd: function() {
+ this.stream.polygonEnd();
+ }
+ };
+ function d3_geo_transformPoint(stream, point) {
+ return {
+ point: point,
+ sphere: function() {
+ stream.sphere();
+ },
+ lineStart: function() {
+ stream.lineStart();
+ },
+ lineEnd: function() {
+ stream.lineEnd();
+ },
+ polygonStart: function() {
+ stream.polygonStart();
+ },
+ polygonEnd: function() {
+ stream.polygonEnd();
+ }
+ };
+ }
+ d3.geo.projection = d3_geo_projection;
+ d3.geo.projectionMutator = d3_geo_projectionMutator;
+ function d3_geo_projection(project) {
+ return d3_geo_projectionMutator(function() {
+ return project;
+ })();
+ }
+ function d3_geo_projectionMutator(projectAt) {
+ var project, rotate, projectRotate, projectResample = d3_geo_resample(function(x, y) {
+ x = project(x, y);
+ return [ x[0] * k + δx, δy - x[1] * k ];
+ }), k = 150, x = 480, y = 250, λ = 0, φ = 0, δλ = 0, δφ = 0, δγ = 0, δx, δy, preclip = d3_geo_clipAntimeridian, postclip = d3_identity, clipAngle = null, clipExtent = null, stream;
+ function projection(point) {
+ point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
+ return [ point[0] * k + δx, δy - point[1] * k ];
+ }
+ function invert(point) {
+ point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
+ return point && [ point[0] * d3_degrees, point[1] * d3_degrees ];
+ }
+ projection.stream = function(output) {
+ if (stream) stream.valid = false;
+ stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output))));
+ stream.valid = true;
+ return stream;
+ };
+ projection.clipAngle = function(_) {
+ if (!arguments.length) return clipAngle;
+ preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
+ return invalidate();
+ };
+ projection.clipExtent = function(_) {
+ if (!arguments.length) return clipExtent;
+ clipExtent = _;
+ postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity;
+ return invalidate();
+ };
+ projection.scale = function(_) {
+ if (!arguments.length) return k;
+ k = +_;
+ return reset();
+ };
+ projection.translate = function(_) {
+ if (!arguments.length) return [ x, y ];
+ x = +_[0];
+ y = +_[1];
+ return reset();
+ };
+ projection.center = function(_) {
+ if (!arguments.length) return [ λ * d3_degrees, φ * d3_degrees ];
+ λ = _[0] % 360 * d3_radians;
+ φ = _[1] % 360 * d3_radians;
+ return reset();
+ };
+ projection.rotate = function(_) {
+ if (!arguments.length) return [ δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees ];
+ δλ = _[0] % 360 * d3_radians;
+ δφ = _[1] % 360 * d3_radians;
+ δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
+ return reset();
+ };
+ d3.rebind(projection, projectResample, "precision");
+ function reset() {
+ projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
+ var center = project(λ, φ);
+ δx = x - center[0] * k;
+ δy = y + center[1] * k;
+ return invalidate();
+ }
+ function invalidate() {
+ if (stream) stream.valid = false, stream = null;
+ return projection;
+ }
+ return function() {
+ project = projectAt.apply(this, arguments);
+ projection.invert = project.invert && invert;
+ return reset();
+ };
+ }
+ function d3_geo_projectionRadians(stream) {
+ return d3_geo_transformPoint(stream, function(x, y) {
+ stream.point(x * d3_radians, y * d3_radians);
+ });
+ }
+ function d3_geo_equirectangular(λ, φ) {
+ return [ λ, φ ];
+ }
+ (d3.geo.equirectangular = function() {
+ return d3_geo_projection(d3_geo_equirectangular);
+ }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;
+ d3.geo.rotation = function(rotate) {
+ rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
+ function forward(coordinates) {
+ coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+ return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+ }
+ forward.invert = function(coordinates) {
+ coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+ return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+ };
+ return forward;
+ };
+ function d3_geo_identityRotation(λ, φ) {
+ return [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
+ }
+ d3_geo_identityRotation.invert = d3_geo_equirectangular;
+ function d3_geo_rotation(δλ, δφ, δγ) {
+ return δλ ? δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ) : δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) : d3_geo_identityRotation;
+ }
+ function d3_geo_forwardRotationλ(δλ) {
+ return function(λ, φ) {
+ return λ += δλ, [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
+ };
+ }
+ function d3_geo_rotationλ(δλ) {
+ var rotation = d3_geo_forwardRotationλ(δλ);
+ rotation.invert = d3_geo_forwardRotationλ(-δλ);
+ return rotation;
+ }
+ function d3_geo_rotationφγ(δφ, δγ) {
+ var cosδφ = Math.cos(δφ), sinδφ = Math.sin(δφ), cosδγ = Math.cos(δγ), sinδγ = Math.sin(δγ);
+ function rotation(λ, φ) {
+ var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδφ + x * sinδφ;
+ return [ Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), d3_asin(k * cosδγ + y * sinδγ) ];
+ }
+ rotation.invert = function(λ, φ) {
+ var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδγ - y * sinδγ;
+ return [ Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), d3_asin(k * cosδφ - x * sinδφ) ];
+ };
+ return rotation;
+ }
+ d3.geo.circle = function() {
+ var origin = [ 0, 0 ], angle, precision = 6, interpolate;
+ function circle() {
+ var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, ring = [];
+ interpolate(null, null, 1, {
+ point: function(x, y) {
+ ring.push(x = rotate(x, y));
+ x[0] *= d3_degrees, x[1] *= d3_degrees;
+ }
+ });
+ return {
+ type: "Polygon",
+ coordinates: [ ring ]
+ };
+ }
+ circle.origin = function(x) {
+ if (!arguments.length) return origin;
+ origin = x;
+ return circle;
+ };
+ circle.angle = function(x) {
+ if (!arguments.length) return angle;
+ interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
+ return circle;
+ };
+ circle.precision = function(_) {
+ if (!arguments.length) return precision;
+ interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
+ return circle;
+ };
+ return circle.angle(90);
+ };
+ function d3_geo_circleInterpolate(radius, precision) {
+ var cr = Math.cos(radius), sr = Math.sin(radius);
+ return function(from, to, direction, listener) {
+ var step = direction * precision;
+ if (from != null) {
+ from = d3_geo_circleAngle(cr, from);
+ to = d3_geo_circleAngle(cr, to);
+ if (direction > 0 ? from < to : from > to) from += direction * τ;
+ } else {
+ from = radius + direction * τ;
+ to = radius - .5 * step;
+ }
+ for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) {
+ listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), -sr * Math.sin(t) ]))[0], point[1]);
+ }
+ };
+ }
+ function d3_geo_circleAngle(cr, point) {
+ var a = d3_geo_cartesian(point);
+ a[0] -= cr;
+ d3_geo_cartesianNormalize(a);
+ var angle = d3_acos(-a[1]);
+ return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
+ }
+ d3.geo.distance = function(a, b) {
+ var Δλ = (b[0] - a[0]) * d3_radians, φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians, sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ), sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1), t;
+ return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ);
+ };
+ d3.geo.graticule = function() {
+ var x1, x0, X1, X0, y1, y0, Y1, Y0, dx = 10, dy = dx, DX = 90, DY = 360, x, y, X, Y, precision = 2.5;
+ function graticule() {
+ return {
+ type: "MultiLineString",
+ coordinates: lines()
+ };
+ }
+ function lines() {
+ return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X).concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) {
+ return abs(x % DX) > ε;
+ }).map(x)).concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) {
+ return abs(y % DY) > ε;
+ }).map(y));
+ }
+ graticule.lines = function() {
+ return lines().map(function(coordinates) {
+ return {
+ type: "LineString",
+ coordinates: coordinates
+ };
+ });
+ };
+ graticule.outline = function() {
+ return {
+ type: "Polygon",
+ coordinates: [ X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1)) ]
+ };
+ };
+ graticule.extent = function(_) {
+ if (!arguments.length) return graticule.minorExtent();
+ return graticule.majorExtent(_).minorExtent(_);
+ };
+ graticule.majorExtent = function(_) {
+ if (!arguments.length) return [ [ X0, Y0 ], [ X1, Y1 ] ];
+ X0 = +_[0][0], X1 = +_[1][0];
+ Y0 = +_[0][1], Y1 = +_[1][1];
+ if (X0 > X1) _ = X0, X0 = X1, X1 = _;
+ if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
+ return graticule.precision(precision);
+ };
+ graticule.minorExtent = function(_) {
+ if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
+ x0 = +_[0][0], x1 = +_[1][0];
+ y0 = +_[0][1], y1 = +_[1][1];
+ if (x0 > x1) _ = x0, x0 = x1, x1 = _;
+ if (y0 > y1) _ = y0, y0 = y1, y1 = _;
+ return graticule.precision(precision);
+ };
+ graticule.step = function(_) {
+ if (!arguments.length) return graticule.minorStep();
+ return graticule.majorStep(_).minorStep(_);
+ };
+ graticule.majorStep = function(_) {
+ if (!arguments.length) return [ DX, DY ];
+ DX = +_[0], DY = +_[1];
+ return graticule;
+ };
+ graticule.minorStep = function(_) {
+ if (!arguments.length) return [ dx, dy ];
+ dx = +_[0], dy = +_[1];
+ return graticule;
+ };
+ graticule.precision = function(_) {
+ if (!arguments.length) return precision;
+ precision = +_;
+ x = d3_geo_graticuleX(y0, y1, 90);
+ y = d3_geo_graticuleY(x0, x1, precision);
+ X = d3_geo_graticuleX(Y0, Y1, 90);
+ Y = d3_geo_graticuleY(X0, X1, precision);
+ return graticule;
+ };
+ return graticule.majorExtent([ [ -180, -90 + ε ], [ 180, 90 - ε ] ]).minorExtent([ [ -180, -80 - ε ], [ 180, 80 + ε ] ]);
+ };
+ function d3_geo_graticuleX(y0, y1, dy) {
+ var y = d3.range(y0, y1 - ε, dy).concat(y1);
+ return function(x) {
+ return y.map(function(y) {
+ return [ x, y ];
+ });
+ };
+ }
+ function d3_geo_graticuleY(x0, x1, dx) {
+ var x = d3.range(x0, x1 - ε, dx).concat(x1);
+ return function(y) {
+ return x.map(function(x) {
+ return [ x, y ];
+ });
+ };
+ }
+ function d3_source(d) {
+ return d.source;
+ }
+ function d3_target(d) {
+ return d.target;
+ }
+ d3.geo.greatArc = function() {
+ var source = d3_source, source_, target = d3_target, target_;
+ function greatArc() {
+ return {
+ type: "LineString",
+ coordinates: [ source_ || source.apply(this, arguments), target_ || target.apply(this, arguments) ]
+ };
+ }
+ greatArc.distance = function() {
+ return d3.geo.distance(source_ || source.apply(this, arguments), target_ || target.apply(this, arguments));
+ };
+ greatArc.source = function(_) {
+ if (!arguments.length) return source;
+ source = _, source_ = typeof _ === "function" ? null : _;
+ return greatArc;
+ };
+ greatArc.target = function(_) {
+ if (!arguments.length) return target;
+ target = _, target_ = typeof _ === "function" ? null : _;
+ return greatArc;
+ };
+ greatArc.precision = function() {
+ return arguments.length ? greatArc : 0;
+ };
+ return greatArc;
+ };
+ d3.geo.interpolate = function(source, target) {
+ return d3_geo_interpolate(source[0] * d3_radians, source[1] * d3_radians, target[0] * d3_radians, target[1] * d3_radians);
+ };
+ function d3_geo_interpolate(x0, y0, x1, y1) {
+ var cy0 = Math.cos(y0), sy0 = Math.sin(y0), cy1 = Math.cos(y1), sy1 = Math.sin(y1), kx0 = cy0 * Math.cos(x0), ky0 = cy0 * Math.sin(x0), kx1 = cy1 * Math.cos(x1), ky1 = cy1 * Math.sin(x1), d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))), k = 1 / Math.sin(d);
+ var interpolate = d ? function(t) {
+ var B = Math.sin(t *= d) * k, A = Math.sin(d - t) * k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1, z = A * sy0 + B * sy1;
+ return [ Math.atan2(y, x) * d3_degrees, Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees ];
+ } : function() {
+ return [ x0 * d3_degrees, y0 * d3_degrees ];
+ };
+ interpolate.distance = d;
+ return interpolate;
+ }
+ d3.geo.length = function(object) {
+ d3_geo_lengthSum = 0;
+ d3.geo.stream(object, d3_geo_length);
+ return d3_geo_lengthSum;
+ };
+ var d3_geo_lengthSum;
+ var d3_geo_length = {
+ sphere: d3_noop,
+ point: d3_noop,
+ lineStart: d3_geo_lengthLineStart,
+ lineEnd: d3_noop,
+ polygonStart: d3_noop,
+ polygonEnd: d3_noop
+ };
+ function d3_geo_lengthLineStart() {
+ var λ0, sinφ0, cosφ0;
+ d3_geo_length.point = function(λ, φ) {
+ λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
+ d3_geo_length.point = nextPoint;
+ };
+ d3_geo_length.lineEnd = function() {
+ d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
+ };
+ function nextPoint(λ, φ) {
+ var sinφ = Math.sin(φ *= d3_radians), cosφ = Math.cos(φ), t = abs((λ *= d3_radians) - λ0), cosΔλ = Math.cos(t);
+ d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
+ λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
+ }
+ }
+ function d3_geo_azimuthal(scale, angle) {
+ function azimuthal(λ, φ) {
+ var cosλ = Math.cos(λ), cosφ = Math.cos(φ), k = scale(cosλ * cosφ);
+ return [ k * cosφ * Math.sin(λ), k * Math.sin(φ) ];
+ }
+ azimuthal.invert = function(x, y) {
+ var ρ = Math.sqrt(x * x + y * y), c = angle(ρ), sinc = Math.sin(c), cosc = Math.cos(c);
+ return [ Math.atan2(x * sinc, ρ * cosc), Math.asin(ρ && y * sinc / ρ) ];
+ };
+ return azimuthal;
+ }
+ var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(function(cosλcosφ) {
+ return Math.sqrt(2 / (1 + cosλcosφ));
+ }, function(ρ) {
+ return 2 * Math.asin(ρ / 2);
+ });
+ (d3.geo.azimuthalEqualArea = function() {
+ return d3_geo_projection(d3_geo_azimuthalEqualArea);
+ }).raw = d3_geo_azimuthalEqualArea;
+ var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(function(cosλcosφ) {
+ var c = Math.acos(cosλcosφ);
+ return c && c / Math.sin(c);
+ }, d3_identity);
+ (d3.geo.azimuthalEquidistant = function() {
+ return d3_geo_projection(d3_geo_azimuthalEquidistant);
+ }).raw = d3_geo_azimuthalEquidistant;
+ function d3_geo_conicConformal(φ0, φ1) {
+ var cosφ0 = Math.cos(φ0), t = function(φ) {
+ return Math.tan(π / 4 + φ / 2);
+ }, n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)), F = cosφ0 * Math.pow(t(φ0), n) / n;
+ if (!n) return d3_geo_mercator;
+ function forward(λ, φ) {
+ if (F > 0) {
+ if (φ < -halfπ + ε) φ = -halfπ + ε;
+ } else {
+ if (φ > halfπ - ε) φ = halfπ - ε;
+ }
+ var ρ = F / Math.pow(t(φ), n);
+ return [ ρ * Math.sin(n * λ), F - ρ * Math.cos(n * λ) ];
+ }
+ forward.invert = function(x, y) {
+ var ρ0_y = F - y, ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
+ return [ Math.atan2(x, ρ0_y) / n, 2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ ];
+ };
+ return forward;
+ }
+ (d3.geo.conicConformal = function() {
+ return d3_geo_conic(d3_geo_conicConformal);
+ }).raw = d3_geo_conicConformal;
+ function d3_geo_conicEquidistant(φ0, φ1) {
+ var cosφ0 = Math.cos(φ0), n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0), G = cosφ0 / n + φ0;
+ if (abs(n) < ε) return d3_geo_equirectangular;
+ function forward(λ, φ) {
+ var ρ = G - φ;
+ return [ ρ * Math.sin(n * λ), G - ρ * Math.cos(n * λ) ];
+ }
+ forward.invert = function(x, y) {
+ var ρ0_y = G - y;
+ return [ Math.atan2(x, ρ0_y) / n, G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y) ];
+ };
+ return forward;
+ }
+ (d3.geo.conicEquidistant = function() {
+ return d3_geo_conic(d3_geo_conicEquidistant);
+ }).raw = d3_geo_conicEquidistant;
+ var d3_geo_gnomonic = d3_geo_azimuthal(function(cosλcosφ) {
+ return 1 / cosλcosφ;
+ }, Math.atan);
+ (d3.geo.gnomonic = function() {
+ return d3_geo_projection(d3_geo_gnomonic);
+ }).raw = d3_geo_gnomonic;
+ function d3_geo_mercator(λ, φ) {
+ return [ λ, Math.log(Math.tan(π / 4 + φ / 2)) ];
+ }
+ d3_geo_mercator.invert = function(x, y) {
+ return [ x, 2 * Math.atan(Math.exp(y)) - halfπ ];
+ };
+ function d3_geo_mercatorProjection(project) {
+ var m = d3_geo_projection(project), scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, clipAuto;
+ m.scale = function() {
+ var v = scale.apply(m, arguments);
+ return v === m ? clipAuto ? m.clipExtent(null) : m : v;
+ };
+ m.translate = function() {
+ var v = translate.apply(m, arguments);
+ return v === m ? clipAuto ? m.clipExtent(null) : m : v;
+ };
+ m.clipExtent = function(_) {
+ var v = clipExtent.apply(m, arguments);
+ if (v === m) {
+ if (clipAuto = _ == null) {
+ var k = π * scale(), t = translate();
+ clipExtent([ [ t[0] - k, t[1] - k ], [ t[0] + k, t[1] + k ] ]);
+ }
+ } else if (clipAuto) {
+ v = null;
+ }
+ return v;
+ };
+ return m.clipExtent(null);
+ }
+ (d3.geo.mercator = function() {
+ return d3_geo_mercatorProjection(d3_geo_mercator);
+ }).raw = d3_geo_mercator;
+ var d3_geo_orthographic = d3_geo_azimuthal(function() {
+ return 1;
+ }, Math.asin);
+ (d3.geo.orthographic = function() {
+ return d3_geo_projection(d3_geo_orthographic);
+ }).raw = d3_geo_orthographic;
+ var d3_geo_stereographic = d3_geo_azimuthal(function(cosλcosφ) {
+ return 1 / (1 + cosλcosφ);
+ }, function(ρ) {
+ return 2 * Math.atan(ρ);
+ });
+ (d3.geo.stereographic = function() {
+ return d3_geo_projection(d3_geo_stereographic);
+ }).raw = d3_geo_stereographic;
+ function d3_geo_transverseMercator(λ, φ) {
+ return [ Math.log(Math.tan(π / 4 + φ / 2)), -λ ];
+ }
+ d3_geo_transverseMercator.invert = function(x, y) {
+ return [ -y, 2 * Math.atan(Math.exp(x)) - halfπ ];
+ };
+ (d3.geo.transverseMercator = function() {
+ var projection = d3_geo_mercatorProjection(d3_geo_transverseMercator), center = projection.center, rotate = projection.rotate;
+ projection.center = function(_) {
+ return _ ? center([ -_[1], _[0] ]) : (_ = center(), [ _[1], -_[0] ]);
+ };
+ projection.rotate = function(_) {
+ return _ ? rotate([ _[0], _[1], _.length > 2 ? _[2] + 90 : 90 ]) : (_ = rotate(),
+ [ _[0], _[1], _[2] - 90 ]);
+ };
+ return rotate([ 0, 0, 90 ]);
+ }).raw = d3_geo_transverseMercator;
+ d3.geom = {};
+ function d3_geom_pointX(d) {
+ return d[0];
+ }
+ function d3_geom_pointY(d) {
+ return d[1];
+ }
+ d3.geom.hull = function(vertices) {
+ var x = d3_geom_pointX, y = d3_geom_pointY;
+ if (arguments.length) return hull(vertices);
+ function hull(data) {
+ if (data.length < 3) return [];
+ var fx = d3_functor(x), fy = d3_functor(y), i, n = data.length, points = [], flippedPoints = [];
+ for (i = 0; i < n; i++) {
+ points.push([ +fx.call(this, data[i], i), +fy.call(this, data[i], i), i ]);
+ }
+ points.sort(d3_geom_hullOrder);
+ for (i = 0; i < n; i++) flippedPoints.push([ points[i][0], -points[i][1] ]);
+ var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints);
+ var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = [];
+ for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]);
+ for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]);
+ return polygon;
+ }
+ hull.x = function(_) {
+ return arguments.length ? (x = _, hull) : x;
+ };
+ hull.y = function(_) {
+ return arguments.length ? (y = _, hull) : y;
+ };
+ return hull;
+ };
+ function d3_geom_hullUpper(points) {
+ var n = points.length, hull = [ 0, 1 ], hs = 2;
+ for (var i = 2; i < n; i++) {
+ while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i]) <= 0) --hs;
+ hull[hs++] = i;
+ }
+ return hull.slice(0, hs);
+ }
+ function d3_geom_hullOrder(a, b) {
+ return a[0] - b[0] || a[1] - b[1];
+ }
+ d3.geom.polygon = function(coordinates) {
+ d3_subclass(coordinates, d3_geom_polygonPrototype);
+ return coordinates;
+ };
+ var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
+ d3_geom_polygonPrototype.area = function() {
+ var i = -1, n = this.length, a, b = this[n - 1], area = 0;
+ while (++i < n) {
+ a = b;
+ b = this[i];
+ area += a[1] * b[0] - a[0] * b[1];
+ }
+ return area * .5;
+ };
+ d3_geom_polygonPrototype.centroid = function(k) {
+ var i = -1, n = this.length, x = 0, y = 0, a, b = this[n - 1], c;
+ if (!arguments.length) k = -1 / (6 * this.area());
+ while (++i < n) {
+ a = b;
+ b = this[i];
+ c = a[0] * b[1] - b[0] * a[1];
+ x += (a[0] + b[0]) * c;
+ y += (a[1] + b[1]) * c;
+ }
+ return [ x * k, y * k ];
+ };
+ d3_geom_polygonPrototype.clip = function(subject) {
+ var input, closed = d3_geom_polygonClosed(subject), i = -1, n = this.length - d3_geom_polygonClosed(this), j, m, a = this[n - 1], b, c, d;
+ while (++i < n) {
+ input = subject.slice();
+ subject.length = 0;
+ b = this[i];
+ c = input[(m = input.length - closed) - 1];
+ j = -1;
+ while (++j < m) {
+ d = input[j];
+ if (d3_geom_polygonInside(d, a, b)) {
+ if (!d3_geom_polygonInside(c, a, b)) {
+ subject.push(d3_geom_polygonIntersect(c, d, a, b));
+ }
+ subject.push(d);
+ } else if (d3_geom_polygonInside(c, a, b)) {
+ subject.push(d3_geom_polygonIntersect(c, d, a, b));
+ }
+ c = d;
+ }
+ if (closed) subject.push(subject[0]);
+ a = b;
+ }
+ return subject;
+ };
+ function d3_geom_polygonInside(p, a, b) {
+ return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]);
+ }
+ function d3_geom_polygonIntersect(c, d, a, b) {
+ var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
+ return [ x1 + ua * x21, y1 + ua * y21 ];
+ }
+ function d3_geom_polygonClosed(coordinates) {
+ var a = coordinates[0], b = coordinates[coordinates.length - 1];
+ return !(a[0] - b[0] || a[1] - b[1]);
+ }
+ var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = [];
+ function d3_geom_voronoiBeach() {
+ d3_geom_voronoiRedBlackNode(this);
+ this.edge = this.site = this.circle = null;
+ }
+ function d3_geom_voronoiCreateBeach(site) {
+ var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach();
+ beach.site = site;
+ return beach;
+ }
+ function d3_geom_voronoiDetachBeach(beach) {
+ d3_geom_voronoiDetachCircle(beach);
+ d3_geom_voronoiBeaches.remove(beach);
+ d3_geom_voronoiBeachPool.push(beach);
+ d3_geom_voronoiRedBlackNode(beach);
+ }
+ function d3_geom_voronoiRemoveBeach(beach) {
+ var circle = beach.circle, x = circle.x, y = circle.cy, vertex = {
+ x: x,
+ y: y
+ }, previous = beach.P, next = beach.N, disappearing = [ beach ];
+ d3_geom_voronoiDetachBeach(beach);
+ var lArc = previous;
+ while (lArc.circle && abs(x - lArc.circle.x) < ε && abs(y - lArc.circle.cy) < ε) {
+ previous = lArc.P;
+ disappearing.unshift(lArc);
+ d3_geom_voronoiDetachBeach(lArc);
+ lArc = previous;
+ }
+ disappearing.unshift(lArc);
+ d3_geom_voronoiDetachCircle(lArc);
+ var rArc = next;
+ while (rArc.circle && abs(x - rArc.circle.x) < ε && abs(y - rArc.circle.cy) < ε) {
+ next = rArc.N;
+ disappearing.push(rArc);
+ d3_geom_voronoiDetachBeach(rArc);
+ rArc = next;
+ }
+ disappearing.push(rArc);
+ d3_geom_voronoiDetachCircle(rArc);
+ var nArcs = disappearing.length, iArc;
+ for (iArc = 1; iArc < nArcs; ++iArc) {
+ rArc = disappearing[iArc];
+ lArc = disappearing[iArc - 1];
+ d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);
+ }
+ lArc = disappearing[0];
+ rArc = disappearing[nArcs - 1];
+ rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex);
+ d3_geom_voronoiAttachCircle(lArc);
+ d3_geom_voronoiAttachCircle(rArc);
+ }
+ function d3_geom_voronoiAddBeach(site) {
+ var x = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._;
+ while (node) {
+ dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x;
+ if (dxl > ε) node = node.L; else {
+ dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix);
+ if (dxr > ε) {
+ if (!node.R) {
+ lArc = node;
+ break;
+ }
+ node = node.R;
+ } else {
+ if (dxl > -ε) {
+ lArc = node.P;
+ rArc = node;
+ } else if (dxr > -ε) {
+ lArc = node;
+ rArc = node.N;
+ } else {
+ lArc = rArc = node;
+ }
+ break;
+ }
+ }
+ }
+ var newArc = d3_geom_voronoiCreateBeach(site);
+ d3_geom_voronoiBeaches.insert(lArc, newArc);
+ if (!lArc && !rArc) return;
+ if (lArc === rArc) {
+ d3_geom_voronoiDetachCircle(lArc);
+ rArc = d3_geom_voronoiCreateBeach(lArc.site);
+ d3_geom_voronoiBeaches.insert(newArc, rArc);
+ newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+ d3_geom_voronoiAttachCircle(lArc);
+ d3_geom_voronoiAttachCircle(rArc);
+ return;
+ }
+ if (!rArc) {
+ newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+ return;
+ }
+ d3_geom_voronoiDetachCircle(lArc);
+ d3_geom_voronoiDetachCircle(rArc);
+ var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d = 2 * (bx * cy - by * cx), hb = bx * bx + by * by, hc = cx * cx + cy * cy, vertex = {
+ x: (cy * hb - by * hc) / d + ax,
+ y: (bx * hc - cx * hb) / d + ay
+ };
+ d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex);
+ newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex);
+ rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex);
+ d3_geom_voronoiAttachCircle(lArc);
+ d3_geom_voronoiAttachCircle(rArc);
+ }
+ function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
+ var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix;
+ if (!pby2) return rfocx;
+ var lArc = arc.P;
+ if (!lArc) return -Infinity;
+ site = lArc.site;
+ var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix;
+ if (!plby2) return lfocx;
+ var hl = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b = hl / plby2;
+ if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
+ return (rfocx + lfocx) / 2;
+ }
+ function d3_geom_voronoiRightBreakPoint(arc, directrix) {
+ var rArc = arc.N;
+ if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix);
+ var site = arc.site;
+ return site.y === directrix ? site.x : Infinity;
+ }
+ function d3_geom_voronoiCell(site) {
+ this.site = site;
+ this.edges = [];
+ }
+ d3_geom_voronoiCell.prototype.prepare = function() {
+ var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge;
+ while (iHalfEdge--) {
+ edge = halfEdges[iHalfEdge].edge;
+ if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1);
+ }
+ halfEdges.sort(d3_geom_voronoiHalfEdgeOrder);
+ return halfEdges.length;
+ };
+ function d3_geom_voronoiCloseCells(extent) {
+ var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end;
+ while (iCell--) {
+ cell = cells[iCell];
+ if (!cell || !cell.prepare()) continue;
+ halfEdges = cell.edges;
+ nHalfEdges = halfEdges.length;
+ iHalfEdge = 0;
+ while (iHalfEdge < nHalfEdges) {
+ end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y;
+ start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y;
+ if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) {
+ halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? {
+ x: x0,
+ y: abs(x2 - x0) < ε ? y2 : y1
+ } : abs(y3 - y1) < ε && x1 - x3 > ε ? {
+ x: abs(y2 - y1) < ε ? x2 : x1,
+ y: y1
+ } : abs(x3 - x1) < ε && y3 - y0 > ε ? {
+ x: x1,
+ y: abs(x2 - x1) < ε ? y2 : y0
+ } : abs(y3 - y0) < ε && x3 - x0 > ε ? {
+ x: abs(y2 - y0) < ε ? x2 : x0,
+ y: y0
+ } : null), cell.site, null));
+ ++nHalfEdges;
+ }
+ }
+ }
+ }
+ function d3_geom_voronoiHalfEdgeOrder(a, b) {
+ return b.angle - a.angle;
+ }
+ function d3_geom_voronoiCircle() {
+ d3_geom_voronoiRedBlackNode(this);
+ this.x = this.y = this.arc = this.site = this.cy = null;
+ }
+ function d3_geom_voronoiAttachCircle(arc) {
+ var lArc = arc.P, rArc = arc.N;
+ if (!lArc || !rArc) return;
+ var lSite = lArc.site, cSite = arc.site, rSite = rArc.site;
+ if (lSite === rSite) return;
+ var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by;
+ var d = 2 * (ax * cy - ay * cx);
+ if (d >= -ε2) return;
+ var ha = ax * ax + ay * ay, hc = cx * cx + cy * cy, x = (cy * ha - ay * hc) / d, y = (ax * hc - cx * ha) / d, cy = y + by;
+ var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle();
+ circle.arc = arc;
+ circle.site = cSite;
+ circle.x = x + bx;
+ circle.y = cy + Math.sqrt(x * x + y * y);
+ circle.cy = cy;
+ arc.circle = circle;
+ var before = null, node = d3_geom_voronoiCircles._;
+ while (node) {
+ if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) {
+ if (node.L) node = node.L; else {
+ before = node.P;
+ break;
+ }
+ } else {
+ if (node.R) node = node.R; else {
+ before = node;
+ break;
+ }
+ }
+ }
+ d3_geom_voronoiCircles.insert(before, circle);
+ if (!before) d3_geom_voronoiFirstCircle = circle;
+ }
+ function d3_geom_voronoiDetachCircle(arc) {
+ var circle = arc.circle;
+ if (circle) {
+ if (!circle.P) d3_geom_voronoiFirstCircle = circle.N;
+ d3_geom_voronoiCircles.remove(circle);
+ d3_geom_voronoiCirclePool.push(circle);
+ d3_geom_voronoiRedBlackNode(circle);
+ arc.circle = null;
+ }
+ }
+ function d3_geom_voronoiClipEdges(extent) {
+ var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i = edges.length, e;
+ while (i--) {
+ e = edges[i];
+ if (!d3_geom_voronoiConnectEdge(e, extent) || !clip(e) || abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε) {
+ e.a = e.b = null;
+ edges.splice(i, 1);
+ }
+ }
+ }
+ function d3_geom_voronoiConnectEdge(edge, extent) {
+ var vb = edge.b;
+ if (vb) return true;
+ var va = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb;
+ if (ry === ly) {
+ if (fx < x0 || fx >= x1) return;
+ if (lx > rx) {
+ if (!va) va = {
+ x: fx,
+ y: y0
+ }; else if (va.y >= y1) return;
+ vb = {
+ x: fx,
+ y: y1
+ };
+ } else {
+ if (!va) va = {
+ x: fx,
+ y: y1
+ }; else if (va.y < y0) return;
+ vb = {
+ x: fx,
+ y: y0
+ };
+ }
+ } else {
+ fm = (lx - rx) / (ry - ly);
+ fb = fy - fm * fx;
+ if (fm < -1 || fm > 1) {
+ if (lx > rx) {
+ if (!va) va = {
+ x: (y0 - fb) / fm,
+ y: y0
+ }; else if (va.y >= y1) return;
+ vb = {
+ x: (y1 - fb) / fm,
+ y: y1
+ };
+ } else {
+ if (!va) va = {
+ x: (y1 - fb) / fm,
+ y: y1
+ }; else if (va.y < y0) return;
+ vb = {
+ x: (y0 - fb) / fm,
+ y: y0
+ };
+ }
+ } else {
+ if (ly < ry) {
+ if (!va) va = {
+ x: x0,
+ y: fm * x0 + fb
+ }; else if (va.x >= x1) return;
+ vb = {
+ x: x1,
+ y: fm * x1 + fb
+ };
+ } else {
+ if (!va) va = {
+ x: x1,
+ y: fm * x1 + fb
+ }; else if (va.x < x0) return;
+ vb = {
+ x: x0,
+ y: fm * x0 + fb
+ };
+ }
+ }
+ }
+ edge.a = va;
+ edge.b = vb;
+ return true;
+ }
+ function d3_geom_voronoiEdge(lSite, rSite) {
+ this.l = lSite;
+ this.r = rSite;
+ this.a = this.b = null;
+ }
+ function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
+ var edge = new d3_geom_voronoiEdge(lSite, rSite);
+ d3_geom_voronoiEdges.push(edge);
+ if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va);
+ if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb);
+ d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite));
+ d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite));
+ return edge;
+ }
+ function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
+ var edge = new d3_geom_voronoiEdge(lSite, null);
+ edge.a = va;
+ edge.b = vb;
+ d3_geom_voronoiEdges.push(edge);
+ return edge;
+ }
+ function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
+ if (!edge.a && !edge.b) {
+ edge.a = vertex;
+ edge.l = lSite;
+ edge.r = rSite;
+ } else if (edge.l === rSite) {
+ edge.b = vertex;
+ } else {
+ edge.a = vertex;
+ }
+ }
+ function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
+ var va = edge.a, vb = edge.b;
+ this.edge = edge;
+ this.site = lSite;
+ this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y) : Math.atan2(va.x - vb.x, vb.y - va.y);
+ }
+ d3_geom_voronoiHalfEdge.prototype = {
+ start: function() {
+ return this.edge.l === this.site ? this.edge.a : this.edge.b;
+ },
+ end: function() {
+ return this.edge.l === this.site ? this.edge.b : this.edge.a;
+ }
+ };
+ function d3_geom_voronoiRedBlackTree() {
+ this._ = null;
+ }
+ function d3_geom_voronoiRedBlackNode(node) {
+ node.U = node.C = node.L = node.R = node.P = node.N = null;
+ }
+ d3_geom_voronoiRedBlackTree.prototype = {
+ insert: function(after, node) {
+ var parent, grandpa, uncle;
+ if (after) {
+ node.P = after;
+ node.N = after.N;
+ if (after.N) after.N.P = node;
+ after.N = node;
+ if (after.R) {
+ after = after.R;
+ while (after.L) after = after.L;
+ after.L = node;
+ } else {
+ after.R = node;
+ }
+ parent = after;
+ } else if (this._) {
+ after = d3_geom_voronoiRedBlackFirst(this._);
+ node.P = null;
+ node.N = after;
+ after.P = after.L = node;
+ parent = after;
+ } else {
+ node.P = node.N = null;
+ this._ = node;
+ parent = null;
+ }
+ node.L = node.R = null;
+ node.U = parent;
+ node.C = true;
+ after = node;
+ while (parent && parent.C) {
+ grandpa = parent.U;
+ if (parent === grandpa.L) {
+ uncle = grandpa.R;
+ if (uncle && uncle.C) {
+ parent.C = uncle.C = false;
+ grandpa.C = true;
+ after = grandpa;
+ } else {
+ if (after === parent.R) {
+ d3_geom_voronoiRedBlackRotateLeft(this, parent);
+ after = parent;
+ parent = after.U;
+ }
+ parent.C = false;
+ grandpa.C = true;
+ d3_geom_voronoiRedBlackRotateRight(this, grandpa);
+ }
+ } else {
+ uncle = grandpa.L;
+ if (uncle && uncle.C) {
+ parent.C = uncle.C = false;
+ grandpa.C = true;
+ after = grandpa;
+ } else {
+ if (after === parent.L) {
+ d3_geom_voronoiRedBlackRotateRight(this, parent);
+ after = parent;
+ parent = after.U;
+ }
+ parent.C = false;
+ grandpa.C = true;
+ d3_geom_voronoiRedBlackRotateLeft(this, grandpa);
+ }
+ }
+ parent = after.U;
+ }
+ this._.C = false;
+ },
+ remove: function(node) {
+ if (node.N) node.N.P = node.P;
+ if (node.P) node.P.N = node.N;
+ node.N = node.P = null;
+ var parent = node.U, sibling, left = node.L, right = node.R, next, red;
+ if (!left) next = right; else if (!right) next = left; else next = d3_geom_voronoiRedBlackFirst(right);
+ if (parent) {
+ if (parent.L === node) parent.L = next; else parent.R = next;
+ } else {
+ this._ = next;
+ }
+ if (left && right) {
+ red = next.C;
+ next.C = node.C;
+ next.L = left;
+ left.U = next;
+ if (next !== right) {
+ parent = next.U;
+ next.U = node.U;
+ node = next.R;
+ parent.L = node;
+ next.R = right;
+ right.U = next;
+ } else {
+ next.U = parent;
+ parent = next;
+ node = next.R;
+ }
+ } else {
+ red = node.C;
+ node = next;
+ }
+ if (node) node.U = parent;
+ if (red) return;
+ if (node && node.C) {
+ node.C = false;
+ return;
+ }
+ do {
+ if (node === this._) break;
+ if (node === parent.L) {
+ sibling = parent.R;
+ if (sibling.C) {
+ sibling.C = false;
+ parent.C = true;
+ d3_geom_voronoiRedBlackRotateLeft(this, parent);
+ sibling = parent.R;
+ }
+ if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+ if (!sibling.R || !sibling.R.C) {
+ sibling.L.C = false;
+ sibling.C = true;
+ d3_geom_voronoiRedBlackRotateRight(this, sibling);
+ sibling = parent.R;
+ }
+ sibling.C = parent.C;
+ parent.C = sibling.R.C = false;
+ d3_geom_voronoiRedBlackRotateLeft(this, parent);
+ node = this._;
+ break;
+ }
+ } else {
+ sibling = parent.L;
+ if (sibling.C) {
+ sibling.C = false;
+ parent.C = true;
+ d3_geom_voronoiRedBlackRotateRight(this, parent);
+ sibling = parent.L;
+ }
+ if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+ if (!sibling.L || !sibling.L.C) {
+ sibling.R.C = false;
+ sibling.C = true;
+ d3_geom_voronoiRedBlackRotateLeft(this, sibling);
+ sibling = parent.L;
+ }
+ sibling.C = parent.C;
+ parent.C = sibling.L.C = false;
+ d3_geom_voronoiRedBlackRotateRight(this, parent);
+ node = this._;
+ break;
+ }
+ }
+ sibling.C = true;
+ node = parent;
+ parent = parent.U;
+ } while (!node.C);
+ if (node) node.C = false;
+ }
+ };
+ function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
+ var p = node, q = node.R, parent = p.U;
+ if (parent) {
+ if (parent.L === p) parent.L = q; else parent.R = q;
+ } else {
+ tree._ = q;
+ }
+ q.U = parent;
+ p.U = q;
+ p.R = q.L;
+ if (p.R) p.R.U = p;
+ q.L = p;
+ }
+ function d3_geom_voronoiRedBlackRotateRight(tree, node) {
+ var p = node, q = node.L, parent = p.U;
+ if (parent) {
+ if (parent.L === p) parent.L = q; else parent.R = q;
+ } else {
+ tree._ = q;
+ }
+ q.U = parent;
+ p.U = q;
+ p.L = q.R;
+ if (p.L) p.L.U = p;
+ q.R = p;
+ }
+ function d3_geom_voronoiRedBlackFirst(node) {
+ while (node.L) node = node.L;
+ return node;
+ }
+ function d3_geom_voronoi(sites, bbox) {
+ var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle;
+ d3_geom_voronoiEdges = [];
+ d3_geom_voronoiCells = new Array(sites.length);
+ d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree();
+ d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree();
+ while (true) {
+ circle = d3_geom_voronoiFirstCircle;
+ if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) {
+ if (site.x !== x0 || site.y !== y0) {
+ d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site);
+ d3_geom_voronoiAddBeach(site);
+ x0 = site.x, y0 = site.y;
+ }
+ site = sites.pop();
+ } else if (circle) {
+ d3_geom_voronoiRemoveBeach(circle.arc);
+ } else {
+ break;
+ }
+ }
+ if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox);
+ var diagram = {
+ cells: d3_geom_voronoiCells,
+ edges: d3_geom_voronoiEdges
+ };
+ d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null;
+ return diagram;
+ }
+ function d3_geom_voronoiVertexOrder(a, b) {
+ return b.y - a.y || b.x - a.x;
+ }
+ d3.geom.voronoi = function(points) {
+ var x = d3_geom_pointX, y = d3_geom_pointY, fx = x, fy = y, clipExtent = d3_geom_voronoiClipExtent;
+ if (points) return voronoi(points);
+ function voronoi(data) {
+ var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1];
+ d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) {
+ var edges = cell.edges, site = cell.site, polygon = polygons[i] = edges.length ? edges.map(function(e) {
+ var s = e.start();
+ return [ s.x, s.y ];
+ }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [ [ x0, y1 ], [ x1, y1 ], [ x1, y0 ], [ x0, y0 ] ] : [];
+ polygon.point = data[i];
+ });
+ return polygons;
+ }
+ function sites(data) {
+ return data.map(function(d, i) {
+ return {
+ x: Math.round(fx(d, i) / ε) * ε,
+ y: Math.round(fy(d, i) / ε) * ε,
+ i: i
+ };
+ });
+ }
+ voronoi.links = function(data) {
+ return d3_geom_voronoi(sites(data)).edges.filter(function(edge) {
+ return edge.l && edge.r;
+ }).map(function(edge) {
+ return {
+ source: data[edge.l.i],
+ target: data[edge.r.i]
+ };
+ });
+ };
+ voronoi.triangles = function(data) {
+ var triangles = [];
+ d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) {
+ var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j = -1, m = edges.length, e0, s0, e1 = edges[m - 1].edge, s1 = e1.l === site ? e1.r : e1.l;
+ while (++j < m) {
+ e0 = e1;
+ s0 = s1;
+ e1 = edges[j].edge;
+ s1 = e1.l === site ? e1.r : e1.l;
+ if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) {
+ triangles.push([ data[i], data[s0.i], data[s1.i] ]);
+ }
+ }
+ });
+ return triangles;
+ };
+ voronoi.x = function(_) {
+ return arguments.length ? (fx = d3_functor(x = _), voronoi) : x;
+ };
+ voronoi.y = function(_) {
+ return arguments.length ? (fy = d3_functor(y = _), voronoi) : y;
+ };
+ voronoi.clipExtent = function(_) {
+ if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent;
+ clipExtent = _ == null ? d3_geom_voronoiClipExtent : _;
+ return voronoi;
+ };
+ voronoi.size = function(_) {
+ if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1];
+ return voronoi.clipExtent(_ && [ [ 0, 0 ], _ ]);
+ };
+ return voronoi;
+ };
+ var d3_geom_voronoiClipExtent = [ [ -1e6, -1e6 ], [ 1e6, 1e6 ] ];
+ function d3_geom_voronoiTriangleArea(a, b, c) {
+ return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y);
+ }
+ d3.geom.delaunay = function(vertices) {
+ return d3.geom.voronoi().triangles(vertices);
+ };
+ d3.geom.quadtree = function(points, x1, y1, x2, y2) {
+ var x = d3_geom_pointX, y = d3_geom_pointY, compat;
+ if (compat = arguments.length) {
+ x = d3_geom_quadtreeCompatX;
+ y = d3_geom_quadtreeCompatY;
+ if (compat === 3) {
+ y2 = y1;
+ x2 = x1;
+ y1 = x1 = 0;
+ }
+ return quadtree(points);
+ }
+ function quadtree(data) {
+ var d, fx = d3_functor(x), fy = d3_functor(y), xs, ys, i, n, x1_, y1_, x2_, y2_;
+ if (x1 != null) {
+ x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
+ } else {
+ x2_ = y2_ = -(x1_ = y1_ = Infinity);
+ xs = [], ys = [];
+ n = data.length;
+ if (compat) for (i = 0; i < n; ++i) {
+ d = data[i];
+ if (d.x < x1_) x1_ = d.x;
+ if (d.y < y1_) y1_ = d.y;
+ if (d.x > x2_) x2_ = d.x;
+ if (d.y > y2_) y2_ = d.y;
+ xs.push(d.x);
+ ys.push(d.y);
+ } else for (i = 0; i < n; ++i) {
+ var x_ = +fx(d = data[i], i), y_ = +fy(d, i);
+ if (x_ < x1_) x1_ = x_;
+ if (y_ < y1_) y1_ = y_;
+ if (x_ > x2_) x2_ = x_;
+ if (y_ > y2_) y2_ = y_;
+ xs.push(x_);
+ ys.push(y_);
+ }
+ }
+ var dx = x2_ - x1_, dy = y2_ - y1_;
+ if (dx > dy) y2_ = y1_ + dx; else x2_ = x1_ + dy;
+ function insert(n, d, x, y, x1, y1, x2, y2) {
+ if (isNaN(x) || isNaN(y)) return;
+ if (n.leaf) {
+ var nx = n.x, ny = n.y;
+ if (nx != null) {
+ if (abs(nx - x) + abs(ny - y) < .01) {
+ insertChild(n, d, x, y, x1, y1, x2, y2);
+ } else {
+ var nPoint = n.point;
+ n.x = n.y = n.point = null;
+ insertChild(n, nPoint, nx, ny, x1, y1, x2, y2);
+ insertChild(n, d, x, y, x1, y1, x2, y2);
+ }
+ } else {
+ n.x = x, n.y = y, n.point = d;
+ }
+ } else {
+ insertChild(n, d, x, y, x1, y1, x2, y2);
+ }
+ }
+ function insertChild(n, d, x, y, x1, y1, x2, y2) {
+ var xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym, i = below << 1 | right;
+ n.leaf = false;
+ n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode());
+ if (right) x1 = xm; else x2 = xm;
+ if (below) y1 = ym; else y2 = ym;
+ insert(n, d, x, y, x1, y1, x2, y2);
+ }
+ var root = d3_geom_quadtreeNode();
+ root.add = function(d) {
+ insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_);
+ };
+ root.visit = function(f) {
+ d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_);
+ };
+ root.find = function(point) {
+ return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
+ };
+ i = -1;
+ if (x1 == null) {
+ while (++i < n) {
+ insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_);
+ }
+ --i;
+ } else data.forEach(root.add);
+ xs = ys = data = d = null;
+ return root;
+ }
+ quadtree.x = function(_) {
+ return arguments.length ? (x = _, quadtree) : x;
+ };
+ quadtree.y = function(_) {
+ return arguments.length ? (y = _, quadtree) : y;
+ };
+ quadtree.extent = function(_) {
+ if (!arguments.length) return x1 == null ? null : [ [ x1, y1 ], [ x2, y2 ] ];
+ if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0],
+ y2 = +_[1][1];
+ return quadtree;
+ };
+ quadtree.size = function(_) {
+ if (!arguments.length) return x1 == null ? null : [ x2 - x1, y2 - y1 ];
+ if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = y1 = 0, x2 = +_[0], y2 = +_[1];
+ return quadtree;
+ };
+ return quadtree;
+ };
+ function d3_geom_quadtreeCompatX(d) {
+ return d.x;
+ }
+ function d3_geom_quadtreeCompatY(d) {
+ return d.y;
+ }
+ function d3_geom_quadtreeNode() {
+ return {
+ leaf: true,
+ nodes: [],
+ point: null,
+ x: null,
+ y: null
+ };
+ }
+ function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
+ if (!f(node, x1, y1, x2, y2)) {
+ var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes;
+ if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy);
+ if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy);
+ if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2);
+ if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2);
+ }
+ }
+ function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
+ var minDistance2 = Infinity, closestPoint;
+ (function find(node, x1, y1, x2, y2) {
+ if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) return;
+ if (point = node.point) {
+ var point, dx = x - node.x, dy = y - node.y, distance2 = dx * dx + dy * dy;
+ if (distance2 < minDistance2) {
+ var distance = Math.sqrt(minDistance2 = distance2);
+ x0 = x - distance, y0 = y - distance;
+ x3 = x + distance, y3 = y + distance;
+ closestPoint = point;
+ }
+ }
+ var children = node.nodes, xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym;
+ for (var i = below << 1 | right, j = i + 4; i < j; ++i) {
+ if (node = children[i & 3]) switch (i & 3) {
+ case 0:
+ find(node, x1, y1, xm, ym);
+ break;
+
+ case 1:
+ find(node, xm, y1, x2, ym);
+ break;
+
+ case 2:
+ find(node, x1, ym, xm, y2);
+ break;
+
+ case 3:
+ find(node, xm, ym, x2, y2);
+ break;
+ }
+ }
+ })(root, x0, y0, x3, y3);
+ return closestPoint;
+ }
+ d3.interpolateRgb = d3_interpolateRgb;
+ function d3_interpolateRgb(a, b) {
+ a = d3.rgb(a);
+ b = d3.rgb(b);
+ var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab;
+ return function(t) {
+ return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t));
+ };
+ }
+ d3.interpolateObject = d3_interpolateObject;
+ function d3_interpolateObject(a, b) {
+ var i = {}, c = {}, k;
+ for (k in a) {
+ if (k in b) {
+ i[k] = d3_interpolate(a[k], b[k]);
+ } else {
+ c[k] = a[k];
+ }
+ }
+ for (k in b) {
+ if (!(k in a)) {
+ c[k] = b[k];
+ }
+ }
+ return function(t) {
+ for (k in i) c[k] = i[k](t);
+ return c;
+ };
+ }
+ d3.interpolateNumber = d3_interpolateNumber;
+ function d3_interpolateNumber(a, b) {
+ a = +a, b = +b;
+ return function(t) {
+ return a * (1 - t) + b * t;
+ };
+ }
+ d3.interpolateString = d3_interpolateString;
+ function d3_interpolateString(a, b) {
+ var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
+ a = a + "", b = b + "";
+ while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) {
+ if ((bs = bm.index) > bi) {
+ bs = b.slice(bi, bs);
+ if (s[i]) s[i] += bs; else s[++i] = bs;
+ }
+ if ((am = am[0]) === (bm = bm[0])) {
+ if (s[i]) s[i] += bm; else s[++i] = bm;
+ } else {
+ s[++i] = null;
+ q.push({
+ i: i,
+ x: d3_interpolateNumber(am, bm)
+ });
+ }
+ bi = d3_interpolate_numberB.lastIndex;
+ }
+ if (bi < b.length) {
+ bs = b.slice(bi);
+ if (s[i]) s[i] += bs; else s[++i] = bs;
+ }
+ return s.length < 2 ? q[0] ? (b = q[0].x, function(t) {
+ return b(t) + "";
+ }) : function() {
+ return b;
+ } : (b = q.length, function(t) {
+ for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
+ return s.join("");
+ });
+ }
+ var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g");
+ d3.interpolate = d3_interpolate;
+ function d3_interpolate(a, b) {
+ var i = d3.interpolators.length, f;
+ while (--i >= 0 && !(f = d3.interpolators[i](a, b))) ;
+ return f;
+ }
+ d3.interpolators = [ function(a, b) {
+ var t = typeof b;
+ return (t === "string" ? d3_rgb_names.has(b.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b);
+ } ];
+ d3.interpolateArray = d3_interpolateArray;
+ function d3_interpolateArray(a, b) {
+ var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i;
+ for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i]));
+ for (;i < na; ++i) c[i] = a[i];
+ for (;i < nb; ++i) c[i] = b[i];
+ return function(t) {
+ for (i = 0; i < n0; ++i) c[i] = x[i](t);
+ return c;
+ };
+ }
+ var d3_ease_default = function() {
+ return d3_identity;
+ };
+ var d3_ease = d3.map({
+ linear: d3_ease_default,
+ poly: d3_ease_poly,
+ quad: function() {
+ return d3_ease_quad;
+ },
+ cubic: function() {
+ return d3_ease_cubic;
+ },
+ sin: function() {
+ return d3_ease_sin;
+ },
+ exp: function() {
+ return d3_ease_exp;
+ },
+ circle: function() {
+ return d3_ease_circle;
+ },
+ elastic: d3_ease_elastic,
+ back: d3_ease_back,
+ bounce: function() {
+ return d3_ease_bounce;
+ }
+ });
+ var d3_ease_mode = d3.map({
+ "in": d3_identity,
+ out: d3_ease_reverse,
+ "in-out": d3_ease_reflect,
+ "out-in": function(f) {
+ return d3_ease_reflect(d3_ease_reverse(f));
+ }
+ });
+ d3.ease = function(name) {
+ var i = name.indexOf("-"), t = i >= 0 ? name.slice(0, i) : name, m = i >= 0 ? name.slice(i + 1) : "in";
+ t = d3_ease.get(t) || d3_ease_default;
+ m = d3_ease_mode.get(m) || d3_identity;
+ return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1))));
+ };
+ function d3_ease_clamp(f) {
+ return function(t) {
+ return t <= 0 ? 0 : t >= 1 ? 1 : f(t);
+ };
+ }
+ function d3_ease_reverse(f) {
+ return function(t) {
+ return 1 - f(1 - t);
+ };
+ }
+ function d3_ease_reflect(f) {
+ return function(t) {
+ return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t));
+ };
+ }
+ function d3_ease_quad(t) {
+ return t * t;
+ }
+ function d3_ease_cubic(t) {
+ return t * t * t;
+ }
+ function d3_ease_cubicInOut(t) {
+ if (t <= 0) return 0;
+ if (t >= 1) return 1;
+ var t2 = t * t, t3 = t2 * t;
+ return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
+ }
+ function d3_ease_poly(e) {
+ return function(t) {
+ return Math.pow(t, e);
+ };
+ }
+ function d3_ease_sin(t) {
+ return 1 - Math.cos(t * halfπ);
+ }
+ function d3_ease_exp(t) {
+ return Math.pow(2, 10 * (t - 1));
+ }
+ function d3_ease_circle(t) {
+ return 1 - Math.sqrt(1 - t * t);
+ }
+ function d3_ease_elastic(a, p) {
+ var s;
+ if (arguments.length < 2) p = .45;
+ if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4;
+ return function(t) {
+ return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p);
+ };
+ }
+ function d3_ease_back(s) {
+ if (!s) s = 1.70158;
+ return function(t) {
+ return t * t * ((s + 1) * t - s);
+ };
+ }
+ function d3_ease_bounce(t) {
+ return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
+ }
+ d3.interpolateHcl = d3_interpolateHcl;
+ function d3_interpolateHcl(a, b) {
+ a = d3.hcl(a);
+ b = d3.hcl(b);
+ var ah = a.h, ac = a.c, al = a.l, bh = b.h - ah, bc = b.c - ac, bl = b.l - al;
+ if (isNaN(bc)) bc = 0, ac = isNaN(ac) ? b.c : ac;
+ if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
+ return function(t) {
+ return d3_hcl_lab(ah + bh * t, ac + bc * t, al + bl * t) + "";
+ };
+ }
+ d3.interpolateHsl = d3_interpolateHsl;
+ function d3_interpolateHsl(a, b) {
+ a = d3.hsl(a);
+ b = d3.hsl(b);
+ var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al;
+ if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as;
+ if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
+ return function(t) {
+ return d3_hsl_rgb(ah + bh * t, as + bs * t, al + bl * t) + "";
+ };
+ }
+ d3.interpolateLab = d3_interpolateLab;
+ function d3_interpolateLab(a, b) {
+ a = d3.lab(a);
+ b = d3.lab(b);
+ var al = a.l, aa = a.a, ab = a.b, bl = b.l - al, ba = b.a - aa, bb = b.b - ab;
+ return function(t) {
+ return d3_lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + "";
+ };
+ }
+ d3.interpolateRound = d3_interpolateRound;
+ function d3_interpolateRound(a, b) {
+ b -= a;
+ return function(t) {
+ return Math.round(a + b * t);
+ };
+ }
+ d3.transform = function(string) {
+ var g = d3_document.createElementNS(d3.ns.prefix.svg, "g");
+ return (d3.transform = function(string) {
+ if (string != null) {
+ g.setAttribute("transform", string);
+ var t = g.transform.baseVal.consolidate();
+ }
+ return new d3_transform(t ? t.matrix : d3_transformIdentity);
+ })(string);
+ };
+ function d3_transform(m) {
+ var r0 = [ m.a, m.b ], r1 = [ m.c, m.d ], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;
+ if (r0[0] * r1[1] < r1[0] * r0[1]) {
+ r0[0] *= -1;
+ r0[1] *= -1;
+ kx *= -1;
+ kz *= -1;
+ }
+ this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees;
+ this.translate = [ m.e, m.f ];
+ this.scale = [ kx, ky ];
+ this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0;
+ }
+ d3_transform.prototype.toString = function() {
+ return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
+ };
+ function d3_transformDot(a, b) {
+ return a[0] * b[0] + a[1] * b[1];
+ }
+ function d3_transformNormalize(a) {
+ var k = Math.sqrt(d3_transformDot(a, a));
+ if (k) {
+ a[0] /= k;
+ a[1] /= k;
+ }
+ return k;
+ }
+ function d3_transformCombine(a, b, k) {
+ a[0] += k * b[0];
+ a[1] += k * b[1];
+ return a;
+ }
+ var d3_transformIdentity = {
+ a: 1,
+ b: 0,
+ c: 0,
+ d: 1,
+ e: 0,
+ f: 0
+ };
+ d3.interpolateTransform = d3_interpolateTransform;
+ function d3_interpolateTransform(a, b) {
+ var s = [], q = [], n, A = d3.transform(a), B = d3.transform(b), ta = A.translate, tb = B.translate, ra = A.rotate, rb = B.rotate, wa = A.skew, wb = B.skew, ka = A.scale, kb = B.scale;
+ if (ta[0] != tb[0] || ta[1] != tb[1]) {
+ s.push("translate(", null, ",", null, ")");
+ q.push({
+ i: 1,
+ x: d3_interpolateNumber(ta[0], tb[0])
+ }, {
+ i: 3,
+ x: d3_interpolateNumber(ta[1], tb[1])
+ });
+ } else if (tb[0] || tb[1]) {
+ s.push("translate(" + tb + ")");
+ } else {
+ s.push("");
+ }
+ if (ra != rb) {
+ if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360;
+ q.push({
+ i: s.push(s.pop() + "rotate(", null, ")") - 2,
+ x: d3_interpolateNumber(ra, rb)
+ });
+ } else if (rb) {
+ s.push(s.pop() + "rotate(" + rb + ")");
+ }
+ if (wa != wb) {
+ q.push({
+ i: s.push(s.pop() + "skewX(", null, ")") - 2,
+ x: d3_interpolateNumber(wa, wb)
+ });
+ } else if (wb) {
+ s.push(s.pop() + "skewX(" + wb + ")");
+ }
+ if (ka[0] != kb[0] || ka[1] != kb[1]) {
+ n = s.push(s.pop() + "scale(", null, ",", null, ")");
+ q.push({
+ i: n - 4,
+ x: d3_interpolateNumber(ka[0], kb[0])
+ }, {
+ i: n - 2,
+ x: d3_interpolateNumber(ka[1], kb[1])
+ });
+ } else if (kb[0] != 1 || kb[1] != 1) {
+ s.push(s.pop() + "scale(" + kb + ")");
+ }
+ n = q.length;
+ return function(t) {
+ var i = -1, o;
+ while (++i < n) s[(o = q[i]).i] = o.x(t);
+ return s.join("");
+ };
+ }
+ function d3_uninterpolateNumber(a, b) {
+ b = (b -= a = +a) || 1 / b;
+ return function(x) {
+ return (x - a) / b;
+ };
+ }
+ function d3_uninterpolateClamp(a, b) {
+ b = (b -= a = +a) || 1 / b;
+ return function(x) {
+ return Math.max(0, Math.min(1, (x - a) / b));
+ };
+ }
+ d3.layout = {};
+ d3.layout.bundle = function() {
+ return function(links) {
+ var paths = [], i = -1, n = links.length;
+ while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
+ return paths;
+ };
+ };
+ function d3_layout_bundlePath(link) {
+ var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [ start ];
+ while (start !== lca) {
+ start = start.parent;
+ points.push(start);
+ }
+ var k = points.length;
+ while (end !== lca) {
+ points.splice(k, 0, end);
+ end = end.parent;
+ }
+ return points;
+ }
+ function d3_layout_bundleAncestors(node) {
+ var ancestors = [], parent = node.parent;
+ while (parent != null) {
+ ancestors.push(node);
+ node = parent;
+ parent = parent.parent;
+ }
+ ancestors.push(node);
+ return ancestors;
+ }
+ function d3_layout_bundleLeastCommonAncestor(a, b) {
+ if (a === b) return a;
+ var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null;
+ while (aNode === bNode) {
+ sharedNode = aNode;
+ aNode = aNodes.pop();
+ bNode = bNodes.pop();
+ }
+ return sharedNode;
+ }
+ d3.layout.chord = function() {
+ var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;
+ function relayout() {
+ var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j;
+ chords = [];
+ groups = [];
+ k = 0, i = -1;
+ while (++i < n) {
+ x = 0, j = -1;
+ while (++j < n) {
+ x += matrix[i][j];
+ }
+ groupSums.push(x);
+ subgroupIndex.push(d3.range(n));
+ k += x;
+ }
+ if (sortGroups) {
+ groupIndex.sort(function(a, b) {
+ return sortGroups(groupSums[a], groupSums[b]);
+ });
+ }
+ if (sortSubgroups) {
+ subgroupIndex.forEach(function(d, i) {
+ d.sort(function(a, b) {
+ return sortSubgroups(matrix[i][a], matrix[i][b]);
+ });
+ });
+ }
+ k = (τ - padding * n) / k;
+ x = 0, i = -1;
+ while (++i < n) {
+ x0 = x, j = -1;
+ while (++j < n) {
+ var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;
+ subgroups[di + "-" + dj] = {
+ index: di,
+ subindex: dj,
+ startAngle: a0,
+ endAngle: a1,
+ value: v
+ };
+ }
+ groups[di] = {
+ index: di,
+ startAngle: x0,
+ endAngle: x,
+ value: (x - x0) / k
+ };
+ x += padding;
+ }
+ i = -1;
+ while (++i < n) {
+ j = i - 1;
+ while (++j < n) {
+ var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i];
+ if (source.value || target.value) {
+ chords.push(source.value < target.value ? {
+ source: target,
+ target: source
+ } : {
+ source: source,
+ target: target
+ });
+ }
+ }
+ }
+ if (sortChords) resort();
+ }
+ function resort() {
+ chords.sort(function(a, b) {
+ return sortChords((a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2);
+ });
+ }
+ chord.matrix = function(x) {
+ if (!arguments.length) return matrix;
+ n = (matrix = x) && matrix.length;
+ chords = groups = null;
+ return chord;
+ };
+ chord.padding = function(x) {
+ if (!arguments.length) return padding;
+ padding = x;
+ chords = groups = null;
+ return chord;
+ };
+ chord.sortGroups = function(x) {
+ if (!arguments.length) return sortGroups;
+ sortGroups = x;
+ chords = groups = null;
+ return chord;
+ };
+ chord.sortSubgroups = function(x) {
+ if (!arguments.length) return sortSubgroups;
+ sortSubgroups = x;
+ chords = null;
+ return chord;
+ };
+ chord.sortChords = function(x) {
+ if (!arguments.length) return sortChords;
+ sortChords = x;
+ if (chords) resort();
+ return chord;
+ };
+ chord.chords = function() {
+ if (!chords) relayout();
+ return chords;
+ };
+ chord.groups = function() {
+ if (!groups) relayout();
+ return groups;
+ };
+ return chord;
+ };
+ d3.layout.force = function() {
+ var force = {}, event = d3.dispatch("start", "tick", "end"), size = [ 1, 1 ], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = .1, theta2 = .64, nodes = [], links = [], distances, strengths, charges;
+ function repulse(node) {
+ return function(quad, x1, _, x2) {
+ if (quad.point !== node) {
+ var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy;
+ if (dw * dw / theta2 < dn) {
+ if (dn < chargeDistance2) {
+ var k = quad.charge / dn;
+ node.px -= dx * k;
+ node.py -= dy * k;
+ }
+ return true;
+ }
+ if (quad.point && dn && dn < chargeDistance2) {
+ var k = quad.pointCharge / dn;
+ node.px -= dx * k;
+ node.py -= dy * k;
+ }
+ }
+ return !quad.charge;
+ };
+ }
+ force.tick = function() {
+ if ((alpha *= .99) < .005) {
+ event.end({
+ type: "end",
+ alpha: alpha = 0
+ });
+ return true;
+ }
+ var n = nodes.length, m = links.length, q, i, o, s, t, l, k, x, y;
+ for (i = 0; i < m; ++i) {
+ o = links[i];
+ s = o.source;
+ t = o.target;
+ x = t.x - s.x;
+ y = t.y - s.y;
+ if (l = x * x + y * y) {
+ l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l;
+ x *= l;
+ y *= l;
+ t.x -= x * (k = s.weight / (t.weight + s.weight));
+ t.y -= y * k;
+ s.x += x * (k = 1 - k);
+ s.y += y * k;
+ }
+ }
+ if (k = alpha * gravity) {
+ x = size[0] / 2;
+ y = size[1] / 2;
+ i = -1;
+ if (k) while (++i < n) {
+ o = nodes[i];
+ o.x += (x - o.x) * k;
+ o.y += (y - o.y) * k;
+ }
+ }
+ if (charge) {
+ d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges);
+ i = -1;
+ while (++i < n) {
+ if (!(o = nodes[i]).fixed) {
+ q.visit(repulse(o));
+ }
+ }
+ }
+ i = -1;
+ while (++i < n) {
+ o = nodes[i];
+ if (o.fixed) {
+ o.x = o.px;
+ o.y = o.py;
+ } else {
+ o.x -= (o.px - (o.px = o.x)) * friction;
+ o.y -= (o.py - (o.py = o.y)) * friction;
+ }
+ }
+ event.tick({
+ type: "tick",
+ alpha: alpha
+ });
+ };
+ force.nodes = function(x) {
+ if (!arguments.length) return nodes;
+ nodes = x;
+ return force;
+ };
+ force.links = function(x) {
+ if (!arguments.length) return links;
+ links = x;
+ return force;
+ };
+ force.size = function(x) {
+ if (!arguments.length) return size;
+ size = x;
+ return force;
+ };
+ force.linkDistance = function(x) {
+ if (!arguments.length) return linkDistance;
+ linkDistance = typeof x === "function" ? x : +x;
+ return force;
+ };
+ force.distance = force.linkDistance;
+ force.linkStrength = function(x) {
+ if (!arguments.length) return linkStrength;
+ linkStrength = typeof x === "function" ? x : +x;
+ return force;
+ };
+ force.friction = function(x) {
+ if (!arguments.length) return friction;
+ friction = +x;
+ return force;
+ };
+ force.charge = function(x) {
+ if (!arguments.length) return charge;
+ charge = typeof x === "function" ? x : +x;
+ return force;
+ };
+ force.chargeDistance = function(x) {
+ if (!arguments.length) return Math.sqrt(chargeDistance2);
+ chargeDistance2 = x * x;
+ return force;
+ };
+ force.gravity = function(x) {
+ if (!arguments.length) return gravity;
+ gravity = +x;
+ return force;
+ };
+ force.theta = function(x) {
+ if (!arguments.length) return Math.sqrt(theta2);
+ theta2 = x * x;
+ return force;
+ };
+ force.alpha = function(x) {
+ if (!arguments.length) return alpha;
+ x = +x;
+ if (alpha) {
+ if (x > 0) alpha = x; else alpha = 0;
+ } else if (x > 0) {
+ event.start({
+ type: "start",
+ alpha: alpha = x
+ });
+ d3.timer(force.tick);
+ }
+ return force;
+ };
+ force.start = function() {
+ var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o;
+ for (i = 0; i < n; ++i) {
+ (o = nodes[i]).index = i;
+ o.weight = 0;
+ }
+ for (i = 0; i < m; ++i) {
+ o = links[i];
+ if (typeof o.source == "number") o.source = nodes[o.source];
+ if (typeof o.target == "number") o.target = nodes[o.target];
+ ++o.source.weight;
+ ++o.target.weight;
+ }
+ for (i = 0; i < n; ++i) {
+ o = nodes[i];
+ if (isNaN(o.x)) o.x = position("x", w);
+ if (isNaN(o.y)) o.y = position("y", h);
+ if (isNaN(o.px)) o.px = o.x;
+ if (isNaN(o.py)) o.py = o.y;
+ }
+ distances = [];
+ if (typeof linkDistance === "function") for (i = 0; i < m; ++i) distances[i] = +linkDistance.call(this, links[i], i); else for (i = 0; i < m; ++i) distances[i] = linkDistance;
+ strengths = [];
+ if (typeof linkStrength === "function") for (i = 0; i < m; ++i) strengths[i] = +linkStrength.call(this, links[i], i); else for (i = 0; i < m; ++i) strengths[i] = linkStrength;
+ charges = [];
+ if (typeof charge === "function") for (i = 0; i < n; ++i) charges[i] = +charge.call(this, nodes[i], i); else for (i = 0; i < n; ++i) charges[i] = charge;
+ function position(dimension, size) {
+ if (!neighbors) {
+ neighbors = new Array(n);
+ for (j = 0; j < n; ++j) {
+ neighbors[j] = [];
+ }
+ for (j = 0; j < m; ++j) {
+ var o = links[j];
+ neighbors[o.source.index].push(o.target);
+ neighbors[o.target.index].push(o.source);
+ }
+ }
+ var candidates = neighbors[i], j = -1, l = candidates.length, x;
+ while (++j < l) if (!isNaN(x = candidates[j][dimension])) return x;
+ return Math.random() * size;
+ }
+ return force.resume();
+ };
+ force.resume = function() {
+ return force.alpha(.1);
+ };
+ force.stop = function() {
+ return force.alpha(0);
+ };
+ force.drag = function() {
+ if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend);
+ if (!arguments.length) return drag;
+ this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag);
+ };
+ function dragmove(d) {
+ d.px = d3.event.x, d.py = d3.event.y;
+ force.resume();
+ }
+ return d3.rebind(force, event, "on");
+ };
+ function d3_layout_forceDragstart(d) {
+ d.fixed |= 2;
+ }
+ function d3_layout_forceDragend(d) {
+ d.fixed &= ~6;
+ }
+ function d3_layout_forceMouseover(d) {
+ d.fixed |= 4;
+ d.px = d.x, d.py = d.y;
+ }
+ function d3_layout_forceMouseout(d) {
+ d.fixed &= ~4;
+ }
+ function d3_layout_forceAccumulate(quad, alpha, charges) {
+ var cx = 0, cy = 0;
+ quad.charge = 0;
+ if (!quad.leaf) {
+ var nodes = quad.nodes, n = nodes.length, i = -1, c;
+ while (++i < n) {
+ c = nodes[i];
+ if (c == null) continue;
+ d3_layout_forceAccumulate(c, alpha, charges);
+ quad.charge += c.charge;
+ cx += c.charge * c.cx;
+ cy += c.charge * c.cy;
+ }
+ }
+ if (quad.point) {
+ if (!quad.leaf) {
+ quad.point.x += Math.random() - .5;
+ quad.point.y += Math.random() - .5;
+ }
+ var k = alpha * charges[quad.point.index];
+ quad.charge += quad.pointCharge = k;
+ cx += k * quad.point.x;
+ cy += k * quad.point.y;
+ }
+ quad.cx = cx / quad.charge;
+ quad.cy = cy / quad.charge;
+ }
+ var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity;
+ d3.layout.hierarchy = function() {
+ var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue;
+ function hierarchy(root) {
+ var stack = [ root ], nodes = [], node;
+ root.depth = 0;
+ while ((node = stack.pop()) != null) {
+ nodes.push(node);
+ if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) {
+ var n, childs, child;
+ while (--n >= 0) {
+ stack.push(child = childs[n]);
+ child.parent = node;
+ child.depth = node.depth + 1;
+ }
+ if (value) node.value = 0;
+ node.children = childs;
+ } else {
+ if (value) node.value = +value.call(hierarchy, node, node.depth) || 0;
+ delete node.children;
+ }
+ }
+ d3_layout_hierarchyVisitAfter(root, function(node) {
+ var childs, parent;
+ if (sort && (childs = node.children)) childs.sort(sort);
+ if (value && (parent = node.parent)) parent.value += node.value;
+ });
+ return nodes;
+ }
+ hierarchy.sort = function(x) {
+ if (!arguments.length) return sort;
+ sort = x;
+ return hierarchy;
+ };
+ hierarchy.children = function(x) {
+ if (!arguments.length) return children;
+ children = x;
+ return hierarchy;
+ };
+ hierarchy.value = function(x) {
+ if (!arguments.length) return value;
+ value = x;
+ return hierarchy;
+ };
+ hierarchy.revalue = function(root) {
+ if (value) {
+ d3_layout_hierarchyVisitBefore(root, function(node) {
+ if (node.children) node.value = 0;
+ });
+ d3_layout_hierarchyVisitAfter(root, function(node) {
+ var parent;
+ if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0;
+ if (parent = node.parent) parent.value += node.value;
+ });
+ }
+ return root;
+ };
+ return hierarchy;
+ };
+ function d3_layout_hierarchyRebind(object, hierarchy) {
+ d3.rebind(object, hierarchy, "sort", "children", "value");
+ object.nodes = object;
+ object.links = d3_layout_hierarchyLinks;
+ return object;
+ }
+ function d3_layout_hierarchyVisitBefore(node, callback) {
+ var nodes = [ node ];
+ while ((node = nodes.pop()) != null) {
+ callback(node);
+ if ((children = node.children) && (n = children.length)) {
+ var n, children;
+ while (--n >= 0) nodes.push(children[n]);
+ }
+ }
+ }
+ function d3_layout_hierarchyVisitAfter(node, callback) {
+ var nodes = [ node ], nodes2 = [];
+ while ((node = nodes.pop()) != null) {
+ nodes2.push(node);
+ if ((children = node.children) && (n = children.length)) {
+ var i = -1, n, children;
+ while (++i < n) nodes.push(children[i]);
+ }
+ }
+ while ((node = nodes2.pop()) != null) {
+ callback(node);
+ }
+ }
+ function d3_layout_hierarchyChildren(d) {
+ return d.children;
+ }
+ function d3_layout_hierarchyValue(d) {
+ return d.value;
+ }
+ function d3_layout_hierarchySort(a, b) {
+ return b.value - a.value;
+ }
+ function d3_layout_hierarchyLinks(nodes) {
+ return d3.merge(nodes.map(function(parent) {
+ return (parent.children || []).map(function(child) {
+ return {
+ source: parent,
+ target: child
+ };
+ });
+ }));
+ }
+ d3.layout.partition = function() {
+ var hierarchy = d3.layout.hierarchy(), size = [ 1, 1 ];
+ function position(node, x, dx, dy) {
+ var children = node.children;
+ node.x = x;
+ node.y = node.depth * dy;
+ node.dx = dx;
+ node.dy = dy;
+ if (children && (n = children.length)) {
+ var i = -1, n, c, d;
+ dx = node.value ? dx / node.value : 0;
+ while (++i < n) {
+ position(c = children[i], x, d = c.value * dx, dy);
+ x += d;
+ }
+ }
+ }
+ function depth(node) {
+ var children = node.children, d = 0;
+ if (children && (n = children.length)) {
+ var i = -1, n;
+ while (++i < n) d = Math.max(d, depth(children[i]));
+ }
+ return 1 + d;
+ }
+ function partition(d, i) {
+ var nodes = hierarchy.call(this, d, i);
+ position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
+ return nodes;
+ }
+ partition.size = function(x) {
+ if (!arguments.length) return size;
+ size = x;
+ return partition;
+ };
+ return d3_layout_hierarchyRebind(partition, hierarchy);
+ };
+ d3.layout.pie = function() {
+ var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0;
+ function pie(data) {
+ var n = data.length, values = data.map(function(d, i) {
+ return +value.call(pie, d, i);
+ }), a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle), da = (typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a, p = Math.min(Math.abs(da) / n, +(typeof padAngle === "function" ? padAngle.apply(this, arguments) : padAngle)), pa = p * (da < 0 ? -1 : 1), k = (da - n * pa) / d3.sum(values), index = d3.range(n), arcs = [], v;
+ if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) {
+ return values[j] - values[i];
+ } : function(i, j) {
+ return sort(data[i], data[j]);
+ });
+ index.forEach(function(i) {
+ arcs[i] = {
+ data: data[i],
+ value: v = values[i],
+ startAngle: a,
+ endAngle: a += v * k + pa,
+ padAngle: p
+ };
+ });
+ return arcs;
+ }
+ pie.value = function(_) {
+ if (!arguments.length) return value;
+ value = _;
+ return pie;
+ };
+ pie.sort = function(_) {
+ if (!arguments.length) return sort;
+ sort = _;
+ return pie;
+ };
+ pie.startAngle = function(_) {
+ if (!arguments.length) return startAngle;
+ startAngle = _;
+ return pie;
+ };
+ pie.endAngle = function(_) {
+ if (!arguments.length) return endAngle;
+ endAngle = _;
+ return pie;
+ };
+ pie.padAngle = function(_) {
+ if (!arguments.length) return padAngle;
+ padAngle = _;
+ return pie;
+ };
+ return pie;
+ };
+ var d3_layout_pieSortByValue = {};
+ d3.layout.stack = function() {
+ var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY;
+ function stack(data, index) {
+ if (!(n = data.length)) return data;
+ var series = data.map(function(d, i) {
+ return values.call(stack, d, i);
+ });
+ var points = series.map(function(d) {
+ return d.map(function(v, i) {
+ return [ x.call(stack, v, i), y.call(stack, v, i) ];
+ });
+ });
+ var orders = order.call(stack, points, index);
+ series = d3.permute(series, orders);
+ points = d3.permute(points, orders);
+ var offsets = offset.call(stack, points, index);
+ var m = series[0].length, n, i, j, o;
+ for (j = 0; j < m; ++j) {
+ out.call(stack, series[0][j], o = offsets[j], points[0][j][1]);
+ for (i = 1; i < n; ++i) {
+ out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]);
+ }
+ }
+ return data;
+ }
+ stack.values = function(x) {
+ if (!arguments.length) return values;
+ values = x;
+ return stack;
+ };
+ stack.order = function(x) {
+ if (!arguments.length) return order;
+ order = typeof x === "function" ? x : d3_layout_stackOrders.get(x) || d3_layout_stackOrderDefault;
+ return stack;
+ };
+ stack.offset = function(x) {
+ if (!arguments.length) return offset;
+ offset = typeof x === "function" ? x : d3_layout_stackOffsets.get(x) || d3_layout_stackOffsetZero;
+ return stack;
+ };
+ stack.x = function(z) {
+ if (!arguments.length) return x;
+ x = z;
+ return stack;
+ };
+ stack.y = function(z) {
+ if (!arguments.length) return y;
+ y = z;
+ return stack;
+ };
+ stack.out = function(z) {
+ if (!arguments.length) return out;
+ out = z;
+ return stack;
+ };
+ return stack;
+ };
+ function d3_layout_stackX(d) {
+ return d.x;
+ }
+ function d3_layout_stackY(d) {
+ return d.y;
+ }
+ function d3_layout_stackOut(d, y0, y) {
+ d.y0 = y0;
+ d.y = y;
+ }
+ var d3_layout_stackOrders = d3.map({
+ "inside-out": function(data) {
+ var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) {
+ return max[a] - max[b];
+ }), top = 0, bottom = 0, tops = [], bottoms = [];
+ for (i = 0; i < n; ++i) {
+ j = index[i];
+ if (top < bottom) {
+ top += sums[j];
+ tops.push(j);
+ } else {
+ bottom += sums[j];
+ bottoms.push(j);
+ }
+ }
+ return bottoms.reverse().concat(tops);
+ },
+ reverse: function(data) {
+ return d3.range(data.length).reverse();
+ },
+ "default": d3_layout_stackOrderDefault
+ });
+ var d3_layout_stackOffsets = d3.map({
+ silhouette: function(data) {
+ var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = [];
+ for (j = 0; j < m; ++j) {
+ for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
+ if (o > max) max = o;
+ sums.push(o);
+ }
+ for (j = 0; j < m; ++j) {
+ y0[j] = (max - sums[j]) / 2;
+ }
+ return y0;
+ },
+ wiggle: function(data) {
+ var n = data.length, x = data[0], m = x.length, i, j, k, s1, s2, s3, dx, o, o0, y0 = [];
+ y0[0] = o = o0 = 0;
+ for (j = 1; j < m; ++j) {
+ for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1];
+ for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) {
+ for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) {
+ s3 += (data[k][j][1] - data[k][j - 1][1]) / dx;
+ }
+ s2 += s3 * data[i][j][1];
+ }
+ y0[j] = o -= s1 ? s2 / s1 * dx : 0;
+ if (o < o0) o0 = o;
+ }
+ for (j = 0; j < m; ++j) y0[j] -= o0;
+ return y0;
+ },
+ expand: function(data) {
+ var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = [];
+ for (j = 0; j < m; ++j) {
+ for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
+ if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k;
+ }
+ for (j = 0; j < m; ++j) y0[j] = 0;
+ return y0;
+ },
+ zero: d3_layout_stackOffsetZero
+ });
+ function d3_layout_stackOrderDefault(data) {
+ return d3.range(data.length);
+ }
+ function d3_layout_stackOffsetZero(data) {
+ var j = -1, m = data[0].length, y0 = [];
+ while (++j < m) y0[j] = 0;
+ return y0;
+ }
+ function d3_layout_stackMaxIndex(array) {
+ var i = 1, j = 0, v = array[0][1], k, n = array.length;
+ for (;i < n; ++i) {
+ if ((k = array[i][1]) > v) {
+ j = i;
+ v = k;
+ }
+ }
+ return j;
+ }
+ function d3_layout_stackReduceSum(d) {
+ return d.reduce(d3_layout_stackSum, 0);
+ }
+ function d3_layout_stackSum(p, d) {
+ return p + d[1];
+ }
+ d3.layout.histogram = function() {
+ var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges;
+ function histogram(data, i) {
+ var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x;
+ while (++i < m) {
+ bin = bins[i] = [];
+ bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]);
+ bin.y = 0;
+ }
+ if (m > 0) {
+ i = -1;
+ while (++i < n) {
+ x = values[i];
+ if (x >= range[0] && x <= range[1]) {
+ bin = bins[d3.bisect(thresholds, x, 1, m) - 1];
+ bin.y += k;
+ bin.push(data[i]);
+ }
+ }
+ }
+ return bins;
+ }
+ histogram.value = function(x) {
+ if (!arguments.length) return valuer;
+ valuer = x;
+ return histogram;
+ };
+ histogram.range = function(x) {
+ if (!arguments.length) return ranger;
+ ranger = d3_functor(x);
+ return histogram;
+ };
+ histogram.bins = function(x) {
+ if (!arguments.length) return binner;
+ binner = typeof x === "number" ? function(range) {
+ return d3_layout_histogramBinFixed(range, x);
+ } : d3_functor(x);
+ return histogram;
+ };
+ histogram.frequency = function(x) {
+ if (!arguments.length) return frequency;
+ frequency = !!x;
+ return histogram;
+ };
+ return histogram;
+ };
+ function d3_layout_histogramBinSturges(range, values) {
+ return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1));
+ }
+ function d3_layout_histogramBinFixed(range, n) {
+ var x = -1, b = +range[0], m = (range[1] - b) / n, f = [];
+ while (++x <= n) f[x] = m * x + b;
+ return f;
+ }
+ function d3_layout_histogramRange(values) {
+ return [ d3.min(values), d3.max(values) ];
+ }
+ d3.layout.pack = function() {
+ var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [ 1, 1 ], radius;
+ function pack(d, i) {
+ var nodes = hierarchy.call(this, d, i), root = nodes[0], w = size[0], h = size[1], r = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() {
+ return radius;
+ };
+ root.x = root.y = 0;
+ d3_layout_hierarchyVisitAfter(root, function(d) {
+ d.r = +r(d.value);
+ });
+ d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+ if (padding) {
+ var dr = padding * (radius ? 1 : Math.max(2 * root.r / w, 2 * root.r / h)) / 2;
+ d3_layout_hierarchyVisitAfter(root, function(d) {
+ d.r += dr;
+ });
+ d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+ d3_layout_hierarchyVisitAfter(root, function(d) {
+ d.r -= dr;
+ });
+ }
+ d3_layout_packTransform(root, w / 2, h / 2, radius ? 1 : 1 / Math.max(2 * root.r / w, 2 * root.r / h));
+ return nodes;
+ }
+ pack.size = function(_) {
+ if (!arguments.length) return size;
+ size = _;
+ return pack;
+ };
+ pack.radius = function(_) {
+ if (!arguments.length) return radius;
+ radius = _ == null || typeof _ === "function" ? _ : +_;
+ return pack;
+ };
+ pack.padding = function(_) {
+ if (!arguments.length) return padding;
+ padding = +_;
+ return pack;
+ };
+ return d3_layout_hierarchyRebind(pack, hierarchy);
+ };
+ function d3_layout_packSort(a, b) {
+ return a.value - b.value;
+ }
+ function d3_layout_packInsert(a, b) {
+ var c = a._pack_next;
+ a._pack_next = b;
+ b._pack_prev = a;
+ b._pack_next = c;
+ c._pack_prev = b;
+ }
+ function d3_layout_packSplice(a, b) {
+ a._pack_next = b;
+ b._pack_prev = a;
+ }
+ function d3_layout_packIntersects(a, b) {
+ var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r;
+ return .999 * dr * dr > dx * dx + dy * dy;
+ }
+ function d3_layout_packSiblings(node) {
+ if (!(nodes = node.children) || !(n = nodes.length)) return;
+ var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a, b, c, i, j, k, n;
+ function bound(node) {
+ xMin = Math.min(node.x - node.r, xMin);
+ xMax = Math.max(node.x + node.r, xMax);
+ yMin = Math.min(node.y - node.r, yMin);
+ yMax = Math.max(node.y + node.r, yMax);
+ }
+ nodes.forEach(d3_layout_packLink);
+ a = nodes[0];
+ a.x = -a.r;
+ a.y = 0;
+ bound(a);
+ if (n > 1) {
+ b = nodes[1];
+ b.x = b.r;
+ b.y = 0;
+ bound(b);
+ if (n > 2) {
+ c = nodes[2];
+ d3_layout_packPlace(a, b, c);
+ bound(c);
+ d3_layout_packInsert(a, c);
+ a._pack_prev = c;
+ d3_layout_packInsert(c, b);
+ b = a._pack_next;
+ for (i = 3; i < n; i++) {
+ d3_layout_packPlace(a, b, c = nodes[i]);
+ var isect = 0, s1 = 1, s2 = 1;
+ for (j = b._pack_next; j !== b; j = j._pack_next, s1++) {
+ if (d3_layout_packIntersects(j, c)) {
+ isect = 1;
+ break;
+ }
+ }
+ if (isect == 1) {
+ for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) {
+ if (d3_layout_packIntersects(k, c)) {
+ break;
+ }
+ }
+ }
+ if (isect) {
+ if (s1 < s2 || s1 == s2 && b.r < a.r) d3_layout_packSplice(a, b = j); else d3_layout_packSplice(a = k, b);
+ i--;
+ } else {
+ d3_layout_packInsert(a, c);
+ b = c;
+ bound(c);
+ }
+ }
+ }
+ }
+ var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0;
+ for (i = 0; i < n; i++) {
+ c = nodes[i];
+ c.x -= cx;
+ c.y -= cy;
+ cr = Math.max(cr, c.r + Math.sqrt(c.x * c.x + c.y * c.y));
+ }
+ node.r = cr;
+ nodes.forEach(d3_layout_packUnlink);
+ }
+ function d3_layout_packLink(node) {
+ node._pack_next = node._pack_prev = node;
+ }
+ function d3_layout_packUnlink(node) {
+ delete node._pack_next;
+ delete node._pack_prev;
+ }
+ function d3_layout_packTransform(node, x, y, k) {
+ var children = node.children;
+ node.x = x += k * node.x;
+ node.y = y += k * node.y;
+ node.r *= k;
+ if (children) {
+ var i = -1, n = children.length;
+ while (++i < n) d3_layout_packTransform(children[i], x, y, k);
+ }
+ }
+ function d3_layout_packPlace(a, b, c) {
+ var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y;
+ if (db && (dx || dy)) {
+ var da = b.r + c.r, dc = dx * dx + dy * dy;
+ da *= da;
+ db *= db;
+ var x = .5 + (db - da) / (2 * dc), y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);
+ c.x = a.x + x * dx + y * dy;
+ c.y = a.y + x * dy - y * dx;
+ } else {
+ c.x = a.x + db;
+ c.y = a.y;
+ }
+ }
+ d3.layout.tree = function() {
+ var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = null;
+ function tree(d, i) {
+ var nodes = hierarchy.call(this, d, i), root0 = nodes[0], root1 = wrapTree(root0);
+ d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z;
+ d3_layout_hierarchyVisitBefore(root1, secondWalk);
+ if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode); else {
+ var left = root0, right = root0, bottom = root0;
+ d3_layout_hierarchyVisitBefore(root0, function(node) {
+ if (node.x < left.x) left = node;
+ if (node.x > right.x) right = node;
+ if (node.depth > bottom.depth) bottom = node;
+ });
+ var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1);
+ d3_layout_hierarchyVisitBefore(root0, function(node) {
+ node.x = (node.x + tx) * kx;
+ node.y = node.depth * ky;
+ });
+ }
+ return nodes;
+ }
+ function wrapTree(root0) {
+ var root1 = {
+ A: null,
+ children: [ root0 ]
+ }, queue = [ root1 ], node1;
+ while ((node1 = queue.pop()) != null) {
+ for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) {
+ queue.push((children[i] = child = {
+ _: children[i],
+ parent: node1,
+ children: (child = children[i].children) && child.slice() || [],
+ A: null,
+ a: null,
+ z: 0,
+ m: 0,
+ c: 0,
+ s: 0,
+ t: null,
+ i: i
+ }).a = child);
+ }
+ }
+ return root1.children[0];
+ }
+ function firstWalk(v) {
+ var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null;
+ if (children.length) {
+ d3_layout_treeShift(v);
+ var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+ if (w) {
+ v.z = w.z + separation(v._, w._);
+ v.m = v.z - midpoint;
+ } else {
+ v.z = midpoint;
+ }
+ } else if (w) {
+ v.z = w.z + separation(v._, w._);
+ }
+ v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
+ }
+ function secondWalk(v) {
+ v._.x = v.z + v.parent.m;
+ v.m += v.parent.m;
+ }
+ function apportion(v, w, ancestor) {
+ if (w) {
+ var vip = v, vop = v, vim = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
+ while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) {
+ vom = d3_layout_treeLeft(vom);
+ vop = d3_layout_treeRight(vop);
+ vop.a = v;
+ shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+ if (shift > 0) {
+ d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift);
+ sip += shift;
+ sop += shift;
+ }
+ sim += vim.m;
+ sip += vip.m;
+ som += vom.m;
+ sop += vop.m;
+ }
+ if (vim && !d3_layout_treeRight(vop)) {
+ vop.t = vim;
+ vop.m += sim - sop;
+ }
+ if (vip && !d3_layout_treeLeft(vom)) {
+ vom.t = vip;
+ vom.m += sip - som;
+ ancestor = v;
+ }
+ }
+ return ancestor;
+ }
+ function sizeNode(node) {
+ node.x *= size[0];
+ node.y = node.depth * size[1];
+ }
+ tree.separation = function(x) {
+ if (!arguments.length) return separation;
+ separation = x;
+ return tree;
+ };
+ tree.size = function(x) {
+ if (!arguments.length) return nodeSize ? null : size;
+ nodeSize = (size = x) == null ? sizeNode : null;
+ return tree;
+ };
+ tree.nodeSize = function(x) {
+ if (!arguments.length) return nodeSize ? size : null;
+ nodeSize = (size = x) == null ? null : sizeNode;
+ return tree;
+ };
+ return d3_layout_hierarchyRebind(tree, hierarchy);
+ };
+ function d3_layout_treeSeparation(a, b) {
+ return a.parent == b.parent ? 1 : 2;
+ }
+ function d3_layout_treeLeft(v) {
+ var children = v.children;
+ return children.length ? children[0] : v.t;
+ }
+ function d3_layout_treeRight(v) {
+ var children = v.children, n;
+ return (n = children.length) ? children[n - 1] : v.t;
+ }
+ function d3_layout_treeMove(wm, wp, shift) {
+ var change = shift / (wp.i - wm.i);
+ wp.c -= change;
+ wp.s += shift;
+ wm.c += change;
+ wp.z += shift;
+ wp.m += shift;
+ }
+ function d3_layout_treeShift(v) {
+ var shift = 0, change = 0, children = v.children, i = children.length, w;
+ while (--i >= 0) {
+ w = children[i];
+ w.z += shift;
+ w.m += shift;
+ shift += w.s + (change += w.c);
+ }
+ }
+ function d3_layout_treeAncestor(vim, v, ancestor) {
+ return vim.a.parent === v.parent ? vim.a : ancestor;
+ }
+ d3.layout.cluster = function() {
+ var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = false;
+ function cluster(d, i) {
+ var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0;
+ d3_layout_hierarchyVisitAfter(root, function(node) {
+ var children = node.children;
+ if (children && children.length) {
+ node.x = d3_layout_clusterX(children);
+ node.y = d3_layout_clusterY(children);
+ } else {
+ node.x = previousNode ? x += separation(node, previousNode) : 0;
+ node.y = 0;
+ previousNode = node;
+ }
+ });
+ var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
+ d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) {
+ node.x = (node.x - root.x) * size[0];
+ node.y = (root.y - node.y) * size[1];
+ } : function(node) {
+ node.x = (node.x - x0) / (x1 - x0) * size[0];
+ node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1];
+ });
+ return nodes;
+ }
+ cluster.separation = function(x) {
+ if (!arguments.length) return separation;
+ separation = x;
+ return cluster;
+ };
+ cluster.size = function(x) {
+ if (!arguments.length) return nodeSize ? null : size;
+ nodeSize = (size = x) == null;
+ return cluster;
+ };
+ cluster.nodeSize = function(x) {
+ if (!arguments.length) return nodeSize ? size : null;
+ nodeSize = (size = x) != null;
+ return cluster;
+ };
+ return d3_layout_hierarchyRebind(cluster, hierarchy);
+ };
+ function d3_layout_clusterY(children) {
+ return 1 + d3.max(children, function(child) {
+ return child.y;
+ });
+ }
+ function d3_layout_clusterX(children) {
+ return children.reduce(function(x, child) {
+ return x + child.x;
+ }, 0) / children.length;
+ }
+ function d3_layout_clusterLeft(node) {
+ var children = node.children;
+ return children && children.length ? d3_layout_clusterLeft(children[0]) : node;
+ }
+ function d3_layout_clusterRight(node) {
+ var children = node.children, n;
+ return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node;
+ }
+ d3.layout.treemap = function() {
+ var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [ 1, 1 ], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = .5 * (1 + Math.sqrt(5));
+ function scale(children, k) {
+ var i = -1, n = children.length, child, area;
+ while (++i < n) {
+ area = (child = children[i]).value * (k < 0 ? 0 : k);
+ child.area = isNaN(area) || area <= 0 ? 0 : area;
+ }
+ }
+ function squarify(node) {
+ var children = node.children;
+ if (children && children.length) {
+ var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n;
+ scale(remaining, rect.dx * rect.dy / node.value);
+ row.area = 0;
+ while ((n = remaining.length) > 0) {
+ row.push(child = remaining[n - 1]);
+ row.area += child.area;
+ if (mode !== "squarify" || (score = worst(row, u)) <= best) {
+ remaining.pop();
+ best = score;
+ } else {
+ row.area -= row.pop().area;
+ position(row, u, rect, false);
+ u = Math.min(rect.dx, rect.dy);
+ row.length = row.area = 0;
+ best = Infinity;
+ }
+ }
+ if (row.length) {
+ position(row, u, rect, true);
+ row.length = row.area = 0;
+ }
+ children.forEach(squarify);
+ }
+ }
+ function stickify(node) {
+ var children = node.children;
+ if (children && children.length) {
+ var rect = pad(node), remaining = children.slice(), child, row = [];
+ scale(remaining, rect.dx * rect.dy / node.value);
+ row.area = 0;
+ while (child = remaining.pop()) {
+ row.push(child);
+ row.area += child.area;
+ if (child.z != null) {
+ position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length);
+ row.length = row.area = 0;
+ }
+ }
+ children.forEach(stickify);
+ }
+ }
+ function worst(row, u) {
+ var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length;
+ while (++i < n) {
+ if (!(r = row[i].area)) continue;
+ if (r < rmin) rmin = r;
+ if (r > rmax) rmax = r;
+ }
+ s *= s;
+ u *= u;
+ return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity;
+ }
+ function position(row, u, rect, flush) {
+ var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o;
+ if (u == rect.dx) {
+ if (flush || v > rect.dy) v = rect.dy;
+ while (++i < n) {
+ o = row[i];
+ o.x = x;
+ o.y = y;
+ o.dy = v;
+ x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0);
+ }
+ o.z = true;
+ o.dx += rect.x + rect.dx - x;
+ rect.y += v;
+ rect.dy -= v;
+ } else {
+ if (flush || v > rect.dx) v = rect.dx;
+ while (++i < n) {
+ o = row[i];
+ o.x = x;
+ o.y = y;
+ o.dx = v;
+ y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0);
+ }
+ o.z = false;
+ o.dy += rect.y + rect.dy - y;
+ rect.x += v;
+ rect.dx -= v;
+ }
+ }
+ function treemap(d) {
+ var nodes = stickies || hierarchy(d), root = nodes[0];
+ root.x = 0;
+ root.y = 0;
+ root.dx = size[0];
+ root.dy = size[1];
+ if (stickies) hierarchy.revalue(root);
+ scale([ root ], root.dx * root.dy / root.value);
+ (stickies ? stickify : squarify)(root);
+ if (sticky) stickies = nodes;
+ return nodes;
+ }
+ treemap.size = function(x) {
+ if (!arguments.length) return size;
+ size = x;
+ return treemap;
+ };
+ treemap.padding = function(x) {
+ if (!arguments.length) return padding;
+ function padFunction(node) {
+ var p = x.call(treemap, node, node.depth);
+ return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [ p, p, p, p ] : p);
+ }
+ function padConstant(node) {
+ return d3_layout_treemapPad(node, x);
+ }
+ var type;
+ pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [ x, x, x, x ],
+ padConstant) : padConstant;
+ return treemap;
+ };
+ treemap.round = function(x) {
+ if (!arguments.length) return round != Number;
+ round = x ? Math.round : Number;
+ return treemap;
+ };
+ treemap.sticky = function(x) {
+ if (!arguments.length) return sticky;
+ sticky = x;
+ stickies = null;
+ return treemap;
+ };
+ treemap.ratio = function(x) {
+ if (!arguments.length) return ratio;
+ ratio = x;
+ return treemap;
+ };
+ treemap.mode = function(x) {
+ if (!arguments.length) return mode;
+ mode = x + "";
+ return treemap;
+ };
+ return d3_layout_hierarchyRebind(treemap, hierarchy);
+ };
+ function d3_layout_treemapPadNull(node) {
+ return {
+ x: node.x,
+ y: node.y,
+ dx: node.dx,
+ dy: node.dy
+ };
+ }
+ function d3_layout_treemapPad(node, padding) {
+ var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2];
+ if (dx < 0) {
+ x += dx / 2;
+ dx = 0;
+ }
+ if (dy < 0) {
+ y += dy / 2;
+ dy = 0;
+ }
+ return {
+ x: x,
+ y: y,
+ dx: dx,
+ dy: dy
+ };
+ }
+ d3.random = {
+ normal: function(µ, σ) {
+ var n = arguments.length;
+ if (n < 2) σ = 1;
+ if (n < 1) µ = 0;
+ return function() {
+ var x, y, r;
+ do {
+ x = Math.random() * 2 - 1;
+ y = Math.random() * 2 - 1;
+ r = x * x + y * y;
+ } while (!r || r > 1);
+ return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r);
+ };
+ },
+ logNormal: function() {
+ var random = d3.random.normal.apply(d3, arguments);
+ return function() {
+ return Math.exp(random());
+ };
+ },
+ bates: function(m) {
+ var random = d3.random.irwinHall(m);
+ return function() {
+ return random() / m;
+ };
+ },
+ irwinHall: function(m) {
+ return function() {
+ for (var s = 0, j = 0; j < m; j++) s += Math.random();
+ return s;
+ };
+ }
+ };
+ d3.scale = {};
+ function d3_scaleExtent(domain) {
+ var start = domain[0], stop = domain[domain.length - 1];
+ return start < stop ? [ start, stop ] : [ stop, start ];
+ }
+ function d3_scaleRange(scale) {
+ return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range());
+ }
+ function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
+ var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]);
+ return function(x) {
+ return i(u(x));
+ };
+ }
+ function d3_scale_nice(domain, nice) {
+ var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx;
+ if (x1 < x0) {
+ dx = i0, i0 = i1, i1 = dx;
+ dx = x0, x0 = x1, x1 = dx;
+ }
+ domain[i0] = nice.floor(x0);
+ domain[i1] = nice.ceil(x1);
+ return domain;
+ }
+ function d3_scale_niceStep(step) {
+ return step ? {
+ floor: function(x) {
+ return Math.floor(x / step) * step;
+ },
+ ceil: function(x) {
+ return Math.ceil(x / step) * step;
+ }
+ } : d3_scale_niceIdentity;
+ }
+ var d3_scale_niceIdentity = {
+ floor: d3_identity,
+ ceil: d3_identity
+ };
+ function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
+ var u = [], i = [], j = 0, k = Math.min(domain.length, range.length) - 1;
+ if (domain[k] < domain[0]) {
+ domain = domain.slice().reverse();
+ range = range.slice().reverse();
+ }
+ while (++j <= k) {
+ u.push(uninterpolate(domain[j - 1], domain[j]));
+ i.push(interpolate(range[j - 1], range[j]));
+ }
+ return function(x) {
+ var j = d3.bisect(domain, x, 1, k) - 1;
+ return i[j](u[j](x));
+ };
+ }
+ d3.scale.linear = function() {
+ return d3_scale_linear([ 0, 1 ], [ 0, 1 ], d3_interpolate, false);
+ };
+ function d3_scale_linear(domain, range, interpolate, clamp) {
+ var output, input;
+ function rescale() {
+ var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
+ output = linear(domain, range, uninterpolate, interpolate);
+ input = linear(range, domain, uninterpolate, d3_interpolate);
+ return scale;
+ }
+ function scale(x) {
+ return output(x);
+ }
+ scale.invert = function(y) {
+ return input(y);
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ domain = x.map(Number);
+ return rescale();
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ return rescale();
+ };
+ scale.rangeRound = function(x) {
+ return scale.range(x).interpolate(d3_interpolateRound);
+ };
+ scale.clamp = function(x) {
+ if (!arguments.length) return clamp;
+ clamp = x;
+ return rescale();
+ };
+ scale.interpolate = function(x) {
+ if (!arguments.length) return interpolate;
+ interpolate = x;
+ return rescale();
+ };
+ scale.ticks = function(m) {
+ return d3_scale_linearTicks(domain, m);
+ };
+ scale.tickFormat = function(m, format) {
+ return d3_scale_linearTickFormat(domain, m, format);
+ };
+ scale.nice = function(m) {
+ d3_scale_linearNice(domain, m);
+ return rescale();
+ };
+ scale.copy = function() {
+ return d3_scale_linear(domain, range, interpolate, clamp);
+ };
+ return rescale();
+ }
+ function d3_scale_linearRebind(scale, linear) {
+ return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp");
+ }
+ function d3_scale_linearNice(domain, m) {
+ return d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+ }
+ function d3_scale_linearTickRange(domain, m) {
+ if (m == null) m = 10;
+ var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step;
+ if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2;
+ extent[0] = Math.ceil(extent[0] / step) * step;
+ extent[1] = Math.floor(extent[1] / step) * step + step * .5;
+ extent[2] = step;
+ return extent;
+ }
+ function d3_scale_linearTicks(domain, m) {
+ return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
+ }
+ function d3_scale_linearTickFormat(domain, m, format) {
+ var range = d3_scale_linearTickRange(domain, m);
+ if (format) {
+ var match = d3_format_re.exec(format);
+ match.shift();
+ if (match[8] === "s") {
+ var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1])));
+ if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2]));
+ match[8] = "f";
+ format = d3.format(match.join(""));
+ return function(d) {
+ return format(prefix.scale(d)) + prefix.symbol;
+ };
+ }
+ if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range);
+ format = match.join("");
+ } else {
+ format = ",." + d3_scale_linearPrecision(range[2]) + "f";
+ }
+ return d3.format(format);
+ }
+ var d3_scale_linearFormatSignificant = {
+ s: 1,
+ g: 1,
+ p: 1,
+ r: 1,
+ e: 1
+ };
+ function d3_scale_linearPrecision(value) {
+ return -Math.floor(Math.log(value) / Math.LN10 + .01);
+ }
+ function d3_scale_linearFormatPrecision(type, range) {
+ var p = d3_scale_linearPrecision(range[2]);
+ return type in d3_scale_linearFormatSignificant ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e") : p - (type === "%") * 2;
+ }
+ d3.scale.log = function() {
+ return d3_scale_log(d3.scale.linear().domain([ 0, 1 ]), 10, true, [ 1, 10 ]);
+ };
+ function d3_scale_log(linear, base, positive, domain) {
+ function log(x) {
+ return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base);
+ }
+ function pow(x) {
+ return positive ? Math.pow(base, x) : -Math.pow(base, -x);
+ }
+ function scale(x) {
+ return linear(log(x));
+ }
+ scale.invert = function(x) {
+ return pow(linear.invert(x));
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ positive = x[0] >= 0;
+ linear.domain((domain = x.map(Number)).map(log));
+ return scale;
+ };
+ scale.base = function(_) {
+ if (!arguments.length) return base;
+ base = +_;
+ linear.domain(domain.map(log));
+ return scale;
+ };
+ scale.nice = function() {
+ var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative);
+ linear.domain(niced);
+ domain = niced.map(pow);
+ return scale;
+ };
+ scale.ticks = function() {
+ var extent = d3_scaleExtent(domain), ticks = [], u = extent[0], v = extent[1], i = Math.floor(log(u)), j = Math.ceil(log(v)), n = base % 1 ? 2 : base;
+ if (isFinite(j - i)) {
+ if (positive) {
+ for (;i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k);
+ ticks.push(pow(i));
+ } else {
+ ticks.push(pow(i));
+ for (;i++ < j; ) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k);
+ }
+ for (i = 0; ticks[i] < u; i++) {}
+ for (j = ticks.length; ticks[j - 1] > v; j--) {}
+ ticks = ticks.slice(i, j);
+ }
+ return ticks;
+ };
+ scale.tickFormat = function(n, format) {
+ if (!arguments.length) return d3_scale_logFormat;
+ if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format);
+ var k = Math.max(.1, n / scale.ticks().length), f = positive ? (e = 1e-12, Math.ceil) : (e = -1e-12,
+ Math.floor), e;
+ return function(d) {
+ return d / pow(f(log(d) + e)) <= k ? format(d) : "";
+ };
+ };
+ scale.copy = function() {
+ return d3_scale_log(linear.copy(), base, positive, domain);
+ };
+ return d3_scale_linearRebind(scale, linear);
+ }
+ var d3_scale_logFormat = d3.format(".0e"), d3_scale_logNiceNegative = {
+ floor: function(x) {
+ return -Math.ceil(-x);
+ },
+ ceil: function(x) {
+ return -Math.floor(-x);
+ }
+ };
+ d3.scale.pow = function() {
+ return d3_scale_pow(d3.scale.linear(), 1, [ 0, 1 ]);
+ };
+ function d3_scale_pow(linear, exponent, domain) {
+ var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent);
+ function scale(x) {
+ return linear(powp(x));
+ }
+ scale.invert = function(x) {
+ return powb(linear.invert(x));
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ linear.domain((domain = x.map(Number)).map(powp));
+ return scale;
+ };
+ scale.ticks = function(m) {
+ return d3_scale_linearTicks(domain, m);
+ };
+ scale.tickFormat = function(m, format) {
+ return d3_scale_linearTickFormat(domain, m, format);
+ };
+ scale.nice = function(m) {
+ return scale.domain(d3_scale_linearNice(domain, m));
+ };
+ scale.exponent = function(x) {
+ if (!arguments.length) return exponent;
+ powp = d3_scale_powPow(exponent = x);
+ powb = d3_scale_powPow(1 / exponent);
+ linear.domain(domain.map(powp));
+ return scale;
+ };
+ scale.copy = function() {
+ return d3_scale_pow(linear.copy(), exponent, domain);
+ };
+ return d3_scale_linearRebind(scale, linear);
+ }
+ function d3_scale_powPow(e) {
+ return function(x) {
+ return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
+ };
+ }
+ d3.scale.sqrt = function() {
+ return d3.scale.pow().exponent(.5);
+ };
+ d3.scale.ordinal = function() {
+ return d3_scale_ordinal([], {
+ t: "range",
+ a: [ [] ]
+ });
+ };
+ function d3_scale_ordinal(domain, ranger) {
+ var index, range, rangeBand;
+ function scale(x) {
+ return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length];
+ }
+ function steps(start, step) {
+ return d3.range(domain.length).map(function(i) {
+ return start + step * i;
+ });
+ }
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ domain = [];
+ index = new d3_Map();
+ var i = -1, n = x.length, xi;
+ while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi));
+ return scale[ranger.t].apply(scale, ranger.a);
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ rangeBand = 0;
+ ranger = {
+ t: "range",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangePoints = function(x, padding) {
+ if (arguments.length < 2) padding = 0;
+ var start = x[0], stop = x[1], step = domain.length < 2 ? (start = (start + stop) / 2,
+ 0) : (stop - start) / (domain.length - 1 + padding);
+ range = steps(start + step * padding / 2, step);
+ rangeBand = 0;
+ ranger = {
+ t: "rangePoints",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeRoundPoints = function(x, padding) {
+ if (arguments.length < 2) padding = 0;
+ var start = x[0], stop = x[1], step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2),
+ 0) : (stop - start) / (domain.length - 1 + padding) | 0;
+ range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step);
+ rangeBand = 0;
+ ranger = {
+ t: "rangeRoundPoints",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeBands = function(x, padding, outerPadding) {
+ if (arguments.length < 2) padding = 0;
+ if (arguments.length < 3) outerPadding = padding;
+ var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding);
+ range = steps(start + step * outerPadding, step);
+ if (reverse) range.reverse();
+ rangeBand = step * (1 - padding);
+ ranger = {
+ t: "rangeBands",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeRoundBands = function(x, padding, outerPadding) {
+ if (arguments.length < 2) padding = 0;
+ if (arguments.length < 3) outerPadding = padding;
+ var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding));
+ range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step);
+ if (reverse) range.reverse();
+ rangeBand = Math.round(step * (1 - padding));
+ ranger = {
+ t: "rangeRoundBands",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeBand = function() {
+ return rangeBand;
+ };
+ scale.rangeExtent = function() {
+ return d3_scaleExtent(ranger.a[0]);
+ };
+ scale.copy = function() {
+ return d3_scale_ordinal(domain, ranger);
+ };
+ return scale.domain(domain);
+ }
+ d3.scale.category10 = function() {
+ return d3.scale.ordinal().range(d3_category10);
+ };
+ d3.scale.category20 = function() {
+ return d3.scale.ordinal().range(d3_category20);
+ };
+ d3.scale.category20b = function() {
+ return d3.scale.ordinal().range(d3_category20b);
+ };
+ d3.scale.category20c = function() {
+ return d3.scale.ordinal().range(d3_category20c);
+ };
+ var d3_category10 = [ 2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175 ].map(d3_rgbString);
+ var d3_category20 = [ 2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725 ].map(d3_rgbString);
+ var d3_category20b = [ 3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654 ].map(d3_rgbString);
+ var d3_category20c = [ 3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081 ].map(d3_rgbString);
+ d3.scale.quantile = function() {
+ return d3_scale_quantile([], []);
+ };
+ function d3_scale_quantile(domain, range) {
+ var thresholds;
+ function rescale() {
+ var k = 0, q = range.length;
+ thresholds = [];
+ while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
+ return scale;
+ }
+ function scale(x) {
+ if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)];
+ }
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ domain = x.map(d3_number).filter(d3_numeric).sort(d3_ascending);
+ return rescale();
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ return rescale();
+ };
+ scale.quantiles = function() {
+ return thresholds;
+ };
+ scale.invertExtent = function(y) {
+ y = range.indexOf(y);
+ return y < 0 ? [ NaN, NaN ] : [ y > 0 ? thresholds[y - 1] : domain[0], y < thresholds.length ? thresholds[y] : domain[domain.length - 1] ];
+ };
+ scale.copy = function() {
+ return d3_scale_quantile(domain, range);
+ };
+ return rescale();
+ }
+ d3.scale.quantize = function() {
+ return d3_scale_quantize(0, 1, [ 0, 1 ]);
+ };
+ function d3_scale_quantize(x0, x1, range) {
+ var kx, i;
+ function scale(x) {
+ return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
+ }
+ function rescale() {
+ kx = range.length / (x1 - x0);
+ i = range.length - 1;
+ return scale;
+ }
+ scale.domain = function(x) {
+ if (!arguments.length) return [ x0, x1 ];
+ x0 = +x[0];
+ x1 = +x[x.length - 1];
+ return rescale();
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ return rescale();
+ };
+ scale.invertExtent = function(y) {
+ y = range.indexOf(y);
+ y = y < 0 ? NaN : y / kx + x0;
+ return [ y, y + 1 / kx ];
+ };
+ scale.copy = function() {
+ return d3_scale_quantize(x0, x1, range);
+ };
+ return rescale();
+ }
+ d3.scale.threshold = function() {
+ return d3_scale_threshold([ .5 ], [ 0, 1 ]);
+ };
+ function d3_scale_threshold(domain, range) {
+ function scale(x) {
+ if (x <= x) return range[d3.bisect(domain, x)];
+ }
+ scale.domain = function(_) {
+ if (!arguments.length) return domain;
+ domain = _;
+ return scale;
+ };
+ scale.range = function(_) {
+ if (!arguments.length) return range;
+ range = _;
+ return scale;
+ };
+ scale.invertExtent = function(y) {
+ y = range.indexOf(y);
+ return [ domain[y - 1], domain[y] ];
+ };
+ scale.copy = function() {
+ return d3_scale_threshold(domain, range);
+ };
+ return scale;
+ }
+ d3.scale.identity = function() {
+ return d3_scale_identity([ 0, 1 ]);
+ };
+ function d3_scale_identity(domain) {
+ function identity(x) {
+ return +x;
+ }
+ identity.invert = identity;
+ identity.domain = identity.range = function(x) {
+ if (!arguments.length) return domain;
+ domain = x.map(identity);
+ return identity;
+ };
+ identity.ticks = function(m) {
+ return d3_scale_linearTicks(domain, m);
+ };
+ identity.tickFormat = function(m, format) {
+ return d3_scale_linearTickFormat(domain, m, format);
+ };
+ identity.copy = function() {
+ return d3_scale_identity(domain);
+ };
+ return identity;
+ }
+ d3.svg = {};
+ function d3_zero() {
+ return 0;
+ }
+ d3.svg.arc = function() {
+ var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, cornerRadius = d3_zero, padRadius = d3_svg_arcAuto, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle, padAngle = d3_svg_arcPadAngle;
+ function arc() {
+ var r0 = Math.max(0, +innerRadius.apply(this, arguments)), r1 = Math.max(0, +outerRadius.apply(this, arguments)), a0 = startAngle.apply(this, arguments) - halfπ, a1 = endAngle.apply(this, arguments) - halfπ, da = Math.abs(a1 - a0), cw = a0 > a1 ? 0 : 1;
+ if (r1 < r0) rc = r1, r1 = r0, r0 = rc;
+ if (da >= τε) return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z";
+ var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
+ if (ap = (+padAngle.apply(this, arguments) || 0) / 2) {
+ rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments);
+ if (!cw) p1 *= -1;
+ if (r1) p1 = d3_asin(rp / r1 * Math.sin(ap));
+ if (r0) p0 = d3_asin(rp / r0 * Math.sin(ap));
+ }
+ if (r1) {
+ x0 = r1 * Math.cos(a0 + p1);
+ y0 = r1 * Math.sin(a0 + p1);
+ x1 = r1 * Math.cos(a1 - p1);
+ y1 = r1 * Math.sin(a1 - p1);
+ var l1 = Math.abs(a1 - a0 - 2 * p1) <= π ? 0 : 1;
+ if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) {
+ var h1 = (a0 + a1) / 2;
+ x0 = r1 * Math.cos(h1);
+ y0 = r1 * Math.sin(h1);
+ x1 = y1 = null;
+ }
+ } else {
+ x0 = y0 = 0;
+ }
+ if (r0) {
+ x2 = r0 * Math.cos(a1 - p0);
+ y2 = r0 * Math.sin(a1 - p0);
+ x3 = r0 * Math.cos(a0 + p0);
+ y3 = r0 * Math.sin(a0 + p0);
+ var l0 = Math.abs(a0 - a1 + 2 * p0) <= π ? 0 : 1;
+ if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) {
+ var h0 = (a0 + a1) / 2;
+ x2 = r0 * Math.cos(h0);
+ y2 = r0 * Math.sin(h0);
+ x3 = y3 = null;
+ }
+ } else {
+ x2 = y2 = 0;
+ }
+ if ((rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > .001) {
+ cr = r0 < r1 ^ cw ? 0 : 1;
+ var oc = x3 == null ? [ x2, y2 ] : x1 == null ? [ x0, y0 ] : d3_geom_polygonIntersect([ x0, y0 ], [ x3, y3 ], [ x1, y1 ], [ x2, y2 ]), ax = x0 - oc[0], ay = y0 - oc[1], bx = x1 - oc[0], by = y1 - oc[1], kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
+ if (x1 != null) {
+ var rc1 = Math.min(rc, (r1 - lc) / (kc + 1)), t30 = d3_svg_arcCornerTangents(x3 == null ? [ x2, y2 ] : [ x3, y3 ], [ x0, y0 ], r1, rc1, cw), t12 = d3_svg_arcCornerTangents([ x1, y1 ], [ x2, y2 ], r1, rc1, cw);
+ if (rc === rc1) {
+ path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);
+ } else {
+ path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
+ }
+ } else {
+ path.push("M", x0, ",", y0);
+ }
+ if (x3 != null) {
+ var rc0 = Math.min(rc, (r0 - lc) / (kc - 1)), t03 = d3_svg_arcCornerTangents([ x0, y0 ], [ x3, y3 ], r0, -rc0, cw), t21 = d3_svg_arcCornerTangents([ x2, y2 ], x1 == null ? [ x0, y0 ] : [ x1, y1 ], r0, -rc0, cw);
+ if (rc === rc0) {
+ path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+ } else {
+ path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+ }
+ } else {
+ path.push("L", x2, ",", y2);
+ }
+ } else {
+ path.push("M", x0, ",", y0);
+ if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
+ path.push("L", x2, ",", y2);
+ if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
+ }
+ path.push("Z");
+ return path.join("");
+ }
+ function circleSegment(r1, cw) {
+ return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1;
+ }
+ arc.innerRadius = function(v) {
+ if (!arguments.length) return innerRadius;
+ innerRadius = d3_functor(v);
+ return arc;
+ };
+ arc.outerRadius = function(v) {
+ if (!arguments.length) return outerRadius;
+ outerRadius = d3_functor(v);
+ return arc;
+ };
+ arc.cornerRadius = function(v) {
+ if (!arguments.length) return cornerRadius;
+ cornerRadius = d3_functor(v);
+ return arc;
+ };
+ arc.padRadius = function(v) {
+ if (!arguments.length) return padRadius;
+ padRadius = v == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v);
+ return arc;
+ };
+ arc.startAngle = function(v) {
+ if (!arguments.length) return startAngle;
+ startAngle = d3_functor(v);
+ return arc;
+ };
+ arc.endAngle = function(v) {
+ if (!arguments.length) return endAngle;
+ endAngle = d3_functor(v);
+ return arc;
+ };
+ arc.padAngle = function(v) {
+ if (!arguments.length) return padAngle;
+ padAngle = d3_functor(v);
+ return arc;
+ };
+ arc.centroid = function() {
+ var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - halfπ;
+ return [ Math.cos(a) * r, Math.sin(a) * r ];
+ };
+ return arc;
+ };
+ var d3_svg_arcAuto = "auto";
+ function d3_svg_arcInnerRadius(d) {
+ return d.innerRadius;
+ }
+ function d3_svg_arcOuterRadius(d) {
+ return d.outerRadius;
+ }
+ function d3_svg_arcStartAngle(d) {
+ return d.startAngle;
+ }
+ function d3_svg_arcEndAngle(d) {
+ return d.endAngle;
+ }
+ function d3_svg_arcPadAngle(d) {
+ return d && d.padAngle;
+ }
+ function d3_svg_arcSweep(x0, y0, x1, y1) {
+ return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;
+ }
+ function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
+ var x01 = p0[0] - p1[0], y01 = p0[1] - p1[1], lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x1 = p0[0] + ox, y1 = p0[1] + oy, x2 = p1[0] + ox, y2 = p1[1] + oy, x3 = (x1 + x2) / 2, y3 = (y1 + y2) / 2, dx = x2 - x1, dy = y2 - y1, d2 = dx * dx + dy * dy, r = r1 - rc, D = x1 * y2 - x2 * y1, d = (dy < 0 ? -1 : 1) * Math.sqrt(r * r * d2 - D * D), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * [...]
+ if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+ return [ [ cx0 - ox, cy0 - oy ], [ cx0 * r1 / r, cy0 * r1 / r ] ];
+ }
+ function d3_svg_line(projection) {
+ var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7;
+ function line(data) {
+ var segments = [], points = [], i = -1, n = data.length, d, fx = d3_functor(x), fy = d3_functor(y);
+ function segment() {
+ segments.push("M", interpolate(projection(points), tension));
+ }
+ while (++i < n) {
+ if (defined.call(this, d = data[i], i)) {
+ points.push([ +fx.call(this, d, i), +fy.call(this, d, i) ]);
+ } else if (points.length) {
+ segment();
+ points = [];
+ }
+ }
+ if (points.length) segment();
+ return segments.length ? segments.join("") : null;
+ }
+ line.x = function(_) {
+ if (!arguments.length) return x;
+ x = _;
+ return line;
+ };
+ line.y = function(_) {
+ if (!arguments.length) return y;
+ y = _;
+ return line;
+ };
+ line.defined = function(_) {
+ if (!arguments.length) return defined;
+ defined = _;
+ return line;
+ };
+ line.interpolate = function(_) {
+ if (!arguments.length) return interpolateKey;
+ if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
+ return line;
+ };
+ line.tension = function(_) {
+ if (!arguments.length) return tension;
+ tension = _;
+ return line;
+ };
+ return line;
+ }
+ d3.svg.line = function() {
+ return d3_svg_line(d3_identity);
+ };
+ var d3_svg_lineInterpolators = d3.map({
+ linear: d3_svg_lineLinear,
+ "linear-closed": d3_svg_lineLinearClosed,
+ step: d3_svg_lineStep,
+ "step-before": d3_svg_lineStepBefore,
+ "step-after": d3_svg_lineStepAfter,
+ basis: d3_svg_lineBasis,
+ "basis-open": d3_svg_lineBasisOpen,
+ "basis-closed": d3_svg_lineBasisClosed,
+ bundle: d3_svg_lineBundle,
+ cardinal: d3_svg_lineCardinal,
+ "cardinal-open": d3_svg_lineCardinalOpen,
+ "cardinal-closed": d3_svg_lineCardinalClosed,
+ monotone: d3_svg_lineMonotone
+ });
+ d3_svg_lineInterpolators.forEach(function(key, value) {
+ value.key = key;
+ value.closed = /-closed$/.test(key);
+ });
+ function d3_svg_lineLinear(points) {
+ return points.join("L");
+ }
+ function d3_svg_lineLinearClosed(points) {
+ return d3_svg_lineLinear(points) + "Z";
+ }
+ function d3_svg_lineStep(points) {
+ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+ while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
+ if (n > 1) path.push("H", p[0]);
+ return path.join("");
+ }
+ function d3_svg_lineStepBefore(points) {
+ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+ while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
+ return path.join("");
+ }
+ function d3_svg_lineStepAfter(points) {
+ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+ while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
+ return path.join("");
+ }
+ function d3_svg_lineCardinalOpen(points, tension) {
+ return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension));
+ }
+ function d3_svg_lineCardinalClosed(points, tension) {
+ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite((points.push(points[0]),
+ points), d3_svg_lineCardinalTangents([ points[points.length - 2] ].concat(points, [ points[1] ]), tension));
+ }
+ function d3_svg_lineCardinal(points, tension) {
+ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension));
+ }
+ function d3_svg_lineHermite(points, tangents) {
+ if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) {
+ return d3_svg_lineLinear(points);
+ }
+ var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
+ if (quad) {
+ path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
+ p0 = points[1];
+ pi = 2;
+ }
+ if (tangents.length > 1) {
+ t = tangents[1];
+ p = points[pi];
+ pi++;
+ path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
+ for (var i = 2; i < tangents.length; i++, pi++) {
+ p = points[pi];
+ t = tangents[i];
+ path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
+ }
+ }
+ if (quad) {
+ var lp = points[pi];
+ path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
+ }
+ return path;
+ }
+ function d3_svg_lineCardinalTangents(points, tension) {
+ var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length;
+ while (++i < n) {
+ p0 = p1;
+ p1 = p2;
+ p2 = points[i];
+ tangents.push([ a * (p2[0] - p0[0]), a * (p2[1] - p0[1]) ]);
+ }
+ return tangents;
+ }
+ function d3_svg_lineBasis(points) {
+ if (points.length < 3) return d3_svg_lineLinear(points);
+ var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
+ points.push(points[n - 1]);
+ while (++i <= n) {
+ pi = points[i];
+ px.shift();
+ px.push(pi[0]);
+ py.shift();
+ py.push(pi[1]);
+ d3_svg_lineBasisBezier(path, px, py);
+ }
+ points.pop();
+ path.push("L", pi);
+ return path.join("");
+ }
+ function d3_svg_lineBasisOpen(points) {
+ if (points.length < 4) return d3_svg_lineLinear(points);
+ var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
+ while (++i < 3) {
+ pi = points[i];
+ px.push(pi[0]);
+ py.push(pi[1]);
+ }
+ path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
+ --i;
+ while (++i < n) {
+ pi = points[i];
+ px.shift();
+ px.push(pi[0]);
+ py.shift();
+ py.push(pi[1]);
+ d3_svg_lineBasisBezier(path, px, py);
+ }
+ return path.join("");
+ }
+ function d3_svg_lineBasisClosed(points) {
+ var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
+ while (++i < 4) {
+ pi = points[i % n];
+ px.push(pi[0]);
+ py.push(pi[1]);
+ }
+ path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
+ --i;
+ while (++i < m) {
+ pi = points[i % n];
+ px.shift();
+ px.push(pi[0]);
+ py.shift();
+ py.push(pi[1]);
+ d3_svg_lineBasisBezier(path, px, py);
+ }
+ return path.join("");
+ }
+ function d3_svg_lineBundle(points, tension) {
+ var n = points.length - 1;
+ if (n) {
+ var x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t;
+ while (++i <= n) {
+ p = points[i];
+ t = i / n;
+ p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
+ p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
+ }
+ }
+ return d3_svg_lineBasis(points);
+ }
+ function d3_svg_lineDot4(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+ }
+ var d3_svg_lineBasisBezier1 = [ 0, 2 / 3, 1 / 3, 0 ], d3_svg_lineBasisBezier2 = [ 0, 1 / 3, 2 / 3, 0 ], d3_svg_lineBasisBezier3 = [ 0, 1 / 6, 2 / 3, 1 / 6 ];
+ function d3_svg_lineBasisBezier(path, x, y) {
+ path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
+ }
+ function d3_svg_lineSlope(p0, p1) {
+ return (p1[1] - p0[1]) / (p1[0] - p0[0]);
+ }
+ function d3_svg_lineFiniteDifferences(points) {
+ var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1);
+ while (++i < j) {
+ m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2;
+ }
+ m[i] = d;
+ return m;
+ }
+ function d3_svg_lineMonotoneTangents(points) {
+ var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1;
+ while (++i < j) {
+ d = d3_svg_lineSlope(points[i], points[i + 1]);
+ if (abs(d) < ε) {
+ m[i] = m[i + 1] = 0;
+ } else {
+ a = m[i] / d;
+ b = m[i + 1] / d;
+ s = a * a + b * b;
+ if (s > 9) {
+ s = d * 3 / Math.sqrt(s);
+ m[i] = s * a;
+ m[i + 1] = s * b;
+ }
+ }
+ }
+ i = -1;
+ while (++i <= j) {
+ s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i]));
+ tangents.push([ s || 0, m[i] * s || 0 ]);
+ }
+ return tangents;
+ }
+ function d3_svg_lineMonotone(points) {
+ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
+ }
+ d3.svg.line.radial = function() {
+ var line = d3_svg_line(d3_svg_lineRadial);
+ line.radius = line.x, delete line.x;
+ line.angle = line.y, delete line.y;
+ return line;
+ };
+ function d3_svg_lineRadial(points) {
+ var point, i = -1, n = points.length, r, a;
+ while (++i < n) {
+ point = points[i];
+ r = point[0];
+ a = point[1] - halfπ;
+ point[0] = r * Math.cos(a);
+ point[1] = r * Math.sin(a);
+ }
+ return points;
+ }
+ function d3_svg_area(projection) {
+ var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L = "L", tension = .7;
+ function area(data) {
+ var segments = [], points0 = [], points1 = [], i = -1, n = data.length, d, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() {
+ return x;
+ } : d3_functor(x1), fy1 = y0 === y1 ? function() {
+ return y;
+ } : d3_functor(y1), x, y;
+ function segment() {
+ segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z");
+ }
+ while (++i < n) {
+ if (defined.call(this, d = data[i], i)) {
+ points0.push([ x = +fx0.call(this, d, i), y = +fy0.call(this, d, i) ]);
+ points1.push([ +fx1.call(this, d, i), +fy1.call(this, d, i) ]);
+ } else if (points0.length) {
+ segment();
+ points0 = [];
+ points1 = [];
+ }
+ }
+ if (points0.length) segment();
+ return segments.length ? segments.join("") : null;
+ }
+ area.x = function(_) {
+ if (!arguments.length) return x1;
+ x0 = x1 = _;
+ return area;
+ };
+ area.x0 = function(_) {
+ if (!arguments.length) return x0;
+ x0 = _;
+ return area;
+ };
+ area.x1 = function(_) {
+ if (!arguments.length) return x1;
+ x1 = _;
+ return area;
+ };
+ area.y = function(_) {
+ if (!arguments.length) return y1;
+ y0 = y1 = _;
+ return area;
+ };
+ area.y0 = function(_) {
+ if (!arguments.length) return y0;
+ y0 = _;
+ return area;
+ };
+ area.y1 = function(_) {
+ if (!arguments.length) return y1;
+ y1 = _;
+ return area;
+ };
+ area.defined = function(_) {
+ if (!arguments.length) return defined;
+ defined = _;
+ return area;
+ };
+ area.interpolate = function(_) {
+ if (!arguments.length) return interpolateKey;
+ if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
+ interpolateReverse = interpolate.reverse || interpolate;
+ L = interpolate.closed ? "M" : "L";
+ return area;
+ };
+ area.tension = function(_) {
+ if (!arguments.length) return tension;
+ tension = _;
+ return area;
+ };
+ return area;
+ }
+ d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
+ d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;
+ d3.svg.area = function() {
+ return d3_svg_area(d3_identity);
+ };
+ d3.svg.area.radial = function() {
+ var area = d3_svg_area(d3_svg_lineRadial);
+ area.radius = area.x, delete area.x;
+ area.innerRadius = area.x0, delete area.x0;
+ area.outerRadius = area.x1, delete area.x1;
+ area.angle = area.y, delete area.y;
+ area.startAngle = area.y0, delete area.y0;
+ area.endAngle = area.y1, delete area.y1;
+ return area;
+ };
+ d3.svg.chord = function() {
+ var source = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle;
+ function chord(d, i) {
+ var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i);
+ return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z";
+ }
+ function subgroup(self, f, d, i) {
+ var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) - halfπ, a1 = endAngle.call(self, subgroup, i) - halfπ;
+ return {
+ r: r,
+ a0: a0,
+ a1: a1,
+ p0: [ r * Math.cos(a0), r * Math.sin(a0) ],
+ p1: [ r * Math.cos(a1), r * Math.sin(a1) ]
+ };
+ }
+ function equals(a, b) {
+ return a.a0 == b.a0 && a.a1 == b.a1;
+ }
+ function arc(r, p, a) {
+ return "A" + r + "," + r + " 0 " + +(a > π) + ",1 " + p;
+ }
+ function curve(r0, p0, r1, p1) {
+ return "Q 0,0 " + p1;
+ }
+ chord.radius = function(v) {
+ if (!arguments.length) return radius;
+ radius = d3_functor(v);
+ return chord;
+ };
+ chord.source = function(v) {
+ if (!arguments.length) return source;
+ source = d3_functor(v);
+ return chord;
+ };
+ chord.target = function(v) {
+ if (!arguments.length) return target;
+ target = d3_functor(v);
+ return chord;
+ };
+ chord.startAngle = function(v) {
+ if (!arguments.length) return startAngle;
+ startAngle = d3_functor(v);
+ return chord;
+ };
+ chord.endAngle = function(v) {
+ if (!arguments.length) return endAngle;
+ endAngle = d3_functor(v);
+ return chord;
+ };
+ return chord;
+ };
+ function d3_svg_chordRadius(d) {
+ return d.radius;
+ }
+ d3.svg.diagonal = function() {
+ var source = d3_source, target = d3_target, projection = d3_svg_diagonalProjection;
+ function diagonal(d, i) {
+ var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [ p0, {
+ x: p0.x,
+ y: m
+ }, {
+ x: p3.x,
+ y: m
+ }, p3 ];
+ p = p.map(projection);
+ return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3];
+ }
+ diagonal.source = function(x) {
+ if (!arguments.length) return source;
+ source = d3_functor(x);
+ return diagonal;
+ };
+ diagonal.target = function(x) {
+ if (!arguments.length) return target;
+ target = d3_functor(x);
+ return diagonal;
+ };
+ diagonal.projection = function(x) {
+ if (!arguments.length) return projection;
+ projection = x;
+ return diagonal;
+ };
+ return diagonal;
+ };
+ function d3_svg_diagonalProjection(d) {
+ return [ d.x, d.y ];
+ }
+ d3.svg.diagonal.radial = function() {
+ var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection;
+ diagonal.projection = function(x) {
+ return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection;
+ };
+ return diagonal;
+ };
+ function d3_svg_diagonalRadialProjection(projection) {
+ return function() {
+ var d = projection.apply(this, arguments), r = d[0], a = d[1] - halfπ;
+ return [ r * Math.cos(a), r * Math.sin(a) ];
+ };
+ }
+ d3.svg.symbol = function() {
+ var type = d3_svg_symbolType, size = d3_svg_symbolSize;
+ function symbol(d, i) {
+ return (d3_svg_symbols.get(type.call(this, d, i)) || d3_svg_symbolCircle)(size.call(this, d, i));
+ }
+ symbol.type = function(x) {
+ if (!arguments.length) return type;
+ type = d3_functor(x);
+ return symbol;
+ };
+ symbol.size = function(x) {
+ if (!arguments.length) return size;
+ size = d3_functor(x);
+ return symbol;
+ };
+ return symbol;
+ };
+ function d3_svg_symbolSize() {
+ return 64;
+ }
+ function d3_svg_symbolType() {
+ return "circle";
+ }
+ function d3_svg_symbolCircle(size) {
+ var r = Math.sqrt(size / π);
+ return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + -r + "A" + r + "," + r + " 0 1,1 0," + r + "Z";
+ }
+ var d3_svg_symbols = d3.map({
+ circle: d3_svg_symbolCircle,
+ cross: function(size) {
+ var r = Math.sqrt(size / 5) / 2;
+ return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z";
+ },
+ diamond: function(size) {
+ var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30;
+ return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z";
+ },
+ square: function(size) {
+ var r = Math.sqrt(size) / 2;
+ return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z";
+ },
+ "triangle-down": function(size) {
+ var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+ return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z";
+ },
+ "triangle-up": function(size) {
+ var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+ return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z";
+ }
+ });
+ d3.svg.symbolTypes = d3_svg_symbols.keys();
+ var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians);
+ d3_selectionPrototype.transition = function(name) {
+ var id = d3_transitionInheritId || ++d3_transitionId, ns = d3_transitionNamespace(name), subgroups = [], subgroup, node, transition = d3_transitionInherit || {
+ time: Date.now(),
+ ease: d3_ease_cubicInOut,
+ delay: 0,
+ duration: 250
+ };
+ for (var j = -1, m = this.length; ++j < m; ) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) d3_transitionNode(node, i, ns, id, transition);
+ subgroup.push(node);
+ }
+ }
+ return d3_transition(subgroups, ns, id);
+ };
+ d3_selectionPrototype.interrupt = function(name) {
+ return this.each(name == null ? d3_selection_interrupt : d3_selection_interruptNS(d3_transitionNamespace(name)));
+ };
+ var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
+ function d3_selection_interruptNS(ns) {
+ return function() {
+ var lock, active;
+ if ((lock = this[ns]) && (active = lock[lock.active])) {
+ if (--lock.count) delete lock[lock.active]; else delete this[ns];
+ lock.active += .5;
+ active.event && active.event.interrupt.call(this, this.__data__, active.index);
+ }
+ };
+ }
+ function d3_transition(groups, ns, id) {
+ d3_subclass(groups, d3_transitionPrototype);
+ groups.namespace = ns;
+ groups.id = id;
+ return groups;
+ }
+ var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit;
+ d3_transitionPrototype.call = d3_selectionPrototype.call;
+ d3_transitionPrototype.empty = d3_selectionPrototype.empty;
+ d3_transitionPrototype.node = d3_selectionPrototype.node;
+ d3_transitionPrototype.size = d3_selectionPrototype.size;
+ d3.transition = function(selection, name) {
+ return selection && selection.transition ? d3_transitionInheritId ? selection.transition(name) : selection : d3.selection().transition(selection);
+ };
+ d3.transition.prototype = d3_transitionPrototype;
+ d3_transitionPrototype.select = function(selector) {
+ var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnode, node;
+ selector = d3_selection_selector(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) {
+ if ("__data__" in node) subnode.__data__ = node.__data__;
+ d3_transitionNode(subnode, i, ns, id, node[ns][id]);
+ subgroup.push(subnode);
+ } else {
+ subgroup.push(null);
+ }
+ }
+ }
+ return d3_transition(subgroups, ns, id);
+ };
+ d3_transitionPrototype.selectAll = function(selector) {
+ var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnodes, node, subnode, transition;
+ selector = d3_selection_selectorAll(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ transition = node[ns][id];
+ subnodes = selector.call(node, node.__data__, i, j);
+ subgroups.push(subgroup = []);
+ for (var k = -1, o = subnodes.length; ++k < o; ) {
+ if (subnode = subnodes[k]) d3_transitionNode(subnode, k, ns, id, transition);
+ subgroup.push(subnode);
+ }
+ }
+ }
+ }
+ return d3_transition(subgroups, ns, id);
+ };
+ d3_transitionPrototype.filter = function(filter) {
+ var subgroups = [], subgroup, group, node;
+ if (typeof filter !== "function") filter = d3_selection_filter(filter);
+ for (var j = 0, m = this.length; j < m; j++) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+ if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
+ subgroup.push(node);
+ }
+ }
+ }
+ return d3_transition(subgroups, this.namespace, this.id);
+ };
+ d3_transitionPrototype.tween = function(name, tween) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 2) return this.node()[ns][id].tween.get(name);
+ return d3_selection_each(this, tween == null ? function(node) {
+ node[ns][id].tween.remove(name);
+ } : function(node) {
+ node[ns][id].tween.set(name, tween);
+ });
+ };
+ function d3_transition_tween(groups, name, value, tween) {
+ var id = groups.id, ns = groups.namespace;
+ return d3_selection_each(groups, typeof value === "function" ? function(node, i, j) {
+ node[ns][id].tween.set(name, tween(value.call(node, node.__data__, i, j)));
+ } : (value = tween(value), function(node) {
+ node[ns][id].tween.set(name, value);
+ }));
+ }
+ d3_transitionPrototype.attr = function(nameNS, value) {
+ if (arguments.length < 2) {
+ for (value in nameNS) this.attr(value, nameNS[value]);
+ return this;
+ }
+ var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name = d3.ns.qualify(nameNS);
+ function attrNull() {
+ this.removeAttribute(name);
+ }
+ function attrNullNS() {
+ this.removeAttributeNS(name.space, name.local);
+ }
+ function attrTween(b) {
+ return b == null ? attrNull : (b += "", function() {
+ var a = this.getAttribute(name), i;
+ return a !== b && (i = interpolate(a, b), function(t) {
+ this.setAttribute(name, i(t));
+ });
+ });
+ }
+ function attrTweenNS(b) {
+ return b == null ? attrNullNS : (b += "", function() {
+ var a = this.getAttributeNS(name.space, name.local), i;
+ return a !== b && (i = interpolate(a, b), function(t) {
+ this.setAttributeNS(name.space, name.local, i(t));
+ });
+ });
+ }
+ return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween);
+ };
+ d3_transitionPrototype.attrTween = function(nameNS, tween) {
+ var name = d3.ns.qualify(nameNS);
+ function attrTween(d, i) {
+ var f = tween.call(this, d, i, this.getAttribute(name));
+ return f && function(t) {
+ this.setAttribute(name, f(t));
+ };
+ }
+ function attrTweenNS(d, i) {
+ var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
+ return f && function(t) {
+ this.setAttributeNS(name.space, name.local, f(t));
+ };
+ }
+ return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
+ };
+ d3_transitionPrototype.style = function(name, value, priority) {
+ var n = arguments.length;
+ if (n < 3) {
+ if (typeof name !== "string") {
+ if (n < 2) value = "";
+ for (priority in name) this.style(priority, name[priority], value);
+ return this;
+ }
+ priority = "";
+ }
+ function styleNull() {
+ this.style.removeProperty(name);
+ }
+ function styleString(b) {
+ return b == null ? styleNull : (b += "", function() {
+ var a = d3_window(this).getComputedStyle(this, null).getPropertyValue(name), i;
+ return a !== b && (i = d3_interpolate(a, b), function(t) {
+ this.style.setProperty(name, i(t), priority);
+ });
+ });
+ }
+ return d3_transition_tween(this, "style." + name, value, styleString);
+ };
+ d3_transitionPrototype.styleTween = function(name, tween, priority) {
+ if (arguments.length < 3) priority = "";
+ function styleTween(d, i) {
+ var f = tween.call(this, d, i, d3_window(this).getComputedStyle(this, null).getPropertyValue(name));
+ return f && function(t) {
+ this.style.setProperty(name, f(t), priority);
+ };
+ }
+ return this.tween("style." + name, styleTween);
+ };
+ d3_transitionPrototype.text = function(value) {
+ return d3_transition_tween(this, "text", value, d3_transition_text);
+ };
+ function d3_transition_text(b) {
+ if (b == null) b = "";
+ return function() {
+ this.textContent = b;
+ };
+ }
+ d3_transitionPrototype.remove = function() {
+ var ns = this.namespace;
+ return this.each("end.transition", function() {
+ var p;
+ if (this[ns].count < 2 && (p = this.parentNode)) p.removeChild(this);
+ });
+ };
+ d3_transitionPrototype.ease = function(value) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 1) return this.node()[ns][id].ease;
+ if (typeof value !== "function") value = d3.ease.apply(d3, arguments);
+ return d3_selection_each(this, function(node) {
+ node[ns][id].ease = value;
+ });
+ };
+ d3_transitionPrototype.delay = function(value) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 1) return this.node()[ns][id].delay;
+ return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
+ node[ns][id].delay = +value.call(node, node.__data__, i, j);
+ } : (value = +value, function(node) {
+ node[ns][id].delay = value;
+ }));
+ };
+ d3_transitionPrototype.duration = function(value) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 1) return this.node()[ns][id].duration;
+ return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
+ node[ns][id].duration = Math.max(1, value.call(node, node.__data__, i, j));
+ } : (value = Math.max(1, value), function(node) {
+ node[ns][id].duration = value;
+ }));
+ };
+ d3_transitionPrototype.each = function(type, listener) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 2) {
+ var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId;
+ try {
+ d3_transitionInheritId = id;
+ d3_selection_each(this, function(node, i, j) {
+ d3_transitionInherit = node[ns][id];
+ type.call(node, node.__data__, i, j);
+ });
+ } finally {
+ d3_transitionInherit = inherit;
+ d3_transitionInheritId = inheritId;
+ }
+ } else {
+ d3_selection_each(this, function(node) {
+ var transition = node[ns][id];
+ (transition.event || (transition.event = d3.dispatch("start", "end", "interrupt"))).on(type, listener);
+ });
+ }
+ return this;
+ };
+ d3_transitionPrototype.transition = function() {
+ var id0 = this.id, id1 = ++d3_transitionId, ns = this.namespace, subgroups = [], subgroup, group, node, transition;
+ for (var j = 0, m = this.length; j < m; j++) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+ if (node = group[i]) {
+ transition = node[ns][id0];
+ d3_transitionNode(node, i, ns, id1, {
+ time: transition.time,
+ ease: transition.ease,
+ delay: transition.delay + transition.duration,
+ duration: transition.duration
+ });
+ }
+ subgroup.push(node);
+ }
+ }
+ return d3_transition(subgroups, ns, id1);
+ };
+ function d3_transitionNamespace(name) {
+ return name == null ? "__transition__" : "__transition_" + name + "__";
+ }
+ function d3_transitionNode(node, i, ns, id, inherit) {
+ var lock = node[ns] || (node[ns] = {
+ active: 0,
+ count: 0
+ }), transition = lock[id];
+ if (!transition) {
+ var time = inherit.time;
+ transition = lock[id] = {
+ tween: new d3_Map(),
+ time: time,
+ delay: inherit.delay,
+ duration: inherit.duration,
+ ease: inherit.ease,
+ index: i
+ };
+ inherit = null;
+ ++lock.count;
+ d3.timer(function(elapsed) {
+ var delay = transition.delay, duration, ease, timer = d3_timer_active, tweened = [];
+ timer.t = delay + time;
+ if (delay <= elapsed) return start(elapsed - delay);
+ timer.c = start;
+ function start(elapsed) {
+ if (lock.active > id) return stop();
+ var active = lock[lock.active];
+ if (active) {
+ --lock.count;
+ delete lock[lock.active];
+ active.event && active.event.interrupt.call(node, node.__data__, active.index);
+ }
+ lock.active = id;
+ transition.event && transition.event.start.call(node, node.__data__, i);
+ transition.tween.forEach(function(key, value) {
+ if (value = value.call(node, node.__data__, i)) {
+ tweened.push(value);
+ }
+ });
+ ease = transition.ease;
+ duration = transition.duration;
+ d3.timer(function() {
+ timer.c = tick(elapsed || 1) ? d3_true : tick;
+ return 1;
+ }, 0, time);
+ }
+ function tick(elapsed) {
+ if (lock.active !== id) return 1;
+ var t = elapsed / duration, e = ease(t), n = tweened.length;
+ while (n > 0) {
+ tweened[--n].call(node, e);
+ }
+ if (t >= 1) {
+ transition.event && transition.event.end.call(node, node.__data__, i);
+ return stop();
+ }
+ }
+ function stop() {
+ if (--lock.count) delete lock[id]; else delete node[ns];
+ return 1;
+ }
+ }, 0, time);
+ }
+ }
+ d3.svg.axis = function() {
+ var scale = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [ 10 ], tickValues = null, tickFormat_;
+ function axis(g) {
+ g.each(function() {
+ var g = d3.select(this);
+ var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = scale.copy();
+ var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.trans [...]
+ var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"),
+ d3.transition(path));
+ tickEnter.append("line");
+ tickEnter.append("text");
+ var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"), sign = orient === "top" || orient === "left" ? -1 : 1, x1, x2, y1, y2;
+ if (orient === "bottom" || orient === "top") {
+ tickTransform = d3_svg_axisX, x1 = "x", y1 = "y", x2 = "x2", y2 = "y2";
+ text.attr("dy", sign < 0 ? "0em" : ".71em").style("text-anchor", "middle");
+ pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outerTickSize);
+ } else {
+ tickTransform = d3_svg_axisY, x1 = "y", y1 = "x", x2 = "y2", y2 = "x2";
+ text.attr("dy", ".32em").style("text-anchor", sign < 0 ? "end" : "start");
+ pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outerTickSize);
+ }
+ lineEnter.attr(y2, sign * innerTickSize);
+ textEnter.attr(y1, sign * tickSpacing);
+ lineUpdate.attr(x2, 0).attr(y2, sign * innerTickSize);
+ textUpdate.attr(x1, 0).attr(y1, sign * tickSpacing);
+ if (scale1.rangeBand) {
+ var x = scale1, dx = x.rangeBand() / 2;
+ scale0 = scale1 = function(d) {
+ return x(d) + dx;
+ };
+ } else if (scale0.rangeBand) {
+ scale0 = scale1;
+ } else {
+ tickExit.call(tickTransform, scale1, scale0);
+ }
+ tickEnter.call(tickTransform, scale0, scale1);
+ tickUpdate.call(tickTransform, scale1, scale1);
+ });
+ }
+ axis.scale = function(x) {
+ if (!arguments.length) return scale;
+ scale = x;
+ return axis;
+ };
+ axis.orient = function(x) {
+ if (!arguments.length) return orient;
+ orient = x in d3_svg_axisOrients ? x + "" : d3_svg_axisDefaultOrient;
+ return axis;
+ };
+ axis.ticks = function() {
+ if (!arguments.length) return tickArguments_;
+ tickArguments_ = arguments;
+ return axis;
+ };
+ axis.tickValues = function(x) {
+ if (!arguments.length) return tickValues;
+ tickValues = x;
+ return axis;
+ };
+ axis.tickFormat = function(x) {
+ if (!arguments.length) return tickFormat_;
+ tickFormat_ = x;
+ return axis;
+ };
+ axis.tickSize = function(x) {
+ var n = arguments.length;
+ if (!n) return innerTickSize;
+ innerTickSize = +x;
+ outerTickSize = +arguments[n - 1];
+ return axis;
+ };
+ axis.innerTickSize = function(x) {
+ if (!arguments.length) return innerTickSize;
+ innerTickSize = +x;
+ return axis;
+ };
+ axis.outerTickSize = function(x) {
+ if (!arguments.length) return outerTickSize;
+ outerTickSize = +x;
+ return axis;
+ };
+ axis.tickPadding = function(x) {
+ if (!arguments.length) return tickPadding;
+ tickPadding = +x;
+ return axis;
+ };
+ axis.tickSubdivide = function() {
+ return arguments.length && axis;
+ };
+ return axis;
+ };
+ var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = {
+ top: 1,
+ right: 1,
+ bottom: 1,
+ left: 1
+ };
+ function d3_svg_axisX(selection, x0, x1) {
+ selection.attr("transform", function(d) {
+ var v0 = x0(d);
+ return "translate(" + (isFinite(v0) ? v0 : x1(d)) + ",0)";
+ });
+ }
+ function d3_svg_axisY(selection, y0, y1) {
+ selection.attr("transform", function(d) {
+ var v0 = y0(d);
+ return "translate(0," + (isFinite(v0) ? v0 : y1(d)) + ")";
+ });
+ }
+ d3.svg.brush = function() {
+ var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x = null, y = null, xExtent = [ 0, 0 ], yExtent = [ 0, 0 ], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0];
+ function brush(g) {
+ g.each(function() {
+ var g = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart);
+ var background = g.selectAll(".background").data([ 0 ]);
+ background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair");
+ g.selectAll(".extent").data([ 0 ]).enter().append("rect").attr("class", "extent").style("cursor", "move");
+ var resize = g.selectAll(".resize").data(resizes, d3_identity);
+ resize.exit().remove();
+ resize.enter().append("g").attr("class", function(d) {
+ return "resize " + d;
+ }).style("cursor", function(d) {
+ return d3_svg_brushCursor[d];
+ }).append("rect").attr("x", function(d) {
+ return /[ew]$/.test(d) ? -3 : null;
+ }).attr("y", function(d) {
+ return /^[ns]/.test(d) ? -3 : null;
+ }).attr("width", 6).attr("height", 6).style("visibility", "hidden");
+ resize.style("display", brush.empty() ? "none" : null);
+ var gUpdate = d3.transition(g), backgroundUpdate = d3.transition(background), range;
+ if (x) {
+ range = d3_scaleRange(x);
+ backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]);
+ redrawX(gUpdate);
+ }
+ if (y) {
+ range = d3_scaleRange(y);
+ backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]);
+ redrawY(gUpdate);
+ }
+ redraw(gUpdate);
+ });
+ }
+ brush.event = function(g) {
+ g.each(function() {
+ var event_ = event.of(this, arguments), extent1 = {
+ x: xExtent,
+ y: yExtent,
+ i: xExtentDomain,
+ j: yExtentDomain
+ }, extent0 = this.__chart__ || extent1;
+ this.__chart__ = extent1;
+ if (d3_transitionInheritId) {
+ d3.select(this).transition().each("start.brush", function() {
+ xExtentDomain = extent0.i;
+ yExtentDomain = extent0.j;
+ xExtent = extent0.x;
+ yExtent = extent0.y;
+ event_({
+ type: "brushstart"
+ });
+ }).tween("brush:brush", function() {
+ var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y);
+ xExtentDomain = yExtentDomain = null;
+ return function(t) {
+ xExtent = extent1.x = xi(t);
+ yExtent = extent1.y = yi(t);
+ event_({
+ type: "brush",
+ mode: "resize"
+ });
+ };
+ }).each("end.brush", function() {
+ xExtentDomain = extent1.i;
+ yExtentDomain = extent1.j;
+ event_({
+ type: "brush",
+ mode: "resize"
+ });
+ event_({
+ type: "brushend"
+ });
+ });
+ } else {
+ event_({
+ type: "brushstart"
+ });
+ event_({
+ type: "brush",
+ mode: "resize"
+ });
+ event_({
+ type: "brushend"
+ });
+ }
+ });
+ };
+ function redraw(g) {
+ g.selectAll(".resize").attr("transform", function(d) {
+ return "translate(" + xExtent[+/e$/.test(d)] + "," + yExtent[+/^s/.test(d)] + ")";
+ });
+ }
+ function redrawX(g) {
+ g.select(".extent").attr("x", xExtent[0]);
+ g.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]);
+ }
+ function redrawY(g) {
+ g.select(".extent").attr("y", yExtent[0]);
+ g.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]);
+ }
+ function brushstart() {
+ var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x, resizingY = !/^(e|w)$/.test(resizing) && y, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(target), center, origin = d3.mouse(target), offset;
+ var w = d3.select(d3_window(target)).on("keydown.brush", keydown).on("keyup.brush", keyup);
+ if (d3.event.changedTouches) {
+ w.on("touchmove.brush", brushmove).on("touchend.brush", brushend);
+ } else {
+ w.on("mousemove.brush", brushmove).on("mouseup.brush", brushend);
+ }
+ g.interrupt().selectAll("*").interrupt();
+ if (dragging) {
+ origin[0] = xExtent[0] - origin[0];
+ origin[1] = yExtent[0] - origin[1];
+ } else if (resizing) {
+ var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing);
+ offset = [ xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1] ];
+ origin[0] = xExtent[ex];
+ origin[1] = yExtent[ey];
+ } else if (d3.event.altKey) center = origin.slice();
+ g.style("pointer-events", "none").selectAll(".resize").style("display", null);
+ d3.select("body").style("cursor", eventTarget.style("cursor"));
+ event_({
+ type: "brushstart"
+ });
+ brushmove();
+ function keydown() {
+ if (d3.event.keyCode == 32) {
+ if (!dragging) {
+ center = null;
+ origin[0] -= xExtent[1];
+ origin[1] -= yExtent[1];
+ dragging = 2;
+ }
+ d3_eventPreventDefault();
+ }
+ }
+ function keyup() {
+ if (d3.event.keyCode == 32 && dragging == 2) {
+ origin[0] += xExtent[1];
+ origin[1] += yExtent[1];
+ dragging = 0;
+ d3_eventPreventDefault();
+ }
+ }
+ function brushmove() {
+ var point = d3.mouse(target), moved = false;
+ if (offset) {
+ point[0] += offset[0];
+ point[1] += offset[1];
+ }
+ if (!dragging) {
+ if (d3.event.altKey) {
+ if (!center) center = [ (xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2 ];
+ origin[0] = xExtent[+(point[0] < center[0])];
+ origin[1] = yExtent[+(point[1] < center[1])];
+ } else center = null;
+ }
+ if (resizingX && move1(point, x, 0)) {
+ redrawX(g);
+ moved = true;
+ }
+ if (resizingY && move1(point, y, 1)) {
+ redrawY(g);
+ moved = true;
+ }
+ if (moved) {
+ redraw(g);
+ event_({
+ type: "brush",
+ mode: dragging ? "move" : "resize"
+ });
+ }
+ }
+ function move1(point, scale, i) {
+ var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], position = origin[i], extent = i ? yExtent : xExtent, size = extent[1] - extent[0], min, max;
+ if (dragging) {
+ r0 -= position;
+ r1 -= size + position;
+ }
+ min = (i ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i])) : point[i];
+ if (dragging) {
+ max = (min += position) + size;
+ } else {
+ if (center) position = Math.max(r0, Math.min(r1, 2 * center[i] - min));
+ if (position < min) {
+ max = min;
+ min = position;
+ } else {
+ max = position;
+ }
+ }
+ if (extent[0] != min || extent[1] != max) {
+ if (i) yExtentDomain = null; else xExtentDomain = null;
+ extent[0] = min;
+ extent[1] = max;
+ return true;
+ }
+ }
+ function brushend() {
+ brushmove();
+ g.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null);
+ d3.select("body").style("cursor", null);
+ w.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null);
+ dragRestore();
+ event_({
+ type: "brushend"
+ });
+ }
+ }
+ brush.x = function(z) {
+ if (!arguments.length) return x;
+ x = z;
+ resizes = d3_svg_brushResizes[!x << 1 | !y];
+ return brush;
+ };
+ brush.y = function(z) {
+ if (!arguments.length) return y;
+ y = z;
+ resizes = d3_svg_brushResizes[!x << 1 | !y];
+ return brush;
+ };
+ brush.clamp = function(z) {
+ if (!arguments.length) return x && y ? [ xClamp, yClamp ] : x ? xClamp : y ? yClamp : null;
+ if (x && y) xClamp = !!z[0], yClamp = !!z[1]; else if (x) xClamp = !!z; else if (y) yClamp = !!z;
+ return brush;
+ };
+ brush.extent = function(z) {
+ var x0, x1, y0, y1, t;
+ if (!arguments.length) {
+ if (x) {
+ if (xExtentDomain) {
+ x0 = xExtentDomain[0], x1 = xExtentDomain[1];
+ } else {
+ x0 = xExtent[0], x1 = xExtent[1];
+ if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1);
+ if (x1 < x0) t = x0, x0 = x1, x1 = t;
+ }
+ }
+ if (y) {
+ if (yExtentDomain) {
+ y0 = yExtentDomain[0], y1 = yExtentDomain[1];
+ } else {
+ y0 = yExtent[0], y1 = yExtent[1];
+ if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1);
+ if (y1 < y0) t = y0, y0 = y1, y1 = t;
+ }
+ }
+ return x && y ? [ [ x0, y0 ], [ x1, y1 ] ] : x ? [ x0, x1 ] : y && [ y0, y1 ];
+ }
+ if (x) {
+ x0 = z[0], x1 = z[1];
+ if (y) x0 = x0[0], x1 = x1[0];
+ xExtentDomain = [ x0, x1 ];
+ if (x.invert) x0 = x(x0), x1 = x(x1);
+ if (x1 < x0) t = x0, x0 = x1, x1 = t;
+ if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [ x0, x1 ];
+ }
+ if (y) {
+ y0 = z[0], y1 = z[1];
+ if (x) y0 = y0[1], y1 = y1[1];
+ yExtentDomain = [ y0, y1 ];
+ if (y.invert) y0 = y(y0), y1 = y(y1);
+ if (y1 < y0) t = y0, y0 = y1, y1 = t;
+ if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [ y0, y1 ];
+ }
+ return brush;
+ };
+ brush.clear = function() {
+ if (!brush.empty()) {
+ xExtent = [ 0, 0 ], yExtent = [ 0, 0 ];
+ xExtentDomain = yExtentDomain = null;
+ }
+ return brush;
+ };
+ brush.empty = function() {
+ return !!x && xExtent[0] == xExtent[1] || !!y && yExtent[0] == yExtent[1];
+ };
+ return d3.rebind(brush, event, "on");
+ };
+ var d3_svg_brushCursor = {
+ n: "ns-resize",
+ e: "ew-resize",
+ s: "ns-resize",
+ w: "ew-resize",
+ nw: "nwse-resize",
+ ne: "nesw-resize",
+ se: "nwse-resize",
+ sw: "nesw-resize"
+ };
+ var d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ];
+ var d3_time_format = d3_time.format = d3_locale_enUS.timeFormat;
+ var d3_time_formatUtc = d3_time_format.utc;
+ var d3_time_formatIso = d3_time_formatUtc("%Y-%m-%dT%H:%M:%S.%LZ");
+ d3_time_format.iso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z") ? d3_time_formatIsoNative : d3_time_formatIso;
+ function d3_time_formatIsoNative(date) {
+ return date.toISOString();
+ }
+ d3_time_formatIsoNative.parse = function(string) {
+ var date = new Date(string);
+ return isNaN(date) ? null : date;
+ };
+ d3_time_formatIsoNative.toString = d3_time_formatIso.toString;
+ d3_time.second = d3_time_interval(function(date) {
+ return new d3_date(Math.floor(date / 1e3) * 1e3);
+ }, function(date, offset) {
+ date.setTime(date.getTime() + Math.floor(offset) * 1e3);
+ }, function(date) {
+ return date.getSeconds();
+ });
+ d3_time.seconds = d3_time.second.range;
+ d3_time.seconds.utc = d3_time.second.utc.range;
+ d3_time.minute = d3_time_interval(function(date) {
+ return new d3_date(Math.floor(date / 6e4) * 6e4);
+ }, function(date, offset) {
+ date.setTime(date.getTime() + Math.floor(offset) * 6e4);
+ }, function(date) {
+ return date.getMinutes();
+ });
+ d3_time.minutes = d3_time.minute.range;
+ d3_time.minutes.utc = d3_time.minute.utc.range;
+ d3_time.hour = d3_time_interval(function(date) {
+ var timezone = date.getTimezoneOffset() / 60;
+ return new d3_date((Math.floor(date / 36e5 - timezone) + timezone) * 36e5);
+ }, function(date, offset) {
+ date.setTime(date.getTime() + Math.floor(offset) * 36e5);
+ }, function(date) {
+ return date.getHours();
+ });
+ d3_time.hours = d3_time.hour.range;
+ d3_time.hours.utc = d3_time.hour.utc.range;
+ d3_time.month = d3_time_interval(function(date) {
+ date = d3_time.day(date);
+ date.setDate(1);
+ return date;
+ }, function(date, offset) {
+ date.setMonth(date.getMonth() + offset);
+ }, function(date) {
+ return date.getMonth();
+ });
+ d3_time.months = d3_time.month.range;
+ d3_time.months.utc = d3_time.month.utc.range;
+ function d3_time_scale(linear, methods, format) {
+ function scale(x) {
+ return linear(x);
+ }
+ scale.invert = function(x) {
+ return d3_time_scaleDate(linear.invert(x));
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return linear.domain().map(d3_time_scaleDate);
+ linear.domain(x);
+ return scale;
+ };
+ function tickMethod(extent, count) {
+ var span = extent[1] - extent[0], target = span / count, i = d3.bisect(d3_time_scaleSteps, target);
+ return i == d3_time_scaleSteps.length ? [ methods.year, d3_scale_linearTickRange(extent.map(function(d) {
+ return d / 31536e6;
+ }), count)[2] ] : !i ? [ d3_time_scaleMilliseconds, d3_scale_linearTickRange(extent, count)[2] ] : methods[target / d3_time_scaleSteps[i - 1] < d3_time_scaleSteps[i] / target ? i - 1 : i];
+ }
+ scale.nice = function(interval, skip) {
+ var domain = scale.domain(), extent = d3_scaleExtent(domain), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" && tickMethod(extent, interval);
+ if (method) interval = method[0], skip = method[1];
+ function skipped(date) {
+ return !isNaN(date) && !interval.range(date, d3_time_scaleDate(+date + 1), skip).length;
+ }
+ return scale.domain(d3_scale_nice(domain, skip > 1 ? {
+ floor: function(date) {
+ while (skipped(date = interval.floor(date))) date = d3_time_scaleDate(date - 1);
+ return date;
+ },
+ ceil: function(date) {
+ while (skipped(date = interval.ceil(date))) date = d3_time_scaleDate(+date + 1);
+ return date;
+ }
+ } : interval));
+ };
+ scale.ticks = function(interval, skip) {
+ var extent = d3_scaleExtent(scale.domain()), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" ? tickMethod(extent, interval) : !interval.range && [ {
+ range: interval
+ }, skip ];
+ if (method) interval = method[0], skip = method[1];
+ return interval.range(extent[0], d3_time_scaleDate(+extent[1] + 1), skip < 1 ? 1 : skip);
+ };
+ scale.tickFormat = function() {
+ return format;
+ };
+ scale.copy = function() {
+ return d3_time_scale(linear.copy(), methods, format);
+ };
+ return d3_scale_linearRebind(scale, linear);
+ }
+ function d3_time_scaleDate(t) {
+ return new Date(t);
+ }
+ var d3_time_scaleSteps = [ 1e3, 5e3, 15e3, 3e4, 6e4, 3e5, 9e5, 18e5, 36e5, 108e5, 216e5, 432e5, 864e5, 1728e5, 6048e5, 2592e6, 7776e6, 31536e6 ];
+ var d3_time_scaleLocalMethods = [ [ d3_time.second, 1 ], [ d3_time.second, 5 ], [ d3_time.second, 15 ], [ d3_time.second, 30 ], [ d3_time.minute, 1 ], [ d3_time.minute, 5 ], [ d3_time.minute, 15 ], [ d3_time.minute, 30 ], [ d3_time.hour, 1 ], [ d3_time.hour, 3 ], [ d3_time.hour, 6 ], [ d3_time.hour, 12 ], [ d3_time.day, 1 ], [ d3_time.day, 2 ], [ d3_time.week, 1 ], [ d3_time.month, 1 ], [ d3_time.month, 3 ], [ d3_time.year, 1 ] ];
+ var d3_time_scaleLocalFormat = d3_time_format.multi([ [ ".%L", function(d) {
+ return d.getMilliseconds();
+ } ], [ ":%S", function(d) {
+ return d.getSeconds();
+ } ], [ "%I:%M", function(d) {
+ return d.getMinutes();
+ } ], [ "%I %p", function(d) {
+ return d.getHours();
+ } ], [ "%a %d", function(d) {
+ return d.getDay() && d.getDate() != 1;
+ } ], [ "%b %d", function(d) {
+ return d.getDate() != 1;
+ } ], [ "%B", function(d) {
+ return d.getMonth();
+ } ], [ "%Y", d3_true ] ]);
+ var d3_time_scaleMilliseconds = {
+ range: function(start, stop, step) {
+ return d3.range(Math.ceil(start / step) * step, +stop, step).map(d3_time_scaleDate);
+ },
+ floor: d3_identity,
+ ceil: d3_identity
+ };
+ d3_time_scaleLocalMethods.year = d3_time.year;
+ d3_time.scale = function() {
+ return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat);
+ };
+ var d3_time_scaleUtcMethods = d3_time_scaleLocalMethods.map(function(m) {
+ return [ m[0].utc, m[1] ];
+ });
+ var d3_time_scaleUtcFormat = d3_time_formatUtc.multi([ [ ".%L", function(d) {
+ return d.getUTCMilliseconds();
+ } ], [ ":%S", function(d) {
+ return d.getUTCSeconds();
+ } ], [ "%I:%M", function(d) {
+ return d.getUTCMinutes();
+ } ], [ "%I %p", function(d) {
+ return d.getUTCHours();
+ } ], [ "%a %d", function(d) {
+ return d.getUTCDay() && d.getUTCDate() != 1;
+ } ], [ "%b %d", function(d) {
+ return d.getUTCDate() != 1;
+ } ], [ "%B", function(d) {
+ return d.getUTCMonth();
+ } ], [ "%Y", d3_true ] ]);
+ d3_time_scaleUtcMethods.year = d3_time.year.utc;
+ d3_time.scale.utc = function() {
+ return d3_time_scale(d3.scale.linear(), d3_time_scaleUtcMethods, d3_time_scaleUtcFormat);
+ };
+ d3.text = d3_xhrType(function(request) {
+ return request.responseText;
+ });
+ d3.json = function(url, callback) {
+ return d3_xhr(url, "application/json", d3_json, callback);
+ };
+ function d3_json(request) {
+ return JSON.parse(request.responseText);
+ }
+ d3.html = function(url, callback) {
+ return d3_xhr(url, "text/html", d3_html, callback);
+ };
+ function d3_html(request) {
+ var range = d3_document.createRange();
+ range.selectNode(d3_document.body);
+ return range.createContextualFragment(request.responseText);
+ }
+ d3.xml = d3_xhrType(function(request) {
+ return request.responseXML;
+ });
+ if (typeof define === "function" && define.amd) define(d3); else if (typeof module === "object" && module.exports) module.exports = d3;
+ this.d3 = d3;
+}();
\ No newline at end of file
diff --git a/debian/missing-source/dagre-d3.js b/debian/missing-source/dagre-d3.js
new file mode 100644
index 0000000..c427486
--- /dev/null
+++ b/debian/missing-source/dagre-d3.js
@@ -0,0 +1,25569 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.dagreD3=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot fi [...]
+/**
+ * @license
+ * Copyright (c) 2012-2013 Chris Pettitt
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+module.exports = {
+ graphlib: require("./lib/graphlib"),
+ dagre: require("./lib/dagre"),
+ intersect: require("./lib/intersect"),
+ render: require("./lib/render"),
+ util: require("./lib/util"),
+ version: require("./lib/version")
+};
+
+},{"./lib/dagre":8,"./lib/graphlib":9,"./lib/intersect":10,"./lib/render":25,"./lib/util":27,"./lib/version":28}],2:[function(require,module,exports){
+var util = require("./util");
+
+module.exports = {
+ "default": normal,
+ "normal": normal,
+ "vee": vee,
+ "undirected": undirected
+};
+
+function normal(parent, id, edge, type) {
+ var marker = parent.append("marker")
+ .attr("id", id)
+ .attr("viewBox", "0 0 10 10")
+ .attr("refX", 9)
+ .attr("refY", 5)
+ .attr("markerUnits", "strokeWidth")
+ .attr("markerWidth", 8)
+ .attr("markerHeight", 6)
+ .attr("orient", "auto");
+
+ var path = marker.append("path")
+ .attr("d", "M 0 0 L 10 5 L 0 10 z")
+ .style("stroke-width", 1)
+ .style("stroke-dasharray", "1,0");
+ util.applyStyle(path, edge[type + "Style"]);
+}
+
+function vee(parent, id, edge, type) {
+ var marker = parent.append("marker")
+ .attr("id", id)
+ .attr("viewBox", "0 0 10 10")
+ .attr("refX", 9)
+ .attr("refY", 5)
+ .attr("markerUnits", "strokeWidth")
+ .attr("markerWidth", 8)
+ .attr("markerHeight", 6)
+ .attr("orient", "auto");
+
+ var path = marker.append("path")
+ .attr("d", "M 0 0 L 10 5 L 0 10 L 4 5 z")
+ .style("stroke-width", 1)
+ .style("stroke-dasharray", "1,0");
+ util.applyStyle(path, edge[type + "Style"]);
+}
+
+function undirected(parent, id, edge, type) {
+ var marker = parent.append("marker")
+ .attr("id", id)
+ .attr("viewBox", "0 0 10 10")
+ .attr("refX", 9)
+ .attr("refY", 5)
+ .attr("markerUnits", "strokeWidth")
+ .attr("markerWidth", 8)
+ .attr("markerHeight", 6)
+ .attr("orient", "auto");
+
+ var path = marker.append("path")
+ .attr("d", "M 0 5 L 10 5")
+ .style("stroke-width", 1)
+ .style("stroke-dasharray", "1,0");
+ util.applyStyle(path, edge[type + "Style"]);
+}
+
+},{"./util":27}],3:[function(require,module,exports){
+var util = require("./util"),
+ addLabel = require("./label/add-label");
+
+module.exports = createClusters;
+
+function createClusters(selection, g) {
+ var clusters = g.nodes().filter(function(v) { return util.isSubgraph(g, v); }),
+ svgClusters = selection.selectAll("g.cluster")
+ .data(clusters, function(v) { return v; });
+
+ svgClusters.selectAll("*").remove();
+ svgClusters.enter()
+ .append("g")
+ .attr("class", "cluster")
+ .style("opacity", 0)
+ .append("rect");
+ util.applyTransition(svgClusters.exit(), g)
+ .style("opacity", 0)
+ .remove();
+
+ util.applyTransition(svgClusters, g)
+ .style("opacity", 1);
+
+ svgClusters.each(function(v) {
+ var node = g.node(v),
+ thisGroup = d3.select(this),
+ labelGroup = thisGroup.append("g").attr("class", "label");
+ addLabel(labelGroup, node, node.clusterLabelPos);
+ });
+
+ svgClusters.selectAll("rect").each(function(c) {
+ var node = g.node(c);
+ var domCluster = d3.select(this);
+ util.applyStyle(domCluster, node.style);
+ });
+}
+
+},{"./label/add-label":18,"./util":27}],4:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ addLabel = require("./label/add-label"),
+ util = require("./util"),
+ d3 = require("./d3");
+
+module.exports = createEdgeLabels;
+
+function createEdgeLabels(selection, g) {
+ var svgEdgeLabels = selection.selectAll("g.edgeLabel")
+ .data(g.edges(), function(e) { return util.edgeToId(e); })
+ .classed("update", true);
+
+ svgEdgeLabels.selectAll("*").remove();
+ svgEdgeLabels.enter()
+ .append("g")
+ .classed("edgeLabel", true)
+ .style("opacity", 0);
+ svgEdgeLabels.each(function(e) {
+ var edge = g.edge(e),
+ label = addLabel(d3.select(this), g.edge(e), 0, 0).classed("label", true),
+ bbox = label.node().getBBox();
+
+ if (edge.labelId) { label.attr("id", edge.labelId); }
+ if (!_.has(edge, "width")) { edge.width = bbox.width; }
+ if (!_.has(edge, "height")) { edge.height = bbox.height; }
+ });
+
+ util.applyTransition(svgEdgeLabels.exit(), g)
+ .style("opacity", 0)
+ .remove();
+
+ return svgEdgeLabels;
+}
+
+},{"./d3":7,"./label/add-label":18,"./lodash":21,"./util":27}],5:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ intersectNode = require("./intersect/intersect-node"),
+ util = require("./util"),
+ d3 = require("./d3");
+
+module.exports = createEdgePaths;
+
+function createEdgePaths(selection, g, arrows) {
+ var svgPaths = selection.selectAll("g.edgePath")
+ .data(g.edges(), function(e) { return util.edgeToId(e); })
+ .classed("update", true);
+
+ enter(svgPaths, g);
+ exit(svgPaths, g);
+
+ util.applyTransition(svgPaths, g)
+ .style("opacity", 1);
+
+ // Save DOM element in the path group, and set ID and class
+ svgPaths.each(function(e) {
+ var domEdge = d3.select(this);
+ var edge = g.edge(e);
+ edge.elem = this;
+
+ if (edge.id) {
+ domEdge.attr("id", edge.id);
+ }
+
+ util.applyClass(domEdge, edge["class"],
+ (domEdge.classed("update") ? "update " : "") + "edgePath");
+ });
+
+ svgPaths.selectAll("path.path")
+ .each(function(e) {
+ var edge = g.edge(e);
+ edge.arrowheadId = _.uniqueId("arrowhead");
+
+ var domEdge = d3.select(this)
+ .attr("marker-end", function() {
+ return "url(#" + edge.arrowheadId + ")";
+ })
+ .style("fill", "none");
+
+ util.applyTransition(domEdge, g)
+ .attr("d", function(e) { return calcPoints(g, e); });
+
+ util.applyStyle(domEdge, edge.style);
+ });
+
+ svgPaths.selectAll("defs *").remove();
+ svgPaths.selectAll("defs")
+ .each(function(e) {
+ var edge = g.edge(e),
+ arrowhead = arrows[edge.arrowhead];
+ arrowhead(d3.select(this), edge.arrowheadId, edge, "arrowhead");
+ });
+
+ return svgPaths;
+}
+
+function calcPoints(g, e) {
+ var edge = g.edge(e),
+ tail = g.node(e.v),
+ head = g.node(e.w),
+ points = edge.points.slice(1, edge.points.length - 1);
+ points.unshift(intersectNode(tail, points[0]));
+ points.push(intersectNode(head, points[points.length - 1]));
+
+ return createLine(edge, points);
+}
+
+function createLine(edge, points) {
+ var line = d3.svg.line()
+ .x(function(d) { return d.x; })
+ .y(function(d) { return d.y; });
+
+ if (_.has(edge, "lineInterpolate")) {
+ line.interpolate(edge.lineInterpolate);
+ }
+
+ if (_.has(edge, "lineTension")) {
+ line.tension(Number(edge.lineTension));
+ }
+
+ return line(points);
+}
+
+function getCoords(elem) {
+ var bbox = elem.getBBox(),
+ matrix = elem.getTransformToElement(elem.ownerSVGElement)
+ .translate(bbox.width / 2, bbox.height / 2);
+ return { x: matrix.e, y: matrix.f };
+}
+
+function enter(svgPaths, g) {
+ var svgPathsEnter = svgPaths.enter()
+ .append("g")
+ .attr("class", "edgePath")
+ .style("opacity", 0);
+ svgPathsEnter.append("path")
+ .attr("class", "path")
+ .attr("d", function(e) {
+ var edge = g.edge(e),
+ sourceElem = g.node(e.v).elem,
+ points = _.range(edge.points.length).map(function() { return getCoords(sourceElem); });
+ return createLine(edge, points);
+ });
+ svgPathsEnter.append("defs");
+}
+
+function exit(svgPaths, g) {
+ var svgPathExit = svgPaths.exit();
+ util.applyTransition(svgPathExit, g)
+ .style("opacity", 0)
+ .remove();
+
+ util.applyTransition(svgPathExit.select("path.path"), g)
+ .attr("d", function(e) {
+ var source = g.node(e.v);
+
+ if (source) {
+ var points = _.range(this.pathSegList.length).map(function() { return source; });
+ return createLine({}, points);
+ } else {
+ return d3.select(this).attr("d");
+ }
+ });
+}
+
+},{"./d3":7,"./intersect/intersect-node":14,"./lodash":21,"./util":27}],6:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ addLabel = require("./label/add-label"),
+ util = require("./util"),
+ d3 = require("./d3");
+
+module.exports = createNodes;
+
+function createNodes(selection, g, shapes) {
+ var simpleNodes = g.nodes().filter(function(v) { return !util.isSubgraph(g, v); });
+ var svgNodes = selection.selectAll("g.node")
+ .data(simpleNodes, function(v) { return v; })
+ .classed("update", true);
+
+ svgNodes.selectAll("*").remove();
+ svgNodes.enter()
+ .append("g")
+ .attr("class", "node")
+ .style("opacity", 0);
+ svgNodes.each(function(v) {
+ var node = g.node(v),
+ thisGroup = d3.select(this),
+ labelGroup = thisGroup.append("g").attr("class", "label"),
+ labelDom = addLabel(labelGroup, node),
+ shape = shapes[node.shape],
+ bbox = _.pick(labelDom.node().getBBox(), "width", "height");
+
+ node.elem = this;
+
+ if (node.id) { thisGroup.attr("id", node.id); }
+ if (node.labelId) { labelGroup.attr("id", node.labelId); }
+ util.applyClass(thisGroup, node["class"],
+ (thisGroup.classed("update") ? "update " : "") + "node");
+
+ if (_.has(node, "width")) { bbox.width = node.width; }
+ if (_.has(node, "height")) { bbox.height = node.height; }
+
+ bbox.width += node.paddingLeft + node.paddingRight;
+ bbox.height += node.paddingTop + node.paddingBottom;
+ labelGroup.attr("transform", "translate(" +
+ ((node.paddingLeft - node.paddingRight) / 2) + "," +
+ ((node.paddingTop - node.paddingBottom) / 2) + ")");
+
+ var shapeSvg = shape(d3.select(this), bbox, node);
+ util.applyStyle(shapeSvg, node.style);
+
+ var shapeBBox = shapeSvg.node().getBBox();
+ node.width = shapeBBox.width;
+ node.height = shapeBBox.height;
+ });
+
+ util.applyTransition(svgNodes.exit(), g)
+ .style("opacity", 0)
+ .remove();
+
+ return svgNodes;
+}
+
+},{"./d3":7,"./label/add-label":18,"./lodash":21,"./util":27}],7:[function(require,module,exports){
+// Stub to get D3 either via NPM or from the global object
+module.exports = window.d3;
+
+},{}],8:[function(require,module,exports){
+/* global window */
+
+var dagre;
+
+if (require) {
+ try {
+ dagre = require("dagre");
+ } catch (e) {}
+}
+
+if (!dagre) {
+ dagre = window.dagre;
+}
+
+module.exports = dagre;
+
+},{"dagre":29}],9:[function(require,module,exports){
+/* global window */
+
+var graphlib;
+
+if (require) {
+ try {
+ graphlib = require("graphlib");
+ } catch (e) {}
+}
+
+if (!graphlib) {
+ graphlib = window.graphlib;
+}
+
+module.exports = graphlib;
+
+},{"graphlib":60}],10:[function(require,module,exports){
+module.exports = {
+ node: require("./intersect-node"),
+ circle: require("./intersect-circle"),
+ ellipse: require("./intersect-ellipse"),
+ polygon: require("./intersect-polygon"),
+ rect: require("./intersect-rect")
+};
+
+},{"./intersect-circle":11,"./intersect-ellipse":12,"./intersect-node":14,"./intersect-polygon":15,"./intersect-rect":16}],11:[function(require,module,exports){
+var intersectEllipse = require("./intersect-ellipse");
+
+module.exports = intersectCircle;
+
+function intersectCircle(node, rx, point) {
+ return intersectEllipse(node, rx, rx, point);
+}
+
+},{"./intersect-ellipse":12}],12:[function(require,module,exports){
+module.exports = intersectEllipse;
+
+function intersectEllipse(node, rx, ry, point) {
+ // Formulae from: http://mathworld.wolfram.com/Ellipse-LineIntersection.html
+
+ var cx = node.x;
+ var cy = node.y;
+
+ var px = cx - point.x;
+ var py = cy - point.y;
+
+ var det = Math.sqrt(rx * rx * py * py + ry * ry * px * px);
+
+ var dx = Math.abs(rx * ry * px / det);
+ if (point.x < cx) {
+ dx = -dx;
+ }
+ var dy = Math.abs(rx * ry * py / det);
+ if (point.y < cy) {
+ dy = -dy;
+ }
+
+ return {x: cx + dx, y: cy + dy};
+}
+
+
+},{}],13:[function(require,module,exports){
+module.exports = intersectLine;
+
+/*
+ * Returns the point at which two lines, p and q, intersect or returns
+ * undefined if they do not intersect.
+ */
+function intersectLine(p1, p2, q1, q2) {
+ // Algorithm from J. Avro, (ed.) Graphics Gems, No 2, Morgan Kaufmann, 1994,
+ // p7 and p473.
+
+ var a1, a2, b1, b2, c1, c2;
+ var r1, r2 , r3, r4;
+ var denom, offset, num;
+ var x, y;
+
+ // Compute a1, b1, c1, where line joining points 1 and 2 is F(x,y) = a1 x +
+ // b1 y + c1 = 0.
+ a1 = p2.y - p1.y;
+ b1 = p1.x - p2.x;
+ c1 = (p2.x * p1.y) - (p1.x * p2.y);
+
+ // Compute r3 and r4.
+ r3 = ((a1 * q1.x) + (b1 * q1.y) + c1);
+ r4 = ((a1 * q2.x) + (b1 * q2.y) + c1);
+
+ // Check signs of r3 and r4. If both point 3 and point 4 lie on
+ // same side of line 1, the line segments do not intersect.
+ if ((r3 !== 0) && (r4 !== 0) && sameSign(r3, r4)) {
+ return /*DONT_INTERSECT*/;
+ }
+
+ // Compute a2, b2, c2 where line joining points 3 and 4 is G(x,y) = a2 x + b2 y + c2 = 0
+ a2 = q2.y - q1.y;
+ b2 = q1.x - q2.x;
+ c2 = (q2.x * q1.y) - (q1.x * q2.y);
+
+ // Compute r1 and r2
+ r1 = (a2 * p1.x) + (b2 * p1.yy) + c2;
+ r2 = (a2 * p2.x) + (b2 * p2.y) + c2;
+
+ // Check signs of r1 and r2. If both point 1 and point 2 lie
+ // on same side of second line segment, the line segments do
+ // not intersect.
+ if ((r1 !== 0) && (r2 !== 0) && (sameSign(r1, r2))) {
+ return /*DONT_INTERSECT*/;
+ }
+
+ // Line segments intersect: compute intersection point.
+ denom = (a1 * b2) - (a2 * b1);
+ if (denom === 0) {
+ return /*COLLINEAR*/;
+ }
+
+ offset = Math.abs(denom / 2);
+
+ // The denom/2 is to get rounding instead of truncating. It
+ // is added or subtracted to the numerator, depending upon the
+ // sign of the numerator.
+ num = (b1 * c2) - (b2 * c1);
+ x = (num < 0) ? ((num - offset) / denom) : ((num + offset) / denom);
+
+ num = (a2 * c1) - (a1 * c2);
+ y = (num < 0) ? ((num - offset) / denom) : ((num + offset) / denom);
+
+ return { x: x, y: y };
+}
+
+function sameSign(r1, r2) {
+ return r1 * r2 > 0;
+}
+
+},{}],14:[function(require,module,exports){
+module.exports = intersectNode;
+
+function intersectNode(node, point) {
+ return node.intersect(point);
+}
+
+},{}],15:[function(require,module,exports){
+var intersectLine = require("./intersect-line");
+
+module.exports = intersectPolygon;
+
+/*
+ * Returns the point ({x, y}) at which the point argument intersects with the
+ * node argument assuming that it has the shape specified by polygon.
+ */
+function intersectPolygon(node, polyPoints, point) {
+ var x1 = node.x;
+ var y1 = node.y;
+
+ var intersections = [];
+
+ var minX = Number.POSITIVE_INFINITY,
+ minY = Number.POSITIVE_INFINITY;
+ polyPoints.forEach(function(entry) {
+ minX = Math.min(minX, entry.x);
+ minY = Math.min(minY, entry.y);
+ });
+
+ var left = x1 - node.width / 2 - minX;
+ var top = y1 - node.height / 2 - minY;
+
+ for (var i = 0; i < polyPoints.length; i++) {
+ var p1 = polyPoints[i];
+ var p2 = polyPoints[i < polyPoints.length - 1 ? i + 1 : 0];
+ var intersect = intersectLine(node, point,
+ {x: left + p1.x, y: top + p1.y}, {x: left + p2.x, y: top + p2.y});
+ if (intersect) {
+ intersections.push(intersect);
+ }
+ }
+
+ if (!intersections.length) {
+ console.log("NO INTERSECTION FOUND, RETURN NODE CENTER", node);
+ return node;
+ }
+
+ if (intersections.length > 1) {
+ // More intersections, find the one nearest to edge end point
+ intersections.sort(function(p, q) {
+ var pdx = p.x - point.x,
+ pdy = p.y - point.y,
+ distp = Math.sqrt(pdx * pdx + pdy * pdy),
+
+ qdx = q.x - point.x,
+ qdy = q.y - point.y,
+ distq = Math.sqrt(qdx * qdx + qdy * qdy);
+
+ return (distp < distq) ? -1 : (distp === distq ? 0 : 1);
+ });
+ }
+ return intersections[0];
+}
+
+},{"./intersect-line":13}],16:[function(require,module,exports){
+module.exports = intersectRect;
+
+function intersectRect(node, point) {
+ var x = node.x;
+ var y = node.y;
+
+ // Rectangle intersection algorithm from:
+ // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
+ var dx = point.x - x;
+ var dy = point.y - y;
+ var w = node.width / 2;
+ var h = node.height / 2;
+
+ var sx, sy;
+ if (Math.abs(dy) * w > Math.abs(dx) * h) {
+ // Intersection is top or bottom of rect.
+ if (dy < 0) {
+ h = -h;
+ }
+ sx = dy === 0 ? 0 : h * dx / dy;
+ sy = h;
+ } else {
+ // Intersection is left or right of rect.
+ if (dx < 0) {
+ w = -w;
+ }
+ sx = w;
+ sy = dx === 0 ? 0 : w * dy / dx;
+ }
+
+ return {x: x + sx, y: y + sy};
+}
+
+},{}],17:[function(require,module,exports){
+var util = require("../util");
+
+module.exports = addHtmlLabel;
+
+function addHtmlLabel(root, node) {
+ var fo = root
+ .append("foreignObject")
+ .attr("width", "100000");
+
+ var div = fo
+ .append("xhtml:div");
+
+ var label = node.label;
+ switch(typeof label) {
+ case "function":
+ div.insert(label);
+ break;
+ case "object":
+ // Currently we assume this is a DOM object.
+ div.insert(function() { return label; });
+ break;
+ default: div.html(label);
+ }
+
+ util.applyStyle(div, node.labelStyle);
+ div.style("display", "inline-block");
+ // Fix for firefox
+ div.style("white-space", "nowrap");
+
+ // TODO find a better way to get dimensions for foreignObjects...
+ var w, h;
+ div
+ .each(function() {
+ w = this.clientWidth;
+ h = this.clientHeight;
+ });
+
+ fo
+ .attr("width", w)
+ .attr("height", h);
+
+ return fo;
+}
+
+},{"../util":27}],18:[function(require,module,exports){
+var addTextLabel = require("./add-text-label"),
+ addHtmlLabel = require("./add-html-label"),
+ addSVGLabel = require("./add-svg-label");
+
+module.exports = addLabel;
+
+function addLabel(root, node, location) {
+ var label = node.label;
+ var labelSvg = root.append("g");
+
+ // Allow the label to be a string, a function that returns a DOM element, or
+ // a DOM element itself.
+ if (node.labelType === "svg") {
+ addSVGLabel(labelSvg, node);
+ } else if (typeof label !== "string" || node.labelType === "html") {
+ addHtmlLabel(labelSvg, node);
+ } else {
+ addTextLabel(labelSvg, node);
+ }
+
+ var labelBBox = labelSvg.node().getBBox();
+ switch(location) {
+ case "top":
+ y = (-node.height / 2);
+ break;
+ case "bottom":
+ y = (node.height / 2) - labelBBox.height;
+ break;
+ default:
+ y = (-labelBBox.height / 2);
+ }
+ labelSvg.attr("transform",
+ "translate(" + (-labelBBox.width / 2) + "," + y + ")");
+
+ return labelSvg;
+}
+
+},{"./add-html-label":17,"./add-svg-label":19,"./add-text-label":20}],19:[function(require,module,exports){
+var util = require("../util");
+
+module.exports = addSVGLabel;
+
+function addSVGLabel(root, node) {
+ var domNode = root;
+
+ domNode.node().appendChild(node.label);
+
+ util.applyStyle(domNode, node.labelStyle);
+
+ return domNode;
+}
+
+},{"../util":27}],20:[function(require,module,exports){
+var util = require("../util");
+
+module.exports = addTextLabel;
+
+/*
+ * Attaches a text label to the specified root. Handles escape sequences.
+ */
+function addTextLabel(root, node) {
+ var domNode = root.append("text");
+
+ var lines = processEscapeSequences(node.label).split("\n");
+ for (var i = 0; i < lines.length; i++) {
+ domNode
+ .append("tspan")
+ .attr("xml:space", "preserve")
+ .attr("dy", "1em")
+ .attr("x", "1")
+ .text(lines[i]);
+ }
+
+ util.applyStyle(domNode, node.labelStyle);
+
+ return domNode;
+}
+
+function processEscapeSequences(text) {
+ var newText = "",
+ escaped = false,
+ ch;
+ for (var i = 0; i < text.length; ++i) {
+ ch = text[i];
+ if (escaped) {
+ switch(ch) {
+ case "n": newText += "\n"; break;
+ default: newText += ch;
+ }
+ escaped = false;
+ } else if (ch === "\\") {
+ escaped = true;
+ } else {
+ newText += ch;
+ }
+ }
+ return newText;
+}
+
+},{"../util":27}],21:[function(require,module,exports){
+/* global window */
+
+var lodash;
+
+if (require) {
+ try {
+ lodash = require("lodash");
+ } catch (e) {}
+}
+
+if (!lodash) {
+ lodash = window._;
+}
+
+module.exports = lodash;
+
+},{"lodash":81}],22:[function(require,module,exports){
+"use strict";
+
+var util = require("./util"),
+ d3 = require("./d3");
+
+module.exports = positionClusters;
+
+function positionClusters(selection, g) {
+ var created = selection.filter(function() { return !d3.select(this).classed("update"); });
+
+ function translate(v) {
+ var node = g.node(v);
+ return "translate(" + node.x + "," + node.y + ")";
+ }
+
+ created.attr("transform", translate);
+
+ util.applyTransition(selection, g)
+ .style("opacity", 1)
+ .attr("transform", translate);
+
+ util.applyTransition(created.selectAll("rect"), g)
+ .attr("width", function(v) { return g.node(v).width; })
+ .attr("height", function(v) { return g.node(v).height; })
+ .attr("x", function(v) {
+ var node = g.node(v);
+ return -node.width / 2;
+ })
+ .attr("y", function(v) {
+ var node = g.node(v);
+ return -node.height / 2;
+ });
+
+}
+
+},{"./d3":7,"./util":27}],23:[function(require,module,exports){
+"use strict";
+
+var util = require("./util"),
+ d3 = require("./d3"),
+ _ = require("./lodash");
+
+module.exports = positionEdgeLabels;
+
+function positionEdgeLabels(selection, g) {
+ var created = selection.filter(function() { return !d3.select(this).classed("update"); });
+
+ function translate(e) {
+ var edge = g.edge(e);
+ return _.has(edge, "x") ? "translate(" + edge.x + "," + edge.y + ")" : "";
+ }
+
+ created.attr("transform", translate);
+
+ util.applyTransition(selection, g)
+ .style("opacity", 1)
+ .attr("transform", translate);
+}
+
+},{"./d3":7,"./lodash":21,"./util":27}],24:[function(require,module,exports){
+"use strict";
+
+var util = require("./util"),
+ d3 = require("./d3");
+
+module.exports = positionNodes;
+
+function positionNodes(selection, g) {
+ var created = selection.filter(function() { return !d3.select(this).classed("update"); });
+
+ function translate(v) {
+ var node = g.node(v);
+ return "translate(" + node.x + "," + node.y + ")";
+ }
+
+ created.attr("transform", translate);
+
+ util.applyTransition(selection, g)
+ .style("opacity", 1)
+ .attr("transform", translate);
+}
+
+},{"./d3":7,"./util":27}],25:[function(require,module,exports){
+var _ = require("./lodash"),
+ layout = require("./dagre").layout;
+
+module.exports = render;
+
+// This design is based on http://bost.ocks.org/mike/chart/.
+function render() {
+ var createNodes = require("./create-nodes"),
+ createClusters = require("./create-clusters"),
+ createEdgeLabels = require("./create-edge-labels"),
+ createEdgePaths = require("./create-edge-paths"),
+ positionNodes = require("./position-nodes"),
+ positionEdgeLabels = require("./position-edge-labels"),
+ positionClusters = require("./position-clusters"),
+ shapes = require("./shapes"),
+ arrows = require("./arrows");
+
+ var fn = function(svg, g) {
+ preProcessGraph(g);
+
+ var outputGroup = createOrSelectGroup(svg, "output"),
+ clustersGroup = createOrSelectGroup(outputGroup, "clusters"),
+ edgePathsGroup = createOrSelectGroup(outputGroup, "edgePaths"),
+ edgeLabels = createEdgeLabels(createOrSelectGroup(outputGroup, "edgeLabels"), g),
+ nodes = createNodes(createOrSelectGroup(outputGroup, "nodes"), g, shapes);
+
+ layout(g);
+
+ positionNodes(nodes, g);
+ positionEdgeLabels(edgeLabels, g);
+ createEdgePaths(edgePathsGroup, g, arrows);
+ createClusters(clustersGroup, g);
+ positionClusters(clustersGroup.selectAll("g.cluster"), g);
+
+ postProcessGraph(g);
+ };
+
+ fn.createNodes = function(value) {
+ if (!arguments.length) return createNodes;
+ createNodes = value;
+ return fn;
+ };
+
+ fn.createClusters = function(value) {
+ if (!arguments.length) return createClusters;
+ createClusters = value;
+ return fn;
+ };
+
+ fn.createEdgeLabels = function(value) {
+ if (!arguments.length) return createEdgeLabels;
+ createEdgeLabels = value;
+ return fn;
+ };
+
+ fn.createEdgePaths = function(value) {
+ if (!arguments.length) return createEdgePaths;
+ createEdgePaths = value;
+ return fn;
+ };
+
+ fn.shapes = function(value) {
+ if (!arguments.length) return shapes;
+ shapes = value;
+ return fn;
+ };
+
+ fn.arrows = function(value) {
+ if (!arguments.length) return arrows;
+ arrows = value;
+ return fn;
+ };
+
+ return fn;
+}
+
+var NODE_DEFAULT_ATTRS = {
+ paddingLeft: 10,
+ paddingRight: 10,
+ paddingTop: 10,
+ paddingBottom: 10,
+ rx: 0,
+ ry: 0,
+ shape: "rect"
+};
+
+var EDGE_DEFAULT_ATTRS = {
+ arrowhead: "normal",
+ lineInterpolate: "linear"
+};
+
+function preProcessGraph(g) {
+ g.nodes().forEach(function(v) {
+ var node = g.node(v);
+ if (!_.has(node, "label")) { node.label = v; }
+
+ if (_.has(node, "paddingX")) {
+ _.defaults(node, {
+ paddingLeft: node.paddingX,
+ paddingRight: node.paddingX
+ });
+ }
+
+ if (_.has(node, "paddingY")) {
+ _.defaults(node, {
+ paddingTop: node.paddingY,
+ paddingBottom: node.paddingY
+ });
+ }
+
+ if (_.has(node, "padding")) {
+ _.defaults(node, {
+ paddingLeft: node.padding,
+ paddingRight: node.padding,
+ paddingTop: node.padding,
+ paddingBottom: node.padding
+ });
+ }
+
+ _.defaults(node, NODE_DEFAULT_ATTRS);
+
+ _.each(["paddingLeft", "paddingRight", "paddingTop", "paddingBottom"], function(k) {
+ node[k] = Number(node[k]);
+ });
+
+ // Save dimensions for restore during post-processing
+ if (_.has(node, "width")) { node._prevWidth = node.width; }
+ if (_.has(node, "height")) { node._prevHeight = node.height; }
+ });
+
+ g.edges().forEach(function(e) {
+ var edge = g.edge(e);
+ if (!_.has(edge, "label")) { edge.label = ""; }
+ _.defaults(edge, EDGE_DEFAULT_ATTRS);
+ });
+}
+
+function postProcessGraph(g) {
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v);
+
+ // Restore original dimensions
+ if (_.has(node, "_prevWidth")) {
+ node.width = node._prevWidth;
+ } else {
+ delete node.width;
+ }
+
+ if (_.has(node, "_prevHeight")) {
+ node.height = node._prevHeight;
+ } else {
+ delete node.height;
+ }
+
+ delete node._prevWidth;
+ delete node._prevHeight;
+ });
+}
+
+function createOrSelectGroup(root, name) {
+ var selection = root.select("g." + name);
+ if (selection.empty()) {
+ selection = root.append("g").attr("class", name);
+ }
+ return selection;
+}
+
+},{"./arrows":2,"./create-clusters":3,"./create-edge-labels":4,"./create-edge-paths":5,"./create-nodes":6,"./dagre":8,"./lodash":21,"./position-clusters":22,"./position-edge-labels":23,"./position-nodes":24,"./shapes":26}],26:[function(require,module,exports){
+"use strict";
+
+var intersectRect = require("./intersect/intersect-rect"),
+ intersectEllipse = require("./intersect/intersect-ellipse"),
+ intersectCircle = require("./intersect/intersect-circle"),
+ intersectPolygon = require("./intersect/intersect-polygon");
+
+module.exports = {
+ rect: rect,
+ ellipse: ellipse,
+ circle: circle,
+ diamond: diamond
+};
+
+function rect(parent, bbox, node) {
+ var shapeSvg = parent.insert("rect", ":first-child")
+ .attr("rx", node.rx)
+ .attr("ry", node.ry)
+ .attr("x", -bbox.width / 2)
+ .attr("y", -bbox.height / 2)
+ .attr("width", bbox.width)
+ .attr("height", bbox.height);
+
+ node.intersect = function(point) {
+ return intersectRect(node, point);
+ };
+
+ return shapeSvg;
+}
+
+function ellipse(parent, bbox, node) {
+ var rx = bbox.width / 2,
+ ry = bbox.height / 2,
+ shapeSvg = parent.insert("ellipse", ":first-child")
+ .attr("x", -bbox.width / 2)
+ .attr("y", -bbox.height / 2)
+ .attr("rx", rx)
+ .attr("ry", ry);
+
+ node.intersect = function(point) {
+ return intersectEllipse(node, rx, ry, point);
+ };
+
+ return shapeSvg;
+}
+
+function circle(parent, bbox, node) {
+ var r = Math.max(bbox.width, bbox.height) / 2,
+ shapeSvg = parent.insert("circle", ":first-child")
+ .attr("x", -bbox.width / 2)
+ .attr("y", -bbox.height / 2)
+ .attr("r", r);
+
+ node.intersect = function(point) {
+ return intersectCircle(node, r, point);
+ };
+
+ return shapeSvg;
+}
+
+// Circumscribe an ellipse for the bounding box with a diamond shape. I derived
+// the function to calculate the diamond shape from:
+// http://mathforum.org/kb/message.jspa?messageID=3750236
+function diamond(parent, bbox, node) {
+ var w = (bbox.width * Math.SQRT2) / 2,
+ h = (bbox.height * Math.SQRT2) / 2,
+ points = [
+ { x: 0, y: -h },
+ { x: -w, y: 0 },
+ { x: 0, y: h },
+ { x: w, y: 0 }
+ ],
+ shapeSvg = parent.insert("polygon", ":first-child")
+ .attr("points", points.map(function(p) { return p.x + "," + p.y; }).join(" "));
+
+ node.intersect = function(p) {
+ return intersectPolygon(node, points, p);
+ };
+
+ return shapeSvg;
+}
+
+},{"./intersect/intersect-circle":11,"./intersect/intersect-ellipse":12,"./intersect/intersect-polygon":15,"./intersect/intersect-rect":16}],27:[function(require,module,exports){
+var _ = require("./lodash");
+
+// Public utility functions
+module.exports = {
+ isSubgraph: isSubgraph,
+ edgeToId: edgeToId,
+ applyStyle: applyStyle,
+ applyClass: applyClass,
+ applyTransition: applyTransition
+};
+
+/*
+ * Returns true if the specified node in the graph is a subgraph node. A
+ * subgraph node is one that contains other nodes.
+ */
+function isSubgraph(g, v) {
+ return !!g.children(v).length;
+}
+
+function edgeToId(e) {
+ return escapeId(e.v) + ":" + escapeId(e.w) + ":" + escapeId(e.name);
+}
+
+var ID_DELIM = /:/g;
+function escapeId(str) {
+ return str ? String(str).replace(ID_DELIM, "\\:") : "";
+}
+
+function applyStyle(dom, styleFn) {
+ if (styleFn) {
+ dom.attr("style", styleFn);
+ }
+}
+
+function applyClass(dom, classFn, otherClasses) {
+ if (classFn) {
+ dom
+ .attr("class", classFn)
+ .attr("class", otherClasses + " " + dom.attr("class"));
+ }
+}
+
+function applyTransition(selection, g) {
+ var graph = g.graph();
+
+ if (_.isPlainObject(graph)) {
+ var transition = graph.transition;
+ if (_.isFunction(transition)) {
+ return transition(selection);
+ }
+ }
+
+ return selection;
+}
+
+},{"./lodash":21}],28:[function(require,module,exports){
+module.exports = "0.4.5";
+
+},{}],29:[function(require,module,exports){
+/*
+Copyright (c) 2012-2014 Chris Pettitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+module.exports = {
+ graphlib: require("./lib/graphlib"),
+
+ layout: require("./lib/layout"),
+ debug: require("./lib/debug"),
+ util: {
+ time: require("./lib/util").time,
+ notime: require("./lib/util").notime
+ },
+ version: require("./lib/version")
+};
+
+},{"./lib/debug":34,"./lib/graphlib":35,"./lib/layout":37,"./lib/util":57,"./lib/version":58}],30:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ greedyFAS = require("./greedy-fas");
+
+module.exports = {
+ run: run,
+ undo: undo
+};
+
+function run(g) {
+ var fas = (g.graph().acyclicer === "greedy"
+ ? greedyFAS(g, weightFn(g))
+ : dfsFAS(g));
+ _.each(fas, function(e) {
+ var label = g.edge(e);
+ g.removeEdge(e);
+ label.forwardName = e.name;
+ label.reversed = true;
+ g.setEdge(e.w, e.v, label, _.uniqueId("rev"));
+ });
+
+ function weightFn(g) {
+ return function(e) {
+ return g.edge(e).weight;
+ };
+ }
+}
+
+function dfsFAS(g) {
+ var fas = [],
+ stack = {},
+ visited = {};
+
+ function dfs(v) {
+ if (_.has(visited, v)) {
+ return;
+ }
+ visited[v] = true;
+ stack[v] = true;
+ _.each(g.outEdges(v), function(e) {
+ if (_.has(stack, e.w)) {
+ fas.push(e);
+ } else {
+ dfs(e.w);
+ }
+ });
+ delete stack[v];
+ }
+
+ _.each(g.nodes(), dfs);
+ return fas;
+}
+
+function undo(g) {
+ _.each(g.edges(), function(e) {
+ var label = g.edge(e);
+ if (label.reversed) {
+ g.removeEdge(e);
+
+ var forwardName = label.forwardName;
+ delete label.reversed;
+ delete label.forwardName;
+ g.setEdge(e.w, e.v, label, forwardName);
+ }
+ });
+}
+
+},{"./greedy-fas":36,"./lodash":38}],31:[function(require,module,exports){
+var _ = require("./lodash"),
+ util = require("./util");
+
+module.exports = addBorderSegments;
+
+function addBorderSegments(g) {
+ function dfs(v) {
+ var children = g.children(v),
+ node = g.node(v);
+ if (children.length) {
+ _.each(children, dfs);
+ }
+
+ if (_.has(node, "minRank")) {
+ node.borderLeft = [];
+ node.borderRight = [];
+ for (var rank = node.minRank, maxRank = node.maxRank + 1;
+ rank < maxRank;
+ ++rank) {
+ addBorderNode(g, "borderLeft", "_bl", v, node, rank);
+ addBorderNode(g, "borderRight", "_br", v, node, rank);
+ }
+ }
+ }
+
+ _.each(g.children(), dfs);
+}
+
+function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
+ var label = { width: 0, height: 0, rank: rank, borderType: prop },
+ prev = sgNode[prop][rank - 1],
+ curr = util.addDummyNode(g, "border", label, prefix);
+ sgNode[prop][rank] = curr;
+ g.setParent(curr, sg);
+ if (prev) {
+ g.setEdge(prev, curr, { weight: 1 });
+ }
+}
+
+},{"./lodash":38,"./util":57}],32:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash");
+
+module.exports = {
+ adjust: adjust,
+ undo: undo
+};
+
+function adjust(g) {
+ var rankDir = g.graph().rankdir.toLowerCase();
+ if (rankDir === "lr" || rankDir === "rl") {
+ swapWidthHeight(g);
+ }
+}
+
+function undo(g) {
+ var rankDir = g.graph().rankdir.toLowerCase();
+ if (rankDir === "bt" || rankDir === "rl") {
+ reverseY(g);
+ }
+
+ if (rankDir === "lr" || rankDir === "rl") {
+ swapXY(g);
+ swapWidthHeight(g);
+ }
+}
+
+function swapWidthHeight(g) {
+ _.each(g.nodes(), function(v) { swapWidthHeightOne(g.node(v)); });
+ _.each(g.edges(), function(e) { swapWidthHeightOne(g.edge(e)); });
+}
+
+function swapWidthHeightOne(attrs) {
+ var w = attrs.width;
+ attrs.width = attrs.height;
+ attrs.height = w;
+}
+
+function reverseY(g) {
+ _.each(g.nodes(), function(v) { reverseYOne(g.node(v)); });
+
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ _.each(edge.points, reverseYOne);
+ if (_.has(edge, "y")) {
+ reverseYOne(edge);
+ }
+ });
+}
+
+function reverseYOne(attrs) {
+ attrs.y = -attrs.y;
+}
+
+function swapXY(g) {
+ _.each(g.nodes(), function(v) { swapXYOne(g.node(v)); });
+
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ _.each(edge.points, swapXYOne);
+ if (_.has(edge, "x")) {
+ swapXYOne(edge);
+ }
+ });
+}
+
+function swapXYOne(attrs) {
+ var x = attrs.x;
+ attrs.x = attrs.y;
+ attrs.y = x;
+}
+
+},{"./lodash":38}],33:[function(require,module,exports){
+/*
+ * Simple doubly linked list implementation derived from Cormen, et al.,
+ * "Introduction to Algorithms".
+ */
+
+module.exports = List;
+
+function List() {
+ var sentinel = {};
+ sentinel._next = sentinel._prev = sentinel;
+ this._sentinel = sentinel;
+}
+
+List.prototype.dequeue = function() {
+ var sentinel = this._sentinel,
+ entry = sentinel._prev;
+ if (entry !== sentinel) {
+ unlink(entry);
+ return entry;
+ }
+};
+
+List.prototype.enqueue = function(entry) {
+ var sentinel = this._sentinel;
+ if (entry._prev && entry._next) {
+ unlink(entry);
+ }
+ entry._next = sentinel._next;
+ sentinel._next._prev = entry;
+ sentinel._next = entry;
+ entry._prev = sentinel;
+};
+
+List.prototype.toString = function() {
+ var strs = [],
+ sentinel = this._sentinel,
+ curr = sentinel._prev;
+ while (curr !== sentinel) {
+ strs.push(JSON.stringify(curr, filterOutLinks));
+ curr = curr._prev;
+ }
+ return "[" + strs.join(", ") + "]";
+};
+
+function unlink(entry) {
+ entry._prev._next = entry._next;
+ entry._next._prev = entry._prev;
+ delete entry._next;
+ delete entry._prev;
+}
+
+function filterOutLinks(k, v) {
+ if (k !== "_next" && k !== "_prev") {
+ return v;
+ }
+}
+
+},{}],34:[function(require,module,exports){
+var _ = require("./lodash"),
+ util = require("./util"),
+ Graph = require("./graphlib").Graph;
+
+module.exports = {
+ debugOrdering: debugOrdering
+};
+
+/* istanbul ignore next */
+function debugOrdering(g) {
+ var layerMatrix = util.buildLayerMatrix(g);
+
+ var h = new Graph({ compound: true, multigraph: true }).setGraph({});
+
+ _.each(g.nodes(), function(v) {
+ h.setNode(v, { label: v });
+ h.setParent(v, "layer" + g.node(v).rank);
+ });
+
+ _.each(g.edges(), function(e) {
+ h.setEdge(e.v, e.w, {}, e.name);
+ });
+
+ _.each(layerMatrix, function(layer, i) {
+ var layerV = "layer" + i;
+ h.setNode(layerV, { rank: "same" });
+ _.reduce(layer, function(u, v) {
+ h.setEdge(u, v, { style: "invis" });
+ return v;
+ });
+ });
+
+ return h;
+}
+
+},{"./graphlib":35,"./lodash":38,"./util":57}],35:[function(require,module,exports){
+module.exports=require(9)
+},{"/Users/cpettitt/projects/dagre-d3/lib/graphlib.js":9,"graphlib":60}],36:[function(require,module,exports){
+var _ = require("./lodash"),
+ Graph = require("./graphlib").Graph,
+ List = require("./data/list");
+
+/*
+ * A greedy heuristic for finding a feedback arc set for a graph. A feedback
+ * arc set is a set of edges that can be removed to make a graph acyclic.
+ * The algorithm comes from: P. Eades, X. Lin, and W. F. Smyth, "A fast and
+ * effective heuristic for the feedback arc set problem." This implementation
+ * adjusts that from the paper to allow for weighted edges.
+ */
+module.exports = greedyFAS;
+
+var DEFAULT_WEIGHT_FN = _.constant(1);
+
+function greedyFAS(g, weightFn) {
+ if (g.nodeCount() <= 1) {
+ return [];
+ }
+ var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+ var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+
+ // Expand multi-edges
+ return _.flatten(_.map(results, function(e) {
+ return g.outEdges(e.v, e.w);
+ }), true);
+}
+
+function doGreedyFAS(g, buckets, zeroIdx) {
+ var results = [],
+ sources = buckets[buckets.length - 1],
+ sinks = buckets[0];
+
+ var entry;
+ while (g.nodeCount()) {
+ while ((entry = sinks.dequeue())) { removeNode(g, buckets, zeroIdx, entry); }
+ while ((entry = sources.dequeue())) { removeNode(g, buckets, zeroIdx, entry); }
+ if (g.nodeCount()) {
+ for (var i = buckets.length - 2; i > 0; --i) {
+ entry = buckets[i].dequeue();
+ if (entry) {
+ results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
+ break;
+ }
+ }
+ }
+ }
+
+ return results;
+}
+
+function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
+ var results = collectPredecessors ? [] : undefined;
+
+ _.each(g.inEdges(entry.v), function(edge) {
+ var weight = g.edge(edge),
+ uEntry = g.node(edge.v);
+
+ if (collectPredecessors) {
+ results.push({ v: edge.v, w: edge.w });
+ }
+
+ uEntry.out -= weight;
+ assignBucket(buckets, zeroIdx, uEntry);
+ });
+
+ _.each(g.outEdges(entry.v), function(edge) {
+ var weight = g.edge(edge),
+ w = edge.w,
+ wEntry = g.node(w);
+ wEntry["in"] -= weight;
+ assignBucket(buckets, zeroIdx, wEntry);
+ });
+
+ g.removeNode(entry.v);
+
+ return results;
+}
+
+function buildState(g, weightFn) {
+ var fasGraph = new Graph(),
+ maxIn = 0,
+ maxOut = 0;
+
+ _.each(g.nodes(), function(v) {
+ fasGraph.setNode(v, { v: v, "in": 0, out: 0 });
+ });
+
+ // Aggregate weights on nodes, but also sum the weights across multi-edges
+ // into a single edge for the fasGraph.
+ _.each(g.edges(), function(e) {
+ var prevWeight = fasGraph.edge(e.v, e.w) || 0,
+ weight = weightFn(e),
+ edgeWeight = prevWeight + weight;
+ fasGraph.setEdge(e.v, e.w, edgeWeight);
+ maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
+ maxIn = Math.max(maxIn, fasGraph.node(e.w)["in"] += weight);
+ });
+
+ var buckets = _.range(maxOut + maxIn + 3).map(function() { return new List(); });
+ var zeroIdx = maxIn + 1;
+
+ _.each(fasGraph.nodes(), function(v) {
+ assignBucket(buckets, zeroIdx, fasGraph.node(v));
+ });
+
+ return { graph: fasGraph, buckets: buckets, zeroIdx: zeroIdx };
+}
+
+function assignBucket(buckets, zeroIdx, entry) {
+ if (!entry.out) {
+ buckets[0].enqueue(entry);
+ } else if (!entry["in"]) {
+ buckets[buckets.length - 1].enqueue(entry);
+ } else {
+ buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
+ }
+}
+
+},{"./data/list":33,"./graphlib":35,"./lodash":38}],37:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ acyclic = require("./acyclic"),
+ normalize = require("./normalize"),
+ rank = require("./rank"),
+ normalizeRanks = require("./util").normalizeRanks,
+ parentDummyChains = require("./parent-dummy-chains"),
+ removeEmptyRanks = require("./util").removeEmptyRanks,
+ nestingGraph = require("./nesting-graph"),
+ addBorderSegments = require("./add-border-segments"),
+ coordinateSystem = require("./coordinate-system"),
+ order = require("./order"),
+ position = require("./position"),
+ util = require("./util"),
+ Graph = require("./graphlib").Graph;
+
+module.exports = layout;
+
+function layout(g, opts) {
+ var time = opts && opts.debugTiming ? util.time : util.notime;
+ time("layout", function() {
+ var layoutGraph = time(" buildLayoutGraph",
+ function() { return buildLayoutGraph(g); });
+ time(" runLayout", function() { runLayout(layoutGraph, time); });
+ time(" updateInputGraph", function() { updateInputGraph(g, layoutGraph); });
+ });
+}
+
+function runLayout(g, time) {
+ time(" makeSpaceForEdgeLabels", function() { makeSpaceForEdgeLabels(g); });
+ time(" removeSelfEdges", function() { removeSelfEdges(g); });
+ time(" acyclic", function() { acyclic.run(g); });
+ time(" nestingGraph.run", function() { nestingGraph.run(g); });
+ time(" rank", function() { rank(util.asNonCompoundGraph(g)); });
+ time(" injectEdgeLabelProxies", function() { injectEdgeLabelProxies(g); });
+ time(" removeEmptyRanks", function() { removeEmptyRanks(g); });
+ time(" nestingGraph.cleanup", function() { nestingGraph.cleanup(g); });
+ time(" normalizeRanks", function() { normalizeRanks(g); });
+ time(" assignRankMinMax", function() { assignRankMinMax(g); });
+ time(" removeEdgeLabelProxies", function() { removeEdgeLabelProxies(g); });
+ time(" normalize.run", function() { normalize.run(g); });
+ time(" parentDummyChains", function() { parentDummyChains(g); });
+ time(" addBorderSegments", function() { addBorderSegments(g); });
+ time(" order", function() { order(g); });
+ time(" insertSelfEdges", function() { insertSelfEdges(g); });
+ time(" adjustCoordinateSystem", function() { coordinateSystem.adjust(g); });
+ time(" position", function() { position(g); });
+ time(" positionSelfEdges", function() { positionSelfEdges(g); });
+ time(" removeBorderNodes", function() { removeBorderNodes(g); });
+ time(" normalize.undo", function() { normalize.undo(g); });
+ time(" fixupEdgeLabelCoords", function() { fixupEdgeLabelCoords(g); });
+ time(" undoCoordinateSystem", function() { coordinateSystem.undo(g); });
+ time(" translateGraph", function() { translateGraph(g); });
+ time(" assignNodeIntersects", function() { assignNodeIntersects(g); });
+ time(" reversePoints", function() { reversePointsForReversedEdges(g); });
+ time(" acyclic.undo", function() { acyclic.undo(g); });
+}
+
+/*
+ * Copies final layout information from the layout graph back to the input
+ * graph. This process only copies whitelisted attributes from the layout graph
+ * to the input graph, so it serves as a good place to determine what
+ * attributes can influence layout.
+ */
+function updateInputGraph(inputGraph, layoutGraph) {
+ _.each(inputGraph.nodes(), function(v) {
+ var inputLabel = inputGraph.node(v),
+ layoutLabel = layoutGraph.node(v);
+
+ if (inputLabel) {
+ inputLabel.x = layoutLabel.x;
+ inputLabel.y = layoutLabel.y;
+
+ if (layoutGraph.children(v).length) {
+ inputLabel.width = layoutLabel.width;
+ inputLabel.height = layoutLabel.height;
+ }
+ }
+ });
+
+ _.each(inputGraph.edges(), function(e) {
+ var inputLabel = inputGraph.edge(e),
+ layoutLabel = layoutGraph.edge(e);
+
+ inputLabel.points = layoutLabel.points;
+ if (_.has(layoutLabel, "x")) {
+ inputLabel.x = layoutLabel.x;
+ inputLabel.y = layoutLabel.y;
+ }
+ });
+
+ inputGraph.graph().width = layoutGraph.graph().width;
+ inputGraph.graph().height = layoutGraph.graph().height;
+}
+
+var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"],
+ graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" },
+ graphAttrs = ["acyclicer", "ranker", "rankdir", "align"],
+ nodeNumAttrs = ["width", "height"],
+ nodeDefaults = { width: 0, height: 0 },
+ edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"],
+ edgeDefaults = {
+ minlen: 1, weight: 1, width: 0, height: 0,
+ labeloffset: 10, labelpos: "r"
+ },
+ edgeAttrs = ["labelpos"];
+
+/*
+ * Constructs a new graph from the input graph, which can be used for layout.
+ * This process copies only whitelisted attributes from the input graph to the
+ * layout graph. Thus this function serves as a good place to determine what
+ * attributes can influence layout.
+ */
+function buildLayoutGraph(inputGraph) {
+ var g = new Graph({ multigraph: true, compound: true }),
+ graph = canonicalize(inputGraph.graph());
+
+ g.setGraph(_.merge({},
+ graphDefaults,
+ selectNumberAttrs(graph, graphNumAttrs),
+ _.pick(graph, graphAttrs)));
+
+ _.each(inputGraph.nodes(), function(v) {
+ var node = canonicalize(inputGraph.node(v));
+ g.setNode(v, _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+ g.setParent(v, inputGraph.parent(v));
+ });
+
+ _.each(inputGraph.edges(), function(e) {
+ var edge = canonicalize(inputGraph.edge(e));
+ g.setEdge(e, _.merge({},
+ edgeDefaults,
+ selectNumberAttrs(edge, edgeNumAttrs),
+ _.pick(edge, edgeAttrs)));
+ });
+
+ return g;
+}
+
+/*
+ * This idea comes from the Gansner paper: to account for edge labels in our
+ * layout we split each rank in half by doubling minlen and halving ranksep.
+ * Then we can place labels at these mid-points between nodes.
+ *
+ * We also add some minimal padding to the width to push the label for the edge
+ * away from the edge itself a bit.
+ */
+function makeSpaceForEdgeLabels(g) {
+ var graph = g.graph();
+ graph.ranksep /= 2;
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ edge.minlen *= 2;
+ if (edge.labelpos.toLowerCase() !== "c") {
+ if (graph.rankdir === "TB" || graph.rankdir === "BT") {
+ edge.width += edge.labeloffset;
+ } else {
+ edge.height += edge.labeloffset;
+ }
+ }
+ });
+}
+
+/*
+ * Creates temporary dummy nodes that capture the rank in which each edge's
+ * label is going to, if it has one of non-zero width and height. We do this
+ * so that we can safely remove empty ranks while preserving balance for the
+ * label's position.
+ */
+function injectEdgeLabelProxies(g) {
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ if (edge.width && edge.height) {
+ var v = g.node(e.v),
+ w = g.node(e.w),
+ label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
+ util.addDummyNode(g, "edge-proxy", label, "_ep");
+ }
+ });
+}
+
+function assignRankMinMax(g) {
+ var maxRank = 0;
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v);
+ if (node.borderTop) {
+ node.minRank = g.node(node.borderTop).rank;
+ node.maxRank = g.node(node.borderBottom).rank;
+ maxRank = _.max(maxRank, node.maxRank);
+ }
+ });
+ g.graph().maxRank = maxRank;
+}
+
+function removeEdgeLabelProxies(g) {
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v);
+ if (node.dummy === "edge-proxy") {
+ g.edge(node.e).labelRank = node.rank;
+ g.removeNode(v);
+ }
+ });
+}
+
+function translateGraph(g) {
+ var minX = Number.POSITIVE_INFINITY,
+ maxX = 0,
+ minY = Number.POSITIVE_INFINITY,
+ maxY = 0,
+ graphLabel = g.graph(),
+ marginX = graphLabel.marginx || 0,
+ marginY = graphLabel.marginy || 0;
+
+ function getExtremes(attrs) {
+ var x = attrs.x,
+ y = attrs.y,
+ w = attrs.width,
+ h = attrs.height;
+ minX = Math.min(minX, x - w / 2);
+ maxX = Math.max(maxX, x + w / 2);
+ minY = Math.min(minY, y - h / 2);
+ maxY = Math.max(maxY, y + h / 2);
+ }
+
+ _.each(g.nodes(), function(v) { getExtremes(g.node(v)); });
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ if (_.has(edge, "x")) {
+ getExtremes(edge);
+ }
+ });
+
+ minX -= marginX;
+ minY -= marginY;
+
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v);
+ node.x -= minX;
+ node.y -= minY;
+ });
+
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ _.each(edge.points, function(p) {
+ p.x -= minX;
+ p.y -= minY;
+ });
+ if (_.has(edge, "x")) { edge.x -= minX; }
+ if (_.has(edge, "y")) { edge.y -= minY; }
+ });
+
+ graphLabel.width = maxX - minX + marginX;
+ graphLabel.height = maxY - minY + marginY;
+}
+
+function assignNodeIntersects(g) {
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e),
+ nodeV = g.node(e.v),
+ nodeW = g.node(e.w),
+ p1, p2;
+ if (!edge.points) {
+ edge.points = [];
+ p1 = nodeW;
+ p2 = nodeV;
+ } else {
+ p1 = edge.points[0];
+ p2 = edge.points[edge.points.length - 1];
+ }
+ edge.points.unshift(util.intersectRect(nodeV, p1));
+ edge.points.push(util.intersectRect(nodeW, p2));
+ });
+}
+
+function fixupEdgeLabelCoords(g) {
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ if (_.has(edge, "x")) {
+ if (edge.labelpos === "l" || edge.labelpos === "r") {
+ edge.width -= edge.labeloffset;
+ }
+ switch (edge.labelpos) {
+ case "l": edge.x -= edge.width / 2 + edge.labeloffset; break;
+ case "r": edge.x += edge.width / 2 + edge.labeloffset; break;
+ }
+ }
+ });
+}
+
+function reversePointsForReversedEdges(g) {
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ if (edge.reversed) {
+ edge.points.reverse();
+ }
+ });
+}
+
+function removeBorderNodes(g) {
+ _.each(g.nodes(), function(v) {
+ if (g.children(v).length) {
+ var node = g.node(v),
+ t = g.node(node.borderTop),
+ b = g.node(node.borderBottom),
+ l = g.node(_.last(node.borderLeft)),
+ r = g.node(_.last(node.borderRight));
+
+ node.width = Math.abs(r.x - l.x);
+ node.height = Math.abs(b.y - t.y);
+ node.x = l.x + node.width / 2;
+ node.y = t.y + node.height / 2;
+ }
+ });
+
+ _.each(g.nodes(), function(v) {
+ if (g.node(v).dummy === "border") {
+ g.removeNode(v);
+ }
+ });
+}
+
+function removeSelfEdges(g) {
+ _.each(g.edges(), function(e) {
+ if (e.v === e.w) {
+ var node = g.node(e.v);
+ if (!node.selfEdges) {
+ node.selfEdges = [];
+ }
+ node.selfEdges.push({ e: e, label: g.edge(e) });
+ g.removeEdge(e);
+ }
+ });
+}
+
+function insertSelfEdges(g) {
+ var layers = util.buildLayerMatrix(g);
+ _.each(layers, function(layer) {
+ var orderShift = 0;
+ _.each(layer, function(v, i) {
+ var node = g.node(v);
+ node.order = i + orderShift;
+ _.each(node.selfEdges, function(selfEdge) {
+ util.addDummyNode(g, "selfedge", {
+ width: selfEdge.label.width,
+ height: selfEdge.label.height,
+ rank: node.rank,
+ order: i + (++orderShift),
+ e: selfEdge.e,
+ label: selfEdge.label
+ }, "_se");
+ });
+ delete node.selfEdges;
+ });
+ });
+}
+
+function positionSelfEdges(g) {
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v);
+ if (node.dummy === "selfedge") {
+ var selfNode = g.node(node.e.v),
+ x = selfNode.x + selfNode.width / 2,
+ y = selfNode.y,
+ dx = node.x - x,
+ dy = selfNode.height / 2;
+ g.setEdge(node.e, node.label);
+ g.removeNode(v);
+ node.label.points = [
+ { x: x + 2 * dx / 3, y: y - dy },
+ { x: x + 5 * dx / 6, y: y - dy },
+ { x: x + dx , y: y },
+ { x: x + 5 * dx / 6, y: y + dy },
+ { x: x + 2 * dx / 3, y: y + dy },
+ ];
+ node.label.x = node.x;
+ node.label.y = node.y;
+ }
+ });
+}
+
+function selectNumberAttrs(obj, attrs) {
+ return _.mapValues(_.pick(obj, attrs), Number);
+}
+
+function canonicalize(attrs) {
+ var newAttrs = {};
+ _.each(attrs, function(v, k) {
+ newAttrs[k.toLowerCase()] = v;
+ });
+ return newAttrs;
+}
+
+},{"./acyclic":30,"./add-border-segments":31,"./coordinate-system":32,"./graphlib":35,"./lodash":38,"./nesting-graph":39,"./normalize":40,"./order":45,"./parent-dummy-chains":50,"./position":52,"./rank":54,"./util":57}],38:[function(require,module,exports){
+arguments[4][21][0].apply(exports,arguments)
+},{"/Users/cpettitt/projects/dagre-d3/lib/lodash.js":21,"lodash":59}],39:[function(require,module,exports){
+var _ = require("./lodash"),
+ util = require("./util");
+
+module.exports = {
+ run: run,
+ cleanup: cleanup
+};
+
+/*
+ * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
+ * adds appropriate edges to ensure that all cluster nodes are placed between
+ * these boundries, and ensures that the graph is connected.
+ *
+ * In addition we ensure, through the use of the minlen property, that nodes
+ * and subgraph border nodes to not end up on the same rank.
+ *
+ * Preconditions:
+ *
+ * 1. Input graph is a DAG
+ * 2. Nodes in the input graph has a minlen attribute
+ *
+ * Postconditions:
+ *
+ * 1. Input graph is connected.
+ * 2. Dummy nodes are added for the tops and bottoms of subgraphs.
+ * 3. The minlen attribute for nodes is adjusted to ensure nodes do not
+ * get placed on the same rank as subgraph border nodes.
+ *
+ * The nesting graph idea comes from Sander, "Layout of Compound Directed
+ * Graphs."
+ */
+function run(g) {
+ var root = util.addDummyNode(g, "root", {}, "_root"),
+ depths = treeDepths(g),
+ height = _.max(depths) - 1,
+ nodeSep = 2 * height + 1;
+
+ g.graph().nestingRoot = root;
+
+ // Multiply minlen by nodeSep to align nodes on non-border ranks.
+ _.each(g.edges(), function(e) { g.edge(e).minlen *= nodeSep; });
+
+ // Calculate a weight that is sufficient to keep subgraphs vertically compact
+ var weight = sumWeights(g) + 1;
+
+ // Create border nodes and link them up
+ _.each(g.children(), function(child) {
+ dfs(g, root, nodeSep, weight, height, depths, child);
+ });
+
+ // Save the multiplier for node layers for later removal of empty border
+ // layers.
+ g.graph().nodeRankFactor = nodeSep;
+}
+
+function dfs(g, root, nodeSep, weight, height, depths, v) {
+ var children = g.children(v);
+ if (!children.length) {
+ if (v !== root) {
+ g.setEdge(root, v, { weight: 0, minlen: nodeSep });
+ }
+ return;
+ }
+
+ var top = util.addBorderNode(g, "_bt"),
+ bottom = util.addBorderNode(g, "_bb"),
+ label = g.node(v);
+
+ g.setParent(top, v);
+ label.borderTop = top;
+ g.setParent(bottom, v);
+ label.borderBottom = bottom;
+
+ _.each(children, function(child) {
+ dfs(g, root, nodeSep, weight, height, depths, child);
+
+ var childNode = g.node(child),
+ childTop = childNode.borderTop ? childNode.borderTop : child,
+ childBottom = childNode.borderBottom ? childNode.borderBottom : child,
+ thisWeight = childNode.borderTop ? weight : 2 * weight,
+ minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+
+ g.setEdge(top, childTop, {
+ weight: thisWeight,
+ minlen: minlen,
+ nestingEdge: true
+ });
+
+ g.setEdge(childBottom, bottom, {
+ weight: thisWeight,
+ minlen: minlen,
+ nestingEdge: true
+ });
+ });
+
+ if (!g.parent(v)) {
+ g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+ }
+}
+
+function treeDepths(g) {
+ var depths = {};
+ function dfs(v, depth) {
+ var children = g.children(v);
+ if (children && children.length) {
+ _.each(children, function(child) {
+ dfs(child, depth + 1);
+ });
+ }
+ depths[v] = depth;
+ }
+ _.each(g.children(), function(v) { dfs(v, 1); });
+ return depths;
+}
+
+function sumWeights(g) {
+ return _.reduce(g.edges(), function(acc, e) {
+ return acc + g.edge(e).weight;
+ }, 0);
+}
+
+function cleanup(g) {
+ var graphLabel = g.graph();
+ g.removeNode(graphLabel.nestingRoot);
+ delete graphLabel.nestingRoot;
+ _.each(g.edges(), function(e) {
+ var edge = g.edge(e);
+ if (edge.nestingEdge) {
+ g.removeEdge(e);
+ }
+ });
+}
+
+},{"./lodash":38,"./util":57}],40:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ util = require("./util");
+
+module.exports = {
+ run: run,
+ undo: undo
+};
+
+/*
+ * Breaks any long edges in the graph into short segments that span 1 layer
+ * each. This operation is undoable with the denormalize function.
+ *
+ * Pre-conditions:
+ *
+ * 1. The input graph is a DAG.
+ * 2. Each node in the graph has a "rank" property.
+ *
+ * Post-condition:
+ *
+ * 1. All edges in the graph have a length of 1.
+ * 2. Dummy nodes are added where edges have been split into segments.
+ * 3. The graph is augmented with a "dummyChains" attribute which contains
+ * the first dummy in each chain of dummy nodes produced.
+ */
+function run(g) {
+ g.graph().dummyChains = [];
+ _.each(g.edges(), function(edge) { normalizeEdge(g, edge); });
+}
+
+function normalizeEdge(g, e) {
+ var v = e.v,
+ vRank = g.node(v).rank,
+ w = e.w,
+ wRank = g.node(w).rank,
+ name = e.name,
+ edgeLabel = g.edge(e),
+ labelRank = edgeLabel.labelRank;
+
+ if (wRank === vRank + 1) return;
+
+ g.removeEdge(e);
+
+ var dummy, attrs, i;
+ for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+ edgeLabel.points = [];
+ attrs = {
+ width: 0, height: 0,
+ edgeLabel: edgeLabel, edgeObj: e,
+ rank: vRank
+ };
+ dummy = util.addDummyNode(g, "edge", attrs, "_d");
+ if (vRank === labelRank) {
+ attrs.width = edgeLabel.width;
+ attrs.height = edgeLabel.height;
+ attrs.dummy = "edge-label";
+ attrs.labelpos = edgeLabel.labelpos;
+ }
+ g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
+ if (i === 0) {
+ g.graph().dummyChains.push(dummy);
+ }
+ v = dummy;
+ }
+
+ g.setEdge(v, w, { weight: edgeLabel.weight }, name);
+}
+
+function undo(g) {
+ _.each(g.graph().dummyChains, function(v) {
+ var node = g.node(v),
+ origLabel = node.edgeLabel,
+ w;
+ g.setEdge(node.edgeObj, origLabel);
+ while (node.dummy) {
+ w = g.successors(v)[0];
+ g.removeNode(v);
+ origLabel.points.push({ x: node.x, y: node.y });
+ if (node.dummy === "edge-label") {
+ origLabel.x = node.x;
+ origLabel.y = node.y;
+ origLabel.width = node.width;
+ origLabel.height = node.height;
+ }
+ v = w;
+ node = g.node(v);
+ }
+ });
+}
+
+},{"./lodash":38,"./util":57}],41:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = addSubgraphConstraints;
+
+function addSubgraphConstraints(g, cg, vs) {
+ var prev = {},
+ rootPrev;
+
+ _.each(vs, function(v) {
+ var child = g.parent(v),
+ parent,
+ prevChild;
+ while (child) {
+ parent = g.parent(child);
+ if (parent) {
+ prevChild = prev[parent];
+ prev[parent] = child;
+ } else {
+ prevChild = rootPrev;
+ rootPrev = child;
+ }
+ if (prevChild && prevChild !== child) {
+ cg.setEdge(prevChild, child);
+ return;
+ }
+ child = parent;
+ }
+ });
+
+ /*
+ function dfs(v) {
+ var children = v ? g.children(v) : g.children();
+ if (children.length) {
+ var min = Number.POSITIVE_INFINITY,
+ subgraphs = [];
+ _.each(children, function(child) {
+ var childMin = dfs(child);
+ if (g.children(child).length) {
+ subgraphs.push({ v: child, order: childMin });
+ }
+ min = Math.min(min, childMin);
+ });
+ _.reduce(_.sortBy(subgraphs, "order"), function(prev, curr) {
+ cg.setEdge(prev.v, curr.v);
+ return curr;
+ });
+ return min;
+ }
+ return g.node(v).order;
+ }
+ dfs(undefined);
+ */
+}
+
+},{"../lodash":38}],42:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = barycenter;
+
+function barycenter(g, movable) {
+ return _.map(movable, function(v) {
+ var inV = g.inEdges(v);
+ if (!inV.length) {
+ return { v: v };
+ } else {
+ var result = _.reduce(inV, function(acc, e) {
+ var edge = g.edge(e),
+ nodeU = g.node(e.v);
+ return {
+ sum: acc.sum + (edge.weight * nodeU.order),
+ weight: acc.weight + edge.weight
+ };
+ }, { sum: 0, weight: 0 });
+
+ return {
+ v: v,
+ barycenter: result.sum / result.weight,
+ weight: result.weight
+ };
+ }
+ });
+}
+
+
+},{"../lodash":38}],43:[function(require,module,exports){
+var _ = require("../lodash"),
+ Graph = require("../graphlib").Graph;
+
+module.exports = buildLayerGraph;
+
+/*
+ * Constructs a graph that can be used to sort a layer of nodes. The graph will
+ * contain all base and subgraph nodes from the request layer in their original
+ * hierarchy and any edges that are incident on these nodes and are of the type
+ * requested by the "relationship" parameter.
+ *
+ * Nodes from the requested rank that do not have parents are assigned a root
+ * node in the output graph, which is set in the root graph attribute. This
+ * makes it easy to walk the hierarchy of movable nodes during ordering.
+ *
+ * Pre-conditions:
+ *
+ * 1. Input graph is a DAG
+ * 2. Base nodes in the input graph have a rank attribute
+ * 3. Subgraph nodes in the input graph has minRank and maxRank attributes
+ * 4. Edges have an assigned weight
+ *
+ * Post-conditions:
+ *
+ * 1. Output graph has all nodes in the movable rank with preserved
+ * hierarchy.
+ * 2. Root nodes in the movable layer are made children of the node
+ * indicated by the root attribute of the graph.
+ * 3. Non-movable nodes incident on movable nodes, selected by the
+ * relationship parameter, are included in the graph (without hierarchy).
+ * 4. Edges incident on movable nodes, selected by the relationship
+ * parameter, are added to the output graph.
+ * 5. The weights for copied edges are aggregated as need, since the output
+ * graph is not a multi-graph.
+ */
+function buildLayerGraph(g, rank, relationship) {
+ var root = createRootNode(g),
+ result = new Graph({ compound: true }).setGraph({ root: root })
+ .setDefaultNodeLabel(function(v) { return g.node(v); });
+
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v),
+ parent = g.parent(v);
+
+ if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
+ result.setNode(v);
+ result.setParent(v, parent || root);
+
+ // This assumes we have only short edges!
+ _.each(g[relationship](v), function(e) {
+ var u = e.v === v ? e.w : e.v,
+ edge = result.edge(u, v),
+ weight = !_.isUndefined(edge) ? edge.weight : 0;
+ result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+ });
+
+ if (_.has(node, "minRank")) {
+ result.setNode(v, {
+ borderLeft: node.borderLeft[rank],
+ borderRight: node.borderRight[rank]
+ });
+ }
+ }
+ });
+
+ return result;
+}
+
+function createRootNode(g) {
+ var v;
+ while (g.hasNode((v = _.uniqueId("_root"))));
+ return v;
+}
+
+},{"../graphlib":35,"../lodash":38}],44:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash");
+
+module.exports = crossCount;
+
+/*
+ * A function that takes a layering (an array of layers, each with an array of
+ * ordererd nodes) and a graph and returns a weighted crossing count.
+ *
+ * Pre-conditions:
+ *
+ * 1. Input graph must be simple (not a multigraph), directed, and include
+ * only simple edges.
+ * 2. Edges in the input graph must have assigned weights.
+ *
+ * Post-conditions:
+ *
+ * 1. The graph and layering matrix are left unchanged.
+ *
+ * This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
+ */
+function crossCount(g, layering) {
+ var cc = 0;
+ for (var i = 1; i < layering.length; ++i) {
+ cc += twoLayerCrossCount(g, layering[i-1], layering[i]);
+ }
+ return cc;
+}
+
+function twoLayerCrossCount(g, northLayer, southLayer) {
+ // Sort all of the edges between the north and south layers by their position
+ // in the north layer and then the south. Map these edges to the position of
+ // their head in the south layer.
+ var southPos = _.zipObject(southLayer,
+ _.map(southLayer, function (v, i) { return i; }));
+ var southEntries = _.flatten(_.map(northLayer, function(v) {
+ return _.chain(g.outEdges(v))
+ .map(function(e) {
+ return { pos: southPos[e.w], weight: g.edge(e).weight };
+ })
+ .sortBy("pos")
+ .value();
+ }), true);
+
+ // Build the accumulator tree
+ var firstIndex = 1;
+ while (firstIndex < southLayer.length) firstIndex <<= 1;
+ var treeSize = 2 * firstIndex - 1;
+ firstIndex -= 1;
+ var tree = _.map(new Array(treeSize), function() { return 0; });
+
+ // Calculate the weighted crossings
+ var cc = 0;
+ _.each(southEntries.forEach(function(entry) {
+ var index = entry.pos + firstIndex;
+ tree[index] += entry.weight;
+ var weightSum = 0;
+ while (index > 0) {
+ if (index % 2) {
+ weightSum += tree[index + 1];
+ }
+ index = (index - 1) >> 1;
+ tree[index] += entry.weight;
+ }
+ cc += entry.weight * weightSum;
+ }));
+
+ return cc;
+}
+
+},{"../lodash":38}],45:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash"),
+ initOrder = require("./init-order"),
+ crossCount = require("./cross-count"),
+ sortSubgraph = require("./sort-subgraph"),
+ buildLayerGraph = require("./build-layer-graph"),
+ addSubgraphConstraints = require("./add-subgraph-constraints"),
+ Graph = require("../graphlib").Graph,
+ util = require("../util");
+
+module.exports = order;
+
+/*
+ * Applies heuristics to minimize edge crossings in the graph and sets the best
+ * order solution as an order attribute on each node.
+ *
+ * Pre-conditions:
+ *
+ * 1. Graph must be DAG
+ * 2. Graph nodes must be objects with a "rank" attribute
+ * 3. Graph edges must have the "weight" attribute
+ *
+ * Post-conditions:
+ *
+ * 1. Graph nodes will have an "order" attribute based on the results of the
+ * algorithm.
+ */
+function order(g) {
+ var maxRank = util.maxRank(g),
+ downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank + 1), "inEdges"),
+ upLayerGraphs = buildLayerGraphs(g, _.range(maxRank - 1, -1, -1), "outEdges");
+
+ var layering = initOrder(g);
+ assignOrder(g, layering);
+
+ var bestCC = Number.POSITIVE_INFINITY,
+ best;
+
+ for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+ sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+
+ layering = util.buildLayerMatrix(g);
+ var cc = crossCount(g, layering);
+ if (cc < bestCC) {
+ lastBest = 0;
+ best = _.cloneDeep(layering);
+ bestCC = cc;
+ }
+ }
+
+ assignOrder(g, best);
+}
+
+function buildLayerGraphs(g, ranks, relationship) {
+ return _.map(ranks, function(rank) {
+ return buildLayerGraph(g, rank, relationship);
+ });
+}
+
+function sweepLayerGraphs(layerGraphs, biasRight) {
+ var cg = new Graph();
+ _.each(layerGraphs, function(lg) {
+ var root = lg.graph().root;
+ var sorted = sortSubgraph(lg, root, cg, biasRight);
+ _.each(sorted.vs, function(v, i) {
+ lg.node(v).order = i;
+ });
+ addSubgraphConstraints(lg, cg, sorted.vs);
+ });
+}
+
+function assignOrder(g, layering) {
+ _.each(layering, function(layer) {
+ _.each(layer, function(v, i) {
+ g.node(v).order = i;
+ });
+ });
+}
+
+},{"../graphlib":35,"../lodash":38,"../util":57,"./add-subgraph-constraints":41,"./build-layer-graph":43,"./cross-count":44,"./init-order":46,"./sort-subgraph":48}],46:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash");
+
+module.exports = initOrder;
+
+/*
+ * Assigns an initial order value for each node by performing a DFS search
+ * starting from nodes in the first rank. Nodes are assigned an order in their
+ * rank as they are first visited.
+ *
+ * This approach comes from Gansner, et al., "A Technique for Drawing Directed
+ * Graphs."
+ *
+ * Returns a layering matrix with an array per layer and each layer sorted by
+ * the order of its nodes.
+ */
+function initOrder(g) {
+ var visited = {},
+ simpleNodes = _.filter(g.nodes(), function(v) {
+ return !g.children(v).length;
+ }),
+ maxRank = _.max(_.map(simpleNodes, function(v) { return g.node(v).rank; })),
+ layers = _.map(_.range(maxRank + 1), function() { return []; });
+
+ function dfs(v) {
+ if (_.has(visited, v)) return;
+ visited[v] = true;
+ var node = g.node(v);
+ layers[node.rank].push(v);
+ _.each(g.successors(v), dfs);
+ }
+
+ var orderedVs = _.sortBy(simpleNodes, function(v) { return g.node(v).rank; });
+ _.each(orderedVs, dfs);
+
+ return layers;
+}
+
+},{"../lodash":38}],47:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash");
+
+module.exports = resolveConflicts;
+
+/*
+ * Given a list of entries of the form {v, barycenter, weight} and a
+ * constraint graph this function will resolve any conflicts between the
+ * constraint graph and the barycenters for the entries. If the barycenters for
+ * an entry would violate a constraint in the constraint graph then we coalesce
+ * the nodes in the conflict into a new node that respects the contraint and
+ * aggregates barycenter and weight information.
+ *
+ * This implementation is based on the description in Forster, "A Fast and
+ * Simple Hueristic for Constrained Two-Level Crossing Reduction," thought it
+ * differs in some specific details.
+ *
+ * Pre-conditions:
+ *
+ * 1. Each entry has the form {v, barycenter, weight}, or if the node has
+ * no barycenter, then {v}.
+ *
+ * Returns:
+ *
+ * A new list of entries of the form {vs, i, barycenter, weight}. The list
+ * `vs` may either be a singleton or it may be an aggregation of nodes
+ * ordered such that they do not violate constraints from the constraint
+ * graph. The property `i` is the lowest original index of any of the
+ * elements in `vs`.
+ */
+function resolveConflicts(entries, cg) {
+ var mappedEntries = {};
+ _.each(entries, function(entry, i) {
+ var tmp = mappedEntries[entry.v] = {
+ indegree: 0,
+ "in": [],
+ out: [],
+ vs: [entry.v],
+ i: i
+ };
+ if (!_.isUndefined(entry.barycenter)) {
+ tmp.barycenter = entry.barycenter;
+ tmp.weight = entry.weight;
+ }
+ });
+
+ _.each(cg.edges(), function(e) {
+ var entryV = mappedEntries[e.v],
+ entryW = mappedEntries[e.w];
+ if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
+ entryW.indegree++;
+ entryV.out.push(mappedEntries[e.w]);
+ }
+ });
+
+ var sourceSet = _.filter(mappedEntries, function(entry) {
+ return !entry.indegree;
+ });
+
+ return doResolveConflicts(sourceSet);
+}
+
+function doResolveConflicts(sourceSet) {
+ var entries = [];
+
+ function handleIn(vEntry) {
+ return function(uEntry) {
+ if (uEntry.merged) {
+ return;
+ }
+ if (_.isUndefined(uEntry.barycenter) ||
+ _.isUndefined(vEntry.barycenter) ||
+ uEntry.barycenter >= vEntry.barycenter) {
+ mergeEntries(vEntry, uEntry);
+ }
+ };
+ }
+
+ function handleOut(vEntry) {
+ return function(wEntry) {
+ wEntry["in"].push(vEntry);
+ if (--wEntry.indegree === 0) {
+ sourceSet.push(wEntry);
+ }
+ };
+ }
+
+ while (sourceSet.length) {
+ var entry = sourceSet.pop();
+ entries.push(entry);
+ _.each(entry["in"].reverse(), handleIn(entry));
+ _.each(entry.out, handleOut(entry));
+ }
+
+ return _.chain(entries)
+ .filter(function(entry) { return !entry.merged; })
+ .map(function(entry) {
+ return _.pick(entry, ["vs", "i", "barycenter", "weight"]);
+ })
+ .value();
+}
+
+function mergeEntries(target, source) {
+ var sum = 0,
+ weight = 0;
+
+ if (target.weight) {
+ sum += target.barycenter * target.weight;
+ weight += target.weight;
+ }
+
+ if (source.weight) {
+ sum += source.barycenter * source.weight;
+ weight += source.weight;
+ }
+
+ target.vs = source.vs.concat(target.vs);
+ target.barycenter = sum / weight;
+ target.weight = weight;
+ target.i = Math.min(source.i, target.i);
+ source.merged = true;
+}
+
+},{"../lodash":38}],48:[function(require,module,exports){
+var _ = require("../lodash"),
+ barycenter = require("./barycenter"),
+ resolveConflicts = require("./resolve-conflicts"),
+ sort = require("./sort");
+
+module.exports = sortSubgraph;
+
+function sortSubgraph(g, v, cg, biasRight) {
+ var movable = g.children(v),
+ node = g.node(v),
+ bl = node ? node.borderLeft : undefined,
+ br = node ? node.borderRight: undefined,
+ subgraphs = {};
+
+ if (bl) {
+ movable = _.filter(movable, function(w) {
+ return w !== bl && w !== br;
+ });
+ }
+
+ var barycenters = barycenter(g, movable);
+ _.each(barycenters, function(entry) {
+ if (g.children(entry.v).length) {
+ var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+ subgraphs[entry.v] = subgraphResult;
+ if (_.has(subgraphResult, "barycenter")) {
+ mergeBarycenters(entry, subgraphResult);
+ }
+ }
+ });
+
+ var entries = resolveConflicts(barycenters, cg);
+ expandSubgraphs(entries, subgraphs);
+
+ var result = sort(entries, biasRight);
+
+ if (bl) {
+ result.vs = _.flatten([bl, result.vs, br], true);
+ if (g.predecessors(bl).length) {
+ var blPred = g.node(g.predecessors(bl)[0]),
+ brPred = g.node(g.predecessors(br)[0]);
+ if (!_.has(result, "barycenter")) {
+ result.barycenter = 0;
+ result.weight = 0;
+ }
+ result.barycenter = (result.barycenter * result.weight +
+ blPred.order + brPred.order) / (result.weight + 2);
+ result.weight += 2;
+ }
+ }
+
+ return result;
+}
+
+function expandSubgraphs(entries, subgraphs) {
+ _.each(entries, function(entry) {
+ entry.vs = _.flatten(entry.vs.map(function(v) {
+ if (subgraphs[v]) {
+ return subgraphs[v].vs;
+ }
+ return v;
+ }), true);
+ });
+}
+
+function mergeBarycenters(target, other) {
+ if (!_.isUndefined(target.barycenter)) {
+ target.barycenter = (target.barycenter * target.weight +
+ other.barycenter * other.weight) /
+ (target.weight + other.weight);
+ target.weight += other.weight;
+ } else {
+ target.barycenter = other.barycenter;
+ target.weight = other.weight;
+ }
+}
+
+},{"../lodash":38,"./barycenter":42,"./resolve-conflicts":47,"./sort":49}],49:[function(require,module,exports){
+var _ = require("../lodash"),
+ util = require("../util");
+
+module.exports = sort;
+
+function sort(entries, biasRight) {
+ var parts = util.partition(entries, function(entry) {
+ return _.has(entry, "barycenter");
+ });
+ var sortable = parts.lhs,
+ unsortable = _.sortBy(parts.rhs, function(entry) { return -entry.i; }),
+ vs = [],
+ sum = 0,
+ weight = 0,
+ vsIndex = 0;
+
+ sortable.sort(compareWithBias(!!biasRight));
+
+ vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+
+ _.each(sortable, function (entry) {
+ vsIndex += entry.vs.length;
+ vs.push(entry.vs);
+ sum += entry.barycenter * entry.weight;
+ weight += entry.weight;
+ vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+ });
+
+ var result = { vs: _.flatten(vs, true) };
+ if (weight) {
+ result.barycenter = sum / weight;
+ result.weight = weight;
+ }
+ return result;
+}
+
+function consumeUnsortable(vs, unsortable, index) {
+ var last;
+ while (unsortable.length && (last = _.last(unsortable)).i <= index) {
+ unsortable.pop();
+ vs.push(last.vs);
+ index++;
+ }
+ return index;
+}
+
+function compareWithBias(bias) {
+ return function(entryV, entryW) {
+ if (entryV.barycenter < entryW.barycenter) {
+ return -1;
+ } else if (entryV.barycenter > entryW.barycenter) {
+ return 1;
+ }
+
+ return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
+ };
+}
+
+},{"../lodash":38,"../util":57}],50:[function(require,module,exports){
+var _ = require("./lodash");
+
+module.exports = parentDummyChains;
+
+function parentDummyChains(g) {
+ var postorderNums = postorder(g);
+
+ _.each(g.graph().dummyChains, function(v) {
+ var node = g.node(v),
+ edgeObj = node.edgeObj,
+ pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w),
+ path = pathData.path,
+ lca = pathData.lca,
+ pathIdx = 0,
+ pathV = path[pathIdx],
+ ascending = true;
+
+ while (v !== edgeObj.w) {
+ node = g.node(v);
+
+ if (ascending) {
+ while ((pathV = path[pathIdx]) !== lca &&
+ g.node(pathV).maxRank < node.rank) {
+ pathIdx++;
+ }
+
+ if (pathV === lca) {
+ ascending = false;
+ }
+ }
+
+ if (!ascending) {
+ while (pathIdx < path.length - 1 &&
+ g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
+ pathIdx++;
+ }
+ pathV = path[pathIdx];
+ }
+
+ g.setParent(v, pathV);
+ v = g.successors(v)[0];
+ }
+ });
+}
+
+// Find a path from v to w through the lowest common ancestor (LCA). Return the
+// full path and the LCA.
+function findPath(g, postorderNums, v, w) {
+ var vPath = [],
+ wPath = [],
+ low = Math.min(postorderNums[v].low, postorderNums[w].low),
+ lim = Math.max(postorderNums[v].lim, postorderNums[w].lim),
+ parent,
+ lca;
+
+ // Traverse up from v to find the LCA
+ parent = v;
+ do {
+ parent = g.parent(parent);
+ vPath.push(parent);
+ } while (parent &&
+ (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+ lca = parent;
+
+ // Traverse from w to LCA
+ parent = w;
+ while ((parent = g.parent(parent)) !== lca) {
+ wPath.push(parent);
+ }
+
+ return { path: vPath.concat(wPath.reverse()), lca: lca };
+}
+
+function postorder(g) {
+ var result = {},
+ lim = 0;
+
+ function dfs(v) {
+ var low = lim;
+ _.each(g.children(v), dfs);
+ result[v] = { low: low, lim: lim++ };
+ }
+ _.each(g.children(), dfs);
+
+ return result;
+}
+
+},{"./lodash":38}],51:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash"),
+ Graph = require("../graphlib").Graph,
+ util = require("../util");
+
+/*
+ * This module provides coordinate assignment based on Brandes and Köpf, "Fast
+ * and Simple Horizontal Coordinate Assignment."
+ */
+
+module.exports = {
+ positionX: positionX,
+ findType1Conflicts: findType1Conflicts,
+ findType2Conflicts: findType2Conflicts,
+ addConflict: addConflict,
+ hasConflict: hasConflict,
+ verticalAlignment: verticalAlignment,
+ horizontalCompaction: horizontalCompaction,
+ alignCoordinates: alignCoordinates,
+ findSmallestWidthAlignment: findSmallestWidthAlignment,
+ balance: balance
+};
+
+/*
+ * Marks all edges in the graph with a type-1 conflict with the "type1Conflict"
+ * property. A type-1 conflict is one where a non-inner segment crosses an
+ * inner segment. An inner segment is an edge with both incident nodes marked
+ * with the "dummy" property.
+ *
+ * This algorithm scans layer by layer, starting with the second, for type-1
+ * conflicts between the current layer and the previous layer. For each layer
+ * it scans the nodes from left to right until it reaches one that is incident
+ * on an inner segment. It then scans predecessors to determine if they have
+ * edges that cross that inner segment. At the end a final scan is done for all
+ * nodes on the current rank to see if they cross the last visited inner
+ * segment.
+ *
+ * This algorithm (safely) assumes that a dummy node will only be incident on a
+ * single node in the layers being scanned.
+ */
+function findType1Conflicts(g, layering) {
+ var conflicts = {};
+
+ function visitLayer(prevLayer, layer) {
+ var
+ // last visited node in the previous layer that is incident on an inner
+ // segment.
+ k0 = 0,
+ // Tracks the last node in this layer scanned for crossings with a type-1
+ // segment.
+ scanPos = 0,
+ prevLayerLength = prevLayer.length,
+ lastNode = _.last(layer);
+
+ _.each(layer, function(v, i) {
+ var w = findOtherInnerSegmentNode(g, v),
+ k1 = w ? g.node(w).order : prevLayerLength;
+
+ if (w || v === lastNode) {
+ _.each(layer.slice(scanPos, i +1), function(scanNode) {
+ _.each(g.predecessors(scanNode), function(u) {
+ var uLabel = g.node(u),
+ uPos = uLabel.order;
+ if ((uPos < k0 || k1 < uPos) &&
+ !(uLabel.dummy && g.node(scanNode).dummy)) {
+ addConflict(conflicts, u, scanNode);
+ }
+ });
+ });
+ scanPos = i + 1;
+ k0 = k1;
+ }
+ });
+
+ return layer;
+ }
+
+ _.reduce(layering, visitLayer);
+ return conflicts;
+}
+
+function findType2Conflicts(g, layering) {
+ var conflicts = {};
+
+ function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+ var v;
+ _.each(_.range(southPos, southEnd), function(i) {
+ v = south[i];
+ if (g.node(v).dummy) {
+ _.each(g.predecessors(v), function(u) {
+ var uNode = g.node(u);
+ if (uNode.dummy &&
+ (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+ addConflict(conflicts, u, v);
+ }
+ });
+ }
+ });
+ }
+
+
+ function visitLayer(north, south) {
+ var prevNorthPos = -1,
+ nextNorthPos,
+ southPos = 0;
+
+ _.each(south, function(v, southLookahead) {
+ if (g.node(v).dummy === "border") {
+ var predecessors = g.predecessors(v);
+ if (predecessors.length) {
+ nextNorthPos = g.node(predecessors[0]).order;
+ scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
+ southPos = southLookahead;
+ prevNorthPos = nextNorthPos;
+ }
+ }
+ scan(south, southPos, south.length, nextNorthPos, north.length);
+ });
+
+ return south;
+ }
+
+ _.reduce(layering, visitLayer);
+ return conflicts;
+}
+
+function findOtherInnerSegmentNode(g, v) {
+ if (g.node(v).dummy) {
+ return _.find(g.predecessors(v), function(u) {
+ return g.node(u).dummy;
+ });
+ }
+}
+
+function addConflict(conflicts, v, w) {
+ if (v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+
+ var conflictsV = conflicts[v];
+ if (!conflictsV) {
+ conflicts[v] = conflictsV = {};
+ }
+ conflictsV[w] = true;
+}
+
+function hasConflict(conflicts, v, w) {
+ if (v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+ return _.has(conflicts[v], w);
+}
+
+/*
+ * Try to align nodes into vertical "blocks" where possible. This algorithm
+ * attempts to align a node with one of its median neighbors. If the edge
+ * connecting a neighbor is a type-1 conflict then we ignore that possibility.
+ * If a previous node has already formed a block with a node after the node
+ * we're trying to form a block with, we also ignore that possibility - our
+ * blocks would be split in that scenario.
+ */
+function verticalAlignment(g, layering, conflicts, neighborFn) {
+ var root = {},
+ align = {},
+ pos = {};
+
+ // We cache the position here based on the layering because the graph and
+ // layering may be out of sync. The layering matrix is manipulated to
+ // generate different extreme alignments.
+ _.each(layering, function(layer) {
+ _.each(layer, function(v, order) {
+ root[v] = v;
+ align[v] = v;
+ pos[v] = order;
+ });
+ });
+
+ _.each(layering, function(layer) {
+ var prevIdx = -1;
+ _.each(layer, function(v) {
+ var ws = neighborFn(v);
+ if (ws.length) {
+ ws = _.sortBy(ws, function(w) { return pos[w]; });
+ var mp = (ws.length - 1) / 2;
+ for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+ var w = ws[i];
+ if (align[v] === v &&
+ prevIdx < pos[w] &&
+ !hasConflict(conflicts, v, w)) {
+ align[w] = v;
+ align[v] = root[v] = root[w];
+ prevIdx = pos[w];
+ }
+ }
+ }
+ });
+ });
+
+ return { root: root, align: align };
+}
+
+function horizontalCompaction(g, layering, root, align, reverseSep) {
+ // This portion of the algorithm differs from BK due to a number of problems.
+ // Instead of their algorithm we construct a new block graph and do two
+ // sweeps. The first sweep places blocks with the smallest possible
+ // coordinates. The second sweep removes unused space by moving blocks to the
+ // greatest coordinates without violating separation.
+ var xs = {},
+ blockG = buildBlockGraph(g, layering, root, reverseSep);
+
+ // First pass, assign smallest coordinates via DFS
+ var visited = {};
+ function pass1(v) {
+ if (!_.has(visited, v)) {
+ visited[v] = true;
+ xs[v] = _.reduce(blockG.inEdges(v), function(max, e) {
+ pass1(e.v);
+ return Math.max(max, xs[e.v] + blockG.edge(e));
+ }, 0);
+ }
+ }
+ _.each(blockG.nodes(), pass1);
+
+ var borderType = reverseSep ? "borderLeft" : "borderRight";
+ function pass2(v) {
+ if (visited[v] !== 2) {
+ visited[v]++;
+ var node = g.node(v);
+ var min = _.reduce(blockG.outEdges(v), function(min, e) {
+ pass2(e.w);
+ return Math.min(min, xs[e.w] - blockG.edge(e));
+ }, Number.POSITIVE_INFINITY);
+ if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
+ xs[v] = Math.max(xs[v], min);
+ }
+ }
+ }
+ _.each(blockG.nodes(), pass2);
+
+ // Assign x coordinates to all nodes
+ _.each(align, function(v) {
+ xs[v] = xs[root[v]];
+ });
+
+ return xs;
+}
+
+
+function buildBlockGraph(g, layering, root, reverseSep) {
+ var blockGraph = new Graph(),
+ graphLabel = g.graph(),
+ sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+
+ _.each(layering, function(layer) {
+ var u;
+ _.each(layer, function(v) {
+ var vRoot = root[v];
+ blockGraph.setNode(vRoot);
+ if (u) {
+ var uRoot = root[u],
+ prevMax = blockGraph.edge(uRoot, vRoot);
+ blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
+ }
+ u = v;
+ });
+ });
+
+ return blockGraph;
+}
+
+/*
+ * Returns the alignment that has the smallest width of the given alignments.
+ */
+function findSmallestWidthAlignment(g, xss) {
+ return _.min(xss, function(xs) {
+ var min = _.min(xs, function(x, v) { return x - width(g, v) / 2; }),
+ max = _.max(xs, function(x, v) { return x + width(g, v) / 2; });
+ return max - min;
+ });
+}
+
+/*
+ * Align the coordinates of each of the layout alignments such that
+ * left-biased alignments have their minimum coordinate at the same point as
+ * the minimum coordinate of the smallest width alignment and right-biased
+ * alignments have their maximum coordinate at the same point as the maximum
+ * coordinate of the smallest width alignment.
+ */
+function alignCoordinates(xss, alignTo) {
+ var alignToMin = _.min(alignTo),
+ alignToMax = _.max(alignTo);
+
+ _.each(["u", "d"], function(vert) {
+ _.each(["l", "r"], function(horiz) {
+ var alignment = vert + horiz,
+ xs = xss[alignment],
+ delta;
+ if (xs === alignTo) return;
+
+ delta = horiz === "l" ? alignToMin - _.min(xs) : alignToMax - _.max(xs);
+
+ if (delta) {
+ xss[alignment] = _.mapValues(xs, function(x) { return x + delta; });
+ }
+ });
+ });
+}
+
+function balance(xss, align) {
+ return _.mapValues(xss.ul, function(ignore, v) {
+ if (align) {
+ return xss[align.toLowerCase()][v];
+ } else {
+ var xs = _.sortBy(_.pluck(xss, v));
+ return (xs[1] + xs[2]) / 2;
+ }
+ });
+}
+
+function positionX(g) {
+ var layering = util.buildLayerMatrix(g),
+ conflicts = _.merge(findType1Conflicts(g, layering),
+ findType2Conflicts(g, layering));
+
+ var xss = {},
+ adjustedLayering;
+ _.each(["u", "d"], function(vert) {
+ adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
+ _.each(["l", "r"], function(horiz) {
+ if (horiz === "r") {
+ adjustedLayering = _.map(adjustedLayering, function(inner) {
+ return _.values(inner).reverse();
+ });
+ }
+
+ var neighborFn = _.bind(vert === "u" ? g.predecessors : g.successors, g);
+ var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+ var xs = horizontalCompaction(g, adjustedLayering,
+ align.root, align.align,
+ horiz === "r");
+ if (horiz === "r") {
+ xs = _.mapValues(xs, function(x) { return -x; });
+ }
+ xss[vert + horiz] = xs;
+ });
+ });
+
+ var smallestWidth = findSmallestWidthAlignment(g, xss);
+ alignCoordinates(xss, smallestWidth);
+ return balance(xss, g.graph().align);
+}
+
+function sep(nodeSep, edgeSep, reverseSep) {
+ return function(g, v, w) {
+ var vLabel = g.node(v),
+ wLabel = g.node(w),
+ sum = 0,
+ delta;
+
+ sum += vLabel.width / 2;
+ if (_.has(vLabel, "labelpos")) {
+ switch (vLabel.labelpos.toLowerCase()) {
+ case "l": delta = -vLabel.width / 2; break;
+ case "r": delta = vLabel.width / 2; break;
+ }
+ }
+ if (delta) {
+ sum += reverseSep ? delta : -delta;
+ }
+ delta = 0;
+
+ sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
+ sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
+
+ sum += wLabel.width / 2;
+ if (_.has(wLabel, "labelpos")) {
+ switch (wLabel.labelpos.toLowerCase()) {
+ case "l": delta = wLabel.width / 2; break;
+ case "r": delta = -wLabel.width / 2; break;
+ }
+ }
+ if (delta) {
+ sum += reverseSep ? delta : -delta;
+ }
+ delta = 0;
+
+ return sum;
+ };
+}
+
+function width(g, v) {
+ return g.node(v).width;
+}
+
+},{"../graphlib":35,"../lodash":38,"../util":57}],52:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash"),
+ util = require("../util"),
+ positionX = require("./bk").positionX;
+
+module.exports = position;
+
+function position(g) {
+ g = util.asNonCompoundGraph(g);
+
+ positionY(g);
+ _.each(positionX(g), function(x, v) {
+ g.node(v).x = x;
+ });
+}
+
+function positionY(g) {
+ var layering = util.buildLayerMatrix(g),
+ rankSep = g.graph().ranksep,
+ prevY = 0;
+ _.each(layering, function(layer) {
+ var maxHeight = _.max(_.map(layer, function(v) { return g.node(v).height; }));
+ _.each(layer, function(v) {
+ g.node(v).y = prevY + maxHeight / 2;
+ });
+ prevY += maxHeight + rankSep;
+ });
+}
+
+
+},{"../lodash":38,"../util":57,"./bk":51}],53:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash"),
+ Graph = require("../graphlib").Graph,
+ slack = require("./util").slack;
+
+module.exports = feasibleTree;
+
+/*
+ * Constructs a spanning tree with tight edges and adjusted the input node's
+ * ranks to achieve this. A tight edge is one that is has a length that matches
+ * its "minlen" attribute.
+ *
+ * The basic structure for this function is derived from Gansner, et al., "A
+ * Technique for Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ * 1. Graph must be a DAG.
+ * 2. Graph must be connected.
+ * 3. Graph must have at least one node.
+ * 5. Graph nodes must have been previously assigned a "rank" property that
+ * respects the "minlen" property of incident edges.
+ * 6. Graph edges must have a "minlen" property.
+ *
+ * Post-conditions:
+ *
+ * - Graph nodes will have their rank adjusted to ensure that all edges are
+ * tight.
+ *
+ * Returns a tree (undirected graph) that is constructed using only "tight"
+ * edges.
+ */
+function feasibleTree(g) {
+ var t = new Graph({ directed: false });
+
+ // Choose arbitrary node from which to start our tree
+ var start = g.nodes()[0],
+ size = g.nodeCount();
+ t.setNode(start, {});
+
+ var edge, delta;
+ while (tightTree(t, g) < size) {
+ edge = findMinSlackEdge(t, g);
+ delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+ shiftRanks(t, g, delta);
+ }
+
+ return t;
+}
+
+/*
+ * Finds a maximal tree of tight edges and returns the number of nodes in the
+ * tree.
+ */
+function tightTree(t, g) {
+ function dfs(v) {
+ _.each(g.nodeEdges(v), function(e) {
+ var edgeV = e.v,
+ w = (v === edgeV) ? e.w : edgeV;
+ if (!t.hasNode(w) && !slack(g, e)) {
+ t.setNode(w, {});
+ t.setEdge(v, w, {});
+ dfs(w);
+ }
+ });
+ }
+
+ _.each(t.nodes(), dfs);
+ return t.nodeCount();
+}
+
+/*
+ * Finds the edge with the smallest slack that is incident on tree and returns
+ * it.
+ */
+function findMinSlackEdge(t, g) {
+ return _.min(g.edges(), function(e) {
+ if (t.hasNode(e.v) !== t.hasNode(e.w)) {
+ return slack(g, e);
+ }
+ });
+}
+
+function shiftRanks(t, g, delta) {
+ _.each(t.nodes(), function(v) {
+ g.node(v).rank += delta;
+ });
+}
+
+},{"../graphlib":35,"../lodash":38,"./util":56}],54:[function(require,module,exports){
+"use strict";
+
+var rankUtil = require("./util"),
+ longestPath = rankUtil.longestPath,
+ feasibleTree = require("./feasible-tree"),
+ networkSimplex = require("./network-simplex");
+
+module.exports = rank;
+
+/*
+ * Assigns a rank to each node in the input graph that respects the "minlen"
+ * constraint specified on edges between nodes.
+ *
+ * This basic structure is derived from Gansner, et al., "A Technique for
+ * Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ * 1. Graph must be a connected DAG
+ * 2. Graph nodes must be objects
+ * 3. Graph edges must have "weight" and "minlen" attributes
+ *
+ * Post-conditions:
+ *
+ * 1. Graph nodes will have a "rank" attribute based on the results of the
+ * algorithm. Ranks can start at any index (including negative), we'll
+ * fix them up later.
+ */
+function rank(g) {
+ switch(g.graph().ranker) {
+ case "network-simplex": networkSimplexRanker(g); break;
+ case "tight-tree": tightTreeRanker(g); break;
+ case "longest-path": longestPathRanker(g); break;
+ default: networkSimplexRanker(g);
+ }
+}
+
+// A fast and simple ranker, but results are far from optimal.
+var longestPathRanker = longestPath;
+
+function tightTreeRanker(g) {
+ longestPath(g);
+ feasibleTree(g);
+}
+
+function networkSimplexRanker(g) {
+ networkSimplex(g);
+}
+
+},{"./feasible-tree":53,"./network-simplex":55,"./util":56}],55:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash"),
+ feasibleTree = require("./feasible-tree"),
+ slack = require("./util").slack,
+ initRank = require("./util").longestPath,
+ preorder = require("../graphlib").alg.preorder,
+ postorder = require("../graphlib").alg.postorder,
+ simplify = require("../util").simplify;
+
+module.exports = networkSimplex;
+
+// Expose some internals for testing purposes
+networkSimplex.initLowLimValues = initLowLimValues;
+networkSimplex.initCutValues = initCutValues;
+networkSimplex.calcCutValue = calcCutValue;
+networkSimplex.leaveEdge = leaveEdge;
+networkSimplex.enterEdge = enterEdge;
+networkSimplex.exchangeEdges = exchangeEdges;
+
+/*
+ * The network simplex algorithm assigns ranks to each node in the input graph
+ * and iteratively improves the ranking to reduce the length of edges.
+ *
+ * Preconditions:
+ *
+ * 1. The input graph must be a DAG.
+ * 2. All nodes in the graph must have an object value.
+ * 3. All edges in the graph must have "minlen" and "weight" attributes.
+ *
+ * Postconditions:
+ *
+ * 1. All nodes in the graph will have an assigned "rank" attribute that has
+ * been optimized by the network simplex algorithm. Ranks start at 0.
+ *
+ *
+ * A rough sketch of the algorithm is as follows:
+ *
+ * 1. Assign initial ranks to each node. We use the longest path algorithm,
+ * which assigns ranks to the lowest position possible. In general this
+ * leads to very wide bottom ranks and unnecessarily long edges.
+ * 2. Construct a feasible tight tree. A tight tree is one such that all
+ * edges in the tree have no slack (difference between length of edge
+ * and minlen for the edge). This by itself greatly improves the assigned
+ * rankings by shorting edges.
+ * 3. Iteratively find edges that have negative cut values. Generally a
+ * negative cut value indicates that the edge could be removed and a new
+ * tree edge could be added to produce a more compact graph.
+ *
+ * Much of the algorithms here are derived from Gansner, et al., "A Technique
+ * for Drawing Directed Graphs." The structure of the file roughly follows the
+ * structure of the overall algorithm.
+ */
+function networkSimplex(g) {
+ g = simplify(g);
+ initRank(g);
+ var t = feasibleTree(g);
+ initLowLimValues(t);
+ initCutValues(t, g);
+
+ var e, f;
+ while ((e = leaveEdge(t))) {
+ f = enterEdge(t, g, e);
+ exchangeEdges(t, g, e, f);
+ }
+}
+
+/*
+ * Initializes cut values for all edges in the tree.
+ */
+function initCutValues(t, g) {
+ var vs = postorder(t, t.nodes());
+ vs = vs.slice(0, vs.length - 1);
+ _.each(vs, function(v) {
+ assignCutValue(t, g, v);
+ });
+}
+
+function assignCutValue(t, g, child) {
+ var childLab = t.node(child),
+ parent = childLab.parent;
+ t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+}
+
+/*
+ * Given the tight tree, its graph, and a child in the graph calculate and
+ * return the cut value for the edge between the child and its parent.
+ */
+function calcCutValue(t, g, child) {
+ var childLab = t.node(child),
+ parent = childLab.parent,
+ // True if the child is on the tail end of the edge in the directed graph
+ childIsTail = true,
+ // The graph's view of the tree edge we're inspecting
+ graphEdge = g.edge(child, parent),
+ // The accumulated cut value for the edge between this node and its parent
+ cutValue = 0;
+
+ if (!graphEdge) {
+ childIsTail = false;
+ graphEdge = g.edge(parent, child);
+ }
+
+ cutValue = graphEdge.weight;
+
+ _.each(g.nodeEdges(child), function(e) {
+ var isOutEdge = e.v === child,
+ other = isOutEdge ? e.w : e.v;
+
+ if (other !== parent) {
+ var pointsToHead = isOutEdge === childIsTail,
+ otherWeight = g.edge(e).weight;
+
+ cutValue += pointsToHead ? otherWeight : -otherWeight;
+ if (isTreeEdge(t, child, other)) {
+ var otherCutValue = t.edge(child, other).cutvalue;
+ cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+ }
+ }
+ });
+
+ return cutValue;
+}
+
+function initLowLimValues(tree, root) {
+ if (arguments.length < 2) {
+ root = tree.nodes()[0];
+ }
+ dfsAssignLowLim(tree, {}, 1, root);
+}
+
+function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+ var low = nextLim,
+ label = tree.node(v);
+
+ visited[v] = true;
+ _.each(tree.neighbors(v), function(w) {
+ if (!_.has(visited, w)) {
+ nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+ }
+ });
+
+ label.low = low;
+ label.lim = nextLim++;
+ if (parent) {
+ label.parent = parent;
+ } else {
+ // TODO should be able to remove this when we incrementally update low lim
+ delete label.parent;
+ }
+
+ return nextLim;
+}
+
+function leaveEdge(tree) {
+ return _.find(tree.edges(), function(e) {
+ return tree.edge(e).cutvalue < 0;
+ });
+}
+
+function enterEdge(t, g, edge) {
+ var v = edge.v,
+ w = edge.w;
+
+ // For the rest of this function we assume that v is the tail and w is the
+ // head, so if we don't have this edge in the graph we should flip it to
+ // match the correct orientation.
+ if (!g.hasEdge(v, w)) {
+ v = edge.w;
+ w = edge.v;
+ }
+
+ var vLabel = t.node(v),
+ wLabel = t.node(w),
+ tailLabel = vLabel,
+ flip = false;
+
+ // If the root is in the tail of the edge then we need to flip the logic that
+ // checks for the head and tail nodes in the candidates function below.
+ if (vLabel.lim > wLabel.lim) {
+ tailLabel = wLabel;
+ flip = true;
+ }
+
+ var candidates = _.filter(g.edges(), function(edge) {
+ return flip === isDescendant(t, t.node(edge.v), tailLabel) &&
+ flip !== isDescendant(t, t.node(edge.w), tailLabel);
+ });
+
+ return _.min(candidates, function(edge) { return slack(g, edge); });
+}
+
+function exchangeEdges(t, g, e, f) {
+ var v = e.v,
+ w = e.w;
+ t.removeEdge(v, w);
+ t.setEdge(f.v, f.w, {});
+ initLowLimValues(t);
+ initCutValues(t, g);
+ updateRanks(t, g);
+}
+
+function updateRanks(t, g) {
+ var root = _.find(t.nodes(), function(v) { return !g.node(v).parent; }),
+ vs = preorder(t, root);
+ vs = vs.slice(1);
+ _.each(vs, function(v) {
+ var parent = t.node(v).parent,
+ edge = g.edge(v, parent),
+ flipped = false;
+
+ if (!edge) {
+ edge = g.edge(parent, v);
+ flipped = true;
+ }
+
+ g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+ });
+}
+
+/*
+ * Returns true if the edge is in the tree.
+ */
+function isTreeEdge(tree, u, v) {
+ return tree.hasEdge(u, v);
+}
+
+/*
+ * Returns true if the specified node is descendant of the root node per the
+ * assigned low and lim attributes in the tree.
+ */
+function isDescendant(tree, vLabel, rootLabel) {
+ return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
+}
+
+},{"../graphlib":35,"../lodash":38,"../util":57,"./feasible-tree":53,"./util":56}],56:[function(require,module,exports){
+"use strict";
+
+var _ = require("../lodash");
+
+module.exports = {
+ longestPath: longestPath,
+ slack: slack
+};
+
+/*
+ * Initializes ranks for the input graph using the longest path algorithm. This
+ * algorithm scales well and is fast in practice, it yields rather poor
+ * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom
+ * ranks wide and leaving edges longer than necessary. However, due to its
+ * speed, this algorithm is good for getting an initial ranking that can be fed
+ * into other algorithms.
+ *
+ * This algorithm does not normalize layers because it will be used by other
+ * algorithms in most cases. If using this algorithm directly, be sure to
+ * run normalize at the end.
+ *
+ * Pre-conditions:
+ *
+ * 1. Input graph is a DAG.
+ * 2. Input graph node labels can be assigned properties.
+ *
+ * Post-conditions:
+ *
+ * 1. Each node will be assign an (unnormalized) "rank" property.
+ */
+function longestPath(g) {
+ var visited = {};
+
+ function dfs(v) {
+ var label = g.node(v);
+ if (_.has(visited, v)) {
+ return label.rank;
+ }
+ visited[v] = true;
+
+ var rank = _.min(_.map(g.outEdges(v), function(e) {
+ return dfs(e.w) - g.edge(e).minlen;
+ }));
+
+ if (rank === Number.POSITIVE_INFINITY) {
+ rank = 0;
+ }
+
+ return (label.rank = rank);
+ }
+
+ _.each(g.sources(), dfs);
+}
+
+/*
+ * Returns the amount of slack for the given edge. The slack is defined as the
+ * difference between the length of the edge and its minimum length.
+ */
+function slack(g, e) {
+ return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+}
+
+},{"../lodash":38}],57:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash"),
+ Graph = require("./graphlib").Graph;
+
+module.exports = {
+ addDummyNode: addDummyNode,
+ simplify: simplify,
+ asNonCompoundGraph: asNonCompoundGraph,
+ successorWeights: successorWeights,
+ predecessorWeights: predecessorWeights,
+ intersectRect: intersectRect,
+ buildLayerMatrix: buildLayerMatrix,
+ normalizeRanks: normalizeRanks,
+ removeEmptyRanks: removeEmptyRanks,
+ addBorderNode: addBorderNode,
+ maxRank: maxRank,
+ partition: partition,
+ time: time,
+ notime: notime
+};
+
+/*
+ * Adds a dummy node to the graph and return v.
+ */
+function addDummyNode(g, type, attrs, name) {
+ var v;
+ do {
+ v = _.uniqueId(name);
+ } while (g.hasNode(v));
+
+ attrs.dummy = type;
+ g.setNode(v, attrs);
+ return v;
+}
+
+/*
+ * Returns a new graph with only simple edges. Handles aggregation of data
+ * associated with multi-edges.
+ */
+function simplify(g) {
+ var simplified = new Graph().setGraph(g.graph());
+ _.each(g.nodes(), function(v) { simplified.setNode(v, g.node(v)); });
+ _.each(g.edges(), function(e) {
+ var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 },
+ label = g.edge(e);
+ simplified.setEdge(e.v, e.w, {
+ weight: simpleLabel.weight + label.weight,
+ minlen: Math.max(simpleLabel.minlen, label.minlen)
+ });
+ });
+ return simplified;
+}
+
+function asNonCompoundGraph(g) {
+ var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+ _.each(g.nodes(), function(v) {
+ if (!g.children(v).length) {
+ simplified.setNode(v, g.node(v));
+ }
+ });
+ _.each(g.edges(), function(e) {
+ simplified.setEdge(e, g.edge(e));
+ });
+ return simplified;
+}
+
+function successorWeights(g) {
+ var weightMap = _.map(g.nodes(), function(v) {
+ var sucs = {};
+ _.each(g.outEdges(v), function(e) {
+ sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
+ });
+ return sucs;
+ });
+ return _.zipObject(g.nodes(), weightMap);
+}
+
+function predecessorWeights(g) {
+ var weightMap = _.map(g.nodes(), function(v) {
+ var preds = {};
+ _.each(g.inEdges(v), function(e) {
+ preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
+ });
+ return preds;
+ });
+ return _.zipObject(g.nodes(), weightMap);
+}
+
+/*
+ * Finds where a line starting at point ({x, y}) would intersect a rectangle
+ * ({x, y, width, height}) if it were pointing at the rectangle's center.
+ */
+function intersectRect(rect, point) {
+ var x = rect.x;
+ var y = rect.y;
+
+ // Rectangle intersection algorithm from:
+ // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
+ var dx = point.x - x;
+ var dy = point.y - y;
+ var w = rect.width / 2;
+ var h = rect.height / 2;
+
+ if (!dx && !dy) {
+ throw new Error("Not possible to find intersection inside of the rectangle");
+ }
+
+ var sx, sy;
+ if (Math.abs(dy) * w > Math.abs(dx) * h) {
+ // Intersection is top or bottom of rect.
+ if (dy < 0) {
+ h = -h;
+ }
+ sx = h * dx / dy;
+ sy = h;
+ } else {
+ // Intersection is left or right of rect.
+ if (dx < 0) {
+ w = -w;
+ }
+ sx = w;
+ sy = w * dy / dx;
+ }
+
+ return { x: x + sx, y: y + sy };
+}
+
+/*
+ * Given a DAG with each node assigned "rank" and "order" properties, this
+ * function will produce a matrix with the ids of each node.
+ */
+function buildLayerMatrix(g) {
+ var layering = _.map(_.range(maxRank(g) + 1), function() { return []; });
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v),
+ rank = node.rank;
+ if (!_.isUndefined(rank)) {
+ layering[rank][node.order] = v;
+ }
+ });
+ return layering;
+}
+
+/*
+ * Adjusts the ranks for all nodes in the graph such that all nodes v have
+ * rank(v) >= 0 and at least one node w has rank(w) = 0.
+ */
+function normalizeRanks(g) {
+ var min = _.min(_.map(g.nodes(), function(v) { return g.node(v).rank; }));
+ _.each(g.nodes(), function(v) {
+ var node = g.node(v);
+ if (_.has(node, "rank")) {
+ node.rank -= min;
+ }
+ });
+}
+
+function removeEmptyRanks(g) {
+ // Ranks may not start at 0, so we need to offset them
+ var offset = _.min(_.map(g.nodes(), function(v) { return g.node(v).rank; }));
+
+ var layers = [];
+ _.each(g.nodes(), function(v) {
+ var rank = g.node(v).rank - offset;
+ if (!_.has(layers, rank)) {
+ layers[rank] = [];
+ }
+ layers[rank].push(v);
+ });
+
+ var delta = 0,
+ nodeRankFactor = g.graph().nodeRankFactor;
+ _.each(layers, function(vs, i) {
+ if (_.isUndefined(vs) && i % nodeRankFactor !== 0) {
+ --delta;
+ } else if (delta) {
+ _.each(vs, function(v) { g.node(v).rank += delta; });
+ }
+ });
+}
+
+function addBorderNode(g, prefix, rank, order) {
+ var node = {
+ width: 0,
+ height: 0
+ };
+ if (arguments.length >= 4) {
+ node.rank = rank;
+ node.order = order;
+ }
+ return addDummyNode(g, "border", node, prefix);
+}
+
+function maxRank(g) {
+ return _.max(_.map(g.nodes(), function(v) {
+ var rank = g.node(v).rank;
+ if (!_.isUndefined(rank)) {
+ return rank;
+ }
+ }));
+}
+
+/*
+ * Partition a collection into two groups: `lhs` and `rhs`. If the supplied
+ * function returns true for an entry it goes into `lhs`. Otherwise it goes
+ * into `rhs.
+ */
+function partition(collection, fn) {
+ var result = { lhs: [], rhs: [] };
+ _.each(collection, function(value) {
+ if (fn(value)) {
+ result.lhs.push(value);
+ } else {
+ result.rhs.push(value);
+ }
+ });
+ return result;
+}
+
+/*
+ * Returns a new function that wraps `fn` with a timer. The wrapper logs the
+ * time it takes to execute the function.
+ */
+function time(name, fn) {
+ var start = _.now();
+ try {
+ return fn();
+ } finally {
+ console.log(name + " time: " + (_.now() - start) + "ms");
+ }
+}
+
+function notime(name, fn) {
+ return fn();
+}
+
+},{"./graphlib":35,"./lodash":38}],58:[function(require,module,exports){
+module.exports = "0.7.2";
+
+},{}],59:[function(require,module,exports){
+(function (global){
+/**
+ * @license
+ * Lo-Dash 2.4.2 (Custom Build) <https://lodash.com/>
+ * Build: `lodash modern -o ./dist/lodash.js`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <https://lodash.com/license>
+ */
+;(function() {
+
+ /** Used as a safe reference for `undefined` in pre ES5 environments */
+ var undefined;
+
+ /** Used to pool arrays and objects used internally */
+ var arrayPool = [],
+ objectPool = [];
+
+ /** Used to generate unique IDs */
+ var idCounter = 0;
+
+ /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */
+ var keyPrefix = +new Date + '';
+
+ /** Used as the size when optimizations are enabled for large arrays */
+ var largeArraySize = 75;
+
+ /** Used as the max size of the `arrayPool` and `objectPool` */
+ var maxPoolSize = 40;
+
+ /** Used to detect and test whitespace */
+ var whitespace = (
+ // whitespace
+ ' \t\x0B\f\xA0\ufeff' +
+
+ // line terminators
+ '\n\r\u2028\u2029' +
+
+ // unicode category "Zs" space separators
+ '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
+ );
+
+ /** Used to match empty string literals in compiled template source */
+ var reEmptyStringLeading = /\b__p \+= '';/g,
+ reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+ reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+ /**
+ * Used to match ES6 template delimiters
+ * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals
+ */
+ var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+ /** Used to match regexp flags from their coerced string values */
+ var reFlags = /\w*$/;
+
+ /** Used to detected named functions */
+ var reFuncName = /^\s*function[ \n\r\t]+\w/;
+
+ /** Used to match "interpolate" template delimiters */
+ var reInterpolate = /<%=([\s\S]+?)%>/g;
+
+ /** Used to match leading whitespace and zeros to be removed */
+ var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');
+
+ /** Used to ensure capturing order of template delimiters */
+ var reNoMatch = /($^)/;
+
+ /** Used to detect functions containing a `this` reference */
+ var reThis = /\bthis\b/;
+
+ /** Used to match unescaped characters in compiled string literals */
+ var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
+
+ /** Used to assign default `context` object properties */
+ var contextProps = [
+ 'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object',
+ 'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',
+ 'parseInt', 'setTimeout'
+ ];
+
+ /** Used to make template sourceURLs easier to identify */
+ var templateCounter = 0;
+
+ /** `Object#toString` result shortcuts */
+ var argsClass = '[object Arguments]',
+ arrayClass = '[object Array]',
+ boolClass = '[object Boolean]',
+ dateClass = '[object Date]',
+ funcClass = '[object Function]',
+ numberClass = '[object Number]',
+ objectClass = '[object Object]',
+ regexpClass = '[object RegExp]',
+ stringClass = '[object String]';
+
+ /** Used to identify object classifications that `_.clone` supports */
+ var cloneableClasses = {};
+ cloneableClasses[funcClass] = false;
+ cloneableClasses[argsClass] = cloneableClasses[arrayClass] =
+ cloneableClasses[boolClass] = cloneableClasses[dateClass] =
+ cloneableClasses[numberClass] = cloneableClasses[objectClass] =
+ cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;
+
+ /** Used as an internal `_.debounce` options object */
+ var debounceOptions = {
+ 'leading': false,
+ 'maxWait': 0,
+ 'trailing': false
+ };
+
+ /** Used as the property descriptor for `__bindData__` */
+ var descriptor = {
+ 'configurable': false,
+ 'enumerable': false,
+ 'value': null,
+ 'writable': false
+ };
+
+ /** Used to determine if values are of the language type Object */
+ var objectTypes = {
+ 'boolean': false,
+ 'function': true,
+ 'object': true,
+ 'number': false,
+ 'string': false,
+ 'undefined': false
+ };
+
+ /** Used to escape characters for inclusion in compiled string literals */
+ var stringEscapes = {
+ '\\': '\\',
+ "'": "'",
+ '\n': 'n',
+ '\r': 'r',
+ '\t': 't',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ /** Used as a reference to the global object */
+ var root = (objectTypes[typeof window] && window) || this;
+
+ /** Detect free variable `exports` */
+ var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
+
+ /** Detect free variable `module` */
+ var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
+
+ /** Detect the popular CommonJS extension `module.exports` */
+ var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
+
+ /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
+ var freeGlobal = objectTypes[typeof global] && global;
+ if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
+ root = freeGlobal;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The base implementation of `_.indexOf` without support for binary searches
+ * or `fromIndex` constraints.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ */
+ function baseIndexOf(array, value, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0;
+
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * An implementation of `_.contains` for cache objects that mimics the return
+ * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.
+ *
+ * @private
+ * @param {Object} cache The cache object to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `0` if `value` is found, else `-1`.
+ */
+ function cacheIndexOf(cache, value) {
+ var type = typeof value;
+ cache = cache.cache;
+
+ if (type == 'boolean' || value == null) {
+ return cache[value] ? 0 : -1;
+ }
+ if (type != 'number' && type != 'string') {
+ type = 'object';
+ }
+ var key = type == 'number' ? value : keyPrefix + value;
+ cache = (cache = cache[type]) && cache[key];
+
+ return type == 'object'
+ ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)
+ : (cache ? 0 : -1);
+ }
+
+ /**
+ * Adds a given value to the corresponding cache object.
+ *
+ * @private
+ * @param {*} value The value to add to the cache.
+ */
+ function cachePush(value) {
+ var cache = this.cache,
+ type = typeof value;
+
+ if (type == 'boolean' || value == null) {
+ cache[value] = true;
+ } else {
+ if (type != 'number' && type != 'string') {
+ type = 'object';
+ }
+ var key = type == 'number' ? value : keyPrefix + value,
+ typeCache = cache[type] || (cache[type] = {});
+
+ if (type == 'object') {
+ (typeCache[key] || (typeCache[key] = [])).push(value);
+ } else {
+ typeCache[key] = true;
+ }
+ }
+ }
+
+ /**
+ * Used by `_.max` and `_.min` as the default callback when a given
+ * collection is a string value.
+ *
+ * @private
+ * @param {string} value The character to inspect.
+ * @returns {number} Returns the code unit of given character.
+ */
+ function charAtCallback(value) {
+ return value.charCodeAt(0);
+ }
+
+ /**
+ * Used by `sortBy` to compare transformed `collection` elements, stable sorting
+ * them in ascending order.
+ *
+ * @private
+ * @param {Object} a The object to compare to `b`.
+ * @param {Object} b The object to compare to `a`.
+ * @returns {number} Returns the sort order indicator of `1` or `-1`.
+ */
+ function compareAscending(a, b) {
+ var ac = a.criteria,
+ bc = b.criteria,
+ index = -1,
+ length = ac.length;
+
+ while (++index < length) {
+ var value = ac[index],
+ other = bc[index];
+
+ if (value !== other) {
+ if (value > other || typeof value == 'undefined') {
+ return 1;
+ }
+ if (value < other || typeof other == 'undefined') {
+ return -1;
+ }
+ }
+ }
+ // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
+ // that causes it, under certain circumstances, to return the same value for
+ // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247
+ //
+ // This also ensures a stable sort in V8 and other engines.
+ // See http://code.google.com/p/v8/issues/detail?id=90
+ return a.index - b.index;
+ }
+
+ /**
+ * Creates a cache object to optimize linear searches of large arrays.
+ *
+ * @private
+ * @param {Array} [array=[]] The array to search.
+ * @returns {null|Object} Returns the cache object or `null` if caching should not be used.
+ */
+ function createCache(array) {
+ var index = -1,
+ length = array.length,
+ first = array[0],
+ mid = array[(length / 2) | 0],
+ last = array[length - 1];
+
+ if (first && typeof first == 'object' &&
+ mid && typeof mid == 'object' && last && typeof last == 'object') {
+ return false;
+ }
+ var cache = getObject();
+ cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;
+
+ var result = getObject();
+ result.array = array;
+ result.cache = cache;
+ result.push = cachePush;
+
+ while (++index < length) {
+ result.push(array[index]);
+ }
+ return result;
+ }
+
+ /**
+ * Used by `template` to escape characters for inclusion in compiled
+ * string literals.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeStringChar(match) {
+ return '\\' + stringEscapes[match];
+ }
+
+ /**
+ * Gets an array from the array pool or creates a new one if the pool is empty.
+ *
+ * @private
+ * @returns {Array} The array from the pool.
+ */
+ function getArray() {
+ return arrayPool.pop() || [];
+ }
+
+ /**
+ * Gets an object from the object pool or creates a new one if the pool is empty.
+ *
+ * @private
+ * @returns {Object} The object from the pool.
+ */
+ function getObject() {
+ return objectPool.pop() || {
+ 'array': null,
+ 'cache': null,
+ 'criteria': null,
+ 'false': false,
+ 'index': 0,
+ 'null': false,
+ 'number': null,
+ 'object': null,
+ 'push': null,
+ 'string': null,
+ 'true': false,
+ 'undefined': false,
+ 'value': null
+ };
+ }
+
+ /**
+ * Releases the given array back to the array pool.
+ *
+ * @private
+ * @param {Array} [array] The array to release.
+ */
+ function releaseArray(array) {
+ array.length = 0;
+ if (arrayPool.length < maxPoolSize) {
+ arrayPool.push(array);
+ }
+ }
+
+ /**
+ * Releases the given object back to the object pool.
+ *
+ * @private
+ * @param {Object} [object] The object to release.
+ */
+ function releaseObject(object) {
+ var cache = object.cache;
+ if (cache) {
+ releaseObject(cache);
+ }
+ object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;
+ if (objectPool.length < maxPoolSize) {
+ objectPool.push(object);
+ }
+ }
+
+ /**
+ * Slices the `collection` from the `start` index up to, but not including,
+ * the `end` index.
+ *
+ * Note: This function is used instead of `Array#slice` to support node lists
+ * in IE < 9 and to ensure dense arrays are returned.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to slice.
+ * @param {number} start The start index.
+ * @param {number} end The end index.
+ * @returns {Array} Returns the new array.
+ */
+ function slice(array, start, end) {
+ start || (start = 0);
+ if (typeof end == 'undefined') {
+ end = array ? array.length : 0;
+ }
+ var index = -1,
+ length = end - start || 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = array[start + index];
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Create a new `lodash` function using the given context object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} [context=root] The context object.
+ * @returns {Function} Returns the `lodash` function.
+ */
+ function runInContext(context) {
+ // Avoid issues with some ES3 environments that attempt to use values, named
+ // after built-in constructors like `Object`, for the creation of literals.
+ // ES5 clears this up by stating that literals must use built-in constructors.
+ // See http://es5.github.io/#x11.1.5.
+ context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;
+
+ /** Native constructor references */
+ var Array = context.Array,
+ Boolean = context.Boolean,
+ Date = context.Date,
+ Function = context.Function,
+ Math = context.Math,
+ Number = context.Number,
+ Object = context.Object,
+ RegExp = context.RegExp,
+ String = context.String,
+ TypeError = context.TypeError;
+
+ /**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+ var arrayRef = [];
+
+ /** Used for native method references */
+ var objectProto = Object.prototype;
+
+ /** Used to restore the original `_` reference in `noConflict` */
+ var oldDash = context._;
+
+ /** Used to resolve the internal [[Class]] of values */
+ var toString = objectProto.toString;
+
+ /** Used to detect if a method is native */
+ var reNative = RegExp('^' +
+ String(toString)
+ .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+ .replace(/toString| for [^\]]+/g, '.*?') + '$'
+ );
+
+ /** Native method shortcuts */
+ var ceil = Math.ceil,
+ clearTimeout = context.clearTimeout,
+ floor = Math.floor,
+ fnToString = Function.prototype.toString,
+ getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
+ hasOwnProperty = objectProto.hasOwnProperty,
+ push = arrayRef.push,
+ setTimeout = context.setTimeout,
+ splice = arrayRef.splice,
+ unshift = arrayRef.unshift;
+
+ /** Used to set meta data on functions */
+ var defineProperty = (function() {
+ // IE 8 only accepts DOM elements
+ try {
+ var o = {},
+ func = isNative(func = Object.defineProperty) && func,
+ result = func(o, o, o) && func;
+ } catch(e) { }
+ return result;
+ }());
+
+ /* Native method shortcuts for methods with the same name as other `lodash` methods */
+ var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate,
+ nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray,
+ nativeIsFinite = context.isFinite,
+ nativeIsNaN = context.isNaN,
+ nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys,
+ nativeMax = Math.max,
+ nativeMin = Math.min,
+ nativeParseInt = context.parseInt,
+ nativeRandom = Math.random;
+
+ /** Used to lookup a built-in constructor by [[Class]] */
+ var ctorByClass = {};
+ ctorByClass[arrayClass] = Array;
+ ctorByClass[boolClass] = Boolean;
+ ctorByClass[dateClass] = Date;
+ ctorByClass[funcClass] = Function;
+ ctorByClass[objectClass] = Object;
+ ctorByClass[numberClass] = Number;
+ ctorByClass[regexpClass] = RegExp;
+ ctorByClass[stringClass] = String;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object which wraps the given value to enable intuitive
+ * method chaining.
+ *
+ * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
+ * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,
+ * and `unshift`
+ *
+ * Chaining is supported in custom builds as long as the `value` method is
+ * implicitly or explicitly included in the build.
+ *
+ * The chainable wrapper functions are:
+ * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,
+ * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`,
+ * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`,
+ * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,
+ * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,
+ * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
+ * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`,
+ * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`,
+ * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`,
+ * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`,
+ * and `zip`
+ *
+ * The non-chainable wrapper functions are:
+ * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`,
+ * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`,
+ * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,
+ * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`,
+ * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`,
+ * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`,
+ * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`,
+ * `template`, `unescape`, `uniqueId`, and `value`
+ *
+ * The wrapper functions `first` and `last` return wrapped values when `n` is
+ * provided, otherwise they return unwrapped values.
+ *
+ * Explicit chaining can be enabled by using the `_.chain` method.
+ *
+ * @name _
+ * @constructor
+ * @category Chaining
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @returns {Object} Returns a `lodash` instance.
+ * @example
+ *
+ * var wrapped = _([1, 2, 3]);
+ *
+ * // returns an unwrapped value
+ * wrapped.reduce(function(sum, num) {
+ * return sum + num;
+ * });
+ * // => 6
+ *
+ * // returns a wrapped value
+ * var squares = wrapped.map(function(num) {
+ * return num * num;
+ * });
+ *
+ * _.isArray(squares);
+ * // => false
+ *
+ * _.isArray(squares.value());
+ * // => true
+ */
+ function lodash(value) {
+ // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor
+ return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))
+ ? value
+ : new lodashWrapper(value);
+ }
+
+ /**
+ * A fast path for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @param {boolean} chainAll A flag to enable chaining for all methods
+ * @returns {Object} Returns a `lodash` instance.
+ */
+ function lodashWrapper(value, chainAll) {
+ this.__chain__ = !!chainAll;
+ this.__wrapped__ = value;
+ }
+ // ensure `new lodashWrapper` is an instance of `lodash`
+ lodashWrapper.prototype = lodash.prototype;
+
+ /**
+ * An object used to flag environments features.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ var support = lodash.support = {};
+
+ /**
+ * Detect if functions can be decompiled by `Function#toString`
+ * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcDecomp = !isNative(context.WinRTError) && reThis.test(runInContext);
+
+ /**
+ * Detect if `Function#name` is supported (all but IE).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcNames = typeof Function.name == 'string';
+
+ /**
+ * By default, the template delimiters used by Lo-Dash are similar to those in
+ * embedded Ruby (ERB). Change the following template settings to use alternative
+ * delimiters.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ lodash.templateSettings = {
+
+ /**
+ * Used to detect `data` property values to be HTML-escaped.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'escape': /<%-([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect code to be evaluated.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'evaluate': /<%([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect `data` property values to inject.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'interpolate': reInterpolate,
+
+ /**
+ * Used to reference the data object in the template text.
+ *
+ * @memberOf _.templateSettings
+ * @type string
+ */
+ 'variable': '',
+
+ /**
+ * Used to import variables into the compiled template.
+ *
+ * @memberOf _.templateSettings
+ * @type Object
+ */
+ 'imports': {
+
+ /**
+ * A reference to the `lodash` function.
+ *
+ * @memberOf _.templateSettings.imports
+ * @type Function
+ */
+ '_': lodash
+ }
+ };
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The base implementation of `_.bind` that creates the bound function and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new bound function.
+ */
+ function baseBind(bindData) {
+ var func = bindData[0],
+ partialArgs = bindData[2],
+ thisArg = bindData[4];
+
+ function bound() {
+ // `Function#bind` spec
+ // http://es5.github.io/#x15.3.4.5
+ if (partialArgs) {
+ // avoid `arguments` object deoptimizations by using `slice` instead
+ // of `Array.prototype.slice.call` and not assigning `arguments` to a
+ // variable as a ternary expression
+ var args = slice(partialArgs);
+ push.apply(args, arguments);
+ }
+ // mimic the constructor's `return` behavior
+ // http://es5.github.io/#x13.2.2
+ if (this instanceof bound) {
+ // ensure `new bound` is an instance of `func`
+ var thisBinding = baseCreate(func.prototype),
+ result = func.apply(thisBinding, args || arguments);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisArg, args || arguments);
+ }
+ setBindData(bound, bindData);
+ return bound;
+ }
+
+ /**
+ * The base implementation of `_.clone` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep=false] Specify a deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates clones with source counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+ function baseClone(value, isDeep, callback, stackA, stackB) {
+ if (callback) {
+ var result = callback(value);
+ if (typeof result != 'undefined') {
+ return result;
+ }
+ }
+ // inspect [[Class]]
+ var isObj = isObject(value);
+ if (isObj) {
+ var className = toString.call(value);
+ if (!cloneableClasses[className]) {
+ return value;
+ }
+ var ctor = ctorByClass[className];
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ return new ctor(+value);
+
+ case numberClass:
+ case stringClass:
+ return new ctor(value);
+
+ case regexpClass:
+ result = ctor(value.source, reFlags.exec(value));
+ result.lastIndex = value.lastIndex;
+ return result;
+ }
+ } else {
+ return value;
+ }
+ var isArr = isArray(value);
+ if (isDeep) {
+ // check for circular references and return corresponding clone
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == value) {
+ return stackB[length];
+ }
+ }
+ result = isArr ? ctor(value.length) : {};
+ }
+ else {
+ result = isArr ? slice(value) : assign({}, value);
+ }
+ // add array properties assigned by `RegExp#exec`
+ if (isArr) {
+ if (hasOwnProperty.call(value, 'index')) {
+ result.index = value.index;
+ }
+ if (hasOwnProperty.call(value, 'input')) {
+ result.input = value.input;
+ }
+ }
+ // exit for shallow clone
+ if (!isDeep) {
+ return result;
+ }
+ // add the source value to the stack of traversed objects
+ // and associate it with its clone
+ stackA.push(value);
+ stackB.push(result);
+
+ // recursively populate clone (susceptible to call stack limits)
+ (isArr ? forEach : forOwn)(value, function(objValue, key) {
+ result[key] = baseClone(objValue, isDeep, callback, stackA, stackB);
+ });
+
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+ function baseCreate(prototype, properties) {
+ return isObject(prototype) ? nativeCreate(prototype) : {};
+ }
+ // fallback for browsers without `Object.create`
+ if (!nativeCreate) {
+ baseCreate = (function() {
+ function Object() {}
+ return function(prototype) {
+ if (isObject(prototype)) {
+ Object.prototype = prototype;
+ var result = new Object;
+ Object.prototype = null;
+ }
+ return result || context.Object();
+ };
+ }());
+ }
+
+ /**
+ * The base implementation of `_.createCallback` without support for creating
+ * "_.pluck" or "_.where" style callbacks.
+ *
+ * @private
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ */
+ function baseCreateCallback(func, thisArg, argCount) {
+ if (typeof func != 'function') {
+ return identity;
+ }
+ // exit early for no `thisArg` or already bound by `Function#bind`
+ if (typeof thisArg == 'undefined' || !('prototype' in func)) {
+ return func;
+ }
+ var bindData = func.__bindData__;
+ if (typeof bindData == 'undefined') {
+ if (support.funcNames) {
+ bindData = !func.name;
+ }
+ bindData = bindData || !support.funcDecomp;
+ if (!bindData) {
+ var source = fnToString.call(func);
+ if (!support.funcNames) {
+ bindData = !reFuncName.test(source);
+ }
+ if (!bindData) {
+ // checks if `func` references the `this` keyword and stores the result
+ bindData = reThis.test(source);
+ setBindData(func, bindData);
+ }
+ }
+ }
+ // exit early if there are no `this` references or `func` is bound
+ if (bindData === false || (bindData !== true && bindData[1] & 1)) {
+ return func;
+ }
+ switch (argCount) {
+ case 1: return function(value) {
+ return func.call(thisArg, value);
+ };
+ case 2: return function(a, b) {
+ return func.call(thisArg, a, b);
+ };
+ case 3: return function(value, index, collection) {
+ return func.call(thisArg, value, index, collection);
+ };
+ case 4: return function(accumulator, value, index, collection) {
+ return func.call(thisArg, accumulator, value, index, collection);
+ };
+ }
+ return bind(func, thisArg);
+ }
+
+ /**
+ * The base implementation of `createWrapper` that creates the wrapper and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new function.
+ */
+ function baseCreateWrapper(bindData) {
+ var func = bindData[0],
+ bitmask = bindData[1],
+ partialArgs = bindData[2],
+ partialRightArgs = bindData[3],
+ thisArg = bindData[4],
+ arity = bindData[5];
+
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ key = func;
+
+ function bound() {
+ var thisBinding = isBind ? thisArg : this;
+ if (partialArgs) {
+ var args = slice(partialArgs);
+ push.apply(args, arguments);
+ }
+ if (partialRightArgs || isCurry) {
+ args || (args = slice(arguments));
+ if (partialRightArgs) {
+ push.apply(args, partialRightArgs);
+ }
+ if (isCurry && args.length < arity) {
+ bitmask |= 16 & ~32;
+ return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
+ }
+ }
+ args || (args = arguments);
+ if (isBindKey) {
+ func = thisBinding[key];
+ }
+ if (this instanceof bound) {
+ thisBinding = baseCreate(func.prototype);
+ var result = func.apply(thisBinding, args);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisBinding, args);
+ }
+ setBindData(bound, bindData);
+ return bound;
+ }
+
+ /**
+ * The base implementation of `_.difference` that accepts a single array
+ * of values to exclude.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {Array} [values] The array of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ */
+ function baseDifference(array, values) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ isLarge = length >= largeArraySize && indexOf === baseIndexOf,
+ result = [];
+
+ if (isLarge) {
+ var cache = createCache(values);
+ if (cache) {
+ indexOf = cacheIndexOf;
+ values = cache;
+ } else {
+ isLarge = false;
+ }
+ }
+ while (++index < length) {
+ var value = array[index];
+ if (indexOf(values, value) < 0) {
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseObject(values);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.flatten` without support for callback
+ * shorthands or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {boolean} [isStrict=false] A flag to restrict flattening to arrays and `arguments` objects.
+ * @param {number} [fromIndex=0] The index to start from.
+ * @returns {Array} Returns a new flattened array.
+ */
+ function baseFlatten(array, isShallow, isStrict, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+
+ if (value && typeof value == 'object' && typeof value.length == 'number'
+ && (isArray(value) || isArguments(value))) {
+ // recursively flatten arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ value = baseFlatten(value, isShallow, isStrict);
+ }
+ var valIndex = -1,
+ valLength = value.length,
+ resIndex = result.length;
+
+ result.length += valLength;
+ while (++valIndex < valLength) {
+ result[resIndex++] = value[valIndex];
+ }
+ } else if (!isStrict) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.isEqual`, without support for `thisArg` binding,
+ * that allows partial "_.where" style comparisons.
+ *
+ * @private
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {Function} [isWhere=false] A flag to indicate performing partial comparisons.
+ * @param {Array} [stackA=[]] Tracks traversed `a` objects.
+ * @param {Array} [stackB=[]] Tracks traversed `b` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+ function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
+ // used to indicate that when comparing objects, `a` has at least the properties of `b`
+ if (callback) {
+ var result = callback(a, b);
+ if (typeof result != 'undefined') {
+ return !!result;
+ }
+ }
+ // exit early for identical values
+ if (a === b) {
+ // treat `+0` vs. `-0` as not equal
+ return a !== 0 || (1 / a == 1 / b);
+ }
+ var type = typeof a,
+ otherType = typeof b;
+
+ // exit early for unlike primitive values
+ if (a === a &&
+ !(a && objectTypes[type]) &&
+ !(b && objectTypes[otherType])) {
+ return false;
+ }
+ // exit early for `null` and `undefined` avoiding ES3's Function#call behavior
+ // http://es5.github.io/#x15.3.4.4
+ if (a == null || b == null) {
+ return a === b;
+ }
+ // compare [[Class]] names
+ var className = toString.call(a),
+ otherClass = toString.call(b);
+
+ if (className == argsClass) {
+ className = objectClass;
+ }
+ if (otherClass == argsClass) {
+ otherClass = objectClass;
+ }
+ if (className != otherClass) {
+ return false;
+ }
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ // coerce dates and booleans to numbers, dates to milliseconds and booleans
+ // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
+ return +a == +b;
+
+ case numberClass:
+ // treat `NaN` vs. `NaN` as equal
+ return (a != +a)
+ ? b != +b
+ // but treat `+0` vs. `-0` as not equal
+ : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+ case regexpClass:
+ case stringClass:
+ // coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
+ // treat string primitives and their corresponding object instances as equal
+ return a == String(b);
+ }
+ var isArr = className == arrayClass;
+ if (!isArr) {
+ // unwrap any `lodash` wrapped values
+ var aWrapped = hasOwnProperty.call(a, '__wrapped__'),
+ bWrapped = hasOwnProperty.call(b, '__wrapped__');
+
+ if (aWrapped || bWrapped) {
+ return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);
+ }
+ // exit for functions and DOM nodes
+ if (className != objectClass) {
+ return false;
+ }
+ // in older versions of Opera, `arguments` objects have `Array` constructors
+ var ctorA = a.constructor,
+ ctorB = b.constructor;
+
+ // non `Object` object instances with different constructors are not equal
+ if (ctorA != ctorB &&
+ !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
+ ('constructor' in a && 'constructor' in b)
+ ) {
+ return false;
+ }
+ }
+ // assume cyclic structures are equal
+ // the algorithm for detecting cyclic structures is adapted from ES 5.1
+ // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == a) {
+ return stackB[length] == b;
+ }
+ }
+ var size = 0;
+ result = true;
+
+ // add `a` and `b` to the stack of traversed objects
+ stackA.push(a);
+ stackB.push(b);
+
+ // recursively compare objects and arrays (susceptible to call stack limits)
+ if (isArr) {
+ // compare lengths to determine if a deep comparison is necessary
+ length = a.length;
+ size = b.length;
+ result = size == length;
+
+ if (result || isWhere) {
+ // deep compare the contents, ignoring non-numeric properties
+ while (size--) {
+ var index = length,
+ value = b[size];
+
+ if (isWhere) {
+ while (index--) {
+ if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ }
+ }
+ else {
+ // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+ // which, in this case, is more costly
+ forIn(b, function(value, key, b) {
+ if (hasOwnProperty.call(b, key)) {
+ // count the number of properties.
+ size++;
+ // deep compare each property value.
+ return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB));
+ }
+ });
+
+ if (result && !isWhere) {
+ // ensure both objects have the same number of properties
+ forIn(a, function(value, key, a) {
+ if (hasOwnProperty.call(a, key)) {
+ // `size` will be `-1` if `a` has more properties than `b`
+ return (result = --size > -1);
+ }
+ });
+ }
+ }
+ stackA.pop();
+ stackB.pop();
+
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.merge` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates values with source counterparts.
+ */
+ function baseMerge(object, source, callback, stackA, stackB) {
+ (isArray(source) ? forEach : forOwn)(source, function(source, key) {
+ var found,
+ isArr,
+ result = source,
+ value = object[key];
+
+ if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+ // avoid merging previously merged cyclic sources
+ var stackLength = stackA.length;
+ while (stackLength--) {
+ if ((found = stackA[stackLength] == source)) {
+ value = stackB[stackLength];
+ break;
+ }
+ }
+ if (!found) {
+ var isShallow;
+ if (callback) {
+ result = callback(value, source);
+ if ((isShallow = typeof result != 'undefined')) {
+ value = result;
+ }
+ }
+ if (!isShallow) {
+ value = isArr
+ ? (isArray(value) ? value : [])
+ : (isPlainObject(value) ? value : {});
+ }
+ // add `source` and associated `value` to the stack of traversed objects
+ stackA.push(source);
+ stackB.push(value);
+
+ // recursively merge objects and arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ baseMerge(value, source, callback, stackA, stackB);
+ }
+ }
+ }
+ else {
+ if (callback) {
+ result = callback(value, source);
+ if (typeof result == 'undefined') {
+ result = source;
+ }
+ }
+ if (typeof result != 'undefined') {
+ value = result;
+ }
+ }
+ object[key] = value;
+ });
+ }
+
+ /**
+ * The base implementation of `_.random` without argument juggling or support
+ * for returning floating-point numbers.
+ *
+ * @private
+ * @param {number} min The minimum possible value.
+ * @param {number} max The maximum possible value.
+ * @returns {number} Returns a random number.
+ */
+ function baseRandom(min, max) {
+ return min + floor(nativeRandom() * (max - min + 1));
+ }
+
+ /**
+ * The base implementation of `_.uniq` without support for callback shorthands
+ * or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function} [callback] The function called per iteration.
+ * @returns {Array} Returns a duplicate-value-free array.
+ */
+ function baseUniq(array, isSorted, callback) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ result = [];
+
+ var isLarge = !isSorted && length >= largeArraySize && indexOf === baseIndexOf,
+ seen = (callback || isLarge) ? getArray() : result;
+
+ if (isLarge) {
+ var cache = createCache(seen);
+ indexOf = cacheIndexOf;
+ seen = cache;
+ }
+ while (++index < length) {
+ var value = array[index],
+ computed = callback ? callback(value, index, array) : value;
+
+ if (isSorted
+ ? !index || seen[seen.length - 1] !== computed
+ : indexOf(seen, computed) < 0
+ ) {
+ if (callback || isLarge) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseArray(seen.array);
+ releaseObject(seen);
+ } else if (callback) {
+ releaseArray(seen);
+ }
+ return result;
+ }
+
+ /**
+ * Creates a function that aggregates a collection, creating an object composed
+ * of keys generated from the results of running each element of the collection
+ * through a callback. The given `setter` function sets the keys and values
+ * of the composed object.
+ *
+ * @private
+ * @param {Function} setter The setter function.
+ * @returns {Function} Returns the new aggregator function.
+ */
+ function createAggregator(setter) {
+ return function(collection, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ setter(result, value, callback(value, index, collection), collection);
+ }
+ } else {
+ forOwn(collection, function(value, key, collection) {
+ setter(result, value, callback(value, key, collection), collection);
+ });
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, either curries or invokes `func`
+ * with an optional `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of method flags to compose.
+ * The bitmask may be composed of the following flags:
+ * 1 - `_.bind`
+ * 2 - `_.bindKey`
+ * 4 - `_.curry`
+ * 8 - `_.curry` (bound)
+ * 16 - `_.partial`
+ * 32 - `_.partialRight`
+ * @param {Array} [partialArgs] An array of arguments to prepend to those
+ * provided to the new function.
+ * @param {Array} [partialRightArgs] An array of arguments to append to those
+ * provided to the new function.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new function.
+ */
+ function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ isPartial = bitmask & 16,
+ isPartialRight = bitmask & 32;
+
+ if (!isBindKey && !isFunction(func)) {
+ throw new TypeError;
+ }
+ if (isPartial && !partialArgs.length) {
+ bitmask &= ~16;
+ isPartial = partialArgs = false;
+ }
+ if (isPartialRight && !partialRightArgs.length) {
+ bitmask &= ~32;
+ isPartialRight = partialRightArgs = false;
+ }
+ var bindData = func && func.__bindData__;
+ if (bindData && bindData !== true) {
+ // clone `bindData`
+ bindData = slice(bindData);
+ if (bindData[2]) {
+ bindData[2] = slice(bindData[2]);
+ }
+ if (bindData[3]) {
+ bindData[3] = slice(bindData[3]);
+ }
+ // set `thisBinding` is not previously bound
+ if (isBind && !(bindData[1] & 1)) {
+ bindData[4] = thisArg;
+ }
+ // set if previously bound but not currently (subsequent curried functions)
+ if (!isBind && bindData[1] & 1) {
+ bitmask |= 8;
+ }
+ // set curried arity if not yet set
+ if (isCurry && !(bindData[1] & 4)) {
+ bindData[5] = arity;
+ }
+ // append partial left arguments
+ if (isPartial) {
+ push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+ }
+ // append partial right arguments
+ if (isPartialRight) {
+ unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+ }
+ // merge flags
+ bindData[1] |= bitmask;
+ return createWrapper.apply(null, bindData);
+ }
+ // fast path for `_.bind`
+ var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
+ return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
+ }
+
+ /**
+ * Used by `escape` to convert characters to HTML entities.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeHtmlChar(match) {
+ return htmlEscapes[match];
+ }
+
+ /**
+ * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
+ * customized, this method returns the custom method, otherwise it returns
+ * the `baseIndexOf` function.
+ *
+ * @private
+ * @returns {Function} Returns the "indexOf" function.
+ */
+ function getIndexOf() {
+ var result = (result = lodash.indexOf) === indexOf ? baseIndexOf : result;
+ return result;
+ }
+
+ /**
+ * Checks if `value` is a native function.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a native function, else `false`.
+ */
+ function isNative(value) {
+ return typeof value == 'function' && reNative.test(value);
+ }
+
+ /**
+ * Sets `this` binding data on a given function.
+ *
+ * @private
+ * @param {Function} func The function to set data on.
+ * @param {Array} value The data array to set.
+ */
+ var setBindData = !defineProperty ? noop : function(func, value) {
+ descriptor.value = value;
+ defineProperty(func, '__bindData__', descriptor);
+ descriptor.value = null;
+ };
+
+ /**
+ * A fallback implementation of `isPlainObject` which checks if a given value
+ * is an object created by the `Object` constructor, assuming objects created
+ * by the `Object` constructor have no inherited enumerable properties and that
+ * there are no `Object.prototype` extensions.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ */
+ function shimIsPlainObject(value) {
+ var ctor,
+ result;
+
+ // avoid non Object objects, `arguments` objects, and DOM elements
+ if (!(value && toString.call(value) == objectClass) ||
+ (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor))) {
+ return false;
+ }
+ // In most environments an object's own properties are iterated before
+ // its inherited properties. If the last iterated property is an object's
+ // own property then there are no inherited enumerable properties.
+ forIn(value, function(value, key) {
+ result = key;
+ });
+ return typeof result == 'undefined' || hasOwnProperty.call(value, result);
+ }
+
+ /**
+ * Used by `unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {string} match The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
+ */
+ function unescapeHtmlChar(match) {
+ return htmlUnescapes[match];
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Checks if `value` is an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`.
+ * @example
+ *
+ * (function() { return _.isArguments(arguments); })(1, 2, 3);
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+ function isArguments(value) {
+ return value && typeof value == 'object' && typeof value.length == 'number' &&
+ toString.call(value) == argsClass || false;
+ }
+
+ /**
+ * Checks if `value` is an array.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an array, else `false`.
+ * @example
+ *
+ * (function() { return _.isArray(arguments); })();
+ * // => false
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ */
+ var isArray = nativeIsArray || function(value) {
+ return value && typeof value == 'object' && typeof value.length == 'number' &&
+ toString.call(value) == arrayClass || false;
+ };
+
+ /**
+ * A fallback implementation of `Object.keys` which produces an array of the
+ * given object's own enumerable property names.
+ *
+ * @private
+ * @type Function
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ */
+ var shimKeys = function(object) {
+ var index, iterable = object, result = [];
+ if (!iterable) return result;
+ if (!(objectTypes[typeof object])) return result;
+ for (index in iterable) {
+ if (hasOwnProperty.call(iterable, index)) {
+ result.push(index);
+ }
+ }
+ return result
+ };
+
+ /**
+ * Creates an array composed of the own enumerable property names of an object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ * @example
+ *
+ * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
+ */
+ var keys = !nativeKeys ? shimKeys : function(object) {
+ if (!isObject(object)) {
+ return [];
+ }
+ return nativeKeys(object);
+ };
+
+ /**
+ * Used to convert characters to HTML entities:
+ *
+ * Though the `>` character is escaped for symmetry, characters like `>` and `/`
+ * don't require escaping in HTML and have no special meaning unless they're part
+ * of a tag or an unquoted attribute value.
+ * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
+ */
+ var htmlEscapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ /** Used to convert HTML entities to characters */
+ var htmlUnescapes = invert(htmlEscapes);
+
+ /** Used to match HTML entities and HTML characters */
+ var reEscapedHtml = RegExp('(' + keys(htmlUnescapes).join('|') + ')', 'g'),
+ reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object. Subsequent sources will overwrite property assignments of previous
+ * sources. If a callback is provided it will be executed to produce the
+ * assigned values. The callback is bound to `thisArg` and invoked with two
+ * arguments; (objectValue, sourceValue).
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @alias extend
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param {Function} [callback] The function to customize assigning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * _.assign({ 'name': 'fred' }, { 'employer': 'slate' });
+ * // => { 'name': 'fred', 'employer': 'slate' }
+ *
+ * var defaults = _.partialRight(_.assign, function(a, b) {
+ * return typeof a == 'undefined' ? b : a;
+ * });
+ *
+ * var object = { 'name': 'barney' };
+ * defaults(object, { 'name': 'fred', 'employer': 'slate' });
+ * // => { 'name': 'barney', 'employer': 'slate' }
+ */
+ var assign = function(object, source, guard) {
+ var index, iterable = object, result = iterable;
+ if (!iterable) return result;
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = typeof guard == 'number' ? 2 : args.length;
+ if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
+ var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);
+ } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
+ callback = args[--argsLength];
+ }
+ while (++argsIndex < argsLength) {
+ iterable = args[argsIndex];
+ if (iterable && objectTypes[typeof iterable]) {
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ result[index] = callback ? callback(result[index], iterable[index]) : iterable[index];
+ }
+ }
+ }
+ return result
+ };
+
+ /**
+ * Creates a clone of `value`. If `isDeep` is `true` nested objects will also
+ * be cloned, otherwise they will be assigned by reference. If a callback
+ * is provided it will be executed to produce the cloned values. If the
+ * callback returns `undefined` cloning will be handled by the method instead.
+ * The callback is bound to `thisArg` and invoked with one argument; (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep=false] Specify a deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the cloned value.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * var shallow = _.clone(characters);
+ * shallow[0] === characters[0];
+ * // => true
+ *
+ * var deep = _.clone(characters, true);
+ * deep[0] === characters[0];
+ * // => false
+ *
+ * _.mixin({
+ * 'clone': _.partialRight(_.clone, function(value) {
+ * return _.isElement(value) ? value.cloneNode(false) : undefined;
+ * })
+ * });
+ *
+ * var clone = _.clone(document.body);
+ * clone.childNodes.length;
+ * // => 0
+ */
+ function clone(value, isDeep, callback, thisArg) {
+ // allows working with "Collections" methods without using their `index`
+ // and `collection` arguments for `isDeep` and `callback`
+ if (typeof isDeep != 'boolean' && isDeep != null) {
+ thisArg = callback;
+ callback = isDeep;
+ isDeep = false;
+ }
+ return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
+ }
+
+ /**
+ * Creates a deep clone of `value`. If a callback is provided it will be
+ * executed to produce the cloned values. If the callback returns `undefined`
+ * cloning will be handled by the method instead. The callback is bound to
+ * `thisArg` and invoked with one argument; (value).
+ *
+ * Note: This method is loosely based on the structured clone algorithm. Functions
+ * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
+ * objects created by constructors other than `Object` are cloned to plain `Object` objects.
+ * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the deep cloned value.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * var deep = _.cloneDeep(characters);
+ * deep[0] === characters[0];
+ * // => false
+ *
+ * var view = {
+ * 'label': 'docs',
+ * 'node': element
+ * };
+ *
+ * var clone = _.cloneDeep(view, function(value) {
+ * return _.isElement(value) ? value.cloneNode(true) : undefined;
+ * });
+ *
+ * clone.node == view.node;
+ * // => false
+ */
+ function cloneDeep(value, callback, thisArg) {
+ return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
+ }
+
+ /**
+ * Creates an object that inherits from the given `prototype` object. If a
+ * `properties` object is provided its own enumerable properties are assigned
+ * to the created object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} prototype The object to inherit from.
+ * @param {Object} [properties] The properties to assign to the object.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * function Circle() {
+ * Shape.call(this);
+ * }
+ *
+ * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle });
+ *
+ * var circle = new Circle;
+ * circle instanceof Circle;
+ * // => true
+ *
+ * circle instanceof Shape;
+ * // => true
+ */
+ function create(prototype, properties) {
+ var result = baseCreate(prototype);
+ return properties ? assign(result, properties) : result;
+ }
+
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object for all destination properties that resolve to `undefined`. Once a
+ * property is set, additional defaults of the same property will be ignored.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param- {Object} [guard] Allows working with `_.reduce` without using its
+ * `key` and `object` arguments as sources.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var object = { 'name': 'barney' };
+ * _.defaults(object, { 'name': 'fred', 'employer': 'slate' });
+ * // => { 'name': 'barney', 'employer': 'slate' }
+ */
+ var defaults = function(object, source, guard) {
+ var index, iterable = object, result = iterable;
+ if (!iterable) return result;
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = typeof guard == 'number' ? 2 : args.length;
+ while (++argsIndex < argsLength) {
+ iterable = args[argsIndex];
+ if (iterable && objectTypes[typeof iterable]) {
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ if (typeof result[index] == 'undefined') result[index] = iterable[index];
+ }
+ }
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.findIndex` except that it returns the key of the
+ * first element that passes the callback check, instead of the element itself.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @param {Function|Object|string} [callback=identity] The function called per
+ * iteration. If a property name or object is provided it will be used to
+ * create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * var characters = {
+ * 'barney': { 'age': 36, 'blocked': false },
+ * 'fred': { 'age': 40, 'blocked': true },
+ * 'pebbles': { 'age': 1, 'blocked': false }
+ * };
+ *
+ * _.findKey(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => 'barney' (property order is not guaranteed across environments)
+ *
+ * // using "_.where" callback shorthand
+ * _.findKey(characters, { 'age': 1 });
+ * // => 'pebbles'
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findKey(characters, 'blocked');
+ * // => 'fred'
+ */
+ function findKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * This method is like `_.findKey` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @param {Function|Object|string} [callback=identity] The function called per
+ * iteration. If a property name or object is provided it will be used to
+ * create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * var characters = {
+ * 'barney': { 'age': 36, 'blocked': true },
+ * 'fred': { 'age': 40, 'blocked': false },
+ * 'pebbles': { 'age': 1, 'blocked': true }
+ * };
+ *
+ * _.findLastKey(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => returns `pebbles`, assuming `_.findKey` returns `barney`
+ *
+ * // using "_.where" callback shorthand
+ * _.findLastKey(characters, { 'age': 40 });
+ * // => 'fred'
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findLastKey(characters, 'blocked');
+ * // => 'pebbles'
+ */
+ function findLastKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwnRight(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over own and inherited enumerable properties of an object,
+ * executing the callback for each property. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, key, object). Callbacks may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * Shape.prototype.move = function(x, y) {
+ * this.x += x;
+ * this.y += y;
+ * };
+ *
+ * _.forIn(new Shape, function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments)
+ */
+ var forIn = function(collection, callback, thisArg) {
+ var index, iterable = collection, result = iterable;
+ if (!iterable) return result;
+ if (!objectTypes[typeof iterable]) return result;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ for (index in iterable) {
+ if (callback(iterable[index], index, collection) === false) return result;
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.forIn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * Shape.prototype.move = function(x, y) {
+ * this.x += x;
+ * this.y += y;
+ * };
+ *
+ * _.forInRight(new Shape, function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move'
+ */
+ function forInRight(object, callback, thisArg) {
+ var pairs = [];
+
+ forIn(object, function(value, key) {
+ pairs.push(key, value);
+ });
+
+ var length = pairs.length;
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(pairs[length--], pairs[length], object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Iterates over own enumerable properties of an object, executing the callback
+ * for each property. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, key, object). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
+ */
+ var forOwn = function(collection, callback, thisArg) {
+ var index, iterable = collection, result = iterable;
+ if (!iterable) return result;
+ if (!objectTypes[typeof iterable]) return result;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ if (callback(iterable[index], index, collection) === false) return result;
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.forOwn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length'
+ */
+ function forOwnRight(object, callback, thisArg) {
+ var props = keys(object),
+ length = props.length;
+
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ var key = props[length];
+ if (callback(object[key], key, object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Creates a sorted array of property names of all enumerable properties,
+ * own and inherited, of `object` that have function values.
+ *
+ * @static
+ * @memberOf _
+ * @alias methods
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names that have function values.
+ * @example
+ *
+ * _.functions(_);
+ * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
+ */
+ function functions(object) {
+ var result = [];
+ forIn(object, function(value, key) {
+ if (isFunction(value)) {
+ result.push(key);
+ }
+ });
+ return result.sort();
+ }
+
+ /**
+ * Checks if the specified property name exists as a direct property of `object`,
+ * instead of an inherited property.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to check.
+ * @returns {boolean} Returns `true` if key is a direct property, else `false`.
+ * @example
+ *
+ * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+ * // => true
+ */
+ function has(object, key) {
+ return object ? hasOwnProperty.call(object, key) : false;
+ }
+
+ /**
+ * Creates an object composed of the inverted keys and values of the given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to invert.
+ * @returns {Object} Returns the created inverted object.
+ * @example
+ *
+ * _.invert({ 'first': 'fred', 'second': 'barney' });
+ * // => { 'fred': 'first', 'barney': 'second' }
+ */
+ function invert(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = {};
+
+ while (++index < length) {
+ var key = props[index];
+ result[object[key]] = key;
+ }
+ return result;
+ }
+
+ /**
+ * Checks if `value` is a boolean value.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`.
+ * @example
+ *
+ * _.isBoolean(null);
+ * // => false
+ */
+ function isBoolean(value) {
+ return value === true || value === false ||
+ value && typeof value == 'object' && toString.call(value) == boolClass || false;
+ }
+
+ /**
+ * Checks if `value` is a date.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a date, else `false`.
+ * @example
+ *
+ * _.isDate(new Date);
+ * // => true
+ */
+ function isDate(value) {
+ return value && typeof value == 'object' && toString.call(value) == dateClass || false;
+ }
+
+ /**
+ * Checks if `value` is a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ */
+ function isElement(value) {
+ return value && value.nodeType === 1 || false;
+ }
+
+ /**
+ * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
+ * length of `0` and objects with no own enumerable properties are considered
+ * "empty".
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object|string} value The value to inspect.
+ * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({});
+ * // => true
+ *
+ * _.isEmpty('');
+ * // => true
+ */
+ function isEmpty(value) {
+ var result = true;
+ if (!value) {
+ return result;
+ }
+ var className = toString.call(value),
+ length = value.length;
+
+ if ((className == arrayClass || className == stringClass || className == argsClass ) ||
+ (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
+ return !length;
+ }
+ forOwn(value, function() {
+ return (result = false);
+ });
+ return result;
+ }
+
+ /**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent to each other. If a callback is provided it will be executed
+ * to compare values. If the callback returns `undefined` comparisons will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (a, b).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var copy = { 'name': 'fred' };
+ *
+ * object == copy;
+ * // => false
+ *
+ * _.isEqual(object, copy);
+ * // => true
+ *
+ * var words = ['hello', 'goodbye'];
+ * var otherWords = ['hi', 'goodbye'];
+ *
+ * _.isEqual(words, otherWords, function(a, b) {
+ * var reGreet = /^(?:hello|hi)$/i,
+ * aGreet = _.isString(a) && reGreet.test(a),
+ * bGreet = _.isString(b) && reGreet.test(b);
+ *
+ * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
+ * });
+ * // => true
+ */
+ function isEqual(a, b, callback, thisArg) {
+ return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2));
+ }
+
+ /**
+ * Checks if `value` is, or can be coerced to, a finite number.
+ *
+ * Note: This is not the same as native `isFinite` which will return true for
+ * booleans and empty strings. See http://es5.github.io/#x15.1.2.5.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is finite, else `false`.
+ * @example
+ *
+ * _.isFinite(-101);
+ * // => true
+ *
+ * _.isFinite('10');
+ * // => true
+ *
+ * _.isFinite(true);
+ * // => false
+ *
+ * _.isFinite('');
+ * // => false
+ *
+ * _.isFinite(Infinity);
+ * // => false
+ */
+ function isFinite(value) {
+ return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
+ }
+
+ /**
+ * Checks if `value` is a function.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ */
+ function isFunction(value) {
+ return typeof value == 'function';
+ }
+
+ /**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(1);
+ * // => false
+ */
+ function isObject(value) {
+ // check if the value is the ECMAScript language type of Object
+ // http://es5.github.io/#x8
+ // and avoid a V8 bug
+ // http://code.google.com/p/v8/issues/detail?id=2291
+ return !!(value && objectTypes[typeof value]);
+ }
+
+ /**
+ * Checks if `value` is `NaN`.
+ *
+ * Note: This is not the same as native `isNaN` which will return `true` for
+ * `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`.
+ * @example
+ *
+ * _.isNaN(NaN);
+ * // => true
+ *
+ * _.isNaN(new Number(NaN));
+ * // => true
+ *
+ * isNaN(undefined);
+ * // => true
+ *
+ * _.isNaN(undefined);
+ * // => false
+ */
+ function isNaN(value) {
+ // `NaN` as a primitive is the only value that is not equal to itself
+ // (perform the [[Class]] check first to avoid errors with some host objects in IE)
+ return isNumber(value) && value != +value;
+ }
+
+ /**
+ * Checks if `value` is `null`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `null`, else `false`.
+ * @example
+ *
+ * _.isNull(null);
+ * // => true
+ *
+ * _.isNull(undefined);
+ * // => false
+ */
+ function isNull(value) {
+ return value === null;
+ }
+
+ /**
+ * Checks if `value` is a number.
+ *
+ * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a number, else `false`.
+ * @example
+ *
+ * _.isNumber(8.4 * 5);
+ * // => true
+ */
+ function isNumber(value) {
+ return typeof value == 'number' ||
+ value && typeof value == 'object' && toString.call(value) == numberClass || false;
+ }
+
+ /**
+ * Checks if `value` is an object created by the `Object` constructor.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * _.isPlainObject(new Shape);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ */
+ var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) {
+ if (!(value && toString.call(value) == objectClass)) {
+ return false;
+ }
+ var valueOf = value.valueOf,
+ objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
+
+ return objProto
+ ? (value == objProto || getPrototypeOf(value) == objProto)
+ : shimIsPlainObject(value);
+ };
+
+ /**
+ * Checks if `value` is a regular expression.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`.
+ * @example
+ *
+ * _.isRegExp(/fred/);
+ * // => true
+ */
+ function isRegExp(value) {
+ return value && typeof value == 'object' && toString.call(value) == regexpClass || false;
+ }
+
+ /**
+ * Checks if `value` is a string.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('fred');
+ * // => true
+ */
+ function isString(value) {
+ return typeof value == 'string' ||
+ value && typeof value == 'object' && toString.call(value) == stringClass || false;
+ }
+
+ /**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ */
+ function isUndefined(value) {
+ return typeof value == 'undefined';
+ }
+
+ /**
+ * Creates an object with the same keys as `object` and values generated by
+ * running each own enumerable property of `object` through the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new object with values of the results of each `callback` execution.
+ * @example
+ *
+ * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ *
+ * var characters = {
+ * 'fred': { 'name': 'fred', 'age': 40 },
+ * 'pebbles': { 'name': 'pebbles', 'age': 1 }
+ * };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.mapValues(characters, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 }
+ */
+ function mapValues(object, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ forOwn(object, function(value, key, object) {
+ result[key] = callback(value, key, object);
+ });
+ return result;
+ }
+
+ /**
+ * Recursively merges own enumerable properties of the source object(s), that
+ * don't resolve to `undefined` into the destination object. Subsequent sources
+ * will overwrite property assignments of previous sources. If a callback is
+ * provided it will be executed to produce the merged values of the destination
+ * and source properties. If the callback returns `undefined` merging will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (objectValue, sourceValue).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var names = {
+ * 'characters': [
+ * { 'name': 'barney' },
+ * { 'name': 'fred' }
+ * ]
+ * };
+ *
+ * var ages = {
+ * 'characters': [
+ * { 'age': 36 },
+ * { 'age': 40 }
+ * ]
+ * };
+ *
+ * _.merge(names, ages);
+ * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] }
+ *
+ * var food = {
+ * 'fruits': ['apple'],
+ * 'vegetables': ['beet']
+ * };
+ *
+ * var otherFood = {
+ * 'fruits': ['banana'],
+ * 'vegetables': ['carrot']
+ * };
+ *
+ * _.merge(food, otherFood, function(a, b) {
+ * return _.isArray(a) ? a.concat(b) : undefined;
+ * });
+ * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
+ */
+ function merge(object) {
+ var args = arguments,
+ length = 2;
+
+ if (!isObject(object)) {
+ return object;
+ }
+ // allows working with `_.reduce` and `_.reduceRight` without using
+ // their `index` and `collection` arguments
+ if (typeof args[2] != 'number') {
+ length = args.length;
+ }
+ if (length > 3 && typeof args[length - 2] == 'function') {
+ var callback = baseCreateCallback(args[--length - 1], args[length--], 2);
+ } else if (length > 2 && typeof args[length - 1] == 'function') {
+ callback = args[--length];
+ }
+ var sources = slice(arguments, 1, length),
+ index = -1,
+ stackA = getArray(),
+ stackB = getArray();
+
+ while (++index < length) {
+ baseMerge(object, sources[index], callback, stackA, stackB);
+ }
+ releaseArray(stackA);
+ releaseArray(stackB);
+ return object;
+ }
+
+ /**
+ * Creates a shallow clone of `object` excluding the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` omitting the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|...string|string[]} [callback] The properties to omit or the
+ * function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object without the omitted properties.
+ * @example
+ *
+ * _.omit({ 'name': 'fred', 'age': 40 }, 'age');
+ * // => { 'name': 'fred' }
+ *
+ * _.omit({ 'name': 'fred', 'age': 40 }, function(value) {
+ * return typeof value == 'number';
+ * });
+ * // => { 'name': 'fred' }
+ */
+ function omit(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var props = [];
+ forIn(object, function(value, key) {
+ props.push(key);
+ });
+ props = baseDifference(props, baseFlatten(arguments, true, false, 1));
+
+ var index = -1,
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+ result[key] = object[key];
+ }
+ } else {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forIn(object, function(value, key, object) {
+ if (!callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates a two dimensional array of an object's key-value pairs,
+ * i.e. `[[key1, value1], [key2, value2]]`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns new array of key-value pairs.
+ * @example
+ *
+ * _.pairs({ 'barney': 36, 'fred': 40 });
+ * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments)
+ */
+ function pairs(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = Array(length);
+
+ while (++index < length) {
+ var key = props[index];
+ result[index] = [key, object[key]];
+ }
+ return result;
+ }
+
+ /**
+ * Creates a shallow clone of `object` composed of the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` picking the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|...string|string[]} [callback] The function called per
+ * iteration or property names to pick, specified as individual property
+ * names or arrays of property names.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object composed of the picked properties.
+ * @example
+ *
+ * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name');
+ * // => { 'name': 'fred' }
+ *
+ * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) {
+ * return key.charAt(0) != '_';
+ * });
+ * // => { 'name': 'fred' }
+ */
+ function pick(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var index = -1,
+ props = baseFlatten(arguments, true, false, 1),
+ length = isObject(object) ? props.length : 0;
+
+ while (++index < length) {
+ var key = props[index];
+ if (key in object) {
+ result[key] = object[key];
+ }
+ }
+ } else {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forIn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * An alternative to `_.reduce` this method transforms `object` to a new
+ * `accumulator` object which is the result of running each of its own
+ * enumerable properties through a callback, with each callback execution
+ * potentially mutating the `accumulator` object. The callback is bound to
+ * `thisArg` and invoked with four arguments; (accumulator, value, key, object).
+ * Callbacks may exit iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] The custom accumulator value.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {
+ * num *= num;
+ * if (num % 2) {
+ * return result.push(num) < 3;
+ * }
+ * });
+ * // => [1, 9, 25]
+ *
+ * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+ * result[key] = num * 3;
+ * });
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ */
+ function transform(object, callback, accumulator, thisArg) {
+ var isArr = isArray(object);
+ if (accumulator == null) {
+ if (isArr) {
+ accumulator = [];
+ } else {
+ var ctor = object && object.constructor,
+ proto = ctor && ctor.prototype;
+
+ accumulator = baseCreate(proto);
+ }
+ }
+ if (callback) {
+ callback = lodash.createCallback(callback, thisArg, 4);
+ (isArr ? forEach : forOwn)(object, function(value, index, object) {
+ return callback(accumulator, value, index, object);
+ });
+ }
+ return accumulator;
+ }
+
+ /**
+ * Creates an array composed of the own enumerable property values of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property values.
+ * @example
+ *
+ * _.values({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => [1, 2, 3] (property order is not guaranteed across environments)
+ */
+ function values(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = object[props[index]];
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array of elements from the specified indexes, or keys, of the
+ * `collection`. Indexes may be specified as individual arguments or as arrays
+ * of indexes.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {...(number|number[]|string|string[])} [index] The indexes of `collection`
+ * to retrieve, specified as individual indexes or arrays of indexes.
+ * @returns {Array} Returns a new array of elements corresponding to the
+ * provided indexes.
+ * @example
+ *
+ * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+ * // => ['a', 'c', 'e']
+ *
+ * _.at(['fred', 'barney', 'pebbles'], 0, 2);
+ * // => ['fred', 'pebbles']
+ */
+ function at(collection) {
+ var args = arguments,
+ index = -1,
+ props = baseFlatten(args, true, false, 1),
+ length = (args[2] && args[2][args[1]] === collection) ? 1 : props.length,
+ result = Array(length);
+
+ while(++index < length) {
+ result[index] = collection[props[index]];
+ }
+ return result;
+ }
+
+ /**
+ * Checks if a given value is present in a collection using strict equality
+ * for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the
+ * offset from the end of the collection.
+ *
+ * @static
+ * @memberOf _
+ * @alias include
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {*} target The value to check for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {boolean} Returns `true` if the `target` element is found, else `false`.
+ * @example
+ *
+ * _.contains([1, 2, 3], 1);
+ * // => true
+ *
+ * _.contains([1, 2, 3], 1, 2);
+ * // => false
+ *
+ * _.contains({ 'name': 'fred', 'age': 40 }, 'fred');
+ * // => true
+ *
+ * _.contains('pebbles', 'eb');
+ * // => true
+ */
+ function contains(collection, target, fromIndex) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = collection ? collection.length : 0,
+ result = false;
+
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
+ if (isArray(collection)) {
+ result = indexOf(collection, target, fromIndex) > -1;
+ } else if (typeof length == 'number') {
+ result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1;
+ } else {
+ forOwn(collection, function(value) {
+ if (++index >= fromIndex) {
+ return !(result = value === target);
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` through the callback. The corresponding value
+ * of each key is the number of times the key was returned by the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy(['one', 'two', 'three'], 'length');
+ * // => { '3': 2, '5': 1 }
+ */
+ var countBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+ });
+
+ /**
+ * Checks if the given callback returns truey value for **all** elements of
+ * a collection. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias all
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if all elements passed the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.every([true, 1, null, 'yes']);
+ * // => false
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.every(characters, 'age');
+ * // => true
+ *
+ * // using "_.where" callback shorthand
+ * _.every(characters, { 'age': 36 });
+ * // => false
+ */
+ function every(collection, callback, thisArg) {
+ var result = true;
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if (!(result = !!callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ return (result = !!callback(value, index, collection));
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, returning an array of all elements
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias select
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that passed the callback check.
+ * @example
+ *
+ * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [2, 4, 6]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.filter(characters, 'blocked');
+ * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
+ *
+ * // using "_.where" callback shorthand
+ * _.filter(characters, { 'age': 36 });
+ * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
+ */
+ function filter(collection, callback, thisArg) {
+ var result = [];
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, returning the first element that
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias detect, findWhere
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ * ];
+ *
+ * _.find(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => { 'name': 'barney', 'age': 36, 'blocked': false }
+ *
+ * // using "_.where" callback shorthand
+ * _.find(characters, { 'age': 1 });
+ * // => { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ *
+ * // using "_.pluck" callback shorthand
+ * _.find(characters, 'blocked');
+ * // => { 'name': 'fred', 'age': 40, 'blocked': true }
+ */
+ function find(collection, callback, thisArg) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ if (callback(value, index, collection)) {
+ return value;
+ }
+ }
+ } else {
+ var result;
+ forOwn(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+ }
+
+ /**
+ * This method is like `_.find` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * _.findLast([1, 2, 3, 4], function(num) {
+ * return num % 2 == 1;
+ * });
+ * // => 3
+ */
+ function findLast(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forEachRight(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, executing the callback for each
+ * element. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * Note: As with other "Collections" methods, objects with a `length` property
+ * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
+ * may be used for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @alias each
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');
+ * // => logs each number and returns '1,2,3'
+ *
+ * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+ * // => logs each number and returns the object (property order is not guaranteed across environments)
+ */
+ function forEach(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if (callback(collection[index], index, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, callback);
+ }
+ return collection;
+ }
+
+ /**
+ * This method is like `_.forEach` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias eachRight
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(',');
+ * // => logs each number from right to left and returns '3,2,1'
+ */
+ function forEachRight(collection, callback, thisArg) {
+ var length = collection ? collection.length : 0;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ while (length--) {
+ if (callback(collection[length], length, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ var props = keys(collection);
+ length = props.length;
+ forOwn(collection, function(value, key, collection) {
+ key = props ? props[--length] : --length;
+ return callback(collection[key], key, collection);
+ });
+ }
+ return collection;
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of a collection through the callback. The corresponding value
+ * of each key is an array of the elements responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * // using "_.pluck" callback shorthand
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+ var groupBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+ });
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of the collection through the given callback. The corresponding
+ * value of each key is the last element responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var keys = [
+ * { 'dir': 'left', 'code': 97 },
+ * { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.indexBy(keys, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String);
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ */
+ var indexBy = createAggregator(function(result, value, key) {
+ result[key] = value;
+ });
+
+ /**
+ * Invokes the method named by `methodName` on each element in the `collection`
+ * returning an array of the results of each invoked method. Additional arguments
+ * will be provided to each invoked method. If `methodName` is a function it
+ * will be invoked for, and `this` bound to, each element in the `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|string} methodName The name of the method to invoke or
+ * the function invoked per iteration.
+ * @param {...*} [arg] Arguments to invoke the method with.
+ * @returns {Array} Returns a new array of the results of each invoked method.
+ * @example
+ *
+ * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+ * // => [[1, 5, 7], [1, 2, 3]]
+ *
+ * _.invoke([123, 456], String.prototype.split, '');
+ * // => [['1', '2', '3'], ['4', '5', '6']]
+ */
+ function invoke(collection, methodName) {
+ var args = slice(arguments, 2),
+ index = -1,
+ isFunc = typeof methodName == 'function',
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ forEach(collection, function(value) {
+ result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);
+ });
+ return result;
+ }
+
+ /**
+ * Creates an array of values by running each element in the collection
+ * through the callback. The callback is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias collect
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of the results of each `callback` execution.
+ * @example
+ *
+ * _.map([1, 2, 3], function(num) { return num * 3; });
+ * // => [3, 6, 9]
+ *
+ * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+ * // => [3, 6, 9] (property order is not guaranteed across environments)
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.map(characters, 'name');
+ * // => ['barney', 'fred']
+ */
+ function map(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ var result = Array(length);
+ while (++index < length) {
+ result[index] = callback(collection[index], index, collection);
+ }
+ } else {
+ result = [];
+ forOwn(collection, function(value, key, collection) {
+ result[++index] = callback(value, key, collection);
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the maximum value of a collection. If the collection is empty or
+ * falsey `-Infinity` is returned. If a callback is provided it will be executed
+ * for each value in the collection to generate the criterion by which the value
+ * is ranked. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * _.max([4, 2, 8, 6]);
+ * // => 8
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.max(characters, function(chr) { return chr.age; });
+ * // => { 'name': 'fred', 'age': 40 };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.max(characters, 'age');
+ * // => { 'name': 'fred', 'age': 40 };
+ */
+ function max(collection, callback, thisArg) {
+ var computed = -Infinity,
+ result = computed;
+
+ // allows working with functions like `_.map` without using
+ // their `index` argument as a callback
+ if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
+ callback = null;
+ }
+ if (callback == null && isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ if (value > result) {
+ result = value;
+ }
+ }
+ } else {
+ callback = (callback == null && isString(collection))
+ ? charAtCallback
+ : lodash.createCallback(callback, thisArg, 3);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current > computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the minimum value of a collection. If the collection is empty or
+ * falsey `Infinity` is returned. If a callback is provided it will be executed
+ * for each value in the collection to generate the criterion by which the value
+ * is ranked. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * _.min([4, 2, 8, 6]);
+ * // => 2
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.min(characters, function(chr) { return chr.age; });
+ * // => { 'name': 'barney', 'age': 36 };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.min(characters, 'age');
+ * // => { 'name': 'barney', 'age': 36 };
+ */
+ function min(collection, callback, thisArg) {
+ var computed = Infinity,
+ result = computed;
+
+ // allows working with functions like `_.map` without using
+ // their `index` argument as a callback
+ if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
+ callback = null;
+ }
+ if (callback == null && isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ if (value < result) {
+ result = value;
+ }
+ }
+ } else {
+ callback = (callback == null && isString(collection))
+ ? charAtCallback
+ : lodash.createCallback(callback, thisArg, 3);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current < computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the value of a specified property from all elements in the collection.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {string} property The name of the property to pluck.
+ * @returns {Array} Returns a new array of property values.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.pluck(characters, 'name');
+ * // => ['barney', 'fred']
+ */
+ var pluck = map;
+
+ /**
+ * Reduces a collection to a value which is the accumulated result of running
+ * each element in the collection through the callback, where each successive
+ * callback execution consumes the return value of the previous execution. If
+ * `accumulator` is not provided the first element of the collection will be
+ * used as the initial `accumulator` value. The callback is bound to `thisArg`
+ * and invoked with four arguments; (accumulator, value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias foldl, inject
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var sum = _.reduce([1, 2, 3], function(sum, num) {
+ * return sum + num;
+ * });
+ * // => 6
+ *
+ * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+ * result[key] = num * 3;
+ * return result;
+ * }, {});
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ */
+ function reduce(collection, callback, accumulator, thisArg) {
+ if (!collection) return accumulator;
+ var noaccum = arguments.length < 3;
+ callback = lodash.createCallback(callback, thisArg, 4);
+
+ var index = -1,
+ length = collection.length;
+
+ if (typeof length == 'number') {
+ if (noaccum) {
+ accumulator = collection[++index];
+ }
+ while (++index < length) {
+ accumulator = callback(accumulator, collection[index], index, collection);
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection)
+ });
+ }
+ return accumulator;
+ }
+
+ /**
+ * This method is like `_.reduce` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias foldr
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var list = [[0, 1], [2, 3], [4, 5]];
+ * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+ * // => [4, 5, 2, 3, 0, 1]
+ */
+ function reduceRight(collection, callback, accumulator, thisArg) {
+ var noaccum = arguments.length < 3;
+ callback = lodash.createCallback(callback, thisArg, 4);
+ forEachRight(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The opposite of `_.filter` this method returns the elements of a
+ * collection that the callback does **not** return truey for.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that failed the callback check.
+ * @example
+ *
+ * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [1, 3, 5]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.reject(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
+ *
+ * // using "_.where" callback shorthand
+ * _.reject(characters, { 'age': 36 });
+ * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
+ */
+ function reject(collection, callback, thisArg) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ return filter(collection, function(value, index, collection) {
+ return !callback(value, index, collection);
+ });
+ }
+
+ /**
+ * Retrieves a random element or `n` random elements from a collection.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to sample.
+ * @param {number} [n] The number of elements to sample.
+ * @param- {Object} [guard] Allows working with functions like `_.map`
+ * without using their `index` arguments as `n`.
+ * @returns {Array} Returns the random sample(s) of `collection`.
+ * @example
+ *
+ * _.sample([1, 2, 3, 4]);
+ * // => 2
+ *
+ * _.sample([1, 2, 3, 4], 2);
+ * // => [3, 1]
+ */
+ function sample(collection, n, guard) {
+ if (collection && typeof collection.length != 'number') {
+ collection = values(collection);
+ }
+ if (n == null || guard) {
+ return collection ? collection[baseRandom(0, collection.length - 1)] : undefined;
+ }
+ var result = shuffle(collection);
+ result.length = nativeMin(nativeMax(0, n), result.length);
+ return result;
+ }
+
+ /**
+ * Creates an array of shuffled values, using a version of the Fisher-Yates
+ * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to shuffle.
+ * @returns {Array} Returns a new shuffled collection.
+ * @example
+ *
+ * _.shuffle([1, 2, 3, 4, 5, 6]);
+ * // => [4, 1, 6, 3, 5, 2]
+ */
+ function shuffle(collection) {
+ var index = -1,
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ forEach(collection, function(value) {
+ var rand = baseRandom(0, ++index);
+ result[index] = result[rand];
+ result[rand] = value;
+ });
+ return result;
+ }
+
+ /**
+ * Gets the size of the `collection` by returning `collection.length` for arrays
+ * and array-like objects or the number of own enumerable properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns `collection.length` or number of own enumerable properties.
+ * @example
+ *
+ * _.size([1, 2]);
+ * // => 2
+ *
+ * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => 3
+ *
+ * _.size('pebbles');
+ * // => 7
+ */
+ function size(collection) {
+ var length = collection ? collection.length : 0;
+ return typeof length == 'number' ? length : keys(collection).length;
+ }
+
+ /**
+ * Checks if the callback returns a truey value for **any** element of a
+ * collection. The function returns as soon as it finds a passing value and
+ * does not iterate over the entire collection. The callback is bound to
+ * `thisArg` and invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias any
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if any element passed the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false], Boolean);
+ * // => true
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.some(characters, 'blocked');
+ * // => true
+ *
+ * // using "_.where" callback shorthand
+ * _.some(characters, { 'age': 1 });
+ * // => false
+ */
+ function some(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if ((result = callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ return !(result = callback(value, index, collection));
+ });
+ }
+ return !!result;
+ }
+
+ /**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection through the callback. This method
+ * performs a stable sort, that is, it will preserve the original sort order
+ * of equal elements. The callback is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an array of property names is provided for `callback` the collection
+ * will be sorted by each property value.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Array|Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of sorted elements.
+ * @example
+ *
+ * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+ * // => [3, 1, 2]
+ *
+ * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+ * // => [3, 1, 2]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 26 },
+ * { 'name': 'fred', 'age': 30 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.map(_.sortBy(characters, 'age'), _.values);
+ * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]]
+ *
+ * // sorting by multiple properties
+ * _.map(_.sortBy(characters, ['name', 'age']), _.values);
+ * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]]
+ */
+ function sortBy(collection, callback, thisArg) {
+ var index = -1,
+ isArr = isArray(callback),
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ if (!isArr) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ }
+ forEach(collection, function(value, key, collection) {
+ var object = result[++index] = getObject();
+ if (isArr) {
+ object.criteria = map(callback, function(key) { return value[key]; });
+ } else {
+ (object.criteria = getArray())[0] = callback(value, key, collection);
+ }
+ object.index = index;
+ object.value = value;
+ });
+
+ length = result.length;
+ result.sort(compareAscending);
+ while (length--) {
+ var object = result[length];
+ result[length] = object.value;
+ if (!isArr) {
+ releaseArray(object.criteria);
+ }
+ releaseObject(object);
+ }
+ return result;
+ }
+
+ /**
+ * Converts the `collection` to an array.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to convert.
+ * @returns {Array} Returns the new converted array.
+ * @example
+ *
+ * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+ * // => [2, 3, 4]
+ */
+ function toArray(collection) {
+ if (collection && typeof collection.length == 'number') {
+ return slice(collection);
+ }
+ return values(collection);
+ }
+
+ /**
+ * Performs a deep comparison of each element in a `collection` to the given
+ * `properties` object, returning an array of all elements that have equivalent
+ * property values.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Object} props The object of property values to filter by.
+ * @returns {Array} Returns a new array of elements that have the given properties.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] },
+ * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
+ * ];
+ *
+ * _.where(characters, { 'age': 36 });
+ * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }]
+ *
+ * _.where(characters, { 'pets': ['dino'] });
+ * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }]
+ */
+ var where = filter;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are all falsey.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+ function compact(array) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (value) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array excluding all values of the provided arrays using strict
+ * equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {...Array} [values] The arrays of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+ * // => [1, 3, 4]
+ */
+ function difference(array) {
+ return baseDifference(array, baseFlatten(arguments, true, true, 1));
+ }
+
+ /**
+ * This method is like `_.find` except that it returns the index of the first
+ * element that passes the callback check, instead of the element itself.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ * ];
+ *
+ * _.findIndex(characters, function(chr) {
+ * return chr.age < 20;
+ * });
+ * // => 2
+ *
+ * // using "_.where" callback shorthand
+ * _.findIndex(characters, { 'age': 36 });
+ * // => 0
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findIndex(characters, 'blocked');
+ * // => 1
+ */
+ function findIndex(array, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length) {
+ if (callback(array[index], index, array)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * This method is like `_.findIndex` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': true },
+ * { 'name': 'fred', 'age': 40, 'blocked': false },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': true }
+ * ];
+ *
+ * _.findLastIndex(characters, function(chr) {
+ * return chr.age > 30;
+ * });
+ * // => 1
+ *
+ * // using "_.where" callback shorthand
+ * _.findLastIndex(characters, { 'age': 36 });
+ * // => 0
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findLastIndex(characters, 'blocked');
+ * // => 2
+ */
+ function findLastIndex(array, callback, thisArg) {
+ var length = array ? array.length : 0;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(array[length], length, array)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Gets the first element or first `n` elements of an array. If a callback
+ * is provided elements at the beginning of the array are returned as long
+ * as the callback returns truey. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias head, take
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback] The function called
+ * per element or the number of elements to return. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the first element(s) of `array`.
+ * @example
+ *
+ * _.first([1, 2, 3]);
+ * // => 1
+ *
+ * _.first([1, 2, 3], 2);
+ * // => [1, 2]
+ *
+ * _.first([1, 2, 3], function(num) {
+ * return num < 3;
+ * });
+ * // => [1, 2]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.first(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }]
+ *
+ * // using "_.where" callback shorthand
+ * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name');
+ * // => ['barney', 'fred']
+ */
+ function first(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = -1;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[0] : undefined;
+ }
+ }
+ return slice(array, 0, nativeMin(nativeMax(0, n), length));
+ }
+
+ /**
+ * Flattens a nested array (the nesting can be to any depth). If `isShallow`
+ * is truey, the array will only be flattened a single level. If a callback
+ * is provided each element of the array is passed through the callback before
+ * flattening. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2], [3, [[4]]]]);
+ * // => [1, 2, 3, 4];
+ *
+ * _.flatten([1, [2], [3, [[4]]]], true);
+ * // => [1, 2, 3, [[4]]];
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] },
+ * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.flatten(characters, 'pets');
+ * // => ['hoppy', 'baby puss', 'dino']
+ */
+ function flatten(array, isShallow, callback, thisArg) {
+ // juggle arguments
+ if (typeof isShallow != 'boolean' && isShallow != null) {
+ thisArg = callback;
+ callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow;
+ isShallow = false;
+ }
+ if (callback != null) {
+ array = map(array, callback, thisArg);
+ }
+ return baseFlatten(array, isShallow);
+ }
+
+ /**
+ * Gets the index at which the first occurrence of `value` is found using
+ * strict equality for comparisons, i.e. `===`. If the array is already sorted
+ * providing `true` for `fromIndex` will run a faster binary search.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {boolean|number} [fromIndex=0] The index to search from or `true`
+ * to perform a binary search on a sorted array.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 1
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 4
+ *
+ * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+ * // => 2
+ */
+ function indexOf(array, value, fromIndex) {
+ if (typeof fromIndex == 'number') {
+ var length = array ? array.length : 0;
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0);
+ } else if (fromIndex) {
+ var index = sortedIndex(array, value);
+ return array[index] === value ? index : -1;
+ }
+ return baseIndexOf(array, value, fromIndex);
+ }
+
+ /**
+ * Gets all but the last element or last `n` elements of an array. If a
+ * callback is provided elements at the end of the array are excluded from
+ * the result as long as the callback returns truey. The callback is bound
+ * to `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback=1] The function called
+ * per element or the number of elements to exclude. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a slice of `array`.
+ * @example
+ *
+ * _.initial([1, 2, 3]);
+ * // => [1, 2]
+ *
+ * _.initial([1, 2, 3], 2);
+ * // => [1]
+ *
+ * _.initial([1, 2, 3], function(num) {
+ * return num > 1;
+ * });
+ * // => [1]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.initial(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }]
+ *
+ * // using "_.where" callback shorthand
+ * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name');
+ * // => ['barney', 'fred']
+ */
+ function initial(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = (callback == null || thisArg) ? 1 : callback || n;
+ }
+ return slice(array, 0, nativeMin(nativeMax(0, length - n), length));
+ }
+
+ /**
+ * Creates an array of unique values present in all provided arrays using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of shared values.
+ * @example
+ *
+ * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2]
+ */
+ function intersection() {
+ var args = [],
+ argsIndex = -1,
+ argsLength = arguments.length,
+ caches = getArray(),
+ indexOf = getIndexOf(),
+ trustIndexOf = indexOf === baseIndexOf,
+ seen = getArray();
+
+ while (++argsIndex < argsLength) {
+ var value = arguments[argsIndex];
+ if (isArray(value) || isArguments(value)) {
+ args.push(value);
+ caches.push(trustIndexOf && value.length >= largeArraySize &&
+ createCache(argsIndex ? args[argsIndex] : seen));
+ }
+ }
+ var array = args[0],
+ index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ outer:
+ while (++index < length) {
+ var cache = caches[0];
+ value = array[index];
+
+ if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) {
+ argsIndex = argsLength;
+ (cache || seen).push(value);
+ while (--argsIndex) {
+ cache = caches[argsIndex];
+ if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) {
+ continue outer;
+ }
+ }
+ result.push(value);
+ }
+ }
+ while (argsLength--) {
+ cache = caches[argsLength];
+ if (cache) {
+ releaseObject(cache);
+ }
+ }
+ releaseArray(caches);
+ releaseArray(seen);
+ return result;
+ }
+
+ /**
+ * Gets the last element or last `n` elements of an array. If a callback is
+ * provided elements at the end of the array are returned as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback] The function called
+ * per element or the number of elements to return. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the last element(s) of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ *
+ * _.last([1, 2, 3], 2);
+ * // => [2, 3]
+ *
+ * _.last([1, 2, 3], function(num) {
+ * return num > 1;
+ * });
+ * // => [2, 3]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.pluck(_.last(characters, 'blocked'), 'name');
+ * // => ['fred', 'pebbles']
+ *
+ * // using "_.where" callback shorthand
+ * _.last(characters, { 'employer': 'na' });
+ * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
+ */
+ function last(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[length - 1] : undefined;
+ }
+ }
+ return slice(array, nativeMax(0, length - n));
+ }
+
+ /**
+ * Gets the index at which the last occurrence of `value` is found using strict
+ * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+ * as the offset from the end of the collection.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 4
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 1
+ */
+ function lastIndexOf(array, value, fromIndex) {
+ var index = array ? array.length : 0;
+ if (typeof fromIndex == 'number') {
+ index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
+ }
+ while (index--) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Removes all provided values from the given array using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {...*} [value] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ * _.pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+ function pull(array) {
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = args.length,
+ length = array ? array.length : 0;
+
+ while (++argsIndex < argsLength) {
+ var index = -1,
+ value = args[argsIndex];
+ while (++index < length) {
+ if (array[index] === value) {
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ }
+ return array;
+ }
+
+ /**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * `start` up to but not including `end`. If `start` is less than `stop` a
+ * zero-length range is created unless a negative `step` is specified.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
+ * @returns {Array} Returns a new range array.
+ * @example
+ *
+ * _.range(4);
+ * // => [0, 1, 2, 3]
+ *
+ * _.range(1, 5);
+ * // => [1, 2, 3, 4]
+ *
+ * _.range(0, 20, 5);
+ * // => [0, 5, 10, 15]
+ *
+ * _.range(0, -4, -1);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.range(0);
+ * // => []
+ */
+ function range(start, end, step) {
+ start = +start || 0;
+ step = typeof step == 'number' ? step : (+step || 1);
+
+ if (end == null) {
+ end = start;
+ start = 0;
+ }
+ // use `Array(length)` so engines like Chakra and V8 avoid slower modes
+ // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+ var index = -1,
+ length = nativeMax(0, ceil((end - start) / (step || 1))),
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = start;
+ start += step;
+ }
+ return result;
+ }
+
+ /**
+ * Removes all elements from an array that the callback returns truey for
+ * and returns an array of removed elements. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of removed elements.
+ * @example
+ *
+ * var array = [1, 2, 3, 4, 5, 6];
+ * var evens = _.remove(array, function(num) { return num % 2 == 0; });
+ *
+ * console.log(array);
+ * // => [1, 3, 5]
+ *
+ * console.log(evens);
+ * // => [2, 4, 6]
+ */
+ function remove(array, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length) {
+ var value = array[index];
+ if (callback(value, index, array)) {
+ result.push(value);
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The opposite of `_.initial` this method gets all but the first element or
+ * first `n` elements of an array. If a callback function is provided elements
+ * at the beginning of the array are excluded from the result as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias drop, tail
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback=1] The function called
+ * per element or the number of elements to exclude. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a slice of `array`.
+ * @example
+ *
+ * _.rest([1, 2, 3]);
+ * // => [2, 3]
+ *
+ * _.rest([1, 2, 3], 2);
+ * // => [3]
+ *
+ * _.rest([1, 2, 3], function(num) {
+ * return num < 3;
+ * });
+ * // => [3]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.pluck(_.rest(characters, 'blocked'), 'name');
+ * // => ['fred', 'pebbles']
+ *
+ * // using "_.where" callback shorthand
+ * _.rest(characters, { 'employer': 'slate' });
+ * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
+ */
+ function rest(array, callback, thisArg) {
+ if (typeof callback != 'number' && callback != null) {
+ var n = 0,
+ index = -1,
+ length = array ? array.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);
+ }
+ return slice(array, n);
+ }
+
+ /**
+ * Uses a binary search to determine the smallest index at which a value
+ * should be inserted into a given sorted array in order to maintain the sort
+ * order of the array. If a callback is provided it will be executed for
+ * `value` and each element of `array` to compute their sort ranking. The
+ * callback is bound to `thisArg` and invoked with one argument; (value).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * _.sortedIndex([20, 30, 50], 40);
+ * // => 2
+ *
+ * // using "_.pluck" callback shorthand
+ * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+ * // => 2
+ *
+ * var dict = {
+ * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+ * };
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return dict.wordToNumber[word];
+ * });
+ * // => 2
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return this.wordToNumber[word];
+ * }, dict);
+ * // => 2
+ */
+ function sortedIndex(array, value, callback, thisArg) {
+ var low = 0,
+ high = array ? array.length : low;
+
+ // explicitly reference `identity` for better inlining in Firefox
+ callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity;
+ value = callback(value);
+
+ while (low < high) {
+ var mid = (low + high) >>> 1;
+ (callback(array[mid]) < value)
+ ? low = mid + 1
+ : high = mid;
+ }
+ return low;
+ }
+
+ /**
+ * Creates an array of unique values, in order, of the provided arrays using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of combined values.
+ * @example
+ *
+ * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2, 3, 5, 4]
+ */
+ function union() {
+ return baseUniq(baseFlatten(arguments, true, true));
+ }
+
+ /**
+ * Creates a duplicate-value-free version of an array using strict equality
+ * for comparisons, i.e. `===`. If the array is sorted, providing
+ * `true` for `isSorted` will use a faster algorithm. If a callback is provided
+ * each element of `array` is passed through the callback before uniqueness
+ * is computed. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias unique
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a duplicate-value-free array.
+ * @example
+ *
+ * _.uniq([1, 2, 1, 3, 1]);
+ * // => [1, 2, 3]
+ *
+ * _.uniq([1, 1, 2, 2, 3], true);
+ * // => [1, 2, 3]
+ *
+ * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); });
+ * // => ['A', 'b', 'C']
+ *
+ * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
+ * // => [1, 2.5, 3]
+ *
+ * // using "_.pluck" callback shorthand
+ * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+ function uniq(array, isSorted, callback, thisArg) {
+ // juggle arguments
+ if (typeof isSorted != 'boolean' && isSorted != null) {
+ thisArg = callback;
+ callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted;
+ isSorted = false;
+ }
+ if (callback != null) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ }
+ return baseUniq(array, isSorted, callback);
+ }
+
+ /**
+ * Creates an array excluding all provided values using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to filter.
+ * @param {...*} [value] The values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+ * // => [2, 3, 4]
+ */
+ function without(array) {
+ return baseDifference(array, slice(arguments, 1));
+ }
+
+ /**
+ * Creates an array that is the symmetric difference of the provided arrays.
+ * See http://en.wikipedia.org/wiki/Symmetric_difference.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of values.
+ * @example
+ *
+ * _.xor([1, 2, 3], [5, 2, 1, 4]);
+ * // => [3, 5, 4]
+ *
+ * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]);
+ * // => [1, 4, 5]
+ */
+ function xor() {
+ var index = -1,
+ length = arguments.length;
+
+ while (++index < length) {
+ var array = arguments[index];
+ if (isArray(array) || isArguments(array)) {
+ var result = result
+ ? baseUniq(baseDifference(result, array).concat(baseDifference(array, result)))
+ : array;
+ }
+ }
+ return result || [];
+ }
+
+ /**
+ * Creates an array of grouped elements, the first of which contains the first
+ * elements of the given arrays, the second of which contains the second
+ * elements of the given arrays, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @alias unzip
+ * @category Arrays
+ * @param {...Array} [array] Arrays to process.
+ * @returns {Array} Returns a new array of grouped elements.
+ * @example
+ *
+ * _.zip(['fred', 'barney'], [30, 40], [true, false]);
+ * // => [['fred', 30, true], ['barney', 40, false]]
+ */
+ function zip() {
+ var array = arguments.length > 1 ? arguments : arguments[0],
+ index = -1,
+ length = array ? max(pluck(array, 'length')) : 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = pluck(array, index);
+ }
+ return result;
+ }
+
+ /**
+ * Creates an object composed from arrays of `keys` and `values`. Provide
+ * either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`
+ * or two arrays, one of `keys` and one of corresponding `values`.
+ *
+ * @static
+ * @memberOf _
+ * @alias object
+ * @category Arrays
+ * @param {Array} keys The array of keys.
+ * @param {Array} [values=[]] The array of values.
+ * @returns {Object} Returns an object composed of the given keys and
+ * corresponding values.
+ * @example
+ *
+ * _.zipObject(['fred', 'barney'], [30, 40]);
+ * // => { 'fred': 30, 'barney': 40 }
+ */
+ function zipObject(keys, values) {
+ var index = -1,
+ length = keys ? keys.length : 0,
+ result = {};
+
+ if (!values && length && !isArray(keys[0])) {
+ values = [];
+ }
+ while (++index < length) {
+ var key = keys[index];
+ if (values) {
+ result[key] = values[index];
+ } else if (key) {
+ result[key[0]] = key[1];
+ }
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that executes `func`, with the `this` binding and
+ * arguments of the created function, only after being called `n` times.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {number} n The number of times the function must be called before
+ * `func` is executed.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var saves = ['profile', 'settings'];
+ *
+ * var done = _.after(saves.length, function() {
+ * console.log('Done saving!');
+ * });
+ *
+ * _.forEach(saves, function(type) {
+ * asyncSave({ 'type': type, 'complete': done });
+ * });
+ * // => logs 'Done saving!', after all saves have completed
+ */
+ function after(n, func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return function() {
+ if (--n < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with the `this`
+ * binding of `thisArg` and prepends any additional `bind` arguments to those
+ * provided to the bound function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to bind.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var func = function(greeting) {
+ * return greeting + ' ' + this.name;
+ * };
+ *
+ * func = _.bind(func, { 'name': 'fred' }, 'hi');
+ * func();
+ * // => 'hi fred'
+ */
+ function bind(func, thisArg) {
+ return arguments.length > 2
+ ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
+ : createWrapper(func, 1, null, null, thisArg);
+ }
+
+ /**
+ * Binds methods of an object to the object itself, overwriting the existing
+ * method. Method names may be specified as individual arguments or as arrays
+ * of method names. If no method names are provided all the function properties
+ * of `object` will be bound.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object to bind and assign the bound methods to.
+ * @param {...string} [methodName] The object method names to
+ * bind, specified as individual method names or arrays of method names.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var view = {
+ * 'label': 'docs',
+ * 'onClick': function() { console.log('clicked ' + this.label); }
+ * };
+ *
+ * _.bindAll(view);
+ * jQuery('#docs').on('click', view.onClick);
+ * // => logs 'clicked docs', when the button is clicked
+ */
+ function bindAll(object) {
+ var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object),
+ index = -1,
+ length = funcs.length;
+
+ while (++index < length) {
+ var key = funcs[index];
+ object[key] = createWrapper(object[key], 1, null, null, object);
+ }
+ return object;
+ }
+
+ /**
+ * Creates a function that, when called, invokes the method at `object[key]`
+ * and prepends any additional `bindKey` arguments to those provided to the bound
+ * function. This method differs from `_.bind` by allowing bound functions to
+ * reference methods that will be redefined or don't yet exist.
+ * See http://michaux.ca/articles/lazy-function-definition-pattern.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object the method belongs to.
+ * @param {string} key The key of the method.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var object = {
+ * 'name': 'fred',
+ * 'greet': function(greeting) {
+ * return greeting + ' ' + this.name;
+ * }
+ * };
+ *
+ * var func = _.bindKey(object, 'greet', 'hi');
+ * func();
+ * // => 'hi fred'
+ *
+ * object.greet = function(greeting) {
+ * return greeting + 'ya ' + this.name + '!';
+ * };
+ *
+ * func();
+ * // => 'hiya fred!'
+ */
+ function bindKey(object, key) {
+ return arguments.length > 2
+ ? createWrapper(key, 19, slice(arguments, 2), null, object)
+ : createWrapper(key, 3, null, null, object);
+ }
+
+ /**
+ * Creates a function that is the composition of the provided functions,
+ * where each function consumes the return value of the function that follows.
+ * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+ * Each function is executed with the `this` binding of the composed function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {...Function} [func] Functions to compose.
+ * @returns {Function} Returns the new composed function.
+ * @example
+ *
+ * var realNameMap = {
+ * 'pebbles': 'penelope'
+ * };
+ *
+ * var format = function(name) {
+ * name = realNameMap[name.toLowerCase()] || name;
+ * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+ * };
+ *
+ * var greet = function(formatted) {
+ * return 'Hiya ' + formatted + '!';
+ * };
+ *
+ * var welcome = _.compose(greet, format);
+ * welcome('pebbles');
+ * // => 'Hiya Penelope!'
+ */
+ function compose() {
+ var funcs = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ if (!isFunction(funcs[length])) {
+ throw new TypeError;
+ }
+ }
+ return function() {
+ var args = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ args = [funcs[length].apply(this, args)];
+ }
+ return args[0];
+ };
+ }
+
+ /**
+ * Creates a function which accepts one or more arguments of `func` that when
+ * invoked either executes `func` returning its result, if all `func` arguments
+ * have been provided, or returns a function that accepts one or more of the
+ * remaining `func` arguments, and so on. The arity of `func` can be specified
+ * if `func.length` is not sufficient.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to curry.
+ * @param {number} [arity=func.length] The arity of `func`.
+ * @returns {Function} Returns the new curried function.
+ * @example
+ *
+ * var curried = _.curry(function(a, b, c) {
+ * console.log(a + b + c);
+ * });
+ *
+ * curried(1)(2)(3);
+ * // => 6
+ *
+ * curried(1, 2)(3);
+ * // => 6
+ *
+ * curried(1, 2, 3);
+ * // => 6
+ */
+ function curry(func, arity) {
+ arity = typeof arity == 'number' ? arity : (+arity || func.length);
+ return createWrapper(func, 4, null, null, null, arity);
+ }
+
+ /**
+ * Creates a function that will delay the execution of `func` until after
+ * `wait` milliseconds have elapsed since the last time it was invoked.
+ * Provide an options object to indicate that `func` should be invoked on
+ * the leading and/or trailing edge of the `wait` timeout. Subsequent calls
+ * to the debounced function will return the result of the last `func` call.
+ *
+ * Note: If `leading` and `trailing` options are `true` `func` will be called
+ * on the trailing edge of the timeout only if the the debounced function is
+ * invoked more than once during the `wait` timeout.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to delay.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout.
+ * @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called.
+ * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // avoid costly calculations while the window size is in flux
+ * var lazyLayout = _.debounce(calculateLayout, 150);
+ * jQuery(window).on('resize', lazyLayout);
+ *
+ * // execute `sendMail` when the click event is fired, debouncing subsequent calls
+ * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
+ * 'leading': true,
+ * 'trailing': false
+ * });
+ *
+ * // ensure `batchLog` is executed once after 1 second of debounced calls
+ * var source = new EventSource('/stream');
+ * source.addEventListener('message', _.debounce(batchLog, 250, {
+ * 'maxWait': 1000
+ * }, false);
+ */
+ function debounce(func, wait, options) {
+ var args,
+ maxTimeoutId,
+ result,
+ stamp,
+ thisArg,
+ timeoutId,
+ trailingCall,
+ lastCalled = 0,
+ maxWait = false,
+ trailing = true;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ wait = nativeMax(0, wait) || 0;
+ if (options === true) {
+ var leading = true;
+ trailing = false;
+ } else if (isObject(options)) {
+ leading = options.leading;
+ maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0);
+ trailing = 'trailing' in options ? options.trailing : trailing;
+ }
+ var delayed = function() {
+ var remaining = wait - (now() - stamp);
+ if (remaining <= 0) {
+ if (maxTimeoutId) {
+ clearTimeout(maxTimeoutId);
+ }
+ var isCalled = trailingCall;
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (isCalled) {
+ lastCalled = now();
+ result = func.apply(thisArg, args);
+ if (!timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ }
+ } else {
+ timeoutId = setTimeout(delayed, remaining);
+ }
+ };
+
+ var maxDelayed = function() {
+ if (timeoutId) {
+ clearTimeout(timeoutId);
+ }
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (trailing || (maxWait !== wait)) {
+ lastCalled = now();
+ result = func.apply(thisArg, args);
+ if (!timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ }
+ };
+
+ return function() {
+ args = arguments;
+ stamp = now();
+ thisArg = this;
+ trailingCall = trailing && (timeoutId || !leading);
+
+ if (maxWait === false) {
+ var leadingCall = leading && !timeoutId;
+ } else {
+ if (!maxTimeoutId && !leading) {
+ lastCalled = stamp;
+ }
+ var remaining = maxWait - (stamp - lastCalled),
+ isCalled = remaining <= 0;
+
+ if (isCalled) {
+ if (maxTimeoutId) {
+ maxTimeoutId = clearTimeout(maxTimeoutId);
+ }
+ lastCalled = stamp;
+ result = func.apply(thisArg, args);
+ }
+ else if (!maxTimeoutId) {
+ maxTimeoutId = setTimeout(maxDelayed, remaining);
+ }
+ }
+ if (isCalled && timeoutId) {
+ timeoutId = clearTimeout(timeoutId);
+ }
+ else if (!timeoutId && wait !== maxWait) {
+ timeoutId = setTimeout(delayed, wait);
+ }
+ if (leadingCall) {
+ isCalled = true;
+ result = func.apply(thisArg, args);
+ }
+ if (isCalled && !timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Defers executing the `func` function until the current call stack has cleared.
+ * Additional arguments will be provided to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to defer.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.defer(function(text) { console.log(text); }, 'deferred');
+ * // logs 'deferred' after one or more milliseconds
+ */
+ function defer(func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var args = slice(arguments, 1);
+ return setTimeout(function() { func.apply(undefined, args); }, 1);
+ }
+
+ /**
+ * Executes the `func` function after `wait` milliseconds. Additional arguments
+ * will be provided to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay execution.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.delay(function(text) { console.log(text); }, 1000, 'later');
+ * // => logs 'later' after one second
+ */
+ function delay(func, wait) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var args = slice(arguments, 2);
+ return setTimeout(function() { func.apply(undefined, args); }, wait);
+ }
+
+ /**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided it will be used to determine the cache key for storing the result
+ * based on the arguments provided to the memoized function. By default, the
+ * first argument provided to the memoized function is used as the cache key.
+ * The `func` is executed with the `this` binding of the memoized function.
+ * The result cache is exposed as the `cache` property on the memoized function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] A function used to resolve the cache key.
+ * @returns {Function} Returns the new memoizing function.
+ * @example
+ *
+ * var fibonacci = _.memoize(function(n) {
+ * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ *
+ * fibonacci(9)
+ * // => 34
+ *
+ * var data = {
+ * 'fred': { 'name': 'fred', 'age': 40 },
+ * 'pebbles': { 'name': 'pebbles', 'age': 1 }
+ * };
+ *
+ * // modifying the result cache
+ * var get = _.memoize(function(name) { return data[name]; }, _.identity);
+ * get('pebbles');
+ * // => { 'name': 'pebbles', 'age': 1 }
+ *
+ * get.cache.pebbles.name = 'penelope';
+ * get('pebbles');
+ * // => { 'name': 'penelope', 'age': 1 }
+ */
+ function memoize(func, resolver) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var memoized = function() {
+ var cache = memoized.cache,
+ key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0];
+
+ return hasOwnProperty.call(cache, key)
+ ? cache[key]
+ : (cache[key] = func.apply(this, arguments));
+ }
+ memoized.cache = {};
+ return memoized;
+ }
+
+ /**
+ * Creates a function that is restricted to execute `func` once. Repeat calls to
+ * the function will return the value of the first call. The `func` is executed
+ * with the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // `initialize` executes `createApplication` once
+ */
+ function once(func) {
+ var ran,
+ result;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return function() {
+ if (ran) {
+ return result;
+ }
+ ran = true;
+ result = func.apply(this, arguments);
+
+ // clear the `func` variable so the function may be garbage collected
+ func = null;
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with any additional
+ * `partial` arguments prepended to those provided to the new function. This
+ * method is similar to `_.bind` except it does **not** alter the `this` binding.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var greet = function(greeting, name) { return greeting + ' ' + name; };
+ * var hi = _.partial(greet, 'hi');
+ * hi('fred');
+ * // => 'hi fred'
+ */
+ function partial(func) {
+ return createWrapper(func, 16, slice(arguments, 1));
+ }
+
+ /**
+ * This method is like `_.partial` except that `partial` arguments are
+ * appended to those provided to the new function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var defaultsDeep = _.partialRight(_.merge, _.defaults);
+ *
+ * var options = {
+ * 'variable': 'data',
+ * 'imports': { 'jq': $ }
+ * };
+ *
+ * defaultsDeep(options, _.templateSettings);
+ *
+ * options.variable
+ * // => 'data'
+ *
+ * options.imports
+ * // => { '_': _, 'jq': $ }
+ */
+ function partialRight(func) {
+ return createWrapper(func, 32, null, slice(arguments, 1));
+ }
+
+ /**
+ * Creates a function that, when executed, will only call the `func` function
+ * at most once per every `wait` milliseconds. Provide an options object to
+ * indicate that `func` should be invoked on the leading and/or trailing edge
+ * of the `wait` timeout. Subsequent calls to the throttled function will
+ * return the result of the last `func` call.
+ *
+ * Note: If `leading` and `trailing` options are `true` `func` will be called
+ * on the trailing edge of the timeout only if the the throttled function is
+ * invoked more than once during the `wait` timeout.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to throttle.
+ * @param {number} wait The number of milliseconds to throttle executions to.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // avoid excessively updating the position while scrolling
+ * var throttled = _.throttle(updatePosition, 100);
+ * jQuery(window).on('scroll', throttled);
+ *
+ * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes
+ * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
+ * 'trailing': false
+ * }));
+ */
+ function throttle(func, wait, options) {
+ var leading = true,
+ trailing = true;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ if (options === false) {
+ leading = false;
+ } else if (isObject(options)) {
+ leading = 'leading' in options ? options.leading : leading;
+ trailing = 'trailing' in options ? options.trailing : trailing;
+ }
+ debounceOptions.leading = leading;
+ debounceOptions.maxWait = wait;
+ debounceOptions.trailing = trailing;
+
+ return debounce(func, wait, debounceOptions);
+ }
+
+ /**
+ * Creates a function that provides `value` to the wrapper function as its
+ * first argument. Additional arguments provided to the function are appended
+ * to those provided to the wrapper function. The wrapper is executed with
+ * the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {*} value The value to wrap.
+ * @param {Function} wrapper The wrapper function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var p = _.wrap(_.escape, function(func, text) {
+ * return '<p>' + func(text) + '</p>';
+ * });
+ *
+ * p('Fred, Wilma, & Pebbles');
+ * // => '<p>Fred, Wilma, & Pebbles</p>'
+ */
+ function wrap(value, wrapper) {
+ return createWrapper(wrapper, 16, [value]);
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var getter = _.constant(object);
+ * getter() === object;
+ * // => true
+ */
+ function constant(value) {
+ return function() {
+ return value;
+ };
+ }
+
+ /**
+ * Produces a callback bound to an optional `thisArg`. If `func` is a property
+ * name the created callback will return the property value for a given element.
+ * If `func` is an object the created callback will return `true` for elements
+ * that contain the equivalent object properties, otherwise it will return `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // wrap to create custom callback shorthands
+ * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
+ * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
+ * return !match ? func(callback, thisArg) : function(object) {
+ * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
+ * };
+ * });
+ *
+ * _.filter(characters, 'age__gt38');
+ * // => [{ 'name': 'fred', 'age': 40 }]
+ */
+ function createCallback(func, thisArg, argCount) {
+ var type = typeof func;
+ if (func == null || type == 'function') {
+ return baseCreateCallback(func, thisArg, argCount);
+ }
+ // handle "_.pluck" style callback shorthands
+ if (type != 'object') {
+ return property(func);
+ }
+ var props = keys(func),
+ key = props[0],
+ a = func[key];
+
+ // handle "_.where" style callback shorthands
+ if (props.length == 1 && a === a && !isObject(a)) {
+ // fast path the common case of providing an object with a single
+ // property containing a primitive value
+ return function(object) {
+ var b = object[key];
+ return a === b && (a !== 0 || (1 / a == 1 / b));
+ };
+ }
+ return function(object) {
+ var length = props.length,
+ result = false;
+
+ while (length--) {
+ if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
+ break;
+ }
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding HTML entities.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escape('Fred, Wilma, & Pebbles');
+ * // => 'Fred, Wilma, & Pebbles'
+ */
+ function escape(string) {
+ return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
+ }
+
+ /**
+ * This method returns the first argument provided to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.identity(object) === object;
+ * // => true
+ */
+ function identity(value) {
+ return value;
+ }
+
+ /**
+ * Adds function properties of a source object to the destination object.
+ * If `object` is a function methods will be added to its prototype as well.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Function|Object} [object=lodash] object The destination object.
+ * @param {Object} source The object of functions to add.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.chain=true] Specify whether the functions added are chainable.
+ * @example
+ *
+ * function capitalize(string) {
+ * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+ * }
+ *
+ * _.mixin({ 'capitalize': capitalize });
+ * _.capitalize('fred');
+ * // => 'Fred'
+ *
+ * _('fred').capitalize().value();
+ * // => 'Fred'
+ *
+ * _.mixin({ 'capitalize': capitalize }, { 'chain': false });
+ * _('fred').capitalize();
+ * // => 'Fred'
+ */
+ function mixin(object, source, options) {
+ var chain = true,
+ methodNames = source && functions(source);
+
+ if (!source || (!options && !methodNames.length)) {
+ if (options == null) {
+ options = source;
+ }
+ ctor = lodashWrapper;
+ source = object;
+ object = lodash;
+ methodNames = functions(source);
+ }
+ if (options === false) {
+ chain = false;
+ } else if (isObject(options) && 'chain' in options) {
+ chain = options.chain;
+ }
+ var ctor = object,
+ isFunc = isFunction(ctor);
+
+ forEach(methodNames, function(methodName) {
+ var func = object[methodName] = source[methodName];
+ if (isFunc) {
+ ctor.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ value = this.__wrapped__,
+ args = [value];
+
+ push.apply(args, arguments);
+ var result = func.apply(object, args);
+ if (chain || chainAll) {
+ if (value === result && isObject(result)) {
+ return this;
+ }
+ result = new ctor(result);
+ result.__chain__ = chainAll;
+ }
+ return result;
+ };
+ }
+ });
+ }
+
+ /**
+ * Reverts the '_' variable to its previous value and returns a reference to
+ * the `lodash` function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @returns {Function} Returns the `lodash` function.
+ * @example
+ *
+ * var lodash = _.noConflict();
+ */
+ function noConflict() {
+ context._ = oldDash;
+ return this;
+ }
+
+ /**
+ * A no-operation function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.noop(object) === undefined;
+ * // => true
+ */
+ function noop() {
+ // no operation performed
+ }
+
+ /**
+ * Gets the number of milliseconds that have elapsed since the Unix epoch
+ * (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var stamp = _.now();
+ * _.defer(function() { console.log(_.now() - stamp); });
+ * // => logs the number of milliseconds it took for the deferred function to be called
+ */
+ var now = isNative(now = Date.now) && now || function() {
+ return new Date().getTime();
+ };
+
+ /**
+ * Converts the given value into an integer of the specified radix.
+ * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the
+ * `value` is a hexadecimal, in which case a `radix` of `16` is used.
+ *
+ * Note: This method avoids differences in native ES3 and ES5 `parseInt`
+ * implementations. See http://es5.github.io/#E.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} value The value to parse.
+ * @param {number} [radix] The radix used to interpret the value to parse.
+ * @returns {number} Returns the new integer value.
+ * @example
+ *
+ * _.parseInt('08');
+ * // => 8
+ */
+ var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {
+ // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt`
+ return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);
+ };
+
+ /**
+ * Creates a "_.pluck" style function, which returns the `key` value of a
+ * given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} key The name of the property to retrieve.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 36 }
+ * ];
+ *
+ * var getName = _.property('name');
+ *
+ * _.map(characters, getName);
+ * // => ['barney', 'fred']
+ *
+ * _.sortBy(characters, getName);
+ * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }]
+ */
+ function property(key) {
+ return function(object) {
+ return object[key];
+ };
+ }
+
+ /**
+ * Produces a random number between `min` and `max` (inclusive). If only one
+ * argument is provided a number between `0` and the given number will be
+ * returned. If `floating` is truey or either `min` or `max` are floats a
+ * floating-point number will be returned instead of an integer.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} [min=0] The minimum possible value.
+ * @param {number} [max=1] The maximum possible value.
+ * @param {boolean} [floating=false] Specify returning a floating-point number.
+ * @returns {number} Returns a random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+ function random(min, max, floating) {
+ var noMin = min == null,
+ noMax = max == null;
+
+ if (floating == null) {
+ if (typeof min == 'boolean' && noMax) {
+ floating = min;
+ min = 1;
+ }
+ else if (!noMax && typeof max == 'boolean') {
+ floating = max;
+ noMax = true;
+ }
+ }
+ if (noMin && noMax) {
+ max = 1;
+ }
+ min = +min || 0;
+ if (noMax) {
+ max = min;
+ min = 0;
+ } else {
+ max = +max || 0;
+ }
+ if (floating || min % 1 || max % 1) {
+ var rand = nativeRandom();
+ return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max);
+ }
+ return baseRandom(min, max);
+ }
+
+ /**
+ * Resolves the value of property `key` on `object`. If `key` is a function
+ * it will be invoked with the `this` binding of `object` and its result returned,
+ * else the property value is returned. If `object` is falsey then `undefined`
+ * is returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to resolve.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = {
+ * 'cheese': 'crumpets',
+ * 'stuff': function() {
+ * return 'nonsense';
+ * }
+ * };
+ *
+ * _.result(object, 'cheese');
+ * // => 'crumpets'
+ *
+ * _.result(object, 'stuff');
+ * // => 'nonsense'
+ */
+ function result(object, key) {
+ if (object) {
+ var value = object[key];
+ return isFunction(value) ? object[key]() : value;
+ }
+ }
+
+ /**
+ * A micro-templating method that handles arbitrary delimiters, preserves
+ * whitespace, and correctly escapes quotes within interpolated code.
+ *
+ * Note: In the development build, `_.template` utilizes sourceURLs for easier
+ * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ *
+ * For more information on precompiling templates see:
+ * https://lodash.com/custom-builds
+ *
+ * For more information on Chrome extension sandboxes see:
+ * http://developer.chrome.com/stable/extensions/sandboxingEval.html
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} text The template text.
+ * @param {Object} data The data object used to populate the text.
+ * @param {Object} [options] The options object.
+ * @param {RegExp} [options.escape] The "escape" delimiter.
+ * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
+ * @param {Object} [options.imports] An object to import into the template as local variables.
+ * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
+ * @param {string} [sourceURL] The sourceURL of the template's compiled source.
+ * @param {string} [variable] The data object variable name.
+ * @returns {Function|string} Returns a compiled function when no `data` object
+ * is given, else it returns the interpolated text.
+ * @example
+ *
+ * // using the "interpolate" delimiter to create a compiled template
+ * var compiled = _.template('hello <%= name %>');
+ * compiled({ 'name': 'fred' });
+ * // => 'hello fred'
+ *
+ * // using the "escape" delimiter to escape HTML in data property values
+ * _.template('<b><%- value %></b>', { 'value': '<script>' });
+ * // => '<b><script></b>'
+ *
+ * // using the "evaluate" delimiter to generate HTML
+ * var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
+ * _.template(list, { 'people': ['fred', 'barney'] });
+ * // => '<li>fred</li><li>barney</li>'
+ *
+ * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
+ * _.template('hello ${ name }', { 'name': 'pebbles' });
+ * // => 'hello pebbles'
+ *
+ * // using the internal `print` function in "evaluate" delimiters
+ * _.template('<% print("hello " + name); %>!', { 'name': 'barney' });
+ * // => 'hello barney!'
+ *
+ * // using a custom template delimiters
+ * _.templateSettings = {
+ * 'interpolate': /{{([\s\S]+?)}}/g
+ * };
+ *
+ * _.template('hello {{ name }}!', { 'name': 'mustache' });
+ * // => 'hello mustache!'
+ *
+ * // using the `imports` option to import jQuery
+ * var list = '<% jq.each(people, function(name) { %><li><%- name %></li><% }); %>';
+ * _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { 'jq': jQuery } });
+ * // => '<li>fred</li><li>barney</li>'
+ *
+ * // using the `sourceURL` option to specify a custom sourceURL for the template
+ * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+ * compiled(data);
+ * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
+ *
+ * // using the `variable` option to ensure a with-statement isn't used in the compiled template
+ * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+ * compiled.source;
+ * // => function(data) {
+ * var __t, __p = '', __e = _.escape;
+ * __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
+ * return __p;
+ * }
+ *
+ * // using the `source` property to inline compiled templates for meaningful
+ * // line numbers in error messages and a stack trace
+ * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
+ * var JST = {\
+ * "main": ' + _.template(mainText).source + '\
+ * };\
+ * ');
+ */
+ function template(text, data, options) {
+ // based on John Resig's `tmpl` implementation
+ // http://ejohn.org/blog/javascript-micro-templating/
+ // and Laura Doktorova's doT.js
+ // https://github.com/olado/doT
+ var settings = lodash.templateSettings;
+ text = String(text || '');
+
+ // avoid missing dependencies when `iteratorTemplate` is not defined
+ options = defaults({}, options, settings);
+
+ var imports = defaults({}, options.imports, settings.imports),
+ importsKeys = keys(imports),
+ importsValues = values(imports);
+
+ var isEvaluating,
+ index = 0,
+ interpolate = options.interpolate || reNoMatch,
+ source = "__p += '";
+
+ // compile the regexp to match each delimiter
+ var reDelimiters = RegExp(
+ (options.escape || reNoMatch).source + '|' +
+ interpolate.source + '|' +
+ (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
+ (options.evaluate || reNoMatch).source + '|$'
+ , 'g');
+
+ text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
+ interpolateValue || (interpolateValue = esTemplateValue);
+
+ // escape characters that cannot be included in string literals
+ source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);
+
+ // replace delimiters with snippets
+ if (escapeValue) {
+ source += "' +\n__e(" + escapeValue + ") +\n'";
+ }
+ if (evaluateValue) {
+ isEvaluating = true;
+ source += "';\n" + evaluateValue + ";\n__p += '";
+ }
+ if (interpolateValue) {
+ source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+ }
+ index = offset + match.length;
+
+ // the JS engine embedded in Adobe products requires returning the `match`
+ // string in order to produce the correct `offset` value
+ return match;
+ });
+
+ source += "';\n";
+
+ // if `variable` is not specified, wrap a with-statement around the generated
+ // code to add the data object to the top of the scope chain
+ var variable = options.variable,
+ hasVariable = variable;
+
+ if (!hasVariable) {
+ variable = 'obj';
+ source = 'with (' + variable + ') {\n' + source + '\n}\n';
+ }
+ // cleanup code by stripping empty strings
+ source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+ .replace(reEmptyStringMiddle, '$1')
+ .replace(reEmptyStringTrailing, '$1;');
+
+ // frame code as the function body
+ source = 'function(' + variable + ') {\n' +
+ (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
+ "var __t, __p = '', __e = _.escape" +
+ (isEvaluating
+ ? ', __j = Array.prototype.join;\n' +
+ "function print() { __p += __j.call(arguments, '') }\n"
+ : ';\n'
+ ) +
+ source +
+ 'return __p\n}';
+
+ // Use a sourceURL for easier debugging.
+ // http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ var sourceURL = '\n/*\n//# sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\n*/';
+
+ try {
+ var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);
+ } catch(e) {
+ e.source = source;
+ throw e;
+ }
+ if (data) {
+ return result(data);
+ }
+ // provide the compiled function's source by its `toString` method, in
+ // supported environments, or the `source` property as a convenience for
+ // inlining compiled templates during the build process
+ result.source = source;
+ return result;
+ }
+
+ /**
+ * Executes the callback `n` times, returning an array of the results
+ * of each callback execution. The callback is bound to `thisArg` and invoked
+ * with one argument; (index).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} n The number of times to execute the callback.
+ * @param {Function} callback The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns an array of the results of each `callback` execution.
+ * @example
+ *
+ * var diceRolls = _.times(3, _.partial(_.random, 1, 6));
+ * // => [3, 6, 4]
+ *
+ * _.times(3, function(n) { mage.castSpell(n); });
+ * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively
+ *
+ * _.times(3, function(n) { this.cast(n); }, mage);
+ * // => also calls `mage.castSpell(n)` three times
+ */
+ function times(n, callback, thisArg) {
+ n = (n = +n) > -1 ? n : 0;
+ var index = -1,
+ result = Array(n);
+
+ callback = baseCreateCallback(callback, thisArg, 1);
+ while (++index < n) {
+ result[index] = callback(index);
+ }
+ return result;
+ }
+
+ /**
+ * The inverse of `_.escape` this method converts the HTML entities
+ * `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding characters.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to unescape.
+ * @returns {string} Returns the unescaped string.
+ * @example
+ *
+ * _.unescape('Fred, Barney & Pebbles');
+ * // => 'Fred, Barney & Pebbles'
+ */
+ function unescape(string) {
+ return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar);
+ }
+
+ /**
+ * Generates a unique ID. If `prefix` is provided the ID will be appended to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} [prefix] The value to prefix the ID with.
+ * @returns {string} Returns the unique ID.
+ * @example
+ *
+ * _.uniqueId('contact_');
+ * // => 'contact_104'
+ *
+ * _.uniqueId();
+ * // => '105'
+ */
+ function uniqueId(prefix) {
+ var id = ++idCounter;
+ return String(prefix == null ? '' : prefix) + id;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object that wraps the given value with explicit
+ * method chaining enabled.
+ *
+ * @static
+ * @memberOf _
+ * @category Chaining
+ * @param {*} value The value to wrap.
+ * @returns {Object} Returns the wrapper object.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'pebbles', 'age': 1 }
+ * ];
+ *
+ * var youngest = _.chain(characters)
+ * .sortBy('age')
+ * .map(function(chr) { return chr.name + ' is ' + chr.age; })
+ * .first()
+ * .value();
+ * // => 'pebbles is 1'
+ */
+ function chain(value) {
+ value = new lodashWrapper(value);
+ value.__chain__ = true;
+ return value;
+ }
+
+ /**
+ * Invokes `interceptor` with the `value` as the first argument and then
+ * returns `value`. The purpose of this method is to "tap into" a method
+ * chain in order to perform operations on intermediate results within
+ * the chain.
+ *
+ * @static
+ * @memberOf _
+ * @category Chaining
+ * @param {*} value The value to provide to `interceptor`.
+ * @param {Function} interceptor The function to invoke.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * _([1, 2, 3, 4])
+ * .tap(function(array) { array.pop(); })
+ * .reverse()
+ * .value();
+ * // => [3, 2, 1]
+ */
+ function tap(value, interceptor) {
+ interceptor(value);
+ return value;
+ }
+
+ /**
+ * Enables explicit method chaining on the wrapper object.
+ *
+ * @name chain
+ * @memberOf _
+ * @category Chaining
+ * @returns {*} Returns the wrapper object.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // without explicit chaining
+ * _(characters).first();
+ * // => { 'name': 'barney', 'age': 36 }
+ *
+ * // with explicit chaining
+ * _(characters).chain()
+ * .first()
+ * .pick('age')
+ * .value();
+ * // => { 'age': 36 }
+ */
+ function wrapperChain() {
+ this.__chain__ = true;
+ return this;
+ }
+
+ /**
+ * Produces the `toString` result of the wrapped value.
+ *
+ * @name toString
+ * @memberOf _
+ * @category Chaining
+ * @returns {string} Returns the string result.
+ * @example
+ *
+ * _([1, 2, 3]).toString();
+ * // => '1,2,3'
+ */
+ function wrapperToString() {
+ return String(this.__wrapped__);
+ }
+
+ /**
+ * Extracts the wrapped value.
+ *
+ * @name valueOf
+ * @memberOf _
+ * @alias value
+ * @category Chaining
+ * @returns {*} Returns the wrapped value.
+ * @example
+ *
+ * _([1, 2, 3]).valueOf();
+ * // => [1, 2, 3]
+ */
+ function wrapperValueOf() {
+ return this.__wrapped__;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions that return wrapped values when chaining
+ lodash.after = after;
+ lodash.assign = assign;
+ lodash.at = at;
+ lodash.bind = bind;
+ lodash.bindAll = bindAll;
+ lodash.bindKey = bindKey;
+ lodash.chain = chain;
+ lodash.compact = compact;
+ lodash.compose = compose;
+ lodash.constant = constant;
+ lodash.countBy = countBy;
+ lodash.create = create;
+ lodash.createCallback = createCallback;
+ lodash.curry = curry;
+ lodash.debounce = debounce;
+ lodash.defaults = defaults;
+ lodash.defer = defer;
+ lodash.delay = delay;
+ lodash.difference = difference;
+ lodash.filter = filter;
+ lodash.flatten = flatten;
+ lodash.forEach = forEach;
+ lodash.forEachRight = forEachRight;
+ lodash.forIn = forIn;
+ lodash.forInRight = forInRight;
+ lodash.forOwn = forOwn;
+ lodash.forOwnRight = forOwnRight;
+ lodash.functions = functions;
+ lodash.groupBy = groupBy;
+ lodash.indexBy = indexBy;
+ lodash.initial = initial;
+ lodash.intersection = intersection;
+ lodash.invert = invert;
+ lodash.invoke = invoke;
+ lodash.keys = keys;
+ lodash.map = map;
+ lodash.mapValues = mapValues;
+ lodash.max = max;
+ lodash.memoize = memoize;
+ lodash.merge = merge;
+ lodash.min = min;
+ lodash.omit = omit;
+ lodash.once = once;
+ lodash.pairs = pairs;
+ lodash.partial = partial;
+ lodash.partialRight = partialRight;
+ lodash.pick = pick;
+ lodash.pluck = pluck;
+ lodash.property = property;
+ lodash.pull = pull;
+ lodash.range = range;
+ lodash.reject = reject;
+ lodash.remove = remove;
+ lodash.rest = rest;
+ lodash.shuffle = shuffle;
+ lodash.sortBy = sortBy;
+ lodash.tap = tap;
+ lodash.throttle = throttle;
+ lodash.times = times;
+ lodash.toArray = toArray;
+ lodash.transform = transform;
+ lodash.union = union;
+ lodash.uniq = uniq;
+ lodash.values = values;
+ lodash.where = where;
+ lodash.without = without;
+ lodash.wrap = wrap;
+ lodash.xor = xor;
+ lodash.zip = zip;
+ lodash.zipObject = zipObject;
+
+ // add aliases
+ lodash.collect = map;
+ lodash.drop = rest;
+ lodash.each = forEach;
+ lodash.eachRight = forEachRight;
+ lodash.extend = assign;
+ lodash.methods = functions;
+ lodash.object = zipObject;
+ lodash.select = filter;
+ lodash.tail = rest;
+ lodash.unique = uniq;
+ lodash.unzip = zip;
+
+ // add functions to `lodash.prototype`
+ mixin(lodash);
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions that return unwrapped values when chaining
+ lodash.clone = clone;
+ lodash.cloneDeep = cloneDeep;
+ lodash.contains = contains;
+ lodash.escape = escape;
+ lodash.every = every;
+ lodash.find = find;
+ lodash.findIndex = findIndex;
+ lodash.findKey = findKey;
+ lodash.findLast = findLast;
+ lodash.findLastIndex = findLastIndex;
+ lodash.findLastKey = findLastKey;
+ lodash.has = has;
+ lodash.identity = identity;
+ lodash.indexOf = indexOf;
+ lodash.isArguments = isArguments;
+ lodash.isArray = isArray;
+ lodash.isBoolean = isBoolean;
+ lodash.isDate = isDate;
+ lodash.isElement = isElement;
+ lodash.isEmpty = isEmpty;
+ lodash.isEqual = isEqual;
+ lodash.isFinite = isFinite;
+ lodash.isFunction = isFunction;
+ lodash.isNaN = isNaN;
+ lodash.isNull = isNull;
+ lodash.isNumber = isNumber;
+ lodash.isObject = isObject;
+ lodash.isPlainObject = isPlainObject;
+ lodash.isRegExp = isRegExp;
+ lodash.isString = isString;
+ lodash.isUndefined = isUndefined;
+ lodash.lastIndexOf = lastIndexOf;
+ lodash.mixin = mixin;
+ lodash.noConflict = noConflict;
+ lodash.noop = noop;
+ lodash.now = now;
+ lodash.parseInt = parseInt;
+ lodash.random = random;
+ lodash.reduce = reduce;
+ lodash.reduceRight = reduceRight;
+ lodash.result = result;
+ lodash.runInContext = runInContext;
+ lodash.size = size;
+ lodash.some = some;
+ lodash.sortedIndex = sortedIndex;
+ lodash.template = template;
+ lodash.unescape = unescape;
+ lodash.uniqueId = uniqueId;
+
+ // add aliases
+ lodash.all = every;
+ lodash.any = some;
+ lodash.detect = find;
+ lodash.findWhere = find;
+ lodash.foldl = reduce;
+ lodash.foldr = reduceRight;
+ lodash.include = contains;
+ lodash.inject = reduce;
+
+ mixin(function() {
+ var source = {}
+ forOwn(lodash, function(func, methodName) {
+ if (!lodash.prototype[methodName]) {
+ source[methodName] = func;
+ }
+ });
+ return source;
+ }(), false);
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions capable of returning wrapped and unwrapped values when chaining
+ lodash.first = first;
+ lodash.last = last;
+ lodash.sample = sample;
+
+ // add aliases
+ lodash.take = first;
+ lodash.head = first;
+
+ forOwn(lodash, function(func, methodName) {
+ var callbackable = methodName !== 'sample';
+ if (!lodash.prototype[methodName]) {
+ lodash.prototype[methodName]= function(n, guard) {
+ var chainAll = this.__chain__,
+ result = func(this.__wrapped__, n, guard);
+
+ return !chainAll && (n == null || (guard && !(callbackable && typeof n == 'function')))
+ ? result
+ : new lodashWrapper(result, chainAll);
+ };
+ }
+ });
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The semantic version number.
+ *
+ * @static
+ * @memberOf _
+ * @type string
+ */
+ lodash.VERSION = '2.4.2';
+
+ // add "Chaining" functions to the wrapper
+ lodash.prototype.chain = wrapperChain;
+ lodash.prototype.toString = wrapperToString;
+ lodash.prototype.value = wrapperValueOf;
+ lodash.prototype.valueOf = wrapperValueOf;
+
+ // add `Array` functions that return unwrapped values
+ forEach(['join', 'pop', 'shift'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ result = func.apply(this.__wrapped__, arguments);
+
+ return chainAll
+ ? new lodashWrapper(result, chainAll)
+ : result;
+ };
+ });
+
+ // add `Array` functions that return the existing wrapped value
+ forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ func.apply(this.__wrapped__, arguments);
+ return this;
+ };
+ });
+
+ // add `Array` functions that return new wrapped values
+ forEach(['concat', 'slice', 'splice'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ return new lodashWrapper(func.apply(this.__wrapped__, arguments), this.__chain__);
+ };
+ });
+
+ return lodash;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ // expose Lo-Dash
+ var _ = runInContext();
+
+ // some AMD build optimizers like r.js check for condition patterns like the following:
+ if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+ // Expose Lo-Dash to the global object even when an AMD loader is present in
+ // case Lo-Dash is loaded with a RequireJS shim config.
+ // See http://requirejs.org/docs/api.html#config-shim
+ root._ = _;
+
+ // define as an anonymous module so, through path mapping, it can be
+ // referenced as the "underscore" module
+ define(function() {
+ return _;
+ });
+ }
+ // check for `exports` after `define` in case a build optimizer adds an `exports` object
+ else if (freeExports && freeModule) {
+ // in Node.js or RingoJS
+ if (moduleExports) {
+ (freeModule.exports = _)._ = _;
+ }
+ // in Narwhal or Rhino -require
+ else {
+ freeExports._ = _;
+ }
+ }
+ else {
+ // in a browser or Rhino
+ root._ = _;
+ }
+}.call(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],60:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Chris Pettitt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+var lib = require("./lib");
+
+module.exports = {
+ Graph: lib.Graph,
+ json: require("./lib/json"),
+ alg: require("./lib/alg"),
+ version: lib.version
+};
+
+},{"./lib":76,"./lib/alg":67,"./lib/json":77}],61:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = components;
+
+function components(g) {
+ var visited = {},
+ cmpts = [],
+ cmpt;
+
+ function dfs(v) {
+ if (_.has(visited, v)) return;
+ visited[v] = true;
+ cmpt.push(v);
+ _.each(g.successors(v), dfs);
+ _.each(g.predecessors(v), dfs);
+ }
+
+ _.each(g.nodes(), function(v) {
+ cmpt = [];
+ dfs(v);
+ if (cmpt.length) {
+ cmpts.push(cmpt);
+ }
+ });
+
+ return cmpts;
+}
+
+},{"../lodash":78}],62:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = dfs;
+
+/*
+ * A helper that preforms a pre- or post-order traversal on the input graph
+ * and returns the nodes in the order they were visited. This algorithm treats
+ * the input as undirected.
+ *
+ * Order must be one of "pre" or "post".
+ */
+function dfs(g, vs, order) {
+ if (!_.isArray(vs)) {
+ vs = [vs];
+ }
+
+ var acc = [],
+ visited = {};
+ _.each(vs, function(v) {
+ if (!g.hasNode(v)) {
+ throw new Error("Graph does not have node: " + v);
+ }
+
+ doDfs(g, v, order === "post", visited, acc);
+ });
+ return acc;
+}
+
+function doDfs(g, v, postorder, visited, acc) {
+ if (!_.has(visited, v)) {
+ visited[v] = true;
+
+ if (!postorder) { acc.push(v); }
+ _.each(g.neighbors(v), function(w) {
+ doDfs(g, w, postorder, visited, acc);
+ });
+ if (postorder) { acc.push(v); }
+ }
+}
+
+},{"../lodash":78}],63:[function(require,module,exports){
+var dijkstra = require("./dijkstra"),
+ _ = require("../lodash");
+
+module.exports = dijkstraAll;
+
+function dijkstraAll(g, weightFunc, edgeFunc) {
+ return _.transform(g.nodes(), function(acc, v) {
+ acc[v] = dijkstra(g, v, weightFunc, edgeFunc);
+ }, {});
+}
+
+},{"../lodash":78,"./dijkstra":64}],64:[function(require,module,exports){
+var _ = require("../lodash"),
+ PriorityQueue = require("../data/priority-queue");
+
+module.exports = dijkstra;
+
+var DEFAULT_WEIGHT_FUNC = _.constant(1);
+
+function dijkstra(g, source, weightFn, edgeFn) {
+ return runDijkstra(g, String(source),
+ weightFn || DEFAULT_WEIGHT_FUNC,
+ edgeFn || function(v) { return g.outEdges(v); });
+}
+
+function runDijkstra(g, source, weightFn, edgeFn) {
+ var results = {},
+ pq = new PriorityQueue(),
+ v, vEntry;
+
+ var updateNeighbors = function(edge) {
+ var w = edge.v !== v ? edge.v : edge.w,
+ wEntry = results[w],
+ weight = weightFn(edge),
+ distance = vEntry.distance + weight;
+
+ if (weight < 0) {
+ throw new Error("dijkstra does not allow negative edge weights. " +
+ "Bad edge: " + edge + " Weight: " + weight);
+ }
+
+ if (distance < wEntry.distance) {
+ wEntry.distance = distance;
+ wEntry.predecessor = v;
+ pq.decrease(w, distance);
+ }
+ };
+
+ g.nodes().forEach(function(v) {
+ var distance = v === source ? 0 : Number.POSITIVE_INFINITY;
+ results[v] = { distance: distance };
+ pq.add(v, distance);
+ });
+
+ while (pq.size() > 0) {
+ v = pq.removeMin();
+ vEntry = results[v];
+ if (vEntry.distance === Number.POSITIVE_INFINITY) {
+ break;
+ }
+
+ edgeFn(v).forEach(updateNeighbors);
+ }
+
+ return results;
+}
+
+},{"../data/priority-queue":74,"../lodash":78}],65:[function(require,module,exports){
+var _ = require("../lodash"),
+ tarjan = require("./tarjan");
+
+module.exports = findCycles;
+
+function findCycles(g) {
+ return _.filter(tarjan(g), function(cmpt) { return cmpt.length > 1; });
+}
+
+},{"../lodash":78,"./tarjan":72}],66:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = floydWarshall;
+
+var DEFAULT_WEIGHT_FUNC = _.constant(1);
+
+function floydWarshall(g, weightFn, edgeFn) {
+ return runFloydWarshall(g,
+ weightFn || DEFAULT_WEIGHT_FUNC,
+ edgeFn || function(v) { return g.outEdges(v); });
+}
+
+function runFloydWarshall(g, weightFn, edgeFn) {
+ var results = {},
+ nodes = g.nodes();
+
+ nodes.forEach(function(v) {
+ results[v] = {};
+ results[v][v] = { distance: 0 };
+ nodes.forEach(function(w) {
+ if (v !== w) {
+ results[v][w] = { distance: Number.POSITIVE_INFINITY };
+ }
+ });
+ edgeFn(v).forEach(function(edge) {
+ var w = edge.v === v ? edge.w : edge.v,
+ d = weightFn(edge);
+ results[v][w] = { distance: d, predecessor: v };
+ });
+ });
+
+ nodes.forEach(function(k) {
+ var rowK = results[k];
+ nodes.forEach(function(i) {
+ var rowI = results[i];
+ nodes.forEach(function(j) {
+ var ik = rowI[k];
+ var kj = rowK[j];
+ var ij = rowI[j];
+ var altDistance = ik.distance + kj.distance;
+ if (altDistance < ij.distance) {
+ ij.distance = altDistance;
+ ij.predecessor = kj.predecessor;
+ }
+ });
+ });
+ });
+
+ return results;
+}
+
+},{"../lodash":78}],67:[function(require,module,exports){
+module.exports = {
+ components: require("./components"),
+ dijkstra: require("./dijkstra"),
+ dijkstraAll: require("./dijkstra-all"),
+ findCycles: require("./find-cycles"),
+ floydWarshall: require("./floyd-warshall"),
+ isAcyclic: require("./is-acyclic"),
+ postorder: require("./postorder"),
+ preorder: require("./preorder"),
+ prim: require("./prim"),
+ tarjan: require("./tarjan"),
+ topsort: require("./topsort")
+};
+
+},{"./components":61,"./dijkstra":64,"./dijkstra-all":63,"./find-cycles":65,"./floyd-warshall":66,"./is-acyclic":68,"./postorder":69,"./preorder":70,"./prim":71,"./tarjan":72,"./topsort":73}],68:[function(require,module,exports){
+var topsort = require("./topsort");
+
+module.exports = isAcyclic;
+
+function isAcyclic(g) {
+ try {
+ topsort(g);
+ } catch (e) {
+ if (e instanceof topsort.CycleException) {
+ return false;
+ }
+ throw e;
+ }
+ return true;
+}
+
+},{"./topsort":73}],69:[function(require,module,exports){
+var dfs = require("./dfs");
+
+module.exports = postorder;
+
+function postorder(g, vs) {
+ return dfs(g, vs, "post");
+}
+
+},{"./dfs":62}],70:[function(require,module,exports){
+var dfs = require("./dfs");
+
+module.exports = preorder;
+
+function preorder(g, vs) {
+ return dfs(g, vs, "pre");
+}
+
+},{"./dfs":62}],71:[function(require,module,exports){
+var _ = require("../lodash"),
+ Graph = require("../graph"),
+ PriorityQueue = require("../data/priority-queue");
+
+module.exports = prim;
+
+function prim(g, weightFunc) {
+ var result = new Graph(),
+ parents = {},
+ pq = new PriorityQueue(),
+ v;
+
+ function updateNeighbors(edge) {
+ var w = edge.v === v ? edge.w : edge.v,
+ pri = pq.priority(w);
+ if (pri !== undefined) {
+ var edgeWeight = weightFunc(edge);
+ if (edgeWeight < pri) {
+ parents[w] = v;
+ pq.decrease(w, edgeWeight);
+ }
+ }
+ }
+
+ if (g.nodeCount() === 0) {
+ return result;
+ }
+
+ _.each(g.nodes(), function(v) {
+ pq.add(v, Number.POSITIVE_INFINITY);
+ result.setNode(v);
+ });
+
+ // Start from an arbitrary node
+ pq.decrease(g.nodes()[0], 0);
+
+ var init = false;
+ while (pq.size() > 0) {
+ v = pq.removeMin();
+ if (_.has(parents, v)) {
+ result.setEdge(v, parents[v]);
+ } else if (init) {
+ throw new Error("Input graph is not connected: " + g);
+ } else {
+ init = true;
+ }
+
+ g.nodeEdges(v).forEach(updateNeighbors);
+ }
+
+ return result;
+}
+
+},{"../data/priority-queue":74,"../graph":75,"../lodash":78}],72:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = tarjan;
+
+function tarjan(g) {
+ var index = 0,
+ stack = [],
+ visited = {}, // node id -> { onStack, lowlink, index }
+ results = [];
+
+ function dfs(v) {
+ var entry = visited[v] = {
+ onStack: true,
+ lowlink: index,
+ index: index++
+ };
+ stack.push(v);
+
+ g.successors(v).forEach(function(w) {
+ if (!_.has(visited, w)) {
+ dfs(w);
+ entry.lowlink = Math.min(entry.lowlink, visited[w].lowlink);
+ } else if (visited[w].onStack) {
+ entry.lowlink = Math.min(entry.lowlink, visited[w].index);
+ }
+ });
+
+ if (entry.lowlink === entry.index) {
+ var cmpt = [],
+ w;
+ do {
+ w = stack.pop();
+ visited[w].onStack = false;
+ cmpt.push(w);
+ } while (v !== w);
+ results.push(cmpt);
+ }
+ }
+
+ g.nodes().forEach(function(v) {
+ if (!_.has(visited, v)) {
+ dfs(v);
+ }
+ });
+
+ return results;
+}
+
+},{"../lodash":78}],73:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = topsort;
+topsort.CycleException = CycleException;
+
+function topsort(g) {
+ var visited = {},
+ stack = {},
+ results = [];
+
+ function visit(node) {
+ if (_.has(stack, node)) {
+ throw new CycleException();
+ }
+
+ if (!_.has(visited, node)) {
+ stack[node] = true;
+ visited[node] = true;
+ _.each(g.predecessors(node), visit);
+ delete stack[node];
+ results.push(node);
+ }
+ }
+
+ _.each(g.sinks(), visit);
+
+ if (_.size(visited) !== g.nodeCount()) {
+ throw new CycleException();
+ }
+
+ return results;
+}
+
+function CycleException() {}
+
+},{"../lodash":78}],74:[function(require,module,exports){
+var _ = require("../lodash");
+
+module.exports = PriorityQueue;
+
+/**
+ * A min-priority queue data structure. This algorithm is derived from Cormen,
+ * et al., "Introduction to Algorithms". The basic idea of a min-priority
+ * queue is that you can efficiently (in O(1) time) get the smallest key in
+ * the queue. Adding and removing elements takes O(log n) time. A key can
+ * have its priority decreased in O(log n) time.
+ */
+function PriorityQueue() {
+ this._arr = [];
+ this._keyIndices = {};
+}
+
+/**
+ * Returns the number of elements in the queue. Takes `O(1)` time.
+ */
+PriorityQueue.prototype.size = function() {
+ return this._arr.length;
+};
+
+/**
+ * Returns the keys that are in the queue. Takes `O(n)` time.
+ */
+PriorityQueue.prototype.keys = function() {
+ return this._arr.map(function(x) { return x.key; });
+};
+
+/**
+ * Returns `true` if **key** is in the queue and `false` if not.
+ */
+PriorityQueue.prototype.has = function(key) {
+ return _.has(this._keyIndices, key);
+};
+
+/**
+ * Returns the priority for **key**. If **key** is not present in the queue
+ * then this function returns `undefined`. Takes `O(1)` time.
+ *
+ * @param {Object} key
+ */
+PriorityQueue.prototype.priority = function(key) {
+ var index = this._keyIndices[key];
+ if (index !== undefined) {
+ return this._arr[index].priority;
+ }
+};
+
+/**
+ * Returns the key for the minimum element in this queue. If the queue is
+ * empty this function throws an Error. Takes `O(1)` time.
+ */
+PriorityQueue.prototype.min = function() {
+ if (this.size() === 0) {
+ throw new Error("Queue underflow");
+ }
+ return this._arr[0].key;
+};
+
+/**
+ * Inserts a new key into the priority queue. If the key already exists in
+ * the queue this function returns `false`; otherwise it will return `true`.
+ * Takes `O(n)` time.
+ *
+ * @param {Object} key the key to add
+ * @param {Number} priority the initial priority for the key
+ */
+PriorityQueue.prototype.add = function(key, priority) {
+ var keyIndices = this._keyIndices;
+ key = String(key);
+ if (!_.has(keyIndices, key)) {
+ var arr = this._arr;
+ var index = arr.length;
+ keyIndices[key] = index;
+ arr.push({key: key, priority: priority});
+ this._decrease(index);
+ return true;
+ }
+ return false;
+};
+
+/**
+ * Removes and returns the smallest key in the queue. Takes `O(log n)` time.
+ */
+PriorityQueue.prototype.removeMin = function() {
+ this._swap(0, this._arr.length - 1);
+ var min = this._arr.pop();
+ delete this._keyIndices[min.key];
+ this._heapify(0);
+ return min.key;
+};
+
+/**
+ * Decreases the priority for **key** to **priority**. If the new priority is
+ * greater than the previous priority, this function will throw an Error.
+ *
+ * @param {Object} key the key for which to raise priority
+ * @param {Number} priority the new priority for the key
+ */
+PriorityQueue.prototype.decrease = function(key, priority) {
+ var index = this._keyIndices[key];
+ if (priority > this._arr[index].priority) {
+ throw new Error("New priority is greater than current priority. " +
+ "Key: " + key + " Old: " + this._arr[index].priority + " New: " + priority);
+ }
+ this._arr[index].priority = priority;
+ this._decrease(index);
+};
+
+PriorityQueue.prototype._heapify = function(i) {
+ var arr = this._arr;
+ var l = 2 * i,
+ r = l + 1,
+ largest = i;
+ if (l < arr.length) {
+ largest = arr[l].priority < arr[largest].priority ? l : largest;
+ if (r < arr.length) {
+ largest = arr[r].priority < arr[largest].priority ? r : largest;
+ }
+ if (largest !== i) {
+ this._swap(i, largest);
+ this._heapify(largest);
+ }
+ }
+};
+
+PriorityQueue.prototype._decrease = function(index) {
+ var arr = this._arr;
+ var priority = arr[index].priority;
+ var parent;
+ while (index !== 0) {
+ parent = index >> 1;
+ if (arr[parent].priority < priority) {
+ break;
+ }
+ this._swap(index, parent);
+ index = parent;
+ }
+};
+
+PriorityQueue.prototype._swap = function(i, j) {
+ var arr = this._arr;
+ var keyIndices = this._keyIndices;
+ var origArrI = arr[i];
+ var origArrJ = arr[j];
+ arr[i] = origArrJ;
+ arr[j] = origArrI;
+ keyIndices[origArrJ.key] = i;
+ keyIndices[origArrI.key] = j;
+};
+
+},{"../lodash":78}],75:[function(require,module,exports){
+"use strict";
+
+var _ = require("./lodash");
+
+module.exports = Graph;
+
+var DEFAULT_EDGE_NAME = "\x00",
+ GRAPH_NODE = "\x00",
+ EDGE_KEY_DELIM = "\x01";
+
+// Implementation notes:
+//
+// * Node id query functions should return string ids for the nodes
+// * Edge id query functions should return an "edgeObj", edge object, that is
+// composed of enough information to uniquely identify an edge: {v, w, name}.
+// * Internally we use an "edgeId", a stringified form of the edgeObj, to
+// reference edges. This is because we need a performant way to look these
+// edges up and, object properties, which have string keys, are the closest
+// we're going to get to a performant hashtable in JavaScript.
+
+function Graph(opts) {
+ this._isDirected = _.has(opts, "directed") ? opts.directed : true;
+ this._isMultigraph = _.has(opts, "multigraph") ? opts.multigraph : false;
+ this._isCompound = _.has(opts, "compound") ? opts.compound : false;
+
+ // Label for the graph itself
+ this._label = undefined;
+
+ // Defaults to be set when creating a new node
+ this._defaultNodeLabelFn = _.constant(undefined);
+
+ // Defaults to be set when creating a new edge
+ this._defaultEdgeLabelFn = _.constant(undefined);
+
+ // v -> label
+ this._nodes = {};
+
+ if (this._isCompound) {
+ // v -> parent
+ this._parent = {};
+
+ // v -> children
+ this._children = {};
+ this._children[GRAPH_NODE] = {};
+ }
+
+ // v -> edgeObj
+ this._in = {};
+
+ // u -> v -> Number
+ this._preds = {};
+
+ // v -> edgeObj
+ this._out = {};
+
+ // v -> w -> Number
+ this._sucs = {};
+
+ // e -> edgeObj
+ this._edgeObjs = {};
+
+ // e -> label
+ this._edgeLabels = {};
+}
+
+/* Number of nodes in the graph. Should only be changed by the implementation. */
+Graph.prototype._nodeCount = 0;
+
+/* Number of edges in the graph. Should only be changed by the implementation. */
+Graph.prototype._edgeCount = 0;
+
+
+/* === Graph functions ========= */
+
+Graph.prototype.isDirected = function() {
+ return this._isDirected;
+};
+
+Graph.prototype.isMultigraph = function() {
+ return this._isMultigraph;
+};
+
+Graph.prototype.isCompound = function() {
+ return this._isCompound;
+};
+
+Graph.prototype.setGraph = function(label) {
+ this._label = label;
+ return this;
+};
+
+Graph.prototype.graph = function() {
+ return this._label;
+};
+
+
+/* === Node functions ========== */
+
+Graph.prototype.setDefaultNodeLabel = function(newDefault) {
+ if (!_.isFunction(newDefault)) {
+ newDefault = _.constant(newDefault);
+ }
+ this._defaultNodeLabelFn = newDefault;
+ return this;
+};
+
+Graph.prototype.nodeCount = function() {
+ return this._nodeCount;
+};
+
+Graph.prototype.nodes = function() {
+ return _.keys(this._nodes);
+};
+
+Graph.prototype.sources = function() {
+ return _.filter(this.nodes(), function(v) {
+ return _.isEmpty(this._in[v]);
+ }, this);
+};
+
+Graph.prototype.sinks = function() {
+ return _.filter(this.nodes(), function(v) {
+ return _.isEmpty(this._out[v]);
+ }, this);
+};
+
+Graph.prototype.setNodes = function(vs, value) {
+ var args = arguments;
+ _.each(vs, function(v) {
+ if (args.length > 1) {
+ this.setNode(v, value);
+ } else {
+ this.setNode(v);
+ }
+ }, this);
+ return this;
+};
+
+Graph.prototype.setNode = function(v, value) {
+ if (_.has(this._nodes, v)) {
+ if (arguments.length > 1) {
+ this._nodes[v] = value;
+ }
+ return this;
+ }
+
+ this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
+ if (this._isCompound) {
+ this._parent[v] = GRAPH_NODE;
+ this._children[v] = {};
+ this._children[GRAPH_NODE][v] = true;
+ }
+ this._in[v] = {};
+ this._preds[v] = {};
+ this._out[v] = {};
+ this._sucs[v] = {};
+ ++this._nodeCount;
+ return this;
+};
+
+Graph.prototype.node = function(v) {
+ return this._nodes[v];
+};
+
+Graph.prototype.hasNode = function(v) {
+ return _.has(this._nodes, v);
+};
+
+Graph.prototype.removeNode = function(v) {
+ var self = this;
+ if (_.has(this._nodes, v)) {
+ var removeEdge = function(e) { self.removeEdge(self._edgeObjs[e]); };
+ delete this._nodes[v];
+ if (this._isCompound) {
+ this._removeFromParentsChildList(v);
+ delete this._parent[v];
+ _.each(this.children(v), function(child) {
+ this.setParent(child);
+ }, this);
+ delete this._children[v];
+ }
+ _.each(_.keys(this._in[v]), removeEdge);
+ delete this._in[v];
+ delete this._preds[v];
+ _.each(_.keys(this._out[v]), removeEdge);
+ delete this._out[v];
+ delete this._sucs[v];
+ --this._nodeCount;
+ }
+ return this;
+};
+
+Graph.prototype.setParent = function(v, parent) {
+ if (!this._isCompound) {
+ throw new Error("Cannot set parent in a non-compound graph");
+ }
+
+ if (_.isUndefined(parent)) {
+ parent = GRAPH_NODE;
+ } else {
+ // Coerce parent to string
+ parent += "";
+ for (var ancestor = parent;
+ !_.isUndefined(ancestor);
+ ancestor = this.parent(ancestor)) {
+ if (ancestor === v) {
+ throw new Error("Setting " + parent+ " as parent of " + v +
+ " would create create a cycle");
+ }
+ }
+
+ this.setNode(parent);
+ }
+
+ this.setNode(v);
+ this._removeFromParentsChildList(v);
+ this._parent[v] = parent;
+ this._children[parent][v] = true;
+ return this;
+};
+
+Graph.prototype._removeFromParentsChildList = function(v) {
+ delete this._children[this._parent[v]][v];
+};
+
+Graph.prototype.parent = function(v) {
+ if (this._isCompound) {
+ var parent = this._parent[v];
+ if (parent !== GRAPH_NODE) {
+ return parent;
+ }
+ }
+};
+
+Graph.prototype.children = function(v) {
+ if (_.isUndefined(v)) {
+ v = GRAPH_NODE;
+ }
+
+ if (this._isCompound) {
+ var children = this._children[v];
+ if (children) {
+ return _.keys(children);
+ }
+ } else if (v === GRAPH_NODE) {
+ return this.nodes();
+ } else if (this.hasNode(v)) {
+ return [];
+ }
+};
+
+Graph.prototype.predecessors = function(v) {
+ var predsV = this._preds[v];
+ if (predsV) {
+ return _.keys(predsV);
+ }
+};
+
+Graph.prototype.successors = function(v) {
+ var sucsV = this._sucs[v];
+ if (sucsV) {
+ return _.keys(sucsV);
+ }
+};
+
+Graph.prototype.neighbors = function(v) {
+ var preds = this.predecessors(v);
+ if (preds) {
+ return _.union(preds, this.successors(v));
+ }
+};
+
+/* === Edge functions ========== */
+
+Graph.prototype.setDefaultEdgeLabel = function(newDefault) {
+ if (!_.isFunction(newDefault)) {
+ newDefault = _.constant(newDefault);
+ }
+ this._defaultEdgeLabelFn = newDefault;
+ return this;
+};
+
+Graph.prototype.edgeCount = function() {
+ return this._edgeCount;
+};
+
+Graph.prototype.edges = function() {
+ return _.values(this._edgeObjs);
+};
+
+Graph.prototype.setPath = function(vs, value) {
+ var self = this,
+ args = arguments;
+ _.reduce(vs, function(v, w) {
+ if (args.length > 1) {
+ self.setEdge(v, w, value);
+ } else {
+ self.setEdge(v, w);
+ }
+ return w;
+ });
+ return this;
+};
+
+/*
+ * setEdge(v, w, [value, [name]])
+ * setEdge({ v, w, [name] }, [value])
+ */
+Graph.prototype.setEdge = function() {
+ var v, w, name, value,
+ valueSpecified = false;
+
+ if (_.isPlainObject(arguments[0])) {
+ v = arguments[0].v;
+ w = arguments[0].w;
+ name = arguments[0].name;
+ if (arguments.length === 2) {
+ value = arguments[1];
+ valueSpecified = true;
+ }
+ } else {
+ v = arguments[0];
+ w = arguments[1];
+ name = arguments[3];
+ if (arguments.length > 2) {
+ value = arguments[2];
+ valueSpecified = true;
+ }
+ }
+
+ v = "" + v;
+ w = "" + w;
+ if (!_.isUndefined(name)) {
+ name = "" + name;
+ }
+
+ var e = edgeArgsToId(this._isDirected, v, w, name);
+ if (_.has(this._edgeLabels, e)) {
+ if (valueSpecified) {
+ this._edgeLabels[e] = value;
+ }
+ return this;
+ }
+
+ if (!_.isUndefined(name) && !this._isMultigraph) {
+ throw new Error("Cannot set a named edge when isMultigraph = false");
+ }
+
+ // It didn't exist, so we need to create it.
+ // First ensure the nodes exist.
+ this.setNode(v);
+ this.setNode(w);
+
+ this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
+
+ var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
+ // Ensure we add undirected edges in a consistent way.
+ v = edgeObj.v;
+ w = edgeObj.w;
+
+ Object.freeze(edgeObj);
+ this._edgeObjs[e] = edgeObj;
+ incrementOrInitEntry(this._preds[w], v);
+ incrementOrInitEntry(this._sucs[v], w);
+ this._in[w][e] = edgeObj;
+ this._out[v][e] = edgeObj;
+ this._edgeCount++;
+ return this;
+};
+
+Graph.prototype.edge = function(v, w, name) {
+ var e = (arguments.length === 1
+ ? edgeObjToId(this._isDirected, arguments[0])
+ : edgeArgsToId(this._isDirected, v, w, name));
+ return this._edgeLabels[e];
+};
+
+Graph.prototype.hasEdge = function(v, w, name) {
+ var e = (arguments.length === 1
+ ? edgeObjToId(this._isDirected, arguments[0])
+ : edgeArgsToId(this._isDirected, v, w, name));
+ return _.has(this._edgeLabels, e);
+};
+
+Graph.prototype.removeEdge = function(v, w, name) {
+ var e = (arguments.length === 1
+ ? edgeObjToId(this._isDirected, arguments[0])
+ : edgeArgsToId(this._isDirected, v, w, name)),
+ edge = this._edgeObjs[e];
+ if (edge) {
+ v = edge.v;
+ w = edge.w;
+ delete this._edgeLabels[e];
+ delete this._edgeObjs[e];
+ decrementOrRemoveEntry(this._preds[w], v);
+ decrementOrRemoveEntry(this._sucs[v], w);
+ delete this._in[w][e];
+ delete this._out[v][e];
+ this._edgeCount--;
+ }
+ return this;
+};
+
+Graph.prototype.inEdges = function(v, u) {
+ var inV = this._in[v];
+ if (inV) {
+ var edges = _.values(inV);
+ if (!u) {
+ return edges;
+ }
+ return _.filter(edges, function(edge) { return edge.v === u; });
+ }
+};
+
+Graph.prototype.outEdges = function(v, w) {
+ var outV = this._out[v];
+ if (outV) {
+ var edges = _.values(outV);
+ if (!w) {
+ return edges;
+ }
+ return _.filter(edges, function(edge) { return edge.w === w; });
+ }
+};
+
+Graph.prototype.nodeEdges = function(v, w) {
+ var inEdges = this.inEdges(v, w);
+ if (inEdges) {
+ return inEdges.concat(this.outEdges(v, w));
+ }
+};
+
+function incrementOrInitEntry(map, k) {
+ if (_.has(map, k)) {
+ map[k]++;
+ } else {
+ map[k] = 1;
+ }
+}
+
+function decrementOrRemoveEntry(map, k) {
+ if (!--map[k]) { delete map[k]; }
+}
+
+function edgeArgsToId(isDirected, v, w, name) {
+ if (!isDirected && v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+ return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM +
+ (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name);
+}
+
+function edgeArgsToObj(isDirected, v, w, name) {
+ if (!isDirected && v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+ var edgeObj = { v: v, w: w };
+ if (name) {
+ edgeObj.name = name;
+ }
+ return edgeObj;
+}
+
+function edgeObjToId(isDirected, edgeObj) {
+ return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
+}
+
+},{"./lodash":78}],76:[function(require,module,exports){
+// Includes only the "core" of graphlib
+module.exports = {
+ Graph: require("./graph"),
+ version: require("./version")
+};
+
+},{"./graph":75,"./version":79}],77:[function(require,module,exports){
+var _ = require("./lodash"),
+ Graph = require("./graph");
+
+module.exports = {
+ write: write,
+ read: read
+};
+
+function write(g) {
+ var json = {
+ options: {
+ directed: g.isDirected(),
+ multigraph: g.isMultigraph(),
+ compound: g.isCompound()
+ },
+ nodes: writeNodes(g),
+ edges: writeEdges(g)
+ };
+ if (!_.isUndefined(g.graph())) {
+ json.value = _.clone(g.graph());
+ }
+ return json;
+}
+
+function writeNodes(g) {
+ return _.map(g.nodes(), function(v) {
+ var nodeValue = g.node(v),
+ parent = g.parent(v),
+ node = { v: v };
+ if (!_.isUndefined(nodeValue)) {
+ node.value = nodeValue;
+ }
+ if (!_.isUndefined(parent)) {
+ node.parent = parent;
+ }
+ return node;
+ });
+}
+
+function writeEdges(g) {
+ return _.map(g.edges(), function(e) {
+ var edgeValue = g.edge(e),
+ edge = { v: e.v, w: e.w };
+ if (!_.isUndefined(e.name)) {
+ edge.name = e.name;
+ }
+ if (!_.isUndefined(edgeValue)) {
+ edge.value = edgeValue;
+ }
+ return edge;
+ });
+}
+
+function read(json) {
+ var g = new Graph(json.options).setGraph(json.value);
+ _.each(json.nodes, function(entry) {
+ g.setNode(entry.v, entry.value);
+ if (entry.parent) {
+ g.setParent(entry.v, entry.parent);
+ }
+ });
+ _.each(json.edges, function(entry) {
+ g.setEdge({ v: entry.v, w: entry.w, name: entry.name }, entry.value);
+ });
+ return g;
+}
+
+},{"./graph":75,"./lodash":78}],78:[function(require,module,exports){
+/* global window */
+
+var lodash;
+
+if (typeof require === "function") {
+ try {
+ lodash = require("lodash");
+ } catch (e) {}
+}
+
+if (!lodash) {
+ lodash = window._;
+}
+
+module.exports = lodash;
+
+},{"lodash":80}],79:[function(require,module,exports){
+module.exports = '1.0.3';
+
+},{}],80:[function(require,module,exports){
+(function (global){
+/**
+ * @license
+ * Lo-Dash 2.4.2 (Custom Build) <https://lodash.com/>
+ * Build: `lodash modern -o ./dist/lodash.js`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <https://lodash.com/license>
+ */
+;(function() {
+
+ /** Used as a safe reference for `undefined` in pre ES5 environments */
+ var undefined;
+
+ /** Used to pool arrays and objects used internally */
+ var arrayPool = [],
+ objectPool = [];
+
+ /** Used to generate unique IDs */
+ var idCounter = 0;
+
+ /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */
+ var keyPrefix = +new Date + '';
+
+ /** Used as the size when optimizations are enabled for large arrays */
+ var largeArraySize = 75;
+
+ /** Used as the max size of the `arrayPool` and `objectPool` */
+ var maxPoolSize = 40;
+
+ /** Used to detect and test whitespace */
+ var whitespace = (
+ // whitespace
+ ' \t\x0B\f\xA0\ufeff' +
+
+ // line terminators
+ '\n\r\u2028\u2029' +
+
+ // unicode category "Zs" space separators
+ '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
+ );
+
+ /** Used to match empty string literals in compiled template source */
+ var reEmptyStringLeading = /\b__p \+= '';/g,
+ reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+ reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+ /**
+ * Used to match ES6 template delimiters
+ * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals
+ */
+ var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+ /** Used to match regexp flags from their coerced string values */
+ var reFlags = /\w*$/;
+
+ /** Used to detected named functions */
+ var reFuncName = /^\s*function[ \n\r\t]+\w/;
+
+ /** Used to match "interpolate" template delimiters */
+ var reInterpolate = /<%=([\s\S]+?)%>/g;
+
+ /** Used to match leading whitespace and zeros to be removed */
+ var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');
+
+ /** Used to ensure capturing order of template delimiters */
+ var reNoMatch = /($^)/;
+
+ /** Used to detect functions containing a `this` reference */
+ var reThis = /\bthis\b/;
+
+ /** Used to match unescaped characters in compiled string literals */
+ var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
+
+ /** Used to assign default `context` object properties */
+ var contextProps = [
+ 'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object',
+ 'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',
+ 'parseInt', 'setTimeout'
+ ];
+
+ /** Used to make template sourceURLs easier to identify */
+ var templateCounter = 0;
+
+ /** `Object#toString` result shortcuts */
+ var argsClass = '[object Arguments]',
+ arrayClass = '[object Array]',
+ boolClass = '[object Boolean]',
+ dateClass = '[object Date]',
+ funcClass = '[object Function]',
+ numberClass = '[object Number]',
+ objectClass = '[object Object]',
+ regexpClass = '[object RegExp]',
+ stringClass = '[object String]';
+
+ /** Used to identify object classifications that `_.clone` supports */
+ var cloneableClasses = {};
+ cloneableClasses[funcClass] = false;
+ cloneableClasses[argsClass] = cloneableClasses[arrayClass] =
+ cloneableClasses[boolClass] = cloneableClasses[dateClass] =
+ cloneableClasses[numberClass] = cloneableClasses[objectClass] =
+ cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;
+
+ /** Used as an internal `_.debounce` options object */
+ var debounceOptions = {
+ 'leading': false,
+ 'maxWait': 0,
+ 'trailing': false
+ };
+
+ /** Used as the property descriptor for `__bindData__` */
+ var descriptor = {
+ 'configurable': false,
+ 'enumerable': false,
+ 'value': null,
+ 'writable': false
+ };
+
+ /** Used to determine if values are of the language type Object */
+ var objectTypes = {
+ 'boolean': false,
+ 'function': true,
+ 'object': true,
+ 'number': false,
+ 'string': false,
+ 'undefined': false
+ };
+
+ /** Used to escape characters for inclusion in compiled string literals */
+ var stringEscapes = {
+ '\\': '\\',
+ "'": "'",
+ '\n': 'n',
+ '\r': 'r',
+ '\t': 't',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ /** Used as a reference to the global object */
+ var root = (objectTypes[typeof window] && window) || this;
+
+ /** Detect free variable `exports` */
+ var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
+
+ /** Detect free variable `module` */
+ var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
+
+ /** Detect the popular CommonJS extension `module.exports` */
+ var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
+
+ /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
+ var freeGlobal = objectTypes[typeof global] && global;
+ if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
+ root = freeGlobal;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The base implementation of `_.indexOf` without support for binary searches
+ * or `fromIndex` constraints.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ */
+ function baseIndexOf(array, value, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0;
+
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * An implementation of `_.contains` for cache objects that mimics the return
+ * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.
+ *
+ * @private
+ * @param {Object} cache The cache object to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `0` if `value` is found, else `-1`.
+ */
+ function cacheIndexOf(cache, value) {
+ var type = typeof value;
+ cache = cache.cache;
+
+ if (type == 'boolean' || value == null) {
+ return cache[value] ? 0 : -1;
+ }
+ if (type != 'number' && type != 'string') {
+ type = 'object';
+ }
+ var key = type == 'number' ? value : keyPrefix + value;
+ cache = (cache = cache[type]) && cache[key];
+
+ return type == 'object'
+ ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)
+ : (cache ? 0 : -1);
+ }
+
+ /**
+ * Adds a given value to the corresponding cache object.
+ *
+ * @private
+ * @param {*} value The value to add to the cache.
+ */
+ function cachePush(value) {
+ var cache = this.cache,
+ type = typeof value;
+
+ if (type == 'boolean' || value == null) {
+ cache[value] = true;
+ } else {
+ if (type != 'number' && type != 'string') {
+ type = 'object';
+ }
+ var key = type == 'number' ? value : keyPrefix + value,
+ typeCache = cache[type] || (cache[type] = {});
+
+ if (type == 'object') {
+ (typeCache[key] || (typeCache[key] = [])).push(value);
+ } else {
+ typeCache[key] = true;
+ }
+ }
+ }
+
+ /**
+ * Used by `_.max` and `_.min` as the default callback when a given
+ * collection is a string value.
+ *
+ * @private
+ * @param {string} value The character to inspect.
+ * @returns {number} Returns the code unit of given character.
+ */
+ function charAtCallback(value) {
+ return value.charCodeAt(0);
+ }
+
+ /**
+ * Used by `sortBy` to compare transformed `collection` elements, stable sorting
+ * them in ascending order.
+ *
+ * @private
+ * @param {Object} a The object to compare to `b`.
+ * @param {Object} b The object to compare to `a`.
+ * @returns {number} Returns the sort order indicator of `1` or `-1`.
+ */
+ function compareAscending(a, b) {
+ var ac = a.criteria,
+ bc = b.criteria,
+ index = -1,
+ length = ac.length;
+
+ while (++index < length) {
+ var value = ac[index],
+ other = bc[index];
+
+ if (value !== other) {
+ if (value > other || typeof value == 'undefined') {
+ return 1;
+ }
+ if (value < other || typeof other == 'undefined') {
+ return -1;
+ }
+ }
+ }
+ // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
+ // that causes it, under certain circumstances, to return the same value for
+ // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247
+ //
+ // This also ensures a stable sort in V8 and other engines.
+ // See http://code.google.com/p/v8/issues/detail?id=90
+ return a.index - b.index;
+ }
+
+ /**
+ * Creates a cache object to optimize linear searches of large arrays.
+ *
+ * @private
+ * @param {Array} [array=[]] The array to search.
+ * @returns {null|Object} Returns the cache object or `null` if caching should not be used.
+ */
+ function createCache(array) {
+ var index = -1,
+ length = array.length,
+ first = array[0],
+ mid = array[(length / 2) | 0],
+ last = array[length - 1];
+
+ if (first && typeof first == 'object' &&
+ mid && typeof mid == 'object' && last && typeof last == 'object') {
+ return false;
+ }
+ var cache = getObject();
+ cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;
+
+ var result = getObject();
+ result.array = array;
+ result.cache = cache;
+ result.push = cachePush;
+
+ while (++index < length) {
+ result.push(array[index]);
+ }
+ return result;
+ }
+
+ /**
+ * Used by `template` to escape characters for inclusion in compiled
+ * string literals.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeStringChar(match) {
+ return '\\' + stringEscapes[match];
+ }
+
+ /**
+ * Gets an array from the array pool or creates a new one if the pool is empty.
+ *
+ * @private
+ * @returns {Array} The array from the pool.
+ */
+ function getArray() {
+ return arrayPool.pop() || [];
+ }
+
+ /**
+ * Gets an object from the object pool or creates a new one if the pool is empty.
+ *
+ * @private
+ * @returns {Object} The object from the pool.
+ */
+ function getObject() {
+ return objectPool.pop() || {
+ 'array': null,
+ 'cache': null,
+ 'criteria': null,
+ 'false': false,
+ 'index': 0,
+ 'null': false,
+ 'number': null,
+ 'object': null,
+ 'push': null,
+ 'string': null,
+ 'true': false,
+ 'undefined': false,
+ 'value': null
+ };
+ }
+
+ /**
+ * Releases the given array back to the array pool.
+ *
+ * @private
+ * @param {Array} [array] The array to release.
+ */
+ function releaseArray(array) {
+ array.length = 0;
+ if (arrayPool.length < maxPoolSize) {
+ arrayPool.push(array);
+ }
+ }
+
+ /**
+ * Releases the given object back to the object pool.
+ *
+ * @private
+ * @param {Object} [object] The object to release.
+ */
+ function releaseObject(object) {
+ var cache = object.cache;
+ if (cache) {
+ releaseObject(cache);
+ }
+ object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;
+ if (objectPool.length < maxPoolSize) {
+ objectPool.push(object);
+ }
+ }
+
+ /**
+ * Slices the `collection` from the `start` index up to, but not including,
+ * the `end` index.
+ *
+ * Note: This function is used instead of `Array#slice` to support node lists
+ * in IE < 9 and to ensure dense arrays are returned.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to slice.
+ * @param {number} start The start index.
+ * @param {number} end The end index.
+ * @returns {Array} Returns the new array.
+ */
+ function slice(array, start, end) {
+ start || (start = 0);
+ if (typeof end == 'undefined') {
+ end = array ? array.length : 0;
+ }
+ var index = -1,
+ length = end - start || 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = array[start + index];
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Create a new `lodash` function using the given context object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} [context=root] The context object.
+ * @returns {Function} Returns the `lodash` function.
+ */
+ function runInContext(context) {
+ // Avoid issues with some ES3 environments that attempt to use values, named
+ // after built-in constructors like `Object`, for the creation of literals.
+ // ES5 clears this up by stating that literals must use built-in constructors.
+ // See http://es5.github.io/#x11.1.5.
+ context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;
+
+ /** Native constructor references */
+ var Array = context.Array,
+ Boolean = context.Boolean,
+ Date = context.Date,
+ Function = context.Function,
+ Math = context.Math,
+ Number = context.Number,
+ Object = context.Object,
+ RegExp = context.RegExp,
+ String = context.String,
+ TypeError = context.TypeError;
+
+ /**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+ var arrayRef = [];
+
+ /** Used for native method references */
+ var objectProto = Object.prototype;
+
+ /** Used to restore the original `_` reference in `noConflict` */
+ var oldDash = context._;
+
+ /** Used to resolve the internal [[Class]] of values */
+ var toString = objectProto.toString;
+
+ /** Used to detect if a method is native */
+ var reNative = RegExp('^' +
+ String(toString)
+ .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+ .replace(/toString| for [^\]]+/g, '.*?') + '$'
+ );
+
+ /** Native method shortcuts */
+ var ceil = Math.ceil,
+ clearTimeout = context.clearTimeout,
+ floor = Math.floor,
+ fnToString = Function.prototype.toString,
+ getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
+ hasOwnProperty = objectProto.hasOwnProperty,
+ push = arrayRef.push,
+ setTimeout = context.setTimeout,
+ splice = arrayRef.splice,
+ unshift = arrayRef.unshift;
+
+ /** Used to set meta data on functions */
+ var defineProperty = (function() {
+ // IE 8 only accepts DOM elements
+ try {
+ var o = {},
+ func = isNative(func = Object.defineProperty) && func,
+ result = func(o, o, o) && func;
+ } catch(e) { }
+ return result;
+ }());
+
+ /* Native method shortcuts for methods with the same name as other `lodash` methods */
+ var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate,
+ nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray,
+ nativeIsFinite = context.isFinite,
+ nativeIsNaN = context.isNaN,
+ nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys,
+ nativeMax = Math.max,
+ nativeMin = Math.min,
+ nativeParseInt = context.parseInt,
+ nativeRandom = Math.random;
+
+ /** Used to lookup a built-in constructor by [[Class]] */
+ var ctorByClass = {};
+ ctorByClass[arrayClass] = Array;
+ ctorByClass[boolClass] = Boolean;
+ ctorByClass[dateClass] = Date;
+ ctorByClass[funcClass] = Function;
+ ctorByClass[objectClass] = Object;
+ ctorByClass[numberClass] = Number;
+ ctorByClass[regexpClass] = RegExp;
+ ctorByClass[stringClass] = String;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object which wraps the given value to enable intuitive
+ * method chaining.
+ *
+ * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
+ * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,
+ * and `unshift`
+ *
+ * Chaining is supported in custom builds as long as the `value` method is
+ * implicitly or explicitly included in the build.
+ *
+ * The chainable wrapper functions are:
+ * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,
+ * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`,
+ * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`,
+ * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,
+ * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,
+ * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
+ * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`,
+ * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`,
+ * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`,
+ * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`,
+ * and `zip`
+ *
+ * The non-chainable wrapper functions are:
+ * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`,
+ * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`,
+ * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,
+ * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`,
+ * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`,
+ * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`,
+ * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`,
+ * `template`, `unescape`, `uniqueId`, and `value`
+ *
+ * The wrapper functions `first` and `last` return wrapped values when `n` is
+ * provided, otherwise they return unwrapped values.
+ *
+ * Explicit chaining can be enabled by using the `_.chain` method.
+ *
+ * @name _
+ * @constructor
+ * @category Chaining
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @returns {Object} Returns a `lodash` instance.
+ * @example
+ *
+ * var wrapped = _([1, 2, 3]);
+ *
+ * // returns an unwrapped value
+ * wrapped.reduce(function(sum, num) {
+ * return sum + num;
+ * });
+ * // => 6
+ *
+ * // returns a wrapped value
+ * var squares = wrapped.map(function(num) {
+ * return num * num;
+ * });
+ *
+ * _.isArray(squares);
+ * // => false
+ *
+ * _.isArray(squares.value());
+ * // => true
+ */
+ function lodash(value) {
+ // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor
+ return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))
+ ? value
+ : new lodashWrapper(value);
+ }
+
+ /**
+ * A fast path for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @param {boolean} chainAll A flag to enable chaining for all methods
+ * @returns {Object} Returns a `lodash` instance.
+ */
+ function lodashWrapper(value, chainAll) {
+ this.__chain__ = !!chainAll;
+ this.__wrapped__ = value;
+ }
+ // ensure `new lodashWrapper` is an instance of `lodash`
+ lodashWrapper.prototype = lodash.prototype;
+
+ /**
+ * An object used to flag environments features.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ var support = lodash.support = {};
+
+ /**
+ * Detect if functions can be decompiled by `Function#toString`
+ * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcDecomp = !isNative(context.WinRTError) && reThis.test(runInContext);
+
+ /**
+ * Detect if `Function#name` is supported (all but IE).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcNames = typeof Function.name == 'string';
+
+ /**
+ * By default, the template delimiters used by Lo-Dash are similar to those in
+ * embedded Ruby (ERB). Change the following template settings to use alternative
+ * delimiters.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ lodash.templateSettings = {
+
+ /**
+ * Used to detect `data` property values to be HTML-escaped.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'escape': /<%-([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect code to be evaluated.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'evaluate': /<%([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect `data` property values to inject.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'interpolate': reInterpolate,
+
+ /**
+ * Used to reference the data object in the template text.
+ *
+ * @memberOf _.templateSettings
+ * @type string
+ */
+ 'variable': '',
+
+ /**
+ * Used to import variables into the compiled template.
+ *
+ * @memberOf _.templateSettings
+ * @type Object
+ */
+ 'imports': {
+
+ /**
+ * A reference to the `lodash` function.
+ *
+ * @memberOf _.templateSettings.imports
+ * @type Function
+ */
+ '_': lodash
+ }
+ };
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The base implementation of `_.bind` that creates the bound function and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new bound function.
+ */
+ function baseBind(bindData) {
+ var func = bindData[0],
+ partialArgs = bindData[2],
+ thisArg = bindData[4];
+
+ function bound() {
+ // `Function#bind` spec
+ // http://es5.github.io/#x15.3.4.5
+ if (partialArgs) {
+ // avoid `arguments` object deoptimizations by using `slice` instead
+ // of `Array.prototype.slice.call` and not assigning `arguments` to a
+ // variable as a ternary expression
+ var args = slice(partialArgs);
+ push.apply(args, arguments);
+ }
+ // mimic the constructor's `return` behavior
+ // http://es5.github.io/#x13.2.2
+ if (this instanceof bound) {
+ // ensure `new bound` is an instance of `func`
+ var thisBinding = baseCreate(func.prototype),
+ result = func.apply(thisBinding, args || arguments);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisArg, args || arguments);
+ }
+ setBindData(bound, bindData);
+ return bound;
+ }
+
+ /**
+ * The base implementation of `_.clone` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep=false] Specify a deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates clones with source counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+ function baseClone(value, isDeep, callback, stackA, stackB) {
+ if (callback) {
+ var result = callback(value);
+ if (typeof result != 'undefined') {
+ return result;
+ }
+ }
+ // inspect [[Class]]
+ var isObj = isObject(value);
+ if (isObj) {
+ var className = toString.call(value);
+ if (!cloneableClasses[className]) {
+ return value;
+ }
+ var ctor = ctorByClass[className];
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ return new ctor(+value);
+
+ case numberClass:
+ case stringClass:
+ return new ctor(value);
+
+ case regexpClass:
+ result = ctor(value.source, reFlags.exec(value));
+ result.lastIndex = value.lastIndex;
+ return result;
+ }
+ } else {
+ return value;
+ }
+ var isArr = isArray(value);
+ if (isDeep) {
+ // check for circular references and return corresponding clone
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == value) {
+ return stackB[length];
+ }
+ }
+ result = isArr ? ctor(value.length) : {};
+ }
+ else {
+ result = isArr ? slice(value) : assign({}, value);
+ }
+ // add array properties assigned by `RegExp#exec`
+ if (isArr) {
+ if (hasOwnProperty.call(value, 'index')) {
+ result.index = value.index;
+ }
+ if (hasOwnProperty.call(value, 'input')) {
+ result.input = value.input;
+ }
+ }
+ // exit for shallow clone
+ if (!isDeep) {
+ return result;
+ }
+ // add the source value to the stack of traversed objects
+ // and associate it with its clone
+ stackA.push(value);
+ stackB.push(result);
+
+ // recursively populate clone (susceptible to call stack limits)
+ (isArr ? forEach : forOwn)(value, function(objValue, key) {
+ result[key] = baseClone(objValue, isDeep, callback, stackA, stackB);
+ });
+
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+ function baseCreate(prototype, properties) {
+ return isObject(prototype) ? nativeCreate(prototype) : {};
+ }
+ // fallback for browsers without `Object.create`
+ if (!nativeCreate) {
+ baseCreate = (function() {
+ function Object() {}
+ return function(prototype) {
+ if (isObject(prototype)) {
+ Object.prototype = prototype;
+ var result = new Object;
+ Object.prototype = null;
+ }
+ return result || context.Object();
+ };
+ }());
+ }
+
+ /**
+ * The base implementation of `_.createCallback` without support for creating
+ * "_.pluck" or "_.where" style callbacks.
+ *
+ * @private
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ */
+ function baseCreateCallback(func, thisArg, argCount) {
+ if (typeof func != 'function') {
+ return identity;
+ }
+ // exit early for no `thisArg` or already bound by `Function#bind`
+ if (typeof thisArg == 'undefined' || !('prototype' in func)) {
+ return func;
+ }
+ var bindData = func.__bindData__;
+ if (typeof bindData == 'undefined') {
+ if (support.funcNames) {
+ bindData = !func.name;
+ }
+ bindData = bindData || !support.funcDecomp;
+ if (!bindData) {
+ var source = fnToString.call(func);
+ if (!support.funcNames) {
+ bindData = !reFuncName.test(source);
+ }
+ if (!bindData) {
+ // checks if `func` references the `this` keyword and stores the result
+ bindData = reThis.test(source);
+ setBindData(func, bindData);
+ }
+ }
+ }
+ // exit early if there are no `this` references or `func` is bound
+ if (bindData === false || (bindData !== true && bindData[1] & 1)) {
+ return func;
+ }
+ switch (argCount) {
+ case 1: return function(value) {
+ return func.call(thisArg, value);
+ };
+ case 2: return function(a, b) {
+ return func.call(thisArg, a, b);
+ };
+ case 3: return function(value, index, collection) {
+ return func.call(thisArg, value, index, collection);
+ };
+ case 4: return function(accumulator, value, index, collection) {
+ return func.call(thisArg, accumulator, value, index, collection);
+ };
+ }
+ return bind(func, thisArg);
+ }
+
+ /**
+ * The base implementation of `createWrapper` that creates the wrapper and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new function.
+ */
+ function baseCreateWrapper(bindData) {
+ var func = bindData[0],
+ bitmask = bindData[1],
+ partialArgs = bindData[2],
+ partialRightArgs = bindData[3],
+ thisArg = bindData[4],
+ arity = bindData[5];
+
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ key = func;
+
+ function bound() {
+ var thisBinding = isBind ? thisArg : this;
+ if (partialArgs) {
+ var args = slice(partialArgs);
+ push.apply(args, arguments);
+ }
+ if (partialRightArgs || isCurry) {
+ args || (args = slice(arguments));
+ if (partialRightArgs) {
+ push.apply(args, partialRightArgs);
+ }
+ if (isCurry && args.length < arity) {
+ bitmask |= 16 & ~32;
+ return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
+ }
+ }
+ args || (args = arguments);
+ if (isBindKey) {
+ func = thisBinding[key];
+ }
+ if (this instanceof bound) {
+ thisBinding = baseCreate(func.prototype);
+ var result = func.apply(thisBinding, args);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisBinding, args);
+ }
+ setBindData(bound, bindData);
+ return bound;
+ }
+
+ /**
+ * The base implementation of `_.difference` that accepts a single array
+ * of values to exclude.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {Array} [values] The array of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ */
+ function baseDifference(array, values) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ isLarge = length >= largeArraySize && indexOf === baseIndexOf,
+ result = [];
+
+ if (isLarge) {
+ var cache = createCache(values);
+ if (cache) {
+ indexOf = cacheIndexOf;
+ values = cache;
+ } else {
+ isLarge = false;
+ }
+ }
+ while (++index < length) {
+ var value = array[index];
+ if (indexOf(values, value) < 0) {
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseObject(values);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.flatten` without support for callback
+ * shorthands or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {boolean} [isStrict=false] A flag to restrict flattening to arrays and `arguments` objects.
+ * @param {number} [fromIndex=0] The index to start from.
+ * @returns {Array} Returns a new flattened array.
+ */
+ function baseFlatten(array, isShallow, isStrict, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+
+ if (value && typeof value == 'object' && typeof value.length == 'number'
+ && (isArray(value) || isArguments(value))) {
+ // recursively flatten arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ value = baseFlatten(value, isShallow, isStrict);
+ }
+ var valIndex = -1,
+ valLength = value.length,
+ resIndex = result.length;
+
+ result.length += valLength;
+ while (++valIndex < valLength) {
+ result[resIndex++] = value[valIndex];
+ }
+ } else if (!isStrict) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.isEqual`, without support for `thisArg` binding,
+ * that allows partial "_.where" style comparisons.
+ *
+ * @private
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {Function} [isWhere=false] A flag to indicate performing partial comparisons.
+ * @param {Array} [stackA=[]] Tracks traversed `a` objects.
+ * @param {Array} [stackB=[]] Tracks traversed `b` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+ function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
+ // used to indicate that when comparing objects, `a` has at least the properties of `b`
+ if (callback) {
+ var result = callback(a, b);
+ if (typeof result != 'undefined') {
+ return !!result;
+ }
+ }
+ // exit early for identical values
+ if (a === b) {
+ // treat `+0` vs. `-0` as not equal
+ return a !== 0 || (1 / a == 1 / b);
+ }
+ var type = typeof a,
+ otherType = typeof b;
+
+ // exit early for unlike primitive values
+ if (a === a &&
+ !(a && objectTypes[type]) &&
+ !(b && objectTypes[otherType])) {
+ return false;
+ }
+ // exit early for `null` and `undefined` avoiding ES3's Function#call behavior
+ // http://es5.github.io/#x15.3.4.4
+ if (a == null || b == null) {
+ return a === b;
+ }
+ // compare [[Class]] names
+ var className = toString.call(a),
+ otherClass = toString.call(b);
+
+ if (className == argsClass) {
+ className = objectClass;
+ }
+ if (otherClass == argsClass) {
+ otherClass = objectClass;
+ }
+ if (className != otherClass) {
+ return false;
+ }
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ // coerce dates and booleans to numbers, dates to milliseconds and booleans
+ // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
+ return +a == +b;
+
+ case numberClass:
+ // treat `NaN` vs. `NaN` as equal
+ return (a != +a)
+ ? b != +b
+ // but treat `+0` vs. `-0` as not equal
+ : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+ case regexpClass:
+ case stringClass:
+ // coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
+ // treat string primitives and their corresponding object instances as equal
+ return a == String(b);
+ }
+ var isArr = className == arrayClass;
+ if (!isArr) {
+ // unwrap any `lodash` wrapped values
+ var aWrapped = hasOwnProperty.call(a, '__wrapped__'),
+ bWrapped = hasOwnProperty.call(b, '__wrapped__');
+
+ if (aWrapped || bWrapped) {
+ return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);
+ }
+ // exit for functions and DOM nodes
+ if (className != objectClass) {
+ return false;
+ }
+ // in older versions of Opera, `arguments` objects have `Array` constructors
+ var ctorA = a.constructor,
+ ctorB = b.constructor;
+
+ // non `Object` object instances with different constructors are not equal
+ if (ctorA != ctorB &&
+ !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
+ ('constructor' in a && 'constructor' in b)
+ ) {
+ return false;
+ }
+ }
+ // assume cyclic structures are equal
+ // the algorithm for detecting cyclic structures is adapted from ES 5.1
+ // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == a) {
+ return stackB[length] == b;
+ }
+ }
+ var size = 0;
+ result = true;
+
+ // add `a` and `b` to the stack of traversed objects
+ stackA.push(a);
+ stackB.push(b);
+
+ // recursively compare objects and arrays (susceptible to call stack limits)
+ if (isArr) {
+ // compare lengths to determine if a deep comparison is necessary
+ length = a.length;
+ size = b.length;
+ result = size == length;
+
+ if (result || isWhere) {
+ // deep compare the contents, ignoring non-numeric properties
+ while (size--) {
+ var index = length,
+ value = b[size];
+
+ if (isWhere) {
+ while (index--) {
+ if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ }
+ }
+ else {
+ // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+ // which, in this case, is more costly
+ forIn(b, function(value, key, b) {
+ if (hasOwnProperty.call(b, key)) {
+ // count the number of properties.
+ size++;
+ // deep compare each property value.
+ return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB));
+ }
+ });
+
+ if (result && !isWhere) {
+ // ensure both objects have the same number of properties
+ forIn(a, function(value, key, a) {
+ if (hasOwnProperty.call(a, key)) {
+ // `size` will be `-1` if `a` has more properties than `b`
+ return (result = --size > -1);
+ }
+ });
+ }
+ }
+ stackA.pop();
+ stackB.pop();
+
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.merge` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates values with source counterparts.
+ */
+ function baseMerge(object, source, callback, stackA, stackB) {
+ (isArray(source) ? forEach : forOwn)(source, function(source, key) {
+ var found,
+ isArr,
+ result = source,
+ value = object[key];
+
+ if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+ // avoid merging previously merged cyclic sources
+ var stackLength = stackA.length;
+ while (stackLength--) {
+ if ((found = stackA[stackLength] == source)) {
+ value = stackB[stackLength];
+ break;
+ }
+ }
+ if (!found) {
+ var isShallow;
+ if (callback) {
+ result = callback(value, source);
+ if ((isShallow = typeof result != 'undefined')) {
+ value = result;
+ }
+ }
+ if (!isShallow) {
+ value = isArr
+ ? (isArray(value) ? value : [])
+ : (isPlainObject(value) ? value : {});
+ }
+ // add `source` and associated `value` to the stack of traversed objects
+ stackA.push(source);
+ stackB.push(value);
+
+ // recursively merge objects and arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ baseMerge(value, source, callback, stackA, stackB);
+ }
+ }
+ }
+ else {
+ if (callback) {
+ result = callback(value, source);
+ if (typeof result == 'undefined') {
+ result = source;
+ }
+ }
+ if (typeof result != 'undefined') {
+ value = result;
+ }
+ }
+ object[key] = value;
+ });
+ }
+
+ /**
+ * The base implementation of `_.random` without argument juggling or support
+ * for returning floating-point numbers.
+ *
+ * @private
+ * @param {number} min The minimum possible value.
+ * @param {number} max The maximum possible value.
+ * @returns {number} Returns a random number.
+ */
+ function baseRandom(min, max) {
+ return min + floor(nativeRandom() * (max - min + 1));
+ }
+
+ /**
+ * The base implementation of `_.uniq` without support for callback shorthands
+ * or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function} [callback] The function called per iteration.
+ * @returns {Array} Returns a duplicate-value-free array.
+ */
+ function baseUniq(array, isSorted, callback) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ result = [];
+
+ var isLarge = !isSorted && length >= largeArraySize && indexOf === baseIndexOf,
+ seen = (callback || isLarge) ? getArray() : result;
+
+ if (isLarge) {
+ var cache = createCache(seen);
+ indexOf = cacheIndexOf;
+ seen = cache;
+ }
+ while (++index < length) {
+ var value = array[index],
+ computed = callback ? callback(value, index, array) : value;
+
+ if (isSorted
+ ? !index || seen[seen.length - 1] !== computed
+ : indexOf(seen, computed) < 0
+ ) {
+ if (callback || isLarge) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseArray(seen.array);
+ releaseObject(seen);
+ } else if (callback) {
+ releaseArray(seen);
+ }
+ return result;
+ }
+
+ /**
+ * Creates a function that aggregates a collection, creating an object composed
+ * of keys generated from the results of running each element of the collection
+ * through a callback. The given `setter` function sets the keys and values
+ * of the composed object.
+ *
+ * @private
+ * @param {Function} setter The setter function.
+ * @returns {Function} Returns the new aggregator function.
+ */
+ function createAggregator(setter) {
+ return function(collection, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ setter(result, value, callback(value, index, collection), collection);
+ }
+ } else {
+ forOwn(collection, function(value, key, collection) {
+ setter(result, value, callback(value, key, collection), collection);
+ });
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, either curries or invokes `func`
+ * with an optional `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of method flags to compose.
+ * The bitmask may be composed of the following flags:
+ * 1 - `_.bind`
+ * 2 - `_.bindKey`
+ * 4 - `_.curry`
+ * 8 - `_.curry` (bound)
+ * 16 - `_.partial`
+ * 32 - `_.partialRight`
+ * @param {Array} [partialArgs] An array of arguments to prepend to those
+ * provided to the new function.
+ * @param {Array} [partialRightArgs] An array of arguments to append to those
+ * provided to the new function.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new function.
+ */
+ function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ isPartial = bitmask & 16,
+ isPartialRight = bitmask & 32;
+
+ if (!isBindKey && !isFunction(func)) {
+ throw new TypeError;
+ }
+ if (isPartial && !partialArgs.length) {
+ bitmask &= ~16;
+ isPartial = partialArgs = false;
+ }
+ if (isPartialRight && !partialRightArgs.length) {
+ bitmask &= ~32;
+ isPartialRight = partialRightArgs = false;
+ }
+ var bindData = func && func.__bindData__;
+ if (bindData && bindData !== true) {
+ // clone `bindData`
+ bindData = slice(bindData);
+ if (bindData[2]) {
+ bindData[2] = slice(bindData[2]);
+ }
+ if (bindData[3]) {
+ bindData[3] = slice(bindData[3]);
+ }
+ // set `thisBinding` is not previously bound
+ if (isBind && !(bindData[1] & 1)) {
+ bindData[4] = thisArg;
+ }
+ // set if previously bound but not currently (subsequent curried functions)
+ if (!isBind && bindData[1] & 1) {
+ bitmask |= 8;
+ }
+ // set curried arity if not yet set
+ if (isCurry && !(bindData[1] & 4)) {
+ bindData[5] = arity;
+ }
+ // append partial left arguments
+ if (isPartial) {
+ push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+ }
+ // append partial right arguments
+ if (isPartialRight) {
+ unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+ }
+ // merge flags
+ bindData[1] |= bitmask;
+ return createWrapper.apply(null, bindData);
+ }
+ // fast path for `_.bind`
+ var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
+ return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
+ }
+
+ /**
+ * Used by `escape` to convert characters to HTML entities.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeHtmlChar(match) {
+ return htmlEscapes[match];
+ }
+
+ /**
+ * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
+ * customized, this method returns the custom method, otherwise it returns
+ * the `baseIndexOf` function.
+ *
+ * @private
+ * @returns {Function} Returns the "indexOf" function.
+ */
+ function getIndexOf() {
+ var result = (result = lodash.indexOf) === indexOf ? baseIndexOf : result;
+ return result;
+ }
+
+ /**
+ * Checks if `value` is a native function.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a native function, else `false`.
+ */
+ function isNative(value) {
+ return typeof value == 'function' && reNative.test(value);
+ }
+
+ /**
+ * Sets `this` binding data on a given function.
+ *
+ * @private
+ * @param {Function} func The function to set data on.
+ * @param {Array} value The data array to set.
+ */
+ var setBindData = !defineProperty ? noop : function(func, value) {
+ descriptor.value = value;
+ defineProperty(func, '__bindData__', descriptor);
+ descriptor.value = null;
+ };
+
+ /**
+ * A fallback implementation of `isPlainObject` which checks if a given value
+ * is an object created by the `Object` constructor, assuming objects created
+ * by the `Object` constructor have no inherited enumerable properties and that
+ * there are no `Object.prototype` extensions.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ */
+ function shimIsPlainObject(value) {
+ var ctor,
+ result;
+
+ // avoid non Object objects, `arguments` objects, and DOM elements
+ if (!(value && toString.call(value) == objectClass) ||
+ (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor))) {
+ return false;
+ }
+ // In most environments an object's own properties are iterated before
+ // its inherited properties. If the last iterated property is an object's
+ // own property then there are no inherited enumerable properties.
+ forIn(value, function(value, key) {
+ result = key;
+ });
+ return typeof result == 'undefined' || hasOwnProperty.call(value, result);
+ }
+
+ /**
+ * Used by `unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {string} match The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
+ */
+ function unescapeHtmlChar(match) {
+ return htmlUnescapes[match];
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Checks if `value` is an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`.
+ * @example
+ *
+ * (function() { return _.isArguments(arguments); })(1, 2, 3);
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+ function isArguments(value) {
+ return value && typeof value == 'object' && typeof value.length == 'number' &&
+ toString.call(value) == argsClass || false;
+ }
+
+ /**
+ * Checks if `value` is an array.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an array, else `false`.
+ * @example
+ *
+ * (function() { return _.isArray(arguments); })();
+ * // => false
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ */
+ var isArray = nativeIsArray || function(value) {
+ return value && typeof value == 'object' && typeof value.length == 'number' &&
+ toString.call(value) == arrayClass || false;
+ };
+
+ /**
+ * A fallback implementation of `Object.keys` which produces an array of the
+ * given object's own enumerable property names.
+ *
+ * @private
+ * @type Function
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ */
+ var shimKeys = function(object) {
+ var index, iterable = object, result = [];
+ if (!iterable) return result;
+ if (!(objectTypes[typeof object])) return result;
+ for (index in iterable) {
+ if (hasOwnProperty.call(iterable, index)) {
+ result.push(index);
+ }
+ }
+ return result
+ };
+
+ /**
+ * Creates an array composed of the own enumerable property names of an object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ * @example
+ *
+ * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
+ */
+ var keys = !nativeKeys ? shimKeys : function(object) {
+ if (!isObject(object)) {
+ return [];
+ }
+ return nativeKeys(object);
+ };
+
+ /**
+ * Used to convert characters to HTML entities:
+ *
+ * Though the `>` character is escaped for symmetry, characters like `>` and `/`
+ * don't require escaping in HTML and have no special meaning unless they're part
+ * of a tag or an unquoted attribute value.
+ * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
+ */
+ var htmlEscapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ /** Used to convert HTML entities to characters */
+ var htmlUnescapes = invert(htmlEscapes);
+
+ /** Used to match HTML entities and HTML characters */
+ var reEscapedHtml = RegExp('(' + keys(htmlUnescapes).join('|') + ')', 'g'),
+ reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object. Subsequent sources will overwrite property assignments of previous
+ * sources. If a callback is provided it will be executed to produce the
+ * assigned values. The callback is bound to `thisArg` and invoked with two
+ * arguments; (objectValue, sourceValue).
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @alias extend
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param {Function} [callback] The function to customize assigning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * _.assign({ 'name': 'fred' }, { 'employer': 'slate' });
+ * // => { 'name': 'fred', 'employer': 'slate' }
+ *
+ * var defaults = _.partialRight(_.assign, function(a, b) {
+ * return typeof a == 'undefined' ? b : a;
+ * });
+ *
+ * var object = { 'name': 'barney' };
+ * defaults(object, { 'name': 'fred', 'employer': 'slate' });
+ * // => { 'name': 'barney', 'employer': 'slate' }
+ */
+ var assign = function(object, source, guard) {
+ var index, iterable = object, result = iterable;
+ if (!iterable) return result;
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = typeof guard == 'number' ? 2 : args.length;
+ if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
+ var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);
+ } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
+ callback = args[--argsLength];
+ }
+ while (++argsIndex < argsLength) {
+ iterable = args[argsIndex];
+ if (iterable && objectTypes[typeof iterable]) {
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ result[index] = callback ? callback(result[index], iterable[index]) : iterable[index];
+ }
+ }
+ }
+ return result
+ };
+
+ /**
+ * Creates a clone of `value`. If `isDeep` is `true` nested objects will also
+ * be cloned, otherwise they will be assigned by reference. If a callback
+ * is provided it will be executed to produce the cloned values. If the
+ * callback returns `undefined` cloning will be handled by the method instead.
+ * The callback is bound to `thisArg` and invoked with one argument; (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep=false] Specify a deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the cloned value.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * var shallow = _.clone(characters);
+ * shallow[0] === characters[0];
+ * // => true
+ *
+ * var deep = _.clone(characters, true);
+ * deep[0] === characters[0];
+ * // => false
+ *
+ * _.mixin({
+ * 'clone': _.partialRight(_.clone, function(value) {
+ * return _.isElement(value) ? value.cloneNode(false) : undefined;
+ * })
+ * });
+ *
+ * var clone = _.clone(document.body);
+ * clone.childNodes.length;
+ * // => 0
+ */
+ function clone(value, isDeep, callback, thisArg) {
+ // allows working with "Collections" methods without using their `index`
+ // and `collection` arguments for `isDeep` and `callback`
+ if (typeof isDeep != 'boolean' && isDeep != null) {
+ thisArg = callback;
+ callback = isDeep;
+ isDeep = false;
+ }
+ return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
+ }
+
+ /**
+ * Creates a deep clone of `value`. If a callback is provided it will be
+ * executed to produce the cloned values. If the callback returns `undefined`
+ * cloning will be handled by the method instead. The callback is bound to
+ * `thisArg` and invoked with one argument; (value).
+ *
+ * Note: This method is loosely based on the structured clone algorithm. Functions
+ * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
+ * objects created by constructors other than `Object` are cloned to plain `Object` objects.
+ * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the deep cloned value.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * var deep = _.cloneDeep(characters);
+ * deep[0] === characters[0];
+ * // => false
+ *
+ * var view = {
+ * 'label': 'docs',
+ * 'node': element
+ * };
+ *
+ * var clone = _.cloneDeep(view, function(value) {
+ * return _.isElement(value) ? value.cloneNode(true) : undefined;
+ * });
+ *
+ * clone.node == view.node;
+ * // => false
+ */
+ function cloneDeep(value, callback, thisArg) {
+ return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
+ }
+
+ /**
+ * Creates an object that inherits from the given `prototype` object. If a
+ * `properties` object is provided its own enumerable properties are assigned
+ * to the created object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} prototype The object to inherit from.
+ * @param {Object} [properties] The properties to assign to the object.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * function Circle() {
+ * Shape.call(this);
+ * }
+ *
+ * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle });
+ *
+ * var circle = new Circle;
+ * circle instanceof Circle;
+ * // => true
+ *
+ * circle instanceof Shape;
+ * // => true
+ */
+ function create(prototype, properties) {
+ var result = baseCreate(prototype);
+ return properties ? assign(result, properties) : result;
+ }
+
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object for all destination properties that resolve to `undefined`. Once a
+ * property is set, additional defaults of the same property will be ignored.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param- {Object} [guard] Allows working with `_.reduce` without using its
+ * `key` and `object` arguments as sources.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var object = { 'name': 'barney' };
+ * _.defaults(object, { 'name': 'fred', 'employer': 'slate' });
+ * // => { 'name': 'barney', 'employer': 'slate' }
+ */
+ var defaults = function(object, source, guard) {
+ var index, iterable = object, result = iterable;
+ if (!iterable) return result;
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = typeof guard == 'number' ? 2 : args.length;
+ while (++argsIndex < argsLength) {
+ iterable = args[argsIndex];
+ if (iterable && objectTypes[typeof iterable]) {
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ if (typeof result[index] == 'undefined') result[index] = iterable[index];
+ }
+ }
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.findIndex` except that it returns the key of the
+ * first element that passes the callback check, instead of the element itself.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @param {Function|Object|string} [callback=identity] The function called per
+ * iteration. If a property name or object is provided it will be used to
+ * create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * var characters = {
+ * 'barney': { 'age': 36, 'blocked': false },
+ * 'fred': { 'age': 40, 'blocked': true },
+ * 'pebbles': { 'age': 1, 'blocked': false }
+ * };
+ *
+ * _.findKey(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => 'barney' (property order is not guaranteed across environments)
+ *
+ * // using "_.where" callback shorthand
+ * _.findKey(characters, { 'age': 1 });
+ * // => 'pebbles'
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findKey(characters, 'blocked');
+ * // => 'fred'
+ */
+ function findKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * This method is like `_.findKey` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @param {Function|Object|string} [callback=identity] The function called per
+ * iteration. If a property name or object is provided it will be used to
+ * create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * var characters = {
+ * 'barney': { 'age': 36, 'blocked': true },
+ * 'fred': { 'age': 40, 'blocked': false },
+ * 'pebbles': { 'age': 1, 'blocked': true }
+ * };
+ *
+ * _.findLastKey(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => returns `pebbles`, assuming `_.findKey` returns `barney`
+ *
+ * // using "_.where" callback shorthand
+ * _.findLastKey(characters, { 'age': 40 });
+ * // => 'fred'
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findLastKey(characters, 'blocked');
+ * // => 'pebbles'
+ */
+ function findLastKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwnRight(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over own and inherited enumerable properties of an object,
+ * executing the callback for each property. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, key, object). Callbacks may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * Shape.prototype.move = function(x, y) {
+ * this.x += x;
+ * this.y += y;
+ * };
+ *
+ * _.forIn(new Shape, function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments)
+ */
+ var forIn = function(collection, callback, thisArg) {
+ var index, iterable = collection, result = iterable;
+ if (!iterable) return result;
+ if (!objectTypes[typeof iterable]) return result;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ for (index in iterable) {
+ if (callback(iterable[index], index, collection) === false) return result;
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.forIn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * Shape.prototype.move = function(x, y) {
+ * this.x += x;
+ * this.y += y;
+ * };
+ *
+ * _.forInRight(new Shape, function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move'
+ */
+ function forInRight(object, callback, thisArg) {
+ var pairs = [];
+
+ forIn(object, function(value, key) {
+ pairs.push(key, value);
+ });
+
+ var length = pairs.length;
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(pairs[length--], pairs[length], object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Iterates over own enumerable properties of an object, executing the callback
+ * for each property. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, key, object). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
+ */
+ var forOwn = function(collection, callback, thisArg) {
+ var index, iterable = collection, result = iterable;
+ if (!iterable) return result;
+ if (!objectTypes[typeof iterable]) return result;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ if (callback(iterable[index], index, collection) === false) return result;
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.forOwn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length'
+ */
+ function forOwnRight(object, callback, thisArg) {
+ var props = keys(object),
+ length = props.length;
+
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ var key = props[length];
+ if (callback(object[key], key, object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Creates a sorted array of property names of all enumerable properties,
+ * own and inherited, of `object` that have function values.
+ *
+ * @static
+ * @memberOf _
+ * @alias methods
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names that have function values.
+ * @example
+ *
+ * _.functions(_);
+ * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
+ */
+ function functions(object) {
+ var result = [];
+ forIn(object, function(value, key) {
+ if (isFunction(value)) {
+ result.push(key);
+ }
+ });
+ return result.sort();
+ }
+
+ /**
+ * Checks if the specified property name exists as a direct property of `object`,
+ * instead of an inherited property.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to check.
+ * @returns {boolean} Returns `true` if key is a direct property, else `false`.
+ * @example
+ *
+ * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+ * // => true
+ */
+ function has(object, key) {
+ return object ? hasOwnProperty.call(object, key) : false;
+ }
+
+ /**
+ * Creates an object composed of the inverted keys and values of the given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to invert.
+ * @returns {Object} Returns the created inverted object.
+ * @example
+ *
+ * _.invert({ 'first': 'fred', 'second': 'barney' });
+ * // => { 'fred': 'first', 'barney': 'second' }
+ */
+ function invert(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = {};
+
+ while (++index < length) {
+ var key = props[index];
+ result[object[key]] = key;
+ }
+ return result;
+ }
+
+ /**
+ * Checks if `value` is a boolean value.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`.
+ * @example
+ *
+ * _.isBoolean(null);
+ * // => false
+ */
+ function isBoolean(value) {
+ return value === true || value === false ||
+ value && typeof value == 'object' && toString.call(value) == boolClass || false;
+ }
+
+ /**
+ * Checks if `value` is a date.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a date, else `false`.
+ * @example
+ *
+ * _.isDate(new Date);
+ * // => true
+ */
+ function isDate(value) {
+ return value && typeof value == 'object' && toString.call(value) == dateClass || false;
+ }
+
+ /**
+ * Checks if `value` is a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ */
+ function isElement(value) {
+ return value && value.nodeType === 1 || false;
+ }
+
+ /**
+ * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
+ * length of `0` and objects with no own enumerable properties are considered
+ * "empty".
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object|string} value The value to inspect.
+ * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({});
+ * // => true
+ *
+ * _.isEmpty('');
+ * // => true
+ */
+ function isEmpty(value) {
+ var result = true;
+ if (!value) {
+ return result;
+ }
+ var className = toString.call(value),
+ length = value.length;
+
+ if ((className == arrayClass || className == stringClass || className == argsClass ) ||
+ (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
+ return !length;
+ }
+ forOwn(value, function() {
+ return (result = false);
+ });
+ return result;
+ }
+
+ /**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent to each other. If a callback is provided it will be executed
+ * to compare values. If the callback returns `undefined` comparisons will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (a, b).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var copy = { 'name': 'fred' };
+ *
+ * object == copy;
+ * // => false
+ *
+ * _.isEqual(object, copy);
+ * // => true
+ *
+ * var words = ['hello', 'goodbye'];
+ * var otherWords = ['hi', 'goodbye'];
+ *
+ * _.isEqual(words, otherWords, function(a, b) {
+ * var reGreet = /^(?:hello|hi)$/i,
+ * aGreet = _.isString(a) && reGreet.test(a),
+ * bGreet = _.isString(b) && reGreet.test(b);
+ *
+ * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
+ * });
+ * // => true
+ */
+ function isEqual(a, b, callback, thisArg) {
+ return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2));
+ }
+
+ /**
+ * Checks if `value` is, or can be coerced to, a finite number.
+ *
+ * Note: This is not the same as native `isFinite` which will return true for
+ * booleans and empty strings. See http://es5.github.io/#x15.1.2.5.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is finite, else `false`.
+ * @example
+ *
+ * _.isFinite(-101);
+ * // => true
+ *
+ * _.isFinite('10');
+ * // => true
+ *
+ * _.isFinite(true);
+ * // => false
+ *
+ * _.isFinite('');
+ * // => false
+ *
+ * _.isFinite(Infinity);
+ * // => false
+ */
+ function isFinite(value) {
+ return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
+ }
+
+ /**
+ * Checks if `value` is a function.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ */
+ function isFunction(value) {
+ return typeof value == 'function';
+ }
+
+ /**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(1);
+ * // => false
+ */
+ function isObject(value) {
+ // check if the value is the ECMAScript language type of Object
+ // http://es5.github.io/#x8
+ // and avoid a V8 bug
+ // http://code.google.com/p/v8/issues/detail?id=2291
+ return !!(value && objectTypes[typeof value]);
+ }
+
+ /**
+ * Checks if `value` is `NaN`.
+ *
+ * Note: This is not the same as native `isNaN` which will return `true` for
+ * `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`.
+ * @example
+ *
+ * _.isNaN(NaN);
+ * // => true
+ *
+ * _.isNaN(new Number(NaN));
+ * // => true
+ *
+ * isNaN(undefined);
+ * // => true
+ *
+ * _.isNaN(undefined);
+ * // => false
+ */
+ function isNaN(value) {
+ // `NaN` as a primitive is the only value that is not equal to itself
+ // (perform the [[Class]] check first to avoid errors with some host objects in IE)
+ return isNumber(value) && value != +value;
+ }
+
+ /**
+ * Checks if `value` is `null`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `null`, else `false`.
+ * @example
+ *
+ * _.isNull(null);
+ * // => true
+ *
+ * _.isNull(undefined);
+ * // => false
+ */
+ function isNull(value) {
+ return value === null;
+ }
+
+ /**
+ * Checks if `value` is a number.
+ *
+ * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a number, else `false`.
+ * @example
+ *
+ * _.isNumber(8.4 * 5);
+ * // => true
+ */
+ function isNumber(value) {
+ return typeof value == 'number' ||
+ value && typeof value == 'object' && toString.call(value) == numberClass || false;
+ }
+
+ /**
+ * Checks if `value` is an object created by the `Object` constructor.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * _.isPlainObject(new Shape);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ */
+ var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) {
+ if (!(value && toString.call(value) == objectClass)) {
+ return false;
+ }
+ var valueOf = value.valueOf,
+ objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
+
+ return objProto
+ ? (value == objProto || getPrototypeOf(value) == objProto)
+ : shimIsPlainObject(value);
+ };
+
+ /**
+ * Checks if `value` is a regular expression.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`.
+ * @example
+ *
+ * _.isRegExp(/fred/);
+ * // => true
+ */
+ function isRegExp(value) {
+ return value && typeof value == 'object' && toString.call(value) == regexpClass || false;
+ }
+
+ /**
+ * Checks if `value` is a string.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('fred');
+ * // => true
+ */
+ function isString(value) {
+ return typeof value == 'string' ||
+ value && typeof value == 'object' && toString.call(value) == stringClass || false;
+ }
+
+ /**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ */
+ function isUndefined(value) {
+ return typeof value == 'undefined';
+ }
+
+ /**
+ * Creates an object with the same keys as `object` and values generated by
+ * running each own enumerable property of `object` through the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new object with values of the results of each `callback` execution.
+ * @example
+ *
+ * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ *
+ * var characters = {
+ * 'fred': { 'name': 'fred', 'age': 40 },
+ * 'pebbles': { 'name': 'pebbles', 'age': 1 }
+ * };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.mapValues(characters, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 }
+ */
+ function mapValues(object, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ forOwn(object, function(value, key, object) {
+ result[key] = callback(value, key, object);
+ });
+ return result;
+ }
+
+ /**
+ * Recursively merges own enumerable properties of the source object(s), that
+ * don't resolve to `undefined` into the destination object. Subsequent sources
+ * will overwrite property assignments of previous sources. If a callback is
+ * provided it will be executed to produce the merged values of the destination
+ * and source properties. If the callback returns `undefined` merging will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (objectValue, sourceValue).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var names = {
+ * 'characters': [
+ * { 'name': 'barney' },
+ * { 'name': 'fred' }
+ * ]
+ * };
+ *
+ * var ages = {
+ * 'characters': [
+ * { 'age': 36 },
+ * { 'age': 40 }
+ * ]
+ * };
+ *
+ * _.merge(names, ages);
+ * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] }
+ *
+ * var food = {
+ * 'fruits': ['apple'],
+ * 'vegetables': ['beet']
+ * };
+ *
+ * var otherFood = {
+ * 'fruits': ['banana'],
+ * 'vegetables': ['carrot']
+ * };
+ *
+ * _.merge(food, otherFood, function(a, b) {
+ * return _.isArray(a) ? a.concat(b) : undefined;
+ * });
+ * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
+ */
+ function merge(object) {
+ var args = arguments,
+ length = 2;
+
+ if (!isObject(object)) {
+ return object;
+ }
+ // allows working with `_.reduce` and `_.reduceRight` without using
+ // their `index` and `collection` arguments
+ if (typeof args[2] != 'number') {
+ length = args.length;
+ }
+ if (length > 3 && typeof args[length - 2] == 'function') {
+ var callback = baseCreateCallback(args[--length - 1], args[length--], 2);
+ } else if (length > 2 && typeof args[length - 1] == 'function') {
+ callback = args[--length];
+ }
+ var sources = slice(arguments, 1, length),
+ index = -1,
+ stackA = getArray(),
+ stackB = getArray();
+
+ while (++index < length) {
+ baseMerge(object, sources[index], callback, stackA, stackB);
+ }
+ releaseArray(stackA);
+ releaseArray(stackB);
+ return object;
+ }
+
+ /**
+ * Creates a shallow clone of `object` excluding the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` omitting the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|...string|string[]} [callback] The properties to omit or the
+ * function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object without the omitted properties.
+ * @example
+ *
+ * _.omit({ 'name': 'fred', 'age': 40 }, 'age');
+ * // => { 'name': 'fred' }
+ *
+ * _.omit({ 'name': 'fred', 'age': 40 }, function(value) {
+ * return typeof value == 'number';
+ * });
+ * // => { 'name': 'fred' }
+ */
+ function omit(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var props = [];
+ forIn(object, function(value, key) {
+ props.push(key);
+ });
+ props = baseDifference(props, baseFlatten(arguments, true, false, 1));
+
+ var index = -1,
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+ result[key] = object[key];
+ }
+ } else {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forIn(object, function(value, key, object) {
+ if (!callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates a two dimensional array of an object's key-value pairs,
+ * i.e. `[[key1, value1], [key2, value2]]`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns new array of key-value pairs.
+ * @example
+ *
+ * _.pairs({ 'barney': 36, 'fred': 40 });
+ * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments)
+ */
+ function pairs(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = Array(length);
+
+ while (++index < length) {
+ var key = props[index];
+ result[index] = [key, object[key]];
+ }
+ return result;
+ }
+
+ /**
+ * Creates a shallow clone of `object` composed of the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` picking the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|...string|string[]} [callback] The function called per
+ * iteration or property names to pick, specified as individual property
+ * names or arrays of property names.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object composed of the picked properties.
+ * @example
+ *
+ * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name');
+ * // => { 'name': 'fred' }
+ *
+ * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) {
+ * return key.charAt(0) != '_';
+ * });
+ * // => { 'name': 'fred' }
+ */
+ function pick(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var index = -1,
+ props = baseFlatten(arguments, true, false, 1),
+ length = isObject(object) ? props.length : 0;
+
+ while (++index < length) {
+ var key = props[index];
+ if (key in object) {
+ result[key] = object[key];
+ }
+ }
+ } else {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forIn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * An alternative to `_.reduce` this method transforms `object` to a new
+ * `accumulator` object which is the result of running each of its own
+ * enumerable properties through a callback, with each callback execution
+ * potentially mutating the `accumulator` object. The callback is bound to
+ * `thisArg` and invoked with four arguments; (accumulator, value, key, object).
+ * Callbacks may exit iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] The custom accumulator value.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {
+ * num *= num;
+ * if (num % 2) {
+ * return result.push(num) < 3;
+ * }
+ * });
+ * // => [1, 9, 25]
+ *
+ * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+ * result[key] = num * 3;
+ * });
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ */
+ function transform(object, callback, accumulator, thisArg) {
+ var isArr = isArray(object);
+ if (accumulator == null) {
+ if (isArr) {
+ accumulator = [];
+ } else {
+ var ctor = object && object.constructor,
+ proto = ctor && ctor.prototype;
+
+ accumulator = baseCreate(proto);
+ }
+ }
+ if (callback) {
+ callback = lodash.createCallback(callback, thisArg, 4);
+ (isArr ? forEach : forOwn)(object, function(value, index, object) {
+ return callback(accumulator, value, index, object);
+ });
+ }
+ return accumulator;
+ }
+
+ /**
+ * Creates an array composed of the own enumerable property values of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property values.
+ * @example
+ *
+ * _.values({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => [1, 2, 3] (property order is not guaranteed across environments)
+ */
+ function values(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = object[props[index]];
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array of elements from the specified indexes, or keys, of the
+ * `collection`. Indexes may be specified as individual arguments or as arrays
+ * of indexes.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {...(number|number[]|string|string[])} [index] The indexes of `collection`
+ * to retrieve, specified as individual indexes or arrays of indexes.
+ * @returns {Array} Returns a new array of elements corresponding to the
+ * provided indexes.
+ * @example
+ *
+ * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+ * // => ['a', 'c', 'e']
+ *
+ * _.at(['fred', 'barney', 'pebbles'], 0, 2);
+ * // => ['fred', 'pebbles']
+ */
+ function at(collection) {
+ var args = arguments,
+ index = -1,
+ props = baseFlatten(args, true, false, 1),
+ length = (args[2] && args[2][args[1]] === collection) ? 1 : props.length,
+ result = Array(length);
+
+ while(++index < length) {
+ result[index] = collection[props[index]];
+ }
+ return result;
+ }
+
+ /**
+ * Checks if a given value is present in a collection using strict equality
+ * for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the
+ * offset from the end of the collection.
+ *
+ * @static
+ * @memberOf _
+ * @alias include
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {*} target The value to check for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {boolean} Returns `true` if the `target` element is found, else `false`.
+ * @example
+ *
+ * _.contains([1, 2, 3], 1);
+ * // => true
+ *
+ * _.contains([1, 2, 3], 1, 2);
+ * // => false
+ *
+ * _.contains({ 'name': 'fred', 'age': 40 }, 'fred');
+ * // => true
+ *
+ * _.contains('pebbles', 'eb');
+ * // => true
+ */
+ function contains(collection, target, fromIndex) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = collection ? collection.length : 0,
+ result = false;
+
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
+ if (isArray(collection)) {
+ result = indexOf(collection, target, fromIndex) > -1;
+ } else if (typeof length == 'number') {
+ result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1;
+ } else {
+ forOwn(collection, function(value) {
+ if (++index >= fromIndex) {
+ return !(result = value === target);
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` through the callback. The corresponding value
+ * of each key is the number of times the key was returned by the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy(['one', 'two', 'three'], 'length');
+ * // => { '3': 2, '5': 1 }
+ */
+ var countBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+ });
+
+ /**
+ * Checks if the given callback returns truey value for **all** elements of
+ * a collection. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias all
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if all elements passed the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.every([true, 1, null, 'yes']);
+ * // => false
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.every(characters, 'age');
+ * // => true
+ *
+ * // using "_.where" callback shorthand
+ * _.every(characters, { 'age': 36 });
+ * // => false
+ */
+ function every(collection, callback, thisArg) {
+ var result = true;
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if (!(result = !!callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ return (result = !!callback(value, index, collection));
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, returning an array of all elements
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias select
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that passed the callback check.
+ * @example
+ *
+ * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [2, 4, 6]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.filter(characters, 'blocked');
+ * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
+ *
+ * // using "_.where" callback shorthand
+ * _.filter(characters, { 'age': 36 });
+ * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
+ */
+ function filter(collection, callback, thisArg) {
+ var result = [];
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, returning the first element that
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias detect, findWhere
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ * ];
+ *
+ * _.find(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => { 'name': 'barney', 'age': 36, 'blocked': false }
+ *
+ * // using "_.where" callback shorthand
+ * _.find(characters, { 'age': 1 });
+ * // => { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ *
+ * // using "_.pluck" callback shorthand
+ * _.find(characters, 'blocked');
+ * // => { 'name': 'fred', 'age': 40, 'blocked': true }
+ */
+ function find(collection, callback, thisArg) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ if (callback(value, index, collection)) {
+ return value;
+ }
+ }
+ } else {
+ var result;
+ forOwn(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+ }
+
+ /**
+ * This method is like `_.find` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * _.findLast([1, 2, 3, 4], function(num) {
+ * return num % 2 == 1;
+ * });
+ * // => 3
+ */
+ function findLast(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forEachRight(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, executing the callback for each
+ * element. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * Note: As with other "Collections" methods, objects with a `length` property
+ * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
+ * may be used for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @alias each
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');
+ * // => logs each number and returns '1,2,3'
+ *
+ * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+ * // => logs each number and returns the object (property order is not guaranteed across environments)
+ */
+ function forEach(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if (callback(collection[index], index, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, callback);
+ }
+ return collection;
+ }
+
+ /**
+ * This method is like `_.forEach` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias eachRight
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(',');
+ * // => logs each number from right to left and returns '3,2,1'
+ */
+ function forEachRight(collection, callback, thisArg) {
+ var length = collection ? collection.length : 0;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ while (length--) {
+ if (callback(collection[length], length, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ var props = keys(collection);
+ length = props.length;
+ forOwn(collection, function(value, key, collection) {
+ key = props ? props[--length] : --length;
+ return callback(collection[key], key, collection);
+ });
+ }
+ return collection;
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of a collection through the callback. The corresponding value
+ * of each key is an array of the elements responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * // using "_.pluck" callback shorthand
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+ var groupBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+ });
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of the collection through the given callback. The corresponding
+ * value of each key is the last element responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var keys = [
+ * { 'dir': 'left', 'code': 97 },
+ * { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.indexBy(keys, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String);
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ */
+ var indexBy = createAggregator(function(result, value, key) {
+ result[key] = value;
+ });
+
+ /**
+ * Invokes the method named by `methodName` on each element in the `collection`
+ * returning an array of the results of each invoked method. Additional arguments
+ * will be provided to each invoked method. If `methodName` is a function it
+ * will be invoked for, and `this` bound to, each element in the `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|string} methodName The name of the method to invoke or
+ * the function invoked per iteration.
+ * @param {...*} [arg] Arguments to invoke the method with.
+ * @returns {Array} Returns a new array of the results of each invoked method.
+ * @example
+ *
+ * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+ * // => [[1, 5, 7], [1, 2, 3]]
+ *
+ * _.invoke([123, 456], String.prototype.split, '');
+ * // => [['1', '2', '3'], ['4', '5', '6']]
+ */
+ function invoke(collection, methodName) {
+ var args = slice(arguments, 2),
+ index = -1,
+ isFunc = typeof methodName == 'function',
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ forEach(collection, function(value) {
+ result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);
+ });
+ return result;
+ }
+
+ /**
+ * Creates an array of values by running each element in the collection
+ * through the callback. The callback is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias collect
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of the results of each `callback` execution.
+ * @example
+ *
+ * _.map([1, 2, 3], function(num) { return num * 3; });
+ * // => [3, 6, 9]
+ *
+ * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+ * // => [3, 6, 9] (property order is not guaranteed across environments)
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.map(characters, 'name');
+ * // => ['barney', 'fred']
+ */
+ function map(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ var result = Array(length);
+ while (++index < length) {
+ result[index] = callback(collection[index], index, collection);
+ }
+ } else {
+ result = [];
+ forOwn(collection, function(value, key, collection) {
+ result[++index] = callback(value, key, collection);
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the maximum value of a collection. If the collection is empty or
+ * falsey `-Infinity` is returned. If a callback is provided it will be executed
+ * for each value in the collection to generate the criterion by which the value
+ * is ranked. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * _.max([4, 2, 8, 6]);
+ * // => 8
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.max(characters, function(chr) { return chr.age; });
+ * // => { 'name': 'fred', 'age': 40 };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.max(characters, 'age');
+ * // => { 'name': 'fred', 'age': 40 };
+ */
+ function max(collection, callback, thisArg) {
+ var computed = -Infinity,
+ result = computed;
+
+ // allows working with functions like `_.map` without using
+ // their `index` argument as a callback
+ if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
+ callback = null;
+ }
+ if (callback == null && isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ if (value > result) {
+ result = value;
+ }
+ }
+ } else {
+ callback = (callback == null && isString(collection))
+ ? charAtCallback
+ : lodash.createCallback(callback, thisArg, 3);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current > computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the minimum value of a collection. If the collection is empty or
+ * falsey `Infinity` is returned. If a callback is provided it will be executed
+ * for each value in the collection to generate the criterion by which the value
+ * is ranked. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * _.min([4, 2, 8, 6]);
+ * // => 2
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.min(characters, function(chr) { return chr.age; });
+ * // => { 'name': 'barney', 'age': 36 };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.min(characters, 'age');
+ * // => { 'name': 'barney', 'age': 36 };
+ */
+ function min(collection, callback, thisArg) {
+ var computed = Infinity,
+ result = computed;
+
+ // allows working with functions like `_.map` without using
+ // their `index` argument as a callback
+ if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
+ callback = null;
+ }
+ if (callback == null && isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ if (value < result) {
+ result = value;
+ }
+ }
+ } else {
+ callback = (callback == null && isString(collection))
+ ? charAtCallback
+ : lodash.createCallback(callback, thisArg, 3);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current < computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the value of a specified property from all elements in the collection.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {string} property The name of the property to pluck.
+ * @returns {Array} Returns a new array of property values.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.pluck(characters, 'name');
+ * // => ['barney', 'fred']
+ */
+ var pluck = map;
+
+ /**
+ * Reduces a collection to a value which is the accumulated result of running
+ * each element in the collection through the callback, where each successive
+ * callback execution consumes the return value of the previous execution. If
+ * `accumulator` is not provided the first element of the collection will be
+ * used as the initial `accumulator` value. The callback is bound to `thisArg`
+ * and invoked with four arguments; (accumulator, value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias foldl, inject
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var sum = _.reduce([1, 2, 3], function(sum, num) {
+ * return sum + num;
+ * });
+ * // => 6
+ *
+ * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+ * result[key] = num * 3;
+ * return result;
+ * }, {});
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ */
+ function reduce(collection, callback, accumulator, thisArg) {
+ if (!collection) return accumulator;
+ var noaccum = arguments.length < 3;
+ callback = lodash.createCallback(callback, thisArg, 4);
+
+ var index = -1,
+ length = collection.length;
+
+ if (typeof length == 'number') {
+ if (noaccum) {
+ accumulator = collection[++index];
+ }
+ while (++index < length) {
+ accumulator = callback(accumulator, collection[index], index, collection);
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection)
+ });
+ }
+ return accumulator;
+ }
+
+ /**
+ * This method is like `_.reduce` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias foldr
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var list = [[0, 1], [2, 3], [4, 5]];
+ * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+ * // => [4, 5, 2, 3, 0, 1]
+ */
+ function reduceRight(collection, callback, accumulator, thisArg) {
+ var noaccum = arguments.length < 3;
+ callback = lodash.createCallback(callback, thisArg, 4);
+ forEachRight(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The opposite of `_.filter` this method returns the elements of a
+ * collection that the callback does **not** return truey for.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that failed the callback check.
+ * @example
+ *
+ * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [1, 3, 5]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.reject(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
+ *
+ * // using "_.where" callback shorthand
+ * _.reject(characters, { 'age': 36 });
+ * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
+ */
+ function reject(collection, callback, thisArg) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ return filter(collection, function(value, index, collection) {
+ return !callback(value, index, collection);
+ });
+ }
+
+ /**
+ * Retrieves a random element or `n` random elements from a collection.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to sample.
+ * @param {number} [n] The number of elements to sample.
+ * @param- {Object} [guard] Allows working with functions like `_.map`
+ * without using their `index` arguments as `n`.
+ * @returns {Array} Returns the random sample(s) of `collection`.
+ * @example
+ *
+ * _.sample([1, 2, 3, 4]);
+ * // => 2
+ *
+ * _.sample([1, 2, 3, 4], 2);
+ * // => [3, 1]
+ */
+ function sample(collection, n, guard) {
+ if (collection && typeof collection.length != 'number') {
+ collection = values(collection);
+ }
+ if (n == null || guard) {
+ return collection ? collection[baseRandom(0, collection.length - 1)] : undefined;
+ }
+ var result = shuffle(collection);
+ result.length = nativeMin(nativeMax(0, n), result.length);
+ return result;
+ }
+
+ /**
+ * Creates an array of shuffled values, using a version of the Fisher-Yates
+ * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to shuffle.
+ * @returns {Array} Returns a new shuffled collection.
+ * @example
+ *
+ * _.shuffle([1, 2, 3, 4, 5, 6]);
+ * // => [4, 1, 6, 3, 5, 2]
+ */
+ function shuffle(collection) {
+ var index = -1,
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ forEach(collection, function(value) {
+ var rand = baseRandom(0, ++index);
+ result[index] = result[rand];
+ result[rand] = value;
+ });
+ return result;
+ }
+
+ /**
+ * Gets the size of the `collection` by returning `collection.length` for arrays
+ * and array-like objects or the number of own enumerable properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns `collection.length` or number of own enumerable properties.
+ * @example
+ *
+ * _.size([1, 2]);
+ * // => 2
+ *
+ * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => 3
+ *
+ * _.size('pebbles');
+ * // => 7
+ */
+ function size(collection) {
+ var length = collection ? collection.length : 0;
+ return typeof length == 'number' ? length : keys(collection).length;
+ }
+
+ /**
+ * Checks if the callback returns a truey value for **any** element of a
+ * collection. The function returns as soon as it finds a passing value and
+ * does not iterate over the entire collection. The callback is bound to
+ * `thisArg` and invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias any
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if any element passed the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false], Boolean);
+ * // => true
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.some(characters, 'blocked');
+ * // => true
+ *
+ * // using "_.where" callback shorthand
+ * _.some(characters, { 'age': 1 });
+ * // => false
+ */
+ function some(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if ((result = callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ return !(result = callback(value, index, collection));
+ });
+ }
+ return !!result;
+ }
+
+ /**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection through the callback. This method
+ * performs a stable sort, that is, it will preserve the original sort order
+ * of equal elements. The callback is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an array of property names is provided for `callback` the collection
+ * will be sorted by each property value.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Array|Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of sorted elements.
+ * @example
+ *
+ * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+ * // => [3, 1, 2]
+ *
+ * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+ * // => [3, 1, 2]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 26 },
+ * { 'name': 'fred', 'age': 30 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.map(_.sortBy(characters, 'age'), _.values);
+ * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]]
+ *
+ * // sorting by multiple properties
+ * _.map(_.sortBy(characters, ['name', 'age']), _.values);
+ * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]]
+ */
+ function sortBy(collection, callback, thisArg) {
+ var index = -1,
+ isArr = isArray(callback),
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ if (!isArr) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ }
+ forEach(collection, function(value, key, collection) {
+ var object = result[++index] = getObject();
+ if (isArr) {
+ object.criteria = map(callback, function(key) { return value[key]; });
+ } else {
+ (object.criteria = getArray())[0] = callback(value, key, collection);
+ }
+ object.index = index;
+ object.value = value;
+ });
+
+ length = result.length;
+ result.sort(compareAscending);
+ while (length--) {
+ var object = result[length];
+ result[length] = object.value;
+ if (!isArr) {
+ releaseArray(object.criteria);
+ }
+ releaseObject(object);
+ }
+ return result;
+ }
+
+ /**
+ * Converts the `collection` to an array.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to convert.
+ * @returns {Array} Returns the new converted array.
+ * @example
+ *
+ * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+ * // => [2, 3, 4]
+ */
+ function toArray(collection) {
+ if (collection && typeof collection.length == 'number') {
+ return slice(collection);
+ }
+ return values(collection);
+ }
+
+ /**
+ * Performs a deep comparison of each element in a `collection` to the given
+ * `properties` object, returning an array of all elements that have equivalent
+ * property values.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Object} props The object of property values to filter by.
+ * @returns {Array} Returns a new array of elements that have the given properties.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] },
+ * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
+ * ];
+ *
+ * _.where(characters, { 'age': 36 });
+ * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }]
+ *
+ * _.where(characters, { 'pets': ['dino'] });
+ * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }]
+ */
+ var where = filter;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are all falsey.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+ function compact(array) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (value) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array excluding all values of the provided arrays using strict
+ * equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {...Array} [values] The arrays of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+ * // => [1, 3, 4]
+ */
+ function difference(array) {
+ return baseDifference(array, baseFlatten(arguments, true, true, 1));
+ }
+
+ /**
+ * This method is like `_.find` except that it returns the index of the first
+ * element that passes the callback check, instead of the element itself.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ * ];
+ *
+ * _.findIndex(characters, function(chr) {
+ * return chr.age < 20;
+ * });
+ * // => 2
+ *
+ * // using "_.where" callback shorthand
+ * _.findIndex(characters, { 'age': 36 });
+ * // => 0
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findIndex(characters, 'blocked');
+ * // => 1
+ */
+ function findIndex(array, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length) {
+ if (callback(array[index], index, array)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * This method is like `_.findIndex` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': true },
+ * { 'name': 'fred', 'age': 40, 'blocked': false },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': true }
+ * ];
+ *
+ * _.findLastIndex(characters, function(chr) {
+ * return chr.age > 30;
+ * });
+ * // => 1
+ *
+ * // using "_.where" callback shorthand
+ * _.findLastIndex(characters, { 'age': 36 });
+ * // => 0
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findLastIndex(characters, 'blocked');
+ * // => 2
+ */
+ function findLastIndex(array, callback, thisArg) {
+ var length = array ? array.length : 0;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(array[length], length, array)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Gets the first element or first `n` elements of an array. If a callback
+ * is provided elements at the beginning of the array are returned as long
+ * as the callback returns truey. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias head, take
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback] The function called
+ * per element or the number of elements to return. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the first element(s) of `array`.
+ * @example
+ *
+ * _.first([1, 2, 3]);
+ * // => 1
+ *
+ * _.first([1, 2, 3], 2);
+ * // => [1, 2]
+ *
+ * _.first([1, 2, 3], function(num) {
+ * return num < 3;
+ * });
+ * // => [1, 2]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.first(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }]
+ *
+ * // using "_.where" callback shorthand
+ * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name');
+ * // => ['barney', 'fred']
+ */
+ function first(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = -1;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[0] : undefined;
+ }
+ }
+ return slice(array, 0, nativeMin(nativeMax(0, n), length));
+ }
+
+ /**
+ * Flattens a nested array (the nesting can be to any depth). If `isShallow`
+ * is truey, the array will only be flattened a single level. If a callback
+ * is provided each element of the array is passed through the callback before
+ * flattening. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2], [3, [[4]]]]);
+ * // => [1, 2, 3, 4];
+ *
+ * _.flatten([1, [2], [3, [[4]]]], true);
+ * // => [1, 2, 3, [[4]]];
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] },
+ * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.flatten(characters, 'pets');
+ * // => ['hoppy', 'baby puss', 'dino']
+ */
+ function flatten(array, isShallow, callback, thisArg) {
+ // juggle arguments
+ if (typeof isShallow != 'boolean' && isShallow != null) {
+ thisArg = callback;
+ callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow;
+ isShallow = false;
+ }
+ if (callback != null) {
+ array = map(array, callback, thisArg);
+ }
+ return baseFlatten(array, isShallow);
+ }
+
+ /**
+ * Gets the index at which the first occurrence of `value` is found using
+ * strict equality for comparisons, i.e. `===`. If the array is already sorted
+ * providing `true` for `fromIndex` will run a faster binary search.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {boolean|number} [fromIndex=0] The index to search from or `true`
+ * to perform a binary search on a sorted array.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 1
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 4
+ *
+ * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+ * // => 2
+ */
+ function indexOf(array, value, fromIndex) {
+ if (typeof fromIndex == 'number') {
+ var length = array ? array.length : 0;
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0);
+ } else if (fromIndex) {
+ var index = sortedIndex(array, value);
+ return array[index] === value ? index : -1;
+ }
+ return baseIndexOf(array, value, fromIndex);
+ }
+
+ /**
+ * Gets all but the last element or last `n` elements of an array. If a
+ * callback is provided elements at the end of the array are excluded from
+ * the result as long as the callback returns truey. The callback is bound
+ * to `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback=1] The function called
+ * per element or the number of elements to exclude. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a slice of `array`.
+ * @example
+ *
+ * _.initial([1, 2, 3]);
+ * // => [1, 2]
+ *
+ * _.initial([1, 2, 3], 2);
+ * // => [1]
+ *
+ * _.initial([1, 2, 3], function(num) {
+ * return num > 1;
+ * });
+ * // => [1]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.initial(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }]
+ *
+ * // using "_.where" callback shorthand
+ * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name');
+ * // => ['barney', 'fred']
+ */
+ function initial(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = (callback == null || thisArg) ? 1 : callback || n;
+ }
+ return slice(array, 0, nativeMin(nativeMax(0, length - n), length));
+ }
+
+ /**
+ * Creates an array of unique values present in all provided arrays using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of shared values.
+ * @example
+ *
+ * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2]
+ */
+ function intersection() {
+ var args = [],
+ argsIndex = -1,
+ argsLength = arguments.length,
+ caches = getArray(),
+ indexOf = getIndexOf(),
+ trustIndexOf = indexOf === baseIndexOf,
+ seen = getArray();
+
+ while (++argsIndex < argsLength) {
+ var value = arguments[argsIndex];
+ if (isArray(value) || isArguments(value)) {
+ args.push(value);
+ caches.push(trustIndexOf && value.length >= largeArraySize &&
+ createCache(argsIndex ? args[argsIndex] : seen));
+ }
+ }
+ var array = args[0],
+ index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ outer:
+ while (++index < length) {
+ var cache = caches[0];
+ value = array[index];
+
+ if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) {
+ argsIndex = argsLength;
+ (cache || seen).push(value);
+ while (--argsIndex) {
+ cache = caches[argsIndex];
+ if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) {
+ continue outer;
+ }
+ }
+ result.push(value);
+ }
+ }
+ while (argsLength--) {
+ cache = caches[argsLength];
+ if (cache) {
+ releaseObject(cache);
+ }
+ }
+ releaseArray(caches);
+ releaseArray(seen);
+ return result;
+ }
+
+ /**
+ * Gets the last element or last `n` elements of an array. If a callback is
+ * provided elements at the end of the array are returned as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback] The function called
+ * per element or the number of elements to return. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the last element(s) of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ *
+ * _.last([1, 2, 3], 2);
+ * // => [2, 3]
+ *
+ * _.last([1, 2, 3], function(num) {
+ * return num > 1;
+ * });
+ * // => [2, 3]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.pluck(_.last(characters, 'blocked'), 'name');
+ * // => ['fred', 'pebbles']
+ *
+ * // using "_.where" callback shorthand
+ * _.last(characters, { 'employer': 'na' });
+ * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
+ */
+ function last(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[length - 1] : undefined;
+ }
+ }
+ return slice(array, nativeMax(0, length - n));
+ }
+
+ /**
+ * Gets the index at which the last occurrence of `value` is found using strict
+ * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+ * as the offset from the end of the collection.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 4
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 1
+ */
+ function lastIndexOf(array, value, fromIndex) {
+ var index = array ? array.length : 0;
+ if (typeof fromIndex == 'number') {
+ index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
+ }
+ while (index--) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Removes all provided values from the given array using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {...*} [value] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ * _.pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+ function pull(array) {
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = args.length,
+ length = array ? array.length : 0;
+
+ while (++argsIndex < argsLength) {
+ var index = -1,
+ value = args[argsIndex];
+ while (++index < length) {
+ if (array[index] === value) {
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ }
+ return array;
+ }
+
+ /**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * `start` up to but not including `end`. If `start` is less than `stop` a
+ * zero-length range is created unless a negative `step` is specified.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
+ * @returns {Array} Returns a new range array.
+ * @example
+ *
+ * _.range(4);
+ * // => [0, 1, 2, 3]
+ *
+ * _.range(1, 5);
+ * // => [1, 2, 3, 4]
+ *
+ * _.range(0, 20, 5);
+ * // => [0, 5, 10, 15]
+ *
+ * _.range(0, -4, -1);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.range(0);
+ * // => []
+ */
+ function range(start, end, step) {
+ start = +start || 0;
+ step = typeof step == 'number' ? step : (+step || 1);
+
+ if (end == null) {
+ end = start;
+ start = 0;
+ }
+ // use `Array(length)` so engines like Chakra and V8 avoid slower modes
+ // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+ var index = -1,
+ length = nativeMax(0, ceil((end - start) / (step || 1))),
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = start;
+ start += step;
+ }
+ return result;
+ }
+
+ /**
+ * Removes all elements from an array that the callback returns truey for
+ * and returns an array of removed elements. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of removed elements.
+ * @example
+ *
+ * var array = [1, 2, 3, 4, 5, 6];
+ * var evens = _.remove(array, function(num) { return num % 2 == 0; });
+ *
+ * console.log(array);
+ * // => [1, 3, 5]
+ *
+ * console.log(evens);
+ * // => [2, 4, 6]
+ */
+ function remove(array, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length) {
+ var value = array[index];
+ if (callback(value, index, array)) {
+ result.push(value);
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The opposite of `_.initial` this method gets all but the first element or
+ * first `n` elements of an array. If a callback function is provided elements
+ * at the beginning of the array are excluded from the result as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias drop, tail
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback=1] The function called
+ * per element or the number of elements to exclude. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a slice of `array`.
+ * @example
+ *
+ * _.rest([1, 2, 3]);
+ * // => [2, 3]
+ *
+ * _.rest([1, 2, 3], 2);
+ * // => [3]
+ *
+ * _.rest([1, 2, 3], function(num) {
+ * return num < 3;
+ * });
+ * // => [3]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.pluck(_.rest(characters, 'blocked'), 'name');
+ * // => ['fred', 'pebbles']
+ *
+ * // using "_.where" callback shorthand
+ * _.rest(characters, { 'employer': 'slate' });
+ * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
+ */
+ function rest(array, callback, thisArg) {
+ if (typeof callback != 'number' && callback != null) {
+ var n = 0,
+ index = -1,
+ length = array ? array.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);
+ }
+ return slice(array, n);
+ }
+
+ /**
+ * Uses a binary search to determine the smallest index at which a value
+ * should be inserted into a given sorted array in order to maintain the sort
+ * order of the array. If a callback is provided it will be executed for
+ * `value` and each element of `array` to compute their sort ranking. The
+ * callback is bound to `thisArg` and invoked with one argument; (value).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * _.sortedIndex([20, 30, 50], 40);
+ * // => 2
+ *
+ * // using "_.pluck" callback shorthand
+ * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+ * // => 2
+ *
+ * var dict = {
+ * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+ * };
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return dict.wordToNumber[word];
+ * });
+ * // => 2
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return this.wordToNumber[word];
+ * }, dict);
+ * // => 2
+ */
+ function sortedIndex(array, value, callback, thisArg) {
+ var low = 0,
+ high = array ? array.length : low;
+
+ // explicitly reference `identity` for better inlining in Firefox
+ callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity;
+ value = callback(value);
+
+ while (low < high) {
+ var mid = (low + high) >>> 1;
+ (callback(array[mid]) < value)
+ ? low = mid + 1
+ : high = mid;
+ }
+ return low;
+ }
+
+ /**
+ * Creates an array of unique values, in order, of the provided arrays using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of combined values.
+ * @example
+ *
+ * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2, 3, 5, 4]
+ */
+ function union() {
+ return baseUniq(baseFlatten(arguments, true, true));
+ }
+
+ /**
+ * Creates a duplicate-value-free version of an array using strict equality
+ * for comparisons, i.e. `===`. If the array is sorted, providing
+ * `true` for `isSorted` will use a faster algorithm. If a callback is provided
+ * each element of `array` is passed through the callback before uniqueness
+ * is computed. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias unique
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a duplicate-value-free array.
+ * @example
+ *
+ * _.uniq([1, 2, 1, 3, 1]);
+ * // => [1, 2, 3]
+ *
+ * _.uniq([1, 1, 2, 2, 3], true);
+ * // => [1, 2, 3]
+ *
+ * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); });
+ * // => ['A', 'b', 'C']
+ *
+ * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
+ * // => [1, 2.5, 3]
+ *
+ * // using "_.pluck" callback shorthand
+ * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+ function uniq(array, isSorted, callback, thisArg) {
+ // juggle arguments
+ if (typeof isSorted != 'boolean' && isSorted != null) {
+ thisArg = callback;
+ callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted;
+ isSorted = false;
+ }
+ if (callback != null) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ }
+ return baseUniq(array, isSorted, callback);
+ }
+
+ /**
+ * Creates an array excluding all provided values using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to filter.
+ * @param {...*} [value] The values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+ * // => [2, 3, 4]
+ */
+ function without(array) {
+ return baseDifference(array, slice(arguments, 1));
+ }
+
+ /**
+ * Creates an array that is the symmetric difference of the provided arrays.
+ * See http://en.wikipedia.org/wiki/Symmetric_difference.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of values.
+ * @example
+ *
+ * _.xor([1, 2, 3], [5, 2, 1, 4]);
+ * // => [3, 5, 4]
+ *
+ * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]);
+ * // => [1, 4, 5]
+ */
+ function xor() {
+ var index = -1,
+ length = arguments.length;
+
+ while (++index < length) {
+ var array = arguments[index];
+ if (isArray(array) || isArguments(array)) {
+ var result = result
+ ? baseUniq(baseDifference(result, array).concat(baseDifference(array, result)))
+ : array;
+ }
+ }
+ return result || [];
+ }
+
+ /**
+ * Creates an array of grouped elements, the first of which contains the first
+ * elements of the given arrays, the second of which contains the second
+ * elements of the given arrays, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @alias unzip
+ * @category Arrays
+ * @param {...Array} [array] Arrays to process.
+ * @returns {Array} Returns a new array of grouped elements.
+ * @example
+ *
+ * _.zip(['fred', 'barney'], [30, 40], [true, false]);
+ * // => [['fred', 30, true], ['barney', 40, false]]
+ */
+ function zip() {
+ var array = arguments.length > 1 ? arguments : arguments[0],
+ index = -1,
+ length = array ? max(pluck(array, 'length')) : 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = pluck(array, index);
+ }
+ return result;
+ }
+
+ /**
+ * Creates an object composed from arrays of `keys` and `values`. Provide
+ * either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`
+ * or two arrays, one of `keys` and one of corresponding `values`.
+ *
+ * @static
+ * @memberOf _
+ * @alias object
+ * @category Arrays
+ * @param {Array} keys The array of keys.
+ * @param {Array} [values=[]] The array of values.
+ * @returns {Object} Returns an object composed of the given keys and
+ * corresponding values.
+ * @example
+ *
+ * _.zipObject(['fred', 'barney'], [30, 40]);
+ * // => { 'fred': 30, 'barney': 40 }
+ */
+ function zipObject(keys, values) {
+ var index = -1,
+ length = keys ? keys.length : 0,
+ result = {};
+
+ if (!values && length && !isArray(keys[0])) {
+ values = [];
+ }
+ while (++index < length) {
+ var key = keys[index];
+ if (values) {
+ result[key] = values[index];
+ } else if (key) {
+ result[key[0]] = key[1];
+ }
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that executes `func`, with the `this` binding and
+ * arguments of the created function, only after being called `n` times.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {number} n The number of times the function must be called before
+ * `func` is executed.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var saves = ['profile', 'settings'];
+ *
+ * var done = _.after(saves.length, function() {
+ * console.log('Done saving!');
+ * });
+ *
+ * _.forEach(saves, function(type) {
+ * asyncSave({ 'type': type, 'complete': done });
+ * });
+ * // => logs 'Done saving!', after all saves have completed
+ */
+ function after(n, func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return function() {
+ if (--n < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with the `this`
+ * binding of `thisArg` and prepends any additional `bind` arguments to those
+ * provided to the bound function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to bind.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var func = function(greeting) {
+ * return greeting + ' ' + this.name;
+ * };
+ *
+ * func = _.bind(func, { 'name': 'fred' }, 'hi');
+ * func();
+ * // => 'hi fred'
+ */
+ function bind(func, thisArg) {
+ return arguments.length > 2
+ ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
+ : createWrapper(func, 1, null, null, thisArg);
+ }
+
+ /**
+ * Binds methods of an object to the object itself, overwriting the existing
+ * method. Method names may be specified as individual arguments or as arrays
+ * of method names. If no method names are provided all the function properties
+ * of `object` will be bound.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object to bind and assign the bound methods to.
+ * @param {...string} [methodName] The object method names to
+ * bind, specified as individual method names or arrays of method names.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var view = {
+ * 'label': 'docs',
+ * 'onClick': function() { console.log('clicked ' + this.label); }
+ * };
+ *
+ * _.bindAll(view);
+ * jQuery('#docs').on('click', view.onClick);
+ * // => logs 'clicked docs', when the button is clicked
+ */
+ function bindAll(object) {
+ var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object),
+ index = -1,
+ length = funcs.length;
+
+ while (++index < length) {
+ var key = funcs[index];
+ object[key] = createWrapper(object[key], 1, null, null, object);
+ }
+ return object;
+ }
+
+ /**
+ * Creates a function that, when called, invokes the method at `object[key]`
+ * and prepends any additional `bindKey` arguments to those provided to the bound
+ * function. This method differs from `_.bind` by allowing bound functions to
+ * reference methods that will be redefined or don't yet exist.
+ * See http://michaux.ca/articles/lazy-function-definition-pattern.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object the method belongs to.
+ * @param {string} key The key of the method.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var object = {
+ * 'name': 'fred',
+ * 'greet': function(greeting) {
+ * return greeting + ' ' + this.name;
+ * }
+ * };
+ *
+ * var func = _.bindKey(object, 'greet', 'hi');
+ * func();
+ * // => 'hi fred'
+ *
+ * object.greet = function(greeting) {
+ * return greeting + 'ya ' + this.name + '!';
+ * };
+ *
+ * func();
+ * // => 'hiya fred!'
+ */
+ function bindKey(object, key) {
+ return arguments.length > 2
+ ? createWrapper(key, 19, slice(arguments, 2), null, object)
+ : createWrapper(key, 3, null, null, object);
+ }
+
+ /**
+ * Creates a function that is the composition of the provided functions,
+ * where each function consumes the return value of the function that follows.
+ * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+ * Each function is executed with the `this` binding of the composed function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {...Function} [func] Functions to compose.
+ * @returns {Function} Returns the new composed function.
+ * @example
+ *
+ * var realNameMap = {
+ * 'pebbles': 'penelope'
+ * };
+ *
+ * var format = function(name) {
+ * name = realNameMap[name.toLowerCase()] || name;
+ * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+ * };
+ *
+ * var greet = function(formatted) {
+ * return 'Hiya ' + formatted + '!';
+ * };
+ *
+ * var welcome = _.compose(greet, format);
+ * welcome('pebbles');
+ * // => 'Hiya Penelope!'
+ */
+ function compose() {
+ var funcs = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ if (!isFunction(funcs[length])) {
+ throw new TypeError;
+ }
+ }
+ return function() {
+ var args = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ args = [funcs[length].apply(this, args)];
+ }
+ return args[0];
+ };
+ }
+
+ /**
+ * Creates a function which accepts one or more arguments of `func` that when
+ * invoked either executes `func` returning its result, if all `func` arguments
+ * have been provided, or returns a function that accepts one or more of the
+ * remaining `func` arguments, and so on. The arity of `func` can be specified
+ * if `func.length` is not sufficient.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to curry.
+ * @param {number} [arity=func.length] The arity of `func`.
+ * @returns {Function} Returns the new curried function.
+ * @example
+ *
+ * var curried = _.curry(function(a, b, c) {
+ * console.log(a + b + c);
+ * });
+ *
+ * curried(1)(2)(3);
+ * // => 6
+ *
+ * curried(1, 2)(3);
+ * // => 6
+ *
+ * curried(1, 2, 3);
+ * // => 6
+ */
+ function curry(func, arity) {
+ arity = typeof arity == 'number' ? arity : (+arity || func.length);
+ return createWrapper(func, 4, null, null, null, arity);
+ }
+
+ /**
+ * Creates a function that will delay the execution of `func` until after
+ * `wait` milliseconds have elapsed since the last time it was invoked.
+ * Provide an options object to indicate that `func` should be invoked on
+ * the leading and/or trailing edge of the `wait` timeout. Subsequent calls
+ * to the debounced function will return the result of the last `func` call.
+ *
+ * Note: If `leading` and `trailing` options are `true` `func` will be called
+ * on the trailing edge of the timeout only if the the debounced function is
+ * invoked more than once during the `wait` timeout.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to delay.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout.
+ * @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called.
+ * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // avoid costly calculations while the window size is in flux
+ * var lazyLayout = _.debounce(calculateLayout, 150);
+ * jQuery(window).on('resize', lazyLayout);
+ *
+ * // execute `sendMail` when the click event is fired, debouncing subsequent calls
+ * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
+ * 'leading': true,
+ * 'trailing': false
+ * });
+ *
+ * // ensure `batchLog` is executed once after 1 second of debounced calls
+ * var source = new EventSource('/stream');
+ * source.addEventListener('message', _.debounce(batchLog, 250, {
+ * 'maxWait': 1000
+ * }, false);
+ */
+ function debounce(func, wait, options) {
+ var args,
+ maxTimeoutId,
+ result,
+ stamp,
+ thisArg,
+ timeoutId,
+ trailingCall,
+ lastCalled = 0,
+ maxWait = false,
+ trailing = true;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ wait = nativeMax(0, wait) || 0;
+ if (options === true) {
+ var leading = true;
+ trailing = false;
+ } else if (isObject(options)) {
+ leading = options.leading;
+ maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0);
+ trailing = 'trailing' in options ? options.trailing : trailing;
+ }
+ var delayed = function() {
+ var remaining = wait - (now() - stamp);
+ if (remaining <= 0) {
+ if (maxTimeoutId) {
+ clearTimeout(maxTimeoutId);
+ }
+ var isCalled = trailingCall;
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (isCalled) {
+ lastCalled = now();
+ result = func.apply(thisArg, args);
+ if (!timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ }
+ } else {
+ timeoutId = setTimeout(delayed, remaining);
+ }
+ };
+
+ var maxDelayed = function() {
+ if (timeoutId) {
+ clearTimeout(timeoutId);
+ }
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (trailing || (maxWait !== wait)) {
+ lastCalled = now();
+ result = func.apply(thisArg, args);
+ if (!timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ }
+ };
+
+ return function() {
+ args = arguments;
+ stamp = now();
+ thisArg = this;
+ trailingCall = trailing && (timeoutId || !leading);
+
+ if (maxWait === false) {
+ var leadingCall = leading && !timeoutId;
+ } else {
+ if (!maxTimeoutId && !leading) {
+ lastCalled = stamp;
+ }
+ var remaining = maxWait - (stamp - lastCalled),
+ isCalled = remaining <= 0;
+
+ if (isCalled) {
+ if (maxTimeoutId) {
+ maxTimeoutId = clearTimeout(maxTimeoutId);
+ }
+ lastCalled = stamp;
+ result = func.apply(thisArg, args);
+ }
+ else if (!maxTimeoutId) {
+ maxTimeoutId = setTimeout(maxDelayed, remaining);
+ }
+ }
+ if (isCalled && timeoutId) {
+ timeoutId = clearTimeout(timeoutId);
+ }
+ else if (!timeoutId && wait !== maxWait) {
+ timeoutId = setTimeout(delayed, wait);
+ }
+ if (leadingCall) {
+ isCalled = true;
+ result = func.apply(thisArg, args);
+ }
+ if (isCalled && !timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Defers executing the `func` function until the current call stack has cleared.
+ * Additional arguments will be provided to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to defer.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.defer(function(text) { console.log(text); }, 'deferred');
+ * // logs 'deferred' after one or more milliseconds
+ */
+ function defer(func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var args = slice(arguments, 1);
+ return setTimeout(function() { func.apply(undefined, args); }, 1);
+ }
+
+ /**
+ * Executes the `func` function after `wait` milliseconds. Additional arguments
+ * will be provided to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay execution.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.delay(function(text) { console.log(text); }, 1000, 'later');
+ * // => logs 'later' after one second
+ */
+ function delay(func, wait) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var args = slice(arguments, 2);
+ return setTimeout(function() { func.apply(undefined, args); }, wait);
+ }
+
+ /**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided it will be used to determine the cache key for storing the result
+ * based on the arguments provided to the memoized function. By default, the
+ * first argument provided to the memoized function is used as the cache key.
+ * The `func` is executed with the `this` binding of the memoized function.
+ * The result cache is exposed as the `cache` property on the memoized function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] A function used to resolve the cache key.
+ * @returns {Function} Returns the new memoizing function.
+ * @example
+ *
+ * var fibonacci = _.memoize(function(n) {
+ * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ *
+ * fibonacci(9)
+ * // => 34
+ *
+ * var data = {
+ * 'fred': { 'name': 'fred', 'age': 40 },
+ * 'pebbles': { 'name': 'pebbles', 'age': 1 }
+ * };
+ *
+ * // modifying the result cache
+ * var get = _.memoize(function(name) { return data[name]; }, _.identity);
+ * get('pebbles');
+ * // => { 'name': 'pebbles', 'age': 1 }
+ *
+ * get.cache.pebbles.name = 'penelope';
+ * get('pebbles');
+ * // => { 'name': 'penelope', 'age': 1 }
+ */
+ function memoize(func, resolver) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var memoized = function() {
+ var cache = memoized.cache,
+ key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0];
+
+ return hasOwnProperty.call(cache, key)
+ ? cache[key]
+ : (cache[key] = func.apply(this, arguments));
+ }
+ memoized.cache = {};
+ return memoized;
+ }
+
+ /**
+ * Creates a function that is restricted to execute `func` once. Repeat calls to
+ * the function will return the value of the first call. The `func` is executed
+ * with the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // `initialize` executes `createApplication` once
+ */
+ function once(func) {
+ var ran,
+ result;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return function() {
+ if (ran) {
+ return result;
+ }
+ ran = true;
+ result = func.apply(this, arguments);
+
+ // clear the `func` variable so the function may be garbage collected
+ func = null;
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with any additional
+ * `partial` arguments prepended to those provided to the new function. This
+ * method is similar to `_.bind` except it does **not** alter the `this` binding.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var greet = function(greeting, name) { return greeting + ' ' + name; };
+ * var hi = _.partial(greet, 'hi');
+ * hi('fred');
+ * // => 'hi fred'
+ */
+ function partial(func) {
+ return createWrapper(func, 16, slice(arguments, 1));
+ }
+
+ /**
+ * This method is like `_.partial` except that `partial` arguments are
+ * appended to those provided to the new function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var defaultsDeep = _.partialRight(_.merge, _.defaults);
+ *
+ * var options = {
+ * 'variable': 'data',
+ * 'imports': { 'jq': $ }
+ * };
+ *
+ * defaultsDeep(options, _.templateSettings);
+ *
+ * options.variable
+ * // => 'data'
+ *
+ * options.imports
+ * // => { '_': _, 'jq': $ }
+ */
+ function partialRight(func) {
+ return createWrapper(func, 32, null, slice(arguments, 1));
+ }
+
+ /**
+ * Creates a function that, when executed, will only call the `func` function
+ * at most once per every `wait` milliseconds. Provide an options object to
+ * indicate that `func` should be invoked on the leading and/or trailing edge
+ * of the `wait` timeout. Subsequent calls to the throttled function will
+ * return the result of the last `func` call.
+ *
+ * Note: If `leading` and `trailing` options are `true` `func` will be called
+ * on the trailing edge of the timeout only if the the throttled function is
+ * invoked more than once during the `wait` timeout.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to throttle.
+ * @param {number} wait The number of milliseconds to throttle executions to.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // avoid excessively updating the position while scrolling
+ * var throttled = _.throttle(updatePosition, 100);
+ * jQuery(window).on('scroll', throttled);
+ *
+ * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes
+ * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
+ * 'trailing': false
+ * }));
+ */
+ function throttle(func, wait, options) {
+ var leading = true,
+ trailing = true;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ if (options === false) {
+ leading = false;
+ } else if (isObject(options)) {
+ leading = 'leading' in options ? options.leading : leading;
+ trailing = 'trailing' in options ? options.trailing : trailing;
+ }
+ debounceOptions.leading = leading;
+ debounceOptions.maxWait = wait;
+ debounceOptions.trailing = trailing;
+
+ return debounce(func, wait, debounceOptions);
+ }
+
+ /**
+ * Creates a function that provides `value` to the wrapper function as its
+ * first argument. Additional arguments provided to the function are appended
+ * to those provided to the wrapper function. The wrapper is executed with
+ * the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {*} value The value to wrap.
+ * @param {Function} wrapper The wrapper function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var p = _.wrap(_.escape, function(func, text) {
+ * return '<p>' + func(text) + '</p>';
+ * });
+ *
+ * p('Fred, Wilma, & Pebbles');
+ * // => '<p>Fred, Wilma, & Pebbles</p>'
+ */
+ function wrap(value, wrapper) {
+ return createWrapper(wrapper, 16, [value]);
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var getter = _.constant(object);
+ * getter() === object;
+ * // => true
+ */
+ function constant(value) {
+ return function() {
+ return value;
+ };
+ }
+
+ /**
+ * Produces a callback bound to an optional `thisArg`. If `func` is a property
+ * name the created callback will return the property value for a given element.
+ * If `func` is an object the created callback will return `true` for elements
+ * that contain the equivalent object properties, otherwise it will return `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // wrap to create custom callback shorthands
+ * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
+ * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
+ * return !match ? func(callback, thisArg) : function(object) {
+ * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
+ * };
+ * });
+ *
+ * _.filter(characters, 'age__gt38');
+ * // => [{ 'name': 'fred', 'age': 40 }]
+ */
+ function createCallback(func, thisArg, argCount) {
+ var type = typeof func;
+ if (func == null || type == 'function') {
+ return baseCreateCallback(func, thisArg, argCount);
+ }
+ // handle "_.pluck" style callback shorthands
+ if (type != 'object') {
+ return property(func);
+ }
+ var props = keys(func),
+ key = props[0],
+ a = func[key];
+
+ // handle "_.where" style callback shorthands
+ if (props.length == 1 && a === a && !isObject(a)) {
+ // fast path the common case of providing an object with a single
+ // property containing a primitive value
+ return function(object) {
+ var b = object[key];
+ return a === b && (a !== 0 || (1 / a == 1 / b));
+ };
+ }
+ return function(object) {
+ var length = props.length,
+ result = false;
+
+ while (length--) {
+ if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
+ break;
+ }
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding HTML entities.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escape('Fred, Wilma, & Pebbles');
+ * // => 'Fred, Wilma, & Pebbles'
+ */
+ function escape(string) {
+ return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
+ }
+
+ /**
+ * This method returns the first argument provided to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.identity(object) === object;
+ * // => true
+ */
+ function identity(value) {
+ return value;
+ }
+
+ /**
+ * Adds function properties of a source object to the destination object.
+ * If `object` is a function methods will be added to its prototype as well.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Function|Object} [object=lodash] object The destination object.
+ * @param {Object} source The object of functions to add.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.chain=true] Specify whether the functions added are chainable.
+ * @example
+ *
+ * function capitalize(string) {
+ * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+ * }
+ *
+ * _.mixin({ 'capitalize': capitalize });
+ * _.capitalize('fred');
+ * // => 'Fred'
+ *
+ * _('fred').capitalize().value();
+ * // => 'Fred'
+ *
+ * _.mixin({ 'capitalize': capitalize }, { 'chain': false });
+ * _('fred').capitalize();
+ * // => 'Fred'
+ */
+ function mixin(object, source, options) {
+ var chain = true,
+ methodNames = source && functions(source);
+
+ if (!source || (!options && !methodNames.length)) {
+ if (options == null) {
+ options = source;
+ }
+ ctor = lodashWrapper;
+ source = object;
+ object = lodash;
+ methodNames = functions(source);
+ }
+ if (options === false) {
+ chain = false;
+ } else if (isObject(options) && 'chain' in options) {
+ chain = options.chain;
+ }
+ var ctor = object,
+ isFunc = isFunction(ctor);
+
+ forEach(methodNames, function(methodName) {
+ var func = object[methodName] = source[methodName];
+ if (isFunc) {
+ ctor.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ value = this.__wrapped__,
+ args = [value];
+
+ push.apply(args, arguments);
+ var result = func.apply(object, args);
+ if (chain || chainAll) {
+ if (value === result && isObject(result)) {
+ return this;
+ }
+ result = new ctor(result);
+ result.__chain__ = chainAll;
+ }
+ return result;
+ };
+ }
+ });
+ }
+
+ /**
+ * Reverts the '_' variable to its previous value and returns a reference to
+ * the `lodash` function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @returns {Function} Returns the `lodash` function.
+ * @example
+ *
+ * var lodash = _.noConflict();
+ */
+ function noConflict() {
+ context._ = oldDash;
+ return this;
+ }
+
+ /**
+ * A no-operation function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.noop(object) === undefined;
+ * // => true
+ */
+ function noop() {
+ // no operation performed
+ }
+
+ /**
+ * Gets the number of milliseconds that have elapsed since the Unix epoch
+ * (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var stamp = _.now();
+ * _.defer(function() { console.log(_.now() - stamp); });
+ * // => logs the number of milliseconds it took for the deferred function to be called
+ */
+ var now = isNative(now = Date.now) && now || function() {
+ return new Date().getTime();
+ };
+
+ /**
+ * Converts the given value into an integer of the specified radix.
+ * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the
+ * `value` is a hexadecimal, in which case a `radix` of `16` is used.
+ *
+ * Note: This method avoids differences in native ES3 and ES5 `parseInt`
+ * implementations. See http://es5.github.io/#E.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} value The value to parse.
+ * @param {number} [radix] The radix used to interpret the value to parse.
+ * @returns {number} Returns the new integer value.
+ * @example
+ *
+ * _.parseInt('08');
+ * // => 8
+ */
+ var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {
+ // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt`
+ return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);
+ };
+
+ /**
+ * Creates a "_.pluck" style function, which returns the `key` value of a
+ * given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} key The name of the property to retrieve.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 36 }
+ * ];
+ *
+ * var getName = _.property('name');
+ *
+ * _.map(characters, getName);
+ * // => ['barney', 'fred']
+ *
+ * _.sortBy(characters, getName);
+ * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }]
+ */
+ function property(key) {
+ return function(object) {
+ return object[key];
+ };
+ }
+
+ /**
+ * Produces a random number between `min` and `max` (inclusive). If only one
+ * argument is provided a number between `0` and the given number will be
+ * returned. If `floating` is truey or either `min` or `max` are floats a
+ * floating-point number will be returned instead of an integer.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} [min=0] The minimum possible value.
+ * @param {number} [max=1] The maximum possible value.
+ * @param {boolean} [floating=false] Specify returning a floating-point number.
+ * @returns {number} Returns a random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+ function random(min, max, floating) {
+ var noMin = min == null,
+ noMax = max == null;
+
+ if (floating == null) {
+ if (typeof min == 'boolean' && noMax) {
+ floating = min;
+ min = 1;
+ }
+ else if (!noMax && typeof max == 'boolean') {
+ floating = max;
+ noMax = true;
+ }
+ }
+ if (noMin && noMax) {
+ max = 1;
+ }
+ min = +min || 0;
+ if (noMax) {
+ max = min;
+ min = 0;
+ } else {
+ max = +max || 0;
+ }
+ if (floating || min % 1 || max % 1) {
+ var rand = nativeRandom();
+ return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max);
+ }
+ return baseRandom(min, max);
+ }
+
+ /**
+ * Resolves the value of property `key` on `object`. If `key` is a function
+ * it will be invoked with the `this` binding of `object` and its result returned,
+ * else the property value is returned. If `object` is falsey then `undefined`
+ * is returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to resolve.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = {
+ * 'cheese': 'crumpets',
+ * 'stuff': function() {
+ * return 'nonsense';
+ * }
+ * };
+ *
+ * _.result(object, 'cheese');
+ * // => 'crumpets'
+ *
+ * _.result(object, 'stuff');
+ * // => 'nonsense'
+ */
+ function result(object, key) {
+ if (object) {
+ var value = object[key];
+ return isFunction(value) ? object[key]() : value;
+ }
+ }
+
+ /**
+ * A micro-templating method that handles arbitrary delimiters, preserves
+ * whitespace, and correctly escapes quotes within interpolated code.
+ *
+ * Note: In the development build, `_.template` utilizes sourceURLs for easier
+ * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ *
+ * For more information on precompiling templates see:
+ * https://lodash.com/custom-builds
+ *
+ * For more information on Chrome extension sandboxes see:
+ * http://developer.chrome.com/stable/extensions/sandboxingEval.html
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} text The template text.
+ * @param {Object} data The data object used to populate the text.
+ * @param {Object} [options] The options object.
+ * @param {RegExp} [options.escape] The "escape" delimiter.
+ * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
+ * @param {Object} [options.imports] An object to import into the template as local variables.
+ * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
+ * @param {string} [sourceURL] The sourceURL of the template's compiled source.
+ * @param {string} [variable] The data object variable name.
+ * @returns {Function|string} Returns a compiled function when no `data` object
+ * is given, else it returns the interpolated text.
+ * @example
+ *
+ * // using the "interpolate" delimiter to create a compiled template
+ * var compiled = _.template('hello <%= name %>');
+ * compiled({ 'name': 'fred' });
+ * // => 'hello fred'
+ *
+ * // using the "escape" delimiter to escape HTML in data property values
+ * _.template('<b><%- value %></b>', { 'value': '<script>' });
+ * // => '<b><script></b>'
+ *
+ * // using the "evaluate" delimiter to generate HTML
+ * var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
+ * _.template(list, { 'people': ['fred', 'barney'] });
+ * // => '<li>fred</li><li>barney</li>'
+ *
+ * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
+ * _.template('hello ${ name }', { 'name': 'pebbles' });
+ * // => 'hello pebbles'
+ *
+ * // using the internal `print` function in "evaluate" delimiters
+ * _.template('<% print("hello " + name); %>!', { 'name': 'barney' });
+ * // => 'hello barney!'
+ *
+ * // using a custom template delimiters
+ * _.templateSettings = {
+ * 'interpolate': /{{([\s\S]+?)}}/g
+ * };
+ *
+ * _.template('hello {{ name }}!', { 'name': 'mustache' });
+ * // => 'hello mustache!'
+ *
+ * // using the `imports` option to import jQuery
+ * var list = '<% jq.each(people, function(name) { %><li><%- name %></li><% }); %>';
+ * _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { 'jq': jQuery } });
+ * // => '<li>fred</li><li>barney</li>'
+ *
+ * // using the `sourceURL` option to specify a custom sourceURL for the template
+ * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+ * compiled(data);
+ * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
+ *
+ * // using the `variable` option to ensure a with-statement isn't used in the compiled template
+ * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+ * compiled.source;
+ * // => function(data) {
+ * var __t, __p = '', __e = _.escape;
+ * __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
+ * return __p;
+ * }
+ *
+ * // using the `source` property to inline compiled templates for meaningful
+ * // line numbers in error messages and a stack trace
+ * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
+ * var JST = {\
+ * "main": ' + _.template(mainText).source + '\
+ * };\
+ * ');
+ */
+ function template(text, data, options) {
+ // based on John Resig's `tmpl` implementation
+ // http://ejohn.org/blog/javascript-micro-templating/
+ // and Laura Doktorova's doT.js
+ // https://github.com/olado/doT
+ var settings = lodash.templateSettings;
+ text = String(text || '');
+
+ // avoid missing dependencies when `iteratorTemplate` is not defined
+ options = defaults({}, options, settings);
+
+ var imports = defaults({}, options.imports, settings.imports),
+ importsKeys = keys(imports),
+ importsValues = values(imports);
+
+ var isEvaluating,
+ index = 0,
+ interpolate = options.interpolate || reNoMatch,
+ source = "__p += '";
+
+ // compile the regexp to match each delimiter
+ var reDelimiters = RegExp(
+ (options.escape || reNoMatch).source + '|' +
+ interpolate.source + '|' +
+ (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
+ (options.evaluate || reNoMatch).source + '|$'
+ , 'g');
+
+ text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
+ interpolateValue || (interpolateValue = esTemplateValue);
+
+ // escape characters that cannot be included in string literals
+ source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);
+
+ // replace delimiters with snippets
+ if (escapeValue) {
+ source += "' +\n__e(" + escapeValue + ") +\n'";
+ }
+ if (evaluateValue) {
+ isEvaluating = true;
+ source += "';\n" + evaluateValue + ";\n__p += '";
+ }
+ if (interpolateValue) {
+ source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+ }
+ index = offset + match.length;
+
+ // the JS engine embedded in Adobe products requires returning the `match`
+ // string in order to produce the correct `offset` value
+ return match;
+ });
+
+ source += "';\n";
+
+ // if `variable` is not specified, wrap a with-statement around the generated
+ // code to add the data object to the top of the scope chain
+ var variable = options.variable,
+ hasVariable = variable;
+
+ if (!hasVariable) {
+ variable = 'obj';
+ source = 'with (' + variable + ') {\n' + source + '\n}\n';
+ }
+ // cleanup code by stripping empty strings
+ source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+ .replace(reEmptyStringMiddle, '$1')
+ .replace(reEmptyStringTrailing, '$1;');
+
+ // frame code as the function body
+ source = 'function(' + variable + ') {\n' +
+ (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
+ "var __t, __p = '', __e = _.escape" +
+ (isEvaluating
+ ? ', __j = Array.prototype.join;\n' +
+ "function print() { __p += __j.call(arguments, '') }\n"
+ : ';\n'
+ ) +
+ source +
+ 'return __p\n}';
+
+ // Use a sourceURL for easier debugging.
+ // http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ var sourceURL = '\n/*\n//# sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\n*/';
+
+ try {
+ var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);
+ } catch(e) {
+ e.source = source;
+ throw e;
+ }
+ if (data) {
+ return result(data);
+ }
+ // provide the compiled function's source by its `toString` method, in
+ // supported environments, or the `source` property as a convenience for
+ // inlining compiled templates during the build process
+ result.source = source;
+ return result;
+ }
+
+ /**
+ * Executes the callback `n` times, returning an array of the results
+ * of each callback execution. The callback is bound to `thisArg` and invoked
+ * with one argument; (index).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} n The number of times to execute the callback.
+ * @param {Function} callback The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns an array of the results of each `callback` execution.
+ * @example
+ *
+ * var diceRolls = _.times(3, _.partial(_.random, 1, 6));
+ * // => [3, 6, 4]
+ *
+ * _.times(3, function(n) { mage.castSpell(n); });
+ * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively
+ *
+ * _.times(3, function(n) { this.cast(n); }, mage);
+ * // => also calls `mage.castSpell(n)` three times
+ */
+ function times(n, callback, thisArg) {
+ n = (n = +n) > -1 ? n : 0;
+ var index = -1,
+ result = Array(n);
+
+ callback = baseCreateCallback(callback, thisArg, 1);
+ while (++index < n) {
+ result[index] = callback(index);
+ }
+ return result;
+ }
+
+ /**
+ * The inverse of `_.escape` this method converts the HTML entities
+ * `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding characters.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to unescape.
+ * @returns {string} Returns the unescaped string.
+ * @example
+ *
+ * _.unescape('Fred, Barney & Pebbles');
+ * // => 'Fred, Barney & Pebbles'
+ */
+ function unescape(string) {
+ return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar);
+ }
+
+ /**
+ * Generates a unique ID. If `prefix` is provided the ID will be appended to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} [prefix] The value to prefix the ID with.
+ * @returns {string} Returns the unique ID.
+ * @example
+ *
+ * _.uniqueId('contact_');
+ * // => 'contact_104'
+ *
+ * _.uniqueId();
+ * // => '105'
+ */
+ function uniqueId(prefix) {
+ var id = ++idCounter;
+ return String(prefix == null ? '' : prefix) + id;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object that wraps the given value with explicit
+ * method chaining enabled.
+ *
+ * @static
+ * @memberOf _
+ * @category Chaining
+ * @param {*} value The value to wrap.
+ * @returns {Object} Returns the wrapper object.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'pebbles', 'age': 1 }
+ * ];
+ *
+ * var youngest = _.chain(characters)
+ * .sortBy('age')
+ * .map(function(chr) { return chr.name + ' is ' + chr.age; })
+ * .first()
+ * .value();
+ * // => 'pebbles is 1'
+ */
+ function chain(value) {
+ value = new lodashWrapper(value);
+ value.__chain__ = true;
+ return value;
+ }
+
+ /**
+ * Invokes `interceptor` with the `value` as the first argument and then
+ * returns `value`. The purpose of this method is to "tap into" a method
+ * chain in order to perform operations on intermediate results within
+ * the chain.
+ *
+ * @static
+ * @memberOf _
+ * @category Chaining
+ * @param {*} value The value to provide to `interceptor`.
+ * @param {Function} interceptor The function to invoke.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * _([1, 2, 3, 4])
+ * .tap(function(array) { array.pop(); })
+ * .reverse()
+ * .value();
+ * // => [3, 2, 1]
+ */
+ function tap(value, interceptor) {
+ interceptor(value);
+ return value;
+ }
+
+ /**
+ * Enables explicit method chaining on the wrapper object.
+ *
+ * @name chain
+ * @memberOf _
+ * @category Chaining
+ * @returns {*} Returns the wrapper object.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // without explicit chaining
+ * _(characters).first();
+ * // => { 'name': 'barney', 'age': 36 }
+ *
+ * // with explicit chaining
+ * _(characters).chain()
+ * .first()
+ * .pick('age')
+ * .value();
+ * // => { 'age': 36 }
+ */
+ function wrapperChain() {
+ this.__chain__ = true;
+ return this;
+ }
+
+ /**
+ * Produces the `toString` result of the wrapped value.
+ *
+ * @name toString
+ * @memberOf _
+ * @category Chaining
+ * @returns {string} Returns the string result.
+ * @example
+ *
+ * _([1, 2, 3]).toString();
+ * // => '1,2,3'
+ */
+ function wrapperToString() {
+ return String(this.__wrapped__);
+ }
+
+ /**
+ * Extracts the wrapped value.
+ *
+ * @name valueOf
+ * @memberOf _
+ * @alias value
+ * @category Chaining
+ * @returns {*} Returns the wrapped value.
+ * @example
+ *
+ * _([1, 2, 3]).valueOf();
+ * // => [1, 2, 3]
+ */
+ function wrapperValueOf() {
+ return this.__wrapped__;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions that return wrapped values when chaining
+ lodash.after = after;
+ lodash.assign = assign;
+ lodash.at = at;
+ lodash.bind = bind;
+ lodash.bindAll = bindAll;
+ lodash.bindKey = bindKey;
+ lodash.chain = chain;
+ lodash.compact = compact;
+ lodash.compose = compose;
+ lodash.constant = constant;
+ lodash.countBy = countBy;
+ lodash.create = create;
+ lodash.createCallback = createCallback;
+ lodash.curry = curry;
+ lodash.debounce = debounce;
+ lodash.defaults = defaults;
+ lodash.defer = defer;
+ lodash.delay = delay;
+ lodash.difference = difference;
+ lodash.filter = filter;
+ lodash.flatten = flatten;
+ lodash.forEach = forEach;
+ lodash.forEachRight = forEachRight;
+ lodash.forIn = forIn;
+ lodash.forInRight = forInRight;
+ lodash.forOwn = forOwn;
+ lodash.forOwnRight = forOwnRight;
+ lodash.functions = functions;
+ lodash.groupBy = groupBy;
+ lodash.indexBy = indexBy;
+ lodash.initial = initial;
+ lodash.intersection = intersection;
+ lodash.invert = invert;
+ lodash.invoke = invoke;
+ lodash.keys = keys;
+ lodash.map = map;
+ lodash.mapValues = mapValues;
+ lodash.max = max;
+ lodash.memoize = memoize;
+ lodash.merge = merge;
+ lodash.min = min;
+ lodash.omit = omit;
+ lodash.once = once;
+ lodash.pairs = pairs;
+ lodash.partial = partial;
+ lodash.partialRight = partialRight;
+ lodash.pick = pick;
+ lodash.pluck = pluck;
+ lodash.property = property;
+ lodash.pull = pull;
+ lodash.range = range;
+ lodash.reject = reject;
+ lodash.remove = remove;
+ lodash.rest = rest;
+ lodash.shuffle = shuffle;
+ lodash.sortBy = sortBy;
+ lodash.tap = tap;
+ lodash.throttle = throttle;
+ lodash.times = times;
+ lodash.toArray = toArray;
+ lodash.transform = transform;
+ lodash.union = union;
+ lodash.uniq = uniq;
+ lodash.values = values;
+ lodash.where = where;
+ lodash.without = without;
+ lodash.wrap = wrap;
+ lodash.xor = xor;
+ lodash.zip = zip;
+ lodash.zipObject = zipObject;
+
+ // add aliases
+ lodash.collect = map;
+ lodash.drop = rest;
+ lodash.each = forEach;
+ lodash.eachRight = forEachRight;
+ lodash.extend = assign;
+ lodash.methods = functions;
+ lodash.object = zipObject;
+ lodash.select = filter;
+ lodash.tail = rest;
+ lodash.unique = uniq;
+ lodash.unzip = zip;
+
+ // add functions to `lodash.prototype`
+ mixin(lodash);
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions that return unwrapped values when chaining
+ lodash.clone = clone;
+ lodash.cloneDeep = cloneDeep;
+ lodash.contains = contains;
+ lodash.escape = escape;
+ lodash.every = every;
+ lodash.find = find;
+ lodash.findIndex = findIndex;
+ lodash.findKey = findKey;
+ lodash.findLast = findLast;
+ lodash.findLastIndex = findLastIndex;
+ lodash.findLastKey = findLastKey;
+ lodash.has = has;
+ lodash.identity = identity;
+ lodash.indexOf = indexOf;
+ lodash.isArguments = isArguments;
+ lodash.isArray = isArray;
+ lodash.isBoolean = isBoolean;
+ lodash.isDate = isDate;
+ lodash.isElement = isElement;
+ lodash.isEmpty = isEmpty;
+ lodash.isEqual = isEqual;
+ lodash.isFinite = isFinite;
+ lodash.isFunction = isFunction;
+ lodash.isNaN = isNaN;
+ lodash.isNull = isNull;
+ lodash.isNumber = isNumber;
+ lodash.isObject = isObject;
+ lodash.isPlainObject = isPlainObject;
+ lodash.isRegExp = isRegExp;
+ lodash.isString = isString;
+ lodash.isUndefined = isUndefined;
+ lodash.lastIndexOf = lastIndexOf;
+ lodash.mixin = mixin;
+ lodash.noConflict = noConflict;
+ lodash.noop = noop;
+ lodash.now = now;
+ lodash.parseInt = parseInt;
+ lodash.random = random;
+ lodash.reduce = reduce;
+ lodash.reduceRight = reduceRight;
+ lodash.result = result;
+ lodash.runInContext = runInContext;
+ lodash.size = size;
+ lodash.some = some;
+ lodash.sortedIndex = sortedIndex;
+ lodash.template = template;
+ lodash.unescape = unescape;
+ lodash.uniqueId = uniqueId;
+
+ // add aliases
+ lodash.all = every;
+ lodash.any = some;
+ lodash.detect = find;
+ lodash.findWhere = find;
+ lodash.foldl = reduce;
+ lodash.foldr = reduceRight;
+ lodash.include = contains;
+ lodash.inject = reduce;
+
+ mixin(function() {
+ var source = {}
+ forOwn(lodash, function(func, methodName) {
+ if (!lodash.prototype[methodName]) {
+ source[methodName] = func;
+ }
+ });
+ return source;
+ }(), false);
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions capable of returning wrapped and unwrapped values when chaining
+ lodash.first = first;
+ lodash.last = last;
+ lodash.sample = sample;
+
+ // add aliases
+ lodash.take = first;
+ lodash.head = first;
+
+ forOwn(lodash, function(func, methodName) {
+ var callbackable = methodName !== 'sample';
+ if (!lodash.prototype[methodName]) {
+ lodash.prototype[methodName]= function(n, guard) {
+ var chainAll = this.__chain__,
+ result = func(this.__wrapped__, n, guard);
+
+ return !chainAll && (n == null || (guard && !(callbackable && typeof n == 'function')))
+ ? result
+ : new lodashWrapper(result, chainAll);
+ };
+ }
+ });
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The semantic version number.
+ *
+ * @static
+ * @memberOf _
+ * @type string
+ */
+ lodash.VERSION = '2.4.2';
+
+ // add "Chaining" functions to the wrapper
+ lodash.prototype.chain = wrapperChain;
+ lodash.prototype.toString = wrapperToString;
+ lodash.prototype.value = wrapperValueOf;
+ lodash.prototype.valueOf = wrapperValueOf;
+
+ // add `Array` functions that return unwrapped values
+ forEach(['join', 'pop', 'shift'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ result = func.apply(this.__wrapped__, arguments);
+
+ return chainAll
+ ? new lodashWrapper(result, chainAll)
+ : result;
+ };
+ });
+
+ // add `Array` functions that return the existing wrapped value
+ forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ func.apply(this.__wrapped__, arguments);
+ return this;
+ };
+ });
+
+ // add `Array` functions that return new wrapped values
+ forEach(['concat', 'slice', 'splice'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ return new lodashWrapper(func.apply(this.__wrapped__, arguments), this.__chain__);
+ };
+ });
+
+ return lodash;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ // expose Lo-Dash
+ var _ = runInContext();
+
+ // some AMD build optimizers like r.js check for condition patterns like the following:
+ if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+ // Expose Lo-Dash to the global object even when an AMD loader is present in
+ // case Lo-Dash is loaded with a RequireJS shim config.
+ // See http://requirejs.org/docs/api.html#config-shim
+ root._ = _;
+
+ // define as an anonymous module so, through path mapping, it can be
+ // referenced as the "underscore" module
+ define(function() {
+ return _;
+ });
+ }
+ // check for `exports` after `define` in case a build optimizer adds an `exports` object
+ else if (freeExports && freeModule) {
+ // in Node.js or RingoJS
+ if (moduleExports) {
+ (freeModule.exports = _)._ = _;
+ }
+ // in Narwhal or Rhino -require
+ else {
+ freeExports._ = _;
+ }
+ }
+ else {
+ // in a browser or Rhino
+ root._ = _;
+ }
+}.call(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],81:[function(require,module,exports){
+(function (global){
+/**
+ * @license
+ * Lo-Dash 2.4.2 (Custom Build) <https://lodash.com/>
+ * Build: `lodash modern -o ./dist/lodash.js`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <https://lodash.com/license>
+ */
+;(function() {
+
+ /** Used as a safe reference for `undefined` in pre ES5 environments */
+ var undefined;
+
+ /** Used to pool arrays and objects used internally */
+ var arrayPool = [],
+ objectPool = [];
+
+ /** Used to generate unique IDs */
+ var idCounter = 0;
+
+ /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */
+ var keyPrefix = +new Date + '';
+
+ /** Used as the size when optimizations are enabled for large arrays */
+ var largeArraySize = 75;
+
+ /** Used as the max size of the `arrayPool` and `objectPool` */
+ var maxPoolSize = 40;
+
+ /** Used to detect and test whitespace */
+ var whitespace = (
+ // whitespace
+ ' \t\x0B\f\xA0\ufeff' +
+
+ // line terminators
+ '\n\r\u2028\u2029' +
+
+ // unicode category "Zs" space separators
+ '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
+ );
+
+ /** Used to match empty string literals in compiled template source */
+ var reEmptyStringLeading = /\b__p \+= '';/g,
+ reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+ reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+ /**
+ * Used to match ES6 template delimiters
+ * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals
+ */
+ var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+ /** Used to match regexp flags from their coerced string values */
+ var reFlags = /\w*$/;
+
+ /** Used to detected named functions */
+ var reFuncName = /^\s*function[ \n\r\t]+\w/;
+
+ /** Used to match "interpolate" template delimiters */
+ var reInterpolate = /<%=([\s\S]+?)%>/g;
+
+ /** Used to match leading whitespace and zeros to be removed */
+ var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');
+
+ /** Used to ensure capturing order of template delimiters */
+ var reNoMatch = /($^)/;
+
+ /** Used to detect functions containing a `this` reference */
+ var reThis = /\bthis\b/;
+
+ /** Used to match unescaped characters in compiled string literals */
+ var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
+
+ /** Used to assign default `context` object properties */
+ var contextProps = [
+ 'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object',
+ 'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',
+ 'parseInt', 'setTimeout'
+ ];
+
+ /** Used to make template sourceURLs easier to identify */
+ var templateCounter = 0;
+
+ /** `Object#toString` result shortcuts */
+ var argsClass = '[object Arguments]',
+ arrayClass = '[object Array]',
+ boolClass = '[object Boolean]',
+ dateClass = '[object Date]',
+ funcClass = '[object Function]',
+ numberClass = '[object Number]',
+ objectClass = '[object Object]',
+ regexpClass = '[object RegExp]',
+ stringClass = '[object String]';
+
+ /** Used to identify object classifications that `_.clone` supports */
+ var cloneableClasses = {};
+ cloneableClasses[funcClass] = false;
+ cloneableClasses[argsClass] = cloneableClasses[arrayClass] =
+ cloneableClasses[boolClass] = cloneableClasses[dateClass] =
+ cloneableClasses[numberClass] = cloneableClasses[objectClass] =
+ cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;
+
+ /** Used as an internal `_.debounce` options object */
+ var debounceOptions = {
+ 'leading': false,
+ 'maxWait': 0,
+ 'trailing': false
+ };
+
+ /** Used as the property descriptor for `__bindData__` */
+ var descriptor = {
+ 'configurable': false,
+ 'enumerable': false,
+ 'value': null,
+ 'writable': false
+ };
+
+ /** Used to determine if values are of the language type Object */
+ var objectTypes = {
+ 'boolean': false,
+ 'function': true,
+ 'object': true,
+ 'number': false,
+ 'string': false,
+ 'undefined': false
+ };
+
+ /** Used to escape characters for inclusion in compiled string literals */
+ var stringEscapes = {
+ '\\': '\\',
+ "'": "'",
+ '\n': 'n',
+ '\r': 'r',
+ '\t': 't',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ /** Used as a reference to the global object */
+ var root = (objectTypes[typeof window] && window) || this;
+
+ /** Detect free variable `exports` */
+ var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
+
+ /** Detect free variable `module` */
+ var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
+
+ /** Detect the popular CommonJS extension `module.exports` */
+ var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
+
+ /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
+ var freeGlobal = objectTypes[typeof global] && global;
+ if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
+ root = freeGlobal;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The base implementation of `_.indexOf` without support for binary searches
+ * or `fromIndex` constraints.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ */
+ function baseIndexOf(array, value, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0;
+
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * An implementation of `_.contains` for cache objects that mimics the return
+ * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.
+ *
+ * @private
+ * @param {Object} cache The cache object to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `0` if `value` is found, else `-1`.
+ */
+ function cacheIndexOf(cache, value) {
+ var type = typeof value;
+ cache = cache.cache;
+
+ if (type == 'boolean' || value == null) {
+ return cache[value] ? 0 : -1;
+ }
+ if (type != 'number' && type != 'string') {
+ type = 'object';
+ }
+ var key = type == 'number' ? value : keyPrefix + value;
+ cache = (cache = cache[type]) && cache[key];
+
+ return type == 'object'
+ ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)
+ : (cache ? 0 : -1);
+ }
+
+ /**
+ * Adds a given value to the corresponding cache object.
+ *
+ * @private
+ * @param {*} value The value to add to the cache.
+ */
+ function cachePush(value) {
+ var cache = this.cache,
+ type = typeof value;
+
+ if (type == 'boolean' || value == null) {
+ cache[value] = true;
+ } else {
+ if (type != 'number' && type != 'string') {
+ type = 'object';
+ }
+ var key = type == 'number' ? value : keyPrefix + value,
+ typeCache = cache[type] || (cache[type] = {});
+
+ if (type == 'object') {
+ (typeCache[key] || (typeCache[key] = [])).push(value);
+ } else {
+ typeCache[key] = true;
+ }
+ }
+ }
+
+ /**
+ * Used by `_.max` and `_.min` as the default callback when a given
+ * collection is a string value.
+ *
+ * @private
+ * @param {string} value The character to inspect.
+ * @returns {number} Returns the code unit of given character.
+ */
+ function charAtCallback(value) {
+ return value.charCodeAt(0);
+ }
+
+ /**
+ * Used by `sortBy` to compare transformed `collection` elements, stable sorting
+ * them in ascending order.
+ *
+ * @private
+ * @param {Object} a The object to compare to `b`.
+ * @param {Object} b The object to compare to `a`.
+ * @returns {number} Returns the sort order indicator of `1` or `-1`.
+ */
+ function compareAscending(a, b) {
+ var ac = a.criteria,
+ bc = b.criteria,
+ index = -1,
+ length = ac.length;
+
+ while (++index < length) {
+ var value = ac[index],
+ other = bc[index];
+
+ if (value !== other) {
+ if (value > other || typeof value == 'undefined') {
+ return 1;
+ }
+ if (value < other || typeof other == 'undefined') {
+ return -1;
+ }
+ }
+ }
+ // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
+ // that causes it, under certain circumstances, to return the same value for
+ // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247
+ //
+ // This also ensures a stable sort in V8 and other engines.
+ // See http://code.google.com/p/v8/issues/detail?id=90
+ return a.index - b.index;
+ }
+
+ /**
+ * Creates a cache object to optimize linear searches of large arrays.
+ *
+ * @private
+ * @param {Array} [array=[]] The array to search.
+ * @returns {null|Object} Returns the cache object or `null` if caching should not be used.
+ */
+ function createCache(array) {
+ var index = -1,
+ length = array.length,
+ first = array[0],
+ mid = array[(length / 2) | 0],
+ last = array[length - 1];
+
+ if (first && typeof first == 'object' &&
+ mid && typeof mid == 'object' && last && typeof last == 'object') {
+ return false;
+ }
+ var cache = getObject();
+ cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;
+
+ var result = getObject();
+ result.array = array;
+ result.cache = cache;
+ result.push = cachePush;
+
+ while (++index < length) {
+ result.push(array[index]);
+ }
+ return result;
+ }
+
+ /**
+ * Used by `template` to escape characters for inclusion in compiled
+ * string literals.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeStringChar(match) {
+ return '\\' + stringEscapes[match];
+ }
+
+ /**
+ * Gets an array from the array pool or creates a new one if the pool is empty.
+ *
+ * @private
+ * @returns {Array} The array from the pool.
+ */
+ function getArray() {
+ return arrayPool.pop() || [];
+ }
+
+ /**
+ * Gets an object from the object pool or creates a new one if the pool is empty.
+ *
+ * @private
+ * @returns {Object} The object from the pool.
+ */
+ function getObject() {
+ return objectPool.pop() || {
+ 'array': null,
+ 'cache': null,
+ 'criteria': null,
+ 'false': false,
+ 'index': 0,
+ 'null': false,
+ 'number': null,
+ 'object': null,
+ 'push': null,
+ 'string': null,
+ 'true': false,
+ 'undefined': false,
+ 'value': null
+ };
+ }
+
+ /**
+ * Releases the given array back to the array pool.
+ *
+ * @private
+ * @param {Array} [array] The array to release.
+ */
+ function releaseArray(array) {
+ array.length = 0;
+ if (arrayPool.length < maxPoolSize) {
+ arrayPool.push(array);
+ }
+ }
+
+ /**
+ * Releases the given object back to the object pool.
+ *
+ * @private
+ * @param {Object} [object] The object to release.
+ */
+ function releaseObject(object) {
+ var cache = object.cache;
+ if (cache) {
+ releaseObject(cache);
+ }
+ object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;
+ if (objectPool.length < maxPoolSize) {
+ objectPool.push(object);
+ }
+ }
+
+ /**
+ * Slices the `collection` from the `start` index up to, but not including,
+ * the `end` index.
+ *
+ * Note: This function is used instead of `Array#slice` to support node lists
+ * in IE < 9 and to ensure dense arrays are returned.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to slice.
+ * @param {number} start The start index.
+ * @param {number} end The end index.
+ * @returns {Array} Returns the new array.
+ */
+ function slice(array, start, end) {
+ start || (start = 0);
+ if (typeof end == 'undefined') {
+ end = array ? array.length : 0;
+ }
+ var index = -1,
+ length = end - start || 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = array[start + index];
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Create a new `lodash` function using the given context object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} [context=root] The context object.
+ * @returns {Function} Returns the `lodash` function.
+ */
+ function runInContext(context) {
+ // Avoid issues with some ES3 environments that attempt to use values, named
+ // after built-in constructors like `Object`, for the creation of literals.
+ // ES5 clears this up by stating that literals must use built-in constructors.
+ // See http://es5.github.io/#x11.1.5.
+ context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;
+
+ /** Native constructor references */
+ var Array = context.Array,
+ Boolean = context.Boolean,
+ Date = context.Date,
+ Function = context.Function,
+ Math = context.Math,
+ Number = context.Number,
+ Object = context.Object,
+ RegExp = context.RegExp,
+ String = context.String,
+ TypeError = context.TypeError;
+
+ /**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+ var arrayRef = [];
+
+ /** Used for native method references */
+ var objectProto = Object.prototype;
+
+ /** Used to restore the original `_` reference in `noConflict` */
+ var oldDash = context._;
+
+ /** Used to resolve the internal [[Class]] of values */
+ var toString = objectProto.toString;
+
+ /** Used to detect if a method is native */
+ var reNative = RegExp('^' +
+ String(toString)
+ .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+ .replace(/toString| for [^\]]+/g, '.*?') + '$'
+ );
+
+ /** Native method shortcuts */
+ var ceil = Math.ceil,
+ clearTimeout = context.clearTimeout,
+ floor = Math.floor,
+ fnToString = Function.prototype.toString,
+ getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
+ hasOwnProperty = objectProto.hasOwnProperty,
+ push = arrayRef.push,
+ setTimeout = context.setTimeout,
+ splice = arrayRef.splice,
+ unshift = arrayRef.unshift;
+
+ /** Used to set meta data on functions */
+ var defineProperty = (function() {
+ // IE 8 only accepts DOM elements
+ try {
+ var o = {},
+ func = isNative(func = Object.defineProperty) && func,
+ result = func(o, o, o) && func;
+ } catch(e) { }
+ return result;
+ }());
+
+ /* Native method shortcuts for methods with the same name as other `lodash` methods */
+ var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate,
+ nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray,
+ nativeIsFinite = context.isFinite,
+ nativeIsNaN = context.isNaN,
+ nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys,
+ nativeMax = Math.max,
+ nativeMin = Math.min,
+ nativeParseInt = context.parseInt,
+ nativeRandom = Math.random;
+
+ /** Used to lookup a built-in constructor by [[Class]] */
+ var ctorByClass = {};
+ ctorByClass[arrayClass] = Array;
+ ctorByClass[boolClass] = Boolean;
+ ctorByClass[dateClass] = Date;
+ ctorByClass[funcClass] = Function;
+ ctorByClass[objectClass] = Object;
+ ctorByClass[numberClass] = Number;
+ ctorByClass[regexpClass] = RegExp;
+ ctorByClass[stringClass] = String;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object which wraps the given value to enable intuitive
+ * method chaining.
+ *
+ * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
+ * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,
+ * and `unshift`
+ *
+ * Chaining is supported in custom builds as long as the `value` method is
+ * implicitly or explicitly included in the build.
+ *
+ * The chainable wrapper functions are:
+ * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,
+ * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`,
+ * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`,
+ * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,
+ * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,
+ * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
+ * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`,
+ * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`,
+ * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`,
+ * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`,
+ * and `zip`
+ *
+ * The non-chainable wrapper functions are:
+ * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`,
+ * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`,
+ * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,
+ * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`,
+ * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`,
+ * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`,
+ * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`,
+ * `template`, `unescape`, `uniqueId`, and `value`
+ *
+ * The wrapper functions `first` and `last` return wrapped values when `n` is
+ * provided, otherwise they return unwrapped values.
+ *
+ * Explicit chaining can be enabled by using the `_.chain` method.
+ *
+ * @name _
+ * @constructor
+ * @category Chaining
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @returns {Object} Returns a `lodash` instance.
+ * @example
+ *
+ * var wrapped = _([1, 2, 3]);
+ *
+ * // returns an unwrapped value
+ * wrapped.reduce(function(sum, num) {
+ * return sum + num;
+ * });
+ * // => 6
+ *
+ * // returns a wrapped value
+ * var squares = wrapped.map(function(num) {
+ * return num * num;
+ * });
+ *
+ * _.isArray(squares);
+ * // => false
+ *
+ * _.isArray(squares.value());
+ * // => true
+ */
+ function lodash(value) {
+ // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor
+ return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))
+ ? value
+ : new lodashWrapper(value);
+ }
+
+ /**
+ * A fast path for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @param {boolean} chainAll A flag to enable chaining for all methods
+ * @returns {Object} Returns a `lodash` instance.
+ */
+ function lodashWrapper(value, chainAll) {
+ this.__chain__ = !!chainAll;
+ this.__wrapped__ = value;
+ }
+ // ensure `new lodashWrapper` is an instance of `lodash`
+ lodashWrapper.prototype = lodash.prototype;
+
+ /**
+ * An object used to flag environments features.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ var support = lodash.support = {};
+
+ /**
+ * Detect if functions can be decompiled by `Function#toString`
+ * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcDecomp = !isNative(context.WinRTError) && reThis.test(runInContext);
+
+ /**
+ * Detect if `Function#name` is supported (all but IE).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcNames = typeof Function.name == 'string';
+
+ /**
+ * By default, the template delimiters used by Lo-Dash are similar to those in
+ * embedded Ruby (ERB). Change the following template settings to use alternative
+ * delimiters.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ lodash.templateSettings = {
+
+ /**
+ * Used to detect `data` property values to be HTML-escaped.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'escape': /<%-([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect code to be evaluated.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'evaluate': /<%([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect `data` property values to inject.
+ *
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'interpolate': reInterpolate,
+
+ /**
+ * Used to reference the data object in the template text.
+ *
+ * @memberOf _.templateSettings
+ * @type string
+ */
+ 'variable': '',
+
+ /**
+ * Used to import variables into the compiled template.
+ *
+ * @memberOf _.templateSettings
+ * @type Object
+ */
+ 'imports': {
+
+ /**
+ * A reference to the `lodash` function.
+ *
+ * @memberOf _.templateSettings.imports
+ * @type Function
+ */
+ '_': lodash
+ }
+ };
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The base implementation of `_.bind` that creates the bound function and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new bound function.
+ */
+ function baseBind(bindData) {
+ var func = bindData[0],
+ partialArgs = bindData[2],
+ thisArg = bindData[4];
+
+ function bound() {
+ // `Function#bind` spec
+ // http://es5.github.io/#x15.3.4.5
+ if (partialArgs) {
+ // avoid `arguments` object deoptimizations by using `slice` instead
+ // of `Array.prototype.slice.call` and not assigning `arguments` to a
+ // variable as a ternary expression
+ var args = slice(partialArgs);
+ push.apply(args, arguments);
+ }
+ // mimic the constructor's `return` behavior
+ // http://es5.github.io/#x13.2.2
+ if (this instanceof bound) {
+ // ensure `new bound` is an instance of `func`
+ var thisBinding = baseCreate(func.prototype),
+ result = func.apply(thisBinding, args || arguments);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisArg, args || arguments);
+ }
+ setBindData(bound, bindData);
+ return bound;
+ }
+
+ /**
+ * The base implementation of `_.clone` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep=false] Specify a deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates clones with source counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+ function baseClone(value, isDeep, callback, stackA, stackB) {
+ if (callback) {
+ var result = callback(value);
+ if (typeof result != 'undefined') {
+ return result;
+ }
+ }
+ // inspect [[Class]]
+ var isObj = isObject(value);
+ if (isObj) {
+ var className = toString.call(value);
+ if (!cloneableClasses[className]) {
+ return value;
+ }
+ var ctor = ctorByClass[className];
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ return new ctor(+value);
+
+ case numberClass:
+ case stringClass:
+ return new ctor(value);
+
+ case regexpClass:
+ result = ctor(value.source, reFlags.exec(value));
+ result.lastIndex = value.lastIndex;
+ return result;
+ }
+ } else {
+ return value;
+ }
+ var isArr = isArray(value);
+ if (isDeep) {
+ // check for circular references and return corresponding clone
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == value) {
+ return stackB[length];
+ }
+ }
+ result = isArr ? ctor(value.length) : {};
+ }
+ else {
+ result = isArr ? slice(value) : assign({}, value);
+ }
+ // add array properties assigned by `RegExp#exec`
+ if (isArr) {
+ if (hasOwnProperty.call(value, 'index')) {
+ result.index = value.index;
+ }
+ if (hasOwnProperty.call(value, 'input')) {
+ result.input = value.input;
+ }
+ }
+ // exit for shallow clone
+ if (!isDeep) {
+ return result;
+ }
+ // add the source value to the stack of traversed objects
+ // and associate it with its clone
+ stackA.push(value);
+ stackB.push(result);
+
+ // recursively populate clone (susceptible to call stack limits)
+ (isArr ? forEach : forOwn)(value, function(objValue, key) {
+ result[key] = baseClone(objValue, isDeep, callback, stackA, stackB);
+ });
+
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+ function baseCreate(prototype, properties) {
+ return isObject(prototype) ? nativeCreate(prototype) : {};
+ }
+ // fallback for browsers without `Object.create`
+ if (!nativeCreate) {
+ baseCreate = (function() {
+ function Object() {}
+ return function(prototype) {
+ if (isObject(prototype)) {
+ Object.prototype = prototype;
+ var result = new Object;
+ Object.prototype = null;
+ }
+ return result || context.Object();
+ };
+ }());
+ }
+
+ /**
+ * The base implementation of `_.createCallback` without support for creating
+ * "_.pluck" or "_.where" style callbacks.
+ *
+ * @private
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ */
+ function baseCreateCallback(func, thisArg, argCount) {
+ if (typeof func != 'function') {
+ return identity;
+ }
+ // exit early for no `thisArg` or already bound by `Function#bind`
+ if (typeof thisArg == 'undefined' || !('prototype' in func)) {
+ return func;
+ }
+ var bindData = func.__bindData__;
+ if (typeof bindData == 'undefined') {
+ if (support.funcNames) {
+ bindData = !func.name;
+ }
+ bindData = bindData || !support.funcDecomp;
+ if (!bindData) {
+ var source = fnToString.call(func);
+ if (!support.funcNames) {
+ bindData = !reFuncName.test(source);
+ }
+ if (!bindData) {
+ // checks if `func` references the `this` keyword and stores the result
+ bindData = reThis.test(source);
+ setBindData(func, bindData);
+ }
+ }
+ }
+ // exit early if there are no `this` references or `func` is bound
+ if (bindData === false || (bindData !== true && bindData[1] & 1)) {
+ return func;
+ }
+ switch (argCount) {
+ case 1: return function(value) {
+ return func.call(thisArg, value);
+ };
+ case 2: return function(a, b) {
+ return func.call(thisArg, a, b);
+ };
+ case 3: return function(value, index, collection) {
+ return func.call(thisArg, value, index, collection);
+ };
+ case 4: return function(accumulator, value, index, collection) {
+ return func.call(thisArg, accumulator, value, index, collection);
+ };
+ }
+ return bind(func, thisArg);
+ }
+
+ /**
+ * The base implementation of `createWrapper` that creates the wrapper and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new function.
+ */
+ function baseCreateWrapper(bindData) {
+ var func = bindData[0],
+ bitmask = bindData[1],
+ partialArgs = bindData[2],
+ partialRightArgs = bindData[3],
+ thisArg = bindData[4],
+ arity = bindData[5];
+
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ key = func;
+
+ function bound() {
+ var thisBinding = isBind ? thisArg : this;
+ if (partialArgs) {
+ var args = slice(partialArgs);
+ push.apply(args, arguments);
+ }
+ if (partialRightArgs || isCurry) {
+ args || (args = slice(arguments));
+ if (partialRightArgs) {
+ push.apply(args, partialRightArgs);
+ }
+ if (isCurry && args.length < arity) {
+ bitmask |= 16 & ~32;
+ return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
+ }
+ }
+ args || (args = arguments);
+ if (isBindKey) {
+ func = thisBinding[key];
+ }
+ if (this instanceof bound) {
+ thisBinding = baseCreate(func.prototype);
+ var result = func.apply(thisBinding, args);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisBinding, args);
+ }
+ setBindData(bound, bindData);
+ return bound;
+ }
+
+ /**
+ * The base implementation of `_.difference` that accepts a single array
+ * of values to exclude.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {Array} [values] The array of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ */
+ function baseDifference(array, values) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ isLarge = length >= largeArraySize && indexOf === baseIndexOf,
+ result = [];
+
+ if (isLarge) {
+ var cache = createCache(values);
+ if (cache) {
+ indexOf = cacheIndexOf;
+ values = cache;
+ } else {
+ isLarge = false;
+ }
+ }
+ while (++index < length) {
+ var value = array[index];
+ if (indexOf(values, value) < 0) {
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseObject(values);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.flatten` without support for callback
+ * shorthands or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {boolean} [isStrict=false] A flag to restrict flattening to arrays and `arguments` objects.
+ * @param {number} [fromIndex=0] The index to start from.
+ * @returns {Array} Returns a new flattened array.
+ */
+ function baseFlatten(array, isShallow, isStrict, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+
+ if (value && typeof value == 'object' && typeof value.length == 'number'
+ && (isArray(value) || isArguments(value))) {
+ // recursively flatten arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ value = baseFlatten(value, isShallow, isStrict);
+ }
+ var valIndex = -1,
+ valLength = value.length,
+ resIndex = result.length;
+
+ result.length += valLength;
+ while (++valIndex < valLength) {
+ result[resIndex++] = value[valIndex];
+ }
+ } else if (!isStrict) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.isEqual`, without support for `thisArg` binding,
+ * that allows partial "_.where" style comparisons.
+ *
+ * @private
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {Function} [isWhere=false] A flag to indicate performing partial comparisons.
+ * @param {Array} [stackA=[]] Tracks traversed `a` objects.
+ * @param {Array} [stackB=[]] Tracks traversed `b` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+ function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
+ // used to indicate that when comparing objects, `a` has at least the properties of `b`
+ if (callback) {
+ var result = callback(a, b);
+ if (typeof result != 'undefined') {
+ return !!result;
+ }
+ }
+ // exit early for identical values
+ if (a === b) {
+ // treat `+0` vs. `-0` as not equal
+ return a !== 0 || (1 / a == 1 / b);
+ }
+ var type = typeof a,
+ otherType = typeof b;
+
+ // exit early for unlike primitive values
+ if (a === a &&
+ !(a && objectTypes[type]) &&
+ !(b && objectTypes[otherType])) {
+ return false;
+ }
+ // exit early for `null` and `undefined` avoiding ES3's Function#call behavior
+ // http://es5.github.io/#x15.3.4.4
+ if (a == null || b == null) {
+ return a === b;
+ }
+ // compare [[Class]] names
+ var className = toString.call(a),
+ otherClass = toString.call(b);
+
+ if (className == argsClass) {
+ className = objectClass;
+ }
+ if (otherClass == argsClass) {
+ otherClass = objectClass;
+ }
+ if (className != otherClass) {
+ return false;
+ }
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ // coerce dates and booleans to numbers, dates to milliseconds and booleans
+ // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
+ return +a == +b;
+
+ case numberClass:
+ // treat `NaN` vs. `NaN` as equal
+ return (a != +a)
+ ? b != +b
+ // but treat `+0` vs. `-0` as not equal
+ : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+ case regexpClass:
+ case stringClass:
+ // coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
+ // treat string primitives and their corresponding object instances as equal
+ return a == String(b);
+ }
+ var isArr = className == arrayClass;
+ if (!isArr) {
+ // unwrap any `lodash` wrapped values
+ var aWrapped = hasOwnProperty.call(a, '__wrapped__'),
+ bWrapped = hasOwnProperty.call(b, '__wrapped__');
+
+ if (aWrapped || bWrapped) {
+ return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);
+ }
+ // exit for functions and DOM nodes
+ if (className != objectClass) {
+ return false;
+ }
+ // in older versions of Opera, `arguments` objects have `Array` constructors
+ var ctorA = a.constructor,
+ ctorB = b.constructor;
+
+ // non `Object` object instances with different constructors are not equal
+ if (ctorA != ctorB &&
+ !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
+ ('constructor' in a && 'constructor' in b)
+ ) {
+ return false;
+ }
+ }
+ // assume cyclic structures are equal
+ // the algorithm for detecting cyclic structures is adapted from ES 5.1
+ // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == a) {
+ return stackB[length] == b;
+ }
+ }
+ var size = 0;
+ result = true;
+
+ // add `a` and `b` to the stack of traversed objects
+ stackA.push(a);
+ stackB.push(b);
+
+ // recursively compare objects and arrays (susceptible to call stack limits)
+ if (isArr) {
+ // compare lengths to determine if a deep comparison is necessary
+ length = a.length;
+ size = b.length;
+ result = size == length;
+
+ if (result || isWhere) {
+ // deep compare the contents, ignoring non-numeric properties
+ while (size--) {
+ var index = length,
+ value = b[size];
+
+ if (isWhere) {
+ while (index--) {
+ if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ }
+ }
+ else {
+ // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+ // which, in this case, is more costly
+ forIn(b, function(value, key, b) {
+ if (hasOwnProperty.call(b, key)) {
+ // count the number of properties.
+ size++;
+ // deep compare each property value.
+ return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB));
+ }
+ });
+
+ if (result && !isWhere) {
+ // ensure both objects have the same number of properties
+ forIn(a, function(value, key, a) {
+ if (hasOwnProperty.call(a, key)) {
+ // `size` will be `-1` if `a` has more properties than `b`
+ return (result = --size > -1);
+ }
+ });
+ }
+ }
+ stackA.pop();
+ stackB.pop();
+
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.merge` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates values with source counterparts.
+ */
+ function baseMerge(object, source, callback, stackA, stackB) {
+ (isArray(source) ? forEach : forOwn)(source, function(source, key) {
+ var found,
+ isArr,
+ result = source,
+ value = object[key];
+
+ if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+ // avoid merging previously merged cyclic sources
+ var stackLength = stackA.length;
+ while (stackLength--) {
+ if ((found = stackA[stackLength] == source)) {
+ value = stackB[stackLength];
+ break;
+ }
+ }
+ if (!found) {
+ var isShallow;
+ if (callback) {
+ result = callback(value, source);
+ if ((isShallow = typeof result != 'undefined')) {
+ value = result;
+ }
+ }
+ if (!isShallow) {
+ value = isArr
+ ? (isArray(value) ? value : [])
+ : (isPlainObject(value) ? value : {});
+ }
+ // add `source` and associated `value` to the stack of traversed objects
+ stackA.push(source);
+ stackB.push(value);
+
+ // recursively merge objects and arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ baseMerge(value, source, callback, stackA, stackB);
+ }
+ }
+ }
+ else {
+ if (callback) {
+ result = callback(value, source);
+ if (typeof result == 'undefined') {
+ result = source;
+ }
+ }
+ if (typeof result != 'undefined') {
+ value = result;
+ }
+ }
+ object[key] = value;
+ });
+ }
+
+ /**
+ * The base implementation of `_.random` without argument juggling or support
+ * for returning floating-point numbers.
+ *
+ * @private
+ * @param {number} min The minimum possible value.
+ * @param {number} max The maximum possible value.
+ * @returns {number} Returns a random number.
+ */
+ function baseRandom(min, max) {
+ return min + floor(nativeRandom() * (max - min + 1));
+ }
+
+ /**
+ * The base implementation of `_.uniq` without support for callback shorthands
+ * or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function} [callback] The function called per iteration.
+ * @returns {Array} Returns a duplicate-value-free array.
+ */
+ function baseUniq(array, isSorted, callback) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ result = [];
+
+ var isLarge = !isSorted && length >= largeArraySize && indexOf === baseIndexOf,
+ seen = (callback || isLarge) ? getArray() : result;
+
+ if (isLarge) {
+ var cache = createCache(seen);
+ indexOf = cacheIndexOf;
+ seen = cache;
+ }
+ while (++index < length) {
+ var value = array[index],
+ computed = callback ? callback(value, index, array) : value;
+
+ if (isSorted
+ ? !index || seen[seen.length - 1] !== computed
+ : indexOf(seen, computed) < 0
+ ) {
+ if (callback || isLarge) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseArray(seen.array);
+ releaseObject(seen);
+ } else if (callback) {
+ releaseArray(seen);
+ }
+ return result;
+ }
+
+ /**
+ * Creates a function that aggregates a collection, creating an object composed
+ * of keys generated from the results of running each element of the collection
+ * through a callback. The given `setter` function sets the keys and values
+ * of the composed object.
+ *
+ * @private
+ * @param {Function} setter The setter function.
+ * @returns {Function} Returns the new aggregator function.
+ */
+ function createAggregator(setter) {
+ return function(collection, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ setter(result, value, callback(value, index, collection), collection);
+ }
+ } else {
+ forOwn(collection, function(value, key, collection) {
+ setter(result, value, callback(value, key, collection), collection);
+ });
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, either curries or invokes `func`
+ * with an optional `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of method flags to compose.
+ * The bitmask may be composed of the following flags:
+ * 1 - `_.bind`
+ * 2 - `_.bindKey`
+ * 4 - `_.curry`
+ * 8 - `_.curry` (bound)
+ * 16 - `_.partial`
+ * 32 - `_.partialRight`
+ * @param {Array} [partialArgs] An array of arguments to prepend to those
+ * provided to the new function.
+ * @param {Array} [partialRightArgs] An array of arguments to append to those
+ * provided to the new function.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new function.
+ */
+ function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ isPartial = bitmask & 16,
+ isPartialRight = bitmask & 32;
+
+ if (!isBindKey && !isFunction(func)) {
+ throw new TypeError;
+ }
+ if (isPartial && !partialArgs.length) {
+ bitmask &= ~16;
+ isPartial = partialArgs = false;
+ }
+ if (isPartialRight && !partialRightArgs.length) {
+ bitmask &= ~32;
+ isPartialRight = partialRightArgs = false;
+ }
+ var bindData = func && func.__bindData__;
+ if (bindData && bindData !== true) {
+ // clone `bindData`
+ bindData = slice(bindData);
+ if (bindData[2]) {
+ bindData[2] = slice(bindData[2]);
+ }
+ if (bindData[3]) {
+ bindData[3] = slice(bindData[3]);
+ }
+ // set `thisBinding` is not previously bound
+ if (isBind && !(bindData[1] & 1)) {
+ bindData[4] = thisArg;
+ }
+ // set if previously bound but not currently (subsequent curried functions)
+ if (!isBind && bindData[1] & 1) {
+ bitmask |= 8;
+ }
+ // set curried arity if not yet set
+ if (isCurry && !(bindData[1] & 4)) {
+ bindData[5] = arity;
+ }
+ // append partial left arguments
+ if (isPartial) {
+ push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+ }
+ // append partial right arguments
+ if (isPartialRight) {
+ unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+ }
+ // merge flags
+ bindData[1] |= bitmask;
+ return createWrapper.apply(null, bindData);
+ }
+ // fast path for `_.bind`
+ var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
+ return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
+ }
+
+ /**
+ * Used by `escape` to convert characters to HTML entities.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeHtmlChar(match) {
+ return htmlEscapes[match];
+ }
+
+ /**
+ * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
+ * customized, this method returns the custom method, otherwise it returns
+ * the `baseIndexOf` function.
+ *
+ * @private
+ * @returns {Function} Returns the "indexOf" function.
+ */
+ function getIndexOf() {
+ var result = (result = lodash.indexOf) === indexOf ? baseIndexOf : result;
+ return result;
+ }
+
+ /**
+ * Checks if `value` is a native function.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a native function, else `false`.
+ */
+ function isNative(value) {
+ return typeof value == 'function' && reNative.test(value);
+ }
+
+ /**
+ * Sets `this` binding data on a given function.
+ *
+ * @private
+ * @param {Function} func The function to set data on.
+ * @param {Array} value The data array to set.
+ */
+ var setBindData = !defineProperty ? noop : function(func, value) {
+ descriptor.value = value;
+ defineProperty(func, '__bindData__', descriptor);
+ descriptor.value = null;
+ };
+
+ /**
+ * A fallback implementation of `isPlainObject` which checks if a given value
+ * is an object created by the `Object` constructor, assuming objects created
+ * by the `Object` constructor have no inherited enumerable properties and that
+ * there are no `Object.prototype` extensions.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ */
+ function shimIsPlainObject(value) {
+ var ctor,
+ result;
+
+ // avoid non Object objects, `arguments` objects, and DOM elements
+ if (!(value && toString.call(value) == objectClass) ||
+ (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor))) {
+ return false;
+ }
+ // In most environments an object's own properties are iterated before
+ // its inherited properties. If the last iterated property is an object's
+ // own property then there are no inherited enumerable properties.
+ forIn(value, function(value, key) {
+ result = key;
+ });
+ return typeof result == 'undefined' || hasOwnProperty.call(value, result);
+ }
+
+ /**
+ * Used by `unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {string} match The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
+ */
+ function unescapeHtmlChar(match) {
+ return htmlUnescapes[match];
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Checks if `value` is an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`.
+ * @example
+ *
+ * (function() { return _.isArguments(arguments); })(1, 2, 3);
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+ function isArguments(value) {
+ return value && typeof value == 'object' && typeof value.length == 'number' &&
+ toString.call(value) == argsClass || false;
+ }
+
+ /**
+ * Checks if `value` is an array.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an array, else `false`.
+ * @example
+ *
+ * (function() { return _.isArray(arguments); })();
+ * // => false
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ */
+ var isArray = nativeIsArray || function(value) {
+ return value && typeof value == 'object' && typeof value.length == 'number' &&
+ toString.call(value) == arrayClass || false;
+ };
+
+ /**
+ * A fallback implementation of `Object.keys` which produces an array of the
+ * given object's own enumerable property names.
+ *
+ * @private
+ * @type Function
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ */
+ var shimKeys = function(object) {
+ var index, iterable = object, result = [];
+ if (!iterable) return result;
+ if (!(objectTypes[typeof object])) return result;
+ for (index in iterable) {
+ if (hasOwnProperty.call(iterable, index)) {
+ result.push(index);
+ }
+ }
+ return result
+ };
+
+ /**
+ * Creates an array composed of the own enumerable property names of an object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ * @example
+ *
+ * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
+ */
+ var keys = !nativeKeys ? shimKeys : function(object) {
+ if (!isObject(object)) {
+ return [];
+ }
+ return nativeKeys(object);
+ };
+
+ /**
+ * Used to convert characters to HTML entities:
+ *
+ * Though the `>` character is escaped for symmetry, characters like `>` and `/`
+ * don't require escaping in HTML and have no special meaning unless they're part
+ * of a tag or an unquoted attribute value.
+ * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
+ */
+ var htmlEscapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ /** Used to convert HTML entities to characters */
+ var htmlUnescapes = invert(htmlEscapes);
+
+ /** Used to match HTML entities and HTML characters */
+ var reEscapedHtml = RegExp('(' + keys(htmlUnescapes).join('|') + ')', 'g'),
+ reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object. Subsequent sources will overwrite property assignments of previous
+ * sources. If a callback is provided it will be executed to produce the
+ * assigned values. The callback is bound to `thisArg` and invoked with two
+ * arguments; (objectValue, sourceValue).
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @alias extend
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param {Function} [callback] The function to customize assigning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * _.assign({ 'name': 'fred' }, { 'employer': 'slate' });
+ * // => { 'name': 'fred', 'employer': 'slate' }
+ *
+ * var defaults = _.partialRight(_.assign, function(a, b) {
+ * return typeof a == 'undefined' ? b : a;
+ * });
+ *
+ * var object = { 'name': 'barney' };
+ * defaults(object, { 'name': 'fred', 'employer': 'slate' });
+ * // => { 'name': 'barney', 'employer': 'slate' }
+ */
+ var assign = function(object, source, guard) {
+ var index, iterable = object, result = iterable;
+ if (!iterable) return result;
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = typeof guard == 'number' ? 2 : args.length;
+ if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
+ var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);
+ } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
+ callback = args[--argsLength];
+ }
+ while (++argsIndex < argsLength) {
+ iterable = args[argsIndex];
+ if (iterable && objectTypes[typeof iterable]) {
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ result[index] = callback ? callback(result[index], iterable[index]) : iterable[index];
+ }
+ }
+ }
+ return result
+ };
+
+ /**
+ * Creates a clone of `value`. If `isDeep` is `true` nested objects will also
+ * be cloned, otherwise they will be assigned by reference. If a callback
+ * is provided it will be executed to produce the cloned values. If the
+ * callback returns `undefined` cloning will be handled by the method instead.
+ * The callback is bound to `thisArg` and invoked with one argument; (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep=false] Specify a deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the cloned value.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * var shallow = _.clone(characters);
+ * shallow[0] === characters[0];
+ * // => true
+ *
+ * var deep = _.clone(characters, true);
+ * deep[0] === characters[0];
+ * // => false
+ *
+ * _.mixin({
+ * 'clone': _.partialRight(_.clone, function(value) {
+ * return _.isElement(value) ? value.cloneNode(false) : undefined;
+ * })
+ * });
+ *
+ * var clone = _.clone(document.body);
+ * clone.childNodes.length;
+ * // => 0
+ */
+ function clone(value, isDeep, callback, thisArg) {
+ // allows working with "Collections" methods without using their `index`
+ // and `collection` arguments for `isDeep` and `callback`
+ if (typeof isDeep != 'boolean' && isDeep != null) {
+ thisArg = callback;
+ callback = isDeep;
+ isDeep = false;
+ }
+ return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
+ }
+
+ /**
+ * Creates a deep clone of `value`. If a callback is provided it will be
+ * executed to produce the cloned values. If the callback returns `undefined`
+ * cloning will be handled by the method instead. The callback is bound to
+ * `thisArg` and invoked with one argument; (value).
+ *
+ * Note: This method is loosely based on the structured clone algorithm. Functions
+ * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
+ * objects created by constructors other than `Object` are cloned to plain `Object` objects.
+ * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to deep clone.
+ * @param {Function} [callback] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the deep cloned value.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * var deep = _.cloneDeep(characters);
+ * deep[0] === characters[0];
+ * // => false
+ *
+ * var view = {
+ * 'label': 'docs',
+ * 'node': element
+ * };
+ *
+ * var clone = _.cloneDeep(view, function(value) {
+ * return _.isElement(value) ? value.cloneNode(true) : undefined;
+ * });
+ *
+ * clone.node == view.node;
+ * // => false
+ */
+ function cloneDeep(value, callback, thisArg) {
+ return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
+ }
+
+ /**
+ * Creates an object that inherits from the given `prototype` object. If a
+ * `properties` object is provided its own enumerable properties are assigned
+ * to the created object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} prototype The object to inherit from.
+ * @param {Object} [properties] The properties to assign to the object.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * function Circle() {
+ * Shape.call(this);
+ * }
+ *
+ * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle });
+ *
+ * var circle = new Circle;
+ * circle instanceof Circle;
+ * // => true
+ *
+ * circle instanceof Shape;
+ * // => true
+ */
+ function create(prototype, properties) {
+ var result = baseCreate(prototype);
+ return properties ? assign(result, properties) : result;
+ }
+
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object for all destination properties that resolve to `undefined`. Once a
+ * property is set, additional defaults of the same property will be ignored.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param- {Object} [guard] Allows working with `_.reduce` without using its
+ * `key` and `object` arguments as sources.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var object = { 'name': 'barney' };
+ * _.defaults(object, { 'name': 'fred', 'employer': 'slate' });
+ * // => { 'name': 'barney', 'employer': 'slate' }
+ */
+ var defaults = function(object, source, guard) {
+ var index, iterable = object, result = iterable;
+ if (!iterable) return result;
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = typeof guard == 'number' ? 2 : args.length;
+ while (++argsIndex < argsLength) {
+ iterable = args[argsIndex];
+ if (iterable && objectTypes[typeof iterable]) {
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ if (typeof result[index] == 'undefined') result[index] = iterable[index];
+ }
+ }
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.findIndex` except that it returns the key of the
+ * first element that passes the callback check, instead of the element itself.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @param {Function|Object|string} [callback=identity] The function called per
+ * iteration. If a property name or object is provided it will be used to
+ * create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * var characters = {
+ * 'barney': { 'age': 36, 'blocked': false },
+ * 'fred': { 'age': 40, 'blocked': true },
+ * 'pebbles': { 'age': 1, 'blocked': false }
+ * };
+ *
+ * _.findKey(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => 'barney' (property order is not guaranteed across environments)
+ *
+ * // using "_.where" callback shorthand
+ * _.findKey(characters, { 'age': 1 });
+ * // => 'pebbles'
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findKey(characters, 'blocked');
+ * // => 'fred'
+ */
+ function findKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * This method is like `_.findKey` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @param {Function|Object|string} [callback=identity] The function called per
+ * iteration. If a property name or object is provided it will be used to
+ * create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * var characters = {
+ * 'barney': { 'age': 36, 'blocked': true },
+ * 'fred': { 'age': 40, 'blocked': false },
+ * 'pebbles': { 'age': 1, 'blocked': true }
+ * };
+ *
+ * _.findLastKey(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => returns `pebbles`, assuming `_.findKey` returns `barney`
+ *
+ * // using "_.where" callback shorthand
+ * _.findLastKey(characters, { 'age': 40 });
+ * // => 'fred'
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findLastKey(characters, 'blocked');
+ * // => 'pebbles'
+ */
+ function findLastKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwnRight(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over own and inherited enumerable properties of an object,
+ * executing the callback for each property. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, key, object). Callbacks may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * Shape.prototype.move = function(x, y) {
+ * this.x += x;
+ * this.y += y;
+ * };
+ *
+ * _.forIn(new Shape, function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments)
+ */
+ var forIn = function(collection, callback, thisArg) {
+ var index, iterable = collection, result = iterable;
+ if (!iterable) return result;
+ if (!objectTypes[typeof iterable]) return result;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ for (index in iterable) {
+ if (callback(iterable[index], index, collection) === false) return result;
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.forIn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * Shape.prototype.move = function(x, y) {
+ * this.x += x;
+ * this.y += y;
+ * };
+ *
+ * _.forInRight(new Shape, function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move'
+ */
+ function forInRight(object, callback, thisArg) {
+ var pairs = [];
+
+ forIn(object, function(value, key) {
+ pairs.push(key, value);
+ });
+
+ var length = pairs.length;
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(pairs[length--], pairs[length], object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Iterates over own enumerable properties of an object, executing the callback
+ * for each property. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, key, object). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
+ */
+ var forOwn = function(collection, callback, thisArg) {
+ var index, iterable = collection, result = iterable;
+ if (!iterable) return result;
+ if (!objectTypes[typeof iterable]) return result;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ var ownIndex = -1,
+ ownProps = objectTypes[typeof iterable] && keys(iterable),
+ length = ownProps ? ownProps.length : 0;
+
+ while (++ownIndex < length) {
+ index = ownProps[ownIndex];
+ if (callback(iterable[index], index, collection) === false) return result;
+ }
+ return result
+ };
+
+ /**
+ * This method is like `_.forOwn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length'
+ */
+ function forOwnRight(object, callback, thisArg) {
+ var props = keys(object),
+ length = props.length;
+
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ var key = props[length];
+ if (callback(object[key], key, object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Creates a sorted array of property names of all enumerable properties,
+ * own and inherited, of `object` that have function values.
+ *
+ * @static
+ * @memberOf _
+ * @alias methods
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names that have function values.
+ * @example
+ *
+ * _.functions(_);
+ * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
+ */
+ function functions(object) {
+ var result = [];
+ forIn(object, function(value, key) {
+ if (isFunction(value)) {
+ result.push(key);
+ }
+ });
+ return result.sort();
+ }
+
+ /**
+ * Checks if the specified property name exists as a direct property of `object`,
+ * instead of an inherited property.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to check.
+ * @returns {boolean} Returns `true` if key is a direct property, else `false`.
+ * @example
+ *
+ * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+ * // => true
+ */
+ function has(object, key) {
+ return object ? hasOwnProperty.call(object, key) : false;
+ }
+
+ /**
+ * Creates an object composed of the inverted keys and values of the given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to invert.
+ * @returns {Object} Returns the created inverted object.
+ * @example
+ *
+ * _.invert({ 'first': 'fred', 'second': 'barney' });
+ * // => { 'fred': 'first', 'barney': 'second' }
+ */
+ function invert(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = {};
+
+ while (++index < length) {
+ var key = props[index];
+ result[object[key]] = key;
+ }
+ return result;
+ }
+
+ /**
+ * Checks if `value` is a boolean value.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`.
+ * @example
+ *
+ * _.isBoolean(null);
+ * // => false
+ */
+ function isBoolean(value) {
+ return value === true || value === false ||
+ value && typeof value == 'object' && toString.call(value) == boolClass || false;
+ }
+
+ /**
+ * Checks if `value` is a date.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a date, else `false`.
+ * @example
+ *
+ * _.isDate(new Date);
+ * // => true
+ */
+ function isDate(value) {
+ return value && typeof value == 'object' && toString.call(value) == dateClass || false;
+ }
+
+ /**
+ * Checks if `value` is a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ */
+ function isElement(value) {
+ return value && value.nodeType === 1 || false;
+ }
+
+ /**
+ * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
+ * length of `0` and objects with no own enumerable properties are considered
+ * "empty".
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object|string} value The value to inspect.
+ * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({});
+ * // => true
+ *
+ * _.isEmpty('');
+ * // => true
+ */
+ function isEmpty(value) {
+ var result = true;
+ if (!value) {
+ return result;
+ }
+ var className = toString.call(value),
+ length = value.length;
+
+ if ((className == arrayClass || className == stringClass || className == argsClass ) ||
+ (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
+ return !length;
+ }
+ forOwn(value, function() {
+ return (result = false);
+ });
+ return result;
+ }
+
+ /**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent to each other. If a callback is provided it will be executed
+ * to compare values. If the callback returns `undefined` comparisons will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (a, b).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var copy = { 'name': 'fred' };
+ *
+ * object == copy;
+ * // => false
+ *
+ * _.isEqual(object, copy);
+ * // => true
+ *
+ * var words = ['hello', 'goodbye'];
+ * var otherWords = ['hi', 'goodbye'];
+ *
+ * _.isEqual(words, otherWords, function(a, b) {
+ * var reGreet = /^(?:hello|hi)$/i,
+ * aGreet = _.isString(a) && reGreet.test(a),
+ * bGreet = _.isString(b) && reGreet.test(b);
+ *
+ * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
+ * });
+ * // => true
+ */
+ function isEqual(a, b, callback, thisArg) {
+ return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2));
+ }
+
+ /**
+ * Checks if `value` is, or can be coerced to, a finite number.
+ *
+ * Note: This is not the same as native `isFinite` which will return true for
+ * booleans and empty strings. See http://es5.github.io/#x15.1.2.5.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is finite, else `false`.
+ * @example
+ *
+ * _.isFinite(-101);
+ * // => true
+ *
+ * _.isFinite('10');
+ * // => true
+ *
+ * _.isFinite(true);
+ * // => false
+ *
+ * _.isFinite('');
+ * // => false
+ *
+ * _.isFinite(Infinity);
+ * // => false
+ */
+ function isFinite(value) {
+ return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
+ }
+
+ /**
+ * Checks if `value` is a function.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ */
+ function isFunction(value) {
+ return typeof value == 'function';
+ }
+
+ /**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(1);
+ * // => false
+ */
+ function isObject(value) {
+ // check if the value is the ECMAScript language type of Object
+ // http://es5.github.io/#x8
+ // and avoid a V8 bug
+ // http://code.google.com/p/v8/issues/detail?id=2291
+ return !!(value && objectTypes[typeof value]);
+ }
+
+ /**
+ * Checks if `value` is `NaN`.
+ *
+ * Note: This is not the same as native `isNaN` which will return `true` for
+ * `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`.
+ * @example
+ *
+ * _.isNaN(NaN);
+ * // => true
+ *
+ * _.isNaN(new Number(NaN));
+ * // => true
+ *
+ * isNaN(undefined);
+ * // => true
+ *
+ * _.isNaN(undefined);
+ * // => false
+ */
+ function isNaN(value) {
+ // `NaN` as a primitive is the only value that is not equal to itself
+ // (perform the [[Class]] check first to avoid errors with some host objects in IE)
+ return isNumber(value) && value != +value;
+ }
+
+ /**
+ * Checks if `value` is `null`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `null`, else `false`.
+ * @example
+ *
+ * _.isNull(null);
+ * // => true
+ *
+ * _.isNull(undefined);
+ * // => false
+ */
+ function isNull(value) {
+ return value === null;
+ }
+
+ /**
+ * Checks if `value` is a number.
+ *
+ * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a number, else `false`.
+ * @example
+ *
+ * _.isNumber(8.4 * 5);
+ * // => true
+ */
+ function isNumber(value) {
+ return typeof value == 'number' ||
+ value && typeof value == 'object' && toString.call(value) == numberClass || false;
+ }
+
+ /**
+ * Checks if `value` is an object created by the `Object` constructor.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * _.isPlainObject(new Shape);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ */
+ var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) {
+ if (!(value && toString.call(value) == objectClass)) {
+ return false;
+ }
+ var valueOf = value.valueOf,
+ objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
+
+ return objProto
+ ? (value == objProto || getPrototypeOf(value) == objProto)
+ : shimIsPlainObject(value);
+ };
+
+ /**
+ * Checks if `value` is a regular expression.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`.
+ * @example
+ *
+ * _.isRegExp(/fred/);
+ * // => true
+ */
+ function isRegExp(value) {
+ return value && typeof value == 'object' && toString.call(value) == regexpClass || false;
+ }
+
+ /**
+ * Checks if `value` is a string.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('fred');
+ * // => true
+ */
+ function isString(value) {
+ return typeof value == 'string' ||
+ value && typeof value == 'object' && toString.call(value) == stringClass || false;
+ }
+
+ /**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ */
+ function isUndefined(value) {
+ return typeof value == 'undefined';
+ }
+
+ /**
+ * Creates an object with the same keys as `object` and values generated by
+ * running each own enumerable property of `object` through the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new object with values of the results of each `callback` execution.
+ * @example
+ *
+ * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ *
+ * var characters = {
+ * 'fred': { 'name': 'fred', 'age': 40 },
+ * 'pebbles': { 'name': 'pebbles', 'age': 1 }
+ * };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.mapValues(characters, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 }
+ */
+ function mapValues(object, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ forOwn(object, function(value, key, object) {
+ result[key] = callback(value, key, object);
+ });
+ return result;
+ }
+
+ /**
+ * Recursively merges own enumerable properties of the source object(s), that
+ * don't resolve to `undefined` into the destination object. Subsequent sources
+ * will overwrite property assignments of previous sources. If a callback is
+ * provided it will be executed to produce the merged values of the destination
+ * and source properties. If the callback returns `undefined` merging will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (objectValue, sourceValue).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {...Object} [source] The source objects.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var names = {
+ * 'characters': [
+ * { 'name': 'barney' },
+ * { 'name': 'fred' }
+ * ]
+ * };
+ *
+ * var ages = {
+ * 'characters': [
+ * { 'age': 36 },
+ * { 'age': 40 }
+ * ]
+ * };
+ *
+ * _.merge(names, ages);
+ * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] }
+ *
+ * var food = {
+ * 'fruits': ['apple'],
+ * 'vegetables': ['beet']
+ * };
+ *
+ * var otherFood = {
+ * 'fruits': ['banana'],
+ * 'vegetables': ['carrot']
+ * };
+ *
+ * _.merge(food, otherFood, function(a, b) {
+ * return _.isArray(a) ? a.concat(b) : undefined;
+ * });
+ * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
+ */
+ function merge(object) {
+ var args = arguments,
+ length = 2;
+
+ if (!isObject(object)) {
+ return object;
+ }
+ // allows working with `_.reduce` and `_.reduceRight` without using
+ // their `index` and `collection` arguments
+ if (typeof args[2] != 'number') {
+ length = args.length;
+ }
+ if (length > 3 && typeof args[length - 2] == 'function') {
+ var callback = baseCreateCallback(args[--length - 1], args[length--], 2);
+ } else if (length > 2 && typeof args[length - 1] == 'function') {
+ callback = args[--length];
+ }
+ var sources = slice(arguments, 1, length),
+ index = -1,
+ stackA = getArray(),
+ stackB = getArray();
+
+ while (++index < length) {
+ baseMerge(object, sources[index], callback, stackA, stackB);
+ }
+ releaseArray(stackA);
+ releaseArray(stackB);
+ return object;
+ }
+
+ /**
+ * Creates a shallow clone of `object` excluding the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` omitting the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|...string|string[]} [callback] The properties to omit or the
+ * function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object without the omitted properties.
+ * @example
+ *
+ * _.omit({ 'name': 'fred', 'age': 40 }, 'age');
+ * // => { 'name': 'fred' }
+ *
+ * _.omit({ 'name': 'fred', 'age': 40 }, function(value) {
+ * return typeof value == 'number';
+ * });
+ * // => { 'name': 'fred' }
+ */
+ function omit(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var props = [];
+ forIn(object, function(value, key) {
+ props.push(key);
+ });
+ props = baseDifference(props, baseFlatten(arguments, true, false, 1));
+
+ var index = -1,
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+ result[key] = object[key];
+ }
+ } else {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forIn(object, function(value, key, object) {
+ if (!callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates a two dimensional array of an object's key-value pairs,
+ * i.e. `[[key1, value1], [key2, value2]]`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns new array of key-value pairs.
+ * @example
+ *
+ * _.pairs({ 'barney': 36, 'fred': 40 });
+ * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments)
+ */
+ function pairs(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = Array(length);
+
+ while (++index < length) {
+ var key = props[index];
+ result[index] = [key, object[key]];
+ }
+ return result;
+ }
+
+ /**
+ * Creates a shallow clone of `object` composed of the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` picking the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|...string|string[]} [callback] The function called per
+ * iteration or property names to pick, specified as individual property
+ * names or arrays of property names.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object composed of the picked properties.
+ * @example
+ *
+ * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name');
+ * // => { 'name': 'fred' }
+ *
+ * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) {
+ * return key.charAt(0) != '_';
+ * });
+ * // => { 'name': 'fred' }
+ */
+ function pick(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var index = -1,
+ props = baseFlatten(arguments, true, false, 1),
+ length = isObject(object) ? props.length : 0;
+
+ while (++index < length) {
+ var key = props[index];
+ if (key in object) {
+ result[key] = object[key];
+ }
+ }
+ } else {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forIn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * An alternative to `_.reduce` this method transforms `object` to a new
+ * `accumulator` object which is the result of running each of its own
+ * enumerable properties through a callback, with each callback execution
+ * potentially mutating the `accumulator` object. The callback is bound to
+ * `thisArg` and invoked with four arguments; (accumulator, value, key, object).
+ * Callbacks may exit iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] The custom accumulator value.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {
+ * num *= num;
+ * if (num % 2) {
+ * return result.push(num) < 3;
+ * }
+ * });
+ * // => [1, 9, 25]
+ *
+ * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+ * result[key] = num * 3;
+ * });
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ */
+ function transform(object, callback, accumulator, thisArg) {
+ var isArr = isArray(object);
+ if (accumulator == null) {
+ if (isArr) {
+ accumulator = [];
+ } else {
+ var ctor = object && object.constructor,
+ proto = ctor && ctor.prototype;
+
+ accumulator = baseCreate(proto);
+ }
+ }
+ if (callback) {
+ callback = lodash.createCallback(callback, thisArg, 4);
+ (isArr ? forEach : forOwn)(object, function(value, index, object) {
+ return callback(accumulator, value, index, object);
+ });
+ }
+ return accumulator;
+ }
+
+ /**
+ * Creates an array composed of the own enumerable property values of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property values.
+ * @example
+ *
+ * _.values({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => [1, 2, 3] (property order is not guaranteed across environments)
+ */
+ function values(object) {
+ var index = -1,
+ props = keys(object),
+ length = props.length,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = object[props[index]];
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array of elements from the specified indexes, or keys, of the
+ * `collection`. Indexes may be specified as individual arguments or as arrays
+ * of indexes.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {...(number|number[]|string|string[])} [index] The indexes of `collection`
+ * to retrieve, specified as individual indexes or arrays of indexes.
+ * @returns {Array} Returns a new array of elements corresponding to the
+ * provided indexes.
+ * @example
+ *
+ * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+ * // => ['a', 'c', 'e']
+ *
+ * _.at(['fred', 'barney', 'pebbles'], 0, 2);
+ * // => ['fred', 'pebbles']
+ */
+ function at(collection) {
+ var args = arguments,
+ index = -1,
+ props = baseFlatten(args, true, false, 1),
+ length = (args[2] && args[2][args[1]] === collection) ? 1 : props.length,
+ result = Array(length);
+
+ while(++index < length) {
+ result[index] = collection[props[index]];
+ }
+ return result;
+ }
+
+ /**
+ * Checks if a given value is present in a collection using strict equality
+ * for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the
+ * offset from the end of the collection.
+ *
+ * @static
+ * @memberOf _
+ * @alias include
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {*} target The value to check for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {boolean} Returns `true` if the `target` element is found, else `false`.
+ * @example
+ *
+ * _.contains([1, 2, 3], 1);
+ * // => true
+ *
+ * _.contains([1, 2, 3], 1, 2);
+ * // => false
+ *
+ * _.contains({ 'name': 'fred', 'age': 40 }, 'fred');
+ * // => true
+ *
+ * _.contains('pebbles', 'eb');
+ * // => true
+ */
+ function contains(collection, target, fromIndex) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = collection ? collection.length : 0,
+ result = false;
+
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
+ if (isArray(collection)) {
+ result = indexOf(collection, target, fromIndex) > -1;
+ } else if (typeof length == 'number') {
+ result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1;
+ } else {
+ forOwn(collection, function(value) {
+ if (++index >= fromIndex) {
+ return !(result = value === target);
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` through the callback. The corresponding value
+ * of each key is the number of times the key was returned by the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy(['one', 'two', 'three'], 'length');
+ * // => { '3': 2, '5': 1 }
+ */
+ var countBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+ });
+
+ /**
+ * Checks if the given callback returns truey value for **all** elements of
+ * a collection. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias all
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if all elements passed the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.every([true, 1, null, 'yes']);
+ * // => false
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.every(characters, 'age');
+ * // => true
+ *
+ * // using "_.where" callback shorthand
+ * _.every(characters, { 'age': 36 });
+ * // => false
+ */
+ function every(collection, callback, thisArg) {
+ var result = true;
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if (!(result = !!callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ return (result = !!callback(value, index, collection));
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, returning an array of all elements
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias select
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that passed the callback check.
+ * @example
+ *
+ * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [2, 4, 6]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.filter(characters, 'blocked');
+ * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
+ *
+ * // using "_.where" callback shorthand
+ * _.filter(characters, { 'age': 36 });
+ * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
+ */
+ function filter(collection, callback, thisArg) {
+ var result = [];
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, returning the first element that
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias detect, findWhere
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ * ];
+ *
+ * _.find(characters, function(chr) {
+ * return chr.age < 40;
+ * });
+ * // => { 'name': 'barney', 'age': 36, 'blocked': false }
+ *
+ * // using "_.where" callback shorthand
+ * _.find(characters, { 'age': 1 });
+ * // => { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ *
+ * // using "_.pluck" callback shorthand
+ * _.find(characters, 'blocked');
+ * // => { 'name': 'fred', 'age': 40, 'blocked': true }
+ */
+ function find(collection, callback, thisArg) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ var value = collection[index];
+ if (callback(value, index, collection)) {
+ return value;
+ }
+ }
+ } else {
+ var result;
+ forOwn(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+ }
+
+ /**
+ * This method is like `_.find` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * _.findLast([1, 2, 3, 4], function(num) {
+ * return num % 2 == 1;
+ * });
+ * // => 3
+ */
+ function findLast(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forEachRight(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, executing the callback for each
+ * element. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * Note: As with other "Collections" methods, objects with a `length` property
+ * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
+ * may be used for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @alias each
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');
+ * // => logs each number and returns '1,2,3'
+ *
+ * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+ * // => logs each number and returns the object (property order is not guaranteed across environments)
+ */
+ function forEach(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if (callback(collection[index], index, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, callback);
+ }
+ return collection;
+ }
+
+ /**
+ * This method is like `_.forEach` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias eachRight
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(',');
+ * // => logs each number from right to left and returns '3,2,1'
+ */
+ function forEachRight(collection, callback, thisArg) {
+ var length = collection ? collection.length : 0;
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ while (length--) {
+ if (callback(collection[length], length, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ var props = keys(collection);
+ length = props.length;
+ forOwn(collection, function(value, key, collection) {
+ key = props ? props[--length] : --length;
+ return callback(collection[key], key, collection);
+ });
+ }
+ return collection;
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of a collection through the callback. The corresponding value
+ * of each key is an array of the elements responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * // using "_.pluck" callback shorthand
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+ var groupBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+ });
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of the collection through the given callback. The corresponding
+ * value of each key is the last element responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var keys = [
+ * { 'dir': 'left', 'code': 97 },
+ * { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.indexBy(keys, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String);
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ */
+ var indexBy = createAggregator(function(result, value, key) {
+ result[key] = value;
+ });
+
+ /**
+ * Invokes the method named by `methodName` on each element in the `collection`
+ * returning an array of the results of each invoked method. Additional arguments
+ * will be provided to each invoked method. If `methodName` is a function it
+ * will be invoked for, and `this` bound to, each element in the `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|string} methodName The name of the method to invoke or
+ * the function invoked per iteration.
+ * @param {...*} [arg] Arguments to invoke the method with.
+ * @returns {Array} Returns a new array of the results of each invoked method.
+ * @example
+ *
+ * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+ * // => [[1, 5, 7], [1, 2, 3]]
+ *
+ * _.invoke([123, 456], String.prototype.split, '');
+ * // => [['1', '2', '3'], ['4', '5', '6']]
+ */
+ function invoke(collection, methodName) {
+ var args = slice(arguments, 2),
+ index = -1,
+ isFunc = typeof methodName == 'function',
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ forEach(collection, function(value) {
+ result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);
+ });
+ return result;
+ }
+
+ /**
+ * Creates an array of values by running each element in the collection
+ * through the callback. The callback is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias collect
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of the results of each `callback` execution.
+ * @example
+ *
+ * _.map([1, 2, 3], function(num) { return num * 3; });
+ * // => [3, 6, 9]
+ *
+ * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+ * // => [3, 6, 9] (property order is not guaranteed across environments)
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.map(characters, 'name');
+ * // => ['barney', 'fred']
+ */
+ function map(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ if (typeof length == 'number') {
+ var result = Array(length);
+ while (++index < length) {
+ result[index] = callback(collection[index], index, collection);
+ }
+ } else {
+ result = [];
+ forOwn(collection, function(value, key, collection) {
+ result[++index] = callback(value, key, collection);
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the maximum value of a collection. If the collection is empty or
+ * falsey `-Infinity` is returned. If a callback is provided it will be executed
+ * for each value in the collection to generate the criterion by which the value
+ * is ranked. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * _.max([4, 2, 8, 6]);
+ * // => 8
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.max(characters, function(chr) { return chr.age; });
+ * // => { 'name': 'fred', 'age': 40 };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.max(characters, 'age');
+ * // => { 'name': 'fred', 'age': 40 };
+ */
+ function max(collection, callback, thisArg) {
+ var computed = -Infinity,
+ result = computed;
+
+ // allows working with functions like `_.map` without using
+ // their `index` argument as a callback
+ if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
+ callback = null;
+ }
+ if (callback == null && isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ if (value > result) {
+ result = value;
+ }
+ }
+ } else {
+ callback = (callback == null && isString(collection))
+ ? charAtCallback
+ : lodash.createCallback(callback, thisArg, 3);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current > computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the minimum value of a collection. If the collection is empty or
+ * falsey `Infinity` is returned. If a callback is provided it will be executed
+ * for each value in the collection to generate the criterion by which the value
+ * is ranked. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * _.min([4, 2, 8, 6]);
+ * // => 2
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.min(characters, function(chr) { return chr.age; });
+ * // => { 'name': 'barney', 'age': 36 };
+ *
+ * // using "_.pluck" callback shorthand
+ * _.min(characters, 'age');
+ * // => { 'name': 'barney', 'age': 36 };
+ */
+ function min(collection, callback, thisArg) {
+ var computed = Infinity,
+ result = computed;
+
+ // allows working with functions like `_.map` without using
+ // their `index` argument as a callback
+ if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
+ callback = null;
+ }
+ if (callback == null && isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ if (value < result) {
+ result = value;
+ }
+ }
+ } else {
+ callback = (callback == null && isString(collection))
+ ? charAtCallback
+ : lodash.createCallback(callback, thisArg, 3);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current < computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the value of a specified property from all elements in the collection.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {string} property The name of the property to pluck.
+ * @returns {Array} Returns a new array of property values.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * _.pluck(characters, 'name');
+ * // => ['barney', 'fred']
+ */
+ var pluck = map;
+
+ /**
+ * Reduces a collection to a value which is the accumulated result of running
+ * each element in the collection through the callback, where each successive
+ * callback execution consumes the return value of the previous execution. If
+ * `accumulator` is not provided the first element of the collection will be
+ * used as the initial `accumulator` value. The callback is bound to `thisArg`
+ * and invoked with four arguments; (accumulator, value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias foldl, inject
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var sum = _.reduce([1, 2, 3], function(sum, num) {
+ * return sum + num;
+ * });
+ * // => 6
+ *
+ * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+ * result[key] = num * 3;
+ * return result;
+ * }, {});
+ * // => { 'a': 3, 'b': 6, 'c': 9 }
+ */
+ function reduce(collection, callback, accumulator, thisArg) {
+ if (!collection) return accumulator;
+ var noaccum = arguments.length < 3;
+ callback = lodash.createCallback(callback, thisArg, 4);
+
+ var index = -1,
+ length = collection.length;
+
+ if (typeof length == 'number') {
+ if (noaccum) {
+ accumulator = collection[++index];
+ }
+ while (++index < length) {
+ accumulator = callback(accumulator, collection[index], index, collection);
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection)
+ });
+ }
+ return accumulator;
+ }
+
+ /**
+ * This method is like `_.reduce` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias foldr
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var list = [[0, 1], [2, 3], [4, 5]];
+ * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+ * // => [4, 5, 2, 3, 0, 1]
+ */
+ function reduceRight(collection, callback, accumulator, thisArg) {
+ var noaccum = arguments.length < 3;
+ callback = lodash.createCallback(callback, thisArg, 4);
+ forEachRight(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The opposite of `_.filter` this method returns the elements of a
+ * collection that the callback does **not** return truey for.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that failed the callback check.
+ * @example
+ *
+ * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [1, 3, 5]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.reject(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
+ *
+ * // using "_.where" callback shorthand
+ * _.reject(characters, { 'age': 36 });
+ * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
+ */
+ function reject(collection, callback, thisArg) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ return filter(collection, function(value, index, collection) {
+ return !callback(value, index, collection);
+ });
+ }
+
+ /**
+ * Retrieves a random element or `n` random elements from a collection.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to sample.
+ * @param {number} [n] The number of elements to sample.
+ * @param- {Object} [guard] Allows working with functions like `_.map`
+ * without using their `index` arguments as `n`.
+ * @returns {Array} Returns the random sample(s) of `collection`.
+ * @example
+ *
+ * _.sample([1, 2, 3, 4]);
+ * // => 2
+ *
+ * _.sample([1, 2, 3, 4], 2);
+ * // => [3, 1]
+ */
+ function sample(collection, n, guard) {
+ if (collection && typeof collection.length != 'number') {
+ collection = values(collection);
+ }
+ if (n == null || guard) {
+ return collection ? collection[baseRandom(0, collection.length - 1)] : undefined;
+ }
+ var result = shuffle(collection);
+ result.length = nativeMin(nativeMax(0, n), result.length);
+ return result;
+ }
+
+ /**
+ * Creates an array of shuffled values, using a version of the Fisher-Yates
+ * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to shuffle.
+ * @returns {Array} Returns a new shuffled collection.
+ * @example
+ *
+ * _.shuffle([1, 2, 3, 4, 5, 6]);
+ * // => [4, 1, 6, 3, 5, 2]
+ */
+ function shuffle(collection) {
+ var index = -1,
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ forEach(collection, function(value) {
+ var rand = baseRandom(0, ++index);
+ result[index] = result[rand];
+ result[rand] = value;
+ });
+ return result;
+ }
+
+ /**
+ * Gets the size of the `collection` by returning `collection.length` for arrays
+ * and array-like objects or the number of own enumerable properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns `collection.length` or number of own enumerable properties.
+ * @example
+ *
+ * _.size([1, 2]);
+ * // => 2
+ *
+ * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => 3
+ *
+ * _.size('pebbles');
+ * // => 7
+ */
+ function size(collection) {
+ var length = collection ? collection.length : 0;
+ return typeof length == 'number' ? length : keys(collection).length;
+ }
+
+ /**
+ * Checks if the callback returns a truey value for **any** element of a
+ * collection. The function returns as soon as it finds a passing value and
+ * does not iterate over the entire collection. The callback is bound to
+ * `thisArg` and invoked with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias any
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if any element passed the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false], Boolean);
+ * // => true
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.some(characters, 'blocked');
+ * // => true
+ *
+ * // using "_.where" callback shorthand
+ * _.some(characters, { 'age': 1 });
+ * // => false
+ */
+ function some(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ if (typeof length == 'number') {
+ while (++index < length) {
+ if ((result = callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forOwn(collection, function(value, index, collection) {
+ return !(result = callback(value, index, collection));
+ });
+ }
+ return !!result;
+ }
+
+ /**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection through the callback. This method
+ * performs a stable sort, that is, it will preserve the original sort order
+ * of equal elements. The callback is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an array of property names is provided for `callback` the collection
+ * will be sorted by each property value.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Array|Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of sorted elements.
+ * @example
+ *
+ * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+ * // => [3, 1, 2]
+ *
+ * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+ * // => [3, 1, 2]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 26 },
+ * { 'name': 'fred', 'age': 30 }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.map(_.sortBy(characters, 'age'), _.values);
+ * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]]
+ *
+ * // sorting by multiple properties
+ * _.map(_.sortBy(characters, ['name', 'age']), _.values);
+ * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]]
+ */
+ function sortBy(collection, callback, thisArg) {
+ var index = -1,
+ isArr = isArray(callback),
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ if (!isArr) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ }
+ forEach(collection, function(value, key, collection) {
+ var object = result[++index] = getObject();
+ if (isArr) {
+ object.criteria = map(callback, function(key) { return value[key]; });
+ } else {
+ (object.criteria = getArray())[0] = callback(value, key, collection);
+ }
+ object.index = index;
+ object.value = value;
+ });
+
+ length = result.length;
+ result.sort(compareAscending);
+ while (length--) {
+ var object = result[length];
+ result[length] = object.value;
+ if (!isArr) {
+ releaseArray(object.criteria);
+ }
+ releaseObject(object);
+ }
+ return result;
+ }
+
+ /**
+ * Converts the `collection` to an array.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to convert.
+ * @returns {Array} Returns the new converted array.
+ * @example
+ *
+ * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+ * // => [2, 3, 4]
+ */
+ function toArray(collection) {
+ if (collection && typeof collection.length == 'number') {
+ return slice(collection);
+ }
+ return values(collection);
+ }
+
+ /**
+ * Performs a deep comparison of each element in a `collection` to the given
+ * `properties` object, returning an array of all elements that have equivalent
+ * property values.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Object} props The object of property values to filter by.
+ * @returns {Array} Returns a new array of elements that have the given properties.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] },
+ * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
+ * ];
+ *
+ * _.where(characters, { 'age': 36 });
+ * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }]
+ *
+ * _.where(characters, { 'pets': ['dino'] });
+ * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }]
+ */
+ var where = filter;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are all falsey.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+ function compact(array) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (value) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array excluding all values of the provided arrays using strict
+ * equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {...Array} [values] The arrays of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+ * // => [1, 3, 4]
+ */
+ function difference(array) {
+ return baseDifference(array, baseFlatten(arguments, true, true, 1));
+ }
+
+ /**
+ * This method is like `_.find` except that it returns the index of the first
+ * element that passes the callback check, instead of the element itself.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': false },
+ * { 'name': 'fred', 'age': 40, 'blocked': true },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': false }
+ * ];
+ *
+ * _.findIndex(characters, function(chr) {
+ * return chr.age < 20;
+ * });
+ * // => 2
+ *
+ * // using "_.where" callback shorthand
+ * _.findIndex(characters, { 'age': 36 });
+ * // => 0
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findIndex(characters, 'blocked');
+ * // => 1
+ */
+ function findIndex(array, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length) {
+ if (callback(array[index], index, array)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * This method is like `_.findIndex` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36, 'blocked': true },
+ * { 'name': 'fred', 'age': 40, 'blocked': false },
+ * { 'name': 'pebbles', 'age': 1, 'blocked': true }
+ * ];
+ *
+ * _.findLastIndex(characters, function(chr) {
+ * return chr.age > 30;
+ * });
+ * // => 1
+ *
+ * // using "_.where" callback shorthand
+ * _.findLastIndex(characters, { 'age': 36 });
+ * // => 0
+ *
+ * // using "_.pluck" callback shorthand
+ * _.findLastIndex(characters, 'blocked');
+ * // => 2
+ */
+ function findLastIndex(array, callback, thisArg) {
+ var length = array ? array.length : 0;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(array[length], length, array)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Gets the first element or first `n` elements of an array. If a callback
+ * is provided elements at the beginning of the array are returned as long
+ * as the callback returns truey. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias head, take
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback] The function called
+ * per element or the number of elements to return. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the first element(s) of `array`.
+ * @example
+ *
+ * _.first([1, 2, 3]);
+ * // => 1
+ *
+ * _.first([1, 2, 3], 2);
+ * // => [1, 2]
+ *
+ * _.first([1, 2, 3], function(num) {
+ * return num < 3;
+ * });
+ * // => [1, 2]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.first(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }]
+ *
+ * // using "_.where" callback shorthand
+ * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name');
+ * // => ['barney', 'fred']
+ */
+ function first(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = -1;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[0] : undefined;
+ }
+ }
+ return slice(array, 0, nativeMin(nativeMax(0, n), length));
+ }
+
+ /**
+ * Flattens a nested array (the nesting can be to any depth). If `isShallow`
+ * is truey, the array will only be flattened a single level. If a callback
+ * is provided each element of the array is passed through the callback before
+ * flattening. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2], [3, [[4]]]]);
+ * // => [1, 2, 3, 4];
+ *
+ * _.flatten([1, [2], [3, [[4]]]], true);
+ * // => [1, 2, 3, [[4]]];
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] },
+ * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.flatten(characters, 'pets');
+ * // => ['hoppy', 'baby puss', 'dino']
+ */
+ function flatten(array, isShallow, callback, thisArg) {
+ // juggle arguments
+ if (typeof isShallow != 'boolean' && isShallow != null) {
+ thisArg = callback;
+ callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow;
+ isShallow = false;
+ }
+ if (callback != null) {
+ array = map(array, callback, thisArg);
+ }
+ return baseFlatten(array, isShallow);
+ }
+
+ /**
+ * Gets the index at which the first occurrence of `value` is found using
+ * strict equality for comparisons, i.e. `===`. If the array is already sorted
+ * providing `true` for `fromIndex` will run a faster binary search.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {boolean|number} [fromIndex=0] The index to search from or `true`
+ * to perform a binary search on a sorted array.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 1
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 4
+ *
+ * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+ * // => 2
+ */
+ function indexOf(array, value, fromIndex) {
+ if (typeof fromIndex == 'number') {
+ var length = array ? array.length : 0;
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0);
+ } else if (fromIndex) {
+ var index = sortedIndex(array, value);
+ return array[index] === value ? index : -1;
+ }
+ return baseIndexOf(array, value, fromIndex);
+ }
+
+ /**
+ * Gets all but the last element or last `n` elements of an array. If a
+ * callback is provided elements at the end of the array are excluded from
+ * the result as long as the callback returns truey. The callback is bound
+ * to `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback=1] The function called
+ * per element or the number of elements to exclude. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a slice of `array`.
+ * @example
+ *
+ * _.initial([1, 2, 3]);
+ * // => [1, 2]
+ *
+ * _.initial([1, 2, 3], 2);
+ * // => [1]
+ *
+ * _.initial([1, 2, 3], function(num) {
+ * return num > 1;
+ * });
+ * // => [1]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.initial(characters, 'blocked');
+ * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }]
+ *
+ * // using "_.where" callback shorthand
+ * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name');
+ * // => ['barney', 'fred']
+ */
+ function initial(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = (callback == null || thisArg) ? 1 : callback || n;
+ }
+ return slice(array, 0, nativeMin(nativeMax(0, length - n), length));
+ }
+
+ /**
+ * Creates an array of unique values present in all provided arrays using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of shared values.
+ * @example
+ *
+ * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2]
+ */
+ function intersection() {
+ var args = [],
+ argsIndex = -1,
+ argsLength = arguments.length,
+ caches = getArray(),
+ indexOf = getIndexOf(),
+ trustIndexOf = indexOf === baseIndexOf,
+ seen = getArray();
+
+ while (++argsIndex < argsLength) {
+ var value = arguments[argsIndex];
+ if (isArray(value) || isArguments(value)) {
+ args.push(value);
+ caches.push(trustIndexOf && value.length >= largeArraySize &&
+ createCache(argsIndex ? args[argsIndex] : seen));
+ }
+ }
+ var array = args[0],
+ index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ outer:
+ while (++index < length) {
+ var cache = caches[0];
+ value = array[index];
+
+ if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) {
+ argsIndex = argsLength;
+ (cache || seen).push(value);
+ while (--argsIndex) {
+ cache = caches[argsIndex];
+ if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) {
+ continue outer;
+ }
+ }
+ result.push(value);
+ }
+ }
+ while (argsLength--) {
+ cache = caches[argsLength];
+ if (cache) {
+ releaseObject(cache);
+ }
+ }
+ releaseArray(caches);
+ releaseArray(seen);
+ return result;
+ }
+
+ /**
+ * Gets the last element or last `n` elements of an array. If a callback is
+ * provided elements at the end of the array are returned as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback] The function called
+ * per element or the number of elements to return. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the last element(s) of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ *
+ * _.last([1, 2, 3], 2);
+ * // => [2, 3]
+ *
+ * _.last([1, 2, 3], function(num) {
+ * return num > 1;
+ * });
+ * // => [2, 3]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.pluck(_.last(characters, 'blocked'), 'name');
+ * // => ['fred', 'pebbles']
+ *
+ * // using "_.where" callback shorthand
+ * _.last(characters, { 'employer': 'na' });
+ * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
+ */
+ function last(array, callback, thisArg) {
+ var n = 0,
+ length = array ? array.length : 0;
+
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[length - 1] : undefined;
+ }
+ }
+ return slice(array, nativeMax(0, length - n));
+ }
+
+ /**
+ * Gets the index at which the last occurrence of `value` is found using strict
+ * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+ * as the offset from the end of the collection.
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 4
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 1
+ */
+ function lastIndexOf(array, value, fromIndex) {
+ var index = array ? array.length : 0;
+ if (typeof fromIndex == 'number') {
+ index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
+ }
+ while (index--) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Removes all provided values from the given array using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {...*} [value] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ * _.pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+ function pull(array) {
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = args.length,
+ length = array ? array.length : 0;
+
+ while (++argsIndex < argsLength) {
+ var index = -1,
+ value = args[argsIndex];
+ while (++index < length) {
+ if (array[index] === value) {
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ }
+ return array;
+ }
+
+ /**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * `start` up to but not including `end`. If `start` is less than `stop` a
+ * zero-length range is created unless a negative `step` is specified.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
+ * @returns {Array} Returns a new range array.
+ * @example
+ *
+ * _.range(4);
+ * // => [0, 1, 2, 3]
+ *
+ * _.range(1, 5);
+ * // => [1, 2, 3, 4]
+ *
+ * _.range(0, 20, 5);
+ * // => [0, 5, 10, 15]
+ *
+ * _.range(0, -4, -1);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.range(0);
+ * // => []
+ */
+ function range(start, end, step) {
+ start = +start || 0;
+ step = typeof step == 'number' ? step : (+step || 1);
+
+ if (end == null) {
+ end = start;
+ start = 0;
+ }
+ // use `Array(length)` so engines like Chakra and V8 avoid slower modes
+ // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+ var index = -1,
+ length = nativeMax(0, ceil((end - start) / (step || 1))),
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = start;
+ start += step;
+ }
+ return result;
+ }
+
+ /**
+ * Removes all elements from an array that the callback returns truey for
+ * and returns an array of removed elements. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of removed elements.
+ * @example
+ *
+ * var array = [1, 2, 3, 4, 5, 6];
+ * var evens = _.remove(array, function(num) { return num % 2 == 0; });
+ *
+ * console.log(array);
+ * // => [1, 3, 5]
+ *
+ * console.log(evens);
+ * // => [2, 4, 6]
+ */
+ function remove(array, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length) {
+ var value = array[index];
+ if (callback(value, index, array)) {
+ result.push(value);
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The opposite of `_.initial` this method gets all but the first element or
+ * first `n` elements of an array. If a callback function is provided elements
+ * at the beginning of the array are excluded from the result as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias drop, tail
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Function|Object|number|string} [callback=1] The function called
+ * per element or the number of elements to exclude. If a property name or
+ * object is provided it will be used to create a "_.pluck" or "_.where"
+ * style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a slice of `array`.
+ * @example
+ *
+ * _.rest([1, 2, 3]);
+ * // => [2, 3]
+ *
+ * _.rest([1, 2, 3], 2);
+ * // => [3]
+ *
+ * _.rest([1, 2, 3], function(num) {
+ * return num < 3;
+ * });
+ * // => [3]
+ *
+ * var characters = [
+ * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
+ * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
+ * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
+ * ];
+ *
+ * // using "_.pluck" callback shorthand
+ * _.pluck(_.rest(characters, 'blocked'), 'name');
+ * // => ['fred', 'pebbles']
+ *
+ * // using "_.where" callback shorthand
+ * _.rest(characters, { 'employer': 'slate' });
+ * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
+ */
+ function rest(array, callback, thisArg) {
+ if (typeof callback != 'number' && callback != null) {
+ var n = 0,
+ index = -1,
+ length = array ? array.length : 0;
+
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);
+ }
+ return slice(array, n);
+ }
+
+ /**
+ * Uses a binary search to determine the smallest index at which a value
+ * should be inserted into a given sorted array in order to maintain the sort
+ * order of the array. If a callback is provided it will be executed for
+ * `value` and each element of `array` to compute their sort ranking. The
+ * callback is bound to `thisArg` and invoked with one argument; (value).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * _.sortedIndex([20, 30, 50], 40);
+ * // => 2
+ *
+ * // using "_.pluck" callback shorthand
+ * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+ * // => 2
+ *
+ * var dict = {
+ * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+ * };
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return dict.wordToNumber[word];
+ * });
+ * // => 2
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return this.wordToNumber[word];
+ * }, dict);
+ * // => 2
+ */
+ function sortedIndex(array, value, callback, thisArg) {
+ var low = 0,
+ high = array ? array.length : low;
+
+ // explicitly reference `identity` for better inlining in Firefox
+ callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity;
+ value = callback(value);
+
+ while (low < high) {
+ var mid = (low + high) >>> 1;
+ (callback(array[mid]) < value)
+ ? low = mid + 1
+ : high = mid;
+ }
+ return low;
+ }
+
+ /**
+ * Creates an array of unique values, in order, of the provided arrays using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of combined values.
+ * @example
+ *
+ * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2, 3, 5, 4]
+ */
+ function union() {
+ return baseUniq(baseFlatten(arguments, true, true));
+ }
+
+ /**
+ * Creates a duplicate-value-free version of an array using strict equality
+ * for comparisons, i.e. `===`. If the array is sorted, providing
+ * `true` for `isSorted` will use a faster algorithm. If a callback is provided
+ * each element of `array` is passed through the callback before uniqueness
+ * is computed. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
+ *
+ * If a property name is provided for `callback` the created "_.pluck" style
+ * callback will return the property value of the given element.
+ *
+ * If an object is provided for `callback` the created "_.where" style callback
+ * will return `true` for elements that have the properties of the given object,
+ * else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias unique
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function|Object|string} [callback=identity] The function called
+ * per iteration. If a property name or object is provided it will be used
+ * to create a "_.pluck" or "_.where" style callback, respectively.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a duplicate-value-free array.
+ * @example
+ *
+ * _.uniq([1, 2, 1, 3, 1]);
+ * // => [1, 2, 3]
+ *
+ * _.uniq([1, 1, 2, 2, 3], true);
+ * // => [1, 2, 3]
+ *
+ * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); });
+ * // => ['A', 'b', 'C']
+ *
+ * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
+ * // => [1, 2.5, 3]
+ *
+ * // using "_.pluck" callback shorthand
+ * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+ function uniq(array, isSorted, callback, thisArg) {
+ // juggle arguments
+ if (typeof isSorted != 'boolean' && isSorted != null) {
+ thisArg = callback;
+ callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted;
+ isSorted = false;
+ }
+ if (callback != null) {
+ callback = lodash.createCallback(callback, thisArg, 3);
+ }
+ return baseUniq(array, isSorted, callback);
+ }
+
+ /**
+ * Creates an array excluding all provided values using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to filter.
+ * @param {...*} [value] The values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
+ * @example
+ *
+ * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+ * // => [2, 3, 4]
+ */
+ function without(array) {
+ return baseDifference(array, slice(arguments, 1));
+ }
+
+ /**
+ * Creates an array that is the symmetric difference of the provided arrays.
+ * See http://en.wikipedia.org/wiki/Symmetric_difference.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of values.
+ * @example
+ *
+ * _.xor([1, 2, 3], [5, 2, 1, 4]);
+ * // => [3, 5, 4]
+ *
+ * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]);
+ * // => [1, 4, 5]
+ */
+ function xor() {
+ var index = -1,
+ length = arguments.length;
+
+ while (++index < length) {
+ var array = arguments[index];
+ if (isArray(array) || isArguments(array)) {
+ var result = result
+ ? baseUniq(baseDifference(result, array).concat(baseDifference(array, result)))
+ : array;
+ }
+ }
+ return result || [];
+ }
+
+ /**
+ * Creates an array of grouped elements, the first of which contains the first
+ * elements of the given arrays, the second of which contains the second
+ * elements of the given arrays, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @alias unzip
+ * @category Arrays
+ * @param {...Array} [array] Arrays to process.
+ * @returns {Array} Returns a new array of grouped elements.
+ * @example
+ *
+ * _.zip(['fred', 'barney'], [30, 40], [true, false]);
+ * // => [['fred', 30, true], ['barney', 40, false]]
+ */
+ function zip() {
+ var array = arguments.length > 1 ? arguments : arguments[0],
+ index = -1,
+ length = array ? max(pluck(array, 'length')) : 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = pluck(array, index);
+ }
+ return result;
+ }
+
+ /**
+ * Creates an object composed from arrays of `keys` and `values`. Provide
+ * either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`
+ * or two arrays, one of `keys` and one of corresponding `values`.
+ *
+ * @static
+ * @memberOf _
+ * @alias object
+ * @category Arrays
+ * @param {Array} keys The array of keys.
+ * @param {Array} [values=[]] The array of values.
+ * @returns {Object} Returns an object composed of the given keys and
+ * corresponding values.
+ * @example
+ *
+ * _.zipObject(['fred', 'barney'], [30, 40]);
+ * // => { 'fred': 30, 'barney': 40 }
+ */
+ function zipObject(keys, values) {
+ var index = -1,
+ length = keys ? keys.length : 0,
+ result = {};
+
+ if (!values && length && !isArray(keys[0])) {
+ values = [];
+ }
+ while (++index < length) {
+ var key = keys[index];
+ if (values) {
+ result[key] = values[index];
+ } else if (key) {
+ result[key[0]] = key[1];
+ }
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that executes `func`, with the `this` binding and
+ * arguments of the created function, only after being called `n` times.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {number} n The number of times the function must be called before
+ * `func` is executed.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var saves = ['profile', 'settings'];
+ *
+ * var done = _.after(saves.length, function() {
+ * console.log('Done saving!');
+ * });
+ *
+ * _.forEach(saves, function(type) {
+ * asyncSave({ 'type': type, 'complete': done });
+ * });
+ * // => logs 'Done saving!', after all saves have completed
+ */
+ function after(n, func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return function() {
+ if (--n < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with the `this`
+ * binding of `thisArg` and prepends any additional `bind` arguments to those
+ * provided to the bound function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to bind.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var func = function(greeting) {
+ * return greeting + ' ' + this.name;
+ * };
+ *
+ * func = _.bind(func, { 'name': 'fred' }, 'hi');
+ * func();
+ * // => 'hi fred'
+ */
+ function bind(func, thisArg) {
+ return arguments.length > 2
+ ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
+ : createWrapper(func, 1, null, null, thisArg);
+ }
+
+ /**
+ * Binds methods of an object to the object itself, overwriting the existing
+ * method. Method names may be specified as individual arguments or as arrays
+ * of method names. If no method names are provided all the function properties
+ * of `object` will be bound.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object to bind and assign the bound methods to.
+ * @param {...string} [methodName] The object method names to
+ * bind, specified as individual method names or arrays of method names.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var view = {
+ * 'label': 'docs',
+ * 'onClick': function() { console.log('clicked ' + this.label); }
+ * };
+ *
+ * _.bindAll(view);
+ * jQuery('#docs').on('click', view.onClick);
+ * // => logs 'clicked docs', when the button is clicked
+ */
+ function bindAll(object) {
+ var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object),
+ index = -1,
+ length = funcs.length;
+
+ while (++index < length) {
+ var key = funcs[index];
+ object[key] = createWrapper(object[key], 1, null, null, object);
+ }
+ return object;
+ }
+
+ /**
+ * Creates a function that, when called, invokes the method at `object[key]`
+ * and prepends any additional `bindKey` arguments to those provided to the bound
+ * function. This method differs from `_.bind` by allowing bound functions to
+ * reference methods that will be redefined or don't yet exist.
+ * See http://michaux.ca/articles/lazy-function-definition-pattern.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object the method belongs to.
+ * @param {string} key The key of the method.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var object = {
+ * 'name': 'fred',
+ * 'greet': function(greeting) {
+ * return greeting + ' ' + this.name;
+ * }
+ * };
+ *
+ * var func = _.bindKey(object, 'greet', 'hi');
+ * func();
+ * // => 'hi fred'
+ *
+ * object.greet = function(greeting) {
+ * return greeting + 'ya ' + this.name + '!';
+ * };
+ *
+ * func();
+ * // => 'hiya fred!'
+ */
+ function bindKey(object, key) {
+ return arguments.length > 2
+ ? createWrapper(key, 19, slice(arguments, 2), null, object)
+ : createWrapper(key, 3, null, null, object);
+ }
+
+ /**
+ * Creates a function that is the composition of the provided functions,
+ * where each function consumes the return value of the function that follows.
+ * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+ * Each function is executed with the `this` binding of the composed function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {...Function} [func] Functions to compose.
+ * @returns {Function} Returns the new composed function.
+ * @example
+ *
+ * var realNameMap = {
+ * 'pebbles': 'penelope'
+ * };
+ *
+ * var format = function(name) {
+ * name = realNameMap[name.toLowerCase()] || name;
+ * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+ * };
+ *
+ * var greet = function(formatted) {
+ * return 'Hiya ' + formatted + '!';
+ * };
+ *
+ * var welcome = _.compose(greet, format);
+ * welcome('pebbles');
+ * // => 'Hiya Penelope!'
+ */
+ function compose() {
+ var funcs = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ if (!isFunction(funcs[length])) {
+ throw new TypeError;
+ }
+ }
+ return function() {
+ var args = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ args = [funcs[length].apply(this, args)];
+ }
+ return args[0];
+ };
+ }
+
+ /**
+ * Creates a function which accepts one or more arguments of `func` that when
+ * invoked either executes `func` returning its result, if all `func` arguments
+ * have been provided, or returns a function that accepts one or more of the
+ * remaining `func` arguments, and so on. The arity of `func` can be specified
+ * if `func.length` is not sufficient.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to curry.
+ * @param {number} [arity=func.length] The arity of `func`.
+ * @returns {Function} Returns the new curried function.
+ * @example
+ *
+ * var curried = _.curry(function(a, b, c) {
+ * console.log(a + b + c);
+ * });
+ *
+ * curried(1)(2)(3);
+ * // => 6
+ *
+ * curried(1, 2)(3);
+ * // => 6
+ *
+ * curried(1, 2, 3);
+ * // => 6
+ */
+ function curry(func, arity) {
+ arity = typeof arity == 'number' ? arity : (+arity || func.length);
+ return createWrapper(func, 4, null, null, null, arity);
+ }
+
+ /**
+ * Creates a function that will delay the execution of `func` until after
+ * `wait` milliseconds have elapsed since the last time it was invoked.
+ * Provide an options object to indicate that `func` should be invoked on
+ * the leading and/or trailing edge of the `wait` timeout. Subsequent calls
+ * to the debounced function will return the result of the last `func` call.
+ *
+ * Note: If `leading` and `trailing` options are `true` `func` will be called
+ * on the trailing edge of the timeout only if the the debounced function is
+ * invoked more than once during the `wait` timeout.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to delay.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout.
+ * @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called.
+ * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // avoid costly calculations while the window size is in flux
+ * var lazyLayout = _.debounce(calculateLayout, 150);
+ * jQuery(window).on('resize', lazyLayout);
+ *
+ * // execute `sendMail` when the click event is fired, debouncing subsequent calls
+ * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
+ * 'leading': true,
+ * 'trailing': false
+ * });
+ *
+ * // ensure `batchLog` is executed once after 1 second of debounced calls
+ * var source = new EventSource('/stream');
+ * source.addEventListener('message', _.debounce(batchLog, 250, {
+ * 'maxWait': 1000
+ * }, false);
+ */
+ function debounce(func, wait, options) {
+ var args,
+ maxTimeoutId,
+ result,
+ stamp,
+ thisArg,
+ timeoutId,
+ trailingCall,
+ lastCalled = 0,
+ maxWait = false,
+ trailing = true;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ wait = nativeMax(0, wait) || 0;
+ if (options === true) {
+ var leading = true;
+ trailing = false;
+ } else if (isObject(options)) {
+ leading = options.leading;
+ maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0);
+ trailing = 'trailing' in options ? options.trailing : trailing;
+ }
+ var delayed = function() {
+ var remaining = wait - (now() - stamp);
+ if (remaining <= 0) {
+ if (maxTimeoutId) {
+ clearTimeout(maxTimeoutId);
+ }
+ var isCalled = trailingCall;
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (isCalled) {
+ lastCalled = now();
+ result = func.apply(thisArg, args);
+ if (!timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ }
+ } else {
+ timeoutId = setTimeout(delayed, remaining);
+ }
+ };
+
+ var maxDelayed = function() {
+ if (timeoutId) {
+ clearTimeout(timeoutId);
+ }
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (trailing || (maxWait !== wait)) {
+ lastCalled = now();
+ result = func.apply(thisArg, args);
+ if (!timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ }
+ };
+
+ return function() {
+ args = arguments;
+ stamp = now();
+ thisArg = this;
+ trailingCall = trailing && (timeoutId || !leading);
+
+ if (maxWait === false) {
+ var leadingCall = leading && !timeoutId;
+ } else {
+ if (!maxTimeoutId && !leading) {
+ lastCalled = stamp;
+ }
+ var remaining = maxWait - (stamp - lastCalled),
+ isCalled = remaining <= 0;
+
+ if (isCalled) {
+ if (maxTimeoutId) {
+ maxTimeoutId = clearTimeout(maxTimeoutId);
+ }
+ lastCalled = stamp;
+ result = func.apply(thisArg, args);
+ }
+ else if (!maxTimeoutId) {
+ maxTimeoutId = setTimeout(maxDelayed, remaining);
+ }
+ }
+ if (isCalled && timeoutId) {
+ timeoutId = clearTimeout(timeoutId);
+ }
+ else if (!timeoutId && wait !== maxWait) {
+ timeoutId = setTimeout(delayed, wait);
+ }
+ if (leadingCall) {
+ isCalled = true;
+ result = func.apply(thisArg, args);
+ }
+ if (isCalled && !timeoutId && !maxTimeoutId) {
+ args = thisArg = null;
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Defers executing the `func` function until the current call stack has cleared.
+ * Additional arguments will be provided to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to defer.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.defer(function(text) { console.log(text); }, 'deferred');
+ * // logs 'deferred' after one or more milliseconds
+ */
+ function defer(func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var args = slice(arguments, 1);
+ return setTimeout(function() { func.apply(undefined, args); }, 1);
+ }
+
+ /**
+ * Executes the `func` function after `wait` milliseconds. Additional arguments
+ * will be provided to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay execution.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.delay(function(text) { console.log(text); }, 1000, 'later');
+ * // => logs 'later' after one second
+ */
+ function delay(func, wait) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var args = slice(arguments, 2);
+ return setTimeout(function() { func.apply(undefined, args); }, wait);
+ }
+
+ /**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided it will be used to determine the cache key for storing the result
+ * based on the arguments provided to the memoized function. By default, the
+ * first argument provided to the memoized function is used as the cache key.
+ * The `func` is executed with the `this` binding of the memoized function.
+ * The result cache is exposed as the `cache` property on the memoized function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] A function used to resolve the cache key.
+ * @returns {Function} Returns the new memoizing function.
+ * @example
+ *
+ * var fibonacci = _.memoize(function(n) {
+ * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ *
+ * fibonacci(9)
+ * // => 34
+ *
+ * var data = {
+ * 'fred': { 'name': 'fred', 'age': 40 },
+ * 'pebbles': { 'name': 'pebbles', 'age': 1 }
+ * };
+ *
+ * // modifying the result cache
+ * var get = _.memoize(function(name) { return data[name]; }, _.identity);
+ * get('pebbles');
+ * // => { 'name': 'pebbles', 'age': 1 }
+ *
+ * get.cache.pebbles.name = 'penelope';
+ * get('pebbles');
+ * // => { 'name': 'penelope', 'age': 1 }
+ */
+ function memoize(func, resolver) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var memoized = function() {
+ var cache = memoized.cache,
+ key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0];
+
+ return hasOwnProperty.call(cache, key)
+ ? cache[key]
+ : (cache[key] = func.apply(this, arguments));
+ }
+ memoized.cache = {};
+ return memoized;
+ }
+
+ /**
+ * Creates a function that is restricted to execute `func` once. Repeat calls to
+ * the function will return the value of the first call. The `func` is executed
+ * with the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // `initialize` executes `createApplication` once
+ */
+ function once(func) {
+ var ran,
+ result;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return function() {
+ if (ran) {
+ return result;
+ }
+ ran = true;
+ result = func.apply(this, arguments);
+
+ // clear the `func` variable so the function may be garbage collected
+ func = null;
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with any additional
+ * `partial` arguments prepended to those provided to the new function. This
+ * method is similar to `_.bind` except it does **not** alter the `this` binding.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var greet = function(greeting, name) { return greeting + ' ' + name; };
+ * var hi = _.partial(greet, 'hi');
+ * hi('fred');
+ * // => 'hi fred'
+ */
+ function partial(func) {
+ return createWrapper(func, 16, slice(arguments, 1));
+ }
+
+ /**
+ * This method is like `_.partial` except that `partial` arguments are
+ * appended to those provided to the new function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var defaultsDeep = _.partialRight(_.merge, _.defaults);
+ *
+ * var options = {
+ * 'variable': 'data',
+ * 'imports': { 'jq': $ }
+ * };
+ *
+ * defaultsDeep(options, _.templateSettings);
+ *
+ * options.variable
+ * // => 'data'
+ *
+ * options.imports
+ * // => { '_': _, 'jq': $ }
+ */
+ function partialRight(func) {
+ return createWrapper(func, 32, null, slice(arguments, 1));
+ }
+
+ /**
+ * Creates a function that, when executed, will only call the `func` function
+ * at most once per every `wait` milliseconds. Provide an options object to
+ * indicate that `func` should be invoked on the leading and/or trailing edge
+ * of the `wait` timeout. Subsequent calls to the throttled function will
+ * return the result of the last `func` call.
+ *
+ * Note: If `leading` and `trailing` options are `true` `func` will be called
+ * on the trailing edge of the timeout only if the the throttled function is
+ * invoked more than once during the `wait` timeout.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to throttle.
+ * @param {number} wait The number of milliseconds to throttle executions to.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // avoid excessively updating the position while scrolling
+ * var throttled = _.throttle(updatePosition, 100);
+ * jQuery(window).on('scroll', throttled);
+ *
+ * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes
+ * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
+ * 'trailing': false
+ * }));
+ */
+ function throttle(func, wait, options) {
+ var leading = true,
+ trailing = true;
+
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ if (options === false) {
+ leading = false;
+ } else if (isObject(options)) {
+ leading = 'leading' in options ? options.leading : leading;
+ trailing = 'trailing' in options ? options.trailing : trailing;
+ }
+ debounceOptions.leading = leading;
+ debounceOptions.maxWait = wait;
+ debounceOptions.trailing = trailing;
+
+ return debounce(func, wait, debounceOptions);
+ }
+
+ /**
+ * Creates a function that provides `value` to the wrapper function as its
+ * first argument. Additional arguments provided to the function are appended
+ * to those provided to the wrapper function. The wrapper is executed with
+ * the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {*} value The value to wrap.
+ * @param {Function} wrapper The wrapper function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var p = _.wrap(_.escape, function(func, text) {
+ * return '<p>' + func(text) + '</p>';
+ * });
+ *
+ * p('Fred, Wilma, & Pebbles');
+ * // => '<p>Fred, Wilma, & Pebbles</p>'
+ */
+ function wrap(value, wrapper) {
+ return createWrapper(wrapper, 16, [value]);
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var getter = _.constant(object);
+ * getter() === object;
+ * // => true
+ */
+ function constant(value) {
+ return function() {
+ return value;
+ };
+ }
+
+ /**
+ * Produces a callback bound to an optional `thisArg`. If `func` is a property
+ * name the created callback will return the property value for a given element.
+ * If `func` is an object the created callback will return `true` for elements
+ * that contain the equivalent object properties, otherwise it will return `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // wrap to create custom callback shorthands
+ * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
+ * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
+ * return !match ? func(callback, thisArg) : function(object) {
+ * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
+ * };
+ * });
+ *
+ * _.filter(characters, 'age__gt38');
+ * // => [{ 'name': 'fred', 'age': 40 }]
+ */
+ function createCallback(func, thisArg, argCount) {
+ var type = typeof func;
+ if (func == null || type == 'function') {
+ return baseCreateCallback(func, thisArg, argCount);
+ }
+ // handle "_.pluck" style callback shorthands
+ if (type != 'object') {
+ return property(func);
+ }
+ var props = keys(func),
+ key = props[0],
+ a = func[key];
+
+ // handle "_.where" style callback shorthands
+ if (props.length == 1 && a === a && !isObject(a)) {
+ // fast path the common case of providing an object with a single
+ // property containing a primitive value
+ return function(object) {
+ var b = object[key];
+ return a === b && (a !== 0 || (1 / a == 1 / b));
+ };
+ }
+ return function(object) {
+ var length = props.length,
+ result = false;
+
+ while (length--) {
+ if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
+ break;
+ }
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding HTML entities.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escape('Fred, Wilma, & Pebbles');
+ * // => 'Fred, Wilma, & Pebbles'
+ */
+ function escape(string) {
+ return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
+ }
+
+ /**
+ * This method returns the first argument provided to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.identity(object) === object;
+ * // => true
+ */
+ function identity(value) {
+ return value;
+ }
+
+ /**
+ * Adds function properties of a source object to the destination object.
+ * If `object` is a function methods will be added to its prototype as well.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Function|Object} [object=lodash] object The destination object.
+ * @param {Object} source The object of functions to add.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.chain=true] Specify whether the functions added are chainable.
+ * @example
+ *
+ * function capitalize(string) {
+ * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+ * }
+ *
+ * _.mixin({ 'capitalize': capitalize });
+ * _.capitalize('fred');
+ * // => 'Fred'
+ *
+ * _('fred').capitalize().value();
+ * // => 'Fred'
+ *
+ * _.mixin({ 'capitalize': capitalize }, { 'chain': false });
+ * _('fred').capitalize();
+ * // => 'Fred'
+ */
+ function mixin(object, source, options) {
+ var chain = true,
+ methodNames = source && functions(source);
+
+ if (!source || (!options && !methodNames.length)) {
+ if (options == null) {
+ options = source;
+ }
+ ctor = lodashWrapper;
+ source = object;
+ object = lodash;
+ methodNames = functions(source);
+ }
+ if (options === false) {
+ chain = false;
+ } else if (isObject(options) && 'chain' in options) {
+ chain = options.chain;
+ }
+ var ctor = object,
+ isFunc = isFunction(ctor);
+
+ forEach(methodNames, function(methodName) {
+ var func = object[methodName] = source[methodName];
+ if (isFunc) {
+ ctor.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ value = this.__wrapped__,
+ args = [value];
+
+ push.apply(args, arguments);
+ var result = func.apply(object, args);
+ if (chain || chainAll) {
+ if (value === result && isObject(result)) {
+ return this;
+ }
+ result = new ctor(result);
+ result.__chain__ = chainAll;
+ }
+ return result;
+ };
+ }
+ });
+ }
+
+ /**
+ * Reverts the '_' variable to its previous value and returns a reference to
+ * the `lodash` function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @returns {Function} Returns the `lodash` function.
+ * @example
+ *
+ * var lodash = _.noConflict();
+ */
+ function noConflict() {
+ context._ = oldDash;
+ return this;
+ }
+
+ /**
+ * A no-operation function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.noop(object) === undefined;
+ * // => true
+ */
+ function noop() {
+ // no operation performed
+ }
+
+ /**
+ * Gets the number of milliseconds that have elapsed since the Unix epoch
+ * (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var stamp = _.now();
+ * _.defer(function() { console.log(_.now() - stamp); });
+ * // => logs the number of milliseconds it took for the deferred function to be called
+ */
+ var now = isNative(now = Date.now) && now || function() {
+ return new Date().getTime();
+ };
+
+ /**
+ * Converts the given value into an integer of the specified radix.
+ * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the
+ * `value` is a hexadecimal, in which case a `radix` of `16` is used.
+ *
+ * Note: This method avoids differences in native ES3 and ES5 `parseInt`
+ * implementations. See http://es5.github.io/#E.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} value The value to parse.
+ * @param {number} [radix] The radix used to interpret the value to parse.
+ * @returns {number} Returns the new integer value.
+ * @example
+ *
+ * _.parseInt('08');
+ * // => 8
+ */
+ var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {
+ // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt`
+ return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);
+ };
+
+ /**
+ * Creates a "_.pluck" style function, which returns the `key` value of a
+ * given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} key The name of the property to retrieve.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 36 }
+ * ];
+ *
+ * var getName = _.property('name');
+ *
+ * _.map(characters, getName);
+ * // => ['barney', 'fred']
+ *
+ * _.sortBy(characters, getName);
+ * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }]
+ */
+ function property(key) {
+ return function(object) {
+ return object[key];
+ };
+ }
+
+ /**
+ * Produces a random number between `min` and `max` (inclusive). If only one
+ * argument is provided a number between `0` and the given number will be
+ * returned. If `floating` is truey or either `min` or `max` are floats a
+ * floating-point number will be returned instead of an integer.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} [min=0] The minimum possible value.
+ * @param {number} [max=1] The maximum possible value.
+ * @param {boolean} [floating=false] Specify returning a floating-point number.
+ * @returns {number} Returns a random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+ function random(min, max, floating) {
+ var noMin = min == null,
+ noMax = max == null;
+
+ if (floating == null) {
+ if (typeof min == 'boolean' && noMax) {
+ floating = min;
+ min = 1;
+ }
+ else if (!noMax && typeof max == 'boolean') {
+ floating = max;
+ noMax = true;
+ }
+ }
+ if (noMin && noMax) {
+ max = 1;
+ }
+ min = +min || 0;
+ if (noMax) {
+ max = min;
+ min = 0;
+ } else {
+ max = +max || 0;
+ }
+ if (floating || min % 1 || max % 1) {
+ var rand = nativeRandom();
+ return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max);
+ }
+ return baseRandom(min, max);
+ }
+
+ /**
+ * Resolves the value of property `key` on `object`. If `key` is a function
+ * it will be invoked with the `this` binding of `object` and its result returned,
+ * else the property value is returned. If `object` is falsey then `undefined`
+ * is returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to resolve.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = {
+ * 'cheese': 'crumpets',
+ * 'stuff': function() {
+ * return 'nonsense';
+ * }
+ * };
+ *
+ * _.result(object, 'cheese');
+ * // => 'crumpets'
+ *
+ * _.result(object, 'stuff');
+ * // => 'nonsense'
+ */
+ function result(object, key) {
+ if (object) {
+ var value = object[key];
+ return isFunction(value) ? object[key]() : value;
+ }
+ }
+
+ /**
+ * A micro-templating method that handles arbitrary delimiters, preserves
+ * whitespace, and correctly escapes quotes within interpolated code.
+ *
+ * Note: In the development build, `_.template` utilizes sourceURLs for easier
+ * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ *
+ * For more information on precompiling templates see:
+ * https://lodash.com/custom-builds
+ *
+ * For more information on Chrome extension sandboxes see:
+ * http://developer.chrome.com/stable/extensions/sandboxingEval.html
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} text The template text.
+ * @param {Object} data The data object used to populate the text.
+ * @param {Object} [options] The options object.
+ * @param {RegExp} [options.escape] The "escape" delimiter.
+ * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
+ * @param {Object} [options.imports] An object to import into the template as local variables.
+ * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
+ * @param {string} [sourceURL] The sourceURL of the template's compiled source.
+ * @param {string} [variable] The data object variable name.
+ * @returns {Function|string} Returns a compiled function when no `data` object
+ * is given, else it returns the interpolated text.
+ * @example
+ *
+ * // using the "interpolate" delimiter to create a compiled template
+ * var compiled = _.template('hello <%= name %>');
+ * compiled({ 'name': 'fred' });
+ * // => 'hello fred'
+ *
+ * // using the "escape" delimiter to escape HTML in data property values
+ * _.template('<b><%- value %></b>', { 'value': '<script>' });
+ * // => '<b><script></b>'
+ *
+ * // using the "evaluate" delimiter to generate HTML
+ * var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
+ * _.template(list, { 'people': ['fred', 'barney'] });
+ * // => '<li>fred</li><li>barney</li>'
+ *
+ * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
+ * _.template('hello ${ name }', { 'name': 'pebbles' });
+ * // => 'hello pebbles'
+ *
+ * // using the internal `print` function in "evaluate" delimiters
+ * _.template('<% print("hello " + name); %>!', { 'name': 'barney' });
+ * // => 'hello barney!'
+ *
+ * // using a custom template delimiters
+ * _.templateSettings = {
+ * 'interpolate': /{{([\s\S]+?)}}/g
+ * };
+ *
+ * _.template('hello {{ name }}!', { 'name': 'mustache' });
+ * // => 'hello mustache!'
+ *
+ * // using the `imports` option to import jQuery
+ * var list = '<% jq.each(people, function(name) { %><li><%- name %></li><% }); %>';
+ * _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { 'jq': jQuery } });
+ * // => '<li>fred</li><li>barney</li>'
+ *
+ * // using the `sourceURL` option to specify a custom sourceURL for the template
+ * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+ * compiled(data);
+ * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
+ *
+ * // using the `variable` option to ensure a with-statement isn't used in the compiled template
+ * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+ * compiled.source;
+ * // => function(data) {
+ * var __t, __p = '', __e = _.escape;
+ * __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
+ * return __p;
+ * }
+ *
+ * // using the `source` property to inline compiled templates for meaningful
+ * // line numbers in error messages and a stack trace
+ * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
+ * var JST = {\
+ * "main": ' + _.template(mainText).source + '\
+ * };\
+ * ');
+ */
+ function template(text, data, options) {
+ // based on John Resig's `tmpl` implementation
+ // http://ejohn.org/blog/javascript-micro-templating/
+ // and Laura Doktorova's doT.js
+ // https://github.com/olado/doT
+ var settings = lodash.templateSettings;
+ text = String(text || '');
+
+ // avoid missing dependencies when `iteratorTemplate` is not defined
+ options = defaults({}, options, settings);
+
+ var imports = defaults({}, options.imports, settings.imports),
+ importsKeys = keys(imports),
+ importsValues = values(imports);
+
+ var isEvaluating,
+ index = 0,
+ interpolate = options.interpolate || reNoMatch,
+ source = "__p += '";
+
+ // compile the regexp to match each delimiter
+ var reDelimiters = RegExp(
+ (options.escape || reNoMatch).source + '|' +
+ interpolate.source + '|' +
+ (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
+ (options.evaluate || reNoMatch).source + '|$'
+ , 'g');
+
+ text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
+ interpolateValue || (interpolateValue = esTemplateValue);
+
+ // escape characters that cannot be included in string literals
+ source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);
+
+ // replace delimiters with snippets
+ if (escapeValue) {
+ source += "' +\n__e(" + escapeValue + ") +\n'";
+ }
+ if (evaluateValue) {
+ isEvaluating = true;
+ source += "';\n" + evaluateValue + ";\n__p += '";
+ }
+ if (interpolateValue) {
+ source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+ }
+ index = offset + match.length;
+
+ // the JS engine embedded in Adobe products requires returning the `match`
+ // string in order to produce the correct `offset` value
+ return match;
+ });
+
+ source += "';\n";
+
+ // if `variable` is not specified, wrap a with-statement around the generated
+ // code to add the data object to the top of the scope chain
+ var variable = options.variable,
+ hasVariable = variable;
+
+ if (!hasVariable) {
+ variable = 'obj';
+ source = 'with (' + variable + ') {\n' + source + '\n}\n';
+ }
+ // cleanup code by stripping empty strings
+ source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+ .replace(reEmptyStringMiddle, '$1')
+ .replace(reEmptyStringTrailing, '$1;');
+
+ // frame code as the function body
+ source = 'function(' + variable + ') {\n' +
+ (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
+ "var __t, __p = '', __e = _.escape" +
+ (isEvaluating
+ ? ', __j = Array.prototype.join;\n' +
+ "function print() { __p += __j.call(arguments, '') }\n"
+ : ';\n'
+ ) +
+ source +
+ 'return __p\n}';
+
+ // Use a sourceURL for easier debugging.
+ // http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ var sourceURL = '\n/*\n//# sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\n*/';
+
+ try {
+ var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);
+ } catch(e) {
+ e.source = source;
+ throw e;
+ }
+ if (data) {
+ return result(data);
+ }
+ // provide the compiled function's source by its `toString` method, in
+ // supported environments, or the `source` property as a convenience for
+ // inlining compiled templates during the build process
+ result.source = source;
+ return result;
+ }
+
+ /**
+ * Executes the callback `n` times, returning an array of the results
+ * of each callback execution. The callback is bound to `thisArg` and invoked
+ * with one argument; (index).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} n The number of times to execute the callback.
+ * @param {Function} callback The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns an array of the results of each `callback` execution.
+ * @example
+ *
+ * var diceRolls = _.times(3, _.partial(_.random, 1, 6));
+ * // => [3, 6, 4]
+ *
+ * _.times(3, function(n) { mage.castSpell(n); });
+ * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively
+ *
+ * _.times(3, function(n) { this.cast(n); }, mage);
+ * // => also calls `mage.castSpell(n)` three times
+ */
+ function times(n, callback, thisArg) {
+ n = (n = +n) > -1 ? n : 0;
+ var index = -1,
+ result = Array(n);
+
+ callback = baseCreateCallback(callback, thisArg, 1);
+ while (++index < n) {
+ result[index] = callback(index);
+ }
+ return result;
+ }
+
+ /**
+ * The inverse of `_.escape` this method converts the HTML entities
+ * `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding characters.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to unescape.
+ * @returns {string} Returns the unescaped string.
+ * @example
+ *
+ * _.unescape('Fred, Barney & Pebbles');
+ * // => 'Fred, Barney & Pebbles'
+ */
+ function unescape(string) {
+ return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar);
+ }
+
+ /**
+ * Generates a unique ID. If `prefix` is provided the ID will be appended to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} [prefix] The value to prefix the ID with.
+ * @returns {string} Returns the unique ID.
+ * @example
+ *
+ * _.uniqueId('contact_');
+ * // => 'contact_104'
+ *
+ * _.uniqueId();
+ * // => '105'
+ */
+ function uniqueId(prefix) {
+ var id = ++idCounter;
+ return String(prefix == null ? '' : prefix) + id;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object that wraps the given value with explicit
+ * method chaining enabled.
+ *
+ * @static
+ * @memberOf _
+ * @category Chaining
+ * @param {*} value The value to wrap.
+ * @returns {Object} Returns the wrapper object.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'pebbles', 'age': 1 }
+ * ];
+ *
+ * var youngest = _.chain(characters)
+ * .sortBy('age')
+ * .map(function(chr) { return chr.name + ' is ' + chr.age; })
+ * .first()
+ * .value();
+ * // => 'pebbles is 1'
+ */
+ function chain(value) {
+ value = new lodashWrapper(value);
+ value.__chain__ = true;
+ return value;
+ }
+
+ /**
+ * Invokes `interceptor` with the `value` as the first argument and then
+ * returns `value`. The purpose of this method is to "tap into" a method
+ * chain in order to perform operations on intermediate results within
+ * the chain.
+ *
+ * @static
+ * @memberOf _
+ * @category Chaining
+ * @param {*} value The value to provide to `interceptor`.
+ * @param {Function} interceptor The function to invoke.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * _([1, 2, 3, 4])
+ * .tap(function(array) { array.pop(); })
+ * .reverse()
+ * .value();
+ * // => [3, 2, 1]
+ */
+ function tap(value, interceptor) {
+ interceptor(value);
+ return value;
+ }
+
+ /**
+ * Enables explicit method chaining on the wrapper object.
+ *
+ * @name chain
+ * @memberOf _
+ * @category Chaining
+ * @returns {*} Returns the wrapper object.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // without explicit chaining
+ * _(characters).first();
+ * // => { 'name': 'barney', 'age': 36 }
+ *
+ * // with explicit chaining
+ * _(characters).chain()
+ * .first()
+ * .pick('age')
+ * .value();
+ * // => { 'age': 36 }
+ */
+ function wrapperChain() {
+ this.__chain__ = true;
+ return this;
+ }
+
+ /**
+ * Produces the `toString` result of the wrapped value.
+ *
+ * @name toString
+ * @memberOf _
+ * @category Chaining
+ * @returns {string} Returns the string result.
+ * @example
+ *
+ * _([1, 2, 3]).toString();
+ * // => '1,2,3'
+ */
+ function wrapperToString() {
+ return String(this.__wrapped__);
+ }
+
+ /**
+ * Extracts the wrapped value.
+ *
+ * @name valueOf
+ * @memberOf _
+ * @alias value
+ * @category Chaining
+ * @returns {*} Returns the wrapped value.
+ * @example
+ *
+ * _([1, 2, 3]).valueOf();
+ * // => [1, 2, 3]
+ */
+ function wrapperValueOf() {
+ return this.__wrapped__;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions that return wrapped values when chaining
+ lodash.after = after;
+ lodash.assign = assign;
+ lodash.at = at;
+ lodash.bind = bind;
+ lodash.bindAll = bindAll;
+ lodash.bindKey = bindKey;
+ lodash.chain = chain;
+ lodash.compact = compact;
+ lodash.compose = compose;
+ lodash.constant = constant;
+ lodash.countBy = countBy;
+ lodash.create = create;
+ lodash.createCallback = createCallback;
+ lodash.curry = curry;
+ lodash.debounce = debounce;
+ lodash.defaults = defaults;
+ lodash.defer = defer;
+ lodash.delay = delay;
+ lodash.difference = difference;
+ lodash.filter = filter;
+ lodash.flatten = flatten;
+ lodash.forEach = forEach;
+ lodash.forEachRight = forEachRight;
+ lodash.forIn = forIn;
+ lodash.forInRight = forInRight;
+ lodash.forOwn = forOwn;
+ lodash.forOwnRight = forOwnRight;
+ lodash.functions = functions;
+ lodash.groupBy = groupBy;
+ lodash.indexBy = indexBy;
+ lodash.initial = initial;
+ lodash.intersection = intersection;
+ lodash.invert = invert;
+ lodash.invoke = invoke;
+ lodash.keys = keys;
+ lodash.map = map;
+ lodash.mapValues = mapValues;
+ lodash.max = max;
+ lodash.memoize = memoize;
+ lodash.merge = merge;
+ lodash.min = min;
+ lodash.omit = omit;
+ lodash.once = once;
+ lodash.pairs = pairs;
+ lodash.partial = partial;
+ lodash.partialRight = partialRight;
+ lodash.pick = pick;
+ lodash.pluck = pluck;
+ lodash.property = property;
+ lodash.pull = pull;
+ lodash.range = range;
+ lodash.reject = reject;
+ lodash.remove = remove;
+ lodash.rest = rest;
+ lodash.shuffle = shuffle;
+ lodash.sortBy = sortBy;
+ lodash.tap = tap;
+ lodash.throttle = throttle;
+ lodash.times = times;
+ lodash.toArray = toArray;
+ lodash.transform = transform;
+ lodash.union = union;
+ lodash.uniq = uniq;
+ lodash.values = values;
+ lodash.where = where;
+ lodash.without = without;
+ lodash.wrap = wrap;
+ lodash.xor = xor;
+ lodash.zip = zip;
+ lodash.zipObject = zipObject;
+
+ // add aliases
+ lodash.collect = map;
+ lodash.drop = rest;
+ lodash.each = forEach;
+ lodash.eachRight = forEachRight;
+ lodash.extend = assign;
+ lodash.methods = functions;
+ lodash.object = zipObject;
+ lodash.select = filter;
+ lodash.tail = rest;
+ lodash.unique = uniq;
+ lodash.unzip = zip;
+
+ // add functions to `lodash.prototype`
+ mixin(lodash);
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions that return unwrapped values when chaining
+ lodash.clone = clone;
+ lodash.cloneDeep = cloneDeep;
+ lodash.contains = contains;
+ lodash.escape = escape;
+ lodash.every = every;
+ lodash.find = find;
+ lodash.findIndex = findIndex;
+ lodash.findKey = findKey;
+ lodash.findLast = findLast;
+ lodash.findLastIndex = findLastIndex;
+ lodash.findLastKey = findLastKey;
+ lodash.has = has;
+ lodash.identity = identity;
+ lodash.indexOf = indexOf;
+ lodash.isArguments = isArguments;
+ lodash.isArray = isArray;
+ lodash.isBoolean = isBoolean;
+ lodash.isDate = isDate;
+ lodash.isElement = isElement;
+ lodash.isEmpty = isEmpty;
+ lodash.isEqual = isEqual;
+ lodash.isFinite = isFinite;
+ lodash.isFunction = isFunction;
+ lodash.isNaN = isNaN;
+ lodash.isNull = isNull;
+ lodash.isNumber = isNumber;
+ lodash.isObject = isObject;
+ lodash.isPlainObject = isPlainObject;
+ lodash.isRegExp = isRegExp;
+ lodash.isString = isString;
+ lodash.isUndefined = isUndefined;
+ lodash.lastIndexOf = lastIndexOf;
+ lodash.mixin = mixin;
+ lodash.noConflict = noConflict;
+ lodash.noop = noop;
+ lodash.now = now;
+ lodash.parseInt = parseInt;
+ lodash.random = random;
+ lodash.reduce = reduce;
+ lodash.reduceRight = reduceRight;
+ lodash.result = result;
+ lodash.runInContext = runInContext;
+ lodash.size = size;
+ lodash.some = some;
+ lodash.sortedIndex = sortedIndex;
+ lodash.template = template;
+ lodash.unescape = unescape;
+ lodash.uniqueId = uniqueId;
+
+ // add aliases
+ lodash.all = every;
+ lodash.any = some;
+ lodash.detect = find;
+ lodash.findWhere = find;
+ lodash.foldl = reduce;
+ lodash.foldr = reduceRight;
+ lodash.include = contains;
+ lodash.inject = reduce;
+
+ mixin(function() {
+ var source = {}
+ forOwn(lodash, function(func, methodName) {
+ if (!lodash.prototype[methodName]) {
+ source[methodName] = func;
+ }
+ });
+ return source;
+ }(), false);
+
+ /*--------------------------------------------------------------------------*/
+
+ // add functions capable of returning wrapped and unwrapped values when chaining
+ lodash.first = first;
+ lodash.last = last;
+ lodash.sample = sample;
+
+ // add aliases
+ lodash.take = first;
+ lodash.head = first;
+
+ forOwn(lodash, function(func, methodName) {
+ var callbackable = methodName !== 'sample';
+ if (!lodash.prototype[methodName]) {
+ lodash.prototype[methodName]= function(n, guard) {
+ var chainAll = this.__chain__,
+ result = func(this.__wrapped__, n, guard);
+
+ return !chainAll && (n == null || (guard && !(callbackable && typeof n == 'function')))
+ ? result
+ : new lodashWrapper(result, chainAll);
+ };
+ }
+ });
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The semantic version number.
+ *
+ * @static
+ * @memberOf _
+ * @type string
+ */
+ lodash.VERSION = '2.4.2';
+
+ // add "Chaining" functions to the wrapper
+ lodash.prototype.chain = wrapperChain;
+ lodash.prototype.toString = wrapperToString;
+ lodash.prototype.value = wrapperValueOf;
+ lodash.prototype.valueOf = wrapperValueOf;
+
+ // add `Array` functions that return unwrapped values
+ forEach(['join', 'pop', 'shift'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ result = func.apply(this.__wrapped__, arguments);
+
+ return chainAll
+ ? new lodashWrapper(result, chainAll)
+ : result;
+ };
+ });
+
+ // add `Array` functions that return the existing wrapped value
+ forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ func.apply(this.__wrapped__, arguments);
+ return this;
+ };
+ });
+
+ // add `Array` functions that return new wrapped values
+ forEach(['concat', 'slice', 'splice'], function(methodName) {
+ var func = arrayRef[methodName];
+ lodash.prototype[methodName] = function() {
+ return new lodashWrapper(func.apply(this.__wrapped__, arguments), this.__chain__);
+ };
+ });
+
+ return lodash;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ // expose Lo-Dash
+ var _ = runInContext();
+
+ // some AMD build optimizers like r.js check for condition patterns like the following:
+ if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+ // Expose Lo-Dash to the global object even when an AMD loader is present in
+ // case Lo-Dash is loaded with a RequireJS shim config.
+ // See http://requirejs.org/docs/api.html#config-shim
+ root._ = _;
+
+ // define as an anonymous module so, through path mapping, it can be
+ // referenced as the "underscore" module
+ define(function() {
+ return _;
+ });
+ }
+ // check for `exports` after `define` in case a build optimizer adds an `exports` object
+ else if (freeExports && freeModule) {
+ // in Node.js or RingoJS
+ if (moduleExports) {
+ (freeModule.exports = _)._ = _;
+ }
+ // in Narwhal or Rhino -require
+ else {
+ freeExports._ = _;
+ }
+ }
+ else {
+ // in a browser or Rhino
+ root._ = _;
+ }
+}.call(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}]},{},[1])(1)
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9icm93c2VyaWZ5L25vZGVfbW9kdWxlcy9icm93c2VyLXBhY2svX3ByZWx1ZGUuanMiLCJpbmRleC5qcyIsImxpYi9hcnJvd3MuanMiLCJsaWIvY3JlYXRlLWNsdXN0ZXJzLmpzIiwibGliL2NyZWF0ZS1lZGdlLWxhYmVscy5qcyIsImxpYi9jcmVhdGUtZWRnZS1wYXRocy5qcyIsImxpYi9jcmVhdGUtbm9kZXMuanMiLCJsaWIvZDMuanMiLCJsaWIvZGFncmUuanMiLCJsaWIvZ3JhcGhsaWIuanMiLCJsaWIvaW50ZXJzZWN0L2luZGV4LmpzIiwibGliL2ludGVyc2VjdC9pbnRlcnNlY3QtY2lyY2xlLmpzIiwibGliL2ludG [...]
diff --git a/debian/missing-source/graphlib-dot.js b/debian/missing-source/graphlib-dot.js
new file mode 100644
index 0000000..a2feefb
--- /dev/null
+++ b/debian/missing-source/graphlib-dot.js
@@ -0,0 +1,44345 @@
+
+
+
+
+<!DOCTYPE html>
+<html lang="en" class=" is-copy-enabled">
+ <head prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb# object: http://ogp.me/ns/object# article: http://ogp.me/ns/article# profile: http://ogp.me/ns/profile#">
+ <meta charset='utf-8'>
+
+ <link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/frameworks-3d76cf5dfcbfddd8456ba6c3563575e62d94b9d37ede7015caec62ca4658eb1c.css" integrity="sha256-PXbPXfy/3dhFa6bDVjV15i2UudN+3nAVyuxiykZY6xw=" media="all" rel="stylesheet" />
+ <link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/github-9b211330eea28af8ad875529a9a1963cd982f9773900b66b4030034b218ca08b.css" integrity="sha256-myETMO6iivith1UpqaGWPNmC+Xc5ALZrQDADSyGMoIs=" media="all" rel="stylesheet" />
+
+
+ <link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/site-3b27741f2e22b48854ecee715112d86949a7c9e4e502f41739c4578cc65283da.css" integrity="sha256-Oyd0Hy4itIhU7O5xURLYaUmnyeTlAvQXOcRXjMZSg9o=" media="all" rel="stylesheet" />
+
+
+
+ <link as="script" href="https://assets-cdn.github.com/assets/frameworks-149d9338c2665172870825c78fa48fdcca4d431d067cbf5fda7120d9e39cc738.js" rel="preload" />
+
+ <link as="script" href="https://assets-cdn.github.com/assets/github-a6cf0d49bc27a901349d1c50564a8c1856596b0b405e3b35b3747719f1038aa5.js" rel="preload" />
+
+ <meta http-equiv="X-UA-Compatible" content="IE=edge">
+ <meta http-equiv="Content-Language" content="en">
+ <meta name="viewport" content="width=device-width">
+
+
+ <title>graphlib-dot/graphlib-dot.js at master · cpettitt/graphlib-dot · GitHub</title>
+ <link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="GitHub">
+ <link rel="fluid-icon" href="https://github.com/fluidicon.png" title="GitHub">
+ <link rel="apple-touch-icon" href="/apple-touch-icon.png">
+ <link rel="apple-touch-icon" sizes="57x57" href="/apple-touch-icon-57x57.png">
+ <link rel="apple-touch-icon" sizes="60x60" href="/apple-touch-icon-60x60.png">
+ <link rel="apple-touch-icon" sizes="72x72" href="/apple-touch-icon-72x72.png">
+ <link rel="apple-touch-icon" sizes="76x76" href="/apple-touch-icon-76x76.png">
+ <link rel="apple-touch-icon" sizes="114x114" href="/apple-touch-icon-114x114.png">
+ <link rel="apple-touch-icon" sizes="120x120" href="/apple-touch-icon-120x120.png">
+ <link rel="apple-touch-icon" sizes="144x144" href="/apple-touch-icon-144x144.png">
+ <link rel="apple-touch-icon" sizes="152x152" href="/apple-touch-icon-152x152.png">
+ <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png">
+ <meta property="fb:app_id" content="1401488693436528">
+
+ <meta content="https://avatars0.githubusercontent.com/u/11766?v=3&s=400" name="twitter:image:src" /><meta content="@github" name="twitter:site" /><meta content="summary" name="twitter:card" /><meta content="cpettitt/graphlib-dot" name="twitter:title" /><meta content="graphlib-dot - A DOT language parser / writer for graphlib" name="twitter:description" />
+ <meta content="https://avatars0.githubusercontent.com/u/11766?v=3&s=400" property="og:image" /><meta content="GitHub" property="og:site_name" /><meta content="object" property="og:type" /><meta content="cpettitt/graphlib-dot" property="og:title" /><meta content="https://github.com/cpettitt/graphlib-dot" property="og:url" /><meta content="graphlib-dot - A DOT language parser / writer for graphlib" property="og:description" />
+ <meta name="browser-stats-url" content="https://api.github.com/_private/browser/stats">
+ <meta name="browser-errors-url" content="https://api.github.com/_private/browser/errors">
+ <link rel="assets" href="https://assets-cdn.github.com/">
+
+ <meta name="pjax-timeout" content="1000">
+
+
+ <meta name="msapplication-TileImage" content="/windows-tile.png">
+ <meta name="msapplication-TileColor" content="#ffffff">
+ <meta name="selected-link" value="repo_source" data-pjax-transient>
+
+ <meta name="google-site-verification" content="KT5gs8h0wvaagLKAVWq8bbeNwnZZK1r1XQysX3xurLU">
+<meta name="google-site-verification" content="ZzhVyEFwb7w3e0-uOTltm8Jsck2F5StVihD0exw2fsA">
+ <meta name="google-analytics" content="UA-3769691-2">
+
+<meta content="collector.githubapp.com" name="octolytics-host" /><meta content="github" name="octolytics-app-id" /><meta content="2E3B8B23:2B24:16792C5D:57840B97" name="octolytics-dimension-request_id" />
+<meta content="/<user-name>/<repo-name>/blob/show" data-pjax-transient="true" name="analytics-location" />
+
+
+
+ <meta class="js-ga-set" name="dimension1" content="Logged Out">
+
+
+
+ <meta name="hostname" content="github.com">
+ <meta name="user-login" content="">
+
+ <meta name="expected-hostname" content="github.com">
+ <meta name="js-proxy-site-detection-payload" content="M2EyMmI0NzY2NDNkYjFmMjgyMWFiMTI0MjZkZWNlOTJkNGM1NGNiMTIxOGQyMzMwZTExMjYzNzdjOGJiZWQ3ZXx7InJlbW90ZV9hZGRyZXNzIjoiNDYuNTkuMTM5LjM1IiwicmVxdWVzdF9pZCI6IjJFM0I4QjIzOjJCMjQ6MTY3OTJDNUQ6NTc4NDBCOTciLCJ0aW1lc3RhbXAiOjE0NjgyNzE1MTJ9">
+
+
+ <link rel="mask-icon" href="https://assets-cdn.github.com/pinned-octocat.svg" color="#4078c0">
+ <link rel="icon" type="image/x-icon" href="https://assets-cdn.github.com/favicon.ico">
+
+ <meta name="html-safe-nonce" content="7f88e04b69aa5bd31552bb01a341fdbe9efc5fef">
+ <meta content="845c042176074c871c9217c24b2c495933ab00de" name="form-nonce" />
+
+ <meta http-equiv="x-pjax-version" content="9cf1839292511819f902a3048cd77625">
+
+
+
+ <meta name="description" content="graphlib-dot - A DOT language parser / writer for graphlib">
+ <meta name="go-import" content="github.com/cpettitt/graphlib-dot git https://github.com/cpettitt/graphlib-dot.git">
+
+ <meta content="11766" name="octolytics-dimension-user_id" /><meta content="cpettitt" name="octolytics-dimension-user_login" /><meta content="12344532" name="octolytics-dimension-repository_id" /><meta content="cpettitt/graphlib-dot" name="octolytics-dimension-repository_nwo" /><meta content="true" name="octolytics-dimension-repository_public" /><meta content="false" name="octolytics-dimension-repository_is_fork" /><meta content="12344532" name="octolytics-dimension-repository_network_r [...]
+ <link href="https://github.com/cpettitt/graphlib-dot/commits/master.atom" rel="alternate" title="Recent Commits to graphlib-dot:master" type="application/atom+xml">
+
+
+ <link rel="canonical" href="https://github.com/cpettitt/graphlib-dot/blob/master/dist/graphlib-dot.js" data-pjax-transient>
+ </head>
+
+
+ <body class="logged-out env-production linux vis-public page-blob">
+ <div id="js-pjax-loader-bar" class="pjax-loader-bar"></div>
+ <a href="#start-of-content" tabindex="1" class="accessibility-aid js-skip-to-content">Skip to content</a>
+
+
+
+
+
+
+
+ <header class="site-header js-details-container" role="banner">
+ <div class="container-responsive">
+ <a class="header-logo-invertocat" href="https://github.com/" aria-label="Homepage" data-ga-click="(Logged out) Header, go to homepage, icon:logo-wordmark">
+ <svg aria-hidden="true" class="octicon octicon-mark-github" height="32" version="1.1" viewBox="0 0 16 16" width="32"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36. [...]
+ </a>
+
+ <button class="btn-link right site-header-toggle js-details-target" type="button" aria-label="Toggle navigation">
+ <svg aria-hidden="true" class="octicon octicon-three-bars" height="24" version="1.1" viewBox="0 0 12 16" width="18"><path d="M11.41 9H.59C0 9 0 8.59 0 8c0-.59 0-1 .59-1H11.4c.59 0 .59.41.59 1 0 .59 0 1-.59 1h.01zm0-4H.59C0 5 0 4.59 0 4c0-.59 0-1 .59-1H11.4c.59 0 .59.41.59 1 0 .59 0 1-.59 1h.01zM.59 11H11.4c.59 0 .59.41.59 1 0 .59 0 1-.59 1H.59C0 13 0 12.59 0 12c0-.59 0-1 .59-1z"></path></svg>
+ </button>
+
+ <div class="site-header-menu">
+ <nav class="site-header-nav site-header-nav-main">
+ <a href="/personal" class="js-selected-navigation-item nav-item nav-item-personal" data-ga-click="Header, click, Nav menu - item:personal" data-selected-links="/personal /personal">
+ Personal
+</a> <a href="/open-source" class="js-selected-navigation-item nav-item nav-item-opensource" data-ga-click="Header, click, Nav menu - item:opensource" data-selected-links="/open-source /open-source">
+ Open source
+</a> <a href="/business" class="js-selected-navigation-item nav-item nav-item-business" data-ga-click="Header, click, Nav menu - item:business" data-selected-links="/business /business/features /business/customers /business">
+ Business
+</a> <a href="/explore" class="js-selected-navigation-item nav-item nav-item-explore" data-ga-click="Header, click, Nav menu - item:explore" data-selected-links="/explore /trending /trending/developers /integrations /integrations/feature/code /integrations/feature/collaborate /integrations/feature/ship /explore">
+ Explore
+</a> </nav>
+
+ <div class="site-header-actions">
+ <a class="btn btn-primary site-header-actions-btn" href="/join?source=header-repo" data-ga-click="(Logged out) Header, clicked Sign up, text:sign-up">Sign up</a>
+ <a class="btn site-header-actions-btn mr-2" href="/login?return_to=%2Fcpettitt%2Fgraphlib-dot%2Fblob%2Fmaster%2Fdist%2Fgraphlib-dot.js" data-ga-click="(Logged out) Header, clicked Sign in, text:sign-in">Sign in</a>
+ </div>
+
+ <nav class="site-header-nav site-header-nav-secondary">
+ <a class="nav-item" href="/pricing">Pricing</a>
+ <a class="nav-item" href="/blog">Blog</a>
+ <a class="nav-item" href="https://help.github.com">Support</a>
+ <a class="nav-item header-search-link" href="https://github.com/search">Search GitHub</a>
+ <div class="header-search scoped-search site-scoped-search js-site-search" role="search">
+ <!-- </textarea> --><!-- '"` --><form accept-charset="UTF-8" action="/cpettitt/graphlib-dot/search" class="js-site-search-form" data-scoped-search-url="/cpettitt/graphlib-dot/search" data-unscoped-search-url="/search" method="get"><div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="✓" /></div>
+ <label class="form-control header-search-wrapper js-chromeless-input-container">
+ <div class="header-search-scope">This repository</div>
+ <input type="text"
+ class="form-control header-search-input js-site-search-focus js-site-search-field is-clearable"
+ data-hotkey="s"
+ name="q"
+ placeholder="Search"
+ aria-label="Search this repository"
+ data-unscoped-placeholder="Search GitHub"
+ data-scoped-placeholder="Search"
+ tabindex="1"
+ autocapitalize="off">
+ </label>
+</form></div>
+
+ </nav>
+ </div>
+ </div>
+</header>
+
+
+
+ <div id="start-of-content" class="accessibility-aid"></div>
+
+ <div id="js-flash-container">
+</div>
+
+
+ <div role="main" class="main-content">
+ <div itemscope itemtype="http://schema.org/SoftwareSourceCode">
+ <div id="js-repo-pjax-container" data-pjax-container>
+
+<div class="pagehead repohead instapaper_ignore readability-menu experiment-repo-nav">
+ <div class="container repohead-details-container">
+
+
+
+<ul class="pagehead-actions">
+
+ <li>
+ <a href="/login?return_to=%2Fcpettitt%2Fgraphlib-dot"
+ class="btn btn-sm btn-with-count tooltipped tooltipped-n"
+ aria-label="You must be signed in to watch a repository" rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-eye" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path d="M8.06 2C3 2 0 8 0 8s3 6 8.06 6C13 14 16 8 16 8s-3-6-7.94-6zM8 12c-2.2 0-4-1.78-4-4 0-2.2 1.8-4 4-4 2.22 0 4 1.8 4 4 0 2.22-1.78 4-4 4zm2-4c0 1.11-.89 2-2 2-1.11 0-2-.89-2-2 0-1.11.89-2 2-2 1.11 0 2 .89 2 2z"></path></svg>
+ Watch
+ </a>
+ <a class="social-count" href="/cpettitt/graphlib-dot/watchers">
+ 12
+ </a>
+
+ </li>
+
+ <li>
+ <a href="/login?return_to=%2Fcpettitt%2Fgraphlib-dot"
+ class="btn btn-sm btn-with-count tooltipped tooltipped-n"
+ aria-label="You must be signed in to star a repository" rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-star" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path d="M14 6l-4.9-.64L7 1 4.9 5.36 0 6l3.6 3.26L2.67 14 7 11.67 11.33 14l-.93-4.74z"></path></svg>
+ Star
+ </a>
+
+ <a class="social-count js-social-count" href="/cpettitt/graphlib-dot/stargazers">
+ 80
+ </a>
+
+ </li>
+
+ <li>
+ <a href="/login?return_to=%2Fcpettitt%2Fgraphlib-dot"
+ class="btn btn-sm btn-with-count tooltipped tooltipped-n"
+ aria-label="You must be signed in to fork a repository" rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-repo-forked" height="16" version="1.1" viewBox="0 0 10 16" width="10"><path d="M8 1a1.993 1.993 0 0 0-1 3.72V6L5 8 3 6V4.72A1.993 1.993 0 0 0 2 1a1.993 1.993 0 0 0-1 3.72V6.5l3 3v1.78A1.993 1.993 0 0 0 5 15a1.993 1.993 0 0 0 1-3.72V9.5l3-3V4.72A1.993 1.993 0 0 0 8 1zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3 10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 [...]
+ Fork
+ </a>
+
+ <a href="/cpettitt/graphlib-dot/network" class="social-count">
+ 12
+ </a>
+ </li>
+</ul>
+
+ <h1 class="public ">
+ <svg aria-hidden="true" class="octicon octicon-repo" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M4 9H3V8h1v1zm0-3H3v1h1V6zm0-2H3v1h1V4zm0-2H3v1h1V2zm8-1v12c0 .55-.45 1-1 1H6v2l-1.5-1.5L3 16v-2H1c-.55 0-1-.45-1-1V1c0-.55.45-1 1-1h10c.55 0 1 .45 1 1zm-1 10H1v2h2v-1h3v1h5v-2zm0-10H2v9h9V1z"></path></svg>
+ <span class="author" itemprop="author"><a href="/cpettitt" class="url fn" rel="author">cpettitt</a></span><!--
+--><span class="path-divider">/</span><!--
+--><strong itemprop="name"><a href="/cpettitt/graphlib-dot" data-pjax="#js-repo-pjax-container">graphlib-dot</a></strong>
+
+</h1>
+
+ </div>
+ <div class="container">
+
+<nav class="reponav js-repo-nav js-sidenav-container-pjax"
+ itemscope
+ itemtype="http://schema.org/BreadcrumbList"
+ role="navigation"
+ data-pjax="#js-repo-pjax-container">
+
+ <span itemscope itemtype="http://schema.org/ListItem" itemprop="itemListElement">
+ <a href="/cpettitt/graphlib-dot" aria-selected="true" class="js-selected-navigation-item selected reponav-item" data-hotkey="g c" data-selected-links="repo_source repo_downloads repo_commits repo_releases repo_tags repo_branches /cpettitt/graphlib-dot" itemprop="url">
+ <svg aria-hidden="true" class="octicon octicon-code" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path d="M9.5 3L8 4.5 11.5 8 8 11.5 9.5 13 14 8 9.5 3zm-5 0L0 8l4.5 5L6 11.5 2.5 8 6 4.5 4.5 3z"></path></svg>
+ <span itemprop="name">Code</span>
+ <meta itemprop="position" content="1">
+</a> </span>
+
+ <span itemscope itemtype="http://schema.org/ListItem" itemprop="itemListElement">
+ <a href="/cpettitt/graphlib-dot/issues" class="js-selected-navigation-item reponav-item" data-hotkey="g i" data-selected-links="repo_issues repo_labels repo_milestones /cpettitt/graphlib-dot/issues" itemprop="url">
+ <svg aria-hidden="true" class="octicon octicon-issue-opened" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path d="M7 2.3c3.14 0 5.7 2.56 5.7 5.7s-2.56 5.7-5.7 5.7A5.71 5.71 0 0 1 1.3 8c0-3.14 2.56-5.7 5.7-5.7zM7 1C3.14 1 0 4.14 0 8s3.14 7 7 7 7-3.14 7-7-3.14-7-7-7zm1 3H6v5h2V4zm0 6H6v2h2v-2z"></path></svg>
+ <span itemprop="name">Issues</span>
+ <span class="counter">6</span>
+ <meta itemprop="position" content="2">
+</a> </span>
+
+ <span itemscope itemtype="http://schema.org/ListItem" itemprop="itemListElement">
+ <a href="/cpettitt/graphlib-dot/pulls" class="js-selected-navigation-item reponav-item" data-hotkey="g p" data-selected-links="repo_pulls /cpettitt/graphlib-dot/pulls" itemprop="url">
+ <svg aria-hidden="true" class="octicon octicon-git-pull-request" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M11 11.28V5c-.03-.78-.34-1.47-.94-2.06C9.46 2.35 8.78 2.03 8 2H7V0L4 3l3 3V4h1c.27.02.48.11.69.31.21.2.3.42.31.69v6.28A1.993 1.993 0 0 0 10 15a1.993 1.993 0 0 0 1-3.72zm-1 2.92c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zM4 3c0-1.11-.89-2-2-2a1.993 1.993 0 0 0-1 3.72v6.56A1.993 1.993 0 0 0 2 15a1.993 1.993 0 0 0 [...]
+ <span itemprop="name">Pull requests</span>
+ <span class="counter">1</span>
+ <meta itemprop="position" content="3">
+</a> </span>
+
+ <a href="/cpettitt/graphlib-dot/wiki" class="js-selected-navigation-item reponav-item" data-hotkey="g w" data-selected-links="repo_wiki /cpettitt/graphlib-dot/wiki">
+ <svg aria-hidden="true" class="octicon octicon-book" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path d="M3 5h4v1H3V5zm0 3h4V7H3v1zm0 2h4V9H3v1zm11-5h-4v1h4V5zm0 2h-4v1h4V7zm0 2h-4v1h4V9zm2-6v9c0 .55-.45 1-1 1H9.5l-1 1-1-1H2c-.55 0-1-.45-1-1V3c0-.55.45-1 1-1h5.5l1 1 1-1H15c.55 0 1 .45 1 1zm-8 .5L7.5 3H2v9h6V3.5zm7-.5H9.5l-.5.5V12h6V3z"></path></svg>
+ Wiki
+</a>
+
+ <a href="/cpettitt/graphlib-dot/pulse" class="js-selected-navigation-item reponav-item" data-selected-links="pulse /cpettitt/graphlib-dot/pulse">
+ <svg aria-hidden="true" class="octicon octicon-pulse" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path d="M11.5 8L8.8 5.4 6.6 8.5 5.5 1.6 2.38 8H0v2h3.6l.9-1.8.9 5.4L9 8.5l1.6 1.5H14V8z"></path></svg>
+ Pulse
+</a>
+ <a href="/cpettitt/graphlib-dot/graphs" class="js-selected-navigation-item reponav-item" data-selected-links="repo_graphs repo_contributors /cpettitt/graphlib-dot/graphs">
+ <svg aria-hidden="true" class="octicon octicon-graph" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path d="M16 14v1H0V0h1v14h15zM5 13H3V8h2v5zm4 0H7V3h2v10zm4 0h-2V6h2v7z"></path></svg>
+ Graphs
+</a>
+
+</nav>
+
+ </div>
+</div>
+
+<div class="container new-discussion-timeline experiment-repo-nav">
+ <div class="repository-content">
+
+
+
+<a href="/cpettitt/graphlib-dot/blob/4d244e4bdbbce22a1211b91c39122646eeb41944/dist/graphlib-dot.js" class="hidden js-permalink-shortcut" data-hotkey="y">Permalink</a>
+
+<!-- blob contrib key: blob_contributors:v21:f9985201d5775468f72790312defd15f -->
+
+<div class="file-navigation js-zeroclipboard-container">
+
+<div class="select-menu branch-select-menu js-menu-container js-select-menu left">
+ <button class="btn btn-sm select-menu-button js-menu-target css-truncate" data-hotkey="w"
+ title="master"
+ type="button" aria-label="Switch branches or tags" tabindex="0" aria-haspopup="true">
+ <i>Branch:</i>
+ <span class="js-select-button css-truncate-target">master</span>
+ </button>
+
+ <div class="select-menu-modal-holder js-menu-content js-navigation-container" data-pjax aria-hidden="true">
+
+ <div class="select-menu-modal">
+ <div class="select-menu-header">
+ <svg aria-label="Close" class="octicon octicon-x js-menu-close" height="16" role="img" version="1.1" viewBox="0 0 12 16" width="12"><path d="M7.48 8l3.75 3.75-1.48 1.48L6 9.48l-3.75 3.75-1.48-1.48L4.52 8 .77 4.25l1.48-1.48L6 6.52l3.75-3.75 1.48 1.48z"></path></svg>
+ <span class="select-menu-title">Switch branches/tags</span>
+ </div>
+
+ <div class="select-menu-filters">
+ <div class="select-menu-text-filter">
+ <input type="text" aria-label="Filter branches/tags" id="context-commitish-filter-field" class="form-control js-filterable-field js-navigation-enable" placeholder="Filter branches/tags">
+ </div>
+ <div class="select-menu-tabs">
+ <ul>
+ <li class="select-menu-tab">
+ <a href="#" data-tab-filter="branches" data-filter-placeholder="Filter branches/tags" class="js-select-menu-tab" role="tab">Branches</a>
+ </li>
+ <li class="select-menu-tab">
+ <a href="#" data-tab-filter="tags" data-filter-placeholder="Find a tag…" class="js-select-menu-tab" role="tab">Tags</a>
+ </li>
+ </ul>
+ </div>
+ </div>
+
+ <div class="select-menu-list select-menu-tab-bucket js-select-menu-tab-bucket" data-tab-filter="branches" role="menu">
+
+ <div data-filterable-for="context-commitish-filter-field" data-filterable-type="substring">
+
+
+ <a class="select-menu-item js-navigation-item js-navigation-open selected"
+ href="/cpettitt/graphlib-dot/blob/master/dist/graphlib-dot.js"
+ data-name="master"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target js-select-menu-filter-text" title="master">
+ master
+ </span>
+ </a>
+ </div>
+
+ <div class="select-menu-no-results">Nothing to show</div>
+ </div>
+
+ <div class="select-menu-list select-menu-tab-bucket js-select-menu-tab-bucket" data-tab-filter="tags">
+ <div data-filterable-for="context-commitish-filter-field" data-filterable-type="substring">
+
+
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.6.2/dist/graphlib-dot.js"
+ data-name="v0.6.2"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.6.2">
+ v0.6.2
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.6.1/dist/graphlib-dot.js"
+ data-name="v0.6.1"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.6.1">
+ v0.6.1
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.6.0/dist/graphlib-dot.js"
+ data-name="v0.6.0"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.6.0">
+ v0.6.0
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.5.2/dist/graphlib-dot.js"
+ data-name="v0.5.2"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.5.2">
+ v0.5.2
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.5.1/dist/graphlib-dot.js"
+ data-name="v0.5.1"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.5.1">
+ v0.5.1
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.5.0/dist/graphlib-dot.js"
+ data-name="v0.5.0"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.5.0">
+ v0.5.0
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.10/dist/graphlib-dot.js"
+ data-name="v0.4.10"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.10">
+ v0.4.10
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.9/dist/graphlib-dot.js"
+ data-name="v0.4.9"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.9">
+ v0.4.9
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.8/dist/graphlib-dot.js"
+ data-name="v0.4.8"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.8">
+ v0.4.8
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.7/dist/graphlib-dot.js"
+ data-name="v0.4.7"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.7">
+ v0.4.7
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.6/dist/graphlib-dot.js"
+ data-name="v0.4.6"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.6">
+ v0.4.6
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.5/dist/graphlib-dot.js"
+ data-name="v0.4.5"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.5">
+ v0.4.5
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.4/dist/graphlib-dot.js"
+ data-name="v0.4.4"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.4">
+ v0.4.4
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.3/dist/graphlib-dot.js"
+ data-name="v0.4.3"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.3">
+ v0.4.3
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.2/dist/graphlib-dot.js"
+ data-name="v0.4.2"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.2">
+ v0.4.2
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.1/dist/graphlib-dot.js"
+ data-name="v0.4.1"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.1">
+ v0.4.1
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.4.0/dist/graphlib-dot.js"
+ data-name="v0.4.0"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.4.0">
+ v0.4.0
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.3.0/dist/graphlib-dot.js"
+ data-name="v0.3.0"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.3.0">
+ v0.3.0
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.2.0/dist/graphlib-dot.js"
+ data-name="v0.2.0"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.2.0">
+ v0.2.0
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.1.0/dist/graphlib-dot.js"
+ data-name="v0.1.0"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.1.0">
+ v0.1.0
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.0.4/dist/graphlib-dot.js"
+ data-name="v0.0.4"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.0.4">
+ v0.0.4
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.0.3/dist/graphlib-dot.js"
+ data-name="v0.0.3"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.0.3">
+ v0.0.3
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.0.2/dist/graphlib-dot.js"
+ data-name="v0.0.2"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.0.2">
+ v0.0.2
+ </span>
+ </a>
+ <a class="select-menu-item js-navigation-item js-navigation-open "
+ href="/cpettitt/graphlib-dot/tree/v0.0.1/dist/graphlib-dot.js"
+ data-name="v0.0.1"
+ data-skip-pjax="true"
+ rel="nofollow">
+ <svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"></path></svg>
+ <span class="select-menu-item-text css-truncate-target" title="v0.0.1">
+ v0.0.1
+ </span>
+ </a>
+ </div>
+
+ <div class="select-menu-no-results">Nothing to show</div>
+ </div>
+
+ </div>
+ </div>
+</div>
+
+ <div class="btn-group right">
+ <a href="/cpettitt/graphlib-dot/find/master"
+ class="js-pjax-capture-input btn btn-sm"
+ data-pjax
+ data-hotkey="t">
+ Find file
+ </a>
+ <button aria-label="Copy file path to clipboard" class="js-zeroclipboard btn btn-sm zeroclipboard-button tooltipped tooltipped-s" data-copied-hint="Copied!" type="button">Copy path</button>
+ </div>
+ <div class="breadcrumb js-zeroclipboard-target">
+ <span class="repo-root js-repo-root"><span class="js-path-segment"><a href="/cpettitt/graphlib-dot"><span>graphlib-dot</span></a></span></span><span class="separator">/</span><span class="js-path-segment"><a href="/cpettitt/graphlib-dot/tree/master/dist"><span>dist</span></a></span><span class="separator">/</span><strong class="final-path">graphlib-dot.js</strong>
+ </div>
+</div>
+
+
+ <div class="commit-tease">
+ <span class="right">
+ <a class="commit-tease-sha" href="/cpettitt/graphlib-dot/commit/b3192e8af635ca013f72929a309404a51515da63" data-pjax>
+ b3192e8
+ </a>
+ <relative-time datetime="2015-07-28T02:21:42Z">Jul 27, 2015</relative-time>
+ </span>
+ <div>
+ <img alt="@cpettitt" class="avatar" height="20" src="https://avatars2.githubusercontent.com/u/11766?v=3&s=40" width="20" />
+ <a href="/cpettitt" class="user-mention" rel="author">cpettitt</a>
+ <a href="/cpettitt/graphlib-dot/commit/b3192e8af635ca013f72929a309404a51515da63" class="message" data-pjax="true" title="Prep v0.6.2 release">Prep v0.6.2 release</a>
+ </div>
+
+ <div class="commit-tease-contributors">
+ <button type="button" class="btn-link muted-link contributors-toggle" data-facebox="#blob_contributors_box">
+ <strong>1</strong>
+ contributor
+ </button>
+
+ </div>
+
+ <div id="blob_contributors_box" style="display:none">
+ <h2 class="facebox-header" data-facebox-id="facebox-header">Users who have contributed to this file</h2>
+ <ul class="facebox-user-list" data-facebox-id="facebox-description">
+ <li class="facebox-user-list-item">
+ <img alt="@cpettitt" height="24" src="https://avatars0.githubusercontent.com/u/11766?v=3&s=48" width="24" />
+ <a href="/cpettitt">cpettitt</a>
+ </li>
+ </ul>
+ </div>
+ </div>
+
+<div class="file">
+ <div class="file-header">
+ <div class="file-actions">
+
+ <div class="btn-group">
+ <a href="/cpettitt/graphlib-dot/raw/master/dist/graphlib-dot.js" class="btn btn-sm " id="raw-url">Raw</a>
+ <a href="/cpettitt/graphlib-dot/blame/master/dist/graphlib-dot.js" class="btn btn-sm js-update-url-with-hash">Blame</a>
+ <a href="/cpettitt/graphlib-dot/commits/master/dist/graphlib-dot.js" class="btn btn-sm " rel="nofollow">History</a>
+ </div>
+
+
+ <button type="button" class="btn-octicon disabled tooltipped tooltipped-nw"
+ aria-label="You must be signed in to make or propose changes">
+ <svg aria-hidden="true" class="octicon octicon-pencil" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path d="M0 12v3h3l8-8-3-3-8 8zm3 2H1v-2h1v1h1v1zm10.3-9.3L12 6 9 3l1.3-1.3a.996.996 0 0 1 1.41 0l1.59 1.59c.39.39.39 1.02 0 1.41z"></path></svg>
+ </button>
+ <button type="button" class="btn-octicon btn-octicon-danger disabled tooltipped tooltipped-nw"
+ aria-label="You must be signed in to make or propose changes">
+ <svg aria-hidden="true" class="octicon octicon-trashcan" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M11 2H9c0-.55-.45-1-1-1H5c-.55 0-1 .45-1 1H2c-.55 0-1 .45-1 1v1c0 .55.45 1 1 1v9c0 .55.45 1 1 1h7c.55 0 1-.45 1-1V5c.55 0 1-.45 1-1V3c0-.55-.45-1-1-1zm-1 12H3V5h1v8h1V5h1v8h1V5h1v8h1V5h1v9zm1-10H2V3h9v1z"></path></svg>
+ </button>
+ </div>
+
+ <div class="file-info">
+ 10702 lines (9922 sloc)
+ <span class="file-info-divider"></span>
+ 329 KB
+ </div>
+</div>
+
+
+
+ <div itemprop="text" class="blob-wrapper data type-javascript">
+ <table class="highlight tab-size js-file-line-container" data-tab-size="8">
+ <tr>
+ <td id="L1" class="blob-num js-line-number" data-line-number="1"></td>
+ <td id="LC1" class="blob-code blob-code-inner js-file-line">(<span class="pl-k">function</span> <span class="pl-en">e</span>(<span class="pl-smi">t</span>,<span class="pl-smi">n</span>,<span class="pl-smi">r</span>){<span class="pl-k">function</span> <span class="pl-en">s</span>(<span class="pl-smi">o</span>,<span class="pl-smi">u</span>){<span class="pl-k">if</span>(<span class="pl-k">!</span>n[o]){<span class="pl-k">if</span>(<span class="pl-k">!</span>t[o]){<span class="pl-k"> [...]
+ </tr>
+ <tr>
+ <td id="L2" class="blob-num js-line-number" data-line-number="2"></td>
+ <td id="LC2" class="blob-code blob-code-inner js-file-line">(<span class="pl-k">function</span> (<span class="pl-c1">global</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3" class="blob-num js-line-number" data-line-number="3"></td>
+ <td id="LC3" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/*</span></td>
+ </tr>
+ <tr>
+ <td id="L4" class="blob-num js-line-number" data-line-number="4"></td>
+ <td id="LC4" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Copyright (c) 2012-2013 Chris Pettitt</span></td>
+ </tr>
+ <tr>
+ <td id="L5" class="blob-num js-line-number" data-line-number="5"></td>
+ <td id="LC5" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6" class="blob-num js-line-number" data-line-number="6"></td>
+ <td id="LC6" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Permission is hereby granted, free of charge, to any person obtaining a copy</span></td>
+ </tr>
+ <tr>
+ <td id="L7" class="blob-num js-line-number" data-line-number="7"></td>
+ <td id="LC7" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of this software and associated documentation files (the "Software"), to deal</span></td>
+ </tr>
+ <tr>
+ <td id="L8" class="blob-num js-line-number" data-line-number="8"></td>
+ <td id="LC8" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * in the Software without restriction, including without limitation the rights</span></td>
+ </tr>
+ <tr>
+ <td id="L9" class="blob-num js-line-number" data-line-number="9"></td>
+ <td id="LC9" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell</span></td>
+ </tr>
+ <tr>
+ <td id="L10" class="blob-num js-line-number" data-line-number="10"></td>
+ <td id="LC10" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * copies of the Software, and to permit persons to whom the Software is</span></td>
+ </tr>
+ <tr>
+ <td id="L11" class="blob-num js-line-number" data-line-number="11"></td>
+ <td id="LC11" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * furnished to do so, subject to the following conditions:</span></td>
+ </tr>
+ <tr>
+ <td id="L12" class="blob-num js-line-number" data-line-number="12"></td>
+ <td id="LC12" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L13" class="blob-num js-line-number" data-line-number="13"></td>
+ <td id="LC13" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The above copyright notice and this permission notice shall be included in</span></td>
+ </tr>
+ <tr>
+ <td id="L14" class="blob-num js-line-number" data-line-number="14"></td>
+ <td id="LC14" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * all copies or substantial portions of the Software.</span></td>
+ </tr>
+ <tr>
+ <td id="L15" class="blob-num js-line-number" data-line-number="15"></td>
+ <td id="LC15" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L16" class="blob-num js-line-number" data-line-number="16"></td>
+ <td id="LC16" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR</span></td>
+ </tr>
+ <tr>
+ <td id="L17" class="blob-num js-line-number" data-line-number="17"></td>
+ <td id="LC17" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,</span></td>
+ </tr>
+ <tr>
+ <td id="L18" class="blob-num js-line-number" data-line-number="18"></td>
+ <td id="LC18" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE</span></td>
+ </tr>
+ <tr>
+ <td id="L19" class="blob-num js-line-number" data-line-number="19"></td>
+ <td id="LC19" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER</span></td>
+ </tr>
+ <tr>
+ <td id="L20" class="blob-num js-line-number" data-line-number="20"></td>
+ <td id="LC20" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,</span></td>
+ </tr>
+ <tr>
+ <td id="L21" class="blob-num js-line-number" data-line-number="21"></td>
+ <td id="LC21" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN</span></td>
+ </tr>
+ <tr>
+ <td id="L22" class="blob-num js-line-number" data-line-number="22"></td>
+ <td id="LC22" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * THE SOFTWARE.</span></td>
+ </tr>
+ <tr>
+ <td id="L23" class="blob-num js-line-number" data-line-number="23"></td>
+ <td id="LC23" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L24" class="blob-num js-line-number" data-line-number="24"></td>
+ <td id="LC24" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">global</span>.<span class="pl-smi">graphlibDot</span> <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./index<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L25" class="blob-num js-line-number" data-line-number="25"></td>
+ <td id="LC25" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L26" class="blob-num js-line-number" data-line-number="26"></td>
+ <td id="LC26" class="blob-code blob-code-inner js-file-line">}).<span class="pl-c1">call</span>(<span class="pl-v">this</span>,<span class="pl-k">typeof</span> <span class="pl-c1">global</span> <span class="pl-k">!==</span> <span class="pl-s"><span class="pl-pds">"</span>undefined<span class="pl-pds">"</span></span> <span class="pl-k">?</span> <span class="pl-c1">global</span> <span class="pl-k">:</span> <span class="pl-k">typeof</span> self <span class="pl-k">!==</span [...]
+ </tr>
+ <tr>
+ <td id="L27" class="blob-num js-line-number" data-line-number="27"></td>
+ <td id="LC27" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./index<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">2</span>}],<span class="pl-c1">2</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L28" class="blob-num js-line-number" data-line-number="28"></td>
+ <td id="LC28" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> read <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/read-one<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L29" class="blob-num js-line-number" data-line-number="29"></td>
+ <td id="LC29" class="blob-code blob-code-inner js-file-line"> readMany <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/read-many<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L30" class="blob-num js-line-number" data-line-number="30"></td>
+ <td id="LC30" class="blob-code blob-code-inner js-file-line"> write <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/write-one<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L31" class="blob-num js-line-number" data-line-number="31"></td>
+ <td id="LC31" class="blob-code blob-code-inner js-file-line"> version <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/version<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L32" class="blob-num js-line-number" data-line-number="32"></td>
+ <td id="LC32" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L33" class="blob-num js-line-number" data-line-number="33"></td>
+ <td id="LC33" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L34" class="blob-num js-line-number" data-line-number="34"></td>
+ <td id="LC34" class="blob-code blob-code-inner js-file-line"> graphlib<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/graphlib<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L35" class="blob-num js-line-number" data-line-number="35"></td>
+ <td id="LC35" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L36" class="blob-num js-line-number" data-line-number="36"></td>
+ <td id="LC36" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Parsing</span></td>
+ </tr>
+ <tr>
+ <td id="L37" class="blob-num js-line-number" data-line-number="37"></td>
+ <td id="LC37" class="blob-code blob-code-inner js-file-line"> read<span class="pl-k">:</span> read,</td>
+ </tr>
+ <tr>
+ <td id="L38" class="blob-num js-line-number" data-line-number="38"></td>
+ <td id="LC38" class="blob-code blob-code-inner js-file-line"> readMany<span class="pl-k">:</span> readMany,</td>
+ </tr>
+ <tr>
+ <td id="L39" class="blob-num js-line-number" data-line-number="39"></td>
+ <td id="LC39" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L40" class="blob-num js-line-number" data-line-number="40"></td>
+ <td id="LC40" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Writing</span></td>
+ </tr>
+ <tr>
+ <td id="L41" class="blob-num js-line-number" data-line-number="41"></td>
+ <td id="LC41" class="blob-code blob-code-inner js-file-line"> write<span class="pl-k">:</span> write,</td>
+ </tr>
+ <tr>
+ <td id="L42" class="blob-num js-line-number" data-line-number="42"></td>
+ <td id="LC42" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L43" class="blob-num js-line-number" data-line-number="43"></td>
+ <td id="LC43" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Version</span></td>
+ </tr>
+ <tr>
+ <td id="L44" class="blob-num js-line-number" data-line-number="44"></td>
+ <td id="LC44" class="blob-code blob-code-inner js-file-line"> version<span class="pl-k">:</span> version,</td>
+ </tr>
+ <tr>
+ <td id="L45" class="blob-num js-line-number" data-line-number="45"></td>
+ <td id="LC45" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L46" class="blob-num js-line-number" data-line-number="46"></td>
+ <td id="LC46" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// For levelup encoding</span></td>
+ </tr>
+ <tr>
+ <td id="L47" class="blob-num js-line-number" data-line-number="47"></td>
+ <td id="LC47" class="blob-code blob-code-inner js-file-line"> type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>dot<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L48" class="blob-num js-line-number" data-line-number="48"></td>
+ <td id="LC48" class="blob-code blob-code-inner js-file-line"> buffer<span class="pl-k">:</span> <span class="pl-c1">false</span></td>
+ </tr>
+ <tr>
+ <td id="L49" class="blob-num js-line-number" data-line-number="49"></td>
+ <td id="LC49" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L50" class="blob-num js-line-number" data-line-number="50"></td>
+ <td id="LC50" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L51" class="blob-num js-line-number" data-line-number="51"></td>
+ <td id="LC51" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./lib/graphlib<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">5</span>,<span class="pl-s"><span class="pl-pds">"</span>./lib/read-many<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">7</span>,<span class="pl-s"><span class="pl-pds">"</span>./lib/read-one<span class="pl-pds">&qu [...]
+ </tr>
+ <tr>
+ <td id="L52" class="blob-num js-line-number" data-line-number="52"></td>
+ <td id="LC52" class="blob-code blob-code-inner js-file-line"><span class="pl-s"><span class="pl-pds">"</span>use strict<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L53" class="blob-num js-line-number" data-line-number="53"></td>
+ <td id="LC53" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L54" class="blob-num js-line-number" data-line-number="54"></td>
+ <td id="LC54" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L55" class="blob-num js-line-number" data-line-number="55"></td>
+ <td id="LC55" class="blob-code blob-code-inner js-file-line"> Graph <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./graphlib<span class="pl-pds">"</span></span>).<span class="pl-smi">Graph</span>;</td>
+ </tr>
+ <tr>
+ <td id="L56" class="blob-num js-line-number" data-line-number="56"></td>
+ <td id="LC56" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L57" class="blob-num js-line-number" data-line-number="57"></td>
+ <td id="LC57" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> buildGraph;</td>
+ </tr>
+ <tr>
+ <td id="L58" class="blob-num js-line-number" data-line-number="58"></td>
+ <td id="LC58" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L59" class="blob-num js-line-number" data-line-number="59"></td>
+ <td id="LC59" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">buildGraph</span>(<span class="pl-smi">parseTree</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L60" class="blob-num js-line-number" data-line-number="60"></td>
+ <td id="LC60" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isDirected <span class="pl-k">=</span> <span class="pl-smi">parseTree</span>.<span class="pl-c1">type</span> <span class="pl-k">!==</span> <span class="pl-s"><span class="pl-pds">"</span>graph<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L61" class="blob-num js-line-number" data-line-number="61"></td>
+ <td id="LC61" class="blob-code blob-code-inner js-file-line"> isMultigraph <span class="pl-k">=</span> <span class="pl-k">!</span><span class="pl-smi">parseTree</span>.<span class="pl-smi">strict</span>,</td>
+ </tr>
+ <tr>
+ <td id="L62" class="blob-num js-line-number" data-line-number="62"></td>
+ <td id="LC62" class="blob-code blob-code-inner js-file-line"> defaultStack <span class="pl-k">=</span> [{ node<span class="pl-k">:</span> {}, edge<span class="pl-k">:</span> {} }],</td>
+ </tr>
+ <tr>
+ <td id="L63" class="blob-num js-line-number" data-line-number="63"></td>
+ <td id="LC63" class="blob-code blob-code-inner js-file-line"> id <span class="pl-k">=</span> <span class="pl-smi">parseTree</span>.<span class="pl-c1">id</span>,</td>
+ </tr>
+ <tr>
+ <td id="L64" class="blob-num js-line-number" data-line-number="64"></td>
+ <td id="LC64" class="blob-code blob-code-inner js-file-line"> g <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">Graph</span>({ directed<span class="pl-k">:</span> isDirected, multigraph<span class="pl-k">:</span> isMultigraph, compound<span class="pl-k">:</span> <span class="pl-c1">true</span> });</td>
+ </tr>
+ <tr>
+ <td id="L65" class="blob-num js-line-number" data-line-number="65"></td>
+ <td id="LC65" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setGraph</span>(id <span class="pl-k">===</span> <span class="pl-c1">null</span> <span class="pl-k">?</span> {} <span class="pl-k">:</span> {id<span class="pl-k">:</span> id});</td>
+ </tr>
+ <tr>
+ <td id="L66" class="blob-num js-line-number" data-line-number="66"></td>
+ <td id="LC66" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">parseTree</span>.<span class="pl-smi">stmts</span>, <span class="pl-k">function</span>(<span class="pl-smi">stmt</span>) { <span class="pl-en">handleStmt</span>(g, stmt, defaultStack); });</td>
+ </tr>
+ <tr>
+ <td id="L67" class="blob-num js-line-number" data-line-number="67"></td>
+ <td id="LC67" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> g;</td>
+ </tr>
+ <tr>
+ <td id="L68" class="blob-num js-line-number" data-line-number="68"></td>
+ <td id="LC68" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L69" class="blob-num js-line-number" data-line-number="69"></td>
+ <td id="LC69" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L70" class="blob-num js-line-number" data-line-number="70"></td>
+ <td id="LC70" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">handleStmt</span>(<span class="pl-smi">g</span>, <span class="pl-smi">stmt</span>, <span class="pl-smi">defaultStack</span>, <span class="pl-smi">sg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L71" class="blob-num js-line-number" data-line-number="71"></td>
+ <td id="LC71" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">switch</span>(<span class="pl-smi">stmt</span>.<span class="pl-c1">type</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L72" class="blob-num js-line-number" data-line-number="72"></td>
+ <td id="LC72" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-en">handleNodeStmt</span>(g, stmt, defaultStack, sg); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L73" class="blob-num js-line-number" data-line-number="73"></td>
+ <td id="LC73" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>edge<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-en">handleEdgeStmt</span>(g, stmt, defaultStack, sg); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L74" class="blob-num js-line-number" data-line-number="74"></td>
+ <td id="LC74" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>subgraph<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-en">handleSubgraphStmt</span>(g, stmt, defaultStack, sg); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L75" class="blob-num js-line-number" data-line-number="75"></td>
+ <td id="LC75" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>attr<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-en">handleAttrStmt</span>(g, stmt, defaultStack); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L76" class="blob-num js-line-number" data-line-number="76"></td>
+ <td id="LC76" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>inlineAttr<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-en">handleInlineAttrsStmt</span>(g, stmt, defaultStack, sg); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L77" class="blob-num js-line-number" data-line-number="77"></td>
+ <td id="LC77" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L78" class="blob-num js-line-number" data-line-number="78"></td>
+ <td id="LC78" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L79" class="blob-num js-line-number" data-line-number="79"></td>
+ <td id="LC79" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L80" class="blob-num js-line-number" data-line-number="80"></td>
+ <td id="LC80" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">handleNodeStmt</span>(<span class="pl-smi">g</span>, <span class="pl-smi">stmt</span>, <span class="pl-smi">defaultStack</span>, <span class="pl-smi">sg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L81" class="blob-num js-line-number" data-line-number="81"></td>
+ <td id="LC81" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> v <span class="pl-k">=</span> <span class="pl-smi">stmt</span>.<span class="pl-c1">id</span>,</td>
+ </tr>
+ <tr>
+ <td id="L82" class="blob-num js-line-number" data-line-number="82"></td>
+ <td id="LC82" class="blob-code blob-code-inner js-file-line"> attrs <span class="pl-k">=</span> <span class="pl-smi">stmt</span>.<span class="pl-smi">attrs</span>;</td>
+ </tr>
+ <tr>
+ <td id="L83" class="blob-num js-line-number" data-line-number="83"></td>
+ <td id="LC83" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">maybeCreateNode</span>(g, v, defaultStack, sg);</td>
+ </tr>
+ <tr>
+ <td id="L84" class="blob-num js-line-number" data-line-number="84"></td>
+ <td id="LC84" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">merge</span>(<span class="pl-smi">g</span>.<span class="pl-en">node</span>(v), attrs);</td>
+ </tr>
+ <tr>
+ <td id="L85" class="blob-num js-line-number" data-line-number="85"></td>
+ <td id="LC85" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L86" class="blob-num js-line-number" data-line-number="86"></td>
+ <td id="LC86" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L87" class="blob-num js-line-number" data-line-number="87"></td>
+ <td id="LC87" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">handleEdgeStmt</span>(<span class="pl-smi">g</span>, <span class="pl-smi">stmt</span>, <span class="pl-smi">defaultStack</span>, <span class="pl-smi">sg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L88" class="blob-num js-line-number" data-line-number="88"></td>
+ <td id="LC88" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> attrs <span class="pl-k">=</span> <span class="pl-smi">stmt</span>.<span class="pl-smi">attrs</span>,</td>
+ </tr>
+ <tr>
+ <td id="L89" class="blob-num js-line-number" data-line-number="89"></td>
+ <td id="LC89" class="blob-code blob-code-inner js-file-line"> prev, curr;</td>
+ </tr>
+ <tr>
+ <td id="L90" class="blob-num js-line-number" data-line-number="90"></td>
+ <td id="LC90" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">stmt</span>.<span class="pl-smi">elems</span>, <span class="pl-k">function</span>(<span class="pl-smi">elem</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L91" class="blob-num js-line-number" data-line-number="91"></td>
+ <td id="LC91" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">handleStmt</span>(g, elem, defaultStack, sg);</td>
+ </tr>
+ <tr>
+ <td id="L92" class="blob-num js-line-number" data-line-number="92"></td>
+ <td id="LC92" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L93" class="blob-num js-line-number" data-line-number="93"></td>
+ <td id="LC93" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">switch</span>(<span class="pl-smi">elem</span>.<span class="pl-c1">type</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L94" class="blob-num js-line-number" data-line-number="94"></td>
+ <td id="LC94" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span><span class="pl-k">:</span> curr <span class="pl-k">=</span> [<span class="pl-smi">elem</span>.<span class="pl-c1">id</span>]; <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L95" class="blob-num js-line-number" data-line-number="95"></td>
+ <td id="LC95" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>subgraph<span class="pl-pds">"</span></span><span class="pl-k">:</span> curr <span class="pl-k">=</span> <span class="pl-en">collectNodeIds</span>(elem); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L96" class="blob-num js-line-number" data-line-number="96"></td>
+ <td id="LC96" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L97" class="blob-num js-line-number" data-line-number="97"></td>
+ <td id="LC97" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L98" class="blob-num js-line-number" data-line-number="98"></td>
+ <td id="LC98" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(prev, <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L99" class="blob-num js-line-number" data-line-number="99"></td>
+ <td id="LC99" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(curr, <span class="pl-k">function</span>(<span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L100" class="blob-num js-line-number" data-line-number="100"></td>
+ <td id="LC100" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> name;</td>
+ </tr>
+ <tr>
+ <td id="L101" class="blob-num js-line-number" data-line-number="101"></td>
+ <td id="LC101" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">g</span>.<span class="pl-en">hasEdge</span>(v, w) <span class="pl-k">&&</span> <span class="pl-smi">g</span>.<span class="pl-en">isMultigraph</span>()) {</td>
+ </tr>
+ <tr>
+ <td id="L102" class="blob-num js-line-number" data-line-number="102"></td>
+ <td id="LC102" class="blob-code blob-code-inner js-file-line"> name <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">uniqueId</span>(<span class="pl-s"><span class="pl-pds">"</span>edge<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L103" class="blob-num js-line-number" data-line-number="103"></td>
+ <td id="LC103" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L104" class="blob-num js-line-number" data-line-number="104"></td>
+ <td id="LC104" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">hasEdge</span>(v, w, name)) {</td>
+ </tr>
+ <tr>
+ <td id="L105" class="blob-num js-line-number" data-line-number="105"></td>
+ <td id="LC105" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setEdge</span>(v, w, <span class="pl-smi">_</span>.<span class="pl-en">clone</span>(<span class="pl-smi">_</span>.<span class="pl-en">last</span>(defaultStack).<span class="pl-smi">edge</span>), name);</td>
+ </tr>
+ <tr>
+ <td id="L106" class="blob-num js-line-number" data-line-number="106"></td>
+ <td id="LC106" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L107" class="blob-num js-line-number" data-line-number="107"></td>
+ <td id="LC107" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">merge</span>(<span class="pl-smi">g</span>.<span class="pl-en">edge</span>(v, w, name), attrs);</td>
+ </tr>
+ <tr>
+ <td id="L108" class="blob-num js-line-number" data-line-number="108"></td>
+ <td id="LC108" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L109" class="blob-num js-line-number" data-line-number="109"></td>
+ <td id="LC109" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L110" class="blob-num js-line-number" data-line-number="110"></td>
+ <td id="LC110" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L111" class="blob-num js-line-number" data-line-number="111"></td>
+ <td id="LC111" class="blob-code blob-code-inner js-file-line"> prev <span class="pl-k">=</span> curr;</td>
+ </tr>
+ <tr>
+ <td id="L112" class="blob-num js-line-number" data-line-number="112"></td>
+ <td id="LC112" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L113" class="blob-num js-line-number" data-line-number="113"></td>
+ <td id="LC113" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L114" class="blob-num js-line-number" data-line-number="114"></td>
+ <td id="LC114" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L115" class="blob-num js-line-number" data-line-number="115"></td>
+ <td id="LC115" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">handleSubgraphStmt</span>(<span class="pl-smi">g</span>, <span class="pl-smi">stmt</span>, <span class="pl-smi">defaultStack</span>, <span class="pl-smi">sg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L116" class="blob-num js-line-number" data-line-number="116"></td>
+ <td id="LC116" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> id <span class="pl-k">=</span> <span class="pl-smi">stmt</span>.<span class="pl-c1">id</span>;</td>
+ </tr>
+ <tr>
+ <td id="L117" class="blob-num js-line-number" data-line-number="117"></td>
+ <td id="LC117" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (id <span class="pl-k">===</span> <span class="pl-c1">undefined</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L118" class="blob-num js-line-number" data-line-number="118"></td>
+ <td id="LC118" class="blob-code blob-code-inner js-file-line"> id <span class="pl-k">=</span> <span class="pl-en">generateSubgraphId</span>(g);</td>
+ </tr>
+ <tr>
+ <td id="L119" class="blob-num js-line-number" data-line-number="119"></td>
+ <td id="LC119" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L120" class="blob-num js-line-number" data-line-number="120"></td>
+ <td id="LC120" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L121" class="blob-num js-line-number" data-line-number="121"></td>
+ <td id="LC121" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">defaultStack</span>.<span class="pl-c1">push</span>(<span class="pl-smi">_</span>.<span class="pl-en">clone</span>(<span class="pl-smi">_</span>.<span class="pl-en">last</span>(defaultStack)));</td>
+ </tr>
+ <tr>
+ <td id="L122" class="blob-num js-line-number" data-line-number="122"></td>
+ <td id="LC122" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L123" class="blob-num js-line-number" data-line-number="123"></td>
+ <td id="LC123" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">maybeCreateNode</span>(g, id, defaultStack, sg);</td>
+ </tr>
+ <tr>
+ <td id="L124" class="blob-num js-line-number" data-line-number="124"></td>
+ <td id="LC124" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L125" class="blob-num js-line-number" data-line-number="125"></td>
+ <td id="LC125" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">stmt</span>.<span class="pl-smi">stmts</span>, <span class="pl-k">function</span>(<span class="pl-smi">s</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L126" class="blob-num js-line-number" data-line-number="126"></td>
+ <td id="LC126" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">handleStmt</span>(g, s, defaultStack, id);</td>
+ </tr>
+ <tr>
+ <td id="L127" class="blob-num js-line-number" data-line-number="127"></td>
+ <td id="LC127" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L128" class="blob-num js-line-number" data-line-number="128"></td>
+ <td id="LC128" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L129" class="blob-num js-line-number" data-line-number="129"></td>
+ <td id="LC129" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// If there are no statements remove the subgraph</span></td>
+ </tr>
+ <tr>
+ <td id="L130" class="blob-num js-line-number" data-line-number="130"></td>
+ <td id="LC130" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">children</span>(id).<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L131" class="blob-num js-line-number" data-line-number="131"></td>
+ <td id="LC131" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">removeNode</span>(id);</td>
+ </tr>
+ <tr>
+ <td id="L132" class="blob-num js-line-number" data-line-number="132"></td>
+ <td id="LC132" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L133" class="blob-num js-line-number" data-line-number="133"></td>
+ <td id="LC133" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L134" class="blob-num js-line-number" data-line-number="134"></td>
+ <td id="LC134" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">defaultStack</span>.<span class="pl-c1">pop</span>();</td>
+ </tr>
+ <tr>
+ <td id="L135" class="blob-num js-line-number" data-line-number="135"></td>
+ <td id="LC135" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L136" class="blob-num js-line-number" data-line-number="136"></td>
+ <td id="LC136" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L137" class="blob-num js-line-number" data-line-number="137"></td>
+ <td id="LC137" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">handleAttrStmt</span>(<span class="pl-smi">g</span>, <span class="pl-smi">stmt</span>, <span class="pl-smi">defaultStack</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L138" class="blob-num js-line-number" data-line-number="138"></td>
+ <td id="LC138" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">merge</span>(<span class="pl-smi">_</span>.<span class="pl-en">last</span>(defaultStack)[<span class="pl-smi">stmt</span>.<span class="pl-smi">attrType</span>], <span class="pl-smi">stmt</span>.<span class="pl-smi">attrs</span>);</td>
+ </tr>
+ <tr>
+ <td id="L139" class="blob-num js-line-number" data-line-number="139"></td>
+ <td id="LC139" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L140" class="blob-num js-line-number" data-line-number="140"></td>
+ <td id="LC140" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L141" class="blob-num js-line-number" data-line-number="141"></td>
+ <td id="LC141" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">handleInlineAttrsStmt</span>(<span class="pl-smi">g</span>, <span class="pl-smi">stmt</span>, <span class="pl-smi">defaultStack</span>, <span class="pl-smi">sg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L142" class="blob-num js-line-number" data-line-number="142"></td>
+ <td id="LC142" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">merge</span>(sg <span class="pl-k">?</span> <span class="pl-smi">g</span>.<span class="pl-en">node</span>(sg) <span class="pl-k">:</span> <span class="pl-smi">g</span>.<span class="pl-en">graph</span>(), <span class="pl-smi">stmt</span>.<span class="pl-smi">attrs</span>);</td>
+ </tr>
+ <tr>
+ <td id="L143" class="blob-num js-line-number" data-line-number="143"></td>
+ <td id="LC143" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L144" class="blob-num js-line-number" data-line-number="144"></td>
+ <td id="LC144" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L145" class="blob-num js-line-number" data-line-number="145"></td>
+ <td id="LC145" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">generateSubgraphId</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L146" class="blob-num js-line-number" data-line-number="146"></td>
+ <td id="LC146" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> id;</td>
+ </tr>
+ <tr>
+ <td id="L147" class="blob-num js-line-number" data-line-number="147"></td>
+ <td id="LC147" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">do</span> {</td>
+ </tr>
+ <tr>
+ <td id="L148" class="blob-num js-line-number" data-line-number="148"></td>
+ <td id="LC148" class="blob-code blob-code-inner js-file-line"> id <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">uniqueId</span>(<span class="pl-s"><span class="pl-pds">"</span>sg<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L149" class="blob-num js-line-number" data-line-number="149"></td>
+ <td id="LC149" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">while</span> (<span class="pl-smi">g</span>.<span class="pl-en">hasNode</span>(id));</td>
+ </tr>
+ <tr>
+ <td id="L150" class="blob-num js-line-number" data-line-number="150"></td>
+ <td id="LC150" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> id;</td>
+ </tr>
+ <tr>
+ <td id="L151" class="blob-num js-line-number" data-line-number="151"></td>
+ <td id="LC151" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L152" class="blob-num js-line-number" data-line-number="152"></td>
+ <td id="LC152" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L153" class="blob-num js-line-number" data-line-number="153"></td>
+ <td id="LC153" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">maybeCreateNode</span>(<span class="pl-smi">g</span>, <span class="pl-smi">v</span>, <span class="pl-smi">defaultStack</span>, <span class="pl-smi">sg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L154" class="blob-num js-line-number" data-line-number="154"></td>
+ <td id="LC154" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">hasNode</span>(v)) {</td>
+ </tr>
+ <tr>
+ <td id="L155" class="blob-num js-line-number" data-line-number="155"></td>
+ <td id="LC155" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setNode</span>(v, <span class="pl-smi">_</span>.<span class="pl-en">clone</span>(<span class="pl-smi">_</span>.<span class="pl-en">last</span>(defaultStack).<span class="pl-smi">node</span>));</td>
+ </tr>
+ <tr>
+ <td id="L156" class="blob-num js-line-number" data-line-number="156"></td>
+ <td id="LC156" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setParent</span>(v, sg);</td>
+ </tr>
+ <tr>
+ <td id="L157" class="blob-num js-line-number" data-line-number="157"></td>
+ <td id="LC157" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L158" class="blob-num js-line-number" data-line-number="158"></td>
+ <td id="LC158" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L159" class="blob-num js-line-number" data-line-number="159"></td>
+ <td id="LC159" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L160" class="blob-num js-line-number" data-line-number="160"></td>
+ <td id="LC160" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// Collect all nodes involved in a subgraph statement</span></td>
+ </tr>
+ <tr>
+ <td id="L161" class="blob-num js-line-number" data-line-number="161"></td>
+ <td id="LC161" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">collectNodeIds</span>(<span class="pl-smi">stmt</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L162" class="blob-num js-line-number" data-line-number="162"></td>
+ <td id="LC162" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ids <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L163" class="blob-num js-line-number" data-line-number="163"></td>
+ <td id="LC163" class="blob-code blob-code-inner js-file-line"> stack <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L164" class="blob-num js-line-number" data-line-number="164"></td>
+ <td id="LC164" class="blob-code blob-code-inner js-file-line"> curr;</td>
+ </tr>
+ <tr>
+ <td id="L165" class="blob-num js-line-number" data-line-number="165"></td>
+ <td id="LC165" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L166" class="blob-num js-line-number" data-line-number="166"></td>
+ <td id="LC166" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> push <span class="pl-k">=</span> <span class="pl-smi">stack</span>.<span class="pl-smi">push</span>.<span class="pl-en">bind</span>(stack);</td>
+ </tr>
+ <tr>
+ <td id="L167" class="blob-num js-line-number" data-line-number="167"></td>
+ <td id="LC167" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L168" class="blob-num js-line-number" data-line-number="168"></td>
+ <td id="LC168" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">push</span>(stmt);</td>
+ </tr>
+ <tr>
+ <td id="L169" class="blob-num js-line-number" data-line-number="169"></td>
+ <td id="LC169" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span>(<span class="pl-smi">stack</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L170" class="blob-num js-line-number" data-line-number="170"></td>
+ <td id="LC170" class="blob-code blob-code-inner js-file-line"> curr <span class="pl-k">=</span> <span class="pl-smi">stack</span>.<span class="pl-c1">pop</span>();</td>
+ </tr>
+ <tr>
+ <td id="L171" class="blob-num js-line-number" data-line-number="171"></td>
+ <td id="LC171" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">switch</span>(<span class="pl-smi">curr</span>.<span class="pl-c1">type</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L172" class="blob-num js-line-number" data-line-number="172"></td>
+ <td id="LC172" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span><span class="pl-k">:</span> ids[<span class="pl-smi">curr</span>.<span class="pl-c1">id</span>] <span class="pl-k">=</span> <span class="pl-c1">true</span>; <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L173" class="blob-num js-line-number" data-line-number="173"></td>
+ <td id="LC173" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>edge<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">curr</span>.<span class="pl-smi">elems</span>, push); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L174" class="blob-num js-line-number" data-line-number="174"></td>
+ <td id="LC174" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-s"><span class="pl-pds">"</span>subgraph<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">curr</span>.<span class="pl-smi">stmts</span>, push); <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L175" class="blob-num js-line-number" data-line-number="175"></td>
+ <td id="LC175" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L176" class="blob-num js-line-number" data-line-number="176"></td>
+ <td id="LC176" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L177" class="blob-num js-line-number" data-line-number="177"></td>
+ <td id="LC177" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L178" class="blob-num js-line-number" data-line-number="178"></td>
+ <td id="LC178" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">keys</span>(ids);</td>
+ </tr>
+ <tr>
+ <td id="L179" class="blob-num js-line-number" data-line-number="179"></td>
+ <td id="LC179" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L180" class="blob-num js-line-number" data-line-number="180"></td>
+ <td id="LC180" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L181" class="blob-num js-line-number" data-line-number="181"></td>
+ <td id="LC181" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L182" class="blob-num js-line-number" data-line-number="182"></td>
+ <td id="LC182" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./graphlib<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">5</span>,<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">6</span>}],<span class="pl-c1">4</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span cl [...]
+ </tr>
+ <tr>
+ <td id="L183" class="blob-num js-line-number" data-line-number="183"></td>
+ <td id="LC183" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> (<span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L184" class="blob-num js-line-number" data-line-number="184"></td>
+ <td id="LC184" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*</span></td>
+ </tr>
+ <tr>
+ <td id="L185" class="blob-num js-line-number" data-line-number="185"></td>
+ <td id="LC185" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Generated by PEG.js 0.8.0.</span></td>
+ </tr>
+ <tr>
+ <td id="L186" class="blob-num js-line-number" data-line-number="186"></td>
+ <td id="LC186" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L187" class="blob-num js-line-number" data-line-number="187"></td>
+ <td id="LC187" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * http://pegjs.majda.cz/</span></td>
+ </tr>
+ <tr>
+ <td id="L188" class="blob-num js-line-number" data-line-number="188"></td>
+ <td id="LC188" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L189" class="blob-num js-line-number" data-line-number="189"></td>
+ <td id="LC189" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L190" class="blob-num js-line-number" data-line-number="190"></td>
+ <td id="LC190" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$subclass</span>(<span class="pl-smi">child</span>, <span class="pl-smi">parent</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L191" class="blob-num js-line-number" data-line-number="191"></td>
+ <td id="LC191" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">ctor</span>() { <span class="pl-v">this</span>.<span class="pl-c1">constructor</span> <span class="pl-k">=</span> child; }</td>
+ </tr>
+ <tr>
+ <td id="L192" class="blob-num js-line-number" data-line-number="192"></td>
+ <td id="LC192" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">ctor</span>.<span class="pl-c1">prototype</span> <span class="pl-k">=</span> <span class="pl-smi">parent</span>.<span class="pl-c1">prototype</span>;</td>
+ </tr>
+ <tr>
+ <td id="L193" class="blob-num js-line-number" data-line-number="193"></td>
+ <td id="LC193" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">child</span>.<span class="pl-c1">prototype</span> <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">ctor</span>();</td>
+ </tr>
+ <tr>
+ <td id="L194" class="blob-num js-line-number" data-line-number="194"></td>
+ <td id="LC194" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L195" class="blob-num js-line-number" data-line-number="195"></td>
+ <td id="LC195" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L196" class="blob-num js-line-number" data-line-number="196"></td>
+ <td id="LC196" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">SyntaxError</span>(<span class="pl-smi">message</span>, <span class="pl-smi">expected</span>, <span class="pl-smi">found</span>, <span class="pl-smi">offset</span>, <span class="pl-smi">line</span>, <span class="pl-smi">column</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L197" class="blob-num js-line-number" data-line-number="197"></td>
+ <td id="LC197" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">message</span> <span class="pl-k">=</span> message;</td>
+ </tr>
+ <tr>
+ <td id="L198" class="blob-num js-line-number" data-line-number="198"></td>
+ <td id="LC198" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">expected</span> <span class="pl-k">=</span> expected;</td>
+ </tr>
+ <tr>
+ <td id="L199" class="blob-num js-line-number" data-line-number="199"></td>
+ <td id="LC199" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">found</span> <span class="pl-k">=</span> found;</td>
+ </tr>
+ <tr>
+ <td id="L200" class="blob-num js-line-number" data-line-number="200"></td>
+ <td id="LC200" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">offset</span> <span class="pl-k">=</span> offset;</td>
+ </tr>
+ <tr>
+ <td id="L201" class="blob-num js-line-number" data-line-number="201"></td>
+ <td id="LC201" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">line</span> <span class="pl-k">=</span> line;</td>
+ </tr>
+ <tr>
+ <td id="L202" class="blob-num js-line-number" data-line-number="202"></td>
+ <td id="LC202" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">column</span> <span class="pl-k">=</span> column;</td>
+ </tr>
+ <tr>
+ <td id="L203" class="blob-num js-line-number" data-line-number="203"></td>
+ <td id="LC203" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L204" class="blob-num js-line-number" data-line-number="204"></td>
+ <td id="LC204" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-c1">name</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>SyntaxError<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L205" class="blob-num js-line-number" data-line-number="205"></td>
+ <td id="LC205" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L206" class="blob-num js-line-number" data-line-number="206"></td>
+ <td id="LC206" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L207" class="blob-num js-line-number" data-line-number="207"></td>
+ <td id="LC207" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$subclass</span>(SyntaxError, Error);</td>
+ </tr>
+ <tr>
+ <td id="L208" class="blob-num js-line-number" data-line-number="208"></td>
+ <td id="LC208" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L209" class="blob-num js-line-number" data-line-number="209"></td>
+ <td id="LC209" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">parse</span>(<span class="pl-smi">input</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L210" class="blob-num js-line-number" data-line-number="210"></td>
+ <td id="LC210" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> options <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span> <span class="pl-k">?</span> <span class="pl-v">arguments</span>[<span class="pl-c1">1</span>] <span class="pl-k">:</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L211" class="blob-num js-line-number" data-line-number="211"></td>
+ <td id="LC211" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L212" class="blob-num js-line-number" data-line-number="212"></td>
+ <td id="LC212" class="blob-code blob-code-inner js-file-line"> peg$<span class="pl-c1">FAILED</span> <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L213" class="blob-num js-line-number" data-line-number="213"></td>
+ <td id="LC213" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L214" class="blob-num js-line-number" data-line-number="214"></td>
+ <td id="LC214" class="blob-code blob-code-inner js-file-line"> peg$startRuleFunctions <span class="pl-k">=</span> { start<span class="pl-k">:</span> peg$parsestart, graphStmt<span class="pl-k">:</span> peg$parsegraphStmt },</td>
+ </tr>
+ <tr>
+ <td id="L215" class="blob-num js-line-number" data-line-number="215"></td>
+ <td id="LC215" class="blob-code blob-code-inner js-file-line"> peg$startRuleFunction <span class="pl-k">=</span> peg$parsestart,</td>
+ </tr>
+ <tr>
+ <td id="L216" class="blob-num js-line-number" data-line-number="216"></td>
+ <td id="LC216" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L217" class="blob-num js-line-number" data-line-number="217"></td>
+ <td id="LC217" class="blob-code blob-code-inner js-file-line"> peg$c0 <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L218" class="blob-num js-line-number" data-line-number="218"></td>
+ <td id="LC218" class="blob-code blob-code-inner js-file-line"> peg$c1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>,</td>
+ </tr>
+ <tr>
+ <td id="L219" class="blob-num js-line-number" data-line-number="219"></td>
+ <td id="LC219" class="blob-code blob-code-inner js-file-line"> peg$c2 <span class="pl-k">=</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L220" class="blob-num js-line-number" data-line-number="220"></td>
+ <td id="LC220" class="blob-code blob-code-inner js-file-line"> peg$c3 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>{<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L221" class="blob-num js-line-number" data-line-number="221"></td>
+ <td id="LC221" class="blob-code blob-code-inner js-file-line"> peg$c4 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>{<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce" [...]
+ </tr>
+ <tr>
+ <td id="L222" class="blob-num js-line-number" data-line-number="222"></td>
+ <td id="LC222" class="blob-code blob-code-inner js-file-line"> peg$c5 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>}<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L223" class="blob-num js-line-number" data-line-number="223"></td>
+ <td id="LC223" class="blob-code blob-code-inner js-file-line"> peg$c6 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>}<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce" [...]
+ </tr>
+ <tr>
+ <td id="L224" class="blob-num js-line-number" data-line-number="224"></td>
+ <td id="LC224" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c7</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">strict</span>, <span class="pl-smi">type</span>, <span class="pl-smi">id</span>, <span class="pl-smi">stmts</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L225" class="blob-num js-line-number" data-line-number="225"></td>
+ <td id="LC225" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> {type<span class="pl-k">:</span> type, id<span class="pl-k">:</span> id, strict<span class="pl-k">:</span> strict <span class="pl-k">!==</span> <span class="pl-c1">null</span>, stmts<span class="pl-k">:</span> stmts};</td>
+ </tr>
+ <tr>
+ <td id="L226" class="blob-num js-line-number" data-line-number="226"></td>
+ <td id="LC226" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L227" class="blob-num js-line-number" data-line-number="227"></td>
+ <td id="LC227" class="blob-code blob-code-inner js-file-line"> peg$c8 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>;<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L228" class="blob-num js-line-number" data-line-number="228"></td>
+ <td id="LC228" class="blob-code blob-code-inner js-file-line"> peg$c9 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>;<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce" [...]
+ </tr>
+ <tr>
+ <td id="L229" class="blob-num js-line-number" data-line-number="229"></td>
+ <td id="LC229" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c10</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">first</span>, <span class="pl-smi">rest</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L230" class="blob-num js-line-number" data-line-number="230"></td>
+ <td id="LC230" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> [first];</td>
+ </tr>
+ <tr>
+ <td id="L231" class="blob-num js-line-number" data-line-number="231"></td>
+ <td id="LC231" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (<span class="pl-k">var</span> i <span class="pl-k">=</span> <span class="pl-c1">0</span>; i <span class="pl-k"><</span> <span class="pl-smi">rest</span>.<span class="pl-c1">length</span>; <span class="pl-k">++</span>i) {</td>
+ </tr>
+ <tr>
+ <td id="L232" class="blob-num js-line-number" data-line-number="232"></td>
+ <td id="LC232" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(rest[i][<span class="pl-c1">1</span>]);</td>
+ </tr>
+ <tr>
+ <td id="L233" class="blob-num js-line-number" data-line-number="233"></td>
+ <td id="LC233" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L234" class="blob-num js-line-number" data-line-number="234"></td>
+ <td id="LC234" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L235" class="blob-num js-line-number" data-line-number="235"></td>
+ <td id="LC235" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L236" class="blob-num js-line-number" data-line-number="236"></td>
+ <td id="LC236" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c11</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">type</span>, <span class="pl-smi">attrs</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L237" class="blob-num js-line-number" data-line-number="237"></td>
+ <td id="LC237" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>attr<span class="pl-pds">"</span></span>, attrType<span class="pl-k">:</span> type, attrs<span class="pl-k">:</span> attrs <span class="pl-k">||</span> {}};</td>
+ </tr>
+ <tr>
+ <td id="L238" class="blob-num js-line-number" data-line-number="238"></td>
+ <td id="LC238" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L239" class="blob-num js-line-number" data-line-number="239"></td>
+ <td id="LC239" class="blob-code blob-code-inner js-file-line"> peg$c12 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>=<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L240" class="blob-num js-line-number" data-line-number="240"></td>
+ <td id="LC240" class="blob-code blob-code-inner js-file-line"> peg$c13 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>=<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L241" class="blob-num js-line-number" data-line-number="241"></td>
+ <td id="LC241" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c14</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">k</span>, <span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L242" class="blob-num js-line-number" data-line-number="242"></td>
+ <td id="LC242" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> attrs <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L243" class="blob-num js-line-number" data-line-number="243"></td>
+ <td id="LC243" class="blob-code blob-code-inner js-file-line"> attrs[k] <span class="pl-k">=</span> v;</td>
+ </tr>
+ <tr>
+ <td id="L244" class="blob-num js-line-number" data-line-number="244"></td>
+ <td id="LC244" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>inlineAttr<span class="pl-pds">"</span></span>, attrs<span class="pl-k">:</span> attrs };</td>
+ </tr>
+ <tr>
+ <td id="L245" class="blob-num js-line-number" data-line-number="245"></td>
+ <td id="LC245" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L246" class="blob-num js-line-number" data-line-number="246"></td>
+ <td id="LC246" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c15</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">id</span>, <span class="pl-smi">attrs</span>) { <span class="pl-k">return</span> {type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span>, id<span class="pl-k">:</span> id, attrs<span class="pl-k">:</span> attrs <span cl [...]
+ </tr>
+ <tr>
+ <td id="L247" class="blob-num js-line-number" data-line-number="247"></td>
+ <td id="LC247" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c16</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">lhs</span>, <span class="pl-smi">rhs</span>, <span class="pl-smi">attrs</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L248" class="blob-num js-line-number" data-line-number="248"></td>
+ <td id="LC248" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> elems <span class="pl-k">=</span> [lhs];</td>
+ </tr>
+ <tr>
+ <td id="L249" class="blob-num js-line-number" data-line-number="249"></td>
+ <td id="LC249" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (<span class="pl-k">var</span> i <span class="pl-k">=</span> <span class="pl-c1">0</span>; i <span class="pl-k"><</span> <span class="pl-smi">rhs</span>.<span class="pl-c1">length</span>; <span class="pl-k">++</span>i) {</td>
+ </tr>
+ <tr>
+ <td id="L250" class="blob-num js-line-number" data-line-number="250"></td>
+ <td id="LC250" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">elems</span>.<span class="pl-c1">push</span>(rhs[i]);</td>
+ </tr>
+ <tr>
+ <td id="L251" class="blob-num js-line-number" data-line-number="251"></td>
+ <td id="LC251" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L252" class="blob-num js-line-number" data-line-number="252"></td>
+ <td id="LC252" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>edge<span class="pl-pds">"</span></span>, elems<span class="pl-k">:</span> elems, attrs<span class="pl-k">:</span> attrs <span class="pl-k">||</span> {} };</td>
+ </tr>
+ <tr>
+ <td id="L253" class="blob-num js-line-number" data-line-number="253"></td>
+ <td id="LC253" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L254" class="blob-num js-line-number" data-line-number="254"></td>
+ <td id="LC254" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c17</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">id</span>, <span class="pl-smi">stmts</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L255" class="blob-num js-line-number" data-line-number="255"></td>
+ <td id="LC255" class="blob-code blob-code-inner js-file-line"> id <span class="pl-k">=</span> (id <span class="pl-k">&&</span> id[<span class="pl-c1">2</span>]) <span class="pl-k">||</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L256" class="blob-num js-line-number" data-line-number="256"></td>
+ <td id="LC256" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>subgraph<span class="pl-pds">"</span></span>, id<span class="pl-k">:</span> id[<span class="pl-c1">0</span>], stmts<span class="pl-k">:</span> stmts };</td>
+ </tr>
+ <tr>
+ <td id="L257" class="blob-num js-line-number" data-line-number="257"></td>
+ <td id="LC257" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L258" class="blob-num js-line-number" data-line-number="258"></td>
+ <td id="LC258" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c18</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">first</span>, <span class="pl-smi">rest</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L259" class="blob-num js-line-number" data-line-number="259"></td>
+ <td id="LC259" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> first;</td>
+ </tr>
+ <tr>
+ <td id="L260" class="blob-num js-line-number" data-line-number="260"></td>
+ <td id="LC260" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (<span class="pl-k">var</span> i <span class="pl-k">=</span> <span class="pl-c1">0</span>; i <span class="pl-k"><</span> <span class="pl-smi">rest</span>.<span class="pl-c1">length</span>; <span class="pl-k">++</span>i) {</td>
+ </tr>
+ <tr>
+ <td id="L261" class="blob-num js-line-number" data-line-number="261"></td>
+ <td id="LC261" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">merge</span>(result, rest[i][<span class="pl-c1">1</span>]);</td>
+ </tr>
+ <tr>
+ <td id="L262" class="blob-num js-line-number" data-line-number="262"></td>
+ <td id="LC262" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L263" class="blob-num js-line-number" data-line-number="263"></td>
+ <td id="LC263" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L264" class="blob-num js-line-number" data-line-number="264"></td>
+ <td id="LC264" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L265" class="blob-num js-line-number" data-line-number="265"></td>
+ <td id="LC265" class="blob-code blob-code-inner js-file-line"> peg$c19 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>[<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L266" class="blob-num js-line-number" data-line-number="266"></td>
+ <td id="LC266" class="blob-code blob-code-inner js-file-line"> peg$c20 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L267" class="blob-num js-line-number" data-line-number="267"></td>
+ <td id="LC267" class="blob-code blob-code-inner js-file-line"> peg$c21 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>]<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L268" class="blob-num js-line-number" data-line-number="268"></td>
+ <td id="LC268" class="blob-code blob-code-inner js-file-line"> peg$c22 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>]<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L269" class="blob-num js-line-number" data-line-number="269"></td>
+ <td id="LC269" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c23</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">aList</span>) { <span class="pl-k">return</span> aList; },</td>
+ </tr>
+ <tr>
+ <td id="L270" class="blob-num js-line-number" data-line-number="270"></td>
+ <td id="LC270" class="blob-code blob-code-inner js-file-line"> peg$c24 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>,<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L271" class="blob-num js-line-number" data-line-number="271"></td>
+ <td id="LC271" class="blob-code blob-code-inner js-file-line"> peg$c25 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>,<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L272" class="blob-num js-line-number" data-line-number="272"></td>
+ <td id="LC272" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c26</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">first</span>, <span class="pl-smi">rest</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L273" class="blob-num js-line-number" data-line-number="273"></td>
+ <td id="LC273" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> first;</td>
+ </tr>
+ <tr>
+ <td id="L274" class="blob-num js-line-number" data-line-number="274"></td>
+ <td id="LC274" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (<span class="pl-k">var</span> i <span class="pl-k">=</span> <span class="pl-c1">0</span>; i <span class="pl-k"><</span> <span class="pl-smi">rest</span>.<span class="pl-c1">length</span>; <span class="pl-k">++</span>i) {</td>
+ </tr>
+ <tr>
+ <td id="L275" class="blob-num js-line-number" data-line-number="275"></td>
+ <td id="LC275" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">merge</span>(result, rest[i][<span class="pl-c1">3</span>]);</td>
+ </tr>
+ <tr>
+ <td id="L276" class="blob-num js-line-number" data-line-number="276"></td>
+ <td id="LC276" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L277" class="blob-num js-line-number" data-line-number="277"></td>
+ <td id="LC277" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L278" class="blob-num js-line-number" data-line-number="278"></td>
+ <td id="LC278" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L279" class="blob-num js-line-number" data-line-number="279"></td>
+ <td id="LC279" class="blob-code blob-code-inner js-file-line"> peg$c27 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>--<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L280" class="blob-num js-line-number" data-line-number="280"></td>
+ <td id="LC280" class="blob-code blob-code-inner js-file-line"> peg$c28 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>--<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cc [...]
+ </tr>
+ <tr>
+ <td id="L281" class="blob-num js-line-number" data-line-number="281"></td>
+ <td id="LC281" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c29</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() { <span class="pl-k">return</span> directed; },</td>
+ </tr>
+ <tr>
+ <td id="L282" class="blob-num js-line-number" data-line-number="282"></td>
+ <td id="LC282" class="blob-code blob-code-inner js-file-line"> peg$c30 <span class="pl-k">=</span> <span class="pl-k">void</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L283" class="blob-num js-line-number" data-line-number="283"></td>
+ <td id="LC283" class="blob-code blob-code-inner js-file-line"> peg$c31 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>-><span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L284" class="blob-num js-line-number" data-line-number="284"></td>
+ <td id="LC284" class="blob-code blob-code-inner js-file-line"> peg$c32 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>-><span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl [...]
+ </tr>
+ <tr>
+ <td id="L285" class="blob-num js-line-number" data-line-number="285"></td>
+ <td id="LC285" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c33</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">rhs</span>, <span class="pl-smi">rest</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L286" class="blob-num js-line-number" data-line-number="286"></td>
+ <td id="LC286" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> [rhs];</td>
+ </tr>
+ <tr>
+ <td id="L287" class="blob-num js-line-number" data-line-number="287"></td>
+ <td id="LC287" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (rest) {</td>
+ </tr>
+ <tr>
+ <td id="L288" class="blob-num js-line-number" data-line-number="288"></td>
+ <td id="LC288" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (<span class="pl-k">var</span> i <span class="pl-k">=</span> <span class="pl-c1">0</span>; i <span class="pl-k"><</span> <span class="pl-smi">rest</span>.<span class="pl-c1">length</span>; <span class="pl-k">++</span>i) {</td>
+ </tr>
+ <tr>
+ <td id="L289" class="blob-num js-line-number" data-line-number="289"></td>
+ <td id="LC289" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(rest[i]);</td>
+ </tr>
+ <tr>
+ <td id="L290" class="blob-num js-line-number" data-line-number="290"></td>
+ <td id="LC290" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L291" class="blob-num js-line-number" data-line-number="291"></td>
+ <td id="LC291" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L292" class="blob-num js-line-number" data-line-number="292"></td>
+ <td id="LC292" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L293" class="blob-num js-line-number" data-line-number="293"></td>
+ <td id="LC293" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L294" class="blob-num js-line-number" data-line-number="294"></td>
+ <td id="LC294" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c34</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">k</span>, <span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L295" class="blob-num js-line-number" data-line-number="295"></td>
+ <td id="LC295" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L296" class="blob-num js-line-number" data-line-number="296"></td>
+ <td id="LC296" class="blob-code blob-code-inner js-file-line"> result[k] <span class="pl-k">=</span> v[<span class="pl-c1">3</span>];</td>
+ </tr>
+ <tr>
+ <td id="L297" class="blob-num js-line-number" data-line-number="297"></td>
+ <td id="LC297" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L298" class="blob-num js-line-number" data-line-number="298"></td>
+ <td id="LC298" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L299" class="blob-num js-line-number" data-line-number="299"></td>
+ <td id="LC299" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c35</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">id</span>) { <span class="pl-k">return</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span>, id<span class="pl-k">:</span> id, attrs<span class="pl-k">:</span> {} }; },</td>
+ </tr>
+ <tr>
+ <td id="L300" class="blob-num js-line-number" data-line-number="300"></td>
+ <td id="LC300" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c36</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">id</span>) { <span class="pl-k">return</span> id; },</td>
+ </tr>
+ <tr>
+ <td id="L301" class="blob-num js-line-number" data-line-number="301"></td>
+ <td id="LC301" class="blob-code blob-code-inner js-file-line"> peg$c37 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>:<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L302" class="blob-num js-line-number" data-line-number="302"></td>
+ <td id="LC302" class="blob-code blob-code-inner js-file-line"> peg$c38 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>:<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L303" class="blob-num js-line-number" data-line-number="303"></td>
+ <td id="LC303" class="blob-code blob-code-inner js-file-line"> peg$c39 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>ne<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L304" class="blob-num js-line-number" data-line-number="304"></td>
+ <td id="LC304" class="blob-code blob-code-inner js-file-line"> peg$c40 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>ne<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cc [...]
+ </tr>
+ <tr>
+ <td id="L305" class="blob-num js-line-number" data-line-number="305"></td>
+ <td id="LC305" class="blob-code blob-code-inner js-file-line"> peg$c41 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>se<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L306" class="blob-num js-line-number" data-line-number="306"></td>
+ <td id="LC306" class="blob-code blob-code-inner js-file-line"> peg$c42 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>se<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cc [...]
+ </tr>
+ <tr>
+ <td id="L307" class="blob-num js-line-number" data-line-number="307"></td>
+ <td id="LC307" class="blob-code blob-code-inner js-file-line"> peg$c43 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>sw<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L308" class="blob-num js-line-number" data-line-number="308"></td>
+ <td id="LC308" class="blob-code blob-code-inner js-file-line"> peg$c44 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>sw<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cc [...]
+ </tr>
+ <tr>
+ <td id="L309" class="blob-num js-line-number" data-line-number="309"></td>
+ <td id="LC309" class="blob-code blob-code-inner js-file-line"> peg$c45 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>nw<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L310" class="blob-num js-line-number" data-line-number="310"></td>
+ <td id="LC310" class="blob-code blob-code-inner js-file-line"> peg$c46 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>nw<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cc [...]
+ </tr>
+ <tr>
+ <td id="L311" class="blob-num js-line-number" data-line-number="311"></td>
+ <td id="LC311" class="blob-code blob-code-inner js-file-line"> peg$c47 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>n<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L312" class="blob-num js-line-number" data-line-number="312"></td>
+ <td id="LC312" class="blob-code blob-code-inner js-file-line"> peg$c48 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>n<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L313" class="blob-num js-line-number" data-line-number="313"></td>
+ <td id="LC313" class="blob-code blob-code-inner js-file-line"> peg$c49 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>e<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L314" class="blob-num js-line-number" data-line-number="314"></td>
+ <td id="LC314" class="blob-code blob-code-inner js-file-line"> peg$c50 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>e<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L315" class="blob-num js-line-number" data-line-number="315"></td>
+ <td id="LC315" class="blob-code blob-code-inner js-file-line"> peg$c51 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>s<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L316" class="blob-num js-line-number" data-line-number="316"></td>
+ <td id="LC316" class="blob-code blob-code-inner js-file-line"> peg$c52 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>s<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L317" class="blob-num js-line-number" data-line-number="317"></td>
+ <td id="LC317" class="blob-code blob-code-inner js-file-line"> peg$c53 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>w<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L318" class="blob-num js-line-number" data-line-number="318"></td>
+ <td id="LC318" class="blob-code blob-code-inner js-file-line"> peg$c54 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>w<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L319" class="blob-num js-line-number" data-line-number="319"></td>
+ <td id="LC319" class="blob-code blob-code-inner js-file-line"> peg$c55 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>c<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L320" class="blob-num js-line-number" data-line-number="320"></td>
+ <td id="LC320" class="blob-code blob-code-inner js-file-line"> peg$c56 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>c<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L321" class="blob-num js-line-number" data-line-number="321"></td>
+ <td id="LC321" class="blob-code blob-code-inner js-file-line"> peg$c57 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>_<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L322" class="blob-num js-line-number" data-line-number="322"></td>
+ <td id="LC322" class="blob-code blob-code-inner js-file-line"> peg$c58 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>_<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L323" class="blob-num js-line-number" data-line-number="323"></td>
+ <td id="LC323" class="blob-code blob-code-inner js-file-line"> peg$c59 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>other<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>identifier<span class="pl-pds">"</span></span> },</td>
+ </tr>
+ <tr>
+ <td id="L324" class="blob-num js-line-number" data-line-number="324"></td>
+ <td id="LC324" class="blob-code blob-code-inner js-file-line"> peg$c60 <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[<span class="pl-c1">a-zA-Z</span><span class="pl-cce">\u</span>020<span class="pl-c1">0-<span class="pl-cce">\u</span></span>0377_]</span><span class="pl-pds">/</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L325" class="blob-num js-line-number" data-line-number="325"></td>
+ <td id="LC325" class="blob-code blob-code-inner js-file-line"> peg$c61 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>class<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[a-zA-Z<span class="pl-cce">\\</span>u0200-<span class="pl-cce">\\</span>u0377_]<span class="pl-pds">"</span></span>, description<span class="pl-k">:</s [...]
+ </tr>
+ <tr>
+ <td id="L326" class="blob-num js-line-number" data-line-number="326"></td>
+ <td id="LC326" class="blob-code blob-code-inner js-file-line"> peg$c62 <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[<span class="pl-c1">a-zA-Z</span><span class="pl-cce">\u</span>020<span class="pl-c1">0-<span class="pl-cce">\u</span></span>0377_<span class="pl-c1">0-9</span>]</span><span class="pl-pds">/</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L327" class="blob-num js-line-number" data-line-number="327"></td>
+ <td id="LC327" class="blob-code blob-code-inner js-file-line"> peg$c63 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>class<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[a-zA-Z<span class="pl-cce">\\</span>u0200-<span class="pl-cce">\\</span>u0377_0-9]<span class="pl-pds">"</span></span>, description<span class="pl-k">: [...]
+ </tr>
+ <tr>
+ <td id="L328" class="blob-num js-line-number" data-line-number="328"></td>
+ <td id="LC328" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c64</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">fst</span>, <span class="pl-smi">rest</span>) { <span class="pl-k">return</span> fst <span class="pl-k">+</span> <span class="pl-smi">rest</span>.<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>); },</td>
+ </tr>
+ <tr>
+ <td id="L329" class="blob-num js-line-number" data-line-number="329"></td>
+ <td id="LC329" class="blob-code blob-code-inner js-file-line"> peg$c65 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>-<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L330" class="blob-num js-line-number" data-line-number="330"></td>
+ <td id="LC330" class="blob-code blob-code-inner js-file-line"> peg$c66 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>-<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L331" class="blob-num js-line-number" data-line-number="331"></td>
+ <td id="LC331" class="blob-code blob-code-inner js-file-line"> peg$c67 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>.<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L332" class="blob-num js-line-number" data-line-number="332"></td>
+ <td id="LC332" class="blob-code blob-code-inner js-file-line"> peg$c68 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>.<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce [...]
+ </tr>
+ <tr>
+ <td id="L333" class="blob-num js-line-number" data-line-number="333"></td>
+ <td id="LC333" class="blob-code blob-code-inner js-file-line"> peg$c69 <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[<span class="pl-c1">0-9</span>]</span><span class="pl-pds">/</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L334" class="blob-num js-line-number" data-line-number="334"></td>
+ <td id="LC334" class="blob-code blob-code-inner js-file-line"> peg$c70 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>class<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[0-9]<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[0-9]<span class= [...]
+ </tr>
+ <tr>
+ <td id="L335" class="blob-num js-line-number" data-line-number="335"></td>
+ <td id="LC335" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c71</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">sign</span>, <span class="pl-smi">dot</span>, <span class="pl-smi">after</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L336" class="blob-num js-line-number" data-line-number="336"></td>
+ <td id="LC336" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (sign <span class="pl-k">||</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>) <span class="pl-k">+</span> dot <span class="pl-k">+</span> <span class="pl-smi">after</span>.<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L337" class="blob-num js-line-number" data-line-number="337"></td>
+ <td id="LC337" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L338" class="blob-num js-line-number" data-line-number="338"></td>
+ <td id="LC338" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c72</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">sign</span>, <span class="pl-smi">before</span>, <span class="pl-smi">after</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L339" class="blob-num js-line-number" data-line-number="339"></td>
+ <td id="LC339" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (sign <span class="pl-k">||</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>) <span class="pl-k">+</span> <span class="pl-smi">before</span>.<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>) <span class="pl-k">+</span> (after <span class="pl-k" [...]
+ </tr>
+ <tr>
+ <td id="L340" class="blob-num js-line-number" data-line-number="340"></td>
+ <td id="LC340" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L341" class="blob-num js-line-number" data-line-number="341"></td>
+ <td id="LC341" class="blob-code blob-code-inner js-file-line"> peg$c73 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\"</span><span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L342" class="blob-num js-line-number" data-line-number="342"></td>
+ <td id="LC342" class="blob-code blob-code-inner js-file-line"> peg$c74 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\"</span><span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds [...]
+ </tr>
+ <tr>
+ <td id="L343" class="blob-num js-line-number" data-line-number="343"></td>
+ <td id="LC343" class="blob-code blob-code-inner js-file-line"> peg$c75 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\\\"</span><span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L344" class="blob-num js-line-number" data-line-number="344"></td>
+ <td id="LC344" class="blob-code blob-code-inner js-file-line"> peg$c76 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\\\"</span><span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-p [...]
+ </tr>
+ <tr>
+ <td id="L345" class="blob-num js-line-number" data-line-number="345"></td>
+ <td id="LC345" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c77</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() { <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">'</span>"<span class="pl-pds">'</span></span>; },</td>
+ </tr>
+ <tr>
+ <td id="L346" class="blob-num js-line-number" data-line-number="346"></td>
+ <td id="LC346" class="blob-code blob-code-inner js-file-line"> peg$c78 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\\</span><span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L347" class="blob-num js-line-number" data-line-number="347"></td>
+ <td id="LC347" class="blob-code blob-code-inner js-file-line"> peg$c79 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\\</span><span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">&qu [...]
+ </tr>
+ <tr>
+ <td id="L348" class="blob-num js-line-number" data-line-number="348"></td>
+ <td id="LC348" class="blob-code blob-code-inner js-file-line"> peg$c80 <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[<span class="pl-k">^</span>"]</span><span class="pl-pds">/</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L349" class="blob-num js-line-number" data-line-number="349"></td>
+ <td id="LC349" class="blob-code blob-code-inner js-file-line"> peg$c81 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>class<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[^<span class="pl-cce">\"</span>]<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pd [...]
+ </tr>
+ <tr>
+ <td id="L350" class="blob-num js-line-number" data-line-number="350"></td>
+ <td id="LC350" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c82</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">ch</span>) { <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\\</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> ch; },</td>
+ </tr>
+ <tr>
+ <td id="L351" class="blob-num js-line-number" data-line-number="351"></td>
+ <td id="LC351" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c83</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">id</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L352" class="blob-num js-line-number" data-line-number="352"></td>
+ <td id="LC352" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">id</span>.<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L353" class="blob-num js-line-number" data-line-number="353"></td>
+ <td id="LC353" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L354" class="blob-num js-line-number" data-line-number="354"></td>
+ <td id="LC354" class="blob-code blob-code-inner js-file-line"> peg$c84 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L355" class="blob-num js-line-number" data-line-number="355"></td>
+ <td id="LC355" class="blob-code blob-code-inner js-file-line"> peg$c85 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>node<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl- [...]
+ </tr>
+ <tr>
+ <td id="L356" class="blob-num js-line-number" data-line-number="356"></td>
+ <td id="LC356" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c86</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">k</span>) { <span class="pl-k">return</span> <span class="pl-smi">k</span>.<span class="pl-c1">toLowerCase</span>(); },</td>
+ </tr>
+ <tr>
+ <td id="L357" class="blob-num js-line-number" data-line-number="357"></td>
+ <td id="LC357" class="blob-code blob-code-inner js-file-line"> peg$c87 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>edge<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L358" class="blob-num js-line-number" data-line-number="358"></td>
+ <td id="LC358" class="blob-code blob-code-inner js-file-line"> peg$c88 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>edge<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl- [...]
+ </tr>
+ <tr>
+ <td id="L359" class="blob-num js-line-number" data-line-number="359"></td>
+ <td id="LC359" class="blob-code blob-code-inner js-file-line"> peg$c89 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>graph<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L360" class="blob-num js-line-number" data-line-number="360"></td>
+ <td id="LC360" class="blob-code blob-code-inner js-file-line"> peg$c90 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>graph<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl [...]
+ </tr>
+ <tr>
+ <td id="L361" class="blob-num js-line-number" data-line-number="361"></td>
+ <td id="LC361" class="blob-code blob-code-inner js-file-line"> peg$c91 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>digraph<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L362" class="blob-num js-line-number" data-line-number="362"></td>
+ <td id="LC362" class="blob-code blob-code-inner js-file-line"> peg$c92 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>digraph<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class=" [...]
+ </tr>
+ <tr>
+ <td id="L363" class="blob-num js-line-number" data-line-number="363"></td>
+ <td id="LC363" class="blob-code blob-code-inner js-file-line"> peg$c93 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>subgraph<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L364" class="blob-num js-line-number" data-line-number="364"></td>
+ <td id="LC364" class="blob-code blob-code-inner js-file-line"> peg$c94 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>subgraph<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class= [...]
+ </tr>
+ <tr>
+ <td id="L365" class="blob-num js-line-number" data-line-number="365"></td>
+ <td id="LC365" class="blob-code blob-code-inner js-file-line"> peg$c95 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>strict<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L366" class="blob-num js-line-number" data-line-number="366"></td>
+ <td id="LC366" class="blob-code blob-code-inner js-file-line"> peg$c96 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>strict<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="p [...]
+ </tr>
+ <tr>
+ <td id="L367" class="blob-num js-line-number" data-line-number="367"></td>
+ <td id="LC367" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$c97</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">graph</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L368" class="blob-num js-line-number" data-line-number="368"></td>
+ <td id="LC368" class="blob-code blob-code-inner js-file-line"> directed <span class="pl-k">=</span> graph <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span>digraph<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L369" class="blob-num js-line-number" data-line-number="369"></td>
+ <td id="LC369" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> graph;</td>
+ </tr>
+ <tr>
+ <td id="L370" class="blob-num js-line-number" data-line-number="370"></td>
+ <td id="LC370" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L371" class="blob-num js-line-number" data-line-number="371"></td>
+ <td id="LC371" class="blob-code blob-code-inner js-file-line"> peg$c98 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>other<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>whitespace<span class="pl-pds">"</span></span> },</td>
+ </tr>
+ <tr>
+ <td id="L372" class="blob-num js-line-number" data-line-number="372"></td>
+ <td id="LC372" class="blob-code blob-code-inner js-file-line"> peg$c99 <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[ <span class="pl-cce">\t\r\n</span>]</span><span class="pl-pds">/</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L373" class="blob-num js-line-number" data-line-number="373"></td>
+ <td id="LC373" class="blob-code blob-code-inner js-file-line"> peg$c100 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>class<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[ <span class="pl-cce">\\</span>t<span class="pl-cce">\\</span>r<span class="pl-cce">\\</span>n]<span class="pl-pds">"</span></span>, description<span [...]
+ </tr>
+ <tr>
+ <td id="L374" class="blob-num js-line-number" data-line-number="374"></td>
+ <td id="LC374" class="blob-code blob-code-inner js-file-line"> peg$c101 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>other<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>comment<span class="pl-pds">"</span></span> },</td>
+ </tr>
+ <tr>
+ <td id="L375" class="blob-num js-line-number" data-line-number="375"></td>
+ <td id="LC375" class="blob-code blob-code-inner js-file-line"> peg$c102 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>//<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L376" class="blob-num js-line-number" data-line-number="376"></td>
+ <td id="LC376" class="blob-code blob-code-inner js-file-line"> peg$c103 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>//<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-c [...]
+ </tr>
+ <tr>
+ <td id="L377" class="blob-num js-line-number" data-line-number="377"></td>
+ <td id="LC377" class="blob-code blob-code-inner js-file-line"> peg$c104 <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[<span class="pl-k">^</span><span class="pl-cce">\n</span>]</span><span class="pl-pds">/</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L378" class="blob-num js-line-number" data-line-number="378"></td>
+ <td id="LC378" class="blob-code blob-code-inner js-file-line"> peg$c105 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>class<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>[^<span class="pl-cce">\\</span>n]<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds"> [...]
+ </tr>
+ <tr>
+ <td id="L379" class="blob-num js-line-number" data-line-number="379"></td>
+ <td id="LC379" class="blob-code blob-code-inner js-file-line"> peg$c106 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>/*<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L380" class="blob-num js-line-number" data-line-number="380"></td>
+ <td id="LC380" class="blob-code blob-code-inner js-file-line"> peg$c107 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>/*<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-c [...]
+ </tr>
+ <tr>
+ <td id="L381" class="blob-num js-line-number" data-line-number="381"></td>
+ <td id="LC381" class="blob-code blob-code-inner js-file-line"> peg$c108 <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>*/<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L382" class="blob-num js-line-number" data-line-number="382"></td>
+ <td id="LC382" class="blob-code blob-code-inner js-file-line"> peg$c109 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>literal<span class="pl-pds">"</span></span>, value<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>*/<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-c [...]
+ </tr>
+ <tr>
+ <td id="L383" class="blob-num js-line-number" data-line-number="383"></td>
+ <td id="LC383" class="blob-code blob-code-inner js-file-line"> peg$c110 <span class="pl-k">=</span> { type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>any<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>any character<span class="pl-pds">"</span></span> },</td>
+ </tr>
+ <tr>
+ <td id="L384" class="blob-num js-line-number" data-line-number="384"></td>
+ <td id="LC384" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L385" class="blob-num js-line-number" data-line-number="385"></td>
+ <td id="LC385" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L386" class="blob-num js-line-number" data-line-number="386"></td>
+ <td id="LC386" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L387" class="blob-num js-line-number" data-line-number="387"></td>
+ <td id="LC387" class="blob-code blob-code-inner js-file-line"> peg$cachedPos <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L388" class="blob-num js-line-number" data-line-number="388"></td>
+ <td id="LC388" class="blob-code blob-code-inner js-file-line"> peg$cachedPosDetails <span class="pl-k">=</span> { line<span class="pl-k">:</span> <span class="pl-c1">1</span>, column<span class="pl-k">:</span> <span class="pl-c1">1</span>, seenCR<span class="pl-k">:</span> <span class="pl-c1">false</span> },</td>
+ </tr>
+ <tr>
+ <td id="L389" class="blob-num js-line-number" data-line-number="389"></td>
+ <td id="LC389" class="blob-code blob-code-inner js-file-line"> peg$maxFailPos <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L390" class="blob-num js-line-number" data-line-number="390"></td>
+ <td id="LC390" class="blob-code blob-code-inner js-file-line"> peg$maxFailExpected <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L391" class="blob-num js-line-number" data-line-number="391"></td>
+ <td id="LC391" class="blob-code blob-code-inner js-file-line"> peg$silentFails <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L392" class="blob-num js-line-number" data-line-number="392"></td>
+ <td id="LC392" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L393" class="blob-num js-line-number" data-line-number="393"></td>
+ <td id="LC393" class="blob-code blob-code-inner js-file-line"> peg$result;</td>
+ </tr>
+ <tr>
+ <td id="L394" class="blob-num js-line-number" data-line-number="394"></td>
+ <td id="LC394" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L395" class="blob-num js-line-number" data-line-number="395"></td>
+ <td id="LC395" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-s"><span class="pl-pds">"</span>startRule<span class="pl-pds">"</span></span> <span class="pl-k">in</span> options) {</td>
+ </tr>
+ <tr>
+ <td id="L396" class="blob-num js-line-number" data-line-number="396"></td>
+ <td id="LC396" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>(<span class="pl-smi">options</span>.<span class="pl-smi">startRule</span> <span class="pl-k">in</span> peg$startRuleFunctions)) {</td>
+ </tr>
+ <tr>
+ <td id="L397" class="blob-num js-line-number" data-line-number="397"></td>
+ <td id="LC397" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Can't start parsing from rule <span class="pl-cce">\"</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-smi">options</span>.<span class="pl-smi">startRule</span> <span class="pl-k">+</span> <span class="pl-s"><span [...]
+ </tr>
+ <tr>
+ <td id="L398" class="blob-num js-line-number" data-line-number="398"></td>
+ <td id="LC398" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L399" class="blob-num js-line-number" data-line-number="399"></td>
+ <td id="LC399" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L400" class="blob-num js-line-number" data-line-number="400"></td>
+ <td id="LC400" class="blob-code blob-code-inner js-file-line"> peg$startRuleFunction <span class="pl-k">=</span> peg$startRuleFunctions[<span class="pl-smi">options</span>.<span class="pl-smi">startRule</span>];</td>
+ </tr>
+ <tr>
+ <td id="L401" class="blob-num js-line-number" data-line-number="401"></td>
+ <td id="LC401" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L402" class="blob-num js-line-number" data-line-number="402"></td>
+ <td id="LC402" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L403" class="blob-num js-line-number" data-line-number="403"></td>
+ <td id="LC403" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">text</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L404" class="blob-num js-line-number" data-line-number="404"></td>
+ <td id="LC404" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">input</span>.<span class="pl-c1">substring</span>(peg$reportedPos, peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L405" class="blob-num js-line-number" data-line-number="405"></td>
+ <td id="LC405" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L406" class="blob-num js-line-number" data-line-number="406"></td>
+ <td id="LC406" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L407" class="blob-num js-line-number" data-line-number="407"></td>
+ <td id="LC407" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">offset</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L408" class="blob-num js-line-number" data-line-number="408"></td>
+ <td id="LC408" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> peg$reportedPos;</td>
+ </tr>
+ <tr>
+ <td id="L409" class="blob-num js-line-number" data-line-number="409"></td>
+ <td id="LC409" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L410" class="blob-num js-line-number" data-line-number="410"></td>
+ <td id="LC410" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L411" class="blob-num js-line-number" data-line-number="411"></td>
+ <td id="LC411" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">line</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L412" class="blob-num js-line-number" data-line-number="412"></td>
+ <td id="LC412" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">peg$computePosDetails</span>(peg$reportedPos).<span class="pl-smi">line</span>;</td>
+ </tr>
+ <tr>
+ <td id="L413" class="blob-num js-line-number" data-line-number="413"></td>
+ <td id="LC413" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L414" class="blob-num js-line-number" data-line-number="414"></td>
+ <td id="LC414" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L415" class="blob-num js-line-number" data-line-number="415"></td>
+ <td id="LC415" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">column</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L416" class="blob-num js-line-number" data-line-number="416"></td>
+ <td id="LC416" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">peg$computePosDetails</span>(peg$reportedPos).<span class="pl-smi">column</span>;</td>
+ </tr>
+ <tr>
+ <td id="L417" class="blob-num js-line-number" data-line-number="417"></td>
+ <td id="LC417" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L418" class="blob-num js-line-number" data-line-number="418"></td>
+ <td id="LC418" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L419" class="blob-num js-line-number" data-line-number="419"></td>
+ <td id="LC419" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">expected</span>(<span class="pl-smi">description</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L420" class="blob-num js-line-number" data-line-number="420"></td>
+ <td id="LC420" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-en">peg$buildException</span>(</td>
+ </tr>
+ <tr>
+ <td id="L421" class="blob-num js-line-number" data-line-number="421"></td>
+ <td id="LC421" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L422" class="blob-num js-line-number" data-line-number="422"></td>
+ <td id="LC422" class="blob-code blob-code-inner js-file-line"> [{ type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>other<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> description }],</td>
+ </tr>
+ <tr>
+ <td id="L423" class="blob-num js-line-number" data-line-number="423"></td>
+ <td id="LC423" class="blob-code blob-code-inner js-file-line"> peg$reportedPos</td>
+ </tr>
+ <tr>
+ <td id="L424" class="blob-num js-line-number" data-line-number="424"></td>
+ <td id="LC424" class="blob-code blob-code-inner js-file-line"> );</td>
+ </tr>
+ <tr>
+ <td id="L425" class="blob-num js-line-number" data-line-number="425"></td>
+ <td id="LC425" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L426" class="blob-num js-line-number" data-line-number="426"></td>
+ <td id="LC426" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L427" class="blob-num js-line-number" data-line-number="427"></td>
+ <td id="LC427" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">error</span>(<span class="pl-smi">message</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L428" class="blob-num js-line-number" data-line-number="428"></td>
+ <td id="LC428" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-en">peg$buildException</span>(message, <span class="pl-c1">null</span>, peg$reportedPos);</td>
+ </tr>
+ <tr>
+ <td id="L429" class="blob-num js-line-number" data-line-number="429"></td>
+ <td id="LC429" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L430" class="blob-num js-line-number" data-line-number="430"></td>
+ <td id="LC430" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L431" class="blob-num js-line-number" data-line-number="431"></td>
+ <td id="LC431" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$computePosDetails</span>(<span class="pl-smi">pos</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L432" class="blob-num js-line-number" data-line-number="432"></td>
+ <td id="LC432" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">advance</span>(<span class="pl-smi">details</span>, <span class="pl-smi">startPos</span>, <span class="pl-smi">endPos</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L433" class="blob-num js-line-number" data-line-number="433"></td>
+ <td id="LC433" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> p, ch;</td>
+ </tr>
+ <tr>
+ <td id="L434" class="blob-num js-line-number" data-line-number="434"></td>
+ <td id="LC434" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L435" class="blob-num js-line-number" data-line-number="435"></td>
+ <td id="LC435" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (p <span class="pl-k">=</span> startPos; p <span class="pl-k"><</span> endPos; p<span class="pl-k">++</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L436" class="blob-num js-line-number" data-line-number="436"></td>
+ <td id="LC436" class="blob-code blob-code-inner js-file-line"> ch <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(p);</td>
+ </tr>
+ <tr>
+ <td id="L437" class="blob-num js-line-number" data-line-number="437"></td>
+ <td id="LC437" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (ch <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\n</span><span class="pl-pds">"</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L438" class="blob-num js-line-number" data-line-number="438"></td>
+ <td id="LC438" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">details</span>.<span class="pl-smi">seenCR</span>) { <span class="pl-smi">details</span>.<span class="pl-smi">line</span><span class="pl-k">++</span>; }</td>
+ </tr>
+ <tr>
+ <td id="L439" class="blob-num js-line-number" data-line-number="439"></td>
+ <td id="LC439" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">column</span> <span class="pl-k">=</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L440" class="blob-num js-line-number" data-line-number="440"></td>
+ <td id="LC440" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">seenCR</span> <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L441" class="blob-num js-line-number" data-line-number="441"></td>
+ <td id="LC441" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (ch <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\r</span><span class="pl-pds">"</span></span> <span class="pl-k">||</span> ch <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\u</span>2028<span class="pl-pds">"</span></span> [...]
+ </tr>
+ <tr>
+ <td id="L442" class="blob-num js-line-number" data-line-number="442"></td>
+ <td id="LC442" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">line</span><span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L443" class="blob-num js-line-number" data-line-number="443"></td>
+ <td id="LC443" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">column</span> <span class="pl-k">=</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L444" class="blob-num js-line-number" data-line-number="444"></td>
+ <td id="LC444" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">seenCR</span> <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L445" class="blob-num js-line-number" data-line-number="445"></td>
+ <td id="LC445" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L446" class="blob-num js-line-number" data-line-number="446"></td>
+ <td id="LC446" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">column</span><span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L447" class="blob-num js-line-number" data-line-number="447"></td>
+ <td id="LC447" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">details</span>.<span class="pl-smi">seenCR</span> <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L448" class="blob-num js-line-number" data-line-number="448"></td>
+ <td id="LC448" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L449" class="blob-num js-line-number" data-line-number="449"></td>
+ <td id="LC449" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L450" class="blob-num js-line-number" data-line-number="450"></td>
+ <td id="LC450" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L451" class="blob-num js-line-number" data-line-number="451"></td>
+ <td id="LC451" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L452" class="blob-num js-line-number" data-line-number="452"></td>
+ <td id="LC452" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$cachedPos <span class="pl-k">!==</span> pos) {</td>
+ </tr>
+ <tr>
+ <td id="L453" class="blob-num js-line-number" data-line-number="453"></td>
+ <td id="LC453" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$cachedPos <span class="pl-k">></span> pos) {</td>
+ </tr>
+ <tr>
+ <td id="L454" class="blob-num js-line-number" data-line-number="454"></td>
+ <td id="LC454" class="blob-code blob-code-inner js-file-line"> peg$cachedPos <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L455" class="blob-num js-line-number" data-line-number="455"></td>
+ <td id="LC455" class="blob-code blob-code-inner js-file-line"> peg$cachedPosDetails <span class="pl-k">=</span> { line<span class="pl-k">:</span> <span class="pl-c1">1</span>, column<span class="pl-k">:</span> <span class="pl-c1">1</span>, seenCR<span class="pl-k">:</span> <span class="pl-c1">false</span> };</td>
+ </tr>
+ <tr>
+ <td id="L456" class="blob-num js-line-number" data-line-number="456"></td>
+ <td id="LC456" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L457" class="blob-num js-line-number" data-line-number="457"></td>
+ <td id="LC457" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">advance</span>(peg$cachedPosDetails, peg$cachedPos, pos);</td>
+ </tr>
+ <tr>
+ <td id="L458" class="blob-num js-line-number" data-line-number="458"></td>
+ <td id="LC458" class="blob-code blob-code-inner js-file-line"> peg$cachedPos <span class="pl-k">=</span> pos;</td>
+ </tr>
+ <tr>
+ <td id="L459" class="blob-num js-line-number" data-line-number="459"></td>
+ <td id="LC459" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L460" class="blob-num js-line-number" data-line-number="460"></td>
+ <td id="LC460" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L461" class="blob-num js-line-number" data-line-number="461"></td>
+ <td id="LC461" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> peg$cachedPosDetails;</td>
+ </tr>
+ <tr>
+ <td id="L462" class="blob-num js-line-number" data-line-number="462"></td>
+ <td id="LC462" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L463" class="blob-num js-line-number" data-line-number="463"></td>
+ <td id="LC463" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L464" class="blob-num js-line-number" data-line-number="464"></td>
+ <td id="LC464" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$fail</span>(<span class="pl-smi">expected</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L465" class="blob-num js-line-number" data-line-number="465"></td>
+ <td id="LC465" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$currPos <span class="pl-k"><</span> peg$maxFailPos) { <span class="pl-k">return</span>; }</td>
+ </tr>
+ <tr>
+ <td id="L466" class="blob-num js-line-number" data-line-number="466"></td>
+ <td id="LC466" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L467" class="blob-num js-line-number" data-line-number="467"></td>
+ <td id="LC467" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$currPos <span class="pl-k">></span> peg$maxFailPos) {</td>
+ </tr>
+ <tr>
+ <td id="L468" class="blob-num js-line-number" data-line-number="468"></td>
+ <td id="LC468" class="blob-code blob-code-inner js-file-line"> peg$maxFailPos <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L469" class="blob-num js-line-number" data-line-number="469"></td>
+ <td id="LC469" class="blob-code blob-code-inner js-file-line"> peg$maxFailExpected <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L470" class="blob-num js-line-number" data-line-number="470"></td>
+ <td id="LC470" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L471" class="blob-num js-line-number" data-line-number="471"></td>
+ <td id="LC471" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L472" class="blob-num js-line-number" data-line-number="472"></td>
+ <td id="LC472" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">peg$maxFailExpected</span>.<span class="pl-c1">push</span>(expected);</td>
+ </tr>
+ <tr>
+ <td id="L473" class="blob-num js-line-number" data-line-number="473"></td>
+ <td id="LC473" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L474" class="blob-num js-line-number" data-line-number="474"></td>
+ <td id="LC474" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L475" class="blob-num js-line-number" data-line-number="475"></td>
+ <td id="LC475" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$buildException</span>(<span class="pl-smi">message</span>, <span class="pl-smi">expected</span>, <span class="pl-smi">pos</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L476" class="blob-num js-line-number" data-line-number="476"></td>
+ <td id="LC476" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">cleanupExpected</span>(<span class="pl-smi">expected</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L477" class="blob-num js-line-number" data-line-number="477"></td>
+ <td id="LC477" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> i <span class="pl-k">=</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L478" class="blob-num js-line-number" data-line-number="478"></td>
+ <td id="LC478" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L479" class="blob-num js-line-number" data-line-number="479"></td>
+ <td id="LC479" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">expected</span>.<span class="pl-c1">sort</span>(<span class="pl-k">function</span>(<span class="pl-smi">a</span>, <span class="pl-smi">b</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L480" class="blob-num js-line-number" data-line-number="480"></td>
+ <td id="LC480" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">a</span>.<span class="pl-c1">description</span> <span class="pl-k"><</span> <span class="pl-smi">b</span>.<span class="pl-c1">description</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L481" class="blob-num js-line-number" data-line-number="481"></td>
+ <td id="LC481" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L482" class="blob-num js-line-number" data-line-number="482"></td>
+ <td id="LC482" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-smi">a</span>.<span class="pl-c1">description</span> <span class="pl-k">></span> <span class="pl-smi">b</span>.<span class="pl-c1">description</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L483" class="blob-num js-line-number" data-line-number="483"></td>
+ <td id="LC483" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L484" class="blob-num js-line-number" data-line-number="484"></td>
+ <td id="LC484" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L485" class="blob-num js-line-number" data-line-number="485"></td>
+ <td id="LC485" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L486" class="blob-num js-line-number" data-line-number="486"></td>
+ <td id="LC486" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L487" class="blob-num js-line-number" data-line-number="487"></td>
+ <td id="LC487" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L488" class="blob-num js-line-number" data-line-number="488"></td>
+ <td id="LC488" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L489" class="blob-num js-line-number" data-line-number="489"></td>
+ <td id="LC489" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (i <span class="pl-k"><</span> <span class="pl-smi">expected</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L490" class="blob-num js-line-number" data-line-number="490"></td>
+ <td id="LC490" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (expected[i <span class="pl-k">-</span> <span class="pl-c1">1</span>] <span class="pl-k">===</span> expected[i]) {</td>
+ </tr>
+ <tr>
+ <td id="L491" class="blob-num js-line-number" data-line-number="491"></td>
+ <td id="LC491" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">expected</span>.<span class="pl-c1">splice</span>(i, <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L492" class="blob-num js-line-number" data-line-number="492"></td>
+ <td id="LC492" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L493" class="blob-num js-line-number" data-line-number="493"></td>
+ <td id="LC493" class="blob-code blob-code-inner js-file-line"> i<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L494" class="blob-num js-line-number" data-line-number="494"></td>
+ <td id="LC494" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L495" class="blob-num js-line-number" data-line-number="495"></td>
+ <td id="LC495" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L496" class="blob-num js-line-number" data-line-number="496"></td>
+ <td id="LC496" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L497" class="blob-num js-line-number" data-line-number="497"></td>
+ <td id="LC497" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L498" class="blob-num js-line-number" data-line-number="498"></td>
+ <td id="LC498" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">buildMessage</span>(<span class="pl-smi">expected</span>, <span class="pl-smi">found</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L499" class="blob-num js-line-number" data-line-number="499"></td>
+ <td id="LC499" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">stringEscape</span>(<span class="pl-smi">s</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L500" class="blob-num js-line-number" data-line-number="500"></td>
+ <td id="LC500" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">hex</span>(<span class="pl-smi">ch</span>) { <span class="pl-k">return</span> <span class="pl-smi">ch</span>.<span class="pl-c1">charCodeAt</span>(<span class="pl-c1">0</span>).<span class="pl-c1">toString</span>(<span class="pl-c1">16</span>).<span class="pl-c1">toUpperCase</span>(); }</td>
+ </tr>
+ <tr>
+ <td id="L501" class="blob-num js-line-number" data-line-number="501"></td>
+ <td id="LC501" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L502" class="blob-num js-line-number" data-line-number="502"></td>
+ <td id="LC502" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s</td>
+ </tr>
+ <tr>
+ <td id="L503" class="blob-num js-line-number" data-line-number="503"></td>
+ <td id="LC503" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-cce">\\</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\\\</span><span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L504" class="blob-num js-line-number" data-line-number="504"></td>
+ <td id="LC504" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span>"<span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>"<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L505" class="blob-num js-line-number" data-line-number="505"></td>
+ <td id="LC505" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-cce">\x</span>08<span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>b<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L506" class="blob-num js-line-number" data-line-number="506"></td>
+ <td id="LC506" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-cce">\t</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>t<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L507" class="blob-num js-line-number" data-line-number="507"></td>
+ <td id="LC507" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-cce">\n</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>n<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L508" class="blob-num js-line-number" data-line-number="508"></td>
+ <td id="LC508" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-cce">\f</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>f<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L509" class="blob-num js-line-number" data-line-number="509"></td>
+ <td id="LC509" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-cce">\r</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>r<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L510" class="blob-num js-line-number" data-line-number="510"></td>
+ <td id="LC510" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-c1">[<span class="pl-cce">\x</span>0<span class="pl-c1">0-<span class="pl-cce">\x</span></span>07<span class="pl-cce">\x</span>0B<span class="pl-cce">\x</span>0E<span class="pl-cce">\x</span>0F]</span><span class="pl-pds">/</span>g</span>, <span class="pl-k">function</span>(<span class="pl-smi">ch</span>) { [...]
+ </tr>
+ <tr>
+ <td id="L511" class="blob-num js-line-number" data-line-number="511"></td>
+ <td id="LC511" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-c1">[<span class="pl-cce">\x</span>1<span class="pl-c1">0-<span class="pl-cce">\x</span></span>1F<span class="pl-cce">\x</span>8<span class="pl-c1">0-<span class="pl-cce">\x</span></span>FF]</span><span class="pl-pds">/</span>g</span>, <span class="pl-k">function</span>(<span class="pl-smi">ch</span>) { < [...]
+ </tr>
+ <tr>
+ <td id="L512" class="blob-num js-line-number" data-line-number="512"></td>
+ <td id="LC512" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-c1">[<span class="pl-cce">\u</span>018<span class="pl-c1">0-<span class="pl-cce">\u</span></span>0FFF]</span><span class="pl-pds">/</span>g</span>, <span class="pl-k">function</span>(<span class="pl-smi">ch</span>) { <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">'</span [...]
+ </tr>
+ <tr>
+ <td id="L513" class="blob-num js-line-number" data-line-number="513"></td>
+ <td id="LC513" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-c1">[<span class="pl-cce">\u</span>108<span class="pl-c1">0-<span class="pl-cce">\u</span></span>FFFF]</span><span class="pl-pds">/</span>g</span>, <span class="pl-k">function</span>(<span class="pl-smi">ch</span>) { <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">'</span [...]
+ </tr>
+ <tr>
+ <td id="L514" class="blob-num js-line-number" data-line-number="514"></td>
+ <td id="LC514" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L515" class="blob-num js-line-number" data-line-number="515"></td>
+ <td id="LC515" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L516" class="blob-num js-line-number" data-line-number="516"></td>
+ <td id="LC516" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> expectedDescs <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">Array</span>(<span class="pl-smi">expected</span>.<span class="pl-c1">length</span>),</td>
+ </tr>
+ <tr>
+ <td id="L517" class="blob-num js-line-number" data-line-number="517"></td>
+ <td id="LC517" class="blob-code blob-code-inner js-file-line"> expectedDesc, foundDesc, i;</td>
+ </tr>
+ <tr>
+ <td id="L518" class="blob-num js-line-number" data-line-number="518"></td>
+ <td id="LC518" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L519" class="blob-num js-line-number" data-line-number="519"></td>
+ <td id="LC519" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (i <span class="pl-k">=</span> <span class="pl-c1">0</span>; i <span class="pl-k"><</span> <span class="pl-smi">expected</span>.<span class="pl-c1">length</span>; i<span class="pl-k">++</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L520" class="blob-num js-line-number" data-line-number="520"></td>
+ <td id="LC520" class="blob-code blob-code-inner js-file-line"> expectedDescs[i] <span class="pl-k">=</span> expected[i].<span class="pl-c1">description</span>;</td>
+ </tr>
+ <tr>
+ <td id="L521" class="blob-num js-line-number" data-line-number="521"></td>
+ <td id="LC521" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L522" class="blob-num js-line-number" data-line-number="522"></td>
+ <td id="LC522" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L523" class="blob-num js-line-number" data-line-number="523"></td>
+ <td id="LC523" class="blob-code blob-code-inner js-file-line"> expectedDesc <span class="pl-k">=</span> <span class="pl-smi">expected</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span></td>
+ </tr>
+ <tr>
+ <td id="L524" class="blob-num js-line-number" data-line-number="524"></td>
+ <td id="LC524" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-smi">expectedDescs</span>.<span class="pl-c1">slice</span>(<span class="pl-c1">0</span>, <span class="pl-k">-</span><span class="pl-c1">1</span>).<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">"</span>, <span class="pl-pds">"</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L525" class="blob-num js-line-number" data-line-number="525"></td>
+ <td id="LC525" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> or <span class="pl-pds">"</span></span></td>
+ </tr>
+ <tr>
+ <td id="L526" class="blob-num js-line-number" data-line-number="526"></td>
+ <td id="LC526" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">+</span> expectedDescs[<span class="pl-smi">expected</span>.<span class="pl-c1">length</span> <span class="pl-k">-</span> <span class="pl-c1">1</span>]</td>
+ </tr>
+ <tr>
+ <td id="L527" class="blob-num js-line-number" data-line-number="527"></td>
+ <td id="LC527" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> expectedDescs[<span class="pl-c1">0</span>];</td>
+ </tr>
+ <tr>
+ <td id="L528" class="blob-num js-line-number" data-line-number="528"></td>
+ <td id="LC528" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L529" class="blob-num js-line-number" data-line-number="529"></td>
+ <td id="LC529" class="blob-code blob-code-inner js-file-line"> foundDesc <span class="pl-k">=</span> found <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\"</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-en">stringEscape</span>(found) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\"</span><span class="pl-pds"> [...]
+ </tr>
+ <tr>
+ <td id="L530" class="blob-num js-line-number" data-line-number="530"></td>
+ <td id="LC530" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L531" class="blob-num js-line-number" data-line-number="531"></td>
+ <td id="LC531" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">"</span>Expected <span class="pl-pds">"</span></span> <span class="pl-k">+</span> expectedDesc <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> but <span class="pl-pds">"</span></span> <span class="pl-k">+</span> foundDesc <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">&q [...]
+ </tr>
+ <tr>
+ <td id="L532" class="blob-num js-line-number" data-line-number="532"></td>
+ <td id="LC532" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L533" class="blob-num js-line-number" data-line-number="533"></td>
+ <td id="LC533" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L534" class="blob-num js-line-number" data-line-number="534"></td>
+ <td id="LC534" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> posDetails <span class="pl-k">=</span> <span class="pl-en">peg$computePosDetails</span>(pos),</td>
+ </tr>
+ <tr>
+ <td id="L535" class="blob-num js-line-number" data-line-number="535"></td>
+ <td id="LC535" class="blob-code blob-code-inner js-file-line"> found <span class="pl-k">=</span> pos <span class="pl-k"><</span> <span class="pl-smi">input</span>.<span class="pl-c1">length</span> <span class="pl-k">?</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(pos) <span class="pl-k">:</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L536" class="blob-num js-line-number" data-line-number="536"></td>
+ <td id="LC536" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L537" class="blob-num js-line-number" data-line-number="537"></td>
+ <td id="LC537" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (expected <span class="pl-k">!==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L538" class="blob-num js-line-number" data-line-number="538"></td>
+ <td id="LC538" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">cleanupExpected</span>(expected);</td>
+ </tr>
+ <tr>
+ <td id="L539" class="blob-num js-line-number" data-line-number="539"></td>
+ <td id="LC539" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L540" class="blob-num js-line-number" data-line-number="540"></td>
+ <td id="LC540" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L541" class="blob-num js-line-number" data-line-number="541"></td>
+ <td id="LC541" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">new</span> <span class="pl-en">SyntaxError</span>(</td>
+ </tr>
+ <tr>
+ <td id="L542" class="blob-num js-line-number" data-line-number="542"></td>
+ <td id="LC542" class="blob-code blob-code-inner js-file-line"> message <span class="pl-k">!==</span> <span class="pl-c1">null</span> <span class="pl-k">?</span> message <span class="pl-k">:</span> <span class="pl-en">buildMessage</span>(expected, found),</td>
+ </tr>
+ <tr>
+ <td id="L543" class="blob-num js-line-number" data-line-number="543"></td>
+ <td id="LC543" class="blob-code blob-code-inner js-file-line"> expected,</td>
+ </tr>
+ <tr>
+ <td id="L544" class="blob-num js-line-number" data-line-number="544"></td>
+ <td id="LC544" class="blob-code blob-code-inner js-file-line"> found,</td>
+ </tr>
+ <tr>
+ <td id="L545" class="blob-num js-line-number" data-line-number="545"></td>
+ <td id="LC545" class="blob-code blob-code-inner js-file-line"> pos,</td>
+ </tr>
+ <tr>
+ <td id="L546" class="blob-num js-line-number" data-line-number="546"></td>
+ <td id="LC546" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">posDetails</span>.<span class="pl-smi">line</span>,</td>
+ </tr>
+ <tr>
+ <td id="L547" class="blob-num js-line-number" data-line-number="547"></td>
+ <td id="LC547" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">posDetails</span>.<span class="pl-smi">column</span></td>
+ </tr>
+ <tr>
+ <td id="L548" class="blob-num js-line-number" data-line-number="548"></td>
+ <td id="LC548" class="blob-code blob-code-inner js-file-line"> );</td>
+ </tr>
+ <tr>
+ <td id="L549" class="blob-num js-line-number" data-line-number="549"></td>
+ <td id="LC549" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L550" class="blob-num js-line-number" data-line-number="550"></td>
+ <td id="LC550" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L551" class="blob-num js-line-number" data-line-number="551"></td>
+ <td id="LC551" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsestart</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L552" class="blob-num js-line-number" data-line-number="552"></td>
+ <td id="LC552" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L553" class="blob-num js-line-number" data-line-number="553"></td>
+ <td id="LC553" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L554" class="blob-num js-line-number" data-line-number="554"></td>
+ <td id="LC554" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L555" class="blob-num js-line-number" data-line-number="555"></td>
+ <td id="LC555" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsegraphStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L556" class="blob-num js-line-number" data-line-number="556"></td>
+ <td id="LC556" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L557" class="blob-num js-line-number" data-line-number="557"></td>
+ <td id="LC557" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L558" class="blob-num js-line-number" data-line-number="558"></td>
+ <td id="LC558" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s0</span>.<span class="pl-c1">push</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L559" class="blob-num js-line-number" data-line-number="559"></td>
+ <td id="LC559" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsegraphStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L560" class="blob-num js-line-number" data-line-number="560"></td>
+ <td id="LC560" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L561" class="blob-num js-line-number" data-line-number="561"></td>
+ <td id="LC561" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L562" class="blob-num js-line-number" data-line-number="562"></td>
+ <td id="LC562" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L563" class="blob-num js-line-number" data-line-number="563"></td>
+ <td id="LC563" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L564" class="blob-num js-line-number" data-line-number="564"></td>
+ <td id="LC564" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L565" class="blob-num js-line-number" data-line-number="565"></td>
+ <td id="LC565" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L566" class="blob-num js-line-number" data-line-number="566"></td>
+ <td id="LC566" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L567" class="blob-num js-line-number" data-line-number="567"></td>
+ <td id="LC567" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L568" class="blob-num js-line-number" data-line-number="568"></td>
+ <td id="LC568" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsegraphStmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L569" class="blob-num js-line-number" data-line-number="569"></td>
+ <td id="LC569" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;</td>
+ </tr>
+ <tr>
+ <td id="L570" class="blob-num js-line-number" data-line-number="570"></td>
+ <td id="LC570" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L571" class="blob-num js-line-number" data-line-number="571"></td>
+ <td id="LC571" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L572" class="blob-num js-line-number" data-line-number="572"></td>
+ <td id="LC572" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L573" class="blob-num js-line-number" data-line-number="573"></td>
+ <td id="LC573" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L574" class="blob-num js-line-number" data-line-number="574"></td>
+ <td id="LC574" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L575" class="blob-num js-line-number" data-line-number="575"></td>
+ <td id="LC575" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s1</span>.<span class="pl-c1">push</span>(s2);</td>
+ </tr>
+ <tr>
+ <td id="L576" class="blob-num js-line-number" data-line-number="576"></td>
+ <td id="LC576" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L577" class="blob-num js-line-number" data-line-number="577"></td>
+ <td id="LC577" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L578" class="blob-num js-line-number" data-line-number="578"></td>
+ <td id="LC578" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L579" class="blob-num js-line-number" data-line-number="579"></td>
+ <td id="LC579" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L580" class="blob-num js-line-number" data-line-number="580"></td>
+ <td id="LC580" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parsestrict</span>();</td>
+ </tr>
+ <tr>
+ <td id="L581" class="blob-num js-line-number" data-line-number="581"></td>
+ <td id="LC581" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L582" class="blob-num js-line-number" data-line-number="582"></td>
+ <td id="LC582" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L583" class="blob-num js-line-number" data-line-number="583"></td>
+ <td id="LC583" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L584" class="blob-num js-line-number" data-line-number="584"></td>
+ <td id="LC584" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> [s3, s4];</td>
+ </tr>
+ <tr>
+ <td id="L585" class="blob-num js-line-number" data-line-number="585"></td>
+ <td id="LC585" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L586" class="blob-num js-line-number" data-line-number="586"></td>
+ <td id="LC586" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L587" class="blob-num js-line-number" data-line-number="587"></td>
+ <td id="LC587" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L588" class="blob-num js-line-number" data-line-number="588"></td>
+ <td id="LC588" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L589" class="blob-num js-line-number" data-line-number="589"></td>
+ <td id="LC589" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L590" class="blob-num js-line-number" data-line-number="590"></td>
+ <td id="LC590" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L591" class="blob-num js-line-number" data-line-number="591"></td>
+ <td id="LC591" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L592" class="blob-num js-line-number" data-line-number="592"></td>
+ <td id="LC592" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L593" class="blob-num js-line-number" data-line-number="593"></td>
+ <td id="LC593" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L594" class="blob-num js-line-number" data-line-number="594"></td>
+ <td id="LC594" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L595" class="blob-num js-line-number" data-line-number="595"></td>
+ <td id="LC595" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L596" class="blob-num js-line-number" data-line-number="596"></td>
+ <td id="LC596" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L597" class="blob-num js-line-number" data-line-number="597"></td>
+ <td id="LC597" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L598" class="blob-num js-line-number" data-line-number="598"></td>
+ <td id="LC598" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parsegraphType</span>();</td>
+ </tr>
+ <tr>
+ <td id="L599" class="blob-num js-line-number" data-line-number="599"></td>
+ <td id="LC599" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L600" class="blob-num js-line-number" data-line-number="600"></td>
+ <td id="LC600" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L601" class="blob-num js-line-number" data-line-number="601"></td>
+ <td id="LC601" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L602" class="blob-num js-line-number" data-line-number="602"></td>
+ <td id="LC602" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L603" class="blob-num js-line-number" data-line-number="603"></td>
+ <td id="LC603" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L604" class="blob-num js-line-number" data-line-number="604"></td>
+ <td id="LC604" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L605" class="blob-num js-line-number" data-line-number="605"></td>
+ <td id="LC605" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L606" class="blob-num js-line-number" data-line-number="606"></td>
+ <td id="LC606" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L607" class="blob-num js-line-number" data-line-number="607"></td>
+ <td id="LC607" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L608" class="blob-num js-line-number" data-line-number="608"></td>
+ <td id="LC608" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L609" class="blob-num js-line-number" data-line-number="609"></td>
+ <td id="LC609" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L610" class="blob-num js-line-number" data-line-number="610"></td>
+ <td id="LC610" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L611" class="blob-num js-line-number" data-line-number="611"></td>
+ <td id="LC611" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L612" class="blob-num js-line-number" data-line-number="612"></td>
+ <td id="LC612" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L613" class="blob-num js-line-number" data-line-number="613"></td>
+ <td id="LC613" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L614" class="blob-num js-line-number" data-line-number="614"></td>
+ <td id="LC614" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L615" class="blob-num js-line-number" data-line-number="615"></td>
+ <td id="LC615" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s6</span>.<span class="pl-c1">push</span>(s7);</td>
+ </tr>
+ <tr>
+ <td id="L616" class="blob-num js-line-number" data-line-number="616"></td>
+ <td id="LC616" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L617" class="blob-num js-line-number" data-line-number="617"></td>
+ <td id="LC617" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L618" class="blob-num js-line-number" data-line-number="618"></td>
+ <td id="LC618" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L619" class="blob-num js-line-number" data-line-number="619"></td>
+ <td id="LC619" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">123</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L620" class="blob-num js-line-number" data-line-number="620"></td>
+ <td id="LC620" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> peg$c3;</td>
+ </tr>
+ <tr>
+ <td id="L621" class="blob-num js-line-number" data-line-number="621"></td>
+ <td id="LC621" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L622" class="blob-num js-line-number" data-line-number="622"></td>
+ <td id="LC622" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L623" class="blob-num js-line-number" data-line-number="623"></td>
+ <td id="LC623" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L624" class="blob-num js-line-number" data-line-number="624"></td>
+ <td id="LC624" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c4); }</td>
+ </tr>
+ <tr>
+ <td id="L625" class="blob-num js-line-number" data-line-number="625"></td>
+ <td id="LC625" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L626" class="blob-num js-line-number" data-line-number="626"></td>
+ <td id="LC626" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L627" class="blob-num js-line-number" data-line-number="627"></td>
+ <td id="LC627" class="blob-code blob-code-inner js-file-line"> s8 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L628" class="blob-num js-line-number" data-line-number="628"></td>
+ <td id="LC628" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L629" class="blob-num js-line-number" data-line-number="629"></td>
+ <td id="LC629" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s9 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L630" class="blob-num js-line-number" data-line-number="630"></td>
+ <td id="LC630" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s8</span>.<span class="pl-c1">push</span>(s9);</td>
+ </tr>
+ <tr>
+ <td id="L631" class="blob-num js-line-number" data-line-number="631"></td>
+ <td id="LC631" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L632" class="blob-num js-line-number" data-line-number="632"></td>
+ <td id="LC632" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L633" class="blob-num js-line-number" data-line-number="633"></td>
+ <td id="LC633" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s8 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L634" class="blob-num js-line-number" data-line-number="634"></td>
+ <td id="LC634" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parsestmtList</span>();</td>
+ </tr>
+ <tr>
+ <td id="L635" class="blob-num js-line-number" data-line-number="635"></td>
+ <td id="LC635" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s9 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L636" class="blob-num js-line-number" data-line-number="636"></td>
+ <td id="LC636" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L637" class="blob-num js-line-number" data-line-number="637"></td>
+ <td id="LC637" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L638" class="blob-num js-line-number" data-line-number="638"></td>
+ <td id="LC638" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s9 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L639" class="blob-num js-line-number" data-line-number="639"></td>
+ <td id="LC639" class="blob-code blob-code-inner js-file-line"> s10 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L640" class="blob-num js-line-number" data-line-number="640"></td>
+ <td id="LC640" class="blob-code blob-code-inner js-file-line"> s11 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L641" class="blob-num js-line-number" data-line-number="641"></td>
+ <td id="LC641" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s11 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L642" class="blob-num js-line-number" data-line-number="642"></td>
+ <td id="LC642" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s10</span>.<span class="pl-c1">push</span>(s11);</td>
+ </tr>
+ <tr>
+ <td id="L643" class="blob-num js-line-number" data-line-number="643"></td>
+ <td id="LC643" class="blob-code blob-code-inner js-file-line"> s11 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L644" class="blob-num js-line-number" data-line-number="644"></td>
+ <td id="LC644" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L645" class="blob-num js-line-number" data-line-number="645"></td>
+ <td id="LC645" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s10 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L646" class="blob-num js-line-number" data-line-number="646"></td>
+ <td id="LC646" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">125</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L647" class="blob-num js-line-number" data-line-number="647"></td>
+ <td id="LC647" class="blob-code blob-code-inner js-file-line"> s11 <span class="pl-k">=</span> peg$c5;</td>
+ </tr>
+ <tr>
+ <td id="L648" class="blob-num js-line-number" data-line-number="648"></td>
+ <td id="LC648" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L649" class="blob-num js-line-number" data-line-number="649"></td>
+ <td id="LC649" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L650" class="blob-num js-line-number" data-line-number="650"></td>
+ <td id="LC650" class="blob-code blob-code-inner js-file-line"> s11 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L651" class="blob-num js-line-number" data-line-number="651"></td>
+ <td id="LC651" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c6); }</td>
+ </tr>
+ <tr>
+ <td id="L652" class="blob-num js-line-number" data-line-number="652"></td>
+ <td id="LC652" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L653" class="blob-num js-line-number" data-line-number="653"></td>
+ <td id="LC653" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s11 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L654" class="blob-num js-line-number" data-line-number="654"></td>
+ <td id="LC654" class="blob-code blob-code-inner js-file-line"> s12 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L655" class="blob-num js-line-number" data-line-number="655"></td>
+ <td id="LC655" class="blob-code blob-code-inner js-file-line"> s13 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L656" class="blob-num js-line-number" data-line-number="656"></td>
+ <td id="LC656" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s13 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L657" class="blob-num js-line-number" data-line-number="657"></td>
+ <td id="LC657" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s12</span>.<span class="pl-c1">push</span>(s13);</td>
+ </tr>
+ <tr>
+ <td id="L658" class="blob-num js-line-number" data-line-number="658"></td>
+ <td id="LC658" class="blob-code blob-code-inner js-file-line"> s13 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L659" class="blob-num js-line-number" data-line-number="659"></td>
+ <td id="LC659" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L660" class="blob-num js-line-number" data-line-number="660"></td>
+ <td id="LC660" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s12 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L661" class="blob-num js-line-number" data-line-number="661"></td>
+ <td id="LC661" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L662" class="blob-num js-line-number" data-line-number="662"></td>
+ <td id="LC662" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c7</span>(s2, s3, s5, s9);</td>
+ </tr>
+ <tr>
+ <td id="L663" class="blob-num js-line-number" data-line-number="663"></td>
+ <td id="LC663" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L664" class="blob-num js-line-number" data-line-number="664"></td>
+ <td id="LC664" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L665" class="blob-num js-line-number" data-line-number="665"></td>
+ <td id="LC665" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L666" class="blob-num js-line-number" data-line-number="666"></td>
+ <td id="LC666" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L667" class="blob-num js-line-number" data-line-number="667"></td>
+ <td id="LC667" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L668" class="blob-num js-line-number" data-line-number="668"></td>
+ <td id="LC668" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L669" class="blob-num js-line-number" data-line-number="669"></td>
+ <td id="LC669" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L670" class="blob-num js-line-number" data-line-number="670"></td>
+ <td id="LC670" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L671" class="blob-num js-line-number" data-line-number="671"></td>
+ <td id="LC671" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L672" class="blob-num js-line-number" data-line-number="672"></td>
+ <td id="LC672" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L673" class="blob-num js-line-number" data-line-number="673"></td>
+ <td id="LC673" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L674" class="blob-num js-line-number" data-line-number="674"></td>
+ <td id="LC674" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L675" class="blob-num js-line-number" data-line-number="675"></td>
+ <td id="LC675" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L676" class="blob-num js-line-number" data-line-number="676"></td>
+ <td id="LC676" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L677" class="blob-num js-line-number" data-line-number="677"></td>
+ <td id="LC677" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L678" class="blob-num js-line-number" data-line-number="678"></td>
+ <td id="LC678" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L679" class="blob-num js-line-number" data-line-number="679"></td>
+ <td id="LC679" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L680" class="blob-num js-line-number" data-line-number="680"></td>
+ <td id="LC680" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L681" class="blob-num js-line-number" data-line-number="681"></td>
+ <td id="LC681" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L682" class="blob-num js-line-number" data-line-number="682"></td>
+ <td id="LC682" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L683" class="blob-num js-line-number" data-line-number="683"></td>
+ <td id="LC683" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L684" class="blob-num js-line-number" data-line-number="684"></td>
+ <td id="LC684" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L685" class="blob-num js-line-number" data-line-number="685"></td>
+ <td id="LC685" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L686" class="blob-num js-line-number" data-line-number="686"></td>
+ <td id="LC686" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L687" class="blob-num js-line-number" data-line-number="687"></td>
+ <td id="LC687" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L688" class="blob-num js-line-number" data-line-number="688"></td>
+ <td id="LC688" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L689" class="blob-num js-line-number" data-line-number="689"></td>
+ <td id="LC689" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L690" class="blob-num js-line-number" data-line-number="690"></td>
+ <td id="LC690" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L691" class="blob-num js-line-number" data-line-number="691"></td>
+ <td id="LC691" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L692" class="blob-num js-line-number" data-line-number="692"></td>
+ <td id="LC692" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L693" class="blob-num js-line-number" data-line-number="693"></td>
+ <td id="LC693" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L694" class="blob-num js-line-number" data-line-number="694"></td>
+ <td id="LC694" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L695" class="blob-num js-line-number" data-line-number="695"></td>
+ <td id="LC695" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L696" class="blob-num js-line-number" data-line-number="696"></td>
+ <td id="LC696" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L697" class="blob-num js-line-number" data-line-number="697"></td>
+ <td id="LC697" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L698" class="blob-num js-line-number" data-line-number="698"></td>
+ <td id="LC698" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L699" class="blob-num js-line-number" data-line-number="699"></td>
+ <td id="LC699" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L700" class="blob-num js-line-number" data-line-number="700"></td>
+ <td id="LC700" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L701" class="blob-num js-line-number" data-line-number="701"></td>
+ <td id="LC701" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L702" class="blob-num js-line-number" data-line-number="702"></td>
+ <td id="LC702" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L703" class="blob-num js-line-number" data-line-number="703"></td>
+ <td id="LC703" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L704" class="blob-num js-line-number" data-line-number="704"></td>
+ <td id="LC704" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L705" class="blob-num js-line-number" data-line-number="705"></td>
+ <td id="LC705" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L706" class="blob-num js-line-number" data-line-number="706"></td>
+ <td id="LC706" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L707" class="blob-num js-line-number" data-line-number="707"></td>
+ <td id="LC707" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L708" class="blob-num js-line-number" data-line-number="708"></td>
+ <td id="LC708" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L709" class="blob-num js-line-number" data-line-number="709"></td>
+ <td id="LC709" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L710" class="blob-num js-line-number" data-line-number="710"></td>
+ <td id="LC710" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L711" class="blob-num js-line-number" data-line-number="711"></td>
+ <td id="LC711" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L712" class="blob-num js-line-number" data-line-number="712"></td>
+ <td id="LC712" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L713" class="blob-num js-line-number" data-line-number="713"></td>
+ <td id="LC713" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L714" class="blob-num js-line-number" data-line-number="714"></td>
+ <td id="LC714" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L715" class="blob-num js-line-number" data-line-number="715"></td>
+ <td id="LC715" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L716" class="blob-num js-line-number" data-line-number="716"></td>
+ <td id="LC716" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsestmtList</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L717" class="blob-num js-line-number" data-line-number="717"></td>
+ <td id="LC717" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;</td>
+ </tr>
+ <tr>
+ <td id="L718" class="blob-num js-line-number" data-line-number="718"></td>
+ <td id="LC718" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L719" class="blob-num js-line-number" data-line-number="719"></td>
+ <td id="LC719" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L720" class="blob-num js-line-number" data-line-number="720"></td>
+ <td id="LC720" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsestmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L721" class="blob-num js-line-number" data-line-number="721"></td>
+ <td id="LC721" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L722" class="blob-num js-line-number" data-line-number="722"></td>
+ <td id="LC722" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L723" class="blob-num js-line-number" data-line-number="723"></td>
+ <td id="LC723" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L724" class="blob-num js-line-number" data-line-number="724"></td>
+ <td id="LC724" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L725" class="blob-num js-line-number" data-line-number="725"></td>
+ <td id="LC725" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L726" class="blob-num js-line-number" data-line-number="726"></td>
+ <td id="LC726" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L727" class="blob-num js-line-number" data-line-number="727"></td>
+ <td id="LC727" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L728" class="blob-num js-line-number" data-line-number="728"></td>
+ <td id="LC728" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L729" class="blob-num js-line-number" data-line-number="729"></td>
+ <td id="LC729" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">59</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L730" class="blob-num js-line-number" data-line-number="730"></td>
+ <td id="LC730" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c8;</td>
+ </tr>
+ <tr>
+ <td id="L731" class="blob-num js-line-number" data-line-number="731"></td>
+ <td id="LC731" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L732" class="blob-num js-line-number" data-line-number="732"></td>
+ <td id="LC732" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L733" class="blob-num js-line-number" data-line-number="733"></td>
+ <td id="LC733" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L734" class="blob-num js-line-number" data-line-number="734"></td>
+ <td id="LC734" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c9); }</td>
+ </tr>
+ <tr>
+ <td id="L735" class="blob-num js-line-number" data-line-number="735"></td>
+ <td id="LC735" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L736" class="blob-num js-line-number" data-line-number="736"></td>
+ <td id="LC736" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L737" class="blob-num js-line-number" data-line-number="737"></td>
+ <td id="LC737" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L738" class="blob-num js-line-number" data-line-number="738"></td>
+ <td id="LC738" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L739" class="blob-num js-line-number" data-line-number="739"></td>
+ <td id="LC739" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L740" class="blob-num js-line-number" data-line-number="740"></td>
+ <td id="LC740" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L741" class="blob-num js-line-number" data-line-number="741"></td>
+ <td id="LC741" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L742" class="blob-num js-line-number" data-line-number="742"></td>
+ <td id="LC742" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L743" class="blob-num js-line-number" data-line-number="743"></td>
+ <td id="LC743" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L744" class="blob-num js-line-number" data-line-number="744"></td>
+ <td id="LC744" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L745" class="blob-num js-line-number" data-line-number="745"></td>
+ <td id="LC745" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s6</span>.<span class="pl-c1">push</span>(s7);</td>
+ </tr>
+ <tr>
+ <td id="L746" class="blob-num js-line-number" data-line-number="746"></td>
+ <td id="LC746" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L747" class="blob-num js-line-number" data-line-number="747"></td>
+ <td id="LC747" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L748" class="blob-num js-line-number" data-line-number="748"></td>
+ <td id="LC748" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L749" class="blob-num js-line-number" data-line-number="749"></td>
+ <td id="LC749" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parsestmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L750" class="blob-num js-line-number" data-line-number="750"></td>
+ <td id="LC750" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L751" class="blob-num js-line-number" data-line-number="751"></td>
+ <td id="LC751" class="blob-code blob-code-inner js-file-line"> s8 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L752" class="blob-num js-line-number" data-line-number="752"></td>
+ <td id="LC752" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L753" class="blob-num js-line-number" data-line-number="753"></td>
+ <td id="LC753" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s9 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L754" class="blob-num js-line-number" data-line-number="754"></td>
+ <td id="LC754" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s8</span>.<span class="pl-c1">push</span>(s9);</td>
+ </tr>
+ <tr>
+ <td id="L755" class="blob-num js-line-number" data-line-number="755"></td>
+ <td id="LC755" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L756" class="blob-num js-line-number" data-line-number="756"></td>
+ <td id="LC756" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L757" class="blob-num js-line-number" data-line-number="757"></td>
+ <td id="LC757" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s8 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L758" class="blob-num js-line-number" data-line-number="758"></td>
+ <td id="LC758" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">59</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L759" class="blob-num js-line-number" data-line-number="759"></td>
+ <td id="LC759" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$c8;</td>
+ </tr>
+ <tr>
+ <td id="L760" class="blob-num js-line-number" data-line-number="760"></td>
+ <td id="LC760" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L761" class="blob-num js-line-number" data-line-number="761"></td>
+ <td id="LC761" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L762" class="blob-num js-line-number" data-line-number="762"></td>
+ <td id="LC762" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L763" class="blob-num js-line-number" data-line-number="763"></td>
+ <td id="LC763" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c9); }</td>
+ </tr>
+ <tr>
+ <td id="L764" class="blob-num js-line-number" data-line-number="764"></td>
+ <td id="LC764" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L765" class="blob-num js-line-number" data-line-number="765"></td>
+ <td id="LC765" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s9 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L766" class="blob-num js-line-number" data-line-number="766"></td>
+ <td id="LC766" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L767" class="blob-num js-line-number" data-line-number="767"></td>
+ <td id="LC767" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L768" class="blob-num js-line-number" data-line-number="768"></td>
+ <td id="LC768" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s9 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L769" class="blob-num js-line-number" data-line-number="769"></td>
+ <td id="LC769" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [s6, s7, s8, s9];</td>
+ </tr>
+ <tr>
+ <td id="L770" class="blob-num js-line-number" data-line-number="770"></td>
+ <td id="LC770" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> s6;</td>
+ </tr>
+ <tr>
+ <td id="L771" class="blob-num js-line-number" data-line-number="771"></td>
+ <td id="LC771" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L772" class="blob-num js-line-number" data-line-number="772"></td>
+ <td id="LC772" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L773" class="blob-num js-line-number" data-line-number="773"></td>
+ <td id="LC773" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L774" class="blob-num js-line-number" data-line-number="774"></td>
+ <td id="LC774" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L775" class="blob-num js-line-number" data-line-number="775"></td>
+ <td id="LC775" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L776" class="blob-num js-line-number" data-line-number="776"></td>
+ <td id="LC776" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L777" class="blob-num js-line-number" data-line-number="777"></td>
+ <td id="LC777" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L778" class="blob-num js-line-number" data-line-number="778"></td>
+ <td id="LC778" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L779" class="blob-num js-line-number" data-line-number="779"></td>
+ <td id="LC779" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L780" class="blob-num js-line-number" data-line-number="780"></td>
+ <td id="LC780" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L781" class="blob-num js-line-number" data-line-number="781"></td>
+ <td id="LC781" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L782" class="blob-num js-line-number" data-line-number="782"></td>
+ <td id="LC782" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L783" class="blob-num js-line-number" data-line-number="783"></td>
+ <td id="LC783" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L784" class="blob-num js-line-number" data-line-number="784"></td>
+ <td id="LC784" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L785" class="blob-num js-line-number" data-line-number="785"></td>
+ <td id="LC785" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L786" class="blob-num js-line-number" data-line-number="786"></td>
+ <td id="LC786" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L787" class="blob-num js-line-number" data-line-number="787"></td>
+ <td id="LC787" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L788" class="blob-num js-line-number" data-line-number="788"></td>
+ <td id="LC788" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L789" class="blob-num js-line-number" data-line-number="789"></td>
+ <td id="LC789" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L790" class="blob-num js-line-number" data-line-number="790"></td>
+ <td id="LC790" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L791" class="blob-num js-line-number" data-line-number="791"></td>
+ <td id="LC791" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L792" class="blob-num js-line-number" data-line-number="792"></td>
+ <td id="LC792" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L793" class="blob-num js-line-number" data-line-number="793"></td>
+ <td id="LC793" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s6</span>.<span class="pl-c1">push</span>(s7);</td>
+ </tr>
+ <tr>
+ <td id="L794" class="blob-num js-line-number" data-line-number="794"></td>
+ <td id="LC794" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L795" class="blob-num js-line-number" data-line-number="795"></td>
+ <td id="LC795" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L796" class="blob-num js-line-number" data-line-number="796"></td>
+ <td id="LC796" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L797" class="blob-num js-line-number" data-line-number="797"></td>
+ <td id="LC797" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parsestmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L798" class="blob-num js-line-number" data-line-number="798"></td>
+ <td id="LC798" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L799" class="blob-num js-line-number" data-line-number="799"></td>
+ <td id="LC799" class="blob-code blob-code-inner js-file-line"> s8 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L800" class="blob-num js-line-number" data-line-number="800"></td>
+ <td id="LC800" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L801" class="blob-num js-line-number" data-line-number="801"></td>
+ <td id="LC801" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s9 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L802" class="blob-num js-line-number" data-line-number="802"></td>
+ <td id="LC802" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s8</span>.<span class="pl-c1">push</span>(s9);</td>
+ </tr>
+ <tr>
+ <td id="L803" class="blob-num js-line-number" data-line-number="803"></td>
+ <td id="LC803" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L804" class="blob-num js-line-number" data-line-number="804"></td>
+ <td id="LC804" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L805" class="blob-num js-line-number" data-line-number="805"></td>
+ <td id="LC805" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s8 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L806" class="blob-num js-line-number" data-line-number="806"></td>
+ <td id="LC806" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">59</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L807" class="blob-num js-line-number" data-line-number="807"></td>
+ <td id="LC807" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$c8;</td>
+ </tr>
+ <tr>
+ <td id="L808" class="blob-num js-line-number" data-line-number="808"></td>
+ <td id="LC808" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L809" class="blob-num js-line-number" data-line-number="809"></td>
+ <td id="LC809" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L810" class="blob-num js-line-number" data-line-number="810"></td>
+ <td id="LC810" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L811" class="blob-num js-line-number" data-line-number="811"></td>
+ <td id="LC811" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c9); }</td>
+ </tr>
+ <tr>
+ <td id="L812" class="blob-num js-line-number" data-line-number="812"></td>
+ <td id="LC812" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L813" class="blob-num js-line-number" data-line-number="813"></td>
+ <td id="LC813" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s9 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L814" class="blob-num js-line-number" data-line-number="814"></td>
+ <td id="LC814" class="blob-code blob-code-inner js-file-line"> s9 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L815" class="blob-num js-line-number" data-line-number="815"></td>
+ <td id="LC815" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L816" class="blob-num js-line-number" data-line-number="816"></td>
+ <td id="LC816" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s9 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L817" class="blob-num js-line-number" data-line-number="817"></td>
+ <td id="LC817" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [s6, s7, s8, s9];</td>
+ </tr>
+ <tr>
+ <td id="L818" class="blob-num js-line-number" data-line-number="818"></td>
+ <td id="LC818" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> s6;</td>
+ </tr>
+ <tr>
+ <td id="L819" class="blob-num js-line-number" data-line-number="819"></td>
+ <td id="LC819" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L820" class="blob-num js-line-number" data-line-number="820"></td>
+ <td id="LC820" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L821" class="blob-num js-line-number" data-line-number="821"></td>
+ <td id="LC821" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L822" class="blob-num js-line-number" data-line-number="822"></td>
+ <td id="LC822" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L823" class="blob-num js-line-number" data-line-number="823"></td>
+ <td id="LC823" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L824" class="blob-num js-line-number" data-line-number="824"></td>
+ <td id="LC824" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L825" class="blob-num js-line-number" data-line-number="825"></td>
+ <td id="LC825" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L826" class="blob-num js-line-number" data-line-number="826"></td>
+ <td id="LC826" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L827" class="blob-num js-line-number" data-line-number="827"></td>
+ <td id="LC827" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L828" class="blob-num js-line-number" data-line-number="828"></td>
+ <td id="LC828" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L829" class="blob-num js-line-number" data-line-number="829"></td>
+ <td id="LC829" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L830" class="blob-num js-line-number" data-line-number="830"></td>
+ <td id="LC830" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L831" class="blob-num js-line-number" data-line-number="831"></td>
+ <td id="LC831" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L832" class="blob-num js-line-number" data-line-number="832"></td>
+ <td id="LC832" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L833" class="blob-num js-line-number" data-line-number="833"></td>
+ <td id="LC833" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L834" class="blob-num js-line-number" data-line-number="834"></td>
+ <td id="LC834" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L835" class="blob-num js-line-number" data-line-number="835"></td>
+ <td id="LC835" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L836" class="blob-num js-line-number" data-line-number="836"></td>
+ <td id="LC836" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L837" class="blob-num js-line-number" data-line-number="837"></td>
+ <td id="LC837" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L838" class="blob-num js-line-number" data-line-number="838"></td>
+ <td id="LC838" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c10</span>(s1, s4);</td>
+ </tr>
+ <tr>
+ <td id="L839" class="blob-num js-line-number" data-line-number="839"></td>
+ <td id="LC839" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L840" class="blob-num js-line-number" data-line-number="840"></td>
+ <td id="LC840" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L841" class="blob-num js-line-number" data-line-number="841"></td>
+ <td id="LC841" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L842" class="blob-num js-line-number" data-line-number="842"></td>
+ <td id="LC842" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L843" class="blob-num js-line-number" data-line-number="843"></td>
+ <td id="LC843" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L844" class="blob-num js-line-number" data-line-number="844"></td>
+ <td id="LC844" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L845" class="blob-num js-line-number" data-line-number="845"></td>
+ <td id="LC845" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L846" class="blob-num js-line-number" data-line-number="846"></td>
+ <td id="LC846" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L847" class="blob-num js-line-number" data-line-number="847"></td>
+ <td id="LC847" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L848" class="blob-num js-line-number" data-line-number="848"></td>
+ <td id="LC848" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L849" class="blob-num js-line-number" data-line-number="849"></td>
+ <td id="LC849" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L850" class="blob-num js-line-number" data-line-number="850"></td>
+ <td id="LC850" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L851" class="blob-num js-line-number" data-line-number="851"></td>
+ <td id="LC851" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L852" class="blob-num js-line-number" data-line-number="852"></td>
+ <td id="LC852" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L853" class="blob-num js-line-number" data-line-number="853"></td>
+ <td id="LC853" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L854" class="blob-num js-line-number" data-line-number="854"></td>
+ <td id="LC854" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L855" class="blob-num js-line-number" data-line-number="855"></td>
+ <td id="LC855" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L856" class="blob-num js-line-number" data-line-number="856"></td>
+ <td id="LC856" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L857" class="blob-num js-line-number" data-line-number="857"></td>
+ <td id="LC857" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L858" class="blob-num js-line-number" data-line-number="858"></td>
+ <td id="LC858" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L859" class="blob-num js-line-number" data-line-number="859"></td>
+ <td id="LC859" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L860" class="blob-num js-line-number" data-line-number="860"></td>
+ <td id="LC860" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsestmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L861" class="blob-num js-line-number" data-line-number="861"></td>
+ <td id="LC861" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L862" class="blob-num js-line-number" data-line-number="862"></td>
+ <td id="LC862" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L863" class="blob-num js-line-number" data-line-number="863"></td>
+ <td id="LC863" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L864" class="blob-num js-line-number" data-line-number="864"></td>
+ <td id="LC864" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L865" class="blob-num js-line-number" data-line-number="865"></td>
+ <td id="LC865" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parseedgeStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L866" class="blob-num js-line-number" data-line-number="866"></td>
+ <td id="LC866" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L867" class="blob-num js-line-number" data-line-number="867"></td>
+ <td id="LC867" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parsesubgraphStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L868" class="blob-num js-line-number" data-line-number="868"></td>
+ <td id="LC868" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L869" class="blob-num js-line-number" data-line-number="869"></td>
+ <td id="LC869" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parseinlineAttrStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L870" class="blob-num js-line-number" data-line-number="870"></td>
+ <td id="LC870" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L871" class="blob-num js-line-number" data-line-number="871"></td>
+ <td id="LC871" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parsenodeStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L872" class="blob-num js-line-number" data-line-number="872"></td>
+ <td id="LC872" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L873" class="blob-num js-line-number" data-line-number="873"></td>
+ <td id="LC873" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L874" class="blob-num js-line-number" data-line-number="874"></td>
+ <td id="LC874" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L875" class="blob-num js-line-number" data-line-number="875"></td>
+ <td id="LC875" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L876" class="blob-num js-line-number" data-line-number="876"></td>
+ <td id="LC876" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L877" class="blob-num js-line-number" data-line-number="877"></td>
+ <td id="LC877" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L878" class="blob-num js-line-number" data-line-number="878"></td>
+ <td id="LC878" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L879" class="blob-num js-line-number" data-line-number="879"></td>
+ <td id="LC879" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L880" class="blob-num js-line-number" data-line-number="880"></td>
+ <td id="LC880" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseattrStmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L881" class="blob-num js-line-number" data-line-number="881"></td>
+ <td id="LC881" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3;</td>
+ </tr>
+ <tr>
+ <td id="L882" class="blob-num js-line-number" data-line-number="882"></td>
+ <td id="LC882" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L883" class="blob-num js-line-number" data-line-number="883"></td>
+ <td id="LC883" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L884" class="blob-num js-line-number" data-line-number="884"></td>
+ <td id="LC884" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsegraph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L885" class="blob-num js-line-number" data-line-number="885"></td>
+ <td id="LC885" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L886" class="blob-num js-line-number" data-line-number="886"></td>
+ <td id="LC886" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsenode</span>();</td>
+ </tr>
+ <tr>
+ <td id="L887" class="blob-num js-line-number" data-line-number="887"></td>
+ <td id="LC887" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L888" class="blob-num js-line-number" data-line-number="888"></td>
+ <td id="LC888" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parseedge</span>();</td>
+ </tr>
+ <tr>
+ <td id="L889" class="blob-num js-line-number" data-line-number="889"></td>
+ <td id="LC889" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L890" class="blob-num js-line-number" data-line-number="890"></td>
+ <td id="LC890" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L891" class="blob-num js-line-number" data-line-number="891"></td>
+ <td id="LC891" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L892" class="blob-num js-line-number" data-line-number="892"></td>
+ <td id="LC892" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L893" class="blob-num js-line-number" data-line-number="893"></td>
+ <td id="LC893" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L894" class="blob-num js-line-number" data-line-number="894"></td>
+ <td id="LC894" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L895" class="blob-num js-line-number" data-line-number="895"></td>
+ <td id="LC895" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L896" class="blob-num js-line-number" data-line-number="896"></td>
+ <td id="LC896" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L897" class="blob-num js-line-number" data-line-number="897"></td>
+ <td id="LC897" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L898" class="blob-num js-line-number" data-line-number="898"></td>
+ <td id="LC898" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L899" class="blob-num js-line-number" data-line-number="899"></td>
+ <td id="LC899" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrList</span>();</td>
+ </tr>
+ <tr>
+ <td id="L900" class="blob-num js-line-number" data-line-number="900"></td>
+ <td id="LC900" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L901" class="blob-num js-line-number" data-line-number="901"></td>
+ <td id="LC901" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L902" class="blob-num js-line-number" data-line-number="902"></td>
+ <td id="LC902" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c11</span>(s1, s3);</td>
+ </tr>
+ <tr>
+ <td id="L903" class="blob-num js-line-number" data-line-number="903"></td>
+ <td id="LC903" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L904" class="blob-num js-line-number" data-line-number="904"></td>
+ <td id="LC904" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L905" class="blob-num js-line-number" data-line-number="905"></td>
+ <td id="LC905" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L906" class="blob-num js-line-number" data-line-number="906"></td>
+ <td id="LC906" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L907" class="blob-num js-line-number" data-line-number="907"></td>
+ <td id="LC907" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L908" class="blob-num js-line-number" data-line-number="908"></td>
+ <td id="LC908" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L909" class="blob-num js-line-number" data-line-number="909"></td>
+ <td id="LC909" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L910" class="blob-num js-line-number" data-line-number="910"></td>
+ <td id="LC910" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L911" class="blob-num js-line-number" data-line-number="911"></td>
+ <td id="LC911" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L912" class="blob-num js-line-number" data-line-number="912"></td>
+ <td id="LC912" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L913" class="blob-num js-line-number" data-line-number="913"></td>
+ <td id="LC913" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L914" class="blob-num js-line-number" data-line-number="914"></td>
+ <td id="LC914" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L915" class="blob-num js-line-number" data-line-number="915"></td>
+ <td id="LC915" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L916" class="blob-num js-line-number" data-line-number="916"></td>
+ <td id="LC916" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L917" class="blob-num js-line-number" data-line-number="917"></td>
+ <td id="LC917" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L918" class="blob-num js-line-number" data-line-number="918"></td>
+ <td id="LC918" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L919" class="blob-num js-line-number" data-line-number="919"></td>
+ <td id="LC919" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L920" class="blob-num js-line-number" data-line-number="920"></td>
+ <td id="LC920" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseinlineAttrStmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L921" class="blob-num js-line-number" data-line-number="921"></td>
+ <td id="LC921" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5;</td>
+ </tr>
+ <tr>
+ <td id="L922" class="blob-num js-line-number" data-line-number="922"></td>
+ <td id="LC922" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L923" class="blob-num js-line-number" data-line-number="923"></td>
+ <td id="LC923" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L924" class="blob-num js-line-number" data-line-number="924"></td>
+ <td id="LC924" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L925" class="blob-num js-line-number" data-line-number="925"></td>
+ <td id="LC925" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L926" class="blob-num js-line-number" data-line-number="926"></td>
+ <td id="LC926" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L927" class="blob-num js-line-number" data-line-number="927"></td>
+ <td id="LC927" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L928" class="blob-num js-line-number" data-line-number="928"></td>
+ <td id="LC928" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L929" class="blob-num js-line-number" data-line-number="929"></td>
+ <td id="LC929" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L930" class="blob-num js-line-number" data-line-number="930"></td>
+ <td id="LC930" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L931" class="blob-num js-line-number" data-line-number="931"></td>
+ <td id="LC931" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L932" class="blob-num js-line-number" data-line-number="932"></td>
+ <td id="LC932" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L933" class="blob-num js-line-number" data-line-number="933"></td>
+ <td id="LC933" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">61</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L934" class="blob-num js-line-number" data-line-number="934"></td>
+ <td id="LC934" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c12;</td>
+ </tr>
+ <tr>
+ <td id="L935" class="blob-num js-line-number" data-line-number="935"></td>
+ <td id="LC935" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L936" class="blob-num js-line-number" data-line-number="936"></td>
+ <td id="LC936" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L937" class="blob-num js-line-number" data-line-number="937"></td>
+ <td id="LC937" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L938" class="blob-num js-line-number" data-line-number="938"></td>
+ <td id="LC938" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c13); }</td>
+ </tr>
+ <tr>
+ <td id="L939" class="blob-num js-line-number" data-line-number="939"></td>
+ <td id="LC939" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L940" class="blob-num js-line-number" data-line-number="940"></td>
+ <td id="LC940" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L941" class="blob-num js-line-number" data-line-number="941"></td>
+ <td id="LC941" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L942" class="blob-num js-line-number" data-line-number="942"></td>
+ <td id="LC942" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L943" class="blob-num js-line-number" data-line-number="943"></td>
+ <td id="LC943" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L944" class="blob-num js-line-number" data-line-number="944"></td>
+ <td id="LC944" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L945" class="blob-num js-line-number" data-line-number="945"></td>
+ <td id="LC945" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L946" class="blob-num js-line-number" data-line-number="946"></td>
+ <td id="LC946" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L947" class="blob-num js-line-number" data-line-number="947"></td>
+ <td id="LC947" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L948" class="blob-num js-line-number" data-line-number="948"></td>
+ <td id="LC948" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L949" class="blob-num js-line-number" data-line-number="949"></td>
+ <td id="LC949" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L950" class="blob-num js-line-number" data-line-number="950"></td>
+ <td id="LC950" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L951" class="blob-num js-line-number" data-line-number="951"></td>
+ <td id="LC951" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c14</span>(s1, s5);</td>
+ </tr>
+ <tr>
+ <td id="L952" class="blob-num js-line-number" data-line-number="952"></td>
+ <td id="LC952" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L953" class="blob-num js-line-number" data-line-number="953"></td>
+ <td id="LC953" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L954" class="blob-num js-line-number" data-line-number="954"></td>
+ <td id="LC954" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L955" class="blob-num js-line-number" data-line-number="955"></td>
+ <td id="LC955" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L956" class="blob-num js-line-number" data-line-number="956"></td>
+ <td id="LC956" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L957" class="blob-num js-line-number" data-line-number="957"></td>
+ <td id="LC957" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L958" class="blob-num js-line-number" data-line-number="958"></td>
+ <td id="LC958" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L959" class="blob-num js-line-number" data-line-number="959"></td>
+ <td id="LC959" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L960" class="blob-num js-line-number" data-line-number="960"></td>
+ <td id="LC960" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L961" class="blob-num js-line-number" data-line-number="961"></td>
+ <td id="LC961" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L962" class="blob-num js-line-number" data-line-number="962"></td>
+ <td id="LC962" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L963" class="blob-num js-line-number" data-line-number="963"></td>
+ <td id="LC963" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L964" class="blob-num js-line-number" data-line-number="964"></td>
+ <td id="LC964" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L965" class="blob-num js-line-number" data-line-number="965"></td>
+ <td id="LC965" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L966" class="blob-num js-line-number" data-line-number="966"></td>
+ <td id="LC966" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L967" class="blob-num js-line-number" data-line-number="967"></td>
+ <td id="LC967" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L968" class="blob-num js-line-number" data-line-number="968"></td>
+ <td id="LC968" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L969" class="blob-num js-line-number" data-line-number="969"></td>
+ <td id="LC969" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L970" class="blob-num js-line-number" data-line-number="970"></td>
+ <td id="LC970" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L971" class="blob-num js-line-number" data-line-number="971"></td>
+ <td id="LC971" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L972" class="blob-num js-line-number" data-line-number="972"></td>
+ <td id="LC972" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L973" class="blob-num js-line-number" data-line-number="973"></td>
+ <td id="LC973" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L974" class="blob-num js-line-number" data-line-number="974"></td>
+ <td id="LC974" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L975" class="blob-num js-line-number" data-line-number="975"></td>
+ <td id="LC975" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L976" class="blob-num js-line-number" data-line-number="976"></td>
+ <td id="LC976" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L977" class="blob-num js-line-number" data-line-number="977"></td>
+ <td id="LC977" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsenodeStmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L978" class="blob-num js-line-number" data-line-number="978"></td>
+ <td id="LC978" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3;</td>
+ </tr>
+ <tr>
+ <td id="L979" class="blob-num js-line-number" data-line-number="979"></td>
+ <td id="LC979" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L980" class="blob-num js-line-number" data-line-number="980"></td>
+ <td id="LC980" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L981" class="blob-num js-line-number" data-line-number="981"></td>
+ <td id="LC981" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsenodeId</span>();</td>
+ </tr>
+ <tr>
+ <td id="L982" class="blob-num js-line-number" data-line-number="982"></td>
+ <td id="LC982" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L983" class="blob-num js-line-number" data-line-number="983"></td>
+ <td id="LC983" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L984" class="blob-num js-line-number" data-line-number="984"></td>
+ <td id="LC984" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L985" class="blob-num js-line-number" data-line-number="985"></td>
+ <td id="LC985" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L986" class="blob-num js-line-number" data-line-number="986"></td>
+ <td id="LC986" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L987" class="blob-num js-line-number" data-line-number="987"></td>
+ <td id="LC987" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L988" class="blob-num js-line-number" data-line-number="988"></td>
+ <td id="LC988" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L989" class="blob-num js-line-number" data-line-number="989"></td>
+ <td id="LC989" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L990" class="blob-num js-line-number" data-line-number="990"></td>
+ <td id="LC990" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrList</span>();</td>
+ </tr>
+ <tr>
+ <td id="L991" class="blob-num js-line-number" data-line-number="991"></td>
+ <td id="LC991" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L992" class="blob-num js-line-number" data-line-number="992"></td>
+ <td id="LC992" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L993" class="blob-num js-line-number" data-line-number="993"></td>
+ <td id="LC993" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L994" class="blob-num js-line-number" data-line-number="994"></td>
+ <td id="LC994" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L995" class="blob-num js-line-number" data-line-number="995"></td>
+ <td id="LC995" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L996" class="blob-num js-line-number" data-line-number="996"></td>
+ <td id="LC996" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c15</span>(s1, s3);</td>
+ </tr>
+ <tr>
+ <td id="L997" class="blob-num js-line-number" data-line-number="997"></td>
+ <td id="LC997" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L998" class="blob-num js-line-number" data-line-number="998"></td>
+ <td id="LC998" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L999" class="blob-num js-line-number" data-line-number="999"></td>
+ <td id="LC999" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1000" class="blob-num js-line-number" data-line-number="1000"></td>
+ <td id="LC1000" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1001" class="blob-num js-line-number" data-line-number="1001"></td>
+ <td id="LC1001" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1002" class="blob-num js-line-number" data-line-number="1002"></td>
+ <td id="LC1002" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1003" class="blob-num js-line-number" data-line-number="1003"></td>
+ <td id="LC1003" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1004" class="blob-num js-line-number" data-line-number="1004"></td>
+ <td id="LC1004" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1005" class="blob-num js-line-number" data-line-number="1005"></td>
+ <td id="LC1005" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1006" class="blob-num js-line-number" data-line-number="1006"></td>
+ <td id="LC1006" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1007" class="blob-num js-line-number" data-line-number="1007"></td>
+ <td id="LC1007" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1008" class="blob-num js-line-number" data-line-number="1008"></td>
+ <td id="LC1008" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1009" class="blob-num js-line-number" data-line-number="1009"></td>
+ <td id="LC1009" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1010" class="blob-num js-line-number" data-line-number="1010"></td>
+ <td id="LC1010" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1011" class="blob-num js-line-number" data-line-number="1011"></td>
+ <td id="LC1011" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1012" class="blob-num js-line-number" data-line-number="1012"></td>
+ <td id="LC1012" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1013" class="blob-num js-line-number" data-line-number="1013"></td>
+ <td id="LC1013" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1014" class="blob-num js-line-number" data-line-number="1014"></td>
+ <td id="LC1014" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseedgeStmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1015" class="blob-num js-line-number" data-line-number="1015"></td>
+ <td id="LC1015" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5;</td>
+ </tr>
+ <tr>
+ <td id="L1016" class="blob-num js-line-number" data-line-number="1016"></td>
+ <td id="LC1016" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1017" class="blob-num js-line-number" data-line-number="1017"></td>
+ <td id="LC1017" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1018" class="blob-num js-line-number" data-line-number="1018"></td>
+ <td id="LC1018" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsenodeIdOrSubgraph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1019" class="blob-num js-line-number" data-line-number="1019"></td>
+ <td id="LC1019" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1020" class="blob-num js-line-number" data-line-number="1020"></td>
+ <td id="LC1020" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1021" class="blob-num js-line-number" data-line-number="1021"></td>
+ <td id="LC1021" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1022" class="blob-num js-line-number" data-line-number="1022"></td>
+ <td id="LC1022" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1023" class="blob-num js-line-number" data-line-number="1023"></td>
+ <td id="LC1023" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1024" class="blob-num js-line-number" data-line-number="1024"></td>
+ <td id="LC1024" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1025" class="blob-num js-line-number" data-line-number="1025"></td>
+ <td id="LC1025" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1026" class="blob-num js-line-number" data-line-number="1026"></td>
+ <td id="LC1026" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1027" class="blob-num js-line-number" data-line-number="1027"></td>
+ <td id="LC1027" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parseedgeRHS</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1028" class="blob-num js-line-number" data-line-number="1028"></td>
+ <td id="LC1028" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1029" class="blob-num js-line-number" data-line-number="1029"></td>
+ <td id="LC1029" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1030" class="blob-num js-line-number" data-line-number="1030"></td>
+ <td id="LC1030" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1031" class="blob-num js-line-number" data-line-number="1031"></td>
+ <td id="LC1031" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1032" class="blob-num js-line-number" data-line-number="1032"></td>
+ <td id="LC1032" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1033" class="blob-num js-line-number" data-line-number="1033"></td>
+ <td id="LC1033" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1034" class="blob-num js-line-number" data-line-number="1034"></td>
+ <td id="LC1034" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1035" class="blob-num js-line-number" data-line-number="1035"></td>
+ <td id="LC1035" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1036" class="blob-num js-line-number" data-line-number="1036"></td>
+ <td id="LC1036" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrList</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1037" class="blob-num js-line-number" data-line-number="1037"></td>
+ <td id="LC1037" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1038" class="blob-num js-line-number" data-line-number="1038"></td>
+ <td id="LC1038" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1039" class="blob-num js-line-number" data-line-number="1039"></td>
+ <td id="LC1039" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1040" class="blob-num js-line-number" data-line-number="1040"></td>
+ <td id="LC1040" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1041" class="blob-num js-line-number" data-line-number="1041"></td>
+ <td id="LC1041" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1042" class="blob-num js-line-number" data-line-number="1042"></td>
+ <td id="LC1042" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c16</span>(s1, s3, s5);</td>
+ </tr>
+ <tr>
+ <td id="L1043" class="blob-num js-line-number" data-line-number="1043"></td>
+ <td id="LC1043" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1044" class="blob-num js-line-number" data-line-number="1044"></td>
+ <td id="LC1044" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1045" class="blob-num js-line-number" data-line-number="1045"></td>
+ <td id="LC1045" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1046" class="blob-num js-line-number" data-line-number="1046"></td>
+ <td id="LC1046" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1047" class="blob-num js-line-number" data-line-number="1047"></td>
+ <td id="LC1047" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1048" class="blob-num js-line-number" data-line-number="1048"></td>
+ <td id="LC1048" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1049" class="blob-num js-line-number" data-line-number="1049"></td>
+ <td id="LC1049" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1050" class="blob-num js-line-number" data-line-number="1050"></td>
+ <td id="LC1050" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1051" class="blob-num js-line-number" data-line-number="1051"></td>
+ <td id="LC1051" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1052" class="blob-num js-line-number" data-line-number="1052"></td>
+ <td id="LC1052" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1053" class="blob-num js-line-number" data-line-number="1053"></td>
+ <td id="LC1053" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1054" class="blob-num js-line-number" data-line-number="1054"></td>
+ <td id="LC1054" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1055" class="blob-num js-line-number" data-line-number="1055"></td>
+ <td id="LC1055" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1056" class="blob-num js-line-number" data-line-number="1056"></td>
+ <td id="LC1056" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1057" class="blob-num js-line-number" data-line-number="1057"></td>
+ <td id="LC1057" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1058" class="blob-num js-line-number" data-line-number="1058"></td>
+ <td id="LC1058" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1059" class="blob-num js-line-number" data-line-number="1059"></td>
+ <td id="LC1059" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1060" class="blob-num js-line-number" data-line-number="1060"></td>
+ <td id="LC1060" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1061" class="blob-num js-line-number" data-line-number="1061"></td>
+ <td id="LC1061" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1062" class="blob-num js-line-number" data-line-number="1062"></td>
+ <td id="LC1062" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1063" class="blob-num js-line-number" data-line-number="1063"></td>
+ <td id="LC1063" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1064" class="blob-num js-line-number" data-line-number="1064"></td>
+ <td id="LC1064" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1065" class="blob-num js-line-number" data-line-number="1065"></td>
+ <td id="LC1065" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1066" class="blob-num js-line-number" data-line-number="1066"></td>
+ <td id="LC1066" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1067" class="blob-num js-line-number" data-line-number="1067"></td>
+ <td id="LC1067" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1068" class="blob-num js-line-number" data-line-number="1068"></td>
+ <td id="LC1068" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsesubgraphStmt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1069" class="blob-num js-line-number" data-line-number="1069"></td>
+ <td id="LC1069" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6, s7;</td>
+ </tr>
+ <tr>
+ <td id="L1070" class="blob-num js-line-number" data-line-number="1070"></td>
+ <td id="LC1070" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1071" class="blob-num js-line-number" data-line-number="1071"></td>
+ <td id="LC1071" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1072" class="blob-num js-line-number" data-line-number="1072"></td>
+ <td id="LC1072" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1073" class="blob-num js-line-number" data-line-number="1073"></td>
+ <td id="LC1073" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> <span class="pl-en">peg$parsesubgraph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1074" class="blob-num js-line-number" data-line-number="1074"></td>
+ <td id="LC1074" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1075" class="blob-num js-line-number" data-line-number="1075"></td>
+ <td id="LC1075" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1076" class="blob-num js-line-number" data-line-number="1076"></td>
+ <td id="LC1076" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1077" class="blob-num js-line-number" data-line-number="1077"></td>
+ <td id="LC1077" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1078" class="blob-num js-line-number" data-line-number="1078"></td>
+ <td id="LC1078" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s3</span>.<span class="pl-c1">push</span>(s4);</td>
+ </tr>
+ <tr>
+ <td id="L1079" class="blob-num js-line-number" data-line-number="1079"></td>
+ <td id="LC1079" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1080" class="blob-num js-line-number" data-line-number="1080"></td>
+ <td id="LC1080" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1081" class="blob-num js-line-number" data-line-number="1081"></td>
+ <td id="LC1081" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1082" class="blob-num js-line-number" data-line-number="1082"></td>
+ <td id="LC1082" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1083" class="blob-num js-line-number" data-line-number="1083"></td>
+ <td id="LC1083" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1084" class="blob-num js-line-number" data-line-number="1084"></td>
+ <td id="LC1084" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1085" class="blob-num js-line-number" data-line-number="1085"></td>
+ <td id="LC1085" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1086" class="blob-num js-line-number" data-line-number="1086"></td>
+ <td id="LC1086" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1087" class="blob-num js-line-number" data-line-number="1087"></td>
+ <td id="LC1087" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1088" class="blob-num js-line-number" data-line-number="1088"></td>
+ <td id="LC1088" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s6</span>.<span class="pl-c1">push</span>(s7);</td>
+ </tr>
+ <tr>
+ <td id="L1089" class="blob-num js-line-number" data-line-number="1089"></td>
+ <td id="LC1089" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1090" class="blob-num js-line-number" data-line-number="1090"></td>
+ <td id="LC1090" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1091" class="blob-num js-line-number" data-line-number="1091"></td>
+ <td id="LC1091" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1092" class="blob-num js-line-number" data-line-number="1092"></td>
+ <td id="LC1092" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> [s5, s6];</td>
+ </tr>
+ <tr>
+ <td id="L1093" class="blob-num js-line-number" data-line-number="1093"></td>
+ <td id="LC1093" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L1094" class="blob-num js-line-number" data-line-number="1094"></td>
+ <td id="LC1094" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1095" class="blob-num js-line-number" data-line-number="1095"></td>
+ <td id="LC1095" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L1096" class="blob-num js-line-number" data-line-number="1096"></td>
+ <td id="LC1096" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1097" class="blob-num js-line-number" data-line-number="1097"></td>
+ <td id="LC1097" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1098" class="blob-num js-line-number" data-line-number="1098"></td>
+ <td id="LC1098" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1099" class="blob-num js-line-number" data-line-number="1099"></td>
+ <td id="LC1099" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L1100" class="blob-num js-line-number" data-line-number="1100"></td>
+ <td id="LC1100" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1101" class="blob-num js-line-number" data-line-number="1101"></td>
+ <td id="LC1101" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1102" class="blob-num js-line-number" data-line-number="1102"></td>
+ <td id="LC1102" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1103" class="blob-num js-line-number" data-line-number="1103"></td>
+ <td id="LC1103" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1104" class="blob-num js-line-number" data-line-number="1104"></td>
+ <td id="LC1104" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1105" class="blob-num js-line-number" data-line-number="1105"></td>
+ <td id="LC1105" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1106" class="blob-num js-line-number" data-line-number="1106"></td>
+ <td id="LC1106" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [s2, s3, s4];</td>
+ </tr>
+ <tr>
+ <td id="L1107" class="blob-num js-line-number" data-line-number="1107"></td>
+ <td id="LC1107" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1108" class="blob-num js-line-number" data-line-number="1108"></td>
+ <td id="LC1108" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1109" class="blob-num js-line-number" data-line-number="1109"></td>
+ <td id="LC1109" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1110" class="blob-num js-line-number" data-line-number="1110"></td>
+ <td id="LC1110" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1111" class="blob-num js-line-number" data-line-number="1111"></td>
+ <td id="LC1111" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1112" class="blob-num js-line-number" data-line-number="1112"></td>
+ <td id="LC1112" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1113" class="blob-num js-line-number" data-line-number="1113"></td>
+ <td id="LC1113" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1114" class="blob-num js-line-number" data-line-number="1114"></td>
+ <td id="LC1114" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1115" class="blob-num js-line-number" data-line-number="1115"></td>
+ <td id="LC1115" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1116" class="blob-num js-line-number" data-line-number="1116"></td>
+ <td id="LC1116" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1117" class="blob-num js-line-number" data-line-number="1117"></td>
+ <td id="LC1117" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1118" class="blob-num js-line-number" data-line-number="1118"></td>
+ <td id="LC1118" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1119" class="blob-num js-line-number" data-line-number="1119"></td>
+ <td id="LC1119" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1120" class="blob-num js-line-number" data-line-number="1120"></td>
+ <td id="LC1120" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1121" class="blob-num js-line-number" data-line-number="1121"></td>
+ <td id="LC1121" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1122" class="blob-num js-line-number" data-line-number="1122"></td>
+ <td id="LC1122" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1123" class="blob-num js-line-number" data-line-number="1123"></td>
+ <td id="LC1123" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1124" class="blob-num js-line-number" data-line-number="1124"></td>
+ <td id="LC1124" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">123</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1125" class="blob-num js-line-number" data-line-number="1125"></td>
+ <td id="LC1125" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c3;</td>
+ </tr>
+ <tr>
+ <td id="L1126" class="blob-num js-line-number" data-line-number="1126"></td>
+ <td id="LC1126" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1127" class="blob-num js-line-number" data-line-number="1127"></td>
+ <td id="LC1127" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1128" class="blob-num js-line-number" data-line-number="1128"></td>
+ <td id="LC1128" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1129" class="blob-num js-line-number" data-line-number="1129"></td>
+ <td id="LC1129" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c4); }</td>
+ </tr>
+ <tr>
+ <td id="L1130" class="blob-num js-line-number" data-line-number="1130"></td>
+ <td id="LC1130" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1131" class="blob-num js-line-number" data-line-number="1131"></td>
+ <td id="LC1131" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1132" class="blob-num js-line-number" data-line-number="1132"></td>
+ <td id="LC1132" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1133" class="blob-num js-line-number" data-line-number="1133"></td>
+ <td id="LC1133" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1134" class="blob-num js-line-number" data-line-number="1134"></td>
+ <td id="LC1134" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1135" class="blob-num js-line-number" data-line-number="1135"></td>
+ <td id="LC1135" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s3</span>.<span class="pl-c1">push</span>(s4);</td>
+ </tr>
+ <tr>
+ <td id="L1136" class="blob-num js-line-number" data-line-number="1136"></td>
+ <td id="LC1136" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1137" class="blob-num js-line-number" data-line-number="1137"></td>
+ <td id="LC1137" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1138" class="blob-num js-line-number" data-line-number="1138"></td>
+ <td id="LC1138" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1139" class="blob-num js-line-number" data-line-number="1139"></td>
+ <td id="LC1139" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parsestmtList</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1140" class="blob-num js-line-number" data-line-number="1140"></td>
+ <td id="LC1140" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1141" class="blob-num js-line-number" data-line-number="1141"></td>
+ <td id="LC1141" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1142" class="blob-num js-line-number" data-line-number="1142"></td>
+ <td id="LC1142" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1143" class="blob-num js-line-number" data-line-number="1143"></td>
+ <td id="LC1143" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1144" class="blob-num js-line-number" data-line-number="1144"></td>
+ <td id="LC1144" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1145" class="blob-num js-line-number" data-line-number="1145"></td>
+ <td id="LC1145" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1146" class="blob-num js-line-number" data-line-number="1146"></td>
+ <td id="LC1146" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1147" class="blob-num js-line-number" data-line-number="1147"></td>
+ <td id="LC1147" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s5</span>.<span class="pl-c1">push</span>(s6);</td>
+ </tr>
+ <tr>
+ <td id="L1148" class="blob-num js-line-number" data-line-number="1148"></td>
+ <td id="LC1148" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1149" class="blob-num js-line-number" data-line-number="1149"></td>
+ <td id="LC1149" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1150" class="blob-num js-line-number" data-line-number="1150"></td>
+ <td id="LC1150" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1151" class="blob-num js-line-number" data-line-number="1151"></td>
+ <td id="LC1151" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">125</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1152" class="blob-num js-line-number" data-line-number="1152"></td>
+ <td id="LC1152" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> peg$c5;</td>
+ </tr>
+ <tr>
+ <td id="L1153" class="blob-num js-line-number" data-line-number="1153"></td>
+ <td id="LC1153" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1154" class="blob-num js-line-number" data-line-number="1154"></td>
+ <td id="LC1154" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1155" class="blob-num js-line-number" data-line-number="1155"></td>
+ <td id="LC1155" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1156" class="blob-num js-line-number" data-line-number="1156"></td>
+ <td id="LC1156" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c6); }</td>
+ </tr>
+ <tr>
+ <td id="L1157" class="blob-num js-line-number" data-line-number="1157"></td>
+ <td id="LC1157" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1158" class="blob-num js-line-number" data-line-number="1158"></td>
+ <td id="LC1158" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1159" class="blob-num js-line-number" data-line-number="1159"></td>
+ <td id="LC1159" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1160" class="blob-num js-line-number" data-line-number="1160"></td>
+ <td id="LC1160" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c17</span>(s1, s4);</td>
+ </tr>
+ <tr>
+ <td id="L1161" class="blob-num js-line-number" data-line-number="1161"></td>
+ <td id="LC1161" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1162" class="blob-num js-line-number" data-line-number="1162"></td>
+ <td id="LC1162" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1163" class="blob-num js-line-number" data-line-number="1163"></td>
+ <td id="LC1163" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1164" class="blob-num js-line-number" data-line-number="1164"></td>
+ <td id="LC1164" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1165" class="blob-num js-line-number" data-line-number="1165"></td>
+ <td id="LC1165" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1166" class="blob-num js-line-number" data-line-number="1166"></td>
+ <td id="LC1166" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1167" class="blob-num js-line-number" data-line-number="1167"></td>
+ <td id="LC1167" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1168" class="blob-num js-line-number" data-line-number="1168"></td>
+ <td id="LC1168" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1169" class="blob-num js-line-number" data-line-number="1169"></td>
+ <td id="LC1169" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1170" class="blob-num js-line-number" data-line-number="1170"></td>
+ <td id="LC1170" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1171" class="blob-num js-line-number" data-line-number="1171"></td>
+ <td id="LC1171" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1172" class="blob-num js-line-number" data-line-number="1172"></td>
+ <td id="LC1172" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1173" class="blob-num js-line-number" data-line-number="1173"></td>
+ <td id="LC1173" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1174" class="blob-num js-line-number" data-line-number="1174"></td>
+ <td id="LC1174" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1175" class="blob-num js-line-number" data-line-number="1175"></td>
+ <td id="LC1175" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1176" class="blob-num js-line-number" data-line-number="1176"></td>
+ <td id="LC1176" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1177" class="blob-num js-line-number" data-line-number="1177"></td>
+ <td id="LC1177" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1178" class="blob-num js-line-number" data-line-number="1178"></td>
+ <td id="LC1178" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1179" class="blob-num js-line-number" data-line-number="1179"></td>
+ <td id="LC1179" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1180" class="blob-num js-line-number" data-line-number="1180"></td>
+ <td id="LC1180" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1181" class="blob-num js-line-number" data-line-number="1181"></td>
+ <td id="LC1181" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1182" class="blob-num js-line-number" data-line-number="1182"></td>
+ <td id="LC1182" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1183" class="blob-num js-line-number" data-line-number="1183"></td>
+ <td id="LC1183" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1184" class="blob-num js-line-number" data-line-number="1184"></td>
+ <td id="LC1184" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1185" class="blob-num js-line-number" data-line-number="1185"></td>
+ <td id="LC1185" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1186" class="blob-num js-line-number" data-line-number="1186"></td>
+ <td id="LC1186" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1187" class="blob-num js-line-number" data-line-number="1187"></td>
+ <td id="LC1187" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1188" class="blob-num js-line-number" data-line-number="1188"></td>
+ <td id="LC1188" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1189" class="blob-num js-line-number" data-line-number="1189"></td>
+ <td id="LC1189" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1190" class="blob-num js-line-number" data-line-number="1190"></td>
+ <td id="LC1190" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseattrList</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1191" class="blob-num js-line-number" data-line-number="1191"></td>
+ <td id="LC1191" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5;</td>
+ </tr>
+ <tr>
+ <td id="L1192" class="blob-num js-line-number" data-line-number="1192"></td>
+ <td id="LC1192" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1193" class="blob-num js-line-number" data-line-number="1193"></td>
+ <td id="LC1193" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1194" class="blob-num js-line-number" data-line-number="1194"></td>
+ <td id="LC1194" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrListBlock</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1195" class="blob-num js-line-number" data-line-number="1195"></td>
+ <td id="LC1195" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1196" class="blob-num js-line-number" data-line-number="1196"></td>
+ <td id="LC1196" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1197" class="blob-num js-line-number" data-line-number="1197"></td>
+ <td id="LC1197" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1198" class="blob-num js-line-number" data-line-number="1198"></td>
+ <td id="LC1198" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1199" class="blob-num js-line-number" data-line-number="1199"></td>
+ <td id="LC1199" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1200" class="blob-num js-line-number" data-line-number="1200"></td>
+ <td id="LC1200" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1201" class="blob-num js-line-number" data-line-number="1201"></td>
+ <td id="LC1201" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1202" class="blob-num js-line-number" data-line-number="1202"></td>
+ <td id="LC1202" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1203" class="blob-num js-line-number" data-line-number="1203"></td>
+ <td id="LC1203" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1204" class="blob-num js-line-number" data-line-number="1204"></td>
+ <td id="LC1204" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1205" class="blob-num js-line-number" data-line-number="1205"></td>
+ <td id="LC1205" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrListBlock</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1206" class="blob-num js-line-number" data-line-number="1206"></td>
+ <td id="LC1206" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1207" class="blob-num js-line-number" data-line-number="1207"></td>
+ <td id="LC1207" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5];</td>
+ </tr>
+ <tr>
+ <td id="L1208" class="blob-num js-line-number" data-line-number="1208"></td>
+ <td id="LC1208" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L1209" class="blob-num js-line-number" data-line-number="1209"></td>
+ <td id="LC1209" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1210" class="blob-num js-line-number" data-line-number="1210"></td>
+ <td id="LC1210" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1211" class="blob-num js-line-number" data-line-number="1211"></td>
+ <td id="LC1211" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1212" class="blob-num js-line-number" data-line-number="1212"></td>
+ <td id="LC1212" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1213" class="blob-num js-line-number" data-line-number="1213"></td>
+ <td id="LC1213" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1214" class="blob-num js-line-number" data-line-number="1214"></td>
+ <td id="LC1214" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1215" class="blob-num js-line-number" data-line-number="1215"></td>
+ <td id="LC1215" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1216" class="blob-num js-line-number" data-line-number="1216"></td>
+ <td id="LC1216" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1217" class="blob-num js-line-number" data-line-number="1217"></td>
+ <td id="LC1217" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1218" class="blob-num js-line-number" data-line-number="1218"></td>
+ <td id="LC1218" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1219" class="blob-num js-line-number" data-line-number="1219"></td>
+ <td id="LC1219" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1220" class="blob-num js-line-number" data-line-number="1220"></td>
+ <td id="LC1220" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1221" class="blob-num js-line-number" data-line-number="1221"></td>
+ <td id="LC1221" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1222" class="blob-num js-line-number" data-line-number="1222"></td>
+ <td id="LC1222" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1223" class="blob-num js-line-number" data-line-number="1223"></td>
+ <td id="LC1223" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1224" class="blob-num js-line-number" data-line-number="1224"></td>
+ <td id="LC1224" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1225" class="blob-num js-line-number" data-line-number="1225"></td>
+ <td id="LC1225" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1226" class="blob-num js-line-number" data-line-number="1226"></td>
+ <td id="LC1226" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1227" class="blob-num js-line-number" data-line-number="1227"></td>
+ <td id="LC1227" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseattrListBlock</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1228" class="blob-num js-line-number" data-line-number="1228"></td>
+ <td id="LC1228" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1229" class="blob-num js-line-number" data-line-number="1229"></td>
+ <td id="LC1229" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5];</td>
+ </tr>
+ <tr>
+ <td id="L1230" class="blob-num js-line-number" data-line-number="1230"></td>
+ <td id="LC1230" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L1231" class="blob-num js-line-number" data-line-number="1231"></td>
+ <td id="LC1231" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1232" class="blob-num js-line-number" data-line-number="1232"></td>
+ <td id="LC1232" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1233" class="blob-num js-line-number" data-line-number="1233"></td>
+ <td id="LC1233" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1234" class="blob-num js-line-number" data-line-number="1234"></td>
+ <td id="LC1234" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1235" class="blob-num js-line-number" data-line-number="1235"></td>
+ <td id="LC1235" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1236" class="blob-num js-line-number" data-line-number="1236"></td>
+ <td id="LC1236" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1237" class="blob-num js-line-number" data-line-number="1237"></td>
+ <td id="LC1237" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1238" class="blob-num js-line-number" data-line-number="1238"></td>
+ <td id="LC1238" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1239" class="blob-num js-line-number" data-line-number="1239"></td>
+ <td id="LC1239" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1240" class="blob-num js-line-number" data-line-number="1240"></td>
+ <td id="LC1240" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1241" class="blob-num js-line-number" data-line-number="1241"></td>
+ <td id="LC1241" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1242" class="blob-num js-line-number" data-line-number="1242"></td>
+ <td id="LC1242" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c18</span>(s1, s2);</td>
+ </tr>
+ <tr>
+ <td id="L1243" class="blob-num js-line-number" data-line-number="1243"></td>
+ <td id="LC1243" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1244" class="blob-num js-line-number" data-line-number="1244"></td>
+ <td id="LC1244" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1245" class="blob-num js-line-number" data-line-number="1245"></td>
+ <td id="LC1245" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1246" class="blob-num js-line-number" data-line-number="1246"></td>
+ <td id="LC1246" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1247" class="blob-num js-line-number" data-line-number="1247"></td>
+ <td id="LC1247" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1248" class="blob-num js-line-number" data-line-number="1248"></td>
+ <td id="LC1248" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1249" class="blob-num js-line-number" data-line-number="1249"></td>
+ <td id="LC1249" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1250" class="blob-num js-line-number" data-line-number="1250"></td>
+ <td id="LC1250" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1251" class="blob-num js-line-number" data-line-number="1251"></td>
+ <td id="LC1251" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1252" class="blob-num js-line-number" data-line-number="1252"></td>
+ <td id="LC1252" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1253" class="blob-num js-line-number" data-line-number="1253"></td>
+ <td id="LC1253" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1254" class="blob-num js-line-number" data-line-number="1254"></td>
+ <td id="LC1254" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1255" class="blob-num js-line-number" data-line-number="1255"></td>
+ <td id="LC1255" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1256" class="blob-num js-line-number" data-line-number="1256"></td>
+ <td id="LC1256" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseattrListBlock</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1257" class="blob-num js-line-number" data-line-number="1257"></td>
+ <td id="LC1257" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5;</td>
+ </tr>
+ <tr>
+ <td id="L1258" class="blob-num js-line-number" data-line-number="1258"></td>
+ <td id="LC1258" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1259" class="blob-num js-line-number" data-line-number="1259"></td>
+ <td id="LC1259" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1260" class="blob-num js-line-number" data-line-number="1260"></td>
+ <td id="LC1260" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">91</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1261" class="blob-num js-line-number" data-line-number="1261"></td>
+ <td id="LC1261" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c19;</td>
+ </tr>
+ <tr>
+ <td id="L1262" class="blob-num js-line-number" data-line-number="1262"></td>
+ <td id="LC1262" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1263" class="blob-num js-line-number" data-line-number="1263"></td>
+ <td id="LC1263" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1264" class="blob-num js-line-number" data-line-number="1264"></td>
+ <td id="LC1264" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1265" class="blob-num js-line-number" data-line-number="1265"></td>
+ <td id="LC1265" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c20); }</td>
+ </tr>
+ <tr>
+ <td id="L1266" class="blob-num js-line-number" data-line-number="1266"></td>
+ <td id="LC1266" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1267" class="blob-num js-line-number" data-line-number="1267"></td>
+ <td id="LC1267" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1268" class="blob-num js-line-number" data-line-number="1268"></td>
+ <td id="LC1268" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1269" class="blob-num js-line-number" data-line-number="1269"></td>
+ <td id="LC1269" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1270" class="blob-num js-line-number" data-line-number="1270"></td>
+ <td id="LC1270" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1271" class="blob-num js-line-number" data-line-number="1271"></td>
+ <td id="LC1271" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1272" class="blob-num js-line-number" data-line-number="1272"></td>
+ <td id="LC1272" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1273" class="blob-num js-line-number" data-line-number="1273"></td>
+ <td id="LC1273" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1274" class="blob-num js-line-number" data-line-number="1274"></td>
+ <td id="LC1274" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1275" class="blob-num js-line-number" data-line-number="1275"></td>
+ <td id="LC1275" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parseaList</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1276" class="blob-num js-line-number" data-line-number="1276"></td>
+ <td id="LC1276" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1277" class="blob-num js-line-number" data-line-number="1277"></td>
+ <td id="LC1277" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1278" class="blob-num js-line-number" data-line-number="1278"></td>
+ <td id="LC1278" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1279" class="blob-num js-line-number" data-line-number="1279"></td>
+ <td id="LC1279" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1280" class="blob-num js-line-number" data-line-number="1280"></td>
+ <td id="LC1280" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1281" class="blob-num js-line-number" data-line-number="1281"></td>
+ <td id="LC1281" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1282" class="blob-num js-line-number" data-line-number="1282"></td>
+ <td id="LC1282" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1283" class="blob-num js-line-number" data-line-number="1283"></td>
+ <td id="LC1283" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1284" class="blob-num js-line-number" data-line-number="1284"></td>
+ <td id="LC1284" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1285" class="blob-num js-line-number" data-line-number="1285"></td>
+ <td id="LC1285" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1286" class="blob-num js-line-number" data-line-number="1286"></td>
+ <td id="LC1286" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1287" class="blob-num js-line-number" data-line-number="1287"></td>
+ <td id="LC1287" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">93</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1288" class="blob-num js-line-number" data-line-number="1288"></td>
+ <td id="LC1288" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c21;</td>
+ </tr>
+ <tr>
+ <td id="L1289" class="blob-num js-line-number" data-line-number="1289"></td>
+ <td id="LC1289" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1290" class="blob-num js-line-number" data-line-number="1290"></td>
+ <td id="LC1290" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1291" class="blob-num js-line-number" data-line-number="1291"></td>
+ <td id="LC1291" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1292" class="blob-num js-line-number" data-line-number="1292"></td>
+ <td id="LC1292" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c22); }</td>
+ </tr>
+ <tr>
+ <td id="L1293" class="blob-num js-line-number" data-line-number="1293"></td>
+ <td id="LC1293" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1294" class="blob-num js-line-number" data-line-number="1294"></td>
+ <td id="LC1294" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1295" class="blob-num js-line-number" data-line-number="1295"></td>
+ <td id="LC1295" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1296" class="blob-num js-line-number" data-line-number="1296"></td>
+ <td id="LC1296" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c23</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1297" class="blob-num js-line-number" data-line-number="1297"></td>
+ <td id="LC1297" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1298" class="blob-num js-line-number" data-line-number="1298"></td>
+ <td id="LC1298" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1299" class="blob-num js-line-number" data-line-number="1299"></td>
+ <td id="LC1299" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1300" class="blob-num js-line-number" data-line-number="1300"></td>
+ <td id="LC1300" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1301" class="blob-num js-line-number" data-line-number="1301"></td>
+ <td id="LC1301" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1302" class="blob-num js-line-number" data-line-number="1302"></td>
+ <td id="LC1302" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1303" class="blob-num js-line-number" data-line-number="1303"></td>
+ <td id="LC1303" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1304" class="blob-num js-line-number" data-line-number="1304"></td>
+ <td id="LC1304" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1305" class="blob-num js-line-number" data-line-number="1305"></td>
+ <td id="LC1305" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1306" class="blob-num js-line-number" data-line-number="1306"></td>
+ <td id="LC1306" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1307" class="blob-num js-line-number" data-line-number="1307"></td>
+ <td id="LC1307" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1308" class="blob-num js-line-number" data-line-number="1308"></td>
+ <td id="LC1308" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1309" class="blob-num js-line-number" data-line-number="1309"></td>
+ <td id="LC1309" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1310" class="blob-num js-line-number" data-line-number="1310"></td>
+ <td id="LC1310" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1311" class="blob-num js-line-number" data-line-number="1311"></td>
+ <td id="LC1311" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1312" class="blob-num js-line-number" data-line-number="1312"></td>
+ <td id="LC1312" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1313" class="blob-num js-line-number" data-line-number="1313"></td>
+ <td id="LC1313" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1314" class="blob-num js-line-number" data-line-number="1314"></td>
+ <td id="LC1314" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1315" class="blob-num js-line-number" data-line-number="1315"></td>
+ <td id="LC1315" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1316" class="blob-num js-line-number" data-line-number="1316"></td>
+ <td id="LC1316" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1317" class="blob-num js-line-number" data-line-number="1317"></td>
+ <td id="LC1317" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1318" class="blob-num js-line-number" data-line-number="1318"></td>
+ <td id="LC1318" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1319" class="blob-num js-line-number" data-line-number="1319"></td>
+ <td id="LC1319" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1320" class="blob-num js-line-number" data-line-number="1320"></td>
+ <td id="LC1320" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1321" class="blob-num js-line-number" data-line-number="1321"></td>
+ <td id="LC1321" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1322" class="blob-num js-line-number" data-line-number="1322"></td>
+ <td id="LC1322" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseaList</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1323" class="blob-num js-line-number" data-line-number="1323"></td>
+ <td id="LC1323" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6, s7;</td>
+ </tr>
+ <tr>
+ <td id="L1324" class="blob-num js-line-number" data-line-number="1324"></td>
+ <td id="LC1324" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1325" class="blob-num js-line-number" data-line-number="1325"></td>
+ <td id="LC1325" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1326" class="blob-num js-line-number" data-line-number="1326"></td>
+ <td id="LC1326" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parseidDef</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1327" class="blob-num js-line-number" data-line-number="1327"></td>
+ <td id="LC1327" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1328" class="blob-num js-line-number" data-line-number="1328"></td>
+ <td id="LC1328" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1329" class="blob-num js-line-number" data-line-number="1329"></td>
+ <td id="LC1329" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1330" class="blob-num js-line-number" data-line-number="1330"></td>
+ <td id="LC1330" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1331" class="blob-num js-line-number" data-line-number="1331"></td>
+ <td id="LC1331" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1332" class="blob-num js-line-number" data-line-number="1332"></td>
+ <td id="LC1332" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1333" class="blob-num js-line-number" data-line-number="1333"></td>
+ <td id="LC1333" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1334" class="blob-num js-line-number" data-line-number="1334"></td>
+ <td id="LC1334" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1335" class="blob-num js-line-number" data-line-number="1335"></td>
+ <td id="LC1335" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1336" class="blob-num js-line-number" data-line-number="1336"></td>
+ <td id="LC1336" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1337" class="blob-num js-line-number" data-line-number="1337"></td>
+ <td id="LC1337" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">44</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1338" class="blob-num js-line-number" data-line-number="1338"></td>
+ <td id="LC1338" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c24;</td>
+ </tr>
+ <tr>
+ <td id="L1339" class="blob-num js-line-number" data-line-number="1339"></td>
+ <td id="LC1339" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1340" class="blob-num js-line-number" data-line-number="1340"></td>
+ <td id="LC1340" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1341" class="blob-num js-line-number" data-line-number="1341"></td>
+ <td id="LC1341" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1342" class="blob-num js-line-number" data-line-number="1342"></td>
+ <td id="LC1342" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c25); }</td>
+ </tr>
+ <tr>
+ <td id="L1343" class="blob-num js-line-number" data-line-number="1343"></td>
+ <td id="LC1343" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1344" class="blob-num js-line-number" data-line-number="1344"></td>
+ <td id="LC1344" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1345" class="blob-num js-line-number" data-line-number="1345"></td>
+ <td id="LC1345" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1346" class="blob-num js-line-number" data-line-number="1346"></td>
+ <td id="LC1346" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1347" class="blob-num js-line-number" data-line-number="1347"></td>
+ <td id="LC1347" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1348" class="blob-num js-line-number" data-line-number="1348"></td>
+ <td id="LC1348" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1349" class="blob-num js-line-number" data-line-number="1349"></td>
+ <td id="LC1349" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1350" class="blob-num js-line-number" data-line-number="1350"></td>
+ <td id="LC1350" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1351" class="blob-num js-line-number" data-line-number="1351"></td>
+ <td id="LC1351" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s6</span>.<span class="pl-c1">push</span>(s7);</td>
+ </tr>
+ <tr>
+ <td id="L1352" class="blob-num js-line-number" data-line-number="1352"></td>
+ <td id="LC1352" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1353" class="blob-num js-line-number" data-line-number="1353"></td>
+ <td id="LC1353" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1354" class="blob-num js-line-number" data-line-number="1354"></td>
+ <td id="LC1354" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1355" class="blob-num js-line-number" data-line-number="1355"></td>
+ <td id="LC1355" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parseidDef</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1356" class="blob-num js-line-number" data-line-number="1356"></td>
+ <td id="LC1356" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1357" class="blob-num js-line-number" data-line-number="1357"></td>
+ <td id="LC1357" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5, s6, s7];</td>
+ </tr>
+ <tr>
+ <td id="L1358" class="blob-num js-line-number" data-line-number="1358"></td>
+ <td id="LC1358" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L1359" class="blob-num js-line-number" data-line-number="1359"></td>
+ <td id="LC1359" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1360" class="blob-num js-line-number" data-line-number="1360"></td>
+ <td id="LC1360" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1361" class="blob-num js-line-number" data-line-number="1361"></td>
+ <td id="LC1361" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1362" class="blob-num js-line-number" data-line-number="1362"></td>
+ <td id="LC1362" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1363" class="blob-num js-line-number" data-line-number="1363"></td>
+ <td id="LC1363" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1364" class="blob-num js-line-number" data-line-number="1364"></td>
+ <td id="LC1364" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1365" class="blob-num js-line-number" data-line-number="1365"></td>
+ <td id="LC1365" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1366" class="blob-num js-line-number" data-line-number="1366"></td>
+ <td id="LC1366" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1367" class="blob-num js-line-number" data-line-number="1367"></td>
+ <td id="LC1367" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1368" class="blob-num js-line-number" data-line-number="1368"></td>
+ <td id="LC1368" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1369" class="blob-num js-line-number" data-line-number="1369"></td>
+ <td id="LC1369" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1370" class="blob-num js-line-number" data-line-number="1370"></td>
+ <td id="LC1370" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1371" class="blob-num js-line-number" data-line-number="1371"></td>
+ <td id="LC1371" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1372" class="blob-num js-line-number" data-line-number="1372"></td>
+ <td id="LC1372" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1373" class="blob-num js-line-number" data-line-number="1373"></td>
+ <td id="LC1373" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1374" class="blob-num js-line-number" data-line-number="1374"></td>
+ <td id="LC1374" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1375" class="blob-num js-line-number" data-line-number="1375"></td>
+ <td id="LC1375" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1376" class="blob-num js-line-number" data-line-number="1376"></td>
+ <td id="LC1376" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1377" class="blob-num js-line-number" data-line-number="1377"></td>
+ <td id="LC1377" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1378" class="blob-num js-line-number" data-line-number="1378"></td>
+ <td id="LC1378" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1379" class="blob-num js-line-number" data-line-number="1379"></td>
+ <td id="LC1379" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1380" class="blob-num js-line-number" data-line-number="1380"></td>
+ <td id="LC1380" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1381" class="blob-num js-line-number" data-line-number="1381"></td>
+ <td id="LC1381" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1382" class="blob-num js-line-number" data-line-number="1382"></td>
+ <td id="LC1382" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1383" class="blob-num js-line-number" data-line-number="1383"></td>
+ <td id="LC1383" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1384" class="blob-num js-line-number" data-line-number="1384"></td>
+ <td id="LC1384" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1385" class="blob-num js-line-number" data-line-number="1385"></td>
+ <td id="LC1385" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">44</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1386" class="blob-num js-line-number" data-line-number="1386"></td>
+ <td id="LC1386" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c24;</td>
+ </tr>
+ <tr>
+ <td id="L1387" class="blob-num js-line-number" data-line-number="1387"></td>
+ <td id="LC1387" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1388" class="blob-num js-line-number" data-line-number="1388"></td>
+ <td id="LC1388" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1389" class="blob-num js-line-number" data-line-number="1389"></td>
+ <td id="LC1389" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1390" class="blob-num js-line-number" data-line-number="1390"></td>
+ <td id="LC1390" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c25); }</td>
+ </tr>
+ <tr>
+ <td id="L1391" class="blob-num js-line-number" data-line-number="1391"></td>
+ <td id="LC1391" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1392" class="blob-num js-line-number" data-line-number="1392"></td>
+ <td id="LC1392" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1393" class="blob-num js-line-number" data-line-number="1393"></td>
+ <td id="LC1393" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1394" class="blob-num js-line-number" data-line-number="1394"></td>
+ <td id="LC1394" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1395" class="blob-num js-line-number" data-line-number="1395"></td>
+ <td id="LC1395" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1396" class="blob-num js-line-number" data-line-number="1396"></td>
+ <td id="LC1396" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1397" class="blob-num js-line-number" data-line-number="1397"></td>
+ <td id="LC1397" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1398" class="blob-num js-line-number" data-line-number="1398"></td>
+ <td id="LC1398" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1399" class="blob-num js-line-number" data-line-number="1399"></td>
+ <td id="LC1399" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s6</span>.<span class="pl-c1">push</span>(s7);</td>
+ </tr>
+ <tr>
+ <td id="L1400" class="blob-num js-line-number" data-line-number="1400"></td>
+ <td id="LC1400" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1401" class="blob-num js-line-number" data-line-number="1401"></td>
+ <td id="LC1401" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1402" class="blob-num js-line-number" data-line-number="1402"></td>
+ <td id="LC1402" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1403" class="blob-num js-line-number" data-line-number="1403"></td>
+ <td id="LC1403" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> <span class="pl-en">peg$parseidDef</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1404" class="blob-num js-line-number" data-line-number="1404"></td>
+ <td id="LC1404" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1405" class="blob-num js-line-number" data-line-number="1405"></td>
+ <td id="LC1405" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5, s6, s7];</td>
+ </tr>
+ <tr>
+ <td id="L1406" class="blob-num js-line-number" data-line-number="1406"></td>
+ <td id="LC1406" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L1407" class="blob-num js-line-number" data-line-number="1407"></td>
+ <td id="LC1407" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1408" class="blob-num js-line-number" data-line-number="1408"></td>
+ <td id="LC1408" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1409" class="blob-num js-line-number" data-line-number="1409"></td>
+ <td id="LC1409" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1410" class="blob-num js-line-number" data-line-number="1410"></td>
+ <td id="LC1410" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1411" class="blob-num js-line-number" data-line-number="1411"></td>
+ <td id="LC1411" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1412" class="blob-num js-line-number" data-line-number="1412"></td>
+ <td id="LC1412" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1413" class="blob-num js-line-number" data-line-number="1413"></td>
+ <td id="LC1413" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1414" class="blob-num js-line-number" data-line-number="1414"></td>
+ <td id="LC1414" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1415" class="blob-num js-line-number" data-line-number="1415"></td>
+ <td id="LC1415" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1416" class="blob-num js-line-number" data-line-number="1416"></td>
+ <td id="LC1416" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1417" class="blob-num js-line-number" data-line-number="1417"></td>
+ <td id="LC1417" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1418" class="blob-num js-line-number" data-line-number="1418"></td>
+ <td id="LC1418" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1419" class="blob-num js-line-number" data-line-number="1419"></td>
+ <td id="LC1419" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1420" class="blob-num js-line-number" data-line-number="1420"></td>
+ <td id="LC1420" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1421" class="blob-num js-line-number" data-line-number="1421"></td>
+ <td id="LC1421" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1422" class="blob-num js-line-number" data-line-number="1422"></td>
+ <td id="LC1422" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1423" class="blob-num js-line-number" data-line-number="1423"></td>
+ <td id="LC1423" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1424" class="blob-num js-line-number" data-line-number="1424"></td>
+ <td id="LC1424" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1425" class="blob-num js-line-number" data-line-number="1425"></td>
+ <td id="LC1425" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1426" class="blob-num js-line-number" data-line-number="1426"></td>
+ <td id="LC1426" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c26</span>(s1, s2);</td>
+ </tr>
+ <tr>
+ <td id="L1427" class="blob-num js-line-number" data-line-number="1427"></td>
+ <td id="LC1427" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1428" class="blob-num js-line-number" data-line-number="1428"></td>
+ <td id="LC1428" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1429" class="blob-num js-line-number" data-line-number="1429"></td>
+ <td id="LC1429" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1430" class="blob-num js-line-number" data-line-number="1430"></td>
+ <td id="LC1430" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1431" class="blob-num js-line-number" data-line-number="1431"></td>
+ <td id="LC1431" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1432" class="blob-num js-line-number" data-line-number="1432"></td>
+ <td id="LC1432" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1433" class="blob-num js-line-number" data-line-number="1433"></td>
+ <td id="LC1433" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1434" class="blob-num js-line-number" data-line-number="1434"></td>
+ <td id="LC1434" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1435" class="blob-num js-line-number" data-line-number="1435"></td>
+ <td id="LC1435" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1436" class="blob-num js-line-number" data-line-number="1436"></td>
+ <td id="LC1436" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1437" class="blob-num js-line-number" data-line-number="1437"></td>
+ <td id="LC1437" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1438" class="blob-num js-line-number" data-line-number="1438"></td>
+ <td id="LC1438" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1439" class="blob-num js-line-number" data-line-number="1439"></td>
+ <td id="LC1439" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1440" class="blob-num js-line-number" data-line-number="1440"></td>
+ <td id="LC1440" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseedgeRHS</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1441" class="blob-num js-line-number" data-line-number="1441"></td>
+ <td id="LC1441" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5;</td>
+ </tr>
+ <tr>
+ <td id="L1442" class="blob-num js-line-number" data-line-number="1442"></td>
+ <td id="LC1442" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1443" class="blob-num js-line-number" data-line-number="1443"></td>
+ <td id="LC1443" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1444" class="blob-num js-line-number" data-line-number="1444"></td>
+ <td id="LC1444" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1445" class="blob-num js-line-number" data-line-number="1445"></td>
+ <td id="LC1445" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c27) {</td>
+ </tr>
+ <tr>
+ <td id="L1446" class="blob-num js-line-number" data-line-number="1446"></td>
+ <td id="LC1446" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c27;</td>
+ </tr>
+ <tr>
+ <td id="L1447" class="blob-num js-line-number" data-line-number="1447"></td>
+ <td id="LC1447" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1448" class="blob-num js-line-number" data-line-number="1448"></td>
+ <td id="LC1448" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1449" class="blob-num js-line-number" data-line-number="1449"></td>
+ <td id="LC1449" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1450" class="blob-num js-line-number" data-line-number="1450"></td>
+ <td id="LC1450" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c28); }</td>
+ </tr>
+ <tr>
+ <td id="L1451" class="blob-num js-line-number" data-line-number="1451"></td>
+ <td id="LC1451" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1452" class="blob-num js-line-number" data-line-number="1452"></td>
+ <td id="LC1452" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1453" class="blob-num js-line-number" data-line-number="1453"></td>
+ <td id="LC1453" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1454" class="blob-num js-line-number" data-line-number="1454"></td>
+ <td id="LC1454" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$c29</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1455" class="blob-num js-line-number" data-line-number="1455"></td>
+ <td id="LC1455" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3) {</td>
+ </tr>
+ <tr>
+ <td id="L1456" class="blob-num js-line-number" data-line-number="1456"></td>
+ <td id="LC1456" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1457" class="blob-num js-line-number" data-line-number="1457"></td>
+ <td id="LC1457" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1458" class="blob-num js-line-number" data-line-number="1458"></td>
+ <td id="LC1458" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c30;</td>
+ </tr>
+ <tr>
+ <td id="L1459" class="blob-num js-line-number" data-line-number="1459"></td>
+ <td id="LC1459" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1460" class="blob-num js-line-number" data-line-number="1460"></td>
+ <td id="LC1460" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1461" class="blob-num js-line-number" data-line-number="1461"></td>
+ <td id="LC1461" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [s2, s3];</td>
+ </tr>
+ <tr>
+ <td id="L1462" class="blob-num js-line-number" data-line-number="1462"></td>
+ <td id="LC1462" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1463" class="blob-num js-line-number" data-line-number="1463"></td>
+ <td id="LC1463" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1464" class="blob-num js-line-number" data-line-number="1464"></td>
+ <td id="LC1464" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1465" class="blob-num js-line-number" data-line-number="1465"></td>
+ <td id="LC1465" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1466" class="blob-num js-line-number" data-line-number="1466"></td>
+ <td id="LC1466" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1467" class="blob-num js-line-number" data-line-number="1467"></td>
+ <td id="LC1467" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1468" class="blob-num js-line-number" data-line-number="1468"></td>
+ <td id="LC1468" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1469" class="blob-num js-line-number" data-line-number="1469"></td>
+ <td id="LC1469" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1470" class="blob-num js-line-number" data-line-number="1470"></td>
+ <td id="LC1470" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1471" class="blob-num js-line-number" data-line-number="1471"></td>
+ <td id="LC1471" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1472" class="blob-num js-line-number" data-line-number="1472"></td>
+ <td id="LC1472" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1473" class="blob-num js-line-number" data-line-number="1473"></td>
+ <td id="LC1473" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c31) {</td>
+ </tr>
+ <tr>
+ <td id="L1474" class="blob-num js-line-number" data-line-number="1474"></td>
+ <td id="LC1474" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c31;</td>
+ </tr>
+ <tr>
+ <td id="L1475" class="blob-num js-line-number" data-line-number="1475"></td>
+ <td id="LC1475" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1476" class="blob-num js-line-number" data-line-number="1476"></td>
+ <td id="LC1476" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1477" class="blob-num js-line-number" data-line-number="1477"></td>
+ <td id="LC1477" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1478" class="blob-num js-line-number" data-line-number="1478"></td>
+ <td id="LC1478" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c32); }</td>
+ </tr>
+ <tr>
+ <td id="L1479" class="blob-num js-line-number" data-line-number="1479"></td>
+ <td id="LC1479" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1480" class="blob-num js-line-number" data-line-number="1480"></td>
+ <td id="LC1480" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1481" class="blob-num js-line-number" data-line-number="1481"></td>
+ <td id="LC1481" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1482" class="blob-num js-line-number" data-line-number="1482"></td>
+ <td id="LC1482" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$c29</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1483" class="blob-num js-line-number" data-line-number="1483"></td>
+ <td id="LC1483" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3) {</td>
+ </tr>
+ <tr>
+ <td id="L1484" class="blob-num js-line-number" data-line-number="1484"></td>
+ <td id="LC1484" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c30;</td>
+ </tr>
+ <tr>
+ <td id="L1485" class="blob-num js-line-number" data-line-number="1485"></td>
+ <td id="LC1485" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1486" class="blob-num js-line-number" data-line-number="1486"></td>
+ <td id="LC1486" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1487" class="blob-num js-line-number" data-line-number="1487"></td>
+ <td id="LC1487" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1488" class="blob-num js-line-number" data-line-number="1488"></td>
+ <td id="LC1488" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1489" class="blob-num js-line-number" data-line-number="1489"></td>
+ <td id="LC1489" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [s2, s3];</td>
+ </tr>
+ <tr>
+ <td id="L1490" class="blob-num js-line-number" data-line-number="1490"></td>
+ <td id="LC1490" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1491" class="blob-num js-line-number" data-line-number="1491"></td>
+ <td id="LC1491" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1492" class="blob-num js-line-number" data-line-number="1492"></td>
+ <td id="LC1492" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1493" class="blob-num js-line-number" data-line-number="1493"></td>
+ <td id="LC1493" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1494" class="blob-num js-line-number" data-line-number="1494"></td>
+ <td id="LC1494" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1495" class="blob-num js-line-number" data-line-number="1495"></td>
+ <td id="LC1495" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1496" class="blob-num js-line-number" data-line-number="1496"></td>
+ <td id="LC1496" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1497" class="blob-num js-line-number" data-line-number="1497"></td>
+ <td id="LC1497" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1498" class="blob-num js-line-number" data-line-number="1498"></td>
+ <td id="LC1498" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1499" class="blob-num js-line-number" data-line-number="1499"></td>
+ <td id="LC1499" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1500" class="blob-num js-line-number" data-line-number="1500"></td>
+ <td id="LC1500" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1501" class="blob-num js-line-number" data-line-number="1501"></td>
+ <td id="LC1501" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1502" class="blob-num js-line-number" data-line-number="1502"></td>
+ <td id="LC1502" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1503" class="blob-num js-line-number" data-line-number="1503"></td>
+ <td id="LC1503" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1504" class="blob-num js-line-number" data-line-number="1504"></td>
+ <td id="LC1504" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1505" class="blob-num js-line-number" data-line-number="1505"></td>
+ <td id="LC1505" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1506" class="blob-num js-line-number" data-line-number="1506"></td>
+ <td id="LC1506" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1507" class="blob-num js-line-number" data-line-number="1507"></td>
+ <td id="LC1507" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1508" class="blob-num js-line-number" data-line-number="1508"></td>
+ <td id="LC1508" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parsenodeIdOrSubgraph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1509" class="blob-num js-line-number" data-line-number="1509"></td>
+ <td id="LC1509" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1510" class="blob-num js-line-number" data-line-number="1510"></td>
+ <td id="LC1510" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1511" class="blob-num js-line-number" data-line-number="1511"></td>
+ <td id="LC1511" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1512" class="blob-num js-line-number" data-line-number="1512"></td>
+ <td id="LC1512" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1513" class="blob-num js-line-number" data-line-number="1513"></td>
+ <td id="LC1513" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1514" class="blob-num js-line-number" data-line-number="1514"></td>
+ <td id="LC1514" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1515" class="blob-num js-line-number" data-line-number="1515"></td>
+ <td id="LC1515" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1516" class="blob-num js-line-number" data-line-number="1516"></td>
+ <td id="LC1516" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1517" class="blob-num js-line-number" data-line-number="1517"></td>
+ <td id="LC1517" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parseedgeRHS</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1518" class="blob-num js-line-number" data-line-number="1518"></td>
+ <td id="LC1518" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1519" class="blob-num js-line-number" data-line-number="1519"></td>
+ <td id="LC1519" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1520" class="blob-num js-line-number" data-line-number="1520"></td>
+ <td id="LC1520" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1521" class="blob-num js-line-number" data-line-number="1521"></td>
+ <td id="LC1521" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1522" class="blob-num js-line-number" data-line-number="1522"></td>
+ <td id="LC1522" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1523" class="blob-num js-line-number" data-line-number="1523"></td>
+ <td id="LC1523" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c33</span>(s3, s5);</td>
+ </tr>
+ <tr>
+ <td id="L1524" class="blob-num js-line-number" data-line-number="1524"></td>
+ <td id="LC1524" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1525" class="blob-num js-line-number" data-line-number="1525"></td>
+ <td id="LC1525" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1526" class="blob-num js-line-number" data-line-number="1526"></td>
+ <td id="LC1526" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1527" class="blob-num js-line-number" data-line-number="1527"></td>
+ <td id="LC1527" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1528" class="blob-num js-line-number" data-line-number="1528"></td>
+ <td id="LC1528" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1529" class="blob-num js-line-number" data-line-number="1529"></td>
+ <td id="LC1529" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1530" class="blob-num js-line-number" data-line-number="1530"></td>
+ <td id="LC1530" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1531" class="blob-num js-line-number" data-line-number="1531"></td>
+ <td id="LC1531" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1532" class="blob-num js-line-number" data-line-number="1532"></td>
+ <td id="LC1532" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1533" class="blob-num js-line-number" data-line-number="1533"></td>
+ <td id="LC1533" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1534" class="blob-num js-line-number" data-line-number="1534"></td>
+ <td id="LC1534" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1535" class="blob-num js-line-number" data-line-number="1535"></td>
+ <td id="LC1535" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1536" class="blob-num js-line-number" data-line-number="1536"></td>
+ <td id="LC1536" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1537" class="blob-num js-line-number" data-line-number="1537"></td>
+ <td id="LC1537" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1538" class="blob-num js-line-number" data-line-number="1538"></td>
+ <td id="LC1538" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1539" class="blob-num js-line-number" data-line-number="1539"></td>
+ <td id="LC1539" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1540" class="blob-num js-line-number" data-line-number="1540"></td>
+ <td id="LC1540" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1541" class="blob-num js-line-number" data-line-number="1541"></td>
+ <td id="LC1541" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1542" class="blob-num js-line-number" data-line-number="1542"></td>
+ <td id="LC1542" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1543" class="blob-num js-line-number" data-line-number="1543"></td>
+ <td id="LC1543" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1544" class="blob-num js-line-number" data-line-number="1544"></td>
+ <td id="LC1544" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1545" class="blob-num js-line-number" data-line-number="1545"></td>
+ <td id="LC1545" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1546" class="blob-num js-line-number" data-line-number="1546"></td>
+ <td id="LC1546" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1547" class="blob-num js-line-number" data-line-number="1547"></td>
+ <td id="LC1547" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1548" class="blob-num js-line-number" data-line-number="1548"></td>
+ <td id="LC1548" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1549" class="blob-num js-line-number" data-line-number="1549"></td>
+ <td id="LC1549" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseidDef</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1550" class="blob-num js-line-number" data-line-number="1550"></td>
+ <td id="LC1550" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6;</td>
+ </tr>
+ <tr>
+ <td id="L1551" class="blob-num js-line-number" data-line-number="1551"></td>
+ <td id="LC1551" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1552" class="blob-num js-line-number" data-line-number="1552"></td>
+ <td id="LC1552" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1553" class="blob-num js-line-number" data-line-number="1553"></td>
+ <td id="LC1553" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1554" class="blob-num js-line-number" data-line-number="1554"></td>
+ <td id="LC1554" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1555" class="blob-num js-line-number" data-line-number="1555"></td>
+ <td id="LC1555" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1556" class="blob-num js-line-number" data-line-number="1556"></td>
+ <td id="LC1556" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1557" class="blob-num js-line-number" data-line-number="1557"></td>
+ <td id="LC1557" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1558" class="blob-num js-line-number" data-line-number="1558"></td>
+ <td id="LC1558" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1559" class="blob-num js-line-number" data-line-number="1559"></td>
+ <td id="LC1559" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s3</span>.<span class="pl-c1">push</span>(s4);</td>
+ </tr>
+ <tr>
+ <td id="L1560" class="blob-num js-line-number" data-line-number="1560"></td>
+ <td id="LC1560" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1561" class="blob-num js-line-number" data-line-number="1561"></td>
+ <td id="LC1561" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1562" class="blob-num js-line-number" data-line-number="1562"></td>
+ <td id="LC1562" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1563" class="blob-num js-line-number" data-line-number="1563"></td>
+ <td id="LC1563" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">61</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1564" class="blob-num js-line-number" data-line-number="1564"></td>
+ <td id="LC1564" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c12;</td>
+ </tr>
+ <tr>
+ <td id="L1565" class="blob-num js-line-number" data-line-number="1565"></td>
+ <td id="LC1565" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1566" class="blob-num js-line-number" data-line-number="1566"></td>
+ <td id="LC1566" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1567" class="blob-num js-line-number" data-line-number="1567"></td>
+ <td id="LC1567" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1568" class="blob-num js-line-number" data-line-number="1568"></td>
+ <td id="LC1568" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c13); }</td>
+ </tr>
+ <tr>
+ <td id="L1569" class="blob-num js-line-number" data-line-number="1569"></td>
+ <td id="LC1569" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1570" class="blob-num js-line-number" data-line-number="1570"></td>
+ <td id="LC1570" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1571" class="blob-num js-line-number" data-line-number="1571"></td>
+ <td id="LC1571" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1572" class="blob-num js-line-number" data-line-number="1572"></td>
+ <td id="LC1572" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1573" class="blob-num js-line-number" data-line-number="1573"></td>
+ <td id="LC1573" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1574" class="blob-num js-line-number" data-line-number="1574"></td>
+ <td id="LC1574" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s5</span>.<span class="pl-c1">push</span>(s6);</td>
+ </tr>
+ <tr>
+ <td id="L1575" class="blob-num js-line-number" data-line-number="1575"></td>
+ <td id="LC1575" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1576" class="blob-num js-line-number" data-line-number="1576"></td>
+ <td id="LC1576" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1577" class="blob-num js-line-number" data-line-number="1577"></td>
+ <td id="LC1577" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1578" class="blob-num js-line-number" data-line-number="1578"></td>
+ <td id="LC1578" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1579" class="blob-num js-line-number" data-line-number="1579"></td>
+ <td id="LC1579" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1580" class="blob-num js-line-number" data-line-number="1580"></td>
+ <td id="LC1580" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> [s3, s4, s5, s6];</td>
+ </tr>
+ <tr>
+ <td id="L1581" class="blob-num js-line-number" data-line-number="1581"></td>
+ <td id="LC1581" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L1582" class="blob-num js-line-number" data-line-number="1582"></td>
+ <td id="LC1582" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1583" class="blob-num js-line-number" data-line-number="1583"></td>
+ <td id="LC1583" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1584" class="blob-num js-line-number" data-line-number="1584"></td>
+ <td id="LC1584" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1585" class="blob-num js-line-number" data-line-number="1585"></td>
+ <td id="LC1585" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1586" class="blob-num js-line-number" data-line-number="1586"></td>
+ <td id="LC1586" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1587" class="blob-num js-line-number" data-line-number="1587"></td>
+ <td id="LC1587" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1588" class="blob-num js-line-number" data-line-number="1588"></td>
+ <td id="LC1588" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1589" class="blob-num js-line-number" data-line-number="1589"></td>
+ <td id="LC1589" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1590" class="blob-num js-line-number" data-line-number="1590"></td>
+ <td id="LC1590" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1591" class="blob-num js-line-number" data-line-number="1591"></td>
+ <td id="LC1591" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1592" class="blob-num js-line-number" data-line-number="1592"></td>
+ <td id="LC1592" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1593" class="blob-num js-line-number" data-line-number="1593"></td>
+ <td id="LC1593" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1594" class="blob-num js-line-number" data-line-number="1594"></td>
+ <td id="LC1594" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1595" class="blob-num js-line-number" data-line-number="1595"></td>
+ <td id="LC1595" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s2;</td>
+ </tr>
+ <tr>
+ <td id="L1596" class="blob-num js-line-number" data-line-number="1596"></td>
+ <td id="LC1596" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1597" class="blob-num js-line-number" data-line-number="1597"></td>
+ <td id="LC1597" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1598" class="blob-num js-line-number" data-line-number="1598"></td>
+ <td id="LC1598" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1599" class="blob-num js-line-number" data-line-number="1599"></td>
+ <td id="LC1599" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1600" class="blob-num js-line-number" data-line-number="1600"></td>
+ <td id="LC1600" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1601" class="blob-num js-line-number" data-line-number="1601"></td>
+ <td id="LC1601" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1602" class="blob-num js-line-number" data-line-number="1602"></td>
+ <td id="LC1602" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1603" class="blob-num js-line-number" data-line-number="1603"></td>
+ <td id="LC1603" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c34</span>(s1, s2);</td>
+ </tr>
+ <tr>
+ <td id="L1604" class="blob-num js-line-number" data-line-number="1604"></td>
+ <td id="LC1604" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1605" class="blob-num js-line-number" data-line-number="1605"></td>
+ <td id="LC1605" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1606" class="blob-num js-line-number" data-line-number="1606"></td>
+ <td id="LC1606" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1607" class="blob-num js-line-number" data-line-number="1607"></td>
+ <td id="LC1607" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1608" class="blob-num js-line-number" data-line-number="1608"></td>
+ <td id="LC1608" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1609" class="blob-num js-line-number" data-line-number="1609"></td>
+ <td id="LC1609" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1610" class="blob-num js-line-number" data-line-number="1610"></td>
+ <td id="LC1610" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1611" class="blob-num js-line-number" data-line-number="1611"></td>
+ <td id="LC1611" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1612" class="blob-num js-line-number" data-line-number="1612"></td>
+ <td id="LC1612" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1613" class="blob-num js-line-number" data-line-number="1613"></td>
+ <td id="LC1613" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1614" class="blob-num js-line-number" data-line-number="1614"></td>
+ <td id="LC1614" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1615" class="blob-num js-line-number" data-line-number="1615"></td>
+ <td id="LC1615" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1616" class="blob-num js-line-number" data-line-number="1616"></td>
+ <td id="LC1616" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1617" class="blob-num js-line-number" data-line-number="1617"></td>
+ <td id="LC1617" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsenodeIdOrSubgraph</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1618" class="blob-num js-line-number" data-line-number="1618"></td>
+ <td id="LC1618" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L1619" class="blob-num js-line-number" data-line-number="1619"></td>
+ <td id="LC1619" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1620" class="blob-num js-line-number" data-line-number="1620"></td>
+ <td id="LC1620" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parsesubgraphStmt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1621" class="blob-num js-line-number" data-line-number="1621"></td>
+ <td id="LC1621" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1622" class="blob-num js-line-number" data-line-number="1622"></td>
+ <td id="LC1622" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1623" class="blob-num js-line-number" data-line-number="1623"></td>
+ <td id="LC1623" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsenodeId</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1624" class="blob-num js-line-number" data-line-number="1624"></td>
+ <td id="LC1624" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1625" class="blob-num js-line-number" data-line-number="1625"></td>
+ <td id="LC1625" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1626" class="blob-num js-line-number" data-line-number="1626"></td>
+ <td id="LC1626" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c35</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L1627" class="blob-num js-line-number" data-line-number="1627"></td>
+ <td id="LC1627" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1628" class="blob-num js-line-number" data-line-number="1628"></td>
+ <td id="LC1628" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1629" class="blob-num js-line-number" data-line-number="1629"></td>
+ <td id="LC1629" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1630" class="blob-num js-line-number" data-line-number="1630"></td>
+ <td id="LC1630" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1631" class="blob-num js-line-number" data-line-number="1631"></td>
+ <td id="LC1631" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1632" class="blob-num js-line-number" data-line-number="1632"></td>
+ <td id="LC1632" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1633" class="blob-num js-line-number" data-line-number="1633"></td>
+ <td id="LC1633" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1634" class="blob-num js-line-number" data-line-number="1634"></td>
+ <td id="LC1634" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsenodeId</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1635" class="blob-num js-line-number" data-line-number="1635"></td>
+ <td id="LC1635" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3;</td>
+ </tr>
+ <tr>
+ <td id="L1636" class="blob-num js-line-number" data-line-number="1636"></td>
+ <td id="LC1636" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1637" class="blob-num js-line-number" data-line-number="1637"></td>
+ <td id="LC1637" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1638" class="blob-num js-line-number" data-line-number="1638"></td>
+ <td id="LC1638" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1639" class="blob-num js-line-number" data-line-number="1639"></td>
+ <td id="LC1639" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1640" class="blob-num js-line-number" data-line-number="1640"></td>
+ <td id="LC1640" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1641" class="blob-num js-line-number" data-line-number="1641"></td>
+ <td id="LC1641" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1642" class="blob-num js-line-number" data-line-number="1642"></td>
+ <td id="LC1642" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1643" class="blob-num js-line-number" data-line-number="1643"></td>
+ <td id="LC1643" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1644" class="blob-num js-line-number" data-line-number="1644"></td>
+ <td id="LC1644" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1645" class="blob-num js-line-number" data-line-number="1645"></td>
+ <td id="LC1645" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1646" class="blob-num js-line-number" data-line-number="1646"></td>
+ <td id="LC1646" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1647" class="blob-num js-line-number" data-line-number="1647"></td>
+ <td id="LC1647" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parseport</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1648" class="blob-num js-line-number" data-line-number="1648"></td>
+ <td id="LC1648" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1649" class="blob-num js-line-number" data-line-number="1649"></td>
+ <td id="LC1649" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1650" class="blob-num js-line-number" data-line-number="1650"></td>
+ <td id="LC1650" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1651" class="blob-num js-line-number" data-line-number="1651"></td>
+ <td id="LC1651" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1652" class="blob-num js-line-number" data-line-number="1652"></td>
+ <td id="LC1652" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1653" class="blob-num js-line-number" data-line-number="1653"></td>
+ <td id="LC1653" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c36</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L1654" class="blob-num js-line-number" data-line-number="1654"></td>
+ <td id="LC1654" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1655" class="blob-num js-line-number" data-line-number="1655"></td>
+ <td id="LC1655" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1656" class="blob-num js-line-number" data-line-number="1656"></td>
+ <td id="LC1656" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1657" class="blob-num js-line-number" data-line-number="1657"></td>
+ <td id="LC1657" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1658" class="blob-num js-line-number" data-line-number="1658"></td>
+ <td id="LC1658" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1659" class="blob-num js-line-number" data-line-number="1659"></td>
+ <td id="LC1659" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1660" class="blob-num js-line-number" data-line-number="1660"></td>
+ <td id="LC1660" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1661" class="blob-num js-line-number" data-line-number="1661"></td>
+ <td id="LC1661" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1662" class="blob-num js-line-number" data-line-number="1662"></td>
+ <td id="LC1662" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1663" class="blob-num js-line-number" data-line-number="1663"></td>
+ <td id="LC1663" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1664" class="blob-num js-line-number" data-line-number="1664"></td>
+ <td id="LC1664" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1665" class="blob-num js-line-number" data-line-number="1665"></td>
+ <td id="LC1665" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1666" class="blob-num js-line-number" data-line-number="1666"></td>
+ <td id="LC1666" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1667" class="blob-num js-line-number" data-line-number="1667"></td>
+ <td id="LC1667" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1668" class="blob-num js-line-number" data-line-number="1668"></td>
+ <td id="LC1668" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1669" class="blob-num js-line-number" data-line-number="1669"></td>
+ <td id="LC1669" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1670" class="blob-num js-line-number" data-line-number="1670"></td>
+ <td id="LC1670" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1671" class="blob-num js-line-number" data-line-number="1671"></td>
+ <td id="LC1671" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseport</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1672" class="blob-num js-line-number" data-line-number="1672"></td>
+ <td id="LC1672" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6, s7, s8;</td>
+ </tr>
+ <tr>
+ <td id="L1673" class="blob-num js-line-number" data-line-number="1673"></td>
+ <td id="LC1673" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1674" class="blob-num js-line-number" data-line-number="1674"></td>
+ <td id="LC1674" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1675" class="blob-num js-line-number" data-line-number="1675"></td>
+ <td id="LC1675" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">58</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1676" class="blob-num js-line-number" data-line-number="1676"></td>
+ <td id="LC1676" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c37;</td>
+ </tr>
+ <tr>
+ <td id="L1677" class="blob-num js-line-number" data-line-number="1677"></td>
+ <td id="LC1677" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1678" class="blob-num js-line-number" data-line-number="1678"></td>
+ <td id="LC1678" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1679" class="blob-num js-line-number" data-line-number="1679"></td>
+ <td id="LC1679" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1680" class="blob-num js-line-number" data-line-number="1680"></td>
+ <td id="LC1680" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c38); }</td>
+ </tr>
+ <tr>
+ <td id="L1681" class="blob-num js-line-number" data-line-number="1681"></td>
+ <td id="LC1681" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1682" class="blob-num js-line-number" data-line-number="1682"></td>
+ <td id="LC1682" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1683" class="blob-num js-line-number" data-line-number="1683"></td>
+ <td id="LC1683" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1684" class="blob-num js-line-number" data-line-number="1684"></td>
+ <td id="LC1684" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1685" class="blob-num js-line-number" data-line-number="1685"></td>
+ <td id="LC1685" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1686" class="blob-num js-line-number" data-line-number="1686"></td>
+ <td id="LC1686" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1687" class="blob-num js-line-number" data-line-number="1687"></td>
+ <td id="LC1687" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1688" class="blob-num js-line-number" data-line-number="1688"></td>
+ <td id="LC1688" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1689" class="blob-num js-line-number" data-line-number="1689"></td>
+ <td id="LC1689" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1690" class="blob-num js-line-number" data-line-number="1690"></td>
+ <td id="LC1690" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-en">peg$parseid</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1691" class="blob-num js-line-number" data-line-number="1691"></td>
+ <td id="LC1691" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1692" class="blob-num js-line-number" data-line-number="1692"></td>
+ <td id="LC1692" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1693" class="blob-num js-line-number" data-line-number="1693"></td>
+ <td id="LC1693" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1694" class="blob-num js-line-number" data-line-number="1694"></td>
+ <td id="LC1694" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1695" class="blob-num js-line-number" data-line-number="1695"></td>
+ <td id="LC1695" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s4</span>.<span class="pl-c1">push</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L1696" class="blob-num js-line-number" data-line-number="1696"></td>
+ <td id="LC1696" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1697" class="blob-num js-line-number" data-line-number="1697"></td>
+ <td id="LC1697" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1698" class="blob-num js-line-number" data-line-number="1698"></td>
+ <td id="LC1698" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1699" class="blob-num js-line-number" data-line-number="1699"></td>
+ <td id="LC1699" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1700" class="blob-num js-line-number" data-line-number="1700"></td>
+ <td id="LC1700" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">58</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1701" class="blob-num js-line-number" data-line-number="1701"></td>
+ <td id="LC1701" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> peg$c37;</td>
+ </tr>
+ <tr>
+ <td id="L1702" class="blob-num js-line-number" data-line-number="1702"></td>
+ <td id="LC1702" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1703" class="blob-num js-line-number" data-line-number="1703"></td>
+ <td id="LC1703" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1704" class="blob-num js-line-number" data-line-number="1704"></td>
+ <td id="LC1704" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1705" class="blob-num js-line-number" data-line-number="1705"></td>
+ <td id="LC1705" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c38); }</td>
+ </tr>
+ <tr>
+ <td id="L1706" class="blob-num js-line-number" data-line-number="1706"></td>
+ <td id="LC1706" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1707" class="blob-num js-line-number" data-line-number="1707"></td>
+ <td id="LC1707" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1708" class="blob-num js-line-number" data-line-number="1708"></td>
+ <td id="LC1708" class="blob-code blob-code-inner js-file-line"> s7 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1709" class="blob-num js-line-number" data-line-number="1709"></td>
+ <td id="LC1709" class="blob-code blob-code-inner js-file-line"> s8 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1710" class="blob-num js-line-number" data-line-number="1710"></td>
+ <td id="LC1710" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s8 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1711" class="blob-num js-line-number" data-line-number="1711"></td>
+ <td id="LC1711" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s7</span>.<span class="pl-c1">push</span>(s8);</td>
+ </tr>
+ <tr>
+ <td id="L1712" class="blob-num js-line-number" data-line-number="1712"></td>
+ <td id="LC1712" class="blob-code blob-code-inner js-file-line"> s8 <span class="pl-k">=</span> <span class="pl-en">peg$parse_</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1713" class="blob-num js-line-number" data-line-number="1713"></td>
+ <td id="LC1713" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1714" class="blob-num js-line-number" data-line-number="1714"></td>
+ <td id="LC1714" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s7 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1715" class="blob-num js-line-number" data-line-number="1715"></td>
+ <td id="LC1715" class="blob-code blob-code-inner js-file-line"> s8 <span class="pl-k">=</span> <span class="pl-en">peg$parsecompassPt</span>();</td>
+ </tr>
+ <tr>
+ <td id="L1716" class="blob-num js-line-number" data-line-number="1716"></td>
+ <td id="LC1716" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s8 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1717" class="blob-num js-line-number" data-line-number="1717"></td>
+ <td id="LC1717" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> [s6, s7, s8];</td>
+ </tr>
+ <tr>
+ <td id="L1718" class="blob-num js-line-number" data-line-number="1718"></td>
+ <td id="LC1718" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> s6;</td>
+ </tr>
+ <tr>
+ <td id="L1719" class="blob-num js-line-number" data-line-number="1719"></td>
+ <td id="LC1719" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1720" class="blob-num js-line-number" data-line-number="1720"></td>
+ <td id="LC1720" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L1721" class="blob-num js-line-number" data-line-number="1721"></td>
+ <td id="LC1721" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1722" class="blob-num js-line-number" data-line-number="1722"></td>
+ <td id="LC1722" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1723" class="blob-num js-line-number" data-line-number="1723"></td>
+ <td id="LC1723" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1724" class="blob-num js-line-number" data-line-number="1724"></td>
+ <td id="LC1724" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L1725" class="blob-num js-line-number" data-line-number="1725"></td>
+ <td id="LC1725" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1726" class="blob-num js-line-number" data-line-number="1726"></td>
+ <td id="LC1726" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1727" class="blob-num js-line-number" data-line-number="1727"></td>
+ <td id="LC1727" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1728" class="blob-num js-line-number" data-line-number="1728"></td>
+ <td id="LC1728" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s5;</td>
+ </tr>
+ <tr>
+ <td id="L1729" class="blob-num js-line-number" data-line-number="1729"></td>
+ <td id="LC1729" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1730" class="blob-num js-line-number" data-line-number="1730"></td>
+ <td id="LC1730" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1731" class="blob-num js-line-number" data-line-number="1731"></td>
+ <td id="LC1731" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1732" class="blob-num js-line-number" data-line-number="1732"></td>
+ <td id="LC1732" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1733" class="blob-num js-line-number" data-line-number="1733"></td>
+ <td id="LC1733" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1734" class="blob-num js-line-number" data-line-number="1734"></td>
+ <td id="LC1734" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1735" class="blob-num js-line-number" data-line-number="1735"></td>
+ <td id="LC1735" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> [s1, s2, s3, s4, s5];</td>
+ </tr>
+ <tr>
+ <td id="L1736" class="blob-num js-line-number" data-line-number="1736"></td>
+ <td id="LC1736" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1737" class="blob-num js-line-number" data-line-number="1737"></td>
+ <td id="LC1737" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1738" class="blob-num js-line-number" data-line-number="1738"></td>
+ <td id="LC1738" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1739" class="blob-num js-line-number" data-line-number="1739"></td>
+ <td id="LC1739" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1740" class="blob-num js-line-number" data-line-number="1740"></td>
+ <td id="LC1740" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1741" class="blob-num js-line-number" data-line-number="1741"></td>
+ <td id="LC1741" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1742" class="blob-num js-line-number" data-line-number="1742"></td>
+ <td id="LC1742" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1743" class="blob-num js-line-number" data-line-number="1743"></td>
+ <td id="LC1743" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1744" class="blob-num js-line-number" data-line-number="1744"></td>
+ <td id="LC1744" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1745" class="blob-num js-line-number" data-line-number="1745"></td>
+ <td id="LC1745" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1746" class="blob-num js-line-number" data-line-number="1746"></td>
+ <td id="LC1746" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1747" class="blob-num js-line-number" data-line-number="1747"></td>
+ <td id="LC1747" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1748" class="blob-num js-line-number" data-line-number="1748"></td>
+ <td id="LC1748" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1749" class="blob-num js-line-number" data-line-number="1749"></td>
+ <td id="LC1749" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1750" class="blob-num js-line-number" data-line-number="1750"></td>
+ <td id="LC1750" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1751" class="blob-num js-line-number" data-line-number="1751"></td>
+ <td id="LC1751" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1752" class="blob-num js-line-number" data-line-number="1752"></td>
+ <td id="LC1752" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1753" class="blob-num js-line-number" data-line-number="1753"></td>
+ <td id="LC1753" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1754" class="blob-num js-line-number" data-line-number="1754"></td>
+ <td id="LC1754" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1755" class="blob-num js-line-number" data-line-number="1755"></td>
+ <td id="LC1755" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1756" class="blob-num js-line-number" data-line-number="1756"></td>
+ <td id="LC1756" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1757" class="blob-num js-line-number" data-line-number="1757"></td>
+ <td id="LC1757" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1758" class="blob-num js-line-number" data-line-number="1758"></td>
+ <td id="LC1758" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1759" class="blob-num js-line-number" data-line-number="1759"></td>
+ <td id="LC1759" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1760" class="blob-num js-line-number" data-line-number="1760"></td>
+ <td id="LC1760" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1761" class="blob-num js-line-number" data-line-number="1761"></td>
+ <td id="LC1761" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsecompassPt</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1762" class="blob-num js-line-number" data-line-number="1762"></td>
+ <td id="LC1762" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1763" class="blob-num js-line-number" data-line-number="1763"></td>
+ <td id="LC1763" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1764" class="blob-num js-line-number" data-line-number="1764"></td>
+ <td id="LC1764" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c39) {</td>
+ </tr>
+ <tr>
+ <td id="L1765" class="blob-num js-line-number" data-line-number="1765"></td>
+ <td id="LC1765" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c39;</td>
+ </tr>
+ <tr>
+ <td id="L1766" class="blob-num js-line-number" data-line-number="1766"></td>
+ <td id="LC1766" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1767" class="blob-num js-line-number" data-line-number="1767"></td>
+ <td id="LC1767" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1768" class="blob-num js-line-number" data-line-number="1768"></td>
+ <td id="LC1768" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1769" class="blob-num js-line-number" data-line-number="1769"></td>
+ <td id="LC1769" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c40); }</td>
+ </tr>
+ <tr>
+ <td id="L1770" class="blob-num js-line-number" data-line-number="1770"></td>
+ <td id="LC1770" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1771" class="blob-num js-line-number" data-line-number="1771"></td>
+ <td id="LC1771" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1772" class="blob-num js-line-number" data-line-number="1772"></td>
+ <td id="LC1772" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c41) {</td>
+ </tr>
+ <tr>
+ <td id="L1773" class="blob-num js-line-number" data-line-number="1773"></td>
+ <td id="LC1773" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c41;</td>
+ </tr>
+ <tr>
+ <td id="L1774" class="blob-num js-line-number" data-line-number="1774"></td>
+ <td id="LC1774" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1775" class="blob-num js-line-number" data-line-number="1775"></td>
+ <td id="LC1775" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1776" class="blob-num js-line-number" data-line-number="1776"></td>
+ <td id="LC1776" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1777" class="blob-num js-line-number" data-line-number="1777"></td>
+ <td id="LC1777" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c42); }</td>
+ </tr>
+ <tr>
+ <td id="L1778" class="blob-num js-line-number" data-line-number="1778"></td>
+ <td id="LC1778" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1779" class="blob-num js-line-number" data-line-number="1779"></td>
+ <td id="LC1779" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1780" class="blob-num js-line-number" data-line-number="1780"></td>
+ <td id="LC1780" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c43) {</td>
+ </tr>
+ <tr>
+ <td id="L1781" class="blob-num js-line-number" data-line-number="1781"></td>
+ <td id="LC1781" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c43;</td>
+ </tr>
+ <tr>
+ <td id="L1782" class="blob-num js-line-number" data-line-number="1782"></td>
+ <td id="LC1782" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1783" class="blob-num js-line-number" data-line-number="1783"></td>
+ <td id="LC1783" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1784" class="blob-num js-line-number" data-line-number="1784"></td>
+ <td id="LC1784" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1785" class="blob-num js-line-number" data-line-number="1785"></td>
+ <td id="LC1785" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c44); }</td>
+ </tr>
+ <tr>
+ <td id="L1786" class="blob-num js-line-number" data-line-number="1786"></td>
+ <td id="LC1786" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1787" class="blob-num js-line-number" data-line-number="1787"></td>
+ <td id="LC1787" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1788" class="blob-num js-line-number" data-line-number="1788"></td>
+ <td id="LC1788" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c45) {</td>
+ </tr>
+ <tr>
+ <td id="L1789" class="blob-num js-line-number" data-line-number="1789"></td>
+ <td id="LC1789" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c45;</td>
+ </tr>
+ <tr>
+ <td id="L1790" class="blob-num js-line-number" data-line-number="1790"></td>
+ <td id="LC1790" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1791" class="blob-num js-line-number" data-line-number="1791"></td>
+ <td id="LC1791" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1792" class="blob-num js-line-number" data-line-number="1792"></td>
+ <td id="LC1792" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1793" class="blob-num js-line-number" data-line-number="1793"></td>
+ <td id="LC1793" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c46); }</td>
+ </tr>
+ <tr>
+ <td id="L1794" class="blob-num js-line-number" data-line-number="1794"></td>
+ <td id="LC1794" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1795" class="blob-num js-line-number" data-line-number="1795"></td>
+ <td id="LC1795" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1796" class="blob-num js-line-number" data-line-number="1796"></td>
+ <td id="LC1796" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">110</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1797" class="blob-num js-line-number" data-line-number="1797"></td>
+ <td id="LC1797" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c47;</td>
+ </tr>
+ <tr>
+ <td id="L1798" class="blob-num js-line-number" data-line-number="1798"></td>
+ <td id="LC1798" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1799" class="blob-num js-line-number" data-line-number="1799"></td>
+ <td id="LC1799" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1800" class="blob-num js-line-number" data-line-number="1800"></td>
+ <td id="LC1800" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1801" class="blob-num js-line-number" data-line-number="1801"></td>
+ <td id="LC1801" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c48); }</td>
+ </tr>
+ <tr>
+ <td id="L1802" class="blob-num js-line-number" data-line-number="1802"></td>
+ <td id="LC1802" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1803" class="blob-num js-line-number" data-line-number="1803"></td>
+ <td id="LC1803" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1804" class="blob-num js-line-number" data-line-number="1804"></td>
+ <td id="LC1804" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">101</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1805" class="blob-num js-line-number" data-line-number="1805"></td>
+ <td id="LC1805" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c49;</td>
+ </tr>
+ <tr>
+ <td id="L1806" class="blob-num js-line-number" data-line-number="1806"></td>
+ <td id="LC1806" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1807" class="blob-num js-line-number" data-line-number="1807"></td>
+ <td id="LC1807" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1808" class="blob-num js-line-number" data-line-number="1808"></td>
+ <td id="LC1808" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1809" class="blob-num js-line-number" data-line-number="1809"></td>
+ <td id="LC1809" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c50); }</td>
+ </tr>
+ <tr>
+ <td id="L1810" class="blob-num js-line-number" data-line-number="1810"></td>
+ <td id="LC1810" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1811" class="blob-num js-line-number" data-line-number="1811"></td>
+ <td id="LC1811" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1812" class="blob-num js-line-number" data-line-number="1812"></td>
+ <td id="LC1812" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">115</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1813" class="blob-num js-line-number" data-line-number="1813"></td>
+ <td id="LC1813" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c51;</td>
+ </tr>
+ <tr>
+ <td id="L1814" class="blob-num js-line-number" data-line-number="1814"></td>
+ <td id="LC1814" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1815" class="blob-num js-line-number" data-line-number="1815"></td>
+ <td id="LC1815" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1816" class="blob-num js-line-number" data-line-number="1816"></td>
+ <td id="LC1816" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1817" class="blob-num js-line-number" data-line-number="1817"></td>
+ <td id="LC1817" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c52); }</td>
+ </tr>
+ <tr>
+ <td id="L1818" class="blob-num js-line-number" data-line-number="1818"></td>
+ <td id="LC1818" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1819" class="blob-num js-line-number" data-line-number="1819"></td>
+ <td id="LC1819" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1820" class="blob-num js-line-number" data-line-number="1820"></td>
+ <td id="LC1820" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">119</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1821" class="blob-num js-line-number" data-line-number="1821"></td>
+ <td id="LC1821" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c53;</td>
+ </tr>
+ <tr>
+ <td id="L1822" class="blob-num js-line-number" data-line-number="1822"></td>
+ <td id="LC1822" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1823" class="blob-num js-line-number" data-line-number="1823"></td>
+ <td id="LC1823" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1824" class="blob-num js-line-number" data-line-number="1824"></td>
+ <td id="LC1824" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1825" class="blob-num js-line-number" data-line-number="1825"></td>
+ <td id="LC1825" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c54); }</td>
+ </tr>
+ <tr>
+ <td id="L1826" class="blob-num js-line-number" data-line-number="1826"></td>
+ <td id="LC1826" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1827" class="blob-num js-line-number" data-line-number="1827"></td>
+ <td id="LC1827" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1828" class="blob-num js-line-number" data-line-number="1828"></td>
+ <td id="LC1828" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">99</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1829" class="blob-num js-line-number" data-line-number="1829"></td>
+ <td id="LC1829" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c55;</td>
+ </tr>
+ <tr>
+ <td id="L1830" class="blob-num js-line-number" data-line-number="1830"></td>
+ <td id="LC1830" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1831" class="blob-num js-line-number" data-line-number="1831"></td>
+ <td id="LC1831" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1832" class="blob-num js-line-number" data-line-number="1832"></td>
+ <td id="LC1832" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1833" class="blob-num js-line-number" data-line-number="1833"></td>
+ <td id="LC1833" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c56); }</td>
+ </tr>
+ <tr>
+ <td id="L1834" class="blob-num js-line-number" data-line-number="1834"></td>
+ <td id="LC1834" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1835" class="blob-num js-line-number" data-line-number="1835"></td>
+ <td id="LC1835" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1836" class="blob-num js-line-number" data-line-number="1836"></td>
+ <td id="LC1836" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">95</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1837" class="blob-num js-line-number" data-line-number="1837"></td>
+ <td id="LC1837" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c57;</td>
+ </tr>
+ <tr>
+ <td id="L1838" class="blob-num js-line-number" data-line-number="1838"></td>
+ <td id="LC1838" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1839" class="blob-num js-line-number" data-line-number="1839"></td>
+ <td id="LC1839" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1840" class="blob-num js-line-number" data-line-number="1840"></td>
+ <td id="LC1840" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1841" class="blob-num js-line-number" data-line-number="1841"></td>
+ <td id="LC1841" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c58); }</td>
+ </tr>
+ <tr>
+ <td id="L1842" class="blob-num js-line-number" data-line-number="1842"></td>
+ <td id="LC1842" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1843" class="blob-num js-line-number" data-line-number="1843"></td>
+ <td id="LC1843" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1844" class="blob-num js-line-number" data-line-number="1844"></td>
+ <td id="LC1844" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1845" class="blob-num js-line-number" data-line-number="1845"></td>
+ <td id="LC1845" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1846" class="blob-num js-line-number" data-line-number="1846"></td>
+ <td id="LC1846" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1847" class="blob-num js-line-number" data-line-number="1847"></td>
+ <td id="LC1847" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1848" class="blob-num js-line-number" data-line-number="1848"></td>
+ <td id="LC1848" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1849" class="blob-num js-line-number" data-line-number="1849"></td>
+ <td id="LC1849" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1850" class="blob-num js-line-number" data-line-number="1850"></td>
+ <td id="LC1850" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1851" class="blob-num js-line-number" data-line-number="1851"></td>
+ <td id="LC1851" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1852" class="blob-num js-line-number" data-line-number="1852"></td>
+ <td id="LC1852" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1853" class="blob-num js-line-number" data-line-number="1853"></td>
+ <td id="LC1853" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1854" class="blob-num js-line-number" data-line-number="1854"></td>
+ <td id="LC1854" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1855" class="blob-num js-line-number" data-line-number="1855"></td>
+ <td id="LC1855" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1856" class="blob-num js-line-number" data-line-number="1856"></td>
+ <td id="LC1856" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseid</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L1857" class="blob-num js-line-number" data-line-number="1857"></td>
+ <td id="LC1857" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5, s6;</td>
+ </tr>
+ <tr>
+ <td id="L1858" class="blob-num js-line-number" data-line-number="1858"></td>
+ <td id="LC1858" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L1859" class="blob-num js-line-number" data-line-number="1859"></td>
+ <td id="LC1859" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1860" class="blob-num js-line-number" data-line-number="1860"></td>
+ <td id="LC1860" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1861" class="blob-num js-line-number" data-line-number="1861"></td>
+ <td id="LC1861" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c60</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1862" class="blob-num js-line-number" data-line-number="1862"></td>
+ <td id="LC1862" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1863" class="blob-num js-line-number" data-line-number="1863"></td>
+ <td id="LC1863" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1864" class="blob-num js-line-number" data-line-number="1864"></td>
+ <td id="LC1864" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1865" class="blob-num js-line-number" data-line-number="1865"></td>
+ <td id="LC1865" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1866" class="blob-num js-line-number" data-line-number="1866"></td>
+ <td id="LC1866" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c61); }</td>
+ </tr>
+ <tr>
+ <td id="L1867" class="blob-num js-line-number" data-line-number="1867"></td>
+ <td id="LC1867" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1868" class="blob-num js-line-number" data-line-number="1868"></td>
+ <td id="LC1868" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1869" class="blob-num js-line-number" data-line-number="1869"></td>
+ <td id="LC1869" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1870" class="blob-num js-line-number" data-line-number="1870"></td>
+ <td id="LC1870" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c62</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1871" class="blob-num js-line-number" data-line-number="1871"></td>
+ <td id="LC1871" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1872" class="blob-num js-line-number" data-line-number="1872"></td>
+ <td id="LC1872" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1873" class="blob-num js-line-number" data-line-number="1873"></td>
+ <td id="LC1873" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1874" class="blob-num js-line-number" data-line-number="1874"></td>
+ <td id="LC1874" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1875" class="blob-num js-line-number" data-line-number="1875"></td>
+ <td id="LC1875" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c63); }</td>
+ </tr>
+ <tr>
+ <td id="L1876" class="blob-num js-line-number" data-line-number="1876"></td>
+ <td id="LC1876" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1877" class="blob-num js-line-number" data-line-number="1877"></td>
+ <td id="LC1877" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1878" class="blob-num js-line-number" data-line-number="1878"></td>
+ <td id="LC1878" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1879" class="blob-num js-line-number" data-line-number="1879"></td>
+ <td id="LC1879" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c62</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1880" class="blob-num js-line-number" data-line-number="1880"></td>
+ <td id="LC1880" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1881" class="blob-num js-line-number" data-line-number="1881"></td>
+ <td id="LC1881" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1882" class="blob-num js-line-number" data-line-number="1882"></td>
+ <td id="LC1882" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1883" class="blob-num js-line-number" data-line-number="1883"></td>
+ <td id="LC1883" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1884" class="blob-num js-line-number" data-line-number="1884"></td>
+ <td id="LC1884" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c63); }</td>
+ </tr>
+ <tr>
+ <td id="L1885" class="blob-num js-line-number" data-line-number="1885"></td>
+ <td id="LC1885" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1886" class="blob-num js-line-number" data-line-number="1886"></td>
+ <td id="LC1886" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1887" class="blob-num js-line-number" data-line-number="1887"></td>
+ <td id="LC1887" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1888" class="blob-num js-line-number" data-line-number="1888"></td>
+ <td id="LC1888" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1889" class="blob-num js-line-number" data-line-number="1889"></td>
+ <td id="LC1889" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c64</span>(s1, s2);</td>
+ </tr>
+ <tr>
+ <td id="L1890" class="blob-num js-line-number" data-line-number="1890"></td>
+ <td id="LC1890" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1891" class="blob-num js-line-number" data-line-number="1891"></td>
+ <td id="LC1891" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1892" class="blob-num js-line-number" data-line-number="1892"></td>
+ <td id="LC1892" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1893" class="blob-num js-line-number" data-line-number="1893"></td>
+ <td id="LC1893" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1894" class="blob-num js-line-number" data-line-number="1894"></td>
+ <td id="LC1894" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1895" class="blob-num js-line-number" data-line-number="1895"></td>
+ <td id="LC1895" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1896" class="blob-num js-line-number" data-line-number="1896"></td>
+ <td id="LC1896" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1897" class="blob-num js-line-number" data-line-number="1897"></td>
+ <td id="LC1897" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1898" class="blob-num js-line-number" data-line-number="1898"></td>
+ <td id="LC1898" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1899" class="blob-num js-line-number" data-line-number="1899"></td>
+ <td id="LC1899" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1900" class="blob-num js-line-number" data-line-number="1900"></td>
+ <td id="LC1900" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1901" class="blob-num js-line-number" data-line-number="1901"></td>
+ <td id="LC1901" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">45</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1902" class="blob-num js-line-number" data-line-number="1902"></td>
+ <td id="LC1902" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c65;</td>
+ </tr>
+ <tr>
+ <td id="L1903" class="blob-num js-line-number" data-line-number="1903"></td>
+ <td id="LC1903" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1904" class="blob-num js-line-number" data-line-number="1904"></td>
+ <td id="LC1904" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1905" class="blob-num js-line-number" data-line-number="1905"></td>
+ <td id="LC1905" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1906" class="blob-num js-line-number" data-line-number="1906"></td>
+ <td id="LC1906" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c66); }</td>
+ </tr>
+ <tr>
+ <td id="L1907" class="blob-num js-line-number" data-line-number="1907"></td>
+ <td id="LC1907" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1908" class="blob-num js-line-number" data-line-number="1908"></td>
+ <td id="LC1908" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1909" class="blob-num js-line-number" data-line-number="1909"></td>
+ <td id="LC1909" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1910" class="blob-num js-line-number" data-line-number="1910"></td>
+ <td id="LC1910" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1911" class="blob-num js-line-number" data-line-number="1911"></td>
+ <td id="LC1911" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1912" class="blob-num js-line-number" data-line-number="1912"></td>
+ <td id="LC1912" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">46</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1913" class="blob-num js-line-number" data-line-number="1913"></td>
+ <td id="LC1913" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c67;</td>
+ </tr>
+ <tr>
+ <td id="L1914" class="blob-num js-line-number" data-line-number="1914"></td>
+ <td id="LC1914" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1915" class="blob-num js-line-number" data-line-number="1915"></td>
+ <td id="LC1915" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1916" class="blob-num js-line-number" data-line-number="1916"></td>
+ <td id="LC1916" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1917" class="blob-num js-line-number" data-line-number="1917"></td>
+ <td id="LC1917" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c68); }</td>
+ </tr>
+ <tr>
+ <td id="L1918" class="blob-num js-line-number" data-line-number="1918"></td>
+ <td id="LC1918" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1919" class="blob-num js-line-number" data-line-number="1919"></td>
+ <td id="LC1919" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1920" class="blob-num js-line-number" data-line-number="1920"></td>
+ <td id="LC1920" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1921" class="blob-num js-line-number" data-line-number="1921"></td>
+ <td id="LC1921" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c69</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1922" class="blob-num js-line-number" data-line-number="1922"></td>
+ <td id="LC1922" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1923" class="blob-num js-line-number" data-line-number="1923"></td>
+ <td id="LC1923" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1924" class="blob-num js-line-number" data-line-number="1924"></td>
+ <td id="LC1924" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1925" class="blob-num js-line-number" data-line-number="1925"></td>
+ <td id="LC1925" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1926" class="blob-num js-line-number" data-line-number="1926"></td>
+ <td id="LC1926" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c70); }</td>
+ </tr>
+ <tr>
+ <td id="L1927" class="blob-num js-line-number" data-line-number="1927"></td>
+ <td id="LC1927" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1928" class="blob-num js-line-number" data-line-number="1928"></td>
+ <td id="LC1928" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1929" class="blob-num js-line-number" data-line-number="1929"></td>
+ <td id="LC1929" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1930" class="blob-num js-line-number" data-line-number="1930"></td>
+ <td id="LC1930" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s3</span>.<span class="pl-c1">push</span>(s4);</td>
+ </tr>
+ <tr>
+ <td id="L1931" class="blob-num js-line-number" data-line-number="1931"></td>
+ <td id="LC1931" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c69</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1932" class="blob-num js-line-number" data-line-number="1932"></td>
+ <td id="LC1932" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1933" class="blob-num js-line-number" data-line-number="1933"></td>
+ <td id="LC1933" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1934" class="blob-num js-line-number" data-line-number="1934"></td>
+ <td id="LC1934" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1935" class="blob-num js-line-number" data-line-number="1935"></td>
+ <td id="LC1935" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1936" class="blob-num js-line-number" data-line-number="1936"></td>
+ <td id="LC1936" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c70); }</td>
+ </tr>
+ <tr>
+ <td id="L1937" class="blob-num js-line-number" data-line-number="1937"></td>
+ <td id="LC1937" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1938" class="blob-num js-line-number" data-line-number="1938"></td>
+ <td id="LC1938" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1939" class="blob-num js-line-number" data-line-number="1939"></td>
+ <td id="LC1939" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1940" class="blob-num js-line-number" data-line-number="1940"></td>
+ <td id="LC1940" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1941" class="blob-num js-line-number" data-line-number="1941"></td>
+ <td id="LC1941" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1942" class="blob-num js-line-number" data-line-number="1942"></td>
+ <td id="LC1942" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1943" class="blob-num js-line-number" data-line-number="1943"></td>
+ <td id="LC1943" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1944" class="blob-num js-line-number" data-line-number="1944"></td>
+ <td id="LC1944" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c71</span>(s1, s2, s3);</td>
+ </tr>
+ <tr>
+ <td id="L1945" class="blob-num js-line-number" data-line-number="1945"></td>
+ <td id="LC1945" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L1946" class="blob-num js-line-number" data-line-number="1946"></td>
+ <td id="LC1946" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1947" class="blob-num js-line-number" data-line-number="1947"></td>
+ <td id="LC1947" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1948" class="blob-num js-line-number" data-line-number="1948"></td>
+ <td id="LC1948" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1949" class="blob-num js-line-number" data-line-number="1949"></td>
+ <td id="LC1949" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1950" class="blob-num js-line-number" data-line-number="1950"></td>
+ <td id="LC1950" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1951" class="blob-num js-line-number" data-line-number="1951"></td>
+ <td id="LC1951" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1952" class="blob-num js-line-number" data-line-number="1952"></td>
+ <td id="LC1952" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1953" class="blob-num js-line-number" data-line-number="1953"></td>
+ <td id="LC1953" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1954" class="blob-num js-line-number" data-line-number="1954"></td>
+ <td id="LC1954" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1955" class="blob-num js-line-number" data-line-number="1955"></td>
+ <td id="LC1955" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L1956" class="blob-num js-line-number" data-line-number="1956"></td>
+ <td id="LC1956" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1957" class="blob-num js-line-number" data-line-number="1957"></td>
+ <td id="LC1957" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1958" class="blob-num js-line-number" data-line-number="1958"></td>
+ <td id="LC1958" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1959" class="blob-num js-line-number" data-line-number="1959"></td>
+ <td id="LC1959" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1960" class="blob-num js-line-number" data-line-number="1960"></td>
+ <td id="LC1960" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">45</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1961" class="blob-num js-line-number" data-line-number="1961"></td>
+ <td id="LC1961" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c65;</td>
+ </tr>
+ <tr>
+ <td id="L1962" class="blob-num js-line-number" data-line-number="1962"></td>
+ <td id="LC1962" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1963" class="blob-num js-line-number" data-line-number="1963"></td>
+ <td id="LC1963" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1964" class="blob-num js-line-number" data-line-number="1964"></td>
+ <td id="LC1964" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1965" class="blob-num js-line-number" data-line-number="1965"></td>
+ <td id="LC1965" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c66); }</td>
+ </tr>
+ <tr>
+ <td id="L1966" class="blob-num js-line-number" data-line-number="1966"></td>
+ <td id="LC1966" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1967" class="blob-num js-line-number" data-line-number="1967"></td>
+ <td id="LC1967" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1968" class="blob-num js-line-number" data-line-number="1968"></td>
+ <td id="LC1968" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L1969" class="blob-num js-line-number" data-line-number="1969"></td>
+ <td id="LC1969" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1970" class="blob-num js-line-number" data-line-number="1970"></td>
+ <td id="LC1970" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1971" class="blob-num js-line-number" data-line-number="1971"></td>
+ <td id="LC1971" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L1972" class="blob-num js-line-number" data-line-number="1972"></td>
+ <td id="LC1972" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c69</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1973" class="blob-num js-line-number" data-line-number="1973"></td>
+ <td id="LC1973" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1974" class="blob-num js-line-number" data-line-number="1974"></td>
+ <td id="LC1974" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1975" class="blob-num js-line-number" data-line-number="1975"></td>
+ <td id="LC1975" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1976" class="blob-num js-line-number" data-line-number="1976"></td>
+ <td id="LC1976" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1977" class="blob-num js-line-number" data-line-number="1977"></td>
+ <td id="LC1977" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c70); }</td>
+ </tr>
+ <tr>
+ <td id="L1978" class="blob-num js-line-number" data-line-number="1978"></td>
+ <td id="LC1978" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1979" class="blob-num js-line-number" data-line-number="1979"></td>
+ <td id="LC1979" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1980" class="blob-num js-line-number" data-line-number="1980"></td>
+ <td id="LC1980" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1981" class="blob-num js-line-number" data-line-number="1981"></td>
+ <td id="LC1981" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L1982" class="blob-num js-line-number" data-line-number="1982"></td>
+ <td id="LC1982" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c69</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L1983" class="blob-num js-line-number" data-line-number="1983"></td>
+ <td id="LC1983" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L1984" class="blob-num js-line-number" data-line-number="1984"></td>
+ <td id="LC1984" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1985" class="blob-num js-line-number" data-line-number="1985"></td>
+ <td id="LC1985" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1986" class="blob-num js-line-number" data-line-number="1986"></td>
+ <td id="LC1986" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1987" class="blob-num js-line-number" data-line-number="1987"></td>
+ <td id="LC1987" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c70); }</td>
+ </tr>
+ <tr>
+ <td id="L1988" class="blob-num js-line-number" data-line-number="1988"></td>
+ <td id="LC1988" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1989" class="blob-num js-line-number" data-line-number="1989"></td>
+ <td id="LC1989" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1990" class="blob-num js-line-number" data-line-number="1990"></td>
+ <td id="LC1990" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1991" class="blob-num js-line-number" data-line-number="1991"></td>
+ <td id="LC1991" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L1992" class="blob-num js-line-number" data-line-number="1992"></td>
+ <td id="LC1992" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L1993" class="blob-num js-line-number" data-line-number="1993"></td>
+ <td id="LC1993" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1994" class="blob-num js-line-number" data-line-number="1994"></td>
+ <td id="LC1994" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L1995" class="blob-num js-line-number" data-line-number="1995"></td>
+ <td id="LC1995" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">46</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L1996" class="blob-num js-line-number" data-line-number="1996"></td>
+ <td id="LC1996" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c67;</td>
+ </tr>
+ <tr>
+ <td id="L1997" class="blob-num js-line-number" data-line-number="1997"></td>
+ <td id="LC1997" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L1998" class="blob-num js-line-number" data-line-number="1998"></td>
+ <td id="LC1998" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L1999" class="blob-num js-line-number" data-line-number="1999"></td>
+ <td id="LC1999" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2000" class="blob-num js-line-number" data-line-number="2000"></td>
+ <td id="LC2000" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c68); }</td>
+ </tr>
+ <tr>
+ <td id="L2001" class="blob-num js-line-number" data-line-number="2001"></td>
+ <td id="LC2001" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2002" class="blob-num js-line-number" data-line-number="2002"></td>
+ <td id="LC2002" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2003" class="blob-num js-line-number" data-line-number="2003"></td>
+ <td id="LC2003" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L2004" class="blob-num js-line-number" data-line-number="2004"></td>
+ <td id="LC2004" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c69</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2005" class="blob-num js-line-number" data-line-number="2005"></td>
+ <td id="LC2005" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2006" class="blob-num js-line-number" data-line-number="2006"></td>
+ <td id="LC2006" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2007" class="blob-num js-line-number" data-line-number="2007"></td>
+ <td id="LC2007" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2008" class="blob-num js-line-number" data-line-number="2008"></td>
+ <td id="LC2008" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2009" class="blob-num js-line-number" data-line-number="2009"></td>
+ <td id="LC2009" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c70); }</td>
+ </tr>
+ <tr>
+ <td id="L2010" class="blob-num js-line-number" data-line-number="2010"></td>
+ <td id="LC2010" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2011" class="blob-num js-line-number" data-line-number="2011"></td>
+ <td id="LC2011" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s6 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2012" class="blob-num js-line-number" data-line-number="2012"></td>
+ <td id="LC2012" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s5</span>.<span class="pl-c1">push</span>(s6);</td>
+ </tr>
+ <tr>
+ <td id="L2013" class="blob-num js-line-number" data-line-number="2013"></td>
+ <td id="LC2013" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c69</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2014" class="blob-num js-line-number" data-line-number="2014"></td>
+ <td id="LC2014" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2015" class="blob-num js-line-number" data-line-number="2015"></td>
+ <td id="LC2015" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2016" class="blob-num js-line-number" data-line-number="2016"></td>
+ <td id="LC2016" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2017" class="blob-num js-line-number" data-line-number="2017"></td>
+ <td id="LC2017" class="blob-code blob-code-inner js-file-line"> s6 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2018" class="blob-num js-line-number" data-line-number="2018"></td>
+ <td id="LC2018" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c70); }</td>
+ </tr>
+ <tr>
+ <td id="L2019" class="blob-num js-line-number" data-line-number="2019"></td>
+ <td id="LC2019" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2020" class="blob-num js-line-number" data-line-number="2020"></td>
+ <td id="LC2020" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2021" class="blob-num js-line-number" data-line-number="2021"></td>
+ <td id="LC2021" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2022" class="blob-num js-line-number" data-line-number="2022"></td>
+ <td id="LC2022" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5];</td>
+ </tr>
+ <tr>
+ <td id="L2023" class="blob-num js-line-number" data-line-number="2023"></td>
+ <td id="LC2023" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2024" class="blob-num js-line-number" data-line-number="2024"></td>
+ <td id="LC2024" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2025" class="blob-num js-line-number" data-line-number="2025"></td>
+ <td id="LC2025" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2026" class="blob-num js-line-number" data-line-number="2026"></td>
+ <td id="LC2026" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2027" class="blob-num js-line-number" data-line-number="2027"></td>
+ <td id="LC2027" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2028" class="blob-num js-line-number" data-line-number="2028"></td>
+ <td id="LC2028" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2029" class="blob-num js-line-number" data-line-number="2029"></td>
+ <td id="LC2029" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2030" class="blob-num js-line-number" data-line-number="2030"></td>
+ <td id="LC2030" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2031" class="blob-num js-line-number" data-line-number="2031"></td>
+ <td id="LC2031" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2032" class="blob-num js-line-number" data-line-number="2032"></td>
+ <td id="LC2032" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2033" class="blob-num js-line-number" data-line-number="2033"></td>
+ <td id="LC2033" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c2;</td>
+ </tr>
+ <tr>
+ <td id="L2034" class="blob-num js-line-number" data-line-number="2034"></td>
+ <td id="LC2034" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2035" class="blob-num js-line-number" data-line-number="2035"></td>
+ <td id="LC2035" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2036" class="blob-num js-line-number" data-line-number="2036"></td>
+ <td id="LC2036" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2037" class="blob-num js-line-number" data-line-number="2037"></td>
+ <td id="LC2037" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c72</span>(s1, s2, s3);</td>
+ </tr>
+ <tr>
+ <td id="L2038" class="blob-num js-line-number" data-line-number="2038"></td>
+ <td id="LC2038" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2039" class="blob-num js-line-number" data-line-number="2039"></td>
+ <td id="LC2039" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2040" class="blob-num js-line-number" data-line-number="2040"></td>
+ <td id="LC2040" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2041" class="blob-num js-line-number" data-line-number="2041"></td>
+ <td id="LC2041" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2042" class="blob-num js-line-number" data-line-number="2042"></td>
+ <td id="LC2042" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2043" class="blob-num js-line-number" data-line-number="2043"></td>
+ <td id="LC2043" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2044" class="blob-num js-line-number" data-line-number="2044"></td>
+ <td id="LC2044" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2045" class="blob-num js-line-number" data-line-number="2045"></td>
+ <td id="LC2045" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2046" class="blob-num js-line-number" data-line-number="2046"></td>
+ <td id="LC2046" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2047" class="blob-num js-line-number" data-line-number="2047"></td>
+ <td id="LC2047" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2048" class="blob-num js-line-number" data-line-number="2048"></td>
+ <td id="LC2048" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2049" class="blob-num js-line-number" data-line-number="2049"></td>
+ <td id="LC2049" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2050" class="blob-num js-line-number" data-line-number="2050"></td>
+ <td id="LC2050" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2051" class="blob-num js-line-number" data-line-number="2051"></td>
+ <td id="LC2051" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2052" class="blob-num js-line-number" data-line-number="2052"></td>
+ <td id="LC2052" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2053" class="blob-num js-line-number" data-line-number="2053"></td>
+ <td id="LC2053" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">34</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2054" class="blob-num js-line-number" data-line-number="2054"></td>
+ <td id="LC2054" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c73;</td>
+ </tr>
+ <tr>
+ <td id="L2055" class="blob-num js-line-number" data-line-number="2055"></td>
+ <td id="LC2055" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2056" class="blob-num js-line-number" data-line-number="2056"></td>
+ <td id="LC2056" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2057" class="blob-num js-line-number" data-line-number="2057"></td>
+ <td id="LC2057" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2058" class="blob-num js-line-number" data-line-number="2058"></td>
+ <td id="LC2058" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c74); }</td>
+ </tr>
+ <tr>
+ <td id="L2059" class="blob-num js-line-number" data-line-number="2059"></td>
+ <td id="LC2059" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2060" class="blob-num js-line-number" data-line-number="2060"></td>
+ <td id="LC2060" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2061" class="blob-num js-line-number" data-line-number="2061"></td>
+ <td id="LC2061" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L2062" class="blob-num js-line-number" data-line-number="2062"></td>
+ <td id="LC2062" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2063" class="blob-num js-line-number" data-line-number="2063"></td>
+ <td id="LC2063" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c75) {</td>
+ </tr>
+ <tr>
+ <td id="L2064" class="blob-num js-line-number" data-line-number="2064"></td>
+ <td id="LC2064" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c75;</td>
+ </tr>
+ <tr>
+ <td id="L2065" class="blob-num js-line-number" data-line-number="2065"></td>
+ <td id="LC2065" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2066" class="blob-num js-line-number" data-line-number="2066"></td>
+ <td id="LC2066" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2067" class="blob-num js-line-number" data-line-number="2067"></td>
+ <td id="LC2067" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2068" class="blob-num js-line-number" data-line-number="2068"></td>
+ <td id="LC2068" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c76); }</td>
+ </tr>
+ <tr>
+ <td id="L2069" class="blob-num js-line-number" data-line-number="2069"></td>
+ <td id="LC2069" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2070" class="blob-num js-line-number" data-line-number="2070"></td>
+ <td id="LC2070" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2071" class="blob-num js-line-number" data-line-number="2071"></td>
+ <td id="LC2071" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2072" class="blob-num js-line-number" data-line-number="2072"></td>
+ <td id="LC2072" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$c77</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2073" class="blob-num js-line-number" data-line-number="2073"></td>
+ <td id="LC2073" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2074" class="blob-num js-line-number" data-line-number="2074"></td>
+ <td id="LC2074" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2075" class="blob-num js-line-number" data-line-number="2075"></td>
+ <td id="LC2075" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2076" class="blob-num js-line-number" data-line-number="2076"></td>
+ <td id="LC2076" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2077" class="blob-num js-line-number" data-line-number="2077"></td>
+ <td id="LC2077" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">92</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2078" class="blob-num js-line-number" data-line-number="2078"></td>
+ <td id="LC2078" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c78;</td>
+ </tr>
+ <tr>
+ <td id="L2079" class="blob-num js-line-number" data-line-number="2079"></td>
+ <td id="LC2079" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2080" class="blob-num js-line-number" data-line-number="2080"></td>
+ <td id="LC2080" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2081" class="blob-num js-line-number" data-line-number="2081"></td>
+ <td id="LC2081" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2082" class="blob-num js-line-number" data-line-number="2082"></td>
+ <td id="LC2082" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c79); }</td>
+ </tr>
+ <tr>
+ <td id="L2083" class="blob-num js-line-number" data-line-number="2083"></td>
+ <td id="LC2083" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2084" class="blob-num js-line-number" data-line-number="2084"></td>
+ <td id="LC2084" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2085" class="blob-num js-line-number" data-line-number="2085"></td>
+ <td id="LC2085" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c80</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2086" class="blob-num js-line-number" data-line-number="2086"></td>
+ <td id="LC2086" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2087" class="blob-num js-line-number" data-line-number="2087"></td>
+ <td id="LC2087" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2088" class="blob-num js-line-number" data-line-number="2088"></td>
+ <td id="LC2088" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2089" class="blob-num js-line-number" data-line-number="2089"></td>
+ <td id="LC2089" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2090" class="blob-num js-line-number" data-line-number="2090"></td>
+ <td id="LC2090" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c81); }</td>
+ </tr>
+ <tr>
+ <td id="L2091" class="blob-num js-line-number" data-line-number="2091"></td>
+ <td id="LC2091" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2092" class="blob-num js-line-number" data-line-number="2092"></td>
+ <td id="LC2092" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2093" class="blob-num js-line-number" data-line-number="2093"></td>
+ <td id="LC2093" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2094" class="blob-num js-line-number" data-line-number="2094"></td>
+ <td id="LC2094" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$c82</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L2095" class="blob-num js-line-number" data-line-number="2095"></td>
+ <td id="LC2095" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2096" class="blob-num js-line-number" data-line-number="2096"></td>
+ <td id="LC2096" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2097" class="blob-num js-line-number" data-line-number="2097"></td>
+ <td id="LC2097" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2098" class="blob-num js-line-number" data-line-number="2098"></td>
+ <td id="LC2098" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2099" class="blob-num js-line-number" data-line-number="2099"></td>
+ <td id="LC2099" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2100" class="blob-num js-line-number" data-line-number="2100"></td>
+ <td id="LC2100" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2101" class="blob-num js-line-number" data-line-number="2101"></td>
+ <td id="LC2101" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2102" class="blob-num js-line-number" data-line-number="2102"></td>
+ <td id="LC2102" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2103" class="blob-num js-line-number" data-line-number="2103"></td>
+ <td id="LC2103" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2104" class="blob-num js-line-number" data-line-number="2104"></td>
+ <td id="LC2104" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2105" class="blob-num js-line-number" data-line-number="2105"></td>
+ <td id="LC2105" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c80</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2106" class="blob-num js-line-number" data-line-number="2106"></td>
+ <td id="LC2106" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2107" class="blob-num js-line-number" data-line-number="2107"></td>
+ <td id="LC2107" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2108" class="blob-num js-line-number" data-line-number="2108"></td>
+ <td id="LC2108" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2109" class="blob-num js-line-number" data-line-number="2109"></td>
+ <td id="LC2109" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2110" class="blob-num js-line-number" data-line-number="2110"></td>
+ <td id="LC2110" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c81); }</td>
+ </tr>
+ <tr>
+ <td id="L2111" class="blob-num js-line-number" data-line-number="2111"></td>
+ <td id="LC2111" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2112" class="blob-num js-line-number" data-line-number="2112"></td>
+ <td id="LC2112" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2113" class="blob-num js-line-number" data-line-number="2113"></td>
+ <td id="LC2113" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2114" class="blob-num js-line-number" data-line-number="2114"></td>
+ <td id="LC2114" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2115" class="blob-num js-line-number" data-line-number="2115"></td>
+ <td id="LC2115" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L2116" class="blob-num js-line-number" data-line-number="2116"></td>
+ <td id="LC2116" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2117" class="blob-num js-line-number" data-line-number="2117"></td>
+ <td id="LC2117" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c75) {</td>
+ </tr>
+ <tr>
+ <td id="L2118" class="blob-num js-line-number" data-line-number="2118"></td>
+ <td id="LC2118" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c75;</td>
+ </tr>
+ <tr>
+ <td id="L2119" class="blob-num js-line-number" data-line-number="2119"></td>
+ <td id="LC2119" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2120" class="blob-num js-line-number" data-line-number="2120"></td>
+ <td id="LC2120" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2121" class="blob-num js-line-number" data-line-number="2121"></td>
+ <td id="LC2121" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2122" class="blob-num js-line-number" data-line-number="2122"></td>
+ <td id="LC2122" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c76); }</td>
+ </tr>
+ <tr>
+ <td id="L2123" class="blob-num js-line-number" data-line-number="2123"></td>
+ <td id="LC2123" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2124" class="blob-num js-line-number" data-line-number="2124"></td>
+ <td id="LC2124" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2125" class="blob-num js-line-number" data-line-number="2125"></td>
+ <td id="LC2125" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2126" class="blob-num js-line-number" data-line-number="2126"></td>
+ <td id="LC2126" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$c77</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2127" class="blob-num js-line-number" data-line-number="2127"></td>
+ <td id="LC2127" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2128" class="blob-num js-line-number" data-line-number="2128"></td>
+ <td id="LC2128" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2129" class="blob-num js-line-number" data-line-number="2129"></td>
+ <td id="LC2129" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2130" class="blob-num js-line-number" data-line-number="2130"></td>
+ <td id="LC2130" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2131" class="blob-num js-line-number" data-line-number="2131"></td>
+ <td id="LC2131" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">92</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2132" class="blob-num js-line-number" data-line-number="2132"></td>
+ <td id="LC2132" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c78;</td>
+ </tr>
+ <tr>
+ <td id="L2133" class="blob-num js-line-number" data-line-number="2133"></td>
+ <td id="LC2133" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2134" class="blob-num js-line-number" data-line-number="2134"></td>
+ <td id="LC2134" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2135" class="blob-num js-line-number" data-line-number="2135"></td>
+ <td id="LC2135" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2136" class="blob-num js-line-number" data-line-number="2136"></td>
+ <td id="LC2136" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c79); }</td>
+ </tr>
+ <tr>
+ <td id="L2137" class="blob-num js-line-number" data-line-number="2137"></td>
+ <td id="LC2137" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2138" class="blob-num js-line-number" data-line-number="2138"></td>
+ <td id="LC2138" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2139" class="blob-num js-line-number" data-line-number="2139"></td>
+ <td id="LC2139" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c80</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2140" class="blob-num js-line-number" data-line-number="2140"></td>
+ <td id="LC2140" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2141" class="blob-num js-line-number" data-line-number="2141"></td>
+ <td id="LC2141" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2142" class="blob-num js-line-number" data-line-number="2142"></td>
+ <td id="LC2142" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2143" class="blob-num js-line-number" data-line-number="2143"></td>
+ <td id="LC2143" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2144" class="blob-num js-line-number" data-line-number="2144"></td>
+ <td id="LC2144" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c81); }</td>
+ </tr>
+ <tr>
+ <td id="L2145" class="blob-num js-line-number" data-line-number="2145"></td>
+ <td id="LC2145" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2146" class="blob-num js-line-number" data-line-number="2146"></td>
+ <td id="LC2146" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2147" class="blob-num js-line-number" data-line-number="2147"></td>
+ <td id="LC2147" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2148" class="blob-num js-line-number" data-line-number="2148"></td>
+ <td id="LC2148" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> <span class="pl-en">peg$c82</span>(s5);</td>
+ </tr>
+ <tr>
+ <td id="L2149" class="blob-num js-line-number" data-line-number="2149"></td>
+ <td id="LC2149" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2150" class="blob-num js-line-number" data-line-number="2150"></td>
+ <td id="LC2150" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2151" class="blob-num js-line-number" data-line-number="2151"></td>
+ <td id="LC2151" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2152" class="blob-num js-line-number" data-line-number="2152"></td>
+ <td id="LC2152" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2153" class="blob-num js-line-number" data-line-number="2153"></td>
+ <td id="LC2153" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2154" class="blob-num js-line-number" data-line-number="2154"></td>
+ <td id="LC2154" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2155" class="blob-num js-line-number" data-line-number="2155"></td>
+ <td id="LC2155" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2156" class="blob-num js-line-number" data-line-number="2156"></td>
+ <td id="LC2156" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2157" class="blob-num js-line-number" data-line-number="2157"></td>
+ <td id="LC2157" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2158" class="blob-num js-line-number" data-line-number="2158"></td>
+ <td id="LC2158" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2159" class="blob-num js-line-number" data-line-number="2159"></td>
+ <td id="LC2159" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c80</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2160" class="blob-num js-line-number" data-line-number="2160"></td>
+ <td id="LC2160" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2161" class="blob-num js-line-number" data-line-number="2161"></td>
+ <td id="LC2161" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2162" class="blob-num js-line-number" data-line-number="2162"></td>
+ <td id="LC2162" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2163" class="blob-num js-line-number" data-line-number="2163"></td>
+ <td id="LC2163" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2164" class="blob-num js-line-number" data-line-number="2164"></td>
+ <td id="LC2164" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c81); }</td>
+ </tr>
+ <tr>
+ <td id="L2165" class="blob-num js-line-number" data-line-number="2165"></td>
+ <td id="LC2165" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2166" class="blob-num js-line-number" data-line-number="2166"></td>
+ <td id="LC2166" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2167" class="blob-num js-line-number" data-line-number="2167"></td>
+ <td id="LC2167" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2168" class="blob-num js-line-number" data-line-number="2168"></td>
+ <td id="LC2168" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2169" class="blob-num js-line-number" data-line-number="2169"></td>
+ <td id="LC2169" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2170" class="blob-num js-line-number" data-line-number="2170"></td>
+ <td id="LC2170" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">charCodeAt</span>(peg$currPos) <span class="pl-k">===</span> <span class="pl-c1">34</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2171" class="blob-num js-line-number" data-line-number="2171"></td>
+ <td id="LC2171" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c73;</td>
+ </tr>
+ <tr>
+ <td id="L2172" class="blob-num js-line-number" data-line-number="2172"></td>
+ <td id="LC2172" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2173" class="blob-num js-line-number" data-line-number="2173"></td>
+ <td id="LC2173" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2174" class="blob-num js-line-number" data-line-number="2174"></td>
+ <td id="LC2174" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2175" class="blob-num js-line-number" data-line-number="2175"></td>
+ <td id="LC2175" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c74); }</td>
+ </tr>
+ <tr>
+ <td id="L2176" class="blob-num js-line-number" data-line-number="2176"></td>
+ <td id="LC2176" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2177" class="blob-num js-line-number" data-line-number="2177"></td>
+ <td id="LC2177" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2178" class="blob-num js-line-number" data-line-number="2178"></td>
+ <td id="LC2178" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2179" class="blob-num js-line-number" data-line-number="2179"></td>
+ <td id="LC2179" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c83</span>(s2);</td>
+ </tr>
+ <tr>
+ <td id="L2180" class="blob-num js-line-number" data-line-number="2180"></td>
+ <td id="LC2180" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2181" class="blob-num js-line-number" data-line-number="2181"></td>
+ <td id="LC2181" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2182" class="blob-num js-line-number" data-line-number="2182"></td>
+ <td id="LC2182" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2183" class="blob-num js-line-number" data-line-number="2183"></td>
+ <td id="LC2183" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2184" class="blob-num js-line-number" data-line-number="2184"></td>
+ <td id="LC2184" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2185" class="blob-num js-line-number" data-line-number="2185"></td>
+ <td id="LC2185" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2186" class="blob-num js-line-number" data-line-number="2186"></td>
+ <td id="LC2186" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2187" class="blob-num js-line-number" data-line-number="2187"></td>
+ <td id="LC2187" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2188" class="blob-num js-line-number" data-line-number="2188"></td>
+ <td id="LC2188" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2189" class="blob-num js-line-number" data-line-number="2189"></td>
+ <td id="LC2189" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2190" class="blob-num js-line-number" data-line-number="2190"></td>
+ <td id="LC2190" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2191" class="blob-num js-line-number" data-line-number="2191"></td>
+ <td id="LC2191" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2192" class="blob-num js-line-number" data-line-number="2192"></td>
+ <td id="LC2192" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2193" class="blob-num js-line-number" data-line-number="2193"></td>
+ <td id="LC2193" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2194" class="blob-num js-line-number" data-line-number="2194"></td>
+ <td id="LC2194" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2195" class="blob-num js-line-number" data-line-number="2195"></td>
+ <td id="LC2195" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2196" class="blob-num js-line-number" data-line-number="2196"></td>
+ <td id="LC2196" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2197" class="blob-num js-line-number" data-line-number="2197"></td>
+ <td id="LC2197" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2198" class="blob-num js-line-number" data-line-number="2198"></td>
+ <td id="LC2198" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2199" class="blob-num js-line-number" data-line-number="2199"></td>
+ <td id="LC2199" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c59); }</td>
+ </tr>
+ <tr>
+ <td id="L2200" class="blob-num js-line-number" data-line-number="2200"></td>
+ <td id="LC2200" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2201" class="blob-num js-line-number" data-line-number="2201"></td>
+ <td id="LC2201" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2202" class="blob-num js-line-number" data-line-number="2202"></td>
+ <td id="LC2202" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2203" class="blob-num js-line-number" data-line-number="2203"></td>
+ <td id="LC2203" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2204" class="blob-num js-line-number" data-line-number="2204"></td>
+ <td id="LC2204" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2205" class="blob-num js-line-number" data-line-number="2205"></td>
+ <td id="LC2205" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsenode</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2206" class="blob-num js-line-number" data-line-number="2206"></td>
+ <td id="LC2206" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2207" class="blob-num js-line-number" data-line-number="2207"></td>
+ <td id="LC2207" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2208" class="blob-num js-line-number" data-line-number="2208"></td>
+ <td id="LC2208" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2209" class="blob-num js-line-number" data-line-number="2209"></td>
+ <td id="LC2209" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">4</span>).<span class="pl-c1">toLowerCase</span>() <span class="pl-k">===</span> peg$c84) {</td>
+ </tr>
+ <tr>
+ <td id="L2210" class="blob-num js-line-number" data-line-number="2210"></td>
+ <td id="LC2210" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">4</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2211" class="blob-num js-line-number" data-line-number="2211"></td>
+ <td id="LC2211" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">4</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2212" class="blob-num js-line-number" data-line-number="2212"></td>
+ <td id="LC2212" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2213" class="blob-num js-line-number" data-line-number="2213"></td>
+ <td id="LC2213" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2214" class="blob-num js-line-number" data-line-number="2214"></td>
+ <td id="LC2214" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c85); }</td>
+ </tr>
+ <tr>
+ <td id="L2215" class="blob-num js-line-number" data-line-number="2215"></td>
+ <td id="LC2215" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2216" class="blob-num js-line-number" data-line-number="2216"></td>
+ <td id="LC2216" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2217" class="blob-num js-line-number" data-line-number="2217"></td>
+ <td id="LC2217" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2218" class="blob-num js-line-number" data-line-number="2218"></td>
+ <td id="LC2218" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c86</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2219" class="blob-num js-line-number" data-line-number="2219"></td>
+ <td id="LC2219" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2220" class="blob-num js-line-number" data-line-number="2220"></td>
+ <td id="LC2220" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2221" class="blob-num js-line-number" data-line-number="2221"></td>
+ <td id="LC2221" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2222" class="blob-num js-line-number" data-line-number="2222"></td>
+ <td id="LC2222" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2223" class="blob-num js-line-number" data-line-number="2223"></td>
+ <td id="LC2223" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2224" class="blob-num js-line-number" data-line-number="2224"></td>
+ <td id="LC2224" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2225" class="blob-num js-line-number" data-line-number="2225"></td>
+ <td id="LC2225" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parseedge</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2226" class="blob-num js-line-number" data-line-number="2226"></td>
+ <td id="LC2226" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2227" class="blob-num js-line-number" data-line-number="2227"></td>
+ <td id="LC2227" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2228" class="blob-num js-line-number" data-line-number="2228"></td>
+ <td id="LC2228" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2229" class="blob-num js-line-number" data-line-number="2229"></td>
+ <td id="LC2229" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">4</span>).<span class="pl-c1">toLowerCase</span>() <span class="pl-k">===</span> peg$c87) {</td>
+ </tr>
+ <tr>
+ <td id="L2230" class="blob-num js-line-number" data-line-number="2230"></td>
+ <td id="LC2230" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">4</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2231" class="blob-num js-line-number" data-line-number="2231"></td>
+ <td id="LC2231" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">4</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2232" class="blob-num js-line-number" data-line-number="2232"></td>
+ <td id="LC2232" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2233" class="blob-num js-line-number" data-line-number="2233"></td>
+ <td id="LC2233" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2234" class="blob-num js-line-number" data-line-number="2234"></td>
+ <td id="LC2234" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c88); }</td>
+ </tr>
+ <tr>
+ <td id="L2235" class="blob-num js-line-number" data-line-number="2235"></td>
+ <td id="LC2235" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2236" class="blob-num js-line-number" data-line-number="2236"></td>
+ <td id="LC2236" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2237" class="blob-num js-line-number" data-line-number="2237"></td>
+ <td id="LC2237" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2238" class="blob-num js-line-number" data-line-number="2238"></td>
+ <td id="LC2238" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c86</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2239" class="blob-num js-line-number" data-line-number="2239"></td>
+ <td id="LC2239" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2240" class="blob-num js-line-number" data-line-number="2240"></td>
+ <td id="LC2240" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2241" class="blob-num js-line-number" data-line-number="2241"></td>
+ <td id="LC2241" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2242" class="blob-num js-line-number" data-line-number="2242"></td>
+ <td id="LC2242" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2243" class="blob-num js-line-number" data-line-number="2243"></td>
+ <td id="LC2243" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2244" class="blob-num js-line-number" data-line-number="2244"></td>
+ <td id="LC2244" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2245" class="blob-num js-line-number" data-line-number="2245"></td>
+ <td id="LC2245" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsegraph</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2246" class="blob-num js-line-number" data-line-number="2246"></td>
+ <td id="LC2246" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2247" class="blob-num js-line-number" data-line-number="2247"></td>
+ <td id="LC2247" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2248" class="blob-num js-line-number" data-line-number="2248"></td>
+ <td id="LC2248" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2249" class="blob-num js-line-number" data-line-number="2249"></td>
+ <td id="LC2249" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">5</span>).<span class="pl-c1">toLowerCase</span>() <span class="pl-k">===</span> peg$c89) {</td>
+ </tr>
+ <tr>
+ <td id="L2250" class="blob-num js-line-number" data-line-number="2250"></td>
+ <td id="LC2250" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">5</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2251" class="blob-num js-line-number" data-line-number="2251"></td>
+ <td id="LC2251" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">5</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2252" class="blob-num js-line-number" data-line-number="2252"></td>
+ <td id="LC2252" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2253" class="blob-num js-line-number" data-line-number="2253"></td>
+ <td id="LC2253" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2254" class="blob-num js-line-number" data-line-number="2254"></td>
+ <td id="LC2254" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c90); }</td>
+ </tr>
+ <tr>
+ <td id="L2255" class="blob-num js-line-number" data-line-number="2255"></td>
+ <td id="LC2255" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2256" class="blob-num js-line-number" data-line-number="2256"></td>
+ <td id="LC2256" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2257" class="blob-num js-line-number" data-line-number="2257"></td>
+ <td id="LC2257" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2258" class="blob-num js-line-number" data-line-number="2258"></td>
+ <td id="LC2258" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c86</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2259" class="blob-num js-line-number" data-line-number="2259"></td>
+ <td id="LC2259" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2260" class="blob-num js-line-number" data-line-number="2260"></td>
+ <td id="LC2260" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2261" class="blob-num js-line-number" data-line-number="2261"></td>
+ <td id="LC2261" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2262" class="blob-num js-line-number" data-line-number="2262"></td>
+ <td id="LC2262" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2263" class="blob-num js-line-number" data-line-number="2263"></td>
+ <td id="LC2263" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2264" class="blob-num js-line-number" data-line-number="2264"></td>
+ <td id="LC2264" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2265" class="blob-num js-line-number" data-line-number="2265"></td>
+ <td id="LC2265" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsedigraph</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2266" class="blob-num js-line-number" data-line-number="2266"></td>
+ <td id="LC2266" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2267" class="blob-num js-line-number" data-line-number="2267"></td>
+ <td id="LC2267" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2268" class="blob-num js-line-number" data-line-number="2268"></td>
+ <td id="LC2268" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2269" class="blob-num js-line-number" data-line-number="2269"></td>
+ <td id="LC2269" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">7</span>).<span class="pl-c1">toLowerCase</span>() <span class="pl-k">===</span> peg$c91) {</td>
+ </tr>
+ <tr>
+ <td id="L2270" class="blob-num js-line-number" data-line-number="2270"></td>
+ <td id="LC2270" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">7</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2271" class="blob-num js-line-number" data-line-number="2271"></td>
+ <td id="LC2271" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">7</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2272" class="blob-num js-line-number" data-line-number="2272"></td>
+ <td id="LC2272" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2273" class="blob-num js-line-number" data-line-number="2273"></td>
+ <td id="LC2273" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2274" class="blob-num js-line-number" data-line-number="2274"></td>
+ <td id="LC2274" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c92); }</td>
+ </tr>
+ <tr>
+ <td id="L2275" class="blob-num js-line-number" data-line-number="2275"></td>
+ <td id="LC2275" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2276" class="blob-num js-line-number" data-line-number="2276"></td>
+ <td id="LC2276" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2277" class="blob-num js-line-number" data-line-number="2277"></td>
+ <td id="LC2277" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2278" class="blob-num js-line-number" data-line-number="2278"></td>
+ <td id="LC2278" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c86</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2279" class="blob-num js-line-number" data-line-number="2279"></td>
+ <td id="LC2279" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2280" class="blob-num js-line-number" data-line-number="2280"></td>
+ <td id="LC2280" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2281" class="blob-num js-line-number" data-line-number="2281"></td>
+ <td id="LC2281" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2282" class="blob-num js-line-number" data-line-number="2282"></td>
+ <td id="LC2282" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2283" class="blob-num js-line-number" data-line-number="2283"></td>
+ <td id="LC2283" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2284" class="blob-num js-line-number" data-line-number="2284"></td>
+ <td id="LC2284" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2285" class="blob-num js-line-number" data-line-number="2285"></td>
+ <td id="LC2285" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsesubgraph</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2286" class="blob-num js-line-number" data-line-number="2286"></td>
+ <td id="LC2286" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2287" class="blob-num js-line-number" data-line-number="2287"></td>
+ <td id="LC2287" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2288" class="blob-num js-line-number" data-line-number="2288"></td>
+ <td id="LC2288" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2289" class="blob-num js-line-number" data-line-number="2289"></td>
+ <td id="LC2289" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">8</span>).<span class="pl-c1">toLowerCase</span>() <span class="pl-k">===</span> peg$c93) {</td>
+ </tr>
+ <tr>
+ <td id="L2290" class="blob-num js-line-number" data-line-number="2290"></td>
+ <td id="LC2290" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">8</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2291" class="blob-num js-line-number" data-line-number="2291"></td>
+ <td id="LC2291" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">8</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2292" class="blob-num js-line-number" data-line-number="2292"></td>
+ <td id="LC2292" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2293" class="blob-num js-line-number" data-line-number="2293"></td>
+ <td id="LC2293" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2294" class="blob-num js-line-number" data-line-number="2294"></td>
+ <td id="LC2294" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c94); }</td>
+ </tr>
+ <tr>
+ <td id="L2295" class="blob-num js-line-number" data-line-number="2295"></td>
+ <td id="LC2295" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2296" class="blob-num js-line-number" data-line-number="2296"></td>
+ <td id="LC2296" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2297" class="blob-num js-line-number" data-line-number="2297"></td>
+ <td id="LC2297" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2298" class="blob-num js-line-number" data-line-number="2298"></td>
+ <td id="LC2298" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c86</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2299" class="blob-num js-line-number" data-line-number="2299"></td>
+ <td id="LC2299" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2300" class="blob-num js-line-number" data-line-number="2300"></td>
+ <td id="LC2300" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2301" class="blob-num js-line-number" data-line-number="2301"></td>
+ <td id="LC2301" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2302" class="blob-num js-line-number" data-line-number="2302"></td>
+ <td id="LC2302" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2303" class="blob-num js-line-number" data-line-number="2303"></td>
+ <td id="LC2303" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2304" class="blob-num js-line-number" data-line-number="2304"></td>
+ <td id="LC2304" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2305" class="blob-num js-line-number" data-line-number="2305"></td>
+ <td id="LC2305" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsestrict</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2306" class="blob-num js-line-number" data-line-number="2306"></td>
+ <td id="LC2306" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2307" class="blob-num js-line-number" data-line-number="2307"></td>
+ <td id="LC2307" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2308" class="blob-num js-line-number" data-line-number="2308"></td>
+ <td id="LC2308" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2309" class="blob-num js-line-number" data-line-number="2309"></td>
+ <td id="LC2309" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">6</span>).<span class="pl-c1">toLowerCase</span>() <span class="pl-k">===</span> peg$c95) {</td>
+ </tr>
+ <tr>
+ <td id="L2310" class="blob-num js-line-number" data-line-number="2310"></td>
+ <td id="LC2310" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">6</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2311" class="blob-num js-line-number" data-line-number="2311"></td>
+ <td id="LC2311" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">6</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2312" class="blob-num js-line-number" data-line-number="2312"></td>
+ <td id="LC2312" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2313" class="blob-num js-line-number" data-line-number="2313"></td>
+ <td id="LC2313" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2314" class="blob-num js-line-number" data-line-number="2314"></td>
+ <td id="LC2314" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c96); }</td>
+ </tr>
+ <tr>
+ <td id="L2315" class="blob-num js-line-number" data-line-number="2315"></td>
+ <td id="LC2315" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2316" class="blob-num js-line-number" data-line-number="2316"></td>
+ <td id="LC2316" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2317" class="blob-num js-line-number" data-line-number="2317"></td>
+ <td id="LC2317" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2318" class="blob-num js-line-number" data-line-number="2318"></td>
+ <td id="LC2318" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c86</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2319" class="blob-num js-line-number" data-line-number="2319"></td>
+ <td id="LC2319" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2320" class="blob-num js-line-number" data-line-number="2320"></td>
+ <td id="LC2320" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2321" class="blob-num js-line-number" data-line-number="2321"></td>
+ <td id="LC2321" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2322" class="blob-num js-line-number" data-line-number="2322"></td>
+ <td id="LC2322" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2323" class="blob-num js-line-number" data-line-number="2323"></td>
+ <td id="LC2323" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2324" class="blob-num js-line-number" data-line-number="2324"></td>
+ <td id="LC2324" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2325" class="blob-num js-line-number" data-line-number="2325"></td>
+ <td id="LC2325" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsegraphType</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2326" class="blob-num js-line-number" data-line-number="2326"></td>
+ <td id="LC2326" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2327" class="blob-num js-line-number" data-line-number="2327"></td>
+ <td id="LC2327" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2328" class="blob-num js-line-number" data-line-number="2328"></td>
+ <td id="LC2328" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parsegraph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2329" class="blob-num js-line-number" data-line-number="2329"></td>
+ <td id="LC2329" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2330" class="blob-num js-line-number" data-line-number="2330"></td>
+ <td id="LC2330" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2331" class="blob-num js-line-number" data-line-number="2331"></td>
+ <td id="LC2331" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$parsedigraph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2332" class="blob-num js-line-number" data-line-number="2332"></td>
+ <td id="LC2332" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2333" class="blob-num js-line-number" data-line-number="2333"></td>
+ <td id="LC2333" class="blob-code blob-code-inner js-file-line"> peg$reportedPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2334" class="blob-num js-line-number" data-line-number="2334"></td>
+ <td id="LC2334" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-en">peg$c97</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2335" class="blob-num js-line-number" data-line-number="2335"></td>
+ <td id="LC2335" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2336" class="blob-num js-line-number" data-line-number="2336"></td>
+ <td id="LC2336" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2337" class="blob-num js-line-number" data-line-number="2337"></td>
+ <td id="LC2337" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2338" class="blob-num js-line-number" data-line-number="2338"></td>
+ <td id="LC2338" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2339" class="blob-num js-line-number" data-line-number="2339"></td>
+ <td id="LC2339" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2340" class="blob-num js-line-number" data-line-number="2340"></td>
+ <td id="LC2340" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2341" class="blob-num js-line-number" data-line-number="2341"></td>
+ <td id="LC2341" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2342" class="blob-num js-line-number" data-line-number="2342"></td>
+ <td id="LC2342" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsewhitespace</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2343" class="blob-num js-line-number" data-line-number="2343"></td>
+ <td id="LC2343" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1;</td>
+ </tr>
+ <tr>
+ <td id="L2344" class="blob-num js-line-number" data-line-number="2344"></td>
+ <td id="LC2344" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2345" class="blob-num js-line-number" data-line-number="2345"></td>
+ <td id="LC2345" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2346" class="blob-num js-line-number" data-line-number="2346"></td>
+ <td id="LC2346" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L2347" class="blob-num js-line-number" data-line-number="2347"></td>
+ <td id="LC2347" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c99</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2348" class="blob-num js-line-number" data-line-number="2348"></td>
+ <td id="LC2348" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2349" class="blob-num js-line-number" data-line-number="2349"></td>
+ <td id="LC2349" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2350" class="blob-num js-line-number" data-line-number="2350"></td>
+ <td id="LC2350" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2351" class="blob-num js-line-number" data-line-number="2351"></td>
+ <td id="LC2351" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2352" class="blob-num js-line-number" data-line-number="2352"></td>
+ <td id="LC2352" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c100); }</td>
+ </tr>
+ <tr>
+ <td id="L2353" class="blob-num js-line-number" data-line-number="2353"></td>
+ <td id="LC2353" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2354" class="blob-num js-line-number" data-line-number="2354"></td>
+ <td id="LC2354" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2355" class="blob-num js-line-number" data-line-number="2355"></td>
+ <td id="LC2355" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2356" class="blob-num js-line-number" data-line-number="2356"></td>
+ <td id="LC2356" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s0</span>.<span class="pl-c1">push</span>(s1);</td>
+ </tr>
+ <tr>
+ <td id="L2357" class="blob-num js-line-number" data-line-number="2357"></td>
+ <td id="LC2357" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c99</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2358" class="blob-num js-line-number" data-line-number="2358"></td>
+ <td id="LC2358" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2359" class="blob-num js-line-number" data-line-number="2359"></td>
+ <td id="LC2359" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2360" class="blob-num js-line-number" data-line-number="2360"></td>
+ <td id="LC2360" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2361" class="blob-num js-line-number" data-line-number="2361"></td>
+ <td id="LC2361" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2362" class="blob-num js-line-number" data-line-number="2362"></td>
+ <td id="LC2362" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c100); }</td>
+ </tr>
+ <tr>
+ <td id="L2363" class="blob-num js-line-number" data-line-number="2363"></td>
+ <td id="LC2363" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2364" class="blob-num js-line-number" data-line-number="2364"></td>
+ <td id="LC2364" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2365" class="blob-num js-line-number" data-line-number="2365"></td>
+ <td id="LC2365" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2366" class="blob-num js-line-number" data-line-number="2366"></td>
+ <td id="LC2366" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2367" class="blob-num js-line-number" data-line-number="2367"></td>
+ <td id="LC2367" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2368" class="blob-num js-line-number" data-line-number="2368"></td>
+ <td id="LC2368" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2369" class="blob-num js-line-number" data-line-number="2369"></td>
+ <td id="LC2369" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2370" class="blob-num js-line-number" data-line-number="2370"></td>
+ <td id="LC2370" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2371" class="blob-num js-line-number" data-line-number="2371"></td>
+ <td id="LC2371" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c98); }</td>
+ </tr>
+ <tr>
+ <td id="L2372" class="blob-num js-line-number" data-line-number="2372"></td>
+ <td id="LC2372" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2373" class="blob-num js-line-number" data-line-number="2373"></td>
+ <td id="LC2373" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2374" class="blob-num js-line-number" data-line-number="2374"></td>
+ <td id="LC2374" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2375" class="blob-num js-line-number" data-line-number="2375"></td>
+ <td id="LC2375" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2376" class="blob-num js-line-number" data-line-number="2376"></td>
+ <td id="LC2376" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2377" class="blob-num js-line-number" data-line-number="2377"></td>
+ <td id="LC2377" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parsecomment</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2378" class="blob-num js-line-number" data-line-number="2378"></td>
+ <td id="LC2378" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0, s1, s2, s3, s4, s5;</td>
+ </tr>
+ <tr>
+ <td id="L2379" class="blob-num js-line-number" data-line-number="2379"></td>
+ <td id="LC2379" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2380" class="blob-num js-line-number" data-line-number="2380"></td>
+ <td id="LC2380" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2381" class="blob-num js-line-number" data-line-number="2381"></td>
+ <td id="LC2381" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2382" class="blob-num js-line-number" data-line-number="2382"></td>
+ <td id="LC2382" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c102) {</td>
+ </tr>
+ <tr>
+ <td id="L2383" class="blob-num js-line-number" data-line-number="2383"></td>
+ <td id="LC2383" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c102;</td>
+ </tr>
+ <tr>
+ <td id="L2384" class="blob-num js-line-number" data-line-number="2384"></td>
+ <td id="LC2384" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2385" class="blob-num js-line-number" data-line-number="2385"></td>
+ <td id="LC2385" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2386" class="blob-num js-line-number" data-line-number="2386"></td>
+ <td id="LC2386" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2387" class="blob-num js-line-number" data-line-number="2387"></td>
+ <td id="LC2387" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c103); }</td>
+ </tr>
+ <tr>
+ <td id="L2388" class="blob-num js-line-number" data-line-number="2388"></td>
+ <td id="LC2388" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2389" class="blob-num js-line-number" data-line-number="2389"></td>
+ <td id="LC2389" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2390" class="blob-num js-line-number" data-line-number="2390"></td>
+ <td id="LC2390" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L2391" class="blob-num js-line-number" data-line-number="2391"></td>
+ <td id="LC2391" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c104</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2392" class="blob-num js-line-number" data-line-number="2392"></td>
+ <td id="LC2392" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2393" class="blob-num js-line-number" data-line-number="2393"></td>
+ <td id="LC2393" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2394" class="blob-num js-line-number" data-line-number="2394"></td>
+ <td id="LC2394" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2395" class="blob-num js-line-number" data-line-number="2395"></td>
+ <td id="LC2395" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2396" class="blob-num js-line-number" data-line-number="2396"></td>
+ <td id="LC2396" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c105); }</td>
+ </tr>
+ <tr>
+ <td id="L2397" class="blob-num js-line-number" data-line-number="2397"></td>
+ <td id="LC2397" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2398" class="blob-num js-line-number" data-line-number="2398"></td>
+ <td id="LC2398" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2399" class="blob-num js-line-number" data-line-number="2399"></td>
+ <td id="LC2399" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L2400" class="blob-num js-line-number" data-line-number="2400"></td>
+ <td id="LC2400" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">peg$c104</span>.<span class="pl-c1">test</span>(<span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos))) {</td>
+ </tr>
+ <tr>
+ <td id="L2401" class="blob-num js-line-number" data-line-number="2401"></td>
+ <td id="LC2401" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2402" class="blob-num js-line-number" data-line-number="2402"></td>
+ <td id="LC2402" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2403" class="blob-num js-line-number" data-line-number="2403"></td>
+ <td id="LC2403" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2404" class="blob-num js-line-number" data-line-number="2404"></td>
+ <td id="LC2404" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2405" class="blob-num js-line-number" data-line-number="2405"></td>
+ <td id="LC2405" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c105); }</td>
+ </tr>
+ <tr>
+ <td id="L2406" class="blob-num js-line-number" data-line-number="2406"></td>
+ <td id="LC2406" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2407" class="blob-num js-line-number" data-line-number="2407"></td>
+ <td id="LC2407" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2408" class="blob-num js-line-number" data-line-number="2408"></td>
+ <td id="LC2408" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2409" class="blob-num js-line-number" data-line-number="2409"></td>
+ <td id="LC2409" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> [s1, s2];</td>
+ </tr>
+ <tr>
+ <td id="L2410" class="blob-num js-line-number" data-line-number="2410"></td>
+ <td id="LC2410" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2411" class="blob-num js-line-number" data-line-number="2411"></td>
+ <td id="LC2411" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2412" class="blob-num js-line-number" data-line-number="2412"></td>
+ <td id="LC2412" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2413" class="blob-num js-line-number" data-line-number="2413"></td>
+ <td id="LC2413" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2414" class="blob-num js-line-number" data-line-number="2414"></td>
+ <td id="LC2414" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2415" class="blob-num js-line-number" data-line-number="2415"></td>
+ <td id="LC2415" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2416" class="blob-num js-line-number" data-line-number="2416"></td>
+ <td id="LC2416" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2417" class="blob-num js-line-number" data-line-number="2417"></td>
+ <td id="LC2417" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2418" class="blob-num js-line-number" data-line-number="2418"></td>
+ <td id="LC2418" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2419" class="blob-num js-line-number" data-line-number="2419"></td>
+ <td id="LC2419" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2420" class="blob-num js-line-number" data-line-number="2420"></td>
+ <td id="LC2420" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2421" class="blob-num js-line-number" data-line-number="2421"></td>
+ <td id="LC2421" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c106) {</td>
+ </tr>
+ <tr>
+ <td id="L2422" class="blob-num js-line-number" data-line-number="2422"></td>
+ <td id="LC2422" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$c106;</td>
+ </tr>
+ <tr>
+ <td id="L2423" class="blob-num js-line-number" data-line-number="2423"></td>
+ <td id="LC2423" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2424" class="blob-num js-line-number" data-line-number="2424"></td>
+ <td id="LC2424" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2425" class="blob-num js-line-number" data-line-number="2425"></td>
+ <td id="LC2425" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2426" class="blob-num js-line-number" data-line-number="2426"></td>
+ <td id="LC2426" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c107); }</td>
+ </tr>
+ <tr>
+ <td id="L2427" class="blob-num js-line-number" data-line-number="2427"></td>
+ <td id="LC2427" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2428" class="blob-num js-line-number" data-line-number="2428"></td>
+ <td id="LC2428" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s1 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2429" class="blob-num js-line-number" data-line-number="2429"></td>
+ <td id="LC2429" class="blob-code blob-code-inner js-file-line"> s2 <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L2430" class="blob-num js-line-number" data-line-number="2430"></td>
+ <td id="LC2430" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2431" class="blob-num js-line-number" data-line-number="2431"></td>
+ <td id="LC2431" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2432" class="blob-num js-line-number" data-line-number="2432"></td>
+ <td id="LC2432" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2433" class="blob-num js-line-number" data-line-number="2433"></td>
+ <td id="LC2433" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c108) {</td>
+ </tr>
+ <tr>
+ <td id="L2434" class="blob-num js-line-number" data-line-number="2434"></td>
+ <td id="LC2434" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c108;</td>
+ </tr>
+ <tr>
+ <td id="L2435" class="blob-num js-line-number" data-line-number="2435"></td>
+ <td id="LC2435" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2436" class="blob-num js-line-number" data-line-number="2436"></td>
+ <td id="LC2436" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2437" class="blob-num js-line-number" data-line-number="2437"></td>
+ <td id="LC2437" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2438" class="blob-num js-line-number" data-line-number="2438"></td>
+ <td id="LC2438" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c109); }</td>
+ </tr>
+ <tr>
+ <td id="L2439" class="blob-num js-line-number" data-line-number="2439"></td>
+ <td id="LC2439" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2440" class="blob-num js-line-number" data-line-number="2440"></td>
+ <td id="LC2440" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2441" class="blob-num js-line-number" data-line-number="2441"></td>
+ <td id="LC2441" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2442" class="blob-num js-line-number" data-line-number="2442"></td>
+ <td id="LC2442" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c30;</td>
+ </tr>
+ <tr>
+ <td id="L2443" class="blob-num js-line-number" data-line-number="2443"></td>
+ <td id="LC2443" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2444" class="blob-num js-line-number" data-line-number="2444"></td>
+ <td id="LC2444" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2445" class="blob-num js-line-number" data-line-number="2445"></td>
+ <td id="LC2445" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2446" class="blob-num js-line-number" data-line-number="2446"></td>
+ <td id="LC2446" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2447" class="blob-num js-line-number" data-line-number="2447"></td>
+ <td id="LC2447" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2448" class="blob-num js-line-number" data-line-number="2448"></td>
+ <td id="LC2448" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> peg$currPos) {</td>
+ </tr>
+ <tr>
+ <td id="L2449" class="blob-num js-line-number" data-line-number="2449"></td>
+ <td id="LC2449" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2450" class="blob-num js-line-number" data-line-number="2450"></td>
+ <td id="LC2450" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2451" class="blob-num js-line-number" data-line-number="2451"></td>
+ <td id="LC2451" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2452" class="blob-num js-line-number" data-line-number="2452"></td>
+ <td id="LC2452" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2453" class="blob-num js-line-number" data-line-number="2453"></td>
+ <td id="LC2453" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c110); }</td>
+ </tr>
+ <tr>
+ <td id="L2454" class="blob-num js-line-number" data-line-number="2454"></td>
+ <td id="LC2454" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2455" class="blob-num js-line-number" data-line-number="2455"></td>
+ <td id="LC2455" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2456" class="blob-num js-line-number" data-line-number="2456"></td>
+ <td id="LC2456" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5];</td>
+ </tr>
+ <tr>
+ <td id="L2457" class="blob-num js-line-number" data-line-number="2457"></td>
+ <td id="LC2457" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2458" class="blob-num js-line-number" data-line-number="2458"></td>
+ <td id="LC2458" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2459" class="blob-num js-line-number" data-line-number="2459"></td>
+ <td id="LC2459" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2460" class="blob-num js-line-number" data-line-number="2460"></td>
+ <td id="LC2460" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2461" class="blob-num js-line-number" data-line-number="2461"></td>
+ <td id="LC2461" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2462" class="blob-num js-line-number" data-line-number="2462"></td>
+ <td id="LC2462" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2463" class="blob-num js-line-number" data-line-number="2463"></td>
+ <td id="LC2463" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2464" class="blob-num js-line-number" data-line-number="2464"></td>
+ <td id="LC2464" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2465" class="blob-num js-line-number" data-line-number="2465"></td>
+ <td id="LC2465" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2466" class="blob-num js-line-number" data-line-number="2466"></td>
+ <td id="LC2466" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2467" class="blob-num js-line-number" data-line-number="2467"></td>
+ <td id="LC2467" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">s2</span>.<span class="pl-c1">push</span>(s3);</td>
+ </tr>
+ <tr>
+ <td id="L2468" class="blob-num js-line-number" data-line-number="2468"></td>
+ <td id="LC2468" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2469" class="blob-num js-line-number" data-line-number="2469"></td>
+ <td id="LC2469" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$currPos;</td>
+ </tr>
+ <tr>
+ <td id="L2470" class="blob-num js-line-number" data-line-number="2470"></td>
+ <td id="LC2470" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2471" class="blob-num js-line-number" data-line-number="2471"></td>
+ <td id="LC2471" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c108) {</td>
+ </tr>
+ <tr>
+ <td id="L2472" class="blob-num js-line-number" data-line-number="2472"></td>
+ <td id="LC2472" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$c108;</td>
+ </tr>
+ <tr>
+ <td id="L2473" class="blob-num js-line-number" data-line-number="2473"></td>
+ <td id="LC2473" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2474" class="blob-num js-line-number" data-line-number="2474"></td>
+ <td id="LC2474" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2475" class="blob-num js-line-number" data-line-number="2475"></td>
+ <td id="LC2475" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2476" class="blob-num js-line-number" data-line-number="2476"></td>
+ <td id="LC2476" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c109); }</td>
+ </tr>
+ <tr>
+ <td id="L2477" class="blob-num js-line-number" data-line-number="2477"></td>
+ <td id="LC2477" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2478" class="blob-num js-line-number" data-line-number="2478"></td>
+ <td id="LC2478" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2479" class="blob-num js-line-number" data-line-number="2479"></td>
+ <td id="LC2479" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2480" class="blob-num js-line-number" data-line-number="2480"></td>
+ <td id="LC2480" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c30;</td>
+ </tr>
+ <tr>
+ <td id="L2481" class="blob-num js-line-number" data-line-number="2481"></td>
+ <td id="LC2481" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2482" class="blob-num js-line-number" data-line-number="2482"></td>
+ <td id="LC2482" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2483" class="blob-num js-line-number" data-line-number="2483"></td>
+ <td id="LC2483" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2484" class="blob-num js-line-number" data-line-number="2484"></td>
+ <td id="LC2484" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2485" class="blob-num js-line-number" data-line-number="2485"></td>
+ <td id="LC2485" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s4 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2486" class="blob-num js-line-number" data-line-number="2486"></td>
+ <td id="LC2486" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> peg$currPos) {</td>
+ </tr>
+ <tr>
+ <td id="L2487" class="blob-num js-line-number" data-line-number="2487"></td>
+ <td id="LC2487" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> <span class="pl-smi">input</span>.<span class="pl-c1">charAt</span>(peg$currPos);</td>
+ </tr>
+ <tr>
+ <td id="L2488" class="blob-num js-line-number" data-line-number="2488"></td>
+ <td id="LC2488" class="blob-code blob-code-inner js-file-line"> peg$currPos<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2489" class="blob-num js-line-number" data-line-number="2489"></td>
+ <td id="LC2489" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2490" class="blob-num js-line-number" data-line-number="2490"></td>
+ <td id="LC2490" class="blob-code blob-code-inner js-file-line"> s5 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2491" class="blob-num js-line-number" data-line-number="2491"></td>
+ <td id="LC2491" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c110); }</td>
+ </tr>
+ <tr>
+ <td id="L2492" class="blob-num js-line-number" data-line-number="2492"></td>
+ <td id="LC2492" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2493" class="blob-num js-line-number" data-line-number="2493"></td>
+ <td id="LC2493" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s5 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2494" class="blob-num js-line-number" data-line-number="2494"></td>
+ <td id="LC2494" class="blob-code blob-code-inner js-file-line"> s4 <span class="pl-k">=</span> [s4, s5];</td>
+ </tr>
+ <tr>
+ <td id="L2495" class="blob-num js-line-number" data-line-number="2495"></td>
+ <td id="LC2495" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> s4;</td>
+ </tr>
+ <tr>
+ <td id="L2496" class="blob-num js-line-number" data-line-number="2496"></td>
+ <td id="LC2496" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2497" class="blob-num js-line-number" data-line-number="2497"></td>
+ <td id="LC2497" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2498" class="blob-num js-line-number" data-line-number="2498"></td>
+ <td id="LC2498" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2499" class="blob-num js-line-number" data-line-number="2499"></td>
+ <td id="LC2499" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2500" class="blob-num js-line-number" data-line-number="2500"></td>
+ <td id="LC2500" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2501" class="blob-num js-line-number" data-line-number="2501"></td>
+ <td id="LC2501" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s3;</td>
+ </tr>
+ <tr>
+ <td id="L2502" class="blob-num js-line-number" data-line-number="2502"></td>
+ <td id="LC2502" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2503" class="blob-num js-line-number" data-line-number="2503"></td>
+ <td id="LC2503" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2504" class="blob-num js-line-number" data-line-number="2504"></td>
+ <td id="LC2504" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2505" class="blob-num js-line-number" data-line-number="2505"></td>
+ <td id="LC2505" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s2 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2506" class="blob-num js-line-number" data-line-number="2506"></td>
+ <td id="LC2506" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">input</span>.<span class="pl-c1">substr</span>(peg$currPos, <span class="pl-c1">2</span>) <span class="pl-k">===</span> peg$c108) {</td>
+ </tr>
+ <tr>
+ <td id="L2507" class="blob-num js-line-number" data-line-number="2507"></td>
+ <td id="LC2507" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$c108;</td>
+ </tr>
+ <tr>
+ <td id="L2508" class="blob-num js-line-number" data-line-number="2508"></td>
+ <td id="LC2508" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">+=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2509" class="blob-num js-line-number" data-line-number="2509"></td>
+ <td id="LC2509" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2510" class="blob-num js-line-number" data-line-number="2510"></td>
+ <td id="LC2510" class="blob-code blob-code-inner js-file-line"> s3 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2511" class="blob-num js-line-number" data-line-number="2511"></td>
+ <td id="LC2511" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c109); }</td>
+ </tr>
+ <tr>
+ <td id="L2512" class="blob-num js-line-number" data-line-number="2512"></td>
+ <td id="LC2512" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2513" class="blob-num js-line-number" data-line-number="2513"></td>
+ <td id="LC2513" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s3 <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2514" class="blob-num js-line-number" data-line-number="2514"></td>
+ <td id="LC2514" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> [s1, s2, s3];</td>
+ </tr>
+ <tr>
+ <td id="L2515" class="blob-num js-line-number" data-line-number="2515"></td>
+ <td id="LC2515" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> s1;</td>
+ </tr>
+ <tr>
+ <td id="L2516" class="blob-num js-line-number" data-line-number="2516"></td>
+ <td id="LC2516" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2517" class="blob-num js-line-number" data-line-number="2517"></td>
+ <td id="LC2517" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2518" class="blob-num js-line-number" data-line-number="2518"></td>
+ <td id="LC2518" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2519" class="blob-num js-line-number" data-line-number="2519"></td>
+ <td id="LC2519" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2520" class="blob-num js-line-number" data-line-number="2520"></td>
+ <td id="LC2520" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2521" class="blob-num js-line-number" data-line-number="2521"></td>
+ <td id="LC2521" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2522" class="blob-num js-line-number" data-line-number="2522"></td>
+ <td id="LC2522" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2523" class="blob-num js-line-number" data-line-number="2523"></td>
+ <td id="LC2523" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2524" class="blob-num js-line-number" data-line-number="2524"></td>
+ <td id="LC2524" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2525" class="blob-num js-line-number" data-line-number="2525"></td>
+ <td id="LC2525" class="blob-code blob-code-inner js-file-line"> peg$currPos <span class="pl-k">=</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2526" class="blob-num js-line-number" data-line-number="2526"></td>
+ <td id="LC2526" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> peg$c1;</td>
+ </tr>
+ <tr>
+ <td id="L2527" class="blob-num js-line-number" data-line-number="2527"></td>
+ <td id="LC2527" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2528" class="blob-num js-line-number" data-line-number="2528"></td>
+ <td id="LC2528" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2529" class="blob-num js-line-number" data-line-number="2529"></td>
+ <td id="LC2529" class="blob-code blob-code-inner js-file-line"> peg$silentFails<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2530" class="blob-num js-line-number" data-line-number="2530"></td>
+ <td id="LC2530" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2531" class="blob-num js-line-number" data-line-number="2531"></td>
+ <td id="LC2531" class="blob-code blob-code-inner js-file-line"> s1 <span class="pl-k">=</span> peg$<span class="pl-c1">FAILED</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2532" class="blob-num js-line-number" data-line-number="2532"></td>
+ <td id="LC2532" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$silentFails <span class="pl-k">===</span> <span class="pl-c1">0</span>) { <span class="pl-en">peg$fail</span>(peg$c101); }</td>
+ </tr>
+ <tr>
+ <td id="L2533" class="blob-num js-line-number" data-line-number="2533"></td>
+ <td id="LC2533" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2534" class="blob-num js-line-number" data-line-number="2534"></td>
+ <td id="LC2534" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2535" class="blob-num js-line-number" data-line-number="2535"></td>
+ <td id="LC2535" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2536" class="blob-num js-line-number" data-line-number="2536"></td>
+ <td id="LC2536" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2537" class="blob-num js-line-number" data-line-number="2537"></td>
+ <td id="LC2537" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2538" class="blob-num js-line-number" data-line-number="2538"></td>
+ <td id="LC2538" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">peg$parse_</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2539" class="blob-num js-line-number" data-line-number="2539"></td>
+ <td id="LC2539" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2540" class="blob-num js-line-number" data-line-number="2540"></td>
+ <td id="LC2540" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2541" class="blob-num js-line-number" data-line-number="2541"></td>
+ <td id="LC2541" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parsewhitespace</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2542" class="blob-num js-line-number" data-line-number="2542"></td>
+ <td id="LC2542" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (s0 <span class="pl-k">===</span> peg$<span class="pl-c1">FAILED</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2543" class="blob-num js-line-number" data-line-number="2543"></td>
+ <td id="LC2543" class="blob-code blob-code-inner js-file-line"> s0 <span class="pl-k">=</span> <span class="pl-en">peg$parsecomment</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2544" class="blob-num js-line-number" data-line-number="2544"></td>
+ <td id="LC2544" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2545" class="blob-num js-line-number" data-line-number="2545"></td>
+ <td id="LC2545" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2546" class="blob-num js-line-number" data-line-number="2546"></td>
+ <td id="LC2546" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> s0;</td>
+ </tr>
+ <tr>
+ <td id="L2547" class="blob-num js-line-number" data-line-number="2547"></td>
+ <td id="LC2547" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2548" class="blob-num js-line-number" data-line-number="2548"></td>
+ <td id="LC2548" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2549" class="blob-num js-line-number" data-line-number="2549"></td>
+ <td id="LC2549" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2550" class="blob-num js-line-number" data-line-number="2550"></td>
+ <td id="LC2550" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2551" class="blob-num js-line-number" data-line-number="2551"></td>
+ <td id="LC2551" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> directed;</td>
+ </tr>
+ <tr>
+ <td id="L2552" class="blob-num js-line-number" data-line-number="2552"></td>
+ <td id="LC2552" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2553" class="blob-num js-line-number" data-line-number="2553"></td>
+ <td id="LC2553" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2554" class="blob-num js-line-number" data-line-number="2554"></td>
+ <td id="LC2554" class="blob-code blob-code-inner js-file-line"> peg$result <span class="pl-k">=</span> <span class="pl-en">peg$startRuleFunction</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2555" class="blob-num js-line-number" data-line-number="2555"></td>
+ <td id="LC2555" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2556" class="blob-num js-line-number" data-line-number="2556"></td>
+ <td id="LC2556" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$result <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span> <span class="pl-k">&&</span> peg$currPos <span class="pl-k">===</span> <span class="pl-smi">input</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2557" class="blob-num js-line-number" data-line-number="2557"></td>
+ <td id="LC2557" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> peg$result;</td>
+ </tr>
+ <tr>
+ <td id="L2558" class="blob-num js-line-number" data-line-number="2558"></td>
+ <td id="LC2558" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2559" class="blob-num js-line-number" data-line-number="2559"></td>
+ <td id="LC2559" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (peg$result <span class="pl-k">!==</span> peg$<span class="pl-c1">FAILED</span> <span class="pl-k">&&</span> peg$currPos <span class="pl-k"><</span> <span class="pl-smi">input</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2560" class="blob-num js-line-number" data-line-number="2560"></td>
+ <td id="LC2560" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">peg$fail</span>({ type<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>end<span class="pl-pds">"</span></span>, description<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>end of input<span class="pl-pds">"</span></span> });</td>
+ </tr>
+ <tr>
+ <td id="L2561" class="blob-num js-line-number" data-line-number="2561"></td>
+ <td id="LC2561" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2562" class="blob-num js-line-number" data-line-number="2562"></td>
+ <td id="LC2562" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2563" class="blob-num js-line-number" data-line-number="2563"></td>
+ <td id="LC2563" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-en">peg$buildException</span>(<span class="pl-c1">null</span>, peg$maxFailExpected, peg$maxFailPos);</td>
+ </tr>
+ <tr>
+ <td id="L2564" class="blob-num js-line-number" data-line-number="2564"></td>
+ <td id="LC2564" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2565" class="blob-num js-line-number" data-line-number="2565"></td>
+ <td id="LC2565" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2566" class="blob-num js-line-number" data-line-number="2566"></td>
+ <td id="LC2566" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2567" class="blob-num js-line-number" data-line-number="2567"></td>
+ <td id="LC2567" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2568" class="blob-num js-line-number" data-line-number="2568"></td>
+ <td id="LC2568" class="blob-code blob-code-inner js-file-line"> SyntaxError<span class="pl-k">:</span> SyntaxError,</td>
+ </tr>
+ <tr>
+ <td id="L2569" class="blob-num js-line-number" data-line-number="2569"></td>
+ <td id="LC2569" class="blob-code blob-code-inner js-file-line"> parse<span class="pl-k">:</span> parse</td>
+ </tr>
+ <tr>
+ <td id="L2570" class="blob-num js-line-number" data-line-number="2570"></td>
+ <td id="LC2570" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L2571" class="blob-num js-line-number" data-line-number="2571"></td>
+ <td id="LC2571" class="blob-code blob-code-inner js-file-line">})();</td>
+ </tr>
+ <tr>
+ <td id="L2572" class="blob-num js-line-number" data-line-number="2572"></td>
+ <td id="LC2572" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2573" class="blob-num js-line-number" data-line-number="2573"></td>
+ <td id="LC2573" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">6</span>}],<span class="pl-c1">5</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2574" class="blob-num js-line-number" data-line-number="2574"></td>
+ <td id="LC2574" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* global window */</span></td>
+ </tr>
+ <tr>
+ <td id="L2575" class="blob-num js-line-number" data-line-number="2575"></td>
+ <td id="LC2575" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2576" class="blob-num js-line-number" data-line-number="2576"></td>
+ <td id="LC2576" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> graphlib;</td>
+ </tr>
+ <tr>
+ <td id="L2577" class="blob-num js-line-number" data-line-number="2577"></td>
+ <td id="LC2577" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2578" class="blob-num js-line-number" data-line-number="2578"></td>
+ <td id="LC2578" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> (require) {</td>
+ </tr>
+ <tr>
+ <td id="L2579" class="blob-num js-line-number" data-line-number="2579"></td>
+ <td id="LC2579" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2580" class="blob-num js-line-number" data-line-number="2580"></td>
+ <td id="LC2580" class="blob-code blob-code-inner js-file-line"> graphlib <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>graphlib<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2581" class="blob-num js-line-number" data-line-number="2581"></td>
+ <td id="LC2581" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">catch</span> (e) {}</td>
+ </tr>
+ <tr>
+ <td id="L2582" class="blob-num js-line-number" data-line-number="2582"></td>
+ <td id="LC2582" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2583" class="blob-num js-line-number" data-line-number="2583"></td>
+ <td id="LC2583" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2584" class="blob-num js-line-number" data-line-number="2584"></td>
+ <td id="LC2584" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> (<span class="pl-k">!</span>graphlib) {</td>
+ </tr>
+ <tr>
+ <td id="L2585" class="blob-num js-line-number" data-line-number="2585"></td>
+ <td id="LC2585" class="blob-code blob-code-inner js-file-line"> graphlib <span class="pl-k">=</span> <span class="pl-c1">window</span>.<span class="pl-smi">graphlib</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2586" class="blob-num js-line-number" data-line-number="2586"></td>
+ <td id="LC2586" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2587" class="blob-num js-line-number" data-line-number="2587"></td>
+ <td id="LC2587" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2588" class="blob-num js-line-number" data-line-number="2588"></td>
+ <td id="LC2588" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> graphlib;</td>
+ </tr>
+ <tr>
+ <td id="L2589" class="blob-num js-line-number" data-line-number="2589"></td>
+ <td id="LC2589" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2590" class="blob-num js-line-number" data-line-number="2590"></td>
+ <td id="LC2590" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>graphlib<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">11</span>}],<span class="pl-c1">6</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2591" class="blob-num js-line-number" data-line-number="2591"></td>
+ <td id="LC2591" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* global window */</span></td>
+ </tr>
+ <tr>
+ <td id="L2592" class="blob-num js-line-number" data-line-number="2592"></td>
+ <td id="LC2592" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2593" class="blob-num js-line-number" data-line-number="2593"></td>
+ <td id="LC2593" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> lodash;</td>
+ </tr>
+ <tr>
+ <td id="L2594" class="blob-num js-line-number" data-line-number="2594"></td>
+ <td id="LC2594" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2595" class="blob-num js-line-number" data-line-number="2595"></td>
+ <td id="LC2595" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> (require) {</td>
+ </tr>
+ <tr>
+ <td id="L2596" class="blob-num js-line-number" data-line-number="2596"></td>
+ <td id="LC2596" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2597" class="blob-num js-line-number" data-line-number="2597"></td>
+ <td id="LC2597" class="blob-code blob-code-inner js-file-line"> lodash <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2598" class="blob-num js-line-number" data-line-number="2598"></td>
+ <td id="LC2598" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">catch</span> (e) {}</td>
+ </tr>
+ <tr>
+ <td id="L2599" class="blob-num js-line-number" data-line-number="2599"></td>
+ <td id="LC2599" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2600" class="blob-num js-line-number" data-line-number="2600"></td>
+ <td id="LC2600" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2601" class="blob-num js-line-number" data-line-number="2601"></td>
+ <td id="LC2601" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> (<span class="pl-k">!</span>lodash) {</td>
+ </tr>
+ <tr>
+ <td id="L2602" class="blob-num js-line-number" data-line-number="2602"></td>
+ <td id="LC2602" class="blob-code blob-code-inner js-file-line"> lodash <span class="pl-k">=</span> <span class="pl-c1">window</span>.<span class="pl-smi">_</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2603" class="blob-num js-line-number" data-line-number="2603"></td>
+ <td id="LC2603" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2604" class="blob-num js-line-number" data-line-number="2604"></td>
+ <td id="LC2604" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2605" class="blob-num js-line-number" data-line-number="2605"></td>
+ <td id="LC2605" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> lodash;</td>
+ </tr>
+ <tr>
+ <td id="L2606" class="blob-num js-line-number" data-line-number="2606"></td>
+ <td id="LC2606" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2607" class="blob-num js-line-number" data-line-number="2607"></td>
+ <td id="LC2607" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">31</span>}],<span class="pl-c1">7</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2608" class="blob-num js-line-number" data-line-number="2608"></td>
+ <td id="LC2608" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2609" class="blob-num js-line-number" data-line-number="2609"></td>
+ <td id="LC2609" class="blob-code blob-code-inner js-file-line"> grammar <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dot-grammar<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2610" class="blob-num js-line-number" data-line-number="2610"></td>
+ <td id="LC2610" class="blob-code blob-code-inner js-file-line"> buildGraph <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./build-graph<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2611" class="blob-num js-line-number" data-line-number="2611"></td>
+ <td id="LC2611" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2612" class="blob-num js-line-number" data-line-number="2612"></td>
+ <td id="LC2612" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-en">exports</span> <span class="pl-k">=</span> <span class="pl-k">function</span> <span class="pl-en">readMany</span>(<span class="pl-smi">str</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2613" class="blob-num js-line-number" data-line-number="2613"></td>
+ <td id="LC2613" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> parseTree <span class="pl-k">=</span> <span class="pl-smi">grammar</span>.<span class="pl-c1">parse</span>(str);</td>
+ </tr>
+ <tr>
+ <td id="L2614" class="blob-num js-line-number" data-line-number="2614"></td>
+ <td id="LC2614" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">map</span>(parseTree, buildGraph);</td>
+ </tr>
+ <tr>
+ <td id="L2615" class="blob-num js-line-number" data-line-number="2615"></td>
+ <td id="LC2615" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2616" class="blob-num js-line-number" data-line-number="2616"></td>
+ <td id="LC2616" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2617" class="blob-num js-line-number" data-line-number="2617"></td>
+ <td id="LC2617" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./build-graph<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">3</span>,<span class="pl-s"><span class="pl-pds">"</span>./dot-grammar<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">4</span>,<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</sp [...]
+ </tr>
+ <tr>
+ <td id="L2618" class="blob-num js-line-number" data-line-number="2618"></td>
+ <td id="LC2618" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> grammar <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dot-grammar<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2619" class="blob-num js-line-number" data-line-number="2619"></td>
+ <td id="LC2619" class="blob-code blob-code-inner js-file-line"> buildGraph <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./build-graph<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2620" class="blob-num js-line-number" data-line-number="2620"></td>
+ <td id="LC2620" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2621" class="blob-num js-line-number" data-line-number="2621"></td>
+ <td id="LC2621" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-en">exports</span> <span class="pl-k">=</span> <span class="pl-k">function</span> <span class="pl-en">readOne</span>(<span class="pl-smi">str</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2622" class="blob-num js-line-number" data-line-number="2622"></td>
+ <td id="LC2622" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> parseTree <span class="pl-k">=</span> <span class="pl-smi">grammar</span>.<span class="pl-c1">parse</span>(str, { startRule<span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>graphStmt<span class="pl-pds">"</span></span> });</td>
+ </tr>
+ <tr>
+ <td id="L2623" class="blob-num js-line-number" data-line-number="2623"></td>
+ <td id="LC2623" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">buildGraph</span>(parseTree);</td>
+ </tr>
+ <tr>
+ <td id="L2624" class="blob-num js-line-number" data-line-number="2624"></td>
+ <td id="LC2624" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2625" class="blob-num js-line-number" data-line-number="2625"></td>
+ <td id="LC2625" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2626" class="blob-num js-line-number" data-line-number="2626"></td>
+ <td id="LC2626" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2627" class="blob-num js-line-number" data-line-number="2627"></td>
+ <td id="LC2627" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./build-graph<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">3</span>,<span class="pl-s"><span class="pl-pds">"</span>./dot-grammar<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">4</span>}],<span class="pl-c1">9</span><span class="pl-k">:</span>[<span class="pl-k">function</span> [...]
+ </tr>
+ <tr>
+ <td id="L2628" class="blob-num js-line-number" data-line-number="2628"></td>
+ <td id="LC2628" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>0.6.2<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L2629" class="blob-num js-line-number" data-line-number="2629"></td>
+ <td id="LC2629" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2630" class="blob-num js-line-number" data-line-number="2630"></td>
+ <td id="LC2630" class="blob-code blob-code-inner js-file-line">},{}],<span class="pl-c1">10</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2631" class="blob-num js-line-number" data-line-number="2631"></td>
+ <td id="LC2631" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2632" class="blob-num js-line-number" data-line-number="2632"></td>
+ <td id="LC2632" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2633" class="blob-num js-line-number" data-line-number="2633"></td>
+ <td id="LC2633" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> writeOne;</td>
+ </tr>
+ <tr>
+ <td id="L2634" class="blob-num js-line-number" data-line-number="2634"></td>
+ <td id="LC2634" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2635" class="blob-num js-line-number" data-line-number="2635"></td>
+ <td id="LC2635" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> <span class="pl-c1">UNESCAPED_ID_PATTERN</span> <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">[<span class="pl-c1">a-zA-Z<span class="pl-c1">\200</span>-<span class="pl-c1">\377</span></span>_][<span class="pl-c1">a-zA-Z<span class="pl-c1">\200</span>-<span class="pl-c1">\377</span></span>_<span class="pl-c1">0- [...]
+ </tr>
+ <tr>
+ <td id="L2636" class="blob-num js-line-number" data-line-number="2636"></td>
+ <td id="LC2636" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2637" class="blob-num js-line-number" data-line-number="2637"></td>
+ <td id="LC2637" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeOne</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2638" class="blob-num js-line-number" data-line-number="2638"></td>
+ <td id="LC2638" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ec <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">isDirected</span>() <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">"</span>-><span class="pl-pds">"</span></span> <span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>--<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L2639" class="blob-num js-line-number" data-line-number="2639"></td>
+ <td id="LC2639" class="blob-code blob-code-inner js-file-line"> writer <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">Writer</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2640" class="blob-num js-line-number" data-line-number="2640"></td>
+ <td id="LC2640" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2641" class="blob-num js-line-number" data-line-number="2641"></td>
+ <td id="LC2641" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">isMultigraph</span>()) {</td>
+ </tr>
+ <tr>
+ <td id="L2642" class="blob-num js-line-number" data-line-number="2642"></td>
+ <td id="LC2642" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-c1">write</span>(<span class="pl-s"><span class="pl-pds">"</span>strict <span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2643" class="blob-num js-line-number" data-line-number="2643"></td>
+ <td id="LC2643" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2644" class="blob-num js-line-number" data-line-number="2644"></td>
+ <td id="LC2644" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2645" class="blob-num js-line-number" data-line-number="2645"></td>
+ <td id="LC2645" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>((<span class="pl-smi">g</span>.<span class="pl-en">isDirected</span>() <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">"</span>digraph<span class="pl-pds">"</span></span> <span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>graph<span class="pl-pds">"</span></span>) <span class="pl-k [...]
+ </tr>
+ <tr>
+ <td id="L2646" class="blob-num js-line-number" data-line-number="2646"></td>
+ <td id="LC2646" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">indent</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2647" class="blob-num js-line-number" data-line-number="2647"></td>
+ <td id="LC2647" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2648" class="blob-num js-line-number" data-line-number="2648"></td>
+ <td id="LC2648" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> graphAttrs <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">graph</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2649" class="blob-num js-line-number" data-line-number="2649"></td>
+ <td id="LC2649" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">isObject</span>(graphAttrs)) {</td>
+ </tr>
+ <tr>
+ <td id="L2650" class="blob-num js-line-number" data-line-number="2650"></td>
+ <td id="LC2650" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(graphAttrs, <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">k</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2651" class="blob-num js-line-number" data-line-number="2651"></td>
+ <td id="LC2651" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>(<span class="pl-en">id</span>(k) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>=<span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-en">id</span>(v) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>;<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2652" class="blob-num js-line-number" data-line-number="2652"></td>
+ <td id="LC2652" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2653" class="blob-num js-line-number" data-line-number="2653"></td>
+ <td id="LC2653" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2654" class="blob-num js-line-number" data-line-number="2654"></td>
+ <td id="LC2654" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2655" class="blob-num js-line-number" data-line-number="2655"></td>
+ <td id="LC2655" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">writeSubgraph</span>(g, <span class="pl-c1">undefined</span>, writer);</td>
+ </tr>
+ <tr>
+ <td id="L2656" class="blob-num js-line-number" data-line-number="2656"></td>
+ <td id="LC2656" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2657" class="blob-num js-line-number" data-line-number="2657"></td>
+ <td id="LC2657" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">edges</span>().<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">edge</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2658" class="blob-num js-line-number" data-line-number="2658"></td>
+ <td id="LC2658" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">writeEdge</span>(g, edge, ec, writer);</td>
+ </tr>
+ <tr>
+ <td id="L2659" class="blob-num js-line-number" data-line-number="2659"></td>
+ <td id="LC2659" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2660" class="blob-num js-line-number" data-line-number="2660"></td>
+ <td id="LC2660" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2661" class="blob-num js-line-number" data-line-number="2661"></td>
+ <td id="LC2661" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">unindent</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2662" class="blob-num js-line-number" data-line-number="2662"></td>
+ <td id="LC2662" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>(<span class="pl-s"><span class="pl-pds">"</span>}<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2663" class="blob-num js-line-number" data-line-number="2663"></td>
+ <td id="LC2663" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2664" class="blob-num js-line-number" data-line-number="2664"></td>
+ <td id="LC2664" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">writer</span>.<span class="pl-c1">toString</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2665" class="blob-num js-line-number" data-line-number="2665"></td>
+ <td id="LC2665" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2666" class="blob-num js-line-number" data-line-number="2666"></td>
+ <td id="LC2666" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2667" class="blob-num js-line-number" data-line-number="2667"></td>
+ <td id="LC2667" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeSubgraph</span>(<span class="pl-smi">g</span>, <span class="pl-smi">v</span>, <span class="pl-smi">writer</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2668" class="blob-num js-line-number" data-line-number="2668"></td>
+ <td id="LC2668" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> children <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">isCompound</span>() <span class="pl-k">?</span> <span class="pl-smi">g</span>.<span class="pl-en">children</span>(v) <span class="pl-k">:</span> <span class="pl-smi">g</span>.<span class="pl-en">nodes</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2669" class="blob-num js-line-number" data-line-number="2669"></td>
+ <td id="LC2669" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(children, <span class="pl-k">function</span>(<span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2670" class="blob-num js-line-number" data-line-number="2670"></td>
+ <td id="LC2670" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">isCompound</span>() <span class="pl-k">||</span> <span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">children</span>(w).<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2671" class="blob-num js-line-number" data-line-number="2671"></td>
+ <td id="LC2671" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">writeNode</span>(g, w, writer);</td>
+ </tr>
+ <tr>
+ <td id="L2672" class="blob-num js-line-number" data-line-number="2672"></td>
+ <td id="LC2672" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2673" class="blob-num js-line-number" data-line-number="2673"></td>
+ <td id="LC2673" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>(<span class="pl-s"><span class="pl-pds">"</span>subgraph <span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-en">id</span>(w) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> {<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2674" class="blob-num js-line-number" data-line-number="2674"></td>
+ <td id="LC2674" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">indent</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2675" class="blob-num js-line-number" data-line-number="2675"></td>
+ <td id="LC2675" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2676" class="blob-num js-line-number" data-line-number="2676"></td>
+ <td id="LC2676" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">isObject</span>(<span class="pl-smi">g</span>.<span class="pl-en">node</span>(w))) {</td>
+ </tr>
+ <tr>
+ <td id="L2677" class="blob-num js-line-number" data-line-number="2677"></td>
+ <td id="LC2677" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">map</span>(<span class="pl-smi">g</span>.<span class="pl-en">node</span>(w), <span class="pl-k">function</span>(<span class="pl-smi">val</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2678" class="blob-num js-line-number" data-line-number="2678"></td>
+ <td id="LC2678" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>(<span class="pl-en">id</span>(key) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>=<span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-en">id</span>(val) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>;<span class="pl-pds">"</span>< [...]
+ </tr>
+ <tr>
+ <td id="L2679" class="blob-num js-line-number" data-line-number="2679"></td>
+ <td id="LC2679" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2680" class="blob-num js-line-number" data-line-number="2680"></td>
+ <td id="LC2680" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2681" class="blob-num js-line-number" data-line-number="2681"></td>
+ <td id="LC2681" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2682" class="blob-num js-line-number" data-line-number="2682"></td>
+ <td id="LC2682" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">writeSubgraph</span>(g, w, writer);</td>
+ </tr>
+ <tr>
+ <td id="L2683" class="blob-num js-line-number" data-line-number="2683"></td>
+ <td id="LC2683" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">unindent</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2684" class="blob-num js-line-number" data-line-number="2684"></td>
+ <td id="LC2684" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>(<span class="pl-s"><span class="pl-pds">"</span>}<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2685" class="blob-num js-line-number" data-line-number="2685"></td>
+ <td id="LC2685" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2686" class="blob-num js-line-number" data-line-number="2686"></td>
+ <td id="LC2686" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2687" class="blob-num js-line-number" data-line-number="2687"></td>
+ <td id="LC2687" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2688" class="blob-num js-line-number" data-line-number="2688"></td>
+ <td id="LC2688" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2689" class="blob-num js-line-number" data-line-number="2689"></td>
+ <td id="LC2689" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeNode</span>(<span class="pl-smi">g</span>, <span class="pl-smi">v</span>, <span class="pl-smi">writer</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2690" class="blob-num js-line-number" data-line-number="2690"></td>
+ <td id="LC2690" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-c1">write</span>(<span class="pl-en">id</span>(v));</td>
+ </tr>
+ <tr>
+ <td id="L2691" class="blob-num js-line-number" data-line-number="2691"></td>
+ <td id="LC2691" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">writeAttrs</span>(<span class="pl-smi">g</span>.<span class="pl-en">node</span>(v), writer);</td>
+ </tr>
+ <tr>
+ <td id="L2692" class="blob-num js-line-number" data-line-number="2692"></td>
+ <td id="LC2692" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2693" class="blob-num js-line-number" data-line-number="2693"></td>
+ <td id="LC2693" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2694" class="blob-num js-line-number" data-line-number="2694"></td>
+ <td id="LC2694" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2695" class="blob-num js-line-number" data-line-number="2695"></td>
+ <td id="LC2695" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeEdge</span>(<span class="pl-smi">g</span>, <span class="pl-smi">edge</span>, <span class="pl-smi">ec</span>, <span class="pl-smi">writer</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2696" class="blob-num js-line-number" data-line-number="2696"></td>
+ <td id="LC2696" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> v <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2697" class="blob-num js-line-number" data-line-number="2697"></td>
+ <td id="LC2697" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">w</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2698" class="blob-num js-line-number" data-line-number="2698"></td>
+ <td id="LC2698" class="blob-code blob-code-inner js-file-line"> attrs <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">edge</span>(edge);</td>
+ </tr>
+ <tr>
+ <td id="L2699" class="blob-num js-line-number" data-line-number="2699"></td>
+ <td id="LC2699" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2700" class="blob-num js-line-number" data-line-number="2700"></td>
+ <td id="LC2700" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-c1">write</span>(<span class="pl-en">id</span>(v) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> <span class="pl-pds">"</span></span> <span class="pl-k">+</span> ec <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> <span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class [...]
+ </tr>
+ <tr>
+ <td id="L2701" class="blob-num js-line-number" data-line-number="2701"></td>
+ <td id="LC2701" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">writeAttrs</span>(attrs, writer);</td>
+ </tr>
+ <tr>
+ <td id="L2702" class="blob-num js-line-number" data-line-number="2702"></td>
+ <td id="LC2702" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-en">writeLine</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2703" class="blob-num js-line-number" data-line-number="2703"></td>
+ <td id="LC2703" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2704" class="blob-num js-line-number" data-line-number="2704"></td>
+ <td id="LC2704" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2705" class="blob-num js-line-number" data-line-number="2705"></td>
+ <td id="LC2705" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeAttrs</span>(<span class="pl-smi">attrs</span>, <span class="pl-smi">writer</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2706" class="blob-num js-line-number" data-line-number="2706"></td>
+ <td id="LC2706" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">isObject</span>(attrs)) {</td>
+ </tr>
+ <tr>
+ <td id="L2707" class="blob-num js-line-number" data-line-number="2707"></td>
+ <td id="LC2707" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> attrStrs <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">map</span>(attrs, <span class="pl-k">function</span>(<span class="pl-smi">val</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2708" class="blob-num js-line-number" data-line-number="2708"></td>
+ <td id="LC2708" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">id</span>(key) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>=<span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-en">id</span>(val);</td>
+ </tr>
+ <tr>
+ <td id="L2709" class="blob-num js-line-number" data-line-number="2709"></td>
+ <td id="LC2709" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2710" class="blob-num js-line-number" data-line-number="2710"></td>
+ <td id="LC2710" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">attrStrs</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2711" class="blob-num js-line-number" data-line-number="2711"></td>
+ <td id="LC2711" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">writer</span>.<span class="pl-c1">write</span>(<span class="pl-s"><span class="pl-pds">"</span> [<span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-smi">attrStrs</span>.<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">"</span>,<span class="pl-pds">"</span></span>) <span class="pl-k">+</span> <span class="pl-s"><span cla [...]
+ </tr>
+ <tr>
+ <td id="L2712" class="blob-num js-line-number" data-line-number="2712"></td>
+ <td id="LC2712" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2713" class="blob-num js-line-number" data-line-number="2713"></td>
+ <td id="LC2713" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2714" class="blob-num js-line-number" data-line-number="2714"></td>
+ <td id="LC2714" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2715" class="blob-num js-line-number" data-line-number="2715"></td>
+ <td id="LC2715" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2716" class="blob-num js-line-number" data-line-number="2716"></td>
+ <td id="LC2716" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">id</span>(<span class="pl-smi">obj</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2717" class="blob-num js-line-number" data-line-number="2717"></td>
+ <td id="LC2717" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> obj <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span>number<span class="pl-pds">"</span></span> <span class="pl-k">||</span> <span class="pl-smi">obj</span>.<span class="pl-c1">toString</span>().<span class="pl-c1">match</span>(<span class="pl-c1">UNESCAPED_ID_PATTERN</span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L2718" class="blob-num js-line-number" data-line-number="2718"></td>
+ <td id="LC2718" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> obj;</td>
+ </tr>
+ <tr>
+ <td id="L2719" class="blob-num js-line-number" data-line-number="2719"></td>
+ <td id="LC2719" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2720" class="blob-num js-line-number" data-line-number="2720"></td>
+ <td id="LC2720" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2721" class="blob-num js-line-number" data-line-number="2721"></td>
+ <td id="LC2721" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\"</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-smi">obj</span>.<span class="pl-c1">toString</span>().<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span>"<span class="pl-pds">/</span>g</span>, <span class="pl-s"><span clas [...]
+ </tr>
+ <tr>
+ <td id="L2722" class="blob-num js-line-number" data-line-number="2722"></td>
+ <td id="LC2722" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2723" class="blob-num js-line-number" data-line-number="2723"></td>
+ <td id="LC2723" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2724" class="blob-num js-line-number" data-line-number="2724"></td>
+ <td id="LC2724" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// Helper object for making a pretty printer</span></td>
+ </tr>
+ <tr>
+ <td id="L2725" class="blob-num js-line-number" data-line-number="2725"></td>
+ <td id="LC2725" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">Writer</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2726" class="blob-num js-line-number" data-line-number="2726"></td>
+ <td id="LC2726" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_indent</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L2727" class="blob-num js-line-number" data-line-number="2727"></td>
+ <td id="LC2727" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-c1">_content</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L2728" class="blob-num js-line-number" data-line-number="2728"></td>
+ <td id="LC2728" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_shouldIndent</span> <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2729" class="blob-num js-line-number" data-line-number="2729"></td>
+ <td id="LC2729" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2730" class="blob-num js-line-number" data-line-number="2730"></td>
+ <td id="LC2730" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2731" class="blob-num js-line-number" data-line-number="2731"></td>
+ <td id="LC2731" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Writer</span>.<span class="pl-c1">prototype</span>.<span class="pl-c1">INDENT</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span> <span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L2732" class="blob-num js-line-number" data-line-number="2732"></td>
+ <td id="LC2732" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2733" class="blob-num js-line-number" data-line-number="2733"></td>
+ <td id="LC2733" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Writer</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">indent</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2734" class="blob-num js-line-number" data-line-number="2734"></td>
+ <td id="LC2734" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_indent</span> <span class="pl-k">+=</span> <span class="pl-v">this</span>.<span class="pl-c1">INDENT</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2735" class="blob-num js-line-number" data-line-number="2735"></td>
+ <td id="LC2735" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2736" class="blob-num js-line-number" data-line-number="2736"></td>
+ <td id="LC2736" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2737" class="blob-num js-line-number" data-line-number="2737"></td>
+ <td id="LC2737" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Writer</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">unindent</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2738" class="blob-num js-line-number" data-line-number="2738"></td>
+ <td id="LC2738" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_indent</span> <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_indent</span>.<span class="pl-c1">slice</span>(<span class="pl-v">this</span>.<span class="pl-c1">INDENT</span>.<span class="pl-c1">length</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2739" class="blob-num js-line-number" data-line-number="2739"></td>
+ <td id="LC2739" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2740" class="blob-num js-line-number" data-line-number="2740"></td>
+ <td id="LC2740" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2741" class="blob-num js-line-number" data-line-number="2741"></td>
+ <td id="LC2741" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Writer</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">writeLine</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">line</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2742" class="blob-num js-line-number" data-line-number="2742"></td>
+ <td id="LC2742" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-c1">write</span>((line <span class="pl-k">||</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>) <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\n</span><span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2743" class="blob-num js-line-number" data-line-number="2743"></td>
+ <td id="LC2743" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_shouldIndent</span> <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2744" class="blob-num js-line-number" data-line-number="2744"></td>
+ <td id="LC2744" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2745" class="blob-num js-line-number" data-line-number="2745"></td>
+ <td id="LC2745" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2746" class="blob-num js-line-number" data-line-number="2746"></td>
+ <td id="LC2746" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Writer</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">write</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">str</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2747" class="blob-num js-line-number" data-line-number="2747"></td>
+ <td id="LC2747" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-smi">_shouldIndent</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2748" class="blob-num js-line-number" data-line-number="2748"></td>
+ <td id="LC2748" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_shouldIndent</span> <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2749" class="blob-num js-line-number" data-line-number="2749"></td>
+ <td id="LC2749" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-c1">_content</span> <span class="pl-k">+=</span> <span class="pl-v">this</span>.<span class="pl-smi">_indent</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2750" class="blob-num js-line-number" data-line-number="2750"></td>
+ <td id="LC2750" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2751" class="blob-num js-line-number" data-line-number="2751"></td>
+ <td id="LC2751" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-c1">_content</span> <span class="pl-k">+=</span> str;</td>
+ </tr>
+ <tr>
+ <td id="L2752" class="blob-num js-line-number" data-line-number="2752"></td>
+ <td id="LC2752" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2753" class="blob-num js-line-number" data-line-number="2753"></td>
+ <td id="LC2753" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2754" class="blob-num js-line-number" data-line-number="2754"></td>
+ <td id="LC2754" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Writer</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">toString</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L2755" class="blob-num js-line-number" data-line-number="2755"></td>
+ <td id="LC2755" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-c1">_content</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2756" class="blob-num js-line-number" data-line-number="2756"></td>
+ <td id="LC2756" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2757" class="blob-num js-line-number" data-line-number="2757"></td>
+ <td id="LC2757" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2758" class="blob-num js-line-number" data-line-number="2758"></td>
+ <td id="LC2758" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2759" class="blob-num js-line-number" data-line-number="2759"></td>
+ <td id="LC2759" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">6</span>}],<span class="pl-c1">11</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2760" class="blob-num js-line-number" data-line-number="2760"></td>
+ <td id="LC2760" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L2761" class="blob-num js-line-number" data-line-number="2761"></td>
+ <td id="LC2761" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Copyright (c) 2014, Chris Pettitt</span></td>
+ </tr>
+ <tr>
+ <td id="L2762" class="blob-num js-line-number" data-line-number="2762"></td>
+ <td id="LC2762" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * All rights reserved.</span></td>
+ </tr>
+ <tr>
+ <td id="L2763" class="blob-num js-line-number" data-line-number="2763"></td>
+ <td id="LC2763" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L2764" class="blob-num js-line-number" data-line-number="2764"></td>
+ <td id="LC2764" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Redistribution and use in source and binary forms, with or without</span></td>
+ </tr>
+ <tr>
+ <td id="L2765" class="blob-num js-line-number" data-line-number="2765"></td>
+ <td id="LC2765" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * modification, are permitted provided that the following conditions are met:</span></td>
+ </tr>
+ <tr>
+ <td id="L2766" class="blob-num js-line-number" data-line-number="2766"></td>
+ <td id="LC2766" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L2767" class="blob-num js-line-number" data-line-number="2767"></td>
+ <td id="LC2767" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 1. Redistributions of source code must retain the above copyright notice, this</span></td>
+ </tr>
+ <tr>
+ <td id="L2768" class="blob-num js-line-number" data-line-number="2768"></td>
+ <td id="LC2768" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * list of conditions and the following disclaimer.</span></td>
+ </tr>
+ <tr>
+ <td id="L2769" class="blob-num js-line-number" data-line-number="2769"></td>
+ <td id="LC2769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L2770" class="blob-num js-line-number" data-line-number="2770"></td>
+ <td id="LC2770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 2. Redistributions in binary form must reproduce the above copyright notice,</span></td>
+ </tr>
+ <tr>
+ <td id="L2771" class="blob-num js-line-number" data-line-number="2771"></td>
+ <td id="LC2771" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this list of conditions and the following disclaimer in the documentation</span></td>
+ </tr>
+ <tr>
+ <td id="L2772" class="blob-num js-line-number" data-line-number="2772"></td>
+ <td id="LC2772" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and/or other materials provided with the distribution.</span></td>
+ </tr>
+ <tr>
+ <td id="L2773" class="blob-num js-line-number" data-line-number="2773"></td>
+ <td id="LC2773" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L2774" class="blob-num js-line-number" data-line-number="2774"></td>
+ <td id="LC2774" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 3. Neither the name of the copyright holder nor the names of its contributors</span></td>
+ </tr>
+ <tr>
+ <td id="L2775" class="blob-num js-line-number" data-line-number="2775"></td>
+ <td id="LC2775" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * may be used to endorse or promote products derived from this software without</span></td>
+ </tr>
+ <tr>
+ <td id="L2776" class="blob-num js-line-number" data-line-number="2776"></td>
+ <td id="LC2776" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * specific prior written permission.</span></td>
+ </tr>
+ <tr>
+ <td id="L2777" class="blob-num js-line-number" data-line-number="2777"></td>
+ <td id="LC2777" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L2778" class="blob-num js-line-number" data-line-number="2778"></td>
+ <td id="LC2778" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND</span></td>
+ </tr>
+ <tr>
+ <td id="L2779" class="blob-num js-line-number" data-line-number="2779"></td>
+ <td id="LC2779" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED</span></td>
+ </tr>
+ <tr>
+ <td id="L2780" class="blob-num js-line-number" data-line-number="2780"></td>
+ <td id="LC2780" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE</span></td>
+ </tr>
+ <tr>
+ <td id="L2781" class="blob-num js-line-number" data-line-number="2781"></td>
+ <td id="LC2781" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE</span></td>
+ </tr>
+ <tr>
+ <td id="L2782" class="blob-num js-line-number" data-line-number="2782"></td>
+ <td id="LC2782" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL</span></td>
+ </tr>
+ <tr>
+ <td id="L2783" class="blob-num js-line-number" data-line-number="2783"></td>
+ <td id="LC2783" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR</span></td>
+ </tr>
+ <tr>
+ <td id="L2784" class="blob-num js-line-number" data-line-number="2784"></td>
+ <td id="LC2784" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER</span></td>
+ </tr>
+ <tr>
+ <td id="L2785" class="blob-num js-line-number" data-line-number="2785"></td>
+ <td id="LC2785" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,</span></td>
+ </tr>
+ <tr>
+ <td id="L2786" class="blob-num js-line-number" data-line-number="2786"></td>
+ <td id="LC2786" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE</span></td>
+ </tr>
+ <tr>
+ <td id="L2787" class="blob-num js-line-number" data-line-number="2787"></td>
+ <td id="LC2787" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</span></td>
+ </tr>
+ <tr>
+ <td id="L2788" class="blob-num js-line-number" data-line-number="2788"></td>
+ <td id="LC2788" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L2789" class="blob-num js-line-number" data-line-number="2789"></td>
+ <td id="LC2789" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2790" class="blob-num js-line-number" data-line-number="2790"></td>
+ <td id="LC2790" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> lib <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2791" class="blob-num js-line-number" data-line-number="2791"></td>
+ <td id="LC2791" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2792" class="blob-num js-line-number" data-line-number="2792"></td>
+ <td id="LC2792" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L2793" class="blob-num js-line-number" data-line-number="2793"></td>
+ <td id="LC2793" class="blob-code blob-code-inner js-file-line"> Graph<span class="pl-k">:</span> <span class="pl-smi">lib</span>.<span class="pl-smi">Graph</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2794" class="blob-num js-line-number" data-line-number="2794"></td>
+ <td id="LC2794" class="blob-code blob-code-inner js-file-line"> json<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/json<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2795" class="blob-num js-line-number" data-line-number="2795"></td>
+ <td id="LC2795" class="blob-code blob-code-inner js-file-line"> alg<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lib/alg<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2796" class="blob-num js-line-number" data-line-number="2796"></td>
+ <td id="LC2796" class="blob-code blob-code-inner js-file-line"> version<span class="pl-k">:</span> <span class="pl-smi">lib</span>.<span class="pl-c1">version</span></td>
+ </tr>
+ <tr>
+ <td id="L2797" class="blob-num js-line-number" data-line-number="2797"></td>
+ <td id="LC2797" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L2798" class="blob-num js-line-number" data-line-number="2798"></td>
+ <td id="LC2798" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2799" class="blob-num js-line-number" data-line-number="2799"></td>
+ <td id="LC2799" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./lib<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">27</span>,<span class="pl-s"><span class="pl-pds">"</span>./lib/alg<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">18</span>,<span class="pl-s"><span class="pl-pds">"</span>./lib/json<span class="pl-pds">"</span></spa [...]
+ </tr>
+ <tr>
+ <td id="L2800" class="blob-num js-line-number" data-line-number="2800"></td>
+ <td id="LC2800" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2801" class="blob-num js-line-number" data-line-number="2801"></td>
+ <td id="LC2801" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2802" class="blob-num js-line-number" data-line-number="2802"></td>
+ <td id="LC2802" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> components;</td>
+ </tr>
+ <tr>
+ <td id="L2803" class="blob-num js-line-number" data-line-number="2803"></td>
+ <td id="LC2803" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2804" class="blob-num js-line-number" data-line-number="2804"></td>
+ <td id="LC2804" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">components</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2805" class="blob-num js-line-number" data-line-number="2805"></td>
+ <td id="LC2805" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> visited <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L2806" class="blob-num js-line-number" data-line-number="2806"></td>
+ <td id="LC2806" class="blob-code blob-code-inner js-file-line"> cmpts <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L2807" class="blob-num js-line-number" data-line-number="2807"></td>
+ <td id="LC2807" class="blob-code blob-code-inner js-file-line"> cmpt;</td>
+ </tr>
+ <tr>
+ <td id="L2808" class="blob-num js-line-number" data-line-number="2808"></td>
+ <td id="LC2808" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2809" class="blob-num js-line-number" data-line-number="2809"></td>
+ <td id="LC2809" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">dfs</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2810" class="blob-num js-line-number" data-line-number="2810"></td>
+ <td id="LC2810" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(visited, v)) <span class="pl-k">return</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2811" class="blob-num js-line-number" data-line-number="2811"></td>
+ <td id="LC2811" class="blob-code blob-code-inner js-file-line"> visited[v] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2812" class="blob-num js-line-number" data-line-number="2812"></td>
+ <td id="LC2812" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">cmpt</span>.<span class="pl-c1">push</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L2813" class="blob-num js-line-number" data-line-number="2813"></td>
+ <td id="LC2813" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">successors</span>(v), dfs);</td>
+ </tr>
+ <tr>
+ <td id="L2814" class="blob-num js-line-number" data-line-number="2814"></td>
+ <td id="LC2814" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">predecessors</span>(v), dfs);</td>
+ </tr>
+ <tr>
+ <td id="L2815" class="blob-num js-line-number" data-line-number="2815"></td>
+ <td id="LC2815" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2816" class="blob-num js-line-number" data-line-number="2816"></td>
+ <td id="LC2816" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2817" class="blob-num js-line-number" data-line-number="2817"></td>
+ <td id="LC2817" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">nodes</span>(), <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2818" class="blob-num js-line-number" data-line-number="2818"></td>
+ <td id="LC2818" class="blob-code blob-code-inner js-file-line"> cmpt <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L2819" class="blob-num js-line-number" data-line-number="2819"></td>
+ <td id="LC2819" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">dfs</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L2820" class="blob-num js-line-number" data-line-number="2820"></td>
+ <td id="LC2820" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">cmpt</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2821" class="blob-num js-line-number" data-line-number="2821"></td>
+ <td id="LC2821" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">cmpts</span>.<span class="pl-c1">push</span>(cmpt);</td>
+ </tr>
+ <tr>
+ <td id="L2822" class="blob-num js-line-number" data-line-number="2822"></td>
+ <td id="LC2822" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2823" class="blob-num js-line-number" data-line-number="2823"></td>
+ <td id="LC2823" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2824" class="blob-num js-line-number" data-line-number="2824"></td>
+ <td id="LC2824" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2825" class="blob-num js-line-number" data-line-number="2825"></td>
+ <td id="LC2825" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> cmpts;</td>
+ </tr>
+ <tr>
+ <td id="L2826" class="blob-num js-line-number" data-line-number="2826"></td>
+ <td id="LC2826" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2827" class="blob-num js-line-number" data-line-number="2827"></td>
+ <td id="LC2827" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2828" class="blob-num js-line-number" data-line-number="2828"></td>
+ <td id="LC2828" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">13</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2829" class="blob-num js-line-number" data-line-number="2829"></td>
+ <td id="LC2829" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2830" class="blob-num js-line-number" data-line-number="2830"></td>
+ <td id="LC2830" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2831" class="blob-num js-line-number" data-line-number="2831"></td>
+ <td id="LC2831" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> dfs;</td>
+ </tr>
+ <tr>
+ <td id="L2832" class="blob-num js-line-number" data-line-number="2832"></td>
+ <td id="LC2832" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2833" class="blob-num js-line-number" data-line-number="2833"></td>
+ <td id="LC2833" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/*</span></td>
+ </tr>
+ <tr>
+ <td id="L2834" class="blob-num js-line-number" data-line-number="2834"></td>
+ <td id="LC2834" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A helper that preforms a pre- or post-order traversal on the input graph</span></td>
+ </tr>
+ <tr>
+ <td id="L2835" class="blob-num js-line-number" data-line-number="2835"></td>
+ <td id="LC2835" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and returns the nodes in the order they were visited. This algorithm treats</span></td>
+ </tr>
+ <tr>
+ <td id="L2836" class="blob-num js-line-number" data-line-number="2836"></td>
+ <td id="LC2836" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the input as undirected.</span></td>
+ </tr>
+ <tr>
+ <td id="L2837" class="blob-num js-line-number" data-line-number="2837"></td>
+ <td id="LC2837" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L2838" class="blob-num js-line-number" data-line-number="2838"></td>
+ <td id="LC2838" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Order must be one of "pre" or "post".</span></td>
+ </tr>
+ <tr>
+ <td id="L2839" class="blob-num js-line-number" data-line-number="2839"></td>
+ <td id="LC2839" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L2840" class="blob-num js-line-number" data-line-number="2840"></td>
+ <td id="LC2840" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">dfs</span>(<span class="pl-smi">g</span>, <span class="pl-smi">vs</span>, <span class="pl-smi">order</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2841" class="blob-num js-line-number" data-line-number="2841"></td>
+ <td id="LC2841" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isArray</span>(vs)) {</td>
+ </tr>
+ <tr>
+ <td id="L2842" class="blob-num js-line-number" data-line-number="2842"></td>
+ <td id="LC2842" class="blob-code blob-code-inner js-file-line"> vs <span class="pl-k">=</span> [vs];</td>
+ </tr>
+ <tr>
+ <td id="L2843" class="blob-num js-line-number" data-line-number="2843"></td>
+ <td id="LC2843" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2844" class="blob-num js-line-number" data-line-number="2844"></td>
+ <td id="LC2844" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2845" class="blob-num js-line-number" data-line-number="2845"></td>
+ <td id="LC2845" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> acc <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L2846" class="blob-num js-line-number" data-line-number="2846"></td>
+ <td id="LC2846" class="blob-code blob-code-inner js-file-line"> visited <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L2847" class="blob-num js-line-number" data-line-number="2847"></td>
+ <td id="LC2847" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(vs, <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2848" class="blob-num js-line-number" data-line-number="2848"></td>
+ <td id="LC2848" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">g</span>.<span class="pl-en">hasNode</span>(v)) {</td>
+ </tr>
+ <tr>
+ <td id="L2849" class="blob-num js-line-number" data-line-number="2849"></td>
+ <td id="LC2849" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Graph does not have node: <span class="pl-pds">"</span></span> <span class="pl-k">+</span> v);</td>
+ </tr>
+ <tr>
+ <td id="L2850" class="blob-num js-line-number" data-line-number="2850"></td>
+ <td id="LC2850" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2851" class="blob-num js-line-number" data-line-number="2851"></td>
+ <td id="LC2851" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2852" class="blob-num js-line-number" data-line-number="2852"></td>
+ <td id="LC2852" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">doDfs</span>(g, v, order <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span>post<span class="pl-pds">"</span></span>, visited, acc);</td>
+ </tr>
+ <tr>
+ <td id="L2853" class="blob-num js-line-number" data-line-number="2853"></td>
+ <td id="LC2853" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2854" class="blob-num js-line-number" data-line-number="2854"></td>
+ <td id="LC2854" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> acc;</td>
+ </tr>
+ <tr>
+ <td id="L2855" class="blob-num js-line-number" data-line-number="2855"></td>
+ <td id="LC2855" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2856" class="blob-num js-line-number" data-line-number="2856"></td>
+ <td id="LC2856" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2857" class="blob-num js-line-number" data-line-number="2857"></td>
+ <td id="LC2857" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">doDfs</span>(<span class="pl-smi">g</span>, <span class="pl-smi">v</span>, <span class="pl-smi">postorder</span>, <span class="pl-smi">visited</span>, <span class="pl-smi">acc</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2858" class="blob-num js-line-number" data-line-number="2858"></td>
+ <td id="LC2858" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">has</span>(visited, v)) {</td>
+ </tr>
+ <tr>
+ <td id="L2859" class="blob-num js-line-number" data-line-number="2859"></td>
+ <td id="LC2859" class="blob-code blob-code-inner js-file-line"> visited[v] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2860" class="blob-num js-line-number" data-line-number="2860"></td>
+ <td id="LC2860" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2861" class="blob-num js-line-number" data-line-number="2861"></td>
+ <td id="LC2861" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>postorder) { <span class="pl-smi">acc</span>.<span class="pl-c1">push</span>(v); }</td>
+ </tr>
+ <tr>
+ <td id="L2862" class="blob-num js-line-number" data-line-number="2862"></td>
+ <td id="LC2862" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">neighbors</span>(v), <span class="pl-k">function</span>(<span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2863" class="blob-num js-line-number" data-line-number="2863"></td>
+ <td id="LC2863" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">doDfs</span>(g, w, postorder, visited, acc);</td>
+ </tr>
+ <tr>
+ <td id="L2864" class="blob-num js-line-number" data-line-number="2864"></td>
+ <td id="LC2864" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2865" class="blob-num js-line-number" data-line-number="2865"></td>
+ <td id="LC2865" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (postorder) { <span class="pl-smi">acc</span>.<span class="pl-c1">push</span>(v); }</td>
+ </tr>
+ <tr>
+ <td id="L2866" class="blob-num js-line-number" data-line-number="2866"></td>
+ <td id="LC2866" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2867" class="blob-num js-line-number" data-line-number="2867"></td>
+ <td id="LC2867" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2868" class="blob-num js-line-number" data-line-number="2868"></td>
+ <td id="LC2868" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2869" class="blob-num js-line-number" data-line-number="2869"></td>
+ <td id="LC2869" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">14</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L2870" class="blob-num js-line-number" data-line-number="2870"></td>
+ <td id="LC2870" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> dijkstra <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dijkstra<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2871" class="blob-num js-line-number" data-line-number="2871"></td>
+ <td id="LC2871" class="blob-code blob-code-inner js-file-line"> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2872" class="blob-num js-line-number" data-line-number="2872"></td>
+ <td id="LC2872" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2873" class="blob-num js-line-number" data-line-number="2873"></td>
+ <td id="LC2873" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> dijkstraAll;</td>
+ </tr>
+ <tr>
+ <td id="L2874" class="blob-num js-line-number" data-line-number="2874"></td>
+ <td id="LC2874" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2875" class="blob-num js-line-number" data-line-number="2875"></td>
+ <td id="LC2875" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">dijkstraAll</span>(<span class="pl-smi">g</span>, <span class="pl-smi">weightFunc</span>, <span class="pl-smi">edgeFunc</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2876" class="blob-num js-line-number" data-line-number="2876"></td>
+ <td id="LC2876" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">transform</span>(<span class="pl-smi">g</span>.<span class="pl-en">nodes</span>(), <span class="pl-k">function</span>(<span class="pl-smi">acc</span>, <span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2877" class="blob-num js-line-number" data-line-number="2877"></td>
+ <td id="LC2877" class="blob-code blob-code-inner js-file-line"> acc[v] <span class="pl-k">=</span> <span class="pl-en">dijkstra</span>(g, v, weightFunc, edgeFunc);</td>
+ </tr>
+ <tr>
+ <td id="L2878" class="blob-num js-line-number" data-line-number="2878"></td>
+ <td id="LC2878" class="blob-code blob-code-inner js-file-line"> }, {});</td>
+ </tr>
+ <tr>
+ <td id="L2879" class="blob-num js-line-number" data-line-number="2879"></td>
+ <td id="LC2879" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2880" class="blob-num js-line-number" data-line-number="2880"></td>
+ <td id="LC2880" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2881" class="blob-num js-line-number" data-line-number="2881"></td>
+ <td id="LC2881" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>,<span class="pl-s"><span class="pl-pds">"</span>./dijkstra<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">15</span>}],<span class="pl-c1">15</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<sp [...]
+ </tr>
+ <tr>
+ <td id="L2882" class="blob-num js-line-number" data-line-number="2882"></td>
+ <td id="LC2882" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2883" class="blob-num js-line-number" data-line-number="2883"></td>
+ <td id="LC2883" class="blob-code blob-code-inner js-file-line"> PriorityQueue <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../data/priority-queue<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2884" class="blob-num js-line-number" data-line-number="2884"></td>
+ <td id="LC2884" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2885" class="blob-num js-line-number" data-line-number="2885"></td>
+ <td id="LC2885" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> dijkstra;</td>
+ </tr>
+ <tr>
+ <td id="L2886" class="blob-num js-line-number" data-line-number="2886"></td>
+ <td id="LC2886" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2887" class="blob-num js-line-number" data-line-number="2887"></td>
+ <td id="LC2887" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> <span class="pl-c1">DEFAULT_WEIGHT_FUNC</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">constant</span>(<span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2888" class="blob-num js-line-number" data-line-number="2888"></td>
+ <td id="LC2888" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2889" class="blob-num js-line-number" data-line-number="2889"></td>
+ <td id="LC2889" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">dijkstra</span>(<span class="pl-smi">g</span>, <span class="pl-smi">source</span>, <span class="pl-smi">weightFn</span>, <span class="pl-smi">edgeFn</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2890" class="blob-num js-line-number" data-line-number="2890"></td>
+ <td id="LC2890" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">runDijkstra</span>(g, <span class="pl-c1">String</span>(source),</td>
+ </tr>
+ <tr>
+ <td id="L2891" class="blob-num js-line-number" data-line-number="2891"></td>
+ <td id="LC2891" class="blob-code blob-code-inner js-file-line"> weightFn <span class="pl-k">||</span> <span class="pl-c1">DEFAULT_WEIGHT_FUNC</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2892" class="blob-num js-line-number" data-line-number="2892"></td>
+ <td id="LC2892" class="blob-code blob-code-inner js-file-line"> edgeFn <span class="pl-k">||</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) { <span class="pl-k">return</span> <span class="pl-smi">g</span>.<span class="pl-en">outEdges</span>(v); });</td>
+ </tr>
+ <tr>
+ <td id="L2893" class="blob-num js-line-number" data-line-number="2893"></td>
+ <td id="LC2893" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2894" class="blob-num js-line-number" data-line-number="2894"></td>
+ <td id="LC2894" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2895" class="blob-num js-line-number" data-line-number="2895"></td>
+ <td id="LC2895" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">runDijkstra</span>(<span class="pl-smi">g</span>, <span class="pl-smi">source</span>, <span class="pl-smi">weightFn</span>, <span class="pl-smi">edgeFn</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2896" class="blob-num js-line-number" data-line-number="2896"></td>
+ <td id="LC2896" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> results <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L2897" class="blob-num js-line-number" data-line-number="2897"></td>
+ <td id="LC2897" class="blob-code blob-code-inner js-file-line"> pq <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">PriorityQueue</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L2898" class="blob-num js-line-number" data-line-number="2898"></td>
+ <td id="LC2898" class="blob-code blob-code-inner js-file-line"> v, vEntry;</td>
+ </tr>
+ <tr>
+ <td id="L2899" class="blob-num js-line-number" data-line-number="2899"></td>
+ <td id="LC2899" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2900" class="blob-num js-line-number" data-line-number="2900"></td>
+ <td id="LC2900" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">updateNeighbors</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">edge</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2901" class="blob-num js-line-number" data-line-number="2901"></td>
+ <td id="LC2901" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> w <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span> <span class="pl-k">!==</span> v <span class="pl-k">?</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span> <span class="pl-k">:</span> <span class="pl-smi">edge</span>.<span class="pl-smi">w</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2902" class="blob-num js-line-number" data-line-number="2902"></td>
+ <td id="LC2902" class="blob-code blob-code-inner js-file-line"> wEntry <span class="pl-k">=</span> results[w],</td>
+ </tr>
+ <tr>
+ <td id="L2903" class="blob-num js-line-number" data-line-number="2903"></td>
+ <td id="LC2903" class="blob-code blob-code-inner js-file-line"> weight <span class="pl-k">=</span> <span class="pl-en">weightFn</span>(edge),</td>
+ </tr>
+ <tr>
+ <td id="L2904" class="blob-num js-line-number" data-line-number="2904"></td>
+ <td id="LC2904" class="blob-code blob-code-inner js-file-line"> distance <span class="pl-k">=</span> <span class="pl-smi">vEntry</span>.<span class="pl-smi">distance</span> <span class="pl-k">+</span> weight;</td>
+ </tr>
+ <tr>
+ <td id="L2905" class="blob-num js-line-number" data-line-number="2905"></td>
+ <td id="LC2905" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2906" class="blob-num js-line-number" data-line-number="2906"></td>
+ <td id="LC2906" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (weight <span class="pl-k"><</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2907" class="blob-num js-line-number" data-line-number="2907"></td>
+ <td id="LC2907" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>dijkstra does not allow negative edge weights. <span class="pl-pds">"</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L2908" class="blob-num js-line-number" data-line-number="2908"></td>
+ <td id="LC2908" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span>Bad edge: <span class="pl-pds">"</span></span> <span class="pl-k">+</span> edge <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> Weight: <span class="pl-pds">"</span></span> <span class="pl-k">+</span> weight);</td>
+ </tr>
+ <tr>
+ <td id="L2909" class="blob-num js-line-number" data-line-number="2909"></td>
+ <td id="LC2909" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2910" class="blob-num js-line-number" data-line-number="2910"></td>
+ <td id="LC2910" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2911" class="blob-num js-line-number" data-line-number="2911"></td>
+ <td id="LC2911" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (distance <span class="pl-k"><</span> <span class="pl-smi">wEntry</span>.<span class="pl-smi">distance</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2912" class="blob-num js-line-number" data-line-number="2912"></td>
+ <td id="LC2912" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">wEntry</span>.<span class="pl-smi">distance</span> <span class="pl-k">=</span> distance;</td>
+ </tr>
+ <tr>
+ <td id="L2913" class="blob-num js-line-number" data-line-number="2913"></td>
+ <td id="LC2913" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">wEntry</span>.<span class="pl-smi">predecessor</span> <span class="pl-k">=</span> v;</td>
+ </tr>
+ <tr>
+ <td id="L2914" class="blob-num js-line-number" data-line-number="2914"></td>
+ <td id="LC2914" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">pq</span>.<span class="pl-en">decrease</span>(w, distance);</td>
+ </tr>
+ <tr>
+ <td id="L2915" class="blob-num js-line-number" data-line-number="2915"></td>
+ <td id="LC2915" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2916" class="blob-num js-line-number" data-line-number="2916"></td>
+ <td id="LC2916" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L2917" class="blob-num js-line-number" data-line-number="2917"></td>
+ <td id="LC2917" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2918" class="blob-num js-line-number" data-line-number="2918"></td>
+ <td id="LC2918" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">nodes</span>().<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2919" class="blob-num js-line-number" data-line-number="2919"></td>
+ <td id="LC2919" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> distance <span class="pl-k">=</span> v <span class="pl-k">===</span> source <span class="pl-k">?</span> <span class="pl-c1">0</span> <span class="pl-k">:</span> <span class="pl-c1">Number</span>.<span class="pl-c1">POSITIVE_INFINITY</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2920" class="blob-num js-line-number" data-line-number="2920"></td>
+ <td id="LC2920" class="blob-code blob-code-inner js-file-line"> results[v] <span class="pl-k">=</span> { distance<span class="pl-k">:</span> distance };</td>
+ </tr>
+ <tr>
+ <td id="L2921" class="blob-num js-line-number" data-line-number="2921"></td>
+ <td id="LC2921" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">pq</span>.<span class="pl-c1">add</span>(v, distance);</td>
+ </tr>
+ <tr>
+ <td id="L2922" class="blob-num js-line-number" data-line-number="2922"></td>
+ <td id="LC2922" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2923" class="blob-num js-line-number" data-line-number="2923"></td>
+ <td id="LC2923" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2924" class="blob-num js-line-number" data-line-number="2924"></td>
+ <td id="LC2924" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-smi">pq</span>.<span class="pl-c1">size</span>() <span class="pl-k">></span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2925" class="blob-num js-line-number" data-line-number="2925"></td>
+ <td id="LC2925" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-smi">pq</span>.<span class="pl-en">removeMin</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2926" class="blob-num js-line-number" data-line-number="2926"></td>
+ <td id="LC2926" class="blob-code blob-code-inner js-file-line"> vEntry <span class="pl-k">=</span> results[v];</td>
+ </tr>
+ <tr>
+ <td id="L2927" class="blob-num js-line-number" data-line-number="2927"></td>
+ <td id="LC2927" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">vEntry</span>.<span class="pl-smi">distance</span> <span class="pl-k">===</span> <span class="pl-c1">Number</span>.<span class="pl-c1">POSITIVE_INFINITY</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2928" class="blob-num js-line-number" data-line-number="2928"></td>
+ <td id="LC2928" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2929" class="blob-num js-line-number" data-line-number="2929"></td>
+ <td id="LC2929" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2930" class="blob-num js-line-number" data-line-number="2930"></td>
+ <td id="LC2930" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2931" class="blob-num js-line-number" data-line-number="2931"></td>
+ <td id="LC2931" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">edgeFn</span>(v).<span class="pl-en">forEach</span>(updateNeighbors);</td>
+ </tr>
+ <tr>
+ <td id="L2932" class="blob-num js-line-number" data-line-number="2932"></td>
+ <td id="LC2932" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2933" class="blob-num js-line-number" data-line-number="2933"></td>
+ <td id="LC2933" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2934" class="blob-num js-line-number" data-line-number="2934"></td>
+ <td id="LC2934" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> results;</td>
+ </tr>
+ <tr>
+ <td id="L2935" class="blob-num js-line-number" data-line-number="2935"></td>
+ <td id="LC2935" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2936" class="blob-num js-line-number" data-line-number="2936"></td>
+ <td id="LC2936" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2937" class="blob-num js-line-number" data-line-number="2937"></td>
+ <td id="LC2937" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../data/priority-queue<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">25</span>,<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">16</span><span class="pl-k">:</span>[<span class="pl-k">functio [...]
+ </tr>
+ <tr>
+ <td id="L2938" class="blob-num js-line-number" data-line-number="2938"></td>
+ <td id="LC2938" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L2939" class="blob-num js-line-number" data-line-number="2939"></td>
+ <td id="LC2939" class="blob-code blob-code-inner js-file-line"> tarjan <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./tarjan<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2940" class="blob-num js-line-number" data-line-number="2940"></td>
+ <td id="LC2940" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2941" class="blob-num js-line-number" data-line-number="2941"></td>
+ <td id="LC2941" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> findCycles;</td>
+ </tr>
+ <tr>
+ <td id="L2942" class="blob-num js-line-number" data-line-number="2942"></td>
+ <td id="LC2942" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2943" class="blob-num js-line-number" data-line-number="2943"></td>
+ <td id="LC2943" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">findCycles</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2944" class="blob-num js-line-number" data-line-number="2944"></td>
+ <td id="LC2944" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">filter</span>(<span class="pl-en">tarjan</span>(g), <span class="pl-k">function</span>(<span class="pl-smi">cmpt</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2945" class="blob-num js-line-number" data-line-number="2945"></td>
+ <td id="LC2945" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">cmpt</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span> <span class="pl-k">||</span> (<span class="pl-smi">cmpt</span>.<span class="pl-c1">length</span> <span class="pl-k">===</span> <span class="pl-c1">1</span> <span class="pl-k">&&</span> <span class="pl-smi">g</span>.<span class="pl-en">hasEdge</span> [...]
+ </tr>
+ <tr>
+ <td id="L2946" class="blob-num js-line-number" data-line-number="2946"></td>
+ <td id="LC2946" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2947" class="blob-num js-line-number" data-line-number="2947"></td>
+ <td id="LC2947" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2948" class="blob-num js-line-number" data-line-number="2948"></td>
+ <td id="LC2948" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2949" class="blob-num js-line-number" data-line-number="2949"></td>
+ <td id="LC2949" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>,<span class="pl-s"><span class="pl-pds">"</span>./tarjan<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">23</span>}],<span class="pl-c1">17</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span [...]
+ </tr>
+ <tr>
+ <td id="L2950" class="blob-num js-line-number" data-line-number="2950"></td>
+ <td id="LC2950" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L2951" class="blob-num js-line-number" data-line-number="2951"></td>
+ <td id="LC2951" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2952" class="blob-num js-line-number" data-line-number="2952"></td>
+ <td id="LC2952" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> floydWarshall;</td>
+ </tr>
+ <tr>
+ <td id="L2953" class="blob-num js-line-number" data-line-number="2953"></td>
+ <td id="LC2953" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2954" class="blob-num js-line-number" data-line-number="2954"></td>
+ <td id="LC2954" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> <span class="pl-c1">DEFAULT_WEIGHT_FUNC</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">constant</span>(<span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L2955" class="blob-num js-line-number" data-line-number="2955"></td>
+ <td id="LC2955" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2956" class="blob-num js-line-number" data-line-number="2956"></td>
+ <td id="LC2956" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">floydWarshall</span>(<span class="pl-smi">g</span>, <span class="pl-smi">weightFn</span>, <span class="pl-smi">edgeFn</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2957" class="blob-num js-line-number" data-line-number="2957"></td>
+ <td id="LC2957" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">runFloydWarshall</span>(g,</td>
+ </tr>
+ <tr>
+ <td id="L2958" class="blob-num js-line-number" data-line-number="2958"></td>
+ <td id="LC2958" class="blob-code blob-code-inner js-file-line"> weightFn <span class="pl-k">||</span> <span class="pl-c1">DEFAULT_WEIGHT_FUNC</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2959" class="blob-num js-line-number" data-line-number="2959"></td>
+ <td id="LC2959" class="blob-code blob-code-inner js-file-line"> edgeFn <span class="pl-k">||</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) { <span class="pl-k">return</span> <span class="pl-smi">g</span>.<span class="pl-en">outEdges</span>(v); });</td>
+ </tr>
+ <tr>
+ <td id="L2960" class="blob-num js-line-number" data-line-number="2960"></td>
+ <td id="LC2960" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L2961" class="blob-num js-line-number" data-line-number="2961"></td>
+ <td id="LC2961" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2962" class="blob-num js-line-number" data-line-number="2962"></td>
+ <td id="LC2962" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">runFloydWarshall</span>(<span class="pl-smi">g</span>, <span class="pl-smi">weightFn</span>, <span class="pl-smi">edgeFn</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2963" class="blob-num js-line-number" data-line-number="2963"></td>
+ <td id="LC2963" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> results <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L2964" class="blob-num js-line-number" data-line-number="2964"></td>
+ <td id="LC2964" class="blob-code blob-code-inner js-file-line"> nodes <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">nodes</span>();</td>
+ </tr>
+ <tr>
+ <td id="L2965" class="blob-num js-line-number" data-line-number="2965"></td>
+ <td id="LC2965" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2966" class="blob-num js-line-number" data-line-number="2966"></td>
+ <td id="LC2966" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">nodes</span>.<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2967" class="blob-num js-line-number" data-line-number="2967"></td>
+ <td id="LC2967" class="blob-code blob-code-inner js-file-line"> results[v] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L2968" class="blob-num js-line-number" data-line-number="2968"></td>
+ <td id="LC2968" class="blob-code blob-code-inner js-file-line"> results[v][v] <span class="pl-k">=</span> { distance<span class="pl-k">:</span> <span class="pl-c1">0</span> };</td>
+ </tr>
+ <tr>
+ <td id="L2969" class="blob-num js-line-number" data-line-number="2969"></td>
+ <td id="LC2969" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">nodes</span>.<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2970" class="blob-num js-line-number" data-line-number="2970"></td>
+ <td id="LC2970" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (v <span class="pl-k">!==</span> w) {</td>
+ </tr>
+ <tr>
+ <td id="L2971" class="blob-num js-line-number" data-line-number="2971"></td>
+ <td id="LC2971" class="blob-code blob-code-inner js-file-line"> results[v][w] <span class="pl-k">=</span> { distance<span class="pl-k">:</span> <span class="pl-c1">Number</span>.<span class="pl-c1">POSITIVE_INFINITY</span> };</td>
+ </tr>
+ <tr>
+ <td id="L2972" class="blob-num js-line-number" data-line-number="2972"></td>
+ <td id="LC2972" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2973" class="blob-num js-line-number" data-line-number="2973"></td>
+ <td id="LC2973" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2974" class="blob-num js-line-number" data-line-number="2974"></td>
+ <td id="LC2974" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">edgeFn</span>(v).<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">edge</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2975" class="blob-num js-line-number" data-line-number="2975"></td>
+ <td id="LC2975" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> w <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span> <span class="pl-k">===</span> v <span class="pl-k">?</span> <span class="pl-smi">edge</span>.<span class="pl-smi">w</span> <span class="pl-k">:</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span>,</td>
+ </tr>
+ <tr>
+ <td id="L2976" class="blob-num js-line-number" data-line-number="2976"></td>
+ <td id="LC2976" class="blob-code blob-code-inner js-file-line"> d <span class="pl-k">=</span> <span class="pl-en">weightFn</span>(edge);</td>
+ </tr>
+ <tr>
+ <td id="L2977" class="blob-num js-line-number" data-line-number="2977"></td>
+ <td id="LC2977" class="blob-code blob-code-inner js-file-line"> results[v][w] <span class="pl-k">=</span> { distance<span class="pl-k">:</span> d, predecessor<span class="pl-k">:</span> v };</td>
+ </tr>
+ <tr>
+ <td id="L2978" class="blob-num js-line-number" data-line-number="2978"></td>
+ <td id="LC2978" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2979" class="blob-num js-line-number" data-line-number="2979"></td>
+ <td id="LC2979" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2980" class="blob-num js-line-number" data-line-number="2980"></td>
+ <td id="LC2980" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2981" class="blob-num js-line-number" data-line-number="2981"></td>
+ <td id="LC2981" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">nodes</span>.<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">k</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2982" class="blob-num js-line-number" data-line-number="2982"></td>
+ <td id="LC2982" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> rowK <span class="pl-k">=</span> results[k];</td>
+ </tr>
+ <tr>
+ <td id="L2983" class="blob-num js-line-number" data-line-number="2983"></td>
+ <td id="LC2983" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">nodes</span>.<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">i</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2984" class="blob-num js-line-number" data-line-number="2984"></td>
+ <td id="LC2984" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> rowI <span class="pl-k">=</span> results[i];</td>
+ </tr>
+ <tr>
+ <td id="L2985" class="blob-num js-line-number" data-line-number="2985"></td>
+ <td id="LC2985" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">nodes</span>.<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">j</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2986" class="blob-num js-line-number" data-line-number="2986"></td>
+ <td id="LC2986" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ik <span class="pl-k">=</span> rowI[k];</td>
+ </tr>
+ <tr>
+ <td id="L2987" class="blob-num js-line-number" data-line-number="2987"></td>
+ <td id="LC2987" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> kj <span class="pl-k">=</span> rowK[j];</td>
+ </tr>
+ <tr>
+ <td id="L2988" class="blob-num js-line-number" data-line-number="2988"></td>
+ <td id="LC2988" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ij <span class="pl-k">=</span> rowI[j];</td>
+ </tr>
+ <tr>
+ <td id="L2989" class="blob-num js-line-number" data-line-number="2989"></td>
+ <td id="LC2989" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> altDistance <span class="pl-k">=</span> <span class="pl-smi">ik</span>.<span class="pl-smi">distance</span> <span class="pl-k">+</span> <span class="pl-smi">kj</span>.<span class="pl-smi">distance</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2990" class="blob-num js-line-number" data-line-number="2990"></td>
+ <td id="LC2990" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (altDistance <span class="pl-k"><</span> <span class="pl-smi">ij</span>.<span class="pl-smi">distance</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L2991" class="blob-num js-line-number" data-line-number="2991"></td>
+ <td id="LC2991" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">ij</span>.<span class="pl-smi">distance</span> <span class="pl-k">=</span> altDistance;</td>
+ </tr>
+ <tr>
+ <td id="L2992" class="blob-num js-line-number" data-line-number="2992"></td>
+ <td id="LC2992" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">ij</span>.<span class="pl-smi">predecessor</span> <span class="pl-k">=</span> <span class="pl-smi">kj</span>.<span class="pl-smi">predecessor</span>;</td>
+ </tr>
+ <tr>
+ <td id="L2993" class="blob-num js-line-number" data-line-number="2993"></td>
+ <td id="LC2993" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L2994" class="blob-num js-line-number" data-line-number="2994"></td>
+ <td id="LC2994" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2995" class="blob-num js-line-number" data-line-number="2995"></td>
+ <td id="LC2995" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2996" class="blob-num js-line-number" data-line-number="2996"></td>
+ <td id="LC2996" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L2997" class="blob-num js-line-number" data-line-number="2997"></td>
+ <td id="LC2997" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L2998" class="blob-num js-line-number" data-line-number="2998"></td>
+ <td id="LC2998" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> results;</td>
+ </tr>
+ <tr>
+ <td id="L2999" class="blob-num js-line-number" data-line-number="2999"></td>
+ <td id="LC2999" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3000" class="blob-num js-line-number" data-line-number="3000"></td>
+ <td id="LC3000" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3001" class="blob-num js-line-number" data-line-number="3001"></td>
+ <td id="LC3001" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">18</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3002" class="blob-num js-line-number" data-line-number="3002"></td>
+ <td id="LC3002" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3003" class="blob-num js-line-number" data-line-number="3003"></td>
+ <td id="LC3003" class="blob-code blob-code-inner js-file-line"> components<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./components<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3004" class="blob-num js-line-number" data-line-number="3004"></td>
+ <td id="LC3004" class="blob-code blob-code-inner js-file-line"> dijkstra<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dijkstra<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3005" class="blob-num js-line-number" data-line-number="3005"></td>
+ <td id="LC3005" class="blob-code blob-code-inner js-file-line"> dijkstraAll<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dijkstra-all<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3006" class="blob-num js-line-number" data-line-number="3006"></td>
+ <td id="LC3006" class="blob-code blob-code-inner js-file-line"> findCycles<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./find-cycles<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3007" class="blob-num js-line-number" data-line-number="3007"></td>
+ <td id="LC3007" class="blob-code blob-code-inner js-file-line"> floydWarshall<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./floyd-warshall<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3008" class="blob-num js-line-number" data-line-number="3008"></td>
+ <td id="LC3008" class="blob-code blob-code-inner js-file-line"> isAcyclic<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./is-acyclic<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3009" class="blob-num js-line-number" data-line-number="3009"></td>
+ <td id="LC3009" class="blob-code blob-code-inner js-file-line"> postorder<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./postorder<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3010" class="blob-num js-line-number" data-line-number="3010"></td>
+ <td id="LC3010" class="blob-code blob-code-inner js-file-line"> preorder<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./preorder<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3011" class="blob-num js-line-number" data-line-number="3011"></td>
+ <td id="LC3011" class="blob-code blob-code-inner js-file-line"> prim<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./prim<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3012" class="blob-num js-line-number" data-line-number="3012"></td>
+ <td id="LC3012" class="blob-code blob-code-inner js-file-line"> tarjan<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./tarjan<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3013" class="blob-num js-line-number" data-line-number="3013"></td>
+ <td id="LC3013" class="blob-code blob-code-inner js-file-line"> topsort<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./topsort<span class="pl-pds">"</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L3014" class="blob-num js-line-number" data-line-number="3014"></td>
+ <td id="LC3014" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3015" class="blob-num js-line-number" data-line-number="3015"></td>
+ <td id="LC3015" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3016" class="blob-num js-line-number" data-line-number="3016"></td>
+ <td id="LC3016" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./components<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">12</span>,<span class="pl-s"><span class="pl-pds">"</span>./dijkstra<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">15</span>,<span class="pl-s"><span class="pl-pds">"</span>./dijkstra-all<span class="pl-pds">" [...]
+ </tr>
+ <tr>
+ <td id="L3017" class="blob-num js-line-number" data-line-number="3017"></td>
+ <td id="LC3017" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> topsort <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./topsort<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3018" class="blob-num js-line-number" data-line-number="3018"></td>
+ <td id="LC3018" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3019" class="blob-num js-line-number" data-line-number="3019"></td>
+ <td id="LC3019" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> isAcyclic;</td>
+ </tr>
+ <tr>
+ <td id="L3020" class="blob-num js-line-number" data-line-number="3020"></td>
+ <td id="LC3020" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3021" class="blob-num js-line-number" data-line-number="3021"></td>
+ <td id="LC3021" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">isAcyclic</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3022" class="blob-num js-line-number" data-line-number="3022"></td>
+ <td id="LC3022" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3023" class="blob-num js-line-number" data-line-number="3023"></td>
+ <td id="LC3023" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">topsort</span>(g);</td>
+ </tr>
+ <tr>
+ <td id="L3024" class="blob-num js-line-number" data-line-number="3024"></td>
+ <td id="LC3024" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">catch</span> (e) {</td>
+ </tr>
+ <tr>
+ <td id="L3025" class="blob-num js-line-number" data-line-number="3025"></td>
+ <td id="LC3025" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (e <span class="pl-k">instanceof</span> <span class="pl-smi">topsort</span>.<span class="pl-smi">CycleException</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3026" class="blob-num js-line-number" data-line-number="3026"></td>
+ <td id="LC3026" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3027" class="blob-num js-line-number" data-line-number="3027"></td>
+ <td id="LC3027" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3028" class="blob-num js-line-number" data-line-number="3028"></td>
+ <td id="LC3028" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> e;</td>
+ </tr>
+ <tr>
+ <td id="L3029" class="blob-num js-line-number" data-line-number="3029"></td>
+ <td id="LC3029" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3030" class="blob-num js-line-number" data-line-number="3030"></td>
+ <td id="LC3030" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3031" class="blob-num js-line-number" data-line-number="3031"></td>
+ <td id="LC3031" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3032" class="blob-num js-line-number" data-line-number="3032"></td>
+ <td id="LC3032" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3033" class="blob-num js-line-number" data-line-number="3033"></td>
+ <td id="LC3033" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./topsort<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">24</span>}],<span class="pl-c1">20</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3034" class="blob-num js-line-number" data-line-number="3034"></td>
+ <td id="LC3034" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> dfs <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dfs<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3035" class="blob-num js-line-number" data-line-number="3035"></td>
+ <td id="LC3035" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3036" class="blob-num js-line-number" data-line-number="3036"></td>
+ <td id="LC3036" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> postorder;</td>
+ </tr>
+ <tr>
+ <td id="L3037" class="blob-num js-line-number" data-line-number="3037"></td>
+ <td id="LC3037" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3038" class="blob-num js-line-number" data-line-number="3038"></td>
+ <td id="LC3038" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">postorder</span>(<span class="pl-smi">g</span>, <span class="pl-smi">vs</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3039" class="blob-num js-line-number" data-line-number="3039"></td>
+ <td id="LC3039" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">dfs</span>(g, vs, <span class="pl-s"><span class="pl-pds">"</span>post<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3040" class="blob-num js-line-number" data-line-number="3040"></td>
+ <td id="LC3040" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3041" class="blob-num js-line-number" data-line-number="3041"></td>
+ <td id="LC3041" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3042" class="blob-num js-line-number" data-line-number="3042"></td>
+ <td id="LC3042" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./dfs<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">13</span>}],<span class="pl-c1">21</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3043" class="blob-num js-line-number" data-line-number="3043"></td>
+ <td id="LC3043" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> dfs <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./dfs<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3044" class="blob-num js-line-number" data-line-number="3044"></td>
+ <td id="LC3044" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3045" class="blob-num js-line-number" data-line-number="3045"></td>
+ <td id="LC3045" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> preorder;</td>
+ </tr>
+ <tr>
+ <td id="L3046" class="blob-num js-line-number" data-line-number="3046"></td>
+ <td id="LC3046" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3047" class="blob-num js-line-number" data-line-number="3047"></td>
+ <td id="LC3047" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">preorder</span>(<span class="pl-smi">g</span>, <span class="pl-smi">vs</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3048" class="blob-num js-line-number" data-line-number="3048"></td>
+ <td id="LC3048" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">dfs</span>(g, vs, <span class="pl-s"><span class="pl-pds">"</span>pre<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3049" class="blob-num js-line-number" data-line-number="3049"></td>
+ <td id="LC3049" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3050" class="blob-num js-line-number" data-line-number="3050"></td>
+ <td id="LC3050" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3051" class="blob-num js-line-number" data-line-number="3051"></td>
+ <td id="LC3051" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./dfs<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">13</span>}],<span class="pl-c1">22</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3052" class="blob-num js-line-number" data-line-number="3052"></td>
+ <td id="LC3052" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3053" class="blob-num js-line-number" data-line-number="3053"></td>
+ <td id="LC3053" class="blob-code blob-code-inner js-file-line"> Graph <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../graph<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3054" class="blob-num js-line-number" data-line-number="3054"></td>
+ <td id="LC3054" class="blob-code blob-code-inner js-file-line"> PriorityQueue <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../data/priority-queue<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3055" class="blob-num js-line-number" data-line-number="3055"></td>
+ <td id="LC3055" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3056" class="blob-num js-line-number" data-line-number="3056"></td>
+ <td id="LC3056" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> prim;</td>
+ </tr>
+ <tr>
+ <td id="L3057" class="blob-num js-line-number" data-line-number="3057"></td>
+ <td id="LC3057" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3058" class="blob-num js-line-number" data-line-number="3058"></td>
+ <td id="LC3058" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">prim</span>(<span class="pl-smi">g</span>, <span class="pl-smi">weightFunc</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3059" class="blob-num js-line-number" data-line-number="3059"></td>
+ <td id="LC3059" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">Graph</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L3060" class="blob-num js-line-number" data-line-number="3060"></td>
+ <td id="LC3060" class="blob-code blob-code-inner js-file-line"> parents <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L3061" class="blob-num js-line-number" data-line-number="3061"></td>
+ <td id="LC3061" class="blob-code blob-code-inner js-file-line"> pq <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">PriorityQueue</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L3062" class="blob-num js-line-number" data-line-number="3062"></td>
+ <td id="LC3062" class="blob-code blob-code-inner js-file-line"> v;</td>
+ </tr>
+ <tr>
+ <td id="L3063" class="blob-num js-line-number" data-line-number="3063"></td>
+ <td id="LC3063" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3064" class="blob-num js-line-number" data-line-number="3064"></td>
+ <td id="LC3064" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">updateNeighbors</span>(<span class="pl-smi">edge</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3065" class="blob-num js-line-number" data-line-number="3065"></td>
+ <td id="LC3065" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> w <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span> <span class="pl-k">===</span> v <span class="pl-k">?</span> <span class="pl-smi">edge</span>.<span class="pl-smi">w</span> <span class="pl-k">:</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3066" class="blob-num js-line-number" data-line-number="3066"></td>
+ <td id="LC3066" class="blob-code blob-code-inner js-file-line"> pri <span class="pl-k">=</span> <span class="pl-smi">pq</span>.<span class="pl-en">priority</span>(w);</td>
+ </tr>
+ <tr>
+ <td id="L3067" class="blob-num js-line-number" data-line-number="3067"></td>
+ <td id="LC3067" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (pri <span class="pl-k">!==</span> <span class="pl-c1">undefined</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3068" class="blob-num js-line-number" data-line-number="3068"></td>
+ <td id="LC3068" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> edgeWeight <span class="pl-k">=</span> <span class="pl-en">weightFunc</span>(edge);</td>
+ </tr>
+ <tr>
+ <td id="L3069" class="blob-num js-line-number" data-line-number="3069"></td>
+ <td id="LC3069" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (edgeWeight <span class="pl-k"><</span> pri) {</td>
+ </tr>
+ <tr>
+ <td id="L3070" class="blob-num js-line-number" data-line-number="3070"></td>
+ <td id="LC3070" class="blob-code blob-code-inner js-file-line"> parents[w] <span class="pl-k">=</span> v;</td>
+ </tr>
+ <tr>
+ <td id="L3071" class="blob-num js-line-number" data-line-number="3071"></td>
+ <td id="LC3071" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">pq</span>.<span class="pl-en">decrease</span>(w, edgeWeight);</td>
+ </tr>
+ <tr>
+ <td id="L3072" class="blob-num js-line-number" data-line-number="3072"></td>
+ <td id="LC3072" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3073" class="blob-num js-line-number" data-line-number="3073"></td>
+ <td id="LC3073" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3074" class="blob-num js-line-number" data-line-number="3074"></td>
+ <td id="LC3074" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3075" class="blob-num js-line-number" data-line-number="3075"></td>
+ <td id="LC3075" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3076" class="blob-num js-line-number" data-line-number="3076"></td>
+ <td id="LC3076" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">g</span>.<span class="pl-en">nodeCount</span>() <span class="pl-k">===</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3077" class="blob-num js-line-number" data-line-number="3077"></td>
+ <td id="LC3077" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L3078" class="blob-num js-line-number" data-line-number="3078"></td>
+ <td id="LC3078" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3079" class="blob-num js-line-number" data-line-number="3079"></td>
+ <td id="LC3079" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3080" class="blob-num js-line-number" data-line-number="3080"></td>
+ <td id="LC3080" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">nodes</span>(), <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3081" class="blob-num js-line-number" data-line-number="3081"></td>
+ <td id="LC3081" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">pq</span>.<span class="pl-c1">add</span>(v, <span class="pl-c1">Number</span>.<span class="pl-c1">POSITIVE_INFINITY</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3082" class="blob-num js-line-number" data-line-number="3082"></td>
+ <td id="LC3082" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-en">setNode</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3083" class="blob-num js-line-number" data-line-number="3083"></td>
+ <td id="LC3083" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3084" class="blob-num js-line-number" data-line-number="3084"></td>
+ <td id="LC3084" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3085" class="blob-num js-line-number" data-line-number="3085"></td>
+ <td id="LC3085" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Start from an arbitrary node</span></td>
+ </tr>
+ <tr>
+ <td id="L3086" class="blob-num js-line-number" data-line-number="3086"></td>
+ <td id="LC3086" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">pq</span>.<span class="pl-en">decrease</span>(<span class="pl-smi">g</span>.<span class="pl-en">nodes</span>()[<span class="pl-c1">0</span>], <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3087" class="blob-num js-line-number" data-line-number="3087"></td>
+ <td id="LC3087" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3088" class="blob-num js-line-number" data-line-number="3088"></td>
+ <td id="LC3088" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> init <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3089" class="blob-num js-line-number" data-line-number="3089"></td>
+ <td id="LC3089" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-smi">pq</span>.<span class="pl-c1">size</span>() <span class="pl-k">></span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3090" class="blob-num js-line-number" data-line-number="3090"></td>
+ <td id="LC3090" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-smi">pq</span>.<span class="pl-en">removeMin</span>();</td>
+ </tr>
+ <tr>
+ <td id="L3091" class="blob-num js-line-number" data-line-number="3091"></td>
+ <td id="LC3091" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(parents, v)) {</td>
+ </tr>
+ <tr>
+ <td id="L3092" class="blob-num js-line-number" data-line-number="3092"></td>
+ <td id="LC3092" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-en">setEdge</span>(v, parents[v]);</td>
+ </tr>
+ <tr>
+ <td id="L3093" class="blob-num js-line-number" data-line-number="3093"></td>
+ <td id="LC3093" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (init) {</td>
+ </tr>
+ <tr>
+ <td id="L3094" class="blob-num js-line-number" data-line-number="3094"></td>
+ <td id="LC3094" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Input graph is not connected: <span class="pl-pds">"</span></span> <span class="pl-k">+</span> g);</td>
+ </tr>
+ <tr>
+ <td id="L3095" class="blob-num js-line-number" data-line-number="3095"></td>
+ <td id="LC3095" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3096" class="blob-num js-line-number" data-line-number="3096"></td>
+ <td id="LC3096" class="blob-code blob-code-inner js-file-line"> init <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3097" class="blob-num js-line-number" data-line-number="3097"></td>
+ <td id="LC3097" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3098" class="blob-num js-line-number" data-line-number="3098"></td>
+ <td id="LC3098" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3099" class="blob-num js-line-number" data-line-number="3099"></td>
+ <td id="LC3099" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">nodeEdges</span>(v).<span class="pl-en">forEach</span>(updateNeighbors);</td>
+ </tr>
+ <tr>
+ <td id="L3100" class="blob-num js-line-number" data-line-number="3100"></td>
+ <td id="LC3100" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3101" class="blob-num js-line-number" data-line-number="3101"></td>
+ <td id="LC3101" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3102" class="blob-num js-line-number" data-line-number="3102"></td>
+ <td id="LC3102" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L3103" class="blob-num js-line-number" data-line-number="3103"></td>
+ <td id="LC3103" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3104" class="blob-num js-line-number" data-line-number="3104"></td>
+ <td id="LC3104" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3105" class="blob-num js-line-number" data-line-number="3105"></td>
+ <td id="LC3105" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../data/priority-queue<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">25</span>,<span class="pl-s"><span class="pl-pds">"</span>../graph<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">26</span>,<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">&qu [...]
+ </tr>
+ <tr>
+ <td id="L3106" class="blob-num js-line-number" data-line-number="3106"></td>
+ <td id="LC3106" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3107" class="blob-num js-line-number" data-line-number="3107"></td>
+ <td id="LC3107" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3108" class="blob-num js-line-number" data-line-number="3108"></td>
+ <td id="LC3108" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> tarjan;</td>
+ </tr>
+ <tr>
+ <td id="L3109" class="blob-num js-line-number" data-line-number="3109"></td>
+ <td id="LC3109" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3110" class="blob-num js-line-number" data-line-number="3110"></td>
+ <td id="LC3110" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">tarjan</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3111" class="blob-num js-line-number" data-line-number="3111"></td>
+ <td id="LC3111" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3112" class="blob-num js-line-number" data-line-number="3112"></td>
+ <td id="LC3112" class="blob-code blob-code-inner js-file-line"> stack <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L3113" class="blob-num js-line-number" data-line-number="3113"></td>
+ <td id="LC3113" class="blob-code blob-code-inner js-file-line"> visited <span class="pl-k">=</span> {}, <span class="pl-c">// node id -> { onStack, lowlink, index }</span></td>
+ </tr>
+ <tr>
+ <td id="L3114" class="blob-num js-line-number" data-line-number="3114"></td>
+ <td id="LC3114" class="blob-code blob-code-inner js-file-line"> results <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L3115" class="blob-num js-line-number" data-line-number="3115"></td>
+ <td id="LC3115" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3116" class="blob-num js-line-number" data-line-number="3116"></td>
+ <td id="LC3116" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">dfs</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3117" class="blob-num js-line-number" data-line-number="3117"></td>
+ <td id="LC3117" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> entry <span class="pl-k">=</span> visited[v] <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3118" class="blob-num js-line-number" data-line-number="3118"></td>
+ <td id="LC3118" class="blob-code blob-code-inner js-file-line"> onStack<span class="pl-k">:</span> <span class="pl-c1">true</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3119" class="blob-num js-line-number" data-line-number="3119"></td>
+ <td id="LC3119" class="blob-code blob-code-inner js-file-line"> lowlink<span class="pl-k">:</span> index,</td>
+ </tr>
+ <tr>
+ <td id="L3120" class="blob-num js-line-number" data-line-number="3120"></td>
+ <td id="LC3120" class="blob-code blob-code-inner js-file-line"> index<span class="pl-k">:</span> index<span class="pl-k">++</span></td>
+ </tr>
+ <tr>
+ <td id="L3121" class="blob-num js-line-number" data-line-number="3121"></td>
+ <td id="LC3121" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L3122" class="blob-num js-line-number" data-line-number="3122"></td>
+ <td id="LC3122" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stack</span>.<span class="pl-c1">push</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3123" class="blob-num js-line-number" data-line-number="3123"></td>
+ <td id="LC3123" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3124" class="blob-num js-line-number" data-line-number="3124"></td>
+ <td id="LC3124" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">successors</span>(v).<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3125" class="blob-num js-line-number" data-line-number="3125"></td>
+ <td id="LC3125" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">has</span>(visited, w)) {</td>
+ </tr>
+ <tr>
+ <td id="L3126" class="blob-num js-line-number" data-line-number="3126"></td>
+ <td id="LC3126" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">dfs</span>(w);</td>
+ </tr>
+ <tr>
+ <td id="L3127" class="blob-num js-line-number" data-line-number="3127"></td>
+ <td id="LC3127" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">entry</span>.<span class="pl-smi">lowlink</span> <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-c1">min</span>(<span class="pl-smi">entry</span>.<span class="pl-smi">lowlink</span>, visited[w].<span class="pl-smi">lowlink</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3128" class="blob-num js-line-number" data-line-number="3128"></td>
+ <td id="LC3128" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (visited[w].<span class="pl-smi">onStack</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3129" class="blob-num js-line-number" data-line-number="3129"></td>
+ <td id="LC3129" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">entry</span>.<span class="pl-smi">lowlink</span> <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-c1">min</span>(<span class="pl-smi">entry</span>.<span class="pl-smi">lowlink</span>, visited[w].<span class="pl-c1">index</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3130" class="blob-num js-line-number" data-line-number="3130"></td>
+ <td id="LC3130" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3131" class="blob-num js-line-number" data-line-number="3131"></td>
+ <td id="LC3131" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3132" class="blob-num js-line-number" data-line-number="3132"></td>
+ <td id="LC3132" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3133" class="blob-num js-line-number" data-line-number="3133"></td>
+ <td id="LC3133" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">entry</span>.<span class="pl-smi">lowlink</span> <span class="pl-k">===</span> <span class="pl-smi">entry</span>.<span class="pl-c1">index</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3134" class="blob-num js-line-number" data-line-number="3134"></td>
+ <td id="LC3134" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cmpt <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L3135" class="blob-num js-line-number" data-line-number="3135"></td>
+ <td id="LC3135" class="blob-code blob-code-inner js-file-line"> w;</td>
+ </tr>
+ <tr>
+ <td id="L3136" class="blob-num js-line-number" data-line-number="3136"></td>
+ <td id="LC3136" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">do</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3137" class="blob-num js-line-number" data-line-number="3137"></td>
+ <td id="LC3137" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-smi">stack</span>.<span class="pl-c1">pop</span>();</td>
+ </tr>
+ <tr>
+ <td id="L3138" class="blob-num js-line-number" data-line-number="3138"></td>
+ <td id="LC3138" class="blob-code blob-code-inner js-file-line"> visited[w].<span class="pl-smi">onStack</span> <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3139" class="blob-num js-line-number" data-line-number="3139"></td>
+ <td id="LC3139" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">cmpt</span>.<span class="pl-c1">push</span>(w);</td>
+ </tr>
+ <tr>
+ <td id="L3140" class="blob-num js-line-number" data-line-number="3140"></td>
+ <td id="LC3140" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">while</span> (v <span class="pl-k">!==</span> w);</td>
+ </tr>
+ <tr>
+ <td id="L3141" class="blob-num js-line-number" data-line-number="3141"></td>
+ <td id="LC3141" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">results</span>.<span class="pl-c1">push</span>(cmpt);</td>
+ </tr>
+ <tr>
+ <td id="L3142" class="blob-num js-line-number" data-line-number="3142"></td>
+ <td id="LC3142" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3143" class="blob-num js-line-number" data-line-number="3143"></td>
+ <td id="LC3143" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3144" class="blob-num js-line-number" data-line-number="3144"></td>
+ <td id="LC3144" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3145" class="blob-num js-line-number" data-line-number="3145"></td>
+ <td id="LC3145" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">nodes</span>().<span class="pl-en">forEach</span>(<span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3146" class="blob-num js-line-number" data-line-number="3146"></td>
+ <td id="LC3146" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">has</span>(visited, v)) {</td>
+ </tr>
+ <tr>
+ <td id="L3147" class="blob-num js-line-number" data-line-number="3147"></td>
+ <td id="LC3147" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">dfs</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3148" class="blob-num js-line-number" data-line-number="3148"></td>
+ <td id="LC3148" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3149" class="blob-num js-line-number" data-line-number="3149"></td>
+ <td id="LC3149" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3150" class="blob-num js-line-number" data-line-number="3150"></td>
+ <td id="LC3150" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3151" class="blob-num js-line-number" data-line-number="3151"></td>
+ <td id="LC3151" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> results;</td>
+ </tr>
+ <tr>
+ <td id="L3152" class="blob-num js-line-number" data-line-number="3152"></td>
+ <td id="LC3152" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3153" class="blob-num js-line-number" data-line-number="3153"></td>
+ <td id="LC3153" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3154" class="blob-num js-line-number" data-line-number="3154"></td>
+ <td id="LC3154" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">24</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3155" class="blob-num js-line-number" data-line-number="3155"></td>
+ <td id="LC3155" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3156" class="blob-num js-line-number" data-line-number="3156"></td>
+ <td id="LC3156" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3157" class="blob-num js-line-number" data-line-number="3157"></td>
+ <td id="LC3157" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> topsort;</td>
+ </tr>
+ <tr>
+ <td id="L3158" class="blob-num js-line-number" data-line-number="3158"></td>
+ <td id="LC3158" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">topsort</span>.<span class="pl-smi">CycleException</span> <span class="pl-k">=</span> CycleException;</td>
+ </tr>
+ <tr>
+ <td id="L3159" class="blob-num js-line-number" data-line-number="3159"></td>
+ <td id="LC3159" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3160" class="blob-num js-line-number" data-line-number="3160"></td>
+ <td id="LC3160" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">topsort</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3161" class="blob-num js-line-number" data-line-number="3161"></td>
+ <td id="LC3161" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> visited <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L3162" class="blob-num js-line-number" data-line-number="3162"></td>
+ <td id="LC3162" class="blob-code blob-code-inner js-file-line"> stack <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L3163" class="blob-num js-line-number" data-line-number="3163"></td>
+ <td id="LC3163" class="blob-code blob-code-inner js-file-line"> results <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L3164" class="blob-num js-line-number" data-line-number="3164"></td>
+ <td id="LC3164" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3165" class="blob-num js-line-number" data-line-number="3165"></td>
+ <td id="LC3165" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">visit</span>(<span class="pl-smi">node</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3166" class="blob-num js-line-number" data-line-number="3166"></td>
+ <td id="LC3166" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(stack, node)) {</td>
+ </tr>
+ <tr>
+ <td id="L3167" class="blob-num js-line-number" data-line-number="3167"></td>
+ <td id="LC3167" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">CycleException</span>();</td>
+ </tr>
+ <tr>
+ <td id="L3168" class="blob-num js-line-number" data-line-number="3168"></td>
+ <td id="LC3168" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3169" class="blob-num js-line-number" data-line-number="3169"></td>
+ <td id="LC3169" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3170" class="blob-num js-line-number" data-line-number="3170"></td>
+ <td id="LC3170" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">has</span>(visited, node)) {</td>
+ </tr>
+ <tr>
+ <td id="L3171" class="blob-num js-line-number" data-line-number="3171"></td>
+ <td id="LC3171" class="blob-code blob-code-inner js-file-line"> stack[node] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3172" class="blob-num js-line-number" data-line-number="3172"></td>
+ <td id="LC3172" class="blob-code blob-code-inner js-file-line"> visited[node] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3173" class="blob-num js-line-number" data-line-number="3173"></td>
+ <td id="LC3173" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">predecessors</span>(node), visit);</td>
+ </tr>
+ <tr>
+ <td id="L3174" class="blob-num js-line-number" data-line-number="3174"></td>
+ <td id="LC3174" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> stack[node];</td>
+ </tr>
+ <tr>
+ <td id="L3175" class="blob-num js-line-number" data-line-number="3175"></td>
+ <td id="LC3175" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">results</span>.<span class="pl-c1">push</span>(node);</td>
+ </tr>
+ <tr>
+ <td id="L3176" class="blob-num js-line-number" data-line-number="3176"></td>
+ <td id="LC3176" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3177" class="blob-num js-line-number" data-line-number="3177"></td>
+ <td id="LC3177" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3178" class="blob-num js-line-number" data-line-number="3178"></td>
+ <td id="LC3178" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3179" class="blob-num js-line-number" data-line-number="3179"></td>
+ <td id="LC3179" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">g</span>.<span class="pl-en">sinks</span>(), visit);</td>
+ </tr>
+ <tr>
+ <td id="L3180" class="blob-num js-line-number" data-line-number="3180"></td>
+ <td id="LC3180" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3181" class="blob-num js-line-number" data-line-number="3181"></td>
+ <td id="LC3181" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-c1">size</span>(visited) <span class="pl-k">!==</span> <span class="pl-smi">g</span>.<span class="pl-en">nodeCount</span>()) {</td>
+ </tr>
+ <tr>
+ <td id="L3182" class="blob-num js-line-number" data-line-number="3182"></td>
+ <td id="LC3182" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">CycleException</span>();</td>
+ </tr>
+ <tr>
+ <td id="L3183" class="blob-num js-line-number" data-line-number="3183"></td>
+ <td id="LC3183" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3184" class="blob-num js-line-number" data-line-number="3184"></td>
+ <td id="LC3184" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3185" class="blob-num js-line-number" data-line-number="3185"></td>
+ <td id="LC3185" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> results;</td>
+ </tr>
+ <tr>
+ <td id="L3186" class="blob-num js-line-number" data-line-number="3186"></td>
+ <td id="LC3186" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3187" class="blob-num js-line-number" data-line-number="3187"></td>
+ <td id="LC3187" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3188" class="blob-num js-line-number" data-line-number="3188"></td>
+ <td id="LC3188" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">CycleException</span>() {}</td>
+ </tr>
+ <tr>
+ <td id="L3189" class="blob-num js-line-number" data-line-number="3189"></td>
+ <td id="LC3189" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3190" class="blob-num js-line-number" data-line-number="3190"></td>
+ <td id="LC3190" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">25</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3191" class="blob-num js-line-number" data-line-number="3191"></td>
+ <td id="LC3191" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3192" class="blob-num js-line-number" data-line-number="3192"></td>
+ <td id="LC3192" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3193" class="blob-num js-line-number" data-line-number="3193"></td>
+ <td id="LC3193" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> PriorityQueue;</td>
+ </tr>
+ <tr>
+ <td id="L3194" class="blob-num js-line-number" data-line-number="3194"></td>
+ <td id="LC3194" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3195" class="blob-num js-line-number" data-line-number="3195"></td>
+ <td id="LC3195" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3196" class="blob-num js-line-number" data-line-number="3196"></td>
+ <td id="LC3196" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A min-priority queue data structure. This algorithm is derived from Cormen,</span></td>
+ </tr>
+ <tr>
+ <td id="L3197" class="blob-num js-line-number" data-line-number="3197"></td>
+ <td id="LC3197" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * et al., "Introduction to Algorithms". The basic idea of a min-priority</span></td>
+ </tr>
+ <tr>
+ <td id="L3198" class="blob-num js-line-number" data-line-number="3198"></td>
+ <td id="LC3198" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * queue is that you can efficiently (in O(1) time) get the smallest key in</span></td>
+ </tr>
+ <tr>
+ <td id="L3199" class="blob-num js-line-number" data-line-number="3199"></td>
+ <td id="LC3199" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the queue. Adding and removing elements takes O(log n) time. A key can</span></td>
+ </tr>
+ <tr>
+ <td id="L3200" class="blob-num js-line-number" data-line-number="3200"></td>
+ <td id="LC3200" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * have its priority decreased in O(log n) time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3201" class="blob-num js-line-number" data-line-number="3201"></td>
+ <td id="LC3201" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3202" class="blob-num js-line-number" data-line-number="3202"></td>
+ <td id="LC3202" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">PriorityQueue</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3203" class="blob-num js-line-number" data-line-number="3203"></td>
+ <td id="LC3203" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span> <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L3204" class="blob-num js-line-number" data-line-number="3204"></td>
+ <td id="LC3204" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3205" class="blob-num js-line-number" data-line-number="3205"></td>
+ <td id="LC3205" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3206" class="blob-num js-line-number" data-line-number="3206"></td>
+ <td id="LC3206" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3207" class="blob-num js-line-number" data-line-number="3207"></td>
+ <td id="LC3207" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3208" class="blob-num js-line-number" data-line-number="3208"></td>
+ <td id="LC3208" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Returns the number of elements in the queue. Takes `O(1)` time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3209" class="blob-num js-line-number" data-line-number="3209"></td>
+ <td id="LC3209" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3210" class="blob-num js-line-number" data-line-number="3210"></td>
+ <td id="LC3210" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">size</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3211" class="blob-num js-line-number" data-line-number="3211"></td>
+ <td id="LC3211" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3212" class="blob-num js-line-number" data-line-number="3212"></td>
+ <td id="LC3212" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3213" class="blob-num js-line-number" data-line-number="3213"></td>
+ <td id="LC3213" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3214" class="blob-num js-line-number" data-line-number="3214"></td>
+ <td id="LC3214" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3215" class="blob-num js-line-number" data-line-number="3215"></td>
+ <td id="LC3215" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Returns the keys that are in the queue. Takes `O(n)` time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3216" class="blob-num js-line-number" data-line-number="3216"></td>
+ <td id="LC3216" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3217" class="blob-num js-line-number" data-line-number="3217"></td>
+ <td id="LC3217" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">keys</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3218" class="blob-num js-line-number" data-line-number="3218"></td>
+ <td id="LC3218" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>.<span class="pl-en">map</span>(<span class="pl-k">function</span>(<span class="pl-smi">x</span>) { <span class="pl-k">return</span> <span class="pl-smi">x</span>.<span class="pl-smi">key</span>; });</td>
+ </tr>
+ <tr>
+ <td id="L3219" class="blob-num js-line-number" data-line-number="3219"></td>
+ <td id="LC3219" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3220" class="blob-num js-line-number" data-line-number="3220"></td>
+ <td id="LC3220" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3221" class="blob-num js-line-number" data-line-number="3221"></td>
+ <td id="LC3221" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3222" class="blob-num js-line-number" data-line-number="3222"></td>
+ <td id="LC3222" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Returns `true` if **key** is in the queue and `false` if not.</span></td>
+ </tr>
+ <tr>
+ <td id="L3223" class="blob-num js-line-number" data-line-number="3223"></td>
+ <td id="LC3223" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3224" class="blob-num js-line-number" data-line-number="3224"></td>
+ <td id="LC3224" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">has</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3225" class="blob-num js-line-number" data-line-number="3225"></td>
+ <td id="LC3225" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">has</span>(<span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span>, key);</td>
+ </tr>
+ <tr>
+ <td id="L3226" class="blob-num js-line-number" data-line-number="3226"></td>
+ <td id="LC3226" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3227" class="blob-num js-line-number" data-line-number="3227"></td>
+ <td id="LC3227" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3228" class="blob-num js-line-number" data-line-number="3228"></td>
+ <td id="LC3228" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3229" class="blob-num js-line-number" data-line-number="3229"></td>
+ <td id="LC3229" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Returns the priority for **key**. If **key** is not present in the queue</span></td>
+ </tr>
+ <tr>
+ <td id="L3230" class="blob-num js-line-number" data-line-number="3230"></td>
+ <td id="LC3230" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * then this function returns `undefined`. Takes `O(1)` time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3231" class="blob-num js-line-number" data-line-number="3231"></td>
+ <td id="LC3231" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L3232" class="blob-num js-line-number" data-line-number="3232"></td>
+ <td id="LC3232" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">key</span></span></td>
+ </tr>
+ <tr>
+ <td id="L3233" class="blob-num js-line-number" data-line-number="3233"></td>
+ <td id="LC3233" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3234" class="blob-num js-line-number" data-line-number="3234"></td>
+ <td id="LC3234" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">priority</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3235" class="blob-num js-line-number" data-line-number="3235"></td>
+ <td id="LC3235" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span>[key];</td>
+ </tr>
+ <tr>
+ <td id="L3236" class="blob-num js-line-number" data-line-number="3236"></td>
+ <td id="LC3236" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (index <span class="pl-k">!==</span> <span class="pl-c1">undefined</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3237" class="blob-num js-line-number" data-line-number="3237"></td>
+ <td id="LC3237" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>[index].<span class="pl-smi">priority</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3238" class="blob-num js-line-number" data-line-number="3238"></td>
+ <td id="LC3238" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3239" class="blob-num js-line-number" data-line-number="3239"></td>
+ <td id="LC3239" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3240" class="blob-num js-line-number" data-line-number="3240"></td>
+ <td id="LC3240" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3241" class="blob-num js-line-number" data-line-number="3241"></td>
+ <td id="LC3241" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3242" class="blob-num js-line-number" data-line-number="3242"></td>
+ <td id="LC3242" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Returns the key for the minimum element in this queue. If the queue is</span></td>
+ </tr>
+ <tr>
+ <td id="L3243" class="blob-num js-line-number" data-line-number="3243"></td>
+ <td id="LC3243" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * empty this function throws an Error. Takes `O(1)` time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3244" class="blob-num js-line-number" data-line-number="3244"></td>
+ <td id="LC3244" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3245" class="blob-num js-line-number" data-line-number="3245"></td>
+ <td id="LC3245" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">min</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3246" class="blob-num js-line-number" data-line-number="3246"></td>
+ <td id="LC3246" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-c1">size</span>() <span class="pl-k">===</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3247" class="blob-num js-line-number" data-line-number="3247"></td>
+ <td id="LC3247" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Queue underflow<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3248" class="blob-num js-line-number" data-line-number="3248"></td>
+ <td id="LC3248" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3249" class="blob-num js-line-number" data-line-number="3249"></td>
+ <td id="LC3249" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>[<span class="pl-c1">0</span>].<span class="pl-smi">key</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3250" class="blob-num js-line-number" data-line-number="3250"></td>
+ <td id="LC3250" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3251" class="blob-num js-line-number" data-line-number="3251"></td>
+ <td id="LC3251" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3252" class="blob-num js-line-number" data-line-number="3252"></td>
+ <td id="LC3252" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3253" class="blob-num js-line-number" data-line-number="3253"></td>
+ <td id="LC3253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Inserts a new key into the priority queue. If the key already exists in</span></td>
+ </tr>
+ <tr>
+ <td id="L3254" class="blob-num js-line-number" data-line-number="3254"></td>
+ <td id="LC3254" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the queue this function returns `false`; otherwise it will return `true`.</span></td>
+ </tr>
+ <tr>
+ <td id="L3255" class="blob-num js-line-number" data-line-number="3255"></td>
+ <td id="LC3255" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Takes `O(n)` time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3256" class="blob-num js-line-number" data-line-number="3256"></td>
+ <td id="LC3256" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L3257" class="blob-num js-line-number" data-line-number="3257"></td>
+ <td id="LC3257" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">key</span> the key to add</span></td>
+ </tr>
+ <tr>
+ <td id="L3258" class="blob-num js-line-number" data-line-number="3258"></td>
+ <td id="LC3258" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Number}</span> <span class="pl-smi">priority</span> the initial priority for the key</span></td>
+ </tr>
+ <tr>
+ <td id="L3259" class="blob-num js-line-number" data-line-number="3259"></td>
+ <td id="LC3259" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3260" class="blob-num js-line-number" data-line-number="3260"></td>
+ <td id="LC3260" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">add</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">key</span>, <span class="pl-smi">priority</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3261" class="blob-num js-line-number" data-line-number="3261"></td>
+ <td id="LC3261" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> keyIndices <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3262" class="blob-num js-line-number" data-line-number="3262"></td>
+ <td id="LC3262" class="blob-code blob-code-inner js-file-line"> key <span class="pl-k">=</span> <span class="pl-c1">String</span>(key);</td>
+ </tr>
+ <tr>
+ <td id="L3263" class="blob-num js-line-number" data-line-number="3263"></td>
+ <td id="LC3263" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">has</span>(keyIndices, key)) {</td>
+ </tr>
+ <tr>
+ <td id="L3264" class="blob-num js-line-number" data-line-number="3264"></td>
+ <td id="LC3264" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> arr <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3265" class="blob-num js-line-number" data-line-number="3265"></td>
+ <td id="LC3265" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-smi">arr</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3266" class="blob-num js-line-number" data-line-number="3266"></td>
+ <td id="LC3266" class="blob-code blob-code-inner js-file-line"> keyIndices[key] <span class="pl-k">=</span> index;</td>
+ </tr>
+ <tr>
+ <td id="L3267" class="blob-num js-line-number" data-line-number="3267"></td>
+ <td id="LC3267" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">arr</span>.<span class="pl-c1">push</span>({key<span class="pl-k">:</span> key, priority<span class="pl-k">:</span> priority});</td>
+ </tr>
+ <tr>
+ <td id="L3268" class="blob-num js-line-number" data-line-number="3268"></td>
+ <td id="LC3268" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_decrease</span>(index);</td>
+ </tr>
+ <tr>
+ <td id="L3269" class="blob-num js-line-number" data-line-number="3269"></td>
+ <td id="LC3269" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3270" class="blob-num js-line-number" data-line-number="3270"></td>
+ <td id="LC3270" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3271" class="blob-num js-line-number" data-line-number="3271"></td>
+ <td id="LC3271" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3272" class="blob-num js-line-number" data-line-number="3272"></td>
+ <td id="LC3272" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3273" class="blob-num js-line-number" data-line-number="3273"></td>
+ <td id="LC3273" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3274" class="blob-num js-line-number" data-line-number="3274"></td>
+ <td id="LC3274" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3275" class="blob-num js-line-number" data-line-number="3275"></td>
+ <td id="LC3275" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Removes and returns the smallest key in the queue. Takes `O(log n)` time.</span></td>
+ </tr>
+ <tr>
+ <td id="L3276" class="blob-num js-line-number" data-line-number="3276"></td>
+ <td id="LC3276" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3277" class="blob-num js-line-number" data-line-number="3277"></td>
+ <td id="LC3277" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">removeMin</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3278" class="blob-num js-line-number" data-line-number="3278"></td>
+ <td id="LC3278" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_swap</span>(<span class="pl-c1">0</span>, <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>.<span class="pl-c1">length</span> <span class="pl-k">-</span> <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3279" class="blob-num js-line-number" data-line-number="3279"></td>
+ <td id="LC3279" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> min <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>.<span class="pl-c1">pop</span>();</td>
+ </tr>
+ <tr>
+ <td id="L3280" class="blob-num js-line-number" data-line-number="3280"></td>
+ <td id="LC3280" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span>[<span class="pl-smi">min</span>.<span class="pl-smi">key</span>];</td>
+ </tr>
+ <tr>
+ <td id="L3281" class="blob-num js-line-number" data-line-number="3281"></td>
+ <td id="LC3281" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_heapify</span>(<span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3282" class="blob-num js-line-number" data-line-number="3282"></td>
+ <td id="LC3282" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">min</span>.<span class="pl-smi">key</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3283" class="blob-num js-line-number" data-line-number="3283"></td>
+ <td id="LC3283" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3284" class="blob-num js-line-number" data-line-number="3284"></td>
+ <td id="LC3284" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3285" class="blob-num js-line-number" data-line-number="3285"></td>
+ <td id="LC3285" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3286" class="blob-num js-line-number" data-line-number="3286"></td>
+ <td id="LC3286" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Decreases the priority for **key** to **priority**. If the new priority is</span></td>
+ </tr>
+ <tr>
+ <td id="L3287" class="blob-num js-line-number" data-line-number="3287"></td>
+ <td id="LC3287" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * greater than the previous priority, this function will throw an Error.</span></td>
+ </tr>
+ <tr>
+ <td id="L3288" class="blob-num js-line-number" data-line-number="3288"></td>
+ <td id="LC3288" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L3289" class="blob-num js-line-number" data-line-number="3289"></td>
+ <td id="LC3289" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">key</span> the key for which to raise priority</span></td>
+ </tr>
+ <tr>
+ <td id="L3290" class="blob-num js-line-number" data-line-number="3290"></td>
+ <td id="LC3290" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Number}</span> <span class="pl-smi">priority</span> the new priority for the key</span></td>
+ </tr>
+ <tr>
+ <td id="L3291" class="blob-num js-line-number" data-line-number="3291"></td>
+ <td id="LC3291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3292" class="blob-num js-line-number" data-line-number="3292"></td>
+ <td id="LC3292" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">decrease</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">key</span>, <span class="pl-smi">priority</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3293" class="blob-num js-line-number" data-line-number="3293"></td>
+ <td id="LC3293" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span>[key];</td>
+ </tr>
+ <tr>
+ <td id="L3294" class="blob-num js-line-number" data-line-number="3294"></td>
+ <td id="LC3294" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (priority <span class="pl-k">></span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>[index].<span class="pl-smi">priority</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3295" class="blob-num js-line-number" data-line-number="3295"></td>
+ <td id="LC3295" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>New priority is greater than current priority. <span class="pl-pds">"</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L3296" class="blob-num js-line-number" data-line-number="3296"></td>
+ <td id="LC3296" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span>Key: <span class="pl-pds">"</span></span> <span class="pl-k">+</span> key <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> Old: <span class="pl-pds">"</span></span> <span class="pl-k">+</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>[index].<span class="pl-smi">priority</span> <span class="pl- [...]
+ </tr>
+ <tr>
+ <td id="L3297" class="blob-num js-line-number" data-line-number="3297"></td>
+ <td id="LC3297" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3298" class="blob-num js-line-number" data-line-number="3298"></td>
+ <td id="LC3298" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>[index].<span class="pl-smi">priority</span> <span class="pl-k">=</span> priority;</td>
+ </tr>
+ <tr>
+ <td id="L3299" class="blob-num js-line-number" data-line-number="3299"></td>
+ <td id="LC3299" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_decrease</span>(index);</td>
+ </tr>
+ <tr>
+ <td id="L3300" class="blob-num js-line-number" data-line-number="3300"></td>
+ <td id="LC3300" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3301" class="blob-num js-line-number" data-line-number="3301"></td>
+ <td id="LC3301" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3302" class="blob-num js-line-number" data-line-number="3302"></td>
+ <td id="LC3302" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">_heapify</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">i</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3303" class="blob-num js-line-number" data-line-number="3303"></td>
+ <td id="LC3303" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> arr <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3304" class="blob-num js-line-number" data-line-number="3304"></td>
+ <td id="LC3304" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> l <span class="pl-k">=</span> <span class="pl-c1">2</span> <span class="pl-k">*</span> i,</td>
+ </tr>
+ <tr>
+ <td id="L3305" class="blob-num js-line-number" data-line-number="3305"></td>
+ <td id="LC3305" class="blob-code blob-code-inner js-file-line"> r <span class="pl-k">=</span> l <span class="pl-k">+</span> <span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3306" class="blob-num js-line-number" data-line-number="3306"></td>
+ <td id="LC3306" class="blob-code blob-code-inner js-file-line"> largest <span class="pl-k">=</span> i;</td>
+ </tr>
+ <tr>
+ <td id="L3307" class="blob-num js-line-number" data-line-number="3307"></td>
+ <td id="LC3307" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (l <span class="pl-k"><</span> <span class="pl-smi">arr</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3308" class="blob-num js-line-number" data-line-number="3308"></td>
+ <td id="LC3308" class="blob-code blob-code-inner js-file-line"> largest <span class="pl-k">=</span> arr[l].<span class="pl-smi">priority</span> <span class="pl-k"><</span> arr[largest].<span class="pl-smi">priority</span> <span class="pl-k">?</span> l <span class="pl-k">:</span> largest;</td>
+ </tr>
+ <tr>
+ <td id="L3309" class="blob-num js-line-number" data-line-number="3309"></td>
+ <td id="LC3309" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (r <span class="pl-k"><</span> <span class="pl-smi">arr</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3310" class="blob-num js-line-number" data-line-number="3310"></td>
+ <td id="LC3310" class="blob-code blob-code-inner js-file-line"> largest <span class="pl-k">=</span> arr[r].<span class="pl-smi">priority</span> <span class="pl-k"><</span> arr[largest].<span class="pl-smi">priority</span> <span class="pl-k">?</span> r <span class="pl-k">:</span> largest;</td>
+ </tr>
+ <tr>
+ <td id="L3311" class="blob-num js-line-number" data-line-number="3311"></td>
+ <td id="LC3311" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3312" class="blob-num js-line-number" data-line-number="3312"></td>
+ <td id="LC3312" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (largest <span class="pl-k">!==</span> i) {</td>
+ </tr>
+ <tr>
+ <td id="L3313" class="blob-num js-line-number" data-line-number="3313"></td>
+ <td id="LC3313" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_swap</span>(i, largest);</td>
+ </tr>
+ <tr>
+ <td id="L3314" class="blob-num js-line-number" data-line-number="3314"></td>
+ <td id="LC3314" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_heapify</span>(largest);</td>
+ </tr>
+ <tr>
+ <td id="L3315" class="blob-num js-line-number" data-line-number="3315"></td>
+ <td id="LC3315" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3316" class="blob-num js-line-number" data-line-number="3316"></td>
+ <td id="LC3316" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3317" class="blob-num js-line-number" data-line-number="3317"></td>
+ <td id="LC3317" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3318" class="blob-num js-line-number" data-line-number="3318"></td>
+ <td id="LC3318" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3319" class="blob-num js-line-number" data-line-number="3319"></td>
+ <td id="LC3319" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">_decrease</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">index</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3320" class="blob-num js-line-number" data-line-number="3320"></td>
+ <td id="LC3320" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> arr <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3321" class="blob-num js-line-number" data-line-number="3321"></td>
+ <td id="LC3321" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> priority <span class="pl-k">=</span> arr[index].<span class="pl-smi">priority</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3322" class="blob-num js-line-number" data-line-number="3322"></td>
+ <td id="LC3322" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> parent;</td>
+ </tr>
+ <tr>
+ <td id="L3323" class="blob-num js-line-number" data-line-number="3323"></td>
+ <td id="LC3323" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (index <span class="pl-k">!==</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3324" class="blob-num js-line-number" data-line-number="3324"></td>
+ <td id="LC3324" class="blob-code blob-code-inner js-file-line"> parent <span class="pl-k">=</span> index <span class="pl-k">>></span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3325" class="blob-num js-line-number" data-line-number="3325"></td>
+ <td id="LC3325" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (arr[parent].<span class="pl-smi">priority</span> <span class="pl-k"><</span> priority) {</td>
+ </tr>
+ <tr>
+ <td id="L3326" class="blob-num js-line-number" data-line-number="3326"></td>
+ <td id="LC3326" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3327" class="blob-num js-line-number" data-line-number="3327"></td>
+ <td id="LC3327" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3328" class="blob-num js-line-number" data-line-number="3328"></td>
+ <td id="LC3328" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_swap</span>(index, parent);</td>
+ </tr>
+ <tr>
+ <td id="L3329" class="blob-num js-line-number" data-line-number="3329"></td>
+ <td id="LC3329" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> parent;</td>
+ </tr>
+ <tr>
+ <td id="L3330" class="blob-num js-line-number" data-line-number="3330"></td>
+ <td id="LC3330" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3331" class="blob-num js-line-number" data-line-number="3331"></td>
+ <td id="LC3331" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3332" class="blob-num js-line-number" data-line-number="3332"></td>
+ <td id="LC3332" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3333" class="blob-num js-line-number" data-line-number="3333"></td>
+ <td id="LC3333" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">PriorityQueue</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">_swap</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">i</span>, <span class="pl-smi">j</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3334" class="blob-num js-line-number" data-line-number="3334"></td>
+ <td id="LC3334" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> arr <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_arr</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3335" class="blob-num js-line-number" data-line-number="3335"></td>
+ <td id="LC3335" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> keyIndices <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_keyIndices</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3336" class="blob-num js-line-number" data-line-number="3336"></td>
+ <td id="LC3336" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> origArrI <span class="pl-k">=</span> arr[i];</td>
+ </tr>
+ <tr>
+ <td id="L3337" class="blob-num js-line-number" data-line-number="3337"></td>
+ <td id="LC3337" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> origArrJ <span class="pl-k">=</span> arr[j];</td>
+ </tr>
+ <tr>
+ <td id="L3338" class="blob-num js-line-number" data-line-number="3338"></td>
+ <td id="LC3338" class="blob-code blob-code-inner js-file-line"> arr[i] <span class="pl-k">=</span> origArrJ;</td>
+ </tr>
+ <tr>
+ <td id="L3339" class="blob-num js-line-number" data-line-number="3339"></td>
+ <td id="LC3339" class="blob-code blob-code-inner js-file-line"> arr[j] <span class="pl-k">=</span> origArrI;</td>
+ </tr>
+ <tr>
+ <td id="L3340" class="blob-num js-line-number" data-line-number="3340"></td>
+ <td id="LC3340" class="blob-code blob-code-inner js-file-line"> keyIndices[<span class="pl-smi">origArrJ</span>.<span class="pl-smi">key</span>] <span class="pl-k">=</span> i;</td>
+ </tr>
+ <tr>
+ <td id="L3341" class="blob-num js-line-number" data-line-number="3341"></td>
+ <td id="LC3341" class="blob-code blob-code-inner js-file-line"> keyIndices[<span class="pl-smi">origArrI</span>.<span class="pl-smi">key</span>] <span class="pl-k">=</span> j;</td>
+ </tr>
+ <tr>
+ <td id="L3342" class="blob-num js-line-number" data-line-number="3342"></td>
+ <td id="LC3342" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3343" class="blob-num js-line-number" data-line-number="3343"></td>
+ <td id="LC3343" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3344" class="blob-num js-line-number" data-line-number="3344"></td>
+ <td id="LC3344" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>../lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">26</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3345" class="blob-num js-line-number" data-line-number="3345"></td>
+ <td id="LC3345" class="blob-code blob-code-inner js-file-line"><span class="pl-s"><span class="pl-pds">"</span>use strict<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3346" class="blob-num js-line-number" data-line-number="3346"></td>
+ <td id="LC3346" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3347" class="blob-num js-line-number" data-line-number="3347"></td>
+ <td id="LC3347" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3348" class="blob-num js-line-number" data-line-number="3348"></td>
+ <td id="LC3348" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3349" class="blob-num js-line-number" data-line-number="3349"></td>
+ <td id="LC3349" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> Graph;</td>
+ </tr>
+ <tr>
+ <td id="L3350" class="blob-num js-line-number" data-line-number="3350"></td>
+ <td id="LC3350" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3351" class="blob-num js-line-number" data-line-number="3351"></td>
+ <td id="LC3351" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> <span class="pl-c1">DEFAULT_EDGE_NAME</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\x</span>00<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L3352" class="blob-num js-line-number" data-line-number="3352"></td>
+ <td id="LC3352" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">GRAPH_NODE</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\x</span>00<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L3353" class="blob-num js-line-number" data-line-number="3353"></td>
+ <td id="LC3353" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">EDGE_KEY_DELIM</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-cce">\x</span>01<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3354" class="blob-num js-line-number" data-line-number="3354"></td>
+ <td id="LC3354" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3355" class="blob-num js-line-number" data-line-number="3355"></td>
+ <td id="LC3355" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// Implementation notes:</span></td>
+ </tr>
+ <tr>
+ <td id="L3356" class="blob-num js-line-number" data-line-number="3356"></td>
+ <td id="LC3356" class="blob-code blob-code-inner js-file-line"><span class="pl-c">//</span></td>
+ </tr>
+ <tr>
+ <td id="L3357" class="blob-num js-line-number" data-line-number="3357"></td>
+ <td id="LC3357" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// * Node id query functions should return string ids for the nodes</span></td>
+ </tr>
+ <tr>
+ <td id="L3358" class="blob-num js-line-number" data-line-number="3358"></td>
+ <td id="LC3358" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// * Edge id query functions should return an "edgeObj", edge object, that is</span></td>
+ </tr>
+ <tr>
+ <td id="L3359" class="blob-num js-line-number" data-line-number="3359"></td>
+ <td id="LC3359" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// composed of enough information to uniquely identify an edge: {v, w, name}.</span></td>
+ </tr>
+ <tr>
+ <td id="L3360" class="blob-num js-line-number" data-line-number="3360"></td>
+ <td id="LC3360" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// * Internally we use an "edgeId", a stringified form of the edgeObj, to</span></td>
+ </tr>
+ <tr>
+ <td id="L3361" class="blob-num js-line-number" data-line-number="3361"></td>
+ <td id="LC3361" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// reference edges. This is because we need a performant way to look these</span></td>
+ </tr>
+ <tr>
+ <td id="L3362" class="blob-num js-line-number" data-line-number="3362"></td>
+ <td id="LC3362" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// edges up and, object properties, which have string keys, are the closest</span></td>
+ </tr>
+ <tr>
+ <td id="L3363" class="blob-num js-line-number" data-line-number="3363"></td>
+ <td id="LC3363" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// we're going to get to a performant hashtable in JavaScript.</span></td>
+ </tr>
+ <tr>
+ <td id="L3364" class="blob-num js-line-number" data-line-number="3364"></td>
+ <td id="LC3364" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3365" class="blob-num js-line-number" data-line-number="3365"></td>
+ <td id="LC3365" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">Graph</span>(<span class="pl-smi">opts</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3366" class="blob-num js-line-number" data-line-number="3366"></td>
+ <td id="LC3366" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">has</span>(opts, <span class="pl-s"><span class="pl-pds">"</span>directed<span class="pl-pds">"</span></span>) <span class="pl-k">?</span> <span class="pl-smi">opts</span>.<span class="pl-smi">directed</span> <span class="pl-k">:</span> <span class="pl-c1">tru [...]
+ </tr>
+ <tr>
+ <td id="L3367" class="blob-num js-line-number" data-line-number="3367"></td>
+ <td id="LC3367" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_isMultigraph</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">has</span>(opts, <span class="pl-s"><span class="pl-pds">"</span>multigraph<span class="pl-pds">"</span></span>) <span class="pl-k">?</span> <span class="pl-smi">opts</span>.<span class="pl-smi">multigraph</span> <span class="pl-k">:</span> <span class="pl-c [...]
+ </tr>
+ <tr>
+ <td id="L3368" class="blob-num js-line-number" data-line-number="3368"></td>
+ <td id="LC3368" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">has</span>(opts, <span class="pl-s"><span class="pl-pds">"</span>compound<span class="pl-pds">"</span></span>) <span class="pl-k">?</span> <span class="pl-smi">opts</span>.<span class="pl-smi">compound</span> <span class="pl-k">:</span> <span class="pl-c1">fal [...]
+ </tr>
+ <tr>
+ <td id="L3369" class="blob-num js-line-number" data-line-number="3369"></td>
+ <td id="LC3369" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3370" class="blob-num js-line-number" data-line-number="3370"></td>
+ <td id="LC3370" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Label for the graph itself</span></td>
+ </tr>
+ <tr>
+ <td id="L3371" class="blob-num js-line-number" data-line-number="3371"></td>
+ <td id="LC3371" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_label</span> <span class="pl-k">=</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3372" class="blob-num js-line-number" data-line-number="3372"></td>
+ <td id="LC3372" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3373" class="blob-num js-line-number" data-line-number="3373"></td>
+ <td id="LC3373" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Defaults to be set when creating a new node</span></td>
+ </tr>
+ <tr>
+ <td id="L3374" class="blob-num js-line-number" data-line-number="3374"></td>
+ <td id="LC3374" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_defaultNodeLabelFn</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">constant</span>(<span class="pl-c1">undefined</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3375" class="blob-num js-line-number" data-line-number="3375"></td>
+ <td id="LC3375" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3376" class="blob-num js-line-number" data-line-number="3376"></td>
+ <td id="LC3376" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Defaults to be set when creating a new edge</span></td>
+ </tr>
+ <tr>
+ <td id="L3377" class="blob-num js-line-number" data-line-number="3377"></td>
+ <td id="LC3377" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_defaultEdgeLabelFn</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">constant</span>(<span class="pl-c1">undefined</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3378" class="blob-num js-line-number" data-line-number="3378"></td>
+ <td id="LC3378" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3379" class="blob-num js-line-number" data-line-number="3379"></td>
+ <td id="LC3379" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// v -> label</span></td>
+ </tr>
+ <tr>
+ <td id="L3380" class="blob-num js-line-number" data-line-number="3380"></td>
+ <td id="LC3380" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_nodes</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3381" class="blob-num js-line-number" data-line-number="3381"></td>
+ <td id="LC3381" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3382" class="blob-num js-line-number" data-line-number="3382"></td>
+ <td id="LC3382" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3383" class="blob-num js-line-number" data-line-number="3383"></td>
+ <td id="LC3383" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// v -> parent</span></td>
+ </tr>
+ <tr>
+ <td id="L3384" class="blob-num js-line-number" data-line-number="3384"></td>
+ <td id="LC3384" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_parent</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3385" class="blob-num js-line-number" data-line-number="3385"></td>
+ <td id="LC3385" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3386" class="blob-num js-line-number" data-line-number="3386"></td>
+ <td id="LC3386" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// v -> children</span></td>
+ </tr>
+ <tr>
+ <td id="L3387" class="blob-num js-line-number" data-line-number="3387"></td>
+ <td id="LC3387" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_children</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3388" class="blob-num js-line-number" data-line-number="3388"></td>
+ <td id="LC3388" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[<span class="pl-c1">GRAPH_NODE</span>] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3389" class="blob-num js-line-number" data-line-number="3389"></td>
+ <td id="LC3389" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3390" class="blob-num js-line-number" data-line-number="3390"></td>
+ <td id="LC3390" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3391" class="blob-num js-line-number" data-line-number="3391"></td>
+ <td id="LC3391" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// v -> edgeObj</span></td>
+ </tr>
+ <tr>
+ <td id="L3392" class="blob-num js-line-number" data-line-number="3392"></td>
+ <td id="LC3392" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_in</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3393" class="blob-num js-line-number" data-line-number="3393"></td>
+ <td id="LC3393" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3394" class="blob-num js-line-number" data-line-number="3394"></td>
+ <td id="LC3394" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// u -> v -> Number</span></td>
+ </tr>
+ <tr>
+ <td id="L3395" class="blob-num js-line-number" data-line-number="3395"></td>
+ <td id="LC3395" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_preds</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3396" class="blob-num js-line-number" data-line-number="3396"></td>
+ <td id="LC3396" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3397" class="blob-num js-line-number" data-line-number="3397"></td>
+ <td id="LC3397" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// v -> edgeObj</span></td>
+ </tr>
+ <tr>
+ <td id="L3398" class="blob-num js-line-number" data-line-number="3398"></td>
+ <td id="LC3398" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_out</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3399" class="blob-num js-line-number" data-line-number="3399"></td>
+ <td id="LC3399" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3400" class="blob-num js-line-number" data-line-number="3400"></td>
+ <td id="LC3400" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// v -> w -> Number</span></td>
+ </tr>
+ <tr>
+ <td id="L3401" class="blob-num js-line-number" data-line-number="3401"></td>
+ <td id="LC3401" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_sucs</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3402" class="blob-num js-line-number" data-line-number="3402"></td>
+ <td id="LC3402" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3403" class="blob-num js-line-number" data-line-number="3403"></td>
+ <td id="LC3403" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// e -> edgeObj</span></td>
+ </tr>
+ <tr>
+ <td id="L3404" class="blob-num js-line-number" data-line-number="3404"></td>
+ <td id="LC3404" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeObjs</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3405" class="blob-num js-line-number" data-line-number="3405"></td>
+ <td id="LC3405" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3406" class="blob-num js-line-number" data-line-number="3406"></td>
+ <td id="LC3406" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// e -> label</span></td>
+ </tr>
+ <tr>
+ <td id="L3407" class="blob-num js-line-number" data-line-number="3407"></td>
+ <td id="LC3407" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3408" class="blob-num js-line-number" data-line-number="3408"></td>
+ <td id="LC3408" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3409" class="blob-num js-line-number" data-line-number="3409"></td>
+ <td id="LC3409" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3410" class="blob-num js-line-number" data-line-number="3410"></td>
+ <td id="LC3410" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* Number of nodes in the graph. Should only be changed by the implementation. */</span></td>
+ </tr>
+ <tr>
+ <td id="L3411" class="blob-num js-line-number" data-line-number="3411"></td>
+ <td id="LC3411" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-smi">_nodeCount</span> <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3412" class="blob-num js-line-number" data-line-number="3412"></td>
+ <td id="LC3412" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3413" class="blob-num js-line-number" data-line-number="3413"></td>
+ <td id="LC3413" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* Number of edges in the graph. Should only be changed by the implementation. */</span></td>
+ </tr>
+ <tr>
+ <td id="L3414" class="blob-num js-line-number" data-line-number="3414"></td>
+ <td id="LC3414" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-smi">_edgeCount</span> <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3415" class="blob-num js-line-number" data-line-number="3415"></td>
+ <td id="LC3415" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3416" class="blob-num js-line-number" data-line-number="3416"></td>
+ <td id="LC3416" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3417" class="blob-num js-line-number" data-line-number="3417"></td>
+ <td id="LC3417" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* === Graph functions ========= */</span></td>
+ </tr>
+ <tr>
+ <td id="L3418" class="blob-num js-line-number" data-line-number="3418"></td>
+ <td id="LC3418" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3419" class="blob-num js-line-number" data-line-number="3419"></td>
+ <td id="LC3419" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">isDirected</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3420" class="blob-num js-line-number" data-line-number="3420"></td>
+ <td id="LC3420" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3421" class="blob-num js-line-number" data-line-number="3421"></td>
+ <td id="LC3421" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3422" class="blob-num js-line-number" data-line-number="3422"></td>
+ <td id="LC3422" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3423" class="blob-num js-line-number" data-line-number="3423"></td>
+ <td id="LC3423" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">isMultigraph</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3424" class="blob-num js-line-number" data-line-number="3424"></td>
+ <td id="LC3424" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_isMultigraph</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3425" class="blob-num js-line-number" data-line-number="3425"></td>
+ <td id="LC3425" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3426" class="blob-num js-line-number" data-line-number="3426"></td>
+ <td id="LC3426" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3427" class="blob-num js-line-number" data-line-number="3427"></td>
+ <td id="LC3427" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">isCompound</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3428" class="blob-num js-line-number" data-line-number="3428"></td>
+ <td id="LC3428" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3429" class="blob-num js-line-number" data-line-number="3429"></td>
+ <td id="LC3429" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3430" class="blob-num js-line-number" data-line-number="3430"></td>
+ <td id="LC3430" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3431" class="blob-num js-line-number" data-line-number="3431"></td>
+ <td id="LC3431" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setGraph</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">label</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3432" class="blob-num js-line-number" data-line-number="3432"></td>
+ <td id="LC3432" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_label</span> <span class="pl-k">=</span> label;</td>
+ </tr>
+ <tr>
+ <td id="L3433" class="blob-num js-line-number" data-line-number="3433"></td>
+ <td id="LC3433" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3434" class="blob-num js-line-number" data-line-number="3434"></td>
+ <td id="LC3434" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3435" class="blob-num js-line-number" data-line-number="3435"></td>
+ <td id="LC3435" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3436" class="blob-num js-line-number" data-line-number="3436"></td>
+ <td id="LC3436" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">graph</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3437" class="blob-num js-line-number" data-line-number="3437"></td>
+ <td id="LC3437" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_label</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3438" class="blob-num js-line-number" data-line-number="3438"></td>
+ <td id="LC3438" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3439" class="blob-num js-line-number" data-line-number="3439"></td>
+ <td id="LC3439" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3440" class="blob-num js-line-number" data-line-number="3440"></td>
+ <td id="LC3440" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3441" class="blob-num js-line-number" data-line-number="3441"></td>
+ <td id="LC3441" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* === Node functions ========== */</span></td>
+ </tr>
+ <tr>
+ <td id="L3442" class="blob-num js-line-number" data-line-number="3442"></td>
+ <td id="LC3442" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3443" class="blob-num js-line-number" data-line-number="3443"></td>
+ <td id="LC3443" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setDefaultNodeLabel</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">newDefault</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3444" class="blob-num js-line-number" data-line-number="3444"></td>
+ <td id="LC3444" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isFunction</span>(newDefault)) {</td>
+ </tr>
+ <tr>
+ <td id="L3445" class="blob-num js-line-number" data-line-number="3445"></td>
+ <td id="LC3445" class="blob-code blob-code-inner js-file-line"> newDefault <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">constant</span>(newDefault);</td>
+ </tr>
+ <tr>
+ <td id="L3446" class="blob-num js-line-number" data-line-number="3446"></td>
+ <td id="LC3446" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3447" class="blob-num js-line-number" data-line-number="3447"></td>
+ <td id="LC3447" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_defaultNodeLabelFn</span> <span class="pl-k">=</span> newDefault;</td>
+ </tr>
+ <tr>
+ <td id="L3448" class="blob-num js-line-number" data-line-number="3448"></td>
+ <td id="LC3448" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3449" class="blob-num js-line-number" data-line-number="3449"></td>
+ <td id="LC3449" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3450" class="blob-num js-line-number" data-line-number="3450"></td>
+ <td id="LC3450" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3451" class="blob-num js-line-number" data-line-number="3451"></td>
+ <td id="LC3451" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">nodeCount</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3452" class="blob-num js-line-number" data-line-number="3452"></td>
+ <td id="LC3452" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_nodeCount</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3453" class="blob-num js-line-number" data-line-number="3453"></td>
+ <td id="LC3453" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3454" class="blob-num js-line-number" data-line-number="3454"></td>
+ <td id="LC3454" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3455" class="blob-num js-line-number" data-line-number="3455"></td>
+ <td id="LC3455" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">nodes</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3456" class="blob-num js-line-number" data-line-number="3456"></td>
+ <td id="LC3456" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">keys</span>(<span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3457" class="blob-num js-line-number" data-line-number="3457"></td>
+ <td id="LC3457" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3458" class="blob-num js-line-number" data-line-number="3458"></td>
+ <td id="LC3458" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3459" class="blob-num js-line-number" data-line-number="3459"></td>
+ <td id="LC3459" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">sources</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3460" class="blob-num js-line-number" data-line-number="3460"></td>
+ <td id="LC3460" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">filter</span>(<span class="pl-v">this</span>.<span class="pl-en">nodes</span>(), <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3461" class="blob-num js-line-number" data-line-number="3461"></td>
+ <td id="LC3461" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">isEmpty</span>(<span class="pl-v">this</span>.<span class="pl-smi">_in</span>[v]);</td>
+ </tr>
+ <tr>
+ <td id="L3462" class="blob-num js-line-number" data-line-number="3462"></td>
+ <td id="LC3462" class="blob-code blob-code-inner js-file-line"> }, <span class="pl-v">this</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3463" class="blob-num js-line-number" data-line-number="3463"></td>
+ <td id="LC3463" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3464" class="blob-num js-line-number" data-line-number="3464"></td>
+ <td id="LC3464" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3465" class="blob-num js-line-number" data-line-number="3465"></td>
+ <td id="LC3465" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">sinks</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3466" class="blob-num js-line-number" data-line-number="3466"></td>
+ <td id="LC3466" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">filter</span>(<span class="pl-v">this</span>.<span class="pl-en">nodes</span>(), <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3467" class="blob-num js-line-number" data-line-number="3467"></td>
+ <td id="LC3467" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">isEmpty</span>(<span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v]);</td>
+ </tr>
+ <tr>
+ <td id="L3468" class="blob-num js-line-number" data-line-number="3468"></td>
+ <td id="LC3468" class="blob-code blob-code-inner js-file-line"> }, <span class="pl-v">this</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3469" class="blob-num js-line-number" data-line-number="3469"></td>
+ <td id="LC3469" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3470" class="blob-num js-line-number" data-line-number="3470"></td>
+ <td id="LC3470" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3471" class="blob-num js-line-number" data-line-number="3471"></td>
+ <td id="LC3471" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setNodes</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">vs</span>, <span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3472" class="blob-num js-line-number" data-line-number="3472"></td>
+ <td id="LC3472" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3473" class="blob-num js-line-number" data-line-number="3473"></td>
+ <td id="LC3473" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(vs, <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3474" class="blob-num js-line-number" data-line-number="3474"></td>
+ <td id="LC3474" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">args</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3475" class="blob-num js-line-number" data-line-number="3475"></td>
+ <td id="LC3475" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setNode</span>(v, value);</td>
+ </tr>
+ <tr>
+ <td id="L3476" class="blob-num js-line-number" data-line-number="3476"></td>
+ <td id="LC3476" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3477" class="blob-num js-line-number" data-line-number="3477"></td>
+ <td id="LC3477" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setNode</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3478" class="blob-num js-line-number" data-line-number="3478"></td>
+ <td id="LC3478" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3479" class="blob-num js-line-number" data-line-number="3479"></td>
+ <td id="LC3479" class="blob-code blob-code-inner js-file-line"> }, <span class="pl-v">this</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3480" class="blob-num js-line-number" data-line-number="3480"></td>
+ <td id="LC3480" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3481" class="blob-num js-line-number" data-line-number="3481"></td>
+ <td id="LC3481" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3482" class="blob-num js-line-number" data-line-number="3482"></td>
+ <td id="LC3482" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3483" class="blob-num js-line-number" data-line-number="3483"></td>
+ <td id="LC3483" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setNode</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3484" class="blob-num js-line-number" data-line-number="3484"></td>
+ <td id="LC3484" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(<span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>, v)) {</td>
+ </tr>
+ <tr>
+ <td id="L3485" class="blob-num js-line-number" data-line-number="3485"></td>
+ <td id="LC3485" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3486" class="blob-num js-line-number" data-line-number="3486"></td>
+ <td id="LC3486" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>[v] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L3487" class="blob-num js-line-number" data-line-number="3487"></td>
+ <td id="LC3487" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3488" class="blob-num js-line-number" data-line-number="3488"></td>
+ <td id="LC3488" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3489" class="blob-num js-line-number" data-line-number="3489"></td>
+ <td id="LC3489" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3490" class="blob-num js-line-number" data-line-number="3490"></td>
+ <td id="LC3490" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3491" class="blob-num js-line-number" data-line-number="3491"></td>
+ <td id="LC3491" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>[v] <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span> <span class="pl-k">?</span> value <span class="pl-k">:</span> <span class="pl-v">this</span>.<span class="pl-en">_defaultNodeLabelFn</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3492" class="blob-num js-line-number" data-line-number="3492"></td>
+ <td id="LC3492" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3493" class="blob-num js-line-number" data-line-number="3493"></td>
+ <td id="LC3493" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_parent</span>[v] <span class="pl-k">=</span> <span class="pl-c1">GRAPH_NODE</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3494" class="blob-num js-line-number" data-line-number="3494"></td>
+ <td id="LC3494" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[v] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3495" class="blob-num js-line-number" data-line-number="3495"></td>
+ <td id="LC3495" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[<span class="pl-c1">GRAPH_NODE</span>][v] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3496" class="blob-num js-line-number" data-line-number="3496"></td>
+ <td id="LC3496" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3497" class="blob-num js-line-number" data-line-number="3497"></td>
+ <td id="LC3497" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_in</span>[v] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3498" class="blob-num js-line-number" data-line-number="3498"></td>
+ <td id="LC3498" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_preds</span>[v] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3499" class="blob-num js-line-number" data-line-number="3499"></td>
+ <td id="LC3499" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3500" class="blob-num js-line-number" data-line-number="3500"></td>
+ <td id="LC3500" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_sucs</span>[v] <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L3501" class="blob-num js-line-number" data-line-number="3501"></td>
+ <td id="LC3501" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">++</span><span class="pl-v">this</span>.<span class="pl-smi">_nodeCount</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3502" class="blob-num js-line-number" data-line-number="3502"></td>
+ <td id="LC3502" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3503" class="blob-num js-line-number" data-line-number="3503"></td>
+ <td id="LC3503" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3504" class="blob-num js-line-number" data-line-number="3504"></td>
+ <td id="LC3504" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3505" class="blob-num js-line-number" data-line-number="3505"></td>
+ <td id="LC3505" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">node</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3506" class="blob-num js-line-number" data-line-number="3506"></td>
+ <td id="LC3506" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3507" class="blob-num js-line-number" data-line-number="3507"></td>
+ <td id="LC3507" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3508" class="blob-num js-line-number" data-line-number="3508"></td>
+ <td id="LC3508" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3509" class="blob-num js-line-number" data-line-number="3509"></td>
+ <td id="LC3509" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">hasNode</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3510" class="blob-num js-line-number" data-line-number="3510"></td>
+ <td id="LC3510" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">has</span>(<span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>, v);</td>
+ </tr>
+ <tr>
+ <td id="L3511" class="blob-num js-line-number" data-line-number="3511"></td>
+ <td id="LC3511" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3512" class="blob-num js-line-number" data-line-number="3512"></td>
+ <td id="LC3512" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3513" class="blob-num js-line-number" data-line-number="3513"></td>
+ <td id="LC3513" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">removeNode</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3514" class="blob-num js-line-number" data-line-number="3514"></td>
+ <td id="LC3514" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> self <span class="pl-k">=</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3515" class="blob-num js-line-number" data-line-number="3515"></td>
+ <td id="LC3515" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(<span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>, v)) {</td>
+ </tr>
+ <tr>
+ <td id="L3516" class="blob-num js-line-number" data-line-number="3516"></td>
+ <td id="LC3516" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">removeEdge</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">e</span>) { <span class="pl-smi">self</span>.<span class="pl-en">removeEdge</span>(<span class="pl-smi">self</span>.<span class="pl-smi">_edgeObjs</span>[e]); };</td>
+ </tr>
+ <tr>
+ <td id="L3517" class="blob-num js-line-number" data-line-number="3517"></td>
+ <td id="LC3517" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_nodes</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3518" class="blob-num js-line-number" data-line-number="3518"></td>
+ <td id="LC3518" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3519" class="blob-num js-line-number" data-line-number="3519"></td>
+ <td id="LC3519" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_removeFromParentsChildList</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3520" class="blob-num js-line-number" data-line-number="3520"></td>
+ <td id="LC3520" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_parent</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3521" class="blob-num js-line-number" data-line-number="3521"></td>
+ <td id="LC3521" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-v">this</span>.<span class="pl-en">children</span>(v), <span class="pl-k">function</span>(<span class="pl-smi">child</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3522" class="blob-num js-line-number" data-line-number="3522"></td>
+ <td id="LC3522" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setParent</span>(child);</td>
+ </tr>
+ <tr>
+ <td id="L3523" class="blob-num js-line-number" data-line-number="3523"></td>
+ <td id="LC3523" class="blob-code blob-code-inner js-file-line"> }, <span class="pl-v">this</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3524" class="blob-num js-line-number" data-line-number="3524"></td>
+ <td id="LC3524" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3525" class="blob-num js-line-number" data-line-number="3525"></td>
+ <td id="LC3525" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3526" class="blob-num js-line-number" data-line-number="3526"></td>
+ <td id="LC3526" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">_</span>.<span class="pl-en">keys</span>(<span class="pl-v">this</span>.<span class="pl-smi">_in</span>[v]), removeEdge);</td>
+ </tr>
+ <tr>
+ <td id="L3527" class="blob-num js-line-number" data-line-number="3527"></td>
+ <td id="LC3527" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_in</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3528" class="blob-num js-line-number" data-line-number="3528"></td>
+ <td id="LC3528" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_preds</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3529" class="blob-num js-line-number" data-line-number="3529"></td>
+ <td id="LC3529" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">_</span>.<span class="pl-en">keys</span>(<span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v]), removeEdge);</td>
+ </tr>
+ <tr>
+ <td id="L3530" class="blob-num js-line-number" data-line-number="3530"></td>
+ <td id="LC3530" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3531" class="blob-num js-line-number" data-line-number="3531"></td>
+ <td id="LC3531" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_sucs</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3532" class="blob-num js-line-number" data-line-number="3532"></td>
+ <td id="LC3532" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">--</span><span class="pl-v">this</span>.<span class="pl-smi">_nodeCount</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3533" class="blob-num js-line-number" data-line-number="3533"></td>
+ <td id="LC3533" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3534" class="blob-num js-line-number" data-line-number="3534"></td>
+ <td id="LC3534" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3535" class="blob-num js-line-number" data-line-number="3535"></td>
+ <td id="LC3535" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3536" class="blob-num js-line-number" data-line-number="3536"></td>
+ <td id="LC3536" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3537" class="blob-num js-line-number" data-line-number="3537"></td>
+ <td id="LC3537" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setParent</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">parent</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3538" class="blob-num js-line-number" data-line-number="3538"></td>
+ <td id="LC3538" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3539" class="blob-num js-line-number" data-line-number="3539"></td>
+ <td id="LC3539" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Cannot set parent in a non-compound graph<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3540" class="blob-num js-line-number" data-line-number="3540"></td>
+ <td id="LC3540" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3541" class="blob-num js-line-number" data-line-number="3541"></td>
+ <td id="LC3541" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3542" class="blob-num js-line-number" data-line-number="3542"></td>
+ <td id="LC3542" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(parent)) {</td>
+ </tr>
+ <tr>
+ <td id="L3543" class="blob-num js-line-number" data-line-number="3543"></td>
+ <td id="LC3543" class="blob-code blob-code-inner js-file-line"> parent <span class="pl-k">=</span> <span class="pl-c1">GRAPH_NODE</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3544" class="blob-num js-line-number" data-line-number="3544"></td>
+ <td id="LC3544" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3545" class="blob-num js-line-number" data-line-number="3545"></td>
+ <td id="LC3545" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Coerce parent to string</span></td>
+ </tr>
+ <tr>
+ <td id="L3546" class="blob-num js-line-number" data-line-number="3546"></td>
+ <td id="LC3546" class="blob-code blob-code-inner js-file-line"> parent <span class="pl-k">+=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3547" class="blob-num js-line-number" data-line-number="3547"></td>
+ <td id="LC3547" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (<span class="pl-k">var</span> ancestor <span class="pl-k">=</span> parent;</td>
+ </tr>
+ <tr>
+ <td id="L3548" class="blob-num js-line-number" data-line-number="3548"></td>
+ <td id="LC3548" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(ancestor);</td>
+ </tr>
+ <tr>
+ <td id="L3549" class="blob-num js-line-number" data-line-number="3549"></td>
+ <td id="LC3549" class="blob-code blob-code-inner js-file-line"> ancestor <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-c1">parent</span>(ancestor)) {</td>
+ </tr>
+ <tr>
+ <td id="L3550" class="blob-num js-line-number" data-line-number="3550"></td>
+ <td id="LC3550" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (ancestor <span class="pl-k">===</span> v) {</td>
+ </tr>
+ <tr>
+ <td id="L3551" class="blob-num js-line-number" data-line-number="3551"></td>
+ <td id="LC3551" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Setting <span class="pl-pds">"</span></span> <span class="pl-k">+</span> parent<span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span> as parent of <span class="pl-pds">"</span></span> <span class="pl-k">+</span> v <span class="p [...]
+ </tr>
+ <tr>
+ <td id="L3552" class="blob-num js-line-number" data-line-number="3552"></td>
+ <td id="LC3552" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span> would create create a cycle<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3553" class="blob-num js-line-number" data-line-number="3553"></td>
+ <td id="LC3553" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3554" class="blob-num js-line-number" data-line-number="3554"></td>
+ <td id="LC3554" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3555" class="blob-num js-line-number" data-line-number="3555"></td>
+ <td id="LC3555" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3556" class="blob-num js-line-number" data-line-number="3556"></td>
+ <td id="LC3556" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setNode</span>(parent);</td>
+ </tr>
+ <tr>
+ <td id="L3557" class="blob-num js-line-number" data-line-number="3557"></td>
+ <td id="LC3557" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3558" class="blob-num js-line-number" data-line-number="3558"></td>
+ <td id="LC3558" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3559" class="blob-num js-line-number" data-line-number="3559"></td>
+ <td id="LC3559" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setNode</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3560" class="blob-num js-line-number" data-line-number="3560"></td>
+ <td id="LC3560" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">_removeFromParentsChildList</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3561" class="blob-num js-line-number" data-line-number="3561"></td>
+ <td id="LC3561" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_parent</span>[v] <span class="pl-k">=</span> parent;</td>
+ </tr>
+ <tr>
+ <td id="L3562" class="blob-num js-line-number" data-line-number="3562"></td>
+ <td id="LC3562" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[parent][v] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3563" class="blob-num js-line-number" data-line-number="3563"></td>
+ <td id="LC3563" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3564" class="blob-num js-line-number" data-line-number="3564"></td>
+ <td id="LC3564" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3565" class="blob-num js-line-number" data-line-number="3565"></td>
+ <td id="LC3565" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3566" class="blob-num js-line-number" data-line-number="3566"></td>
+ <td id="LC3566" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">_removeFromParentsChildList</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3567" class="blob-num js-line-number" data-line-number="3567"></td>
+ <td id="LC3567" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[<span class="pl-v">this</span>.<span class="pl-smi">_parent</span>[v]][v];</td>
+ </tr>
+ <tr>
+ <td id="L3568" class="blob-num js-line-number" data-line-number="3568"></td>
+ <td id="LC3568" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3569" class="blob-num js-line-number" data-line-number="3569"></td>
+ <td id="LC3569" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3570" class="blob-num js-line-number" data-line-number="3570"></td>
+ <td id="LC3570" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">parent</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3571" class="blob-num js-line-number" data-line-number="3571"></td>
+ <td id="LC3571" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3572" class="blob-num js-line-number" data-line-number="3572"></td>
+ <td id="LC3572" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> parent <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_parent</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3573" class="blob-num js-line-number" data-line-number="3573"></td>
+ <td id="LC3573" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (parent <span class="pl-k">!==</span> <span class="pl-c1">GRAPH_NODE</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3574" class="blob-num js-line-number" data-line-number="3574"></td>
+ <td id="LC3574" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> parent;</td>
+ </tr>
+ <tr>
+ <td id="L3575" class="blob-num js-line-number" data-line-number="3575"></td>
+ <td id="LC3575" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3576" class="blob-num js-line-number" data-line-number="3576"></td>
+ <td id="LC3576" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3577" class="blob-num js-line-number" data-line-number="3577"></td>
+ <td id="LC3577" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3578" class="blob-num js-line-number" data-line-number="3578"></td>
+ <td id="LC3578" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3579" class="blob-num js-line-number" data-line-number="3579"></td>
+ <td id="LC3579" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">children</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3580" class="blob-num js-line-number" data-line-number="3580"></td>
+ <td id="LC3580" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(v)) {</td>
+ </tr>
+ <tr>
+ <td id="L3581" class="blob-num js-line-number" data-line-number="3581"></td>
+ <td id="LC3581" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-c1">GRAPH_NODE</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3582" class="blob-num js-line-number" data-line-number="3582"></td>
+ <td id="LC3582" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3583" class="blob-num js-line-number" data-line-number="3583"></td>
+ <td id="LC3583" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3584" class="blob-num js-line-number" data-line-number="3584"></td>
+ <td id="LC3584" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-smi">_isCompound</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3585" class="blob-num js-line-number" data-line-number="3585"></td>
+ <td id="LC3585" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> children <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_children</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3586" class="blob-num js-line-number" data-line-number="3586"></td>
+ <td id="LC3586" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (children) {</td>
+ </tr>
+ <tr>
+ <td id="L3587" class="blob-num js-line-number" data-line-number="3587"></td>
+ <td id="LC3587" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">keys</span>(children);</td>
+ </tr>
+ <tr>
+ <td id="L3588" class="blob-num js-line-number" data-line-number="3588"></td>
+ <td id="LC3588" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3589" class="blob-num js-line-number" data-line-number="3589"></td>
+ <td id="LC3589" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (v <span class="pl-k">===</span> <span class="pl-c1">GRAPH_NODE</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3590" class="blob-num js-line-number" data-line-number="3590"></td>
+ <td id="LC3590" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-en">nodes</span>();</td>
+ </tr>
+ <tr>
+ <td id="L3591" class="blob-num js-line-number" data-line-number="3591"></td>
+ <td id="LC3591" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-v">this</span>.<span class="pl-en">hasNode</span>(v)) {</td>
+ </tr>
+ <tr>
+ <td id="L3592" class="blob-num js-line-number" data-line-number="3592"></td>
+ <td id="LC3592" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L3593" class="blob-num js-line-number" data-line-number="3593"></td>
+ <td id="LC3593" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3594" class="blob-num js-line-number" data-line-number="3594"></td>
+ <td id="LC3594" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3595" class="blob-num js-line-number" data-line-number="3595"></td>
+ <td id="LC3595" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3596" class="blob-num js-line-number" data-line-number="3596"></td>
+ <td id="LC3596" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">predecessors</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3597" class="blob-num js-line-number" data-line-number="3597"></td>
+ <td id="LC3597" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> predsV <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_preds</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3598" class="blob-num js-line-number" data-line-number="3598"></td>
+ <td id="LC3598" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (predsV) {</td>
+ </tr>
+ <tr>
+ <td id="L3599" class="blob-num js-line-number" data-line-number="3599"></td>
+ <td id="LC3599" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">keys</span>(predsV);</td>
+ </tr>
+ <tr>
+ <td id="L3600" class="blob-num js-line-number" data-line-number="3600"></td>
+ <td id="LC3600" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3601" class="blob-num js-line-number" data-line-number="3601"></td>
+ <td id="LC3601" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3602" class="blob-num js-line-number" data-line-number="3602"></td>
+ <td id="LC3602" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3603" class="blob-num js-line-number" data-line-number="3603"></td>
+ <td id="LC3603" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">successors</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3604" class="blob-num js-line-number" data-line-number="3604"></td>
+ <td id="LC3604" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> sucsV <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_sucs</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3605" class="blob-num js-line-number" data-line-number="3605"></td>
+ <td id="LC3605" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (sucsV) {</td>
+ </tr>
+ <tr>
+ <td id="L3606" class="blob-num js-line-number" data-line-number="3606"></td>
+ <td id="LC3606" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">keys</span>(sucsV);</td>
+ </tr>
+ <tr>
+ <td id="L3607" class="blob-num js-line-number" data-line-number="3607"></td>
+ <td id="LC3607" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3608" class="blob-num js-line-number" data-line-number="3608"></td>
+ <td id="LC3608" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3609" class="blob-num js-line-number" data-line-number="3609"></td>
+ <td id="LC3609" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3610" class="blob-num js-line-number" data-line-number="3610"></td>
+ <td id="LC3610" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">neighbors</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3611" class="blob-num js-line-number" data-line-number="3611"></td>
+ <td id="LC3611" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> preds <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-en">predecessors</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3612" class="blob-num js-line-number" data-line-number="3612"></td>
+ <td id="LC3612" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (preds) {</td>
+ </tr>
+ <tr>
+ <td id="L3613" class="blob-num js-line-number" data-line-number="3613"></td>
+ <td id="LC3613" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">union</span>(preds, <span class="pl-v">this</span>.<span class="pl-en">successors</span>(v));</td>
+ </tr>
+ <tr>
+ <td id="L3614" class="blob-num js-line-number" data-line-number="3614"></td>
+ <td id="LC3614" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3615" class="blob-num js-line-number" data-line-number="3615"></td>
+ <td id="LC3615" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3616" class="blob-num js-line-number" data-line-number="3616"></td>
+ <td id="LC3616" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3617" class="blob-num js-line-number" data-line-number="3617"></td>
+ <td id="LC3617" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* === Edge functions ========== */</span></td>
+ </tr>
+ <tr>
+ <td id="L3618" class="blob-num js-line-number" data-line-number="3618"></td>
+ <td id="LC3618" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3619" class="blob-num js-line-number" data-line-number="3619"></td>
+ <td id="LC3619" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setDefaultEdgeLabel</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">newDefault</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3620" class="blob-num js-line-number" data-line-number="3620"></td>
+ <td id="LC3620" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isFunction</span>(newDefault)) {</td>
+ </tr>
+ <tr>
+ <td id="L3621" class="blob-num js-line-number" data-line-number="3621"></td>
+ <td id="LC3621" class="blob-code blob-code-inner js-file-line"> newDefault <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">constant</span>(newDefault);</td>
+ </tr>
+ <tr>
+ <td id="L3622" class="blob-num js-line-number" data-line-number="3622"></td>
+ <td id="LC3622" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3623" class="blob-num js-line-number" data-line-number="3623"></td>
+ <td id="LC3623" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_defaultEdgeLabelFn</span> <span class="pl-k">=</span> newDefault;</td>
+ </tr>
+ <tr>
+ <td id="L3624" class="blob-num js-line-number" data-line-number="3624"></td>
+ <td id="LC3624" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3625" class="blob-num js-line-number" data-line-number="3625"></td>
+ <td id="LC3625" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3626" class="blob-num js-line-number" data-line-number="3626"></td>
+ <td id="LC3626" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3627" class="blob-num js-line-number" data-line-number="3627"></td>
+ <td id="LC3627" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">edgeCount</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3628" class="blob-num js-line-number" data-line-number="3628"></td>
+ <td id="LC3628" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_edgeCount</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3629" class="blob-num js-line-number" data-line-number="3629"></td>
+ <td id="LC3629" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3630" class="blob-num js-line-number" data-line-number="3630"></td>
+ <td id="LC3630" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3631" class="blob-num js-line-number" data-line-number="3631"></td>
+ <td id="LC3631" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">edges</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3632" class="blob-num js-line-number" data-line-number="3632"></td>
+ <td id="LC3632" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">values</span>(<span class="pl-v">this</span>.<span class="pl-smi">_edgeObjs</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3633" class="blob-num js-line-number" data-line-number="3633"></td>
+ <td id="LC3633" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3634" class="blob-num js-line-number" data-line-number="3634"></td>
+ <td id="LC3634" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3635" class="blob-num js-line-number" data-line-number="3635"></td>
+ <td id="LC3635" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setPath</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">vs</span>, <span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3636" class="blob-num js-line-number" data-line-number="3636"></td>
+ <td id="LC3636" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> self <span class="pl-k">=</span> <span class="pl-v">this</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3637" class="blob-num js-line-number" data-line-number="3637"></td>
+ <td id="LC3637" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3638" class="blob-num js-line-number" data-line-number="3638"></td>
+ <td id="LC3638" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">reduce</span>(vs, <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3639" class="blob-num js-line-number" data-line-number="3639"></td>
+ <td id="LC3639" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">args</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3640" class="blob-num js-line-number" data-line-number="3640"></td>
+ <td id="LC3640" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">self</span>.<span class="pl-en">setEdge</span>(v, w, value);</td>
+ </tr>
+ <tr>
+ <td id="L3641" class="blob-num js-line-number" data-line-number="3641"></td>
+ <td id="LC3641" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3642" class="blob-num js-line-number" data-line-number="3642"></td>
+ <td id="LC3642" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">self</span>.<span class="pl-en">setEdge</span>(v, w);</td>
+ </tr>
+ <tr>
+ <td id="L3643" class="blob-num js-line-number" data-line-number="3643"></td>
+ <td id="LC3643" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3644" class="blob-num js-line-number" data-line-number="3644"></td>
+ <td id="LC3644" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> w;</td>
+ </tr>
+ <tr>
+ <td id="L3645" class="blob-num js-line-number" data-line-number="3645"></td>
+ <td id="LC3645" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3646" class="blob-num js-line-number" data-line-number="3646"></td>
+ <td id="LC3646" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3647" class="blob-num js-line-number" data-line-number="3647"></td>
+ <td id="LC3647" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3648" class="blob-num js-line-number" data-line-number="3648"></td>
+ <td id="LC3648" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3649" class="blob-num js-line-number" data-line-number="3649"></td>
+ <td id="LC3649" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/*</span></td>
+ </tr>
+ <tr>
+ <td id="L3650" class="blob-num js-line-number" data-line-number="3650"></td>
+ <td id="LC3650" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * setEdge(v, w, [value, [name]])</span></td>
+ </tr>
+ <tr>
+ <td id="L3651" class="blob-num js-line-number" data-line-number="3651"></td>
+ <td id="LC3651" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * setEdge({ v, w, [name] }, [value])</span></td>
+ </tr>
+ <tr>
+ <td id="L3652" class="blob-num js-line-number" data-line-number="3652"></td>
+ <td id="LC3652" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3653" class="blob-num js-line-number" data-line-number="3653"></td>
+ <td id="LC3653" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">setEdge</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3654" class="blob-num js-line-number" data-line-number="3654"></td>
+ <td id="LC3654" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> v, w, name, value,</td>
+ </tr>
+ <tr>
+ <td id="L3655" class="blob-num js-line-number" data-line-number="3655"></td>
+ <td id="LC3655" class="blob-code blob-code-inner js-file-line"> valueSpecified <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3656" class="blob-num js-line-number" data-line-number="3656"></td>
+ <td id="LC3656" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3657" class="blob-num js-line-number" data-line-number="3657"></td>
+ <td id="LC3657" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">isPlainObject</span>(<span class="pl-v">arguments</span>[<span class="pl-c1">0</span>])) {</td>
+ </tr>
+ <tr>
+ <td id="L3658" class="blob-num js-line-number" data-line-number="3658"></td>
+ <td id="LC3658" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>].<span class="pl-smi">v</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3659" class="blob-num js-line-number" data-line-number="3659"></td>
+ <td id="LC3659" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>].<span class="pl-smi">w</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3660" class="blob-num js-line-number" data-line-number="3660"></td>
+ <td id="LC3660" class="blob-code blob-code-inner js-file-line"> name <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>].<span class="pl-c1">name</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3661" class="blob-num js-line-number" data-line-number="3661"></td>
+ <td id="LC3661" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">===</span> <span class="pl-c1">2</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3662" class="blob-num js-line-number" data-line-number="3662"></td>
+ <td id="LC3662" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">1</span>];</td>
+ </tr>
+ <tr>
+ <td id="L3663" class="blob-num js-line-number" data-line-number="3663"></td>
+ <td id="LC3663" class="blob-code blob-code-inner js-file-line"> valueSpecified <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3664" class="blob-num js-line-number" data-line-number="3664"></td>
+ <td id="LC3664" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3665" class="blob-num js-line-number" data-line-number="3665"></td>
+ <td id="LC3665" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3666" class="blob-num js-line-number" data-line-number="3666"></td>
+ <td id="LC3666" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>];</td>
+ </tr>
+ <tr>
+ <td id="L3667" class="blob-num js-line-number" data-line-number="3667"></td>
+ <td id="LC3667" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">1</span>];</td>
+ </tr>
+ <tr>
+ <td id="L3668" class="blob-num js-line-number" data-line-number="3668"></td>
+ <td id="LC3668" class="blob-code blob-code-inner js-file-line"> name <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">3</span>];</td>
+ </tr>
+ <tr>
+ <td id="L3669" class="blob-num js-line-number" data-line-number="3669"></td>
+ <td id="LC3669" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">2</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3670" class="blob-num js-line-number" data-line-number="3670"></td>
+ <td id="LC3670" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> <span class="pl-v">arguments</span>[<span class="pl-c1">2</span>];</td>
+ </tr>
+ <tr>
+ <td id="L3671" class="blob-num js-line-number" data-line-number="3671"></td>
+ <td id="LC3671" class="blob-code blob-code-inner js-file-line"> valueSpecified <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3672" class="blob-num js-line-number" data-line-number="3672"></td>
+ <td id="LC3672" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3673" class="blob-num js-line-number" data-line-number="3673"></td>
+ <td id="LC3673" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3674" class="blob-num js-line-number" data-line-number="3674"></td>
+ <td id="LC3674" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3675" class="blob-num js-line-number" data-line-number="3675"></td>
+ <td id="LC3675" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> v;</td>
+ </tr>
+ <tr>
+ <td id="L3676" class="blob-num js-line-number" data-line-number="3676"></td>
+ <td id="LC3676" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> w;</td>
+ </tr>
+ <tr>
+ <td id="L3677" class="blob-num js-line-number" data-line-number="3677"></td>
+ <td id="LC3677" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(name)) {</td>
+ </tr>
+ <tr>
+ <td id="L3678" class="blob-num js-line-number" data-line-number="3678"></td>
+ <td id="LC3678" class="blob-code blob-code-inner js-file-line"> name <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> name;</td>
+ </tr>
+ <tr>
+ <td id="L3679" class="blob-num js-line-number" data-line-number="3679"></td>
+ <td id="LC3679" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3680" class="blob-num js-line-number" data-line-number="3680"></td>
+ <td id="LC3680" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3681" class="blob-num js-line-number" data-line-number="3681"></td>
+ <td id="LC3681" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> e <span class="pl-k">=</span> <span class="pl-en">edgeArgsToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, v, w, name);</td>
+ </tr>
+ <tr>
+ <td id="L3682" class="blob-num js-line-number" data-line-number="3682"></td>
+ <td id="LC3682" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(<span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span>, e)) {</td>
+ </tr>
+ <tr>
+ <td id="L3683" class="blob-num js-line-number" data-line-number="3683"></td>
+ <td id="LC3683" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (valueSpecified) {</td>
+ </tr>
+ <tr>
+ <td id="L3684" class="blob-num js-line-number" data-line-number="3684"></td>
+ <td id="LC3684" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span>[e] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L3685" class="blob-num js-line-number" data-line-number="3685"></td>
+ <td id="LC3685" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3686" class="blob-num js-line-number" data-line-number="3686"></td>
+ <td id="LC3686" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3687" class="blob-num js-line-number" data-line-number="3687"></td>
+ <td id="LC3687" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3688" class="blob-num js-line-number" data-line-number="3688"></td>
+ <td id="LC3688" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3689" class="blob-num js-line-number" data-line-number="3689"></td>
+ <td id="LC3689" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(name) <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-v">this</span>.<span class="pl-smi">_isMultigraph</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3690" class="blob-num js-line-number" data-line-number="3690"></td>
+ <td id="LC3690" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">Error</span>(<span class="pl-s"><span class="pl-pds">"</span>Cannot set a named edge when isMultigraph = false<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3691" class="blob-num js-line-number" data-line-number="3691"></td>
+ <td id="LC3691" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3692" class="blob-num js-line-number" data-line-number="3692"></td>
+ <td id="LC3692" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3693" class="blob-num js-line-number" data-line-number="3693"></td>
+ <td id="LC3693" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// It didn't exist, so we need to create it.</span></td>
+ </tr>
+ <tr>
+ <td id="L3694" class="blob-num js-line-number" data-line-number="3694"></td>
+ <td id="LC3694" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// First ensure the nodes exist.</span></td>
+ </tr>
+ <tr>
+ <td id="L3695" class="blob-num js-line-number" data-line-number="3695"></td>
+ <td id="LC3695" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setNode</span>(v);</td>
+ </tr>
+ <tr>
+ <td id="L3696" class="blob-num js-line-number" data-line-number="3696"></td>
+ <td id="LC3696" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-en">setNode</span>(w);</td>
+ </tr>
+ <tr>
+ <td id="L3697" class="blob-num js-line-number" data-line-number="3697"></td>
+ <td id="LC3697" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3698" class="blob-num js-line-number" data-line-number="3698"></td>
+ <td id="LC3698" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span>[e] <span class="pl-k">=</span> valueSpecified <span class="pl-k">?</span> value <span class="pl-k">:</span> <span class="pl-v">this</span>.<span class="pl-en">_defaultEdgeLabelFn</span>(v, w, name);</td>
+ </tr>
+ <tr>
+ <td id="L3699" class="blob-num js-line-number" data-line-number="3699"></td>
+ <td id="LC3699" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3700" class="blob-num js-line-number" data-line-number="3700"></td>
+ <td id="LC3700" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> edgeObj <span class="pl-k">=</span> <span class="pl-en">edgeArgsToObj</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, v, w, name);</td>
+ </tr>
+ <tr>
+ <td id="L3701" class="blob-num js-line-number" data-line-number="3701"></td>
+ <td id="LC3701" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Ensure we add undirected edges in a consistent way.</span></td>
+ </tr>
+ <tr>
+ <td id="L3702" class="blob-num js-line-number" data-line-number="3702"></td>
+ <td id="LC3702" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-smi">edgeObj</span>.<span class="pl-smi">v</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3703" class="blob-num js-line-number" data-line-number="3703"></td>
+ <td id="LC3703" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-smi">edgeObj</span>.<span class="pl-smi">w</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3704" class="blob-num js-line-number" data-line-number="3704"></td>
+ <td id="LC3704" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3705" class="blob-num js-line-number" data-line-number="3705"></td>
+ <td id="LC3705" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Object</span>.<span class="pl-en">freeze</span>(edgeObj);</td>
+ </tr>
+ <tr>
+ <td id="L3706" class="blob-num js-line-number" data-line-number="3706"></td>
+ <td id="LC3706" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeObjs</span>[e] <span class="pl-k">=</span> edgeObj;</td>
+ </tr>
+ <tr>
+ <td id="L3707" class="blob-num js-line-number" data-line-number="3707"></td>
+ <td id="LC3707" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">incrementOrInitEntry</span>(<span class="pl-v">this</span>.<span class="pl-smi">_preds</span>[w], v);</td>
+ </tr>
+ <tr>
+ <td id="L3708" class="blob-num js-line-number" data-line-number="3708"></td>
+ <td id="LC3708" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">incrementOrInitEntry</span>(<span class="pl-v">this</span>.<span class="pl-smi">_sucs</span>[v], w);</td>
+ </tr>
+ <tr>
+ <td id="L3709" class="blob-num js-line-number" data-line-number="3709"></td>
+ <td id="LC3709" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_in</span>[w][e] <span class="pl-k">=</span> edgeObj;</td>
+ </tr>
+ <tr>
+ <td id="L3710" class="blob-num js-line-number" data-line-number="3710"></td>
+ <td id="LC3710" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v][e] <span class="pl-k">=</span> edgeObj;</td>
+ </tr>
+ <tr>
+ <td id="L3711" class="blob-num js-line-number" data-line-number="3711"></td>
+ <td id="LC3711" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeCount</span><span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3712" class="blob-num js-line-number" data-line-number="3712"></td>
+ <td id="LC3712" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3713" class="blob-num js-line-number" data-line-number="3713"></td>
+ <td id="LC3713" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3714" class="blob-num js-line-number" data-line-number="3714"></td>
+ <td id="LC3714" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3715" class="blob-num js-line-number" data-line-number="3715"></td>
+ <td id="LC3715" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">edge</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">w</span>, <span class="pl-smi">name</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3716" class="blob-num js-line-number" data-line-number="3716"></td>
+ <td id="LC3716" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> e <span class="pl-k">=</span> (<span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">===</span> <span class="pl-c1">1</span></td>
+ </tr>
+ <tr>
+ <td id="L3717" class="blob-num js-line-number" data-line-number="3717"></td>
+ <td id="LC3717" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-en">edgeObjToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>])</td>
+ </tr>
+ <tr>
+ <td id="L3718" class="blob-num js-line-number" data-line-number="3718"></td>
+ <td id="LC3718" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">edgeArgsToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, v, w, name));</td>
+ </tr>
+ <tr>
+ <td id="L3719" class="blob-num js-line-number" data-line-number="3719"></td>
+ <td id="LC3719" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span>[e];</td>
+ </tr>
+ <tr>
+ <td id="L3720" class="blob-num js-line-number" data-line-number="3720"></td>
+ <td id="LC3720" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3721" class="blob-num js-line-number" data-line-number="3721"></td>
+ <td id="LC3721" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3722" class="blob-num js-line-number" data-line-number="3722"></td>
+ <td id="LC3722" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">hasEdge</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">w</span>, <span class="pl-smi">name</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3723" class="blob-num js-line-number" data-line-number="3723"></td>
+ <td id="LC3723" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> e <span class="pl-k">=</span> (<span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">===</span> <span class="pl-c1">1</span></td>
+ </tr>
+ <tr>
+ <td id="L3724" class="blob-num js-line-number" data-line-number="3724"></td>
+ <td id="LC3724" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-en">edgeObjToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>])</td>
+ </tr>
+ <tr>
+ <td id="L3725" class="blob-num js-line-number" data-line-number="3725"></td>
+ <td id="LC3725" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">edgeArgsToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, v, w, name));</td>
+ </tr>
+ <tr>
+ <td id="L3726" class="blob-num js-line-number" data-line-number="3726"></td>
+ <td id="LC3726" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">has</span>(<span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span>, e);</td>
+ </tr>
+ <tr>
+ <td id="L3727" class="blob-num js-line-number" data-line-number="3727"></td>
+ <td id="LC3727" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3728" class="blob-num js-line-number" data-line-number="3728"></td>
+ <td id="LC3728" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3729" class="blob-num js-line-number" data-line-number="3729"></td>
+ <td id="LC3729" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">removeEdge</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">w</span>, <span class="pl-smi">name</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3730" class="blob-num js-line-number" data-line-number="3730"></td>
+ <td id="LC3730" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> e <span class="pl-k">=</span> (<span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">===</span> <span class="pl-c1">1</span></td>
+ </tr>
+ <tr>
+ <td id="L3731" class="blob-num js-line-number" data-line-number="3731"></td>
+ <td id="LC3731" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-en">edgeObjToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>])</td>
+ </tr>
+ <tr>
+ <td id="L3732" class="blob-num js-line-number" data-line-number="3732"></td>
+ <td id="LC3732" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">edgeArgsToId</span>(<span class="pl-v">this</span>.<span class="pl-smi">_isDirected</span>, v, w, name)),</td>
+ </tr>
+ <tr>
+ <td id="L3733" class="blob-num js-line-number" data-line-number="3733"></td>
+ <td id="LC3733" class="blob-code blob-code-inner js-file-line"> edge <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_edgeObjs</span>[e];</td>
+ </tr>
+ <tr>
+ <td id="L3734" class="blob-num js-line-number" data-line-number="3734"></td>
+ <td id="LC3734" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (edge) {</td>
+ </tr>
+ <tr>
+ <td id="L3735" class="blob-num js-line-number" data-line-number="3735"></td>
+ <td id="LC3735" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3736" class="blob-num js-line-number" data-line-number="3736"></td>
+ <td id="LC3736" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> <span class="pl-smi">edge</span>.<span class="pl-smi">w</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3737" class="blob-num js-line-number" data-line-number="3737"></td>
+ <td id="LC3737" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_edgeLabels</span>[e];</td>
+ </tr>
+ <tr>
+ <td id="L3738" class="blob-num js-line-number" data-line-number="3738"></td>
+ <td id="LC3738" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_edgeObjs</span>[e];</td>
+ </tr>
+ <tr>
+ <td id="L3739" class="blob-num js-line-number" data-line-number="3739"></td>
+ <td id="LC3739" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">decrementOrRemoveEntry</span>(<span class="pl-v">this</span>.<span class="pl-smi">_preds</span>[w], v);</td>
+ </tr>
+ <tr>
+ <td id="L3740" class="blob-num js-line-number" data-line-number="3740"></td>
+ <td id="LC3740" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">decrementOrRemoveEntry</span>(<span class="pl-v">this</span>.<span class="pl-smi">_sucs</span>[v], w);</td>
+ </tr>
+ <tr>
+ <td id="L3741" class="blob-num js-line-number" data-line-number="3741"></td>
+ <td id="LC3741" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_in</span>[w][e];</td>
+ </tr>
+ <tr>
+ <td id="L3742" class="blob-num js-line-number" data-line-number="3742"></td>
+ <td id="LC3742" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">delete</span> <span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v][e];</td>
+ </tr>
+ <tr>
+ <td id="L3743" class="blob-num js-line-number" data-line-number="3743"></td>
+ <td id="LC3743" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">_edgeCount</span><span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3744" class="blob-num js-line-number" data-line-number="3744"></td>
+ <td id="LC3744" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3745" class="blob-num js-line-number" data-line-number="3745"></td>
+ <td id="LC3745" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3746" class="blob-num js-line-number" data-line-number="3746"></td>
+ <td id="LC3746" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3747" class="blob-num js-line-number" data-line-number="3747"></td>
+ <td id="LC3747" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3748" class="blob-num js-line-number" data-line-number="3748"></td>
+ <td id="LC3748" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">inEdges</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">u</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3749" class="blob-num js-line-number" data-line-number="3749"></td>
+ <td id="LC3749" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> inV <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_in</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3750" class="blob-num js-line-number" data-line-number="3750"></td>
+ <td id="LC3750" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (inV) {</td>
+ </tr>
+ <tr>
+ <td id="L3751" class="blob-num js-line-number" data-line-number="3751"></td>
+ <td id="LC3751" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> edges <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">values</span>(inV);</td>
+ </tr>
+ <tr>
+ <td id="L3752" class="blob-num js-line-number" data-line-number="3752"></td>
+ <td id="LC3752" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>u) {</td>
+ </tr>
+ <tr>
+ <td id="L3753" class="blob-num js-line-number" data-line-number="3753"></td>
+ <td id="LC3753" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> edges;</td>
+ </tr>
+ <tr>
+ <td id="L3754" class="blob-num js-line-number" data-line-number="3754"></td>
+ <td id="LC3754" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3755" class="blob-num js-line-number" data-line-number="3755"></td>
+ <td id="LC3755" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">filter</span>(edges, <span class="pl-k">function</span>(<span class="pl-smi">edge</span>) { <span class="pl-k">return</span> <span class="pl-smi">edge</span>.<span class="pl-smi">v</span> <span class="pl-k">===</span> u; });</td>
+ </tr>
+ <tr>
+ <td id="L3756" class="blob-num js-line-number" data-line-number="3756"></td>
+ <td id="LC3756" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3757" class="blob-num js-line-number" data-line-number="3757"></td>
+ <td id="LC3757" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3758" class="blob-num js-line-number" data-line-number="3758"></td>
+ <td id="LC3758" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3759" class="blob-num js-line-number" data-line-number="3759"></td>
+ <td id="LC3759" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">outEdges</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3760" class="blob-num js-line-number" data-line-number="3760"></td>
+ <td id="LC3760" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> outV <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">_out</span>[v];</td>
+ </tr>
+ <tr>
+ <td id="L3761" class="blob-num js-line-number" data-line-number="3761"></td>
+ <td id="LC3761" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (outV) {</td>
+ </tr>
+ <tr>
+ <td id="L3762" class="blob-num js-line-number" data-line-number="3762"></td>
+ <td id="LC3762" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> edges <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">values</span>(outV);</td>
+ </tr>
+ <tr>
+ <td id="L3763" class="blob-num js-line-number" data-line-number="3763"></td>
+ <td id="LC3763" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>w) {</td>
+ </tr>
+ <tr>
+ <td id="L3764" class="blob-num js-line-number" data-line-number="3764"></td>
+ <td id="LC3764" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> edges;</td>
+ </tr>
+ <tr>
+ <td id="L3765" class="blob-num js-line-number" data-line-number="3765"></td>
+ <td id="LC3765" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3766" class="blob-num js-line-number" data-line-number="3766"></td>
+ <td id="LC3766" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">filter</span>(edges, <span class="pl-k">function</span>(<span class="pl-smi">edge</span>) { <span class="pl-k">return</span> <span class="pl-smi">edge</span>.<span class="pl-smi">w</span> <span class="pl-k">===</span> w; });</td>
+ </tr>
+ <tr>
+ <td id="L3767" class="blob-num js-line-number" data-line-number="3767"></td>
+ <td id="LC3767" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3768" class="blob-num js-line-number" data-line-number="3768"></td>
+ <td id="LC3768" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3769" class="blob-num js-line-number" data-line-number="3769"></td>
+ <td id="LC3769" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3770" class="blob-num js-line-number" data-line-number="3770"></td>
+ <td id="LC3770" class="blob-code blob-code-inner js-file-line"><span class="pl-smi">Graph</span>.<span class="pl-c1">prototype</span>.<span class="pl-en">nodeEdges</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">v</span>, <span class="pl-smi">w</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3771" class="blob-num js-line-number" data-line-number="3771"></td>
+ <td id="LC3771" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> inEdges <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-en">inEdges</span>(v, w);</td>
+ </tr>
+ <tr>
+ <td id="L3772" class="blob-num js-line-number" data-line-number="3772"></td>
+ <td id="LC3772" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (inEdges) {</td>
+ </tr>
+ <tr>
+ <td id="L3773" class="blob-num js-line-number" data-line-number="3773"></td>
+ <td id="LC3773" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">inEdges</span>.<span class="pl-c1">concat</span>(<span class="pl-v">this</span>.<span class="pl-en">outEdges</span>(v, w));</td>
+ </tr>
+ <tr>
+ <td id="L3774" class="blob-num js-line-number" data-line-number="3774"></td>
+ <td id="LC3774" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3775" class="blob-num js-line-number" data-line-number="3775"></td>
+ <td id="LC3775" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3776" class="blob-num js-line-number" data-line-number="3776"></td>
+ <td id="LC3776" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3777" class="blob-num js-line-number" data-line-number="3777"></td>
+ <td id="LC3777" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">incrementOrInitEntry</span>(<span class="pl-smi">map</span>, <span class="pl-smi">k</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3778" class="blob-num js-line-number" data-line-number="3778"></td>
+ <td id="LC3778" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">_</span>.<span class="pl-en">has</span>(map, k)) {</td>
+ </tr>
+ <tr>
+ <td id="L3779" class="blob-num js-line-number" data-line-number="3779"></td>
+ <td id="LC3779" class="blob-code blob-code-inner js-file-line"> map[k]<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3780" class="blob-num js-line-number" data-line-number="3780"></td>
+ <td id="LC3780" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3781" class="blob-num js-line-number" data-line-number="3781"></td>
+ <td id="LC3781" class="blob-code blob-code-inner js-file-line"> map[k] <span class="pl-k">=</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3782" class="blob-num js-line-number" data-line-number="3782"></td>
+ <td id="LC3782" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3783" class="blob-num js-line-number" data-line-number="3783"></td>
+ <td id="LC3783" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3784" class="blob-num js-line-number" data-line-number="3784"></td>
+ <td id="LC3784" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3785" class="blob-num js-line-number" data-line-number="3785"></td>
+ <td id="LC3785" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">decrementOrRemoveEntry</span>(<span class="pl-smi">map</span>, <span class="pl-smi">k</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3786" class="blob-num js-line-number" data-line-number="3786"></td>
+ <td id="LC3786" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-k">--</span>map[k]) { <span class="pl-k">delete</span> map[k]; }</td>
+ </tr>
+ <tr>
+ <td id="L3787" class="blob-num js-line-number" data-line-number="3787"></td>
+ <td id="LC3787" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3788" class="blob-num js-line-number" data-line-number="3788"></td>
+ <td id="LC3788" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3789" class="blob-num js-line-number" data-line-number="3789"></td>
+ <td id="LC3789" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">edgeArgsToId</span>(<span class="pl-smi">isDirected</span>, <span class="pl-smi">v</span>, <span class="pl-smi">w</span>, <span class="pl-smi">name</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3790" class="blob-num js-line-number" data-line-number="3790"></td>
+ <td id="LC3790" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isDirected <span class="pl-k">&&</span> v <span class="pl-k">></span> w) {</td>
+ </tr>
+ <tr>
+ <td id="L3791" class="blob-num js-line-number" data-line-number="3791"></td>
+ <td id="LC3791" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> tmp <span class="pl-k">=</span> v;</td>
+ </tr>
+ <tr>
+ <td id="L3792" class="blob-num js-line-number" data-line-number="3792"></td>
+ <td id="LC3792" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> w;</td>
+ </tr>
+ <tr>
+ <td id="L3793" class="blob-num js-line-number" data-line-number="3793"></td>
+ <td id="LC3793" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> tmp;</td>
+ </tr>
+ <tr>
+ <td id="L3794" class="blob-num js-line-number" data-line-number="3794"></td>
+ <td id="LC3794" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3795" class="blob-num js-line-number" data-line-number="3795"></td>
+ <td id="LC3795" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> v <span class="pl-k">+</span> <span class="pl-c1">EDGE_KEY_DELIM</span> <span class="pl-k">+</span> w <span class="pl-k">+</span> <span class="pl-c1">EDGE_KEY_DELIM</span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L3796" class="blob-num js-line-number" data-line-number="3796"></td>
+ <td id="LC3796" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(name) <span class="pl-k">?</span> <span class="pl-c1">DEFAULT_EDGE_NAME</span> <span class="pl-k">:</span> name);</td>
+ </tr>
+ <tr>
+ <td id="L3797" class="blob-num js-line-number" data-line-number="3797"></td>
+ <td id="LC3797" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3798" class="blob-num js-line-number" data-line-number="3798"></td>
+ <td id="LC3798" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3799" class="blob-num js-line-number" data-line-number="3799"></td>
+ <td id="LC3799" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">edgeArgsToObj</span>(<span class="pl-smi">isDirected</span>, <span class="pl-smi">v</span>, <span class="pl-smi">w</span>, <span class="pl-smi">name</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3800" class="blob-num js-line-number" data-line-number="3800"></td>
+ <td id="LC3800" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isDirected <span class="pl-k">&&</span> v <span class="pl-k">></span> w) {</td>
+ </tr>
+ <tr>
+ <td id="L3801" class="blob-num js-line-number" data-line-number="3801"></td>
+ <td id="LC3801" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> tmp <span class="pl-k">=</span> v;</td>
+ </tr>
+ <tr>
+ <td id="L3802" class="blob-num js-line-number" data-line-number="3802"></td>
+ <td id="LC3802" class="blob-code blob-code-inner js-file-line"> v <span class="pl-k">=</span> w;</td>
+ </tr>
+ <tr>
+ <td id="L3803" class="blob-num js-line-number" data-line-number="3803"></td>
+ <td id="LC3803" class="blob-code blob-code-inner js-file-line"> w <span class="pl-k">=</span> tmp;</td>
+ </tr>
+ <tr>
+ <td id="L3804" class="blob-num js-line-number" data-line-number="3804"></td>
+ <td id="LC3804" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3805" class="blob-num js-line-number" data-line-number="3805"></td>
+ <td id="LC3805" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> edgeObj <span class="pl-k">=</span> { v<span class="pl-k">:</span> v, w<span class="pl-k">:</span> w };</td>
+ </tr>
+ <tr>
+ <td id="L3806" class="blob-num js-line-number" data-line-number="3806"></td>
+ <td id="LC3806" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (name) {</td>
+ </tr>
+ <tr>
+ <td id="L3807" class="blob-num js-line-number" data-line-number="3807"></td>
+ <td id="LC3807" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">edgeObj</span>.<span class="pl-c1">name</span> <span class="pl-k">=</span> name;</td>
+ </tr>
+ <tr>
+ <td id="L3808" class="blob-num js-line-number" data-line-number="3808"></td>
+ <td id="LC3808" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3809" class="blob-num js-line-number" data-line-number="3809"></td>
+ <td id="LC3809" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> edgeObj;</td>
+ </tr>
+ <tr>
+ <td id="L3810" class="blob-num js-line-number" data-line-number="3810"></td>
+ <td id="LC3810" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3811" class="blob-num js-line-number" data-line-number="3811"></td>
+ <td id="LC3811" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3812" class="blob-num js-line-number" data-line-number="3812"></td>
+ <td id="LC3812" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">edgeObjToId</span>(<span class="pl-smi">isDirected</span>, <span class="pl-smi">edgeObj</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3813" class="blob-num js-line-number" data-line-number="3813"></td>
+ <td id="LC3813" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">edgeArgsToId</span>(isDirected, <span class="pl-smi">edgeObj</span>.<span class="pl-smi">v</span>, <span class="pl-smi">edgeObj</span>.<span class="pl-smi">w</span>, <span class="pl-smi">edgeObj</span>.<span class="pl-c1">name</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3814" class="blob-num js-line-number" data-line-number="3814"></td>
+ <td id="LC3814" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3815" class="blob-num js-line-number" data-line-number="3815"></td>
+ <td id="LC3815" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3816" class="blob-num js-line-number" data-line-number="3816"></td>
+ <td id="LC3816" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">27</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3817" class="blob-num js-line-number" data-line-number="3817"></td>
+ <td id="LC3817" class="blob-code blob-code-inner js-file-line"><span class="pl-c">// Includes only the "core" of graphlib</span></td>
+ </tr>
+ <tr>
+ <td id="L3818" class="blob-num js-line-number" data-line-number="3818"></td>
+ <td id="LC3818" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3819" class="blob-num js-line-number" data-line-number="3819"></td>
+ <td id="LC3819" class="blob-code blob-code-inner js-file-line"> Graph<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./graph<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3820" class="blob-num js-line-number" data-line-number="3820"></td>
+ <td id="LC3820" class="blob-code blob-code-inner js-file-line"> version<span class="pl-k">:</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./version<span class="pl-pds">"</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L3821" class="blob-num js-line-number" data-line-number="3821"></td>
+ <td id="LC3821" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3822" class="blob-num js-line-number" data-line-number="3822"></td>
+ <td id="LC3822" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3823" class="blob-num js-line-number" data-line-number="3823"></td>
+ <td id="LC3823" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./graph<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">26</span>,<span class="pl-s"><span class="pl-pds">"</span>./version<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">30</span>}],<span class="pl-c1">28</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span [...]
+ </tr>
+ <tr>
+ <td id="L3824" class="blob-num js-line-number" data-line-number="3824"></td>
+ <td id="LC3824" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L3825" class="blob-num js-line-number" data-line-number="3825"></td>
+ <td id="LC3825" class="blob-code blob-code-inner js-file-line"> Graph <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>./graph<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3826" class="blob-num js-line-number" data-line-number="3826"></td>
+ <td id="LC3826" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3827" class="blob-num js-line-number" data-line-number="3827"></td>
+ <td id="LC3827" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3828" class="blob-num js-line-number" data-line-number="3828"></td>
+ <td id="LC3828" class="blob-code blob-code-inner js-file-line"> write<span class="pl-k">:</span> write,</td>
+ </tr>
+ <tr>
+ <td id="L3829" class="blob-num js-line-number" data-line-number="3829"></td>
+ <td id="LC3829" class="blob-code blob-code-inner js-file-line"> read<span class="pl-k">:</span> read</td>
+ </tr>
+ <tr>
+ <td id="L3830" class="blob-num js-line-number" data-line-number="3830"></td>
+ <td id="LC3830" class="blob-code blob-code-inner js-file-line">};</td>
+ </tr>
+ <tr>
+ <td id="L3831" class="blob-num js-line-number" data-line-number="3831"></td>
+ <td id="LC3831" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3832" class="blob-num js-line-number" data-line-number="3832"></td>
+ <td id="LC3832" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">write</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3833" class="blob-num js-line-number" data-line-number="3833"></td>
+ <td id="LC3833" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> json <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3834" class="blob-num js-line-number" data-line-number="3834"></td>
+ <td id="LC3834" class="blob-code blob-code-inner js-file-line"> options<span class="pl-k">:</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3835" class="blob-num js-line-number" data-line-number="3835"></td>
+ <td id="LC3835" class="blob-code blob-code-inner js-file-line"> directed<span class="pl-k">:</span> <span class="pl-smi">g</span>.<span class="pl-en">isDirected</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L3836" class="blob-num js-line-number" data-line-number="3836"></td>
+ <td id="LC3836" class="blob-code blob-code-inner js-file-line"> multigraph<span class="pl-k">:</span> <span class="pl-smi">g</span>.<span class="pl-en">isMultigraph</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L3837" class="blob-num js-line-number" data-line-number="3837"></td>
+ <td id="LC3837" class="blob-code blob-code-inner js-file-line"> compound<span class="pl-k">:</span> <span class="pl-smi">g</span>.<span class="pl-en">isCompound</span>()</td>
+ </tr>
+ <tr>
+ <td id="L3838" class="blob-num js-line-number" data-line-number="3838"></td>
+ <td id="LC3838" class="blob-code blob-code-inner js-file-line"> },</td>
+ </tr>
+ <tr>
+ <td id="L3839" class="blob-num js-line-number" data-line-number="3839"></td>
+ <td id="LC3839" class="blob-code blob-code-inner js-file-line"> nodes<span class="pl-k">:</span> <span class="pl-en">writeNodes</span>(g),</td>
+ </tr>
+ <tr>
+ <td id="L3840" class="blob-num js-line-number" data-line-number="3840"></td>
+ <td id="LC3840" class="blob-code blob-code-inner js-file-line"> edges<span class="pl-k">:</span> <span class="pl-en">writeEdges</span>(g)</td>
+ </tr>
+ <tr>
+ <td id="L3841" class="blob-num js-line-number" data-line-number="3841"></td>
+ <td id="LC3841" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L3842" class="blob-num js-line-number" data-line-number="3842"></td>
+ <td id="LC3842" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(<span class="pl-smi">g</span>.<span class="pl-en">graph</span>())) {</td>
+ </tr>
+ <tr>
+ <td id="L3843" class="blob-num js-line-number" data-line-number="3843"></td>
+ <td id="LC3843" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">json</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> <span class="pl-smi">_</span>.<span class="pl-en">clone</span>(<span class="pl-smi">g</span>.<span class="pl-en">graph</span>());</td>
+ </tr>
+ <tr>
+ <td id="L3844" class="blob-num js-line-number" data-line-number="3844"></td>
+ <td id="LC3844" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3845" class="blob-num js-line-number" data-line-number="3845"></td>
+ <td id="LC3845" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> json;</td>
+ </tr>
+ <tr>
+ <td id="L3846" class="blob-num js-line-number" data-line-number="3846"></td>
+ <td id="LC3846" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3847" class="blob-num js-line-number" data-line-number="3847"></td>
+ <td id="LC3847" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3848" class="blob-num js-line-number" data-line-number="3848"></td>
+ <td id="LC3848" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeNodes</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3849" class="blob-num js-line-number" data-line-number="3849"></td>
+ <td id="LC3849" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">map</span>(<span class="pl-smi">g</span>.<span class="pl-en">nodes</span>(), <span class="pl-k">function</span>(<span class="pl-smi">v</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3850" class="blob-num js-line-number" data-line-number="3850"></td>
+ <td id="LC3850" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> nodeValue <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">node</span>(v),</td>
+ </tr>
+ <tr>
+ <td id="L3851" class="blob-num js-line-number" data-line-number="3851"></td>
+ <td id="LC3851" class="blob-code blob-code-inner js-file-line"> parent <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-c1">parent</span>(v),</td>
+ </tr>
+ <tr>
+ <td id="L3852" class="blob-num js-line-number" data-line-number="3852"></td>
+ <td id="LC3852" class="blob-code blob-code-inner js-file-line"> node <span class="pl-k">=</span> { v<span class="pl-k">:</span> v };</td>
+ </tr>
+ <tr>
+ <td id="L3853" class="blob-num js-line-number" data-line-number="3853"></td>
+ <td id="LC3853" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(nodeValue)) {</td>
+ </tr>
+ <tr>
+ <td id="L3854" class="blob-num js-line-number" data-line-number="3854"></td>
+ <td id="LC3854" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">node</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> nodeValue;</td>
+ </tr>
+ <tr>
+ <td id="L3855" class="blob-num js-line-number" data-line-number="3855"></td>
+ <td id="LC3855" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3856" class="blob-num js-line-number" data-line-number="3856"></td>
+ <td id="LC3856" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(parent)) {</td>
+ </tr>
+ <tr>
+ <td id="L3857" class="blob-num js-line-number" data-line-number="3857"></td>
+ <td id="LC3857" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">node</span>.<span class="pl-c1">parent</span> <span class="pl-k">=</span> parent;</td>
+ </tr>
+ <tr>
+ <td id="L3858" class="blob-num js-line-number" data-line-number="3858"></td>
+ <td id="LC3858" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3859" class="blob-num js-line-number" data-line-number="3859"></td>
+ <td id="LC3859" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> node;</td>
+ </tr>
+ <tr>
+ <td id="L3860" class="blob-num js-line-number" data-line-number="3860"></td>
+ <td id="LC3860" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3861" class="blob-num js-line-number" data-line-number="3861"></td>
+ <td id="LC3861" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3862" class="blob-num js-line-number" data-line-number="3862"></td>
+ <td id="LC3862" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3863" class="blob-num js-line-number" data-line-number="3863"></td>
+ <td id="LC3863" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">writeEdges</span>(<span class="pl-smi">g</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3864" class="blob-num js-line-number" data-line-number="3864"></td>
+ <td id="LC3864" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">_</span>.<span class="pl-en">map</span>(<span class="pl-smi">g</span>.<span class="pl-en">edges</span>(), <span class="pl-k">function</span>(<span class="pl-smi">e</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3865" class="blob-num js-line-number" data-line-number="3865"></td>
+ <td id="LC3865" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> edgeValue <span class="pl-k">=</span> <span class="pl-smi">g</span>.<span class="pl-en">edge</span>(e),</td>
+ </tr>
+ <tr>
+ <td id="L3866" class="blob-num js-line-number" data-line-number="3866"></td>
+ <td id="LC3866" class="blob-code blob-code-inner js-file-line"> edge <span class="pl-k">=</span> { v<span class="pl-k">:</span> <span class="pl-smi">e</span>.<span class="pl-smi">v</span>, w<span class="pl-k">:</span> <span class="pl-smi">e</span>.<span class="pl-smi">w</span> };</td>
+ </tr>
+ <tr>
+ <td id="L3867" class="blob-num js-line-number" data-line-number="3867"></td>
+ <td id="LC3867" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(<span class="pl-smi">e</span>.<span class="pl-c1">name</span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L3868" class="blob-num js-line-number" data-line-number="3868"></td>
+ <td id="LC3868" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">edge</span>.<span class="pl-c1">name</span> <span class="pl-k">=</span> <span class="pl-smi">e</span>.<span class="pl-c1">name</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3869" class="blob-num js-line-number" data-line-number="3869"></td>
+ <td id="LC3869" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3870" class="blob-num js-line-number" data-line-number="3870"></td>
+ <td id="LC3870" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">_</span>.<span class="pl-en">isUndefined</span>(edgeValue)) {</td>
+ </tr>
+ <tr>
+ <td id="L3871" class="blob-num js-line-number" data-line-number="3871"></td>
+ <td id="LC3871" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">edge</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> edgeValue;</td>
+ </tr>
+ <tr>
+ <td id="L3872" class="blob-num js-line-number" data-line-number="3872"></td>
+ <td id="LC3872" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3873" class="blob-num js-line-number" data-line-number="3873"></td>
+ <td id="LC3873" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> edge;</td>
+ </tr>
+ <tr>
+ <td id="L3874" class="blob-num js-line-number" data-line-number="3874"></td>
+ <td id="LC3874" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3875" class="blob-num js-line-number" data-line-number="3875"></td>
+ <td id="LC3875" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3876" class="blob-num js-line-number" data-line-number="3876"></td>
+ <td id="LC3876" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3877" class="blob-num js-line-number" data-line-number="3877"></td>
+ <td id="LC3877" class="blob-code blob-code-inner js-file-line"><span class="pl-k">function</span> <span class="pl-en">read</span>(<span class="pl-smi">json</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3878" class="blob-num js-line-number" data-line-number="3878"></td>
+ <td id="LC3878" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> g <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">Graph</span>(<span class="pl-smi">json</span>.<span class="pl-c1">options</span>).<span class="pl-en">setGraph</span>(<span class="pl-smi">json</span>.<span class="pl-c1">value</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3879" class="blob-num js-line-number" data-line-number="3879"></td>
+ <td id="LC3879" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">json</span>.<span class="pl-smi">nodes</span>, <span class="pl-k">function</span>(<span class="pl-smi">entry</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3880" class="blob-num js-line-number" data-line-number="3880"></td>
+ <td id="LC3880" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setNode</span>(<span class="pl-smi">entry</span>.<span class="pl-smi">v</span>, <span class="pl-smi">entry</span>.<span class="pl-c1">value</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3881" class="blob-num js-line-number" data-line-number="3881"></td>
+ <td id="LC3881" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">entry</span>.<span class="pl-c1">parent</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3882" class="blob-num js-line-number" data-line-number="3882"></td>
+ <td id="LC3882" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setParent</span>(<span class="pl-smi">entry</span>.<span class="pl-smi">v</span>, <span class="pl-smi">entry</span>.<span class="pl-c1">parent</span>);</td>
+ </tr>
+ <tr>
+ <td id="L3883" class="blob-num js-line-number" data-line-number="3883"></td>
+ <td id="LC3883" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L3884" class="blob-num js-line-number" data-line-number="3884"></td>
+ <td id="LC3884" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3885" class="blob-num js-line-number" data-line-number="3885"></td>
+ <td id="LC3885" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">_</span>.<span class="pl-en">each</span>(<span class="pl-smi">json</span>.<span class="pl-smi">edges</span>, <span class="pl-k">function</span>(<span class="pl-smi">entry</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3886" class="blob-num js-line-number" data-line-number="3886"></td>
+ <td id="LC3886" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">g</span>.<span class="pl-en">setEdge</span>({ v<span class="pl-k">:</span> <span class="pl-smi">entry</span>.<span class="pl-smi">v</span>, w<span class="pl-k">:</span> <span class="pl-smi">entry</span>.<span class="pl-smi">w</span>, name<span class="pl-k">:</span> <span class="pl-smi">entry</span>.<span class="pl-c1">name</span> }, <span class="pl-smi">entry</span>.<span class="pl-c1">value</ [...]
+ </tr>
+ <tr>
+ <td id="L3887" class="blob-num js-line-number" data-line-number="3887"></td>
+ <td id="LC3887" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L3888" class="blob-num js-line-number" data-line-number="3888"></td>
+ <td id="LC3888" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> g;</td>
+ </tr>
+ <tr>
+ <td id="L3889" class="blob-num js-line-number" data-line-number="3889"></td>
+ <td id="LC3889" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3890" class="blob-num js-line-number" data-line-number="3890"></td>
+ <td id="LC3890" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3891" class="blob-num js-line-number" data-line-number="3891"></td>
+ <td id="LC3891" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>./graph<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">26</span>,<span class="pl-s"><span class="pl-pds">"</span>./lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">29</span>}],<span class="pl-c1">29</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span c [...]
+ </tr>
+ <tr>
+ <td id="L3892" class="blob-num js-line-number" data-line-number="3892"></td>
+ <td id="LC3892" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/* global window */</span></td>
+ </tr>
+ <tr>
+ <td id="L3893" class="blob-num js-line-number" data-line-number="3893"></td>
+ <td id="LC3893" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3894" class="blob-num js-line-number" data-line-number="3894"></td>
+ <td id="LC3894" class="blob-code blob-code-inner js-file-line"><span class="pl-k">var</span> lodash;</td>
+ </tr>
+ <tr>
+ <td id="L3895" class="blob-num js-line-number" data-line-number="3895"></td>
+ <td id="LC3895" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3896" class="blob-num js-line-number" data-line-number="3896"></td>
+ <td id="LC3896" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> (<span class="pl-k">typeof</span> require <span class="pl-k">===</span> <span class="pl-s"><span class="pl-pds">"</span>function<span class="pl-pds">"</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L3897" class="blob-num js-line-number" data-line-number="3897"></td>
+ <td id="LC3897" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span> {</td>
+ </tr>
+ <tr>
+ <td id="L3898" class="blob-num js-line-number" data-line-number="3898"></td>
+ <td id="LC3898" class="blob-code blob-code-inner js-file-line"> lodash <span class="pl-k">=</span> <span class="pl-c1">require</span>(<span class="pl-s"><span class="pl-pds">"</span>lodash<span class="pl-pds">"</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3899" class="blob-num js-line-number" data-line-number="3899"></td>
+ <td id="LC3899" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">catch</span> (e) {}</td>
+ </tr>
+ <tr>
+ <td id="L3900" class="blob-num js-line-number" data-line-number="3900"></td>
+ <td id="LC3900" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3901" class="blob-num js-line-number" data-line-number="3901"></td>
+ <td id="LC3901" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3902" class="blob-num js-line-number" data-line-number="3902"></td>
+ <td id="LC3902" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> (<span class="pl-k">!</span>lodash) {</td>
+ </tr>
+ <tr>
+ <td id="L3903" class="blob-num js-line-number" data-line-number="3903"></td>
+ <td id="LC3903" class="blob-code blob-code-inner js-file-line"> lodash <span class="pl-k">=</span> <span class="pl-c1">window</span>.<span class="pl-smi">_</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3904" class="blob-num js-line-number" data-line-number="3904"></td>
+ <td id="LC3904" class="blob-code blob-code-inner js-file-line">}</td>
+ </tr>
+ <tr>
+ <td id="L3905" class="blob-num js-line-number" data-line-number="3905"></td>
+ <td id="LC3905" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3906" class="blob-num js-line-number" data-line-number="3906"></td>
+ <td id="LC3906" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> lodash;</td>
+ </tr>
+ <tr>
+ <td id="L3907" class="blob-num js-line-number" data-line-number="3907"></td>
+ <td id="LC3907" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3908" class="blob-num js-line-number" data-line-number="3908"></td>
+ <td id="LC3908" class="blob-code blob-code-inner js-file-line">},{<span class="pl-s"><span class="pl-pds">"</span>lodash<span class="pl-pds">"</span></span><span class="pl-k">:</span><span class="pl-c1">31</span>}],<span class="pl-c1">30</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3909" class="blob-num js-line-number" data-line-number="3909"></td>
+ <td id="LC3909" class="blob-code blob-code-inner js-file-line"><span class="pl-c1">module</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>1.0.5<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3910" class="blob-num js-line-number" data-line-number="3910"></td>
+ <td id="LC3910" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3911" class="blob-num js-line-number" data-line-number="3911"></td>
+ <td id="LC3911" class="blob-code blob-code-inner js-file-line">},{}],<span class="pl-c1">31</span><span class="pl-k">:</span>[<span class="pl-k">function</span>(<span class="pl-smi">require</span>,<span class="pl-c1">module</span>,<span class="pl-c1">exports</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3912" class="blob-num js-line-number" data-line-number="3912"></td>
+ <td id="LC3912" class="blob-code blob-code-inner js-file-line">(<span class="pl-k">function</span> (<span class="pl-c1">global</span>){</td>
+ </tr>
+ <tr>
+ <td id="L3913" class="blob-num js-line-number" data-line-number="3913"></td>
+ <td id="LC3913" class="blob-code blob-code-inner js-file-line"><span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3914" class="blob-num js-line-number" data-line-number="3914"></td>
+ <td id="LC3914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@license</span></span></td>
+ </tr>
+ <tr>
+ <td id="L3915" class="blob-num js-line-number" data-line-number="3915"></td>
+ <td id="LC3915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Lo-Dash 2.4.2 (Custom Build) <https://lodash.com/></span></td>
+ </tr>
+ <tr>
+ <td id="L3916" class="blob-num js-line-number" data-line-number="3916"></td>
+ <td id="LC3916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Build: `lodash modern -o ./dist/lodash.js`</span></td>
+ </tr>
+ <tr>
+ <td id="L3917" class="blob-num js-line-number" data-line-number="3917"></td>
+ <td id="LC3917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/></span></td>
+ </tr>
+ <tr>
+ <td id="L3918" class="blob-num js-line-number" data-line-number="3918"></td>
+ <td id="LC3918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE></span></td>
+ </tr>
+ <tr>
+ <td id="L3919" class="blob-num js-line-number" data-line-number="3919"></td>
+ <td id="LC3919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors</span></td>
+ </tr>
+ <tr>
+ <td id="L3920" class="blob-num js-line-number" data-line-number="3920"></td>
+ <td id="LC3920" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Available under MIT license <https://lodash.com/license></span></td>
+ </tr>
+ <tr>
+ <td id="L3921" class="blob-num js-line-number" data-line-number="3921"></td>
+ <td id="LC3921" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3922" class="blob-num js-line-number" data-line-number="3922"></td>
+ <td id="LC3922" class="blob-code blob-code-inner js-file-line">;(<span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L3923" class="blob-num js-line-number" data-line-number="3923"></td>
+ <td id="LC3923" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3924" class="blob-num js-line-number" data-line-number="3924"></td>
+ <td id="LC3924" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used as a safe reference for `undefined` in pre ES5 environments */</span></td>
+ </tr>
+ <tr>
+ <td id="L3925" class="blob-num js-line-number" data-line-number="3925"></td>
+ <td id="LC3925" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3926" class="blob-num js-line-number" data-line-number="3926"></td>
+ <td id="LC3926" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3927" class="blob-num js-line-number" data-line-number="3927"></td>
+ <td id="LC3927" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to pool arrays and objects used internally */</span></td>
+ </tr>
+ <tr>
+ <td id="L3928" class="blob-num js-line-number" data-line-number="3928"></td>
+ <td id="LC3928" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> arrayPool <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L3929" class="blob-num js-line-number" data-line-number="3929"></td>
+ <td id="LC3929" class="blob-code blob-code-inner js-file-line"> objectPool <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L3930" class="blob-num js-line-number" data-line-number="3930"></td>
+ <td id="LC3930" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3931" class="blob-num js-line-number" data-line-number="3931"></td>
+ <td id="LC3931" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to generate unique IDs */</span></td>
+ </tr>
+ <tr>
+ <td id="L3932" class="blob-num js-line-number" data-line-number="3932"></td>
+ <td id="LC3932" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> idCounter <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3933" class="blob-num js-line-number" data-line-number="3933"></td>
+ <td id="LC3933" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3934" class="blob-num js-line-number" data-line-number="3934"></td>
+ <td id="LC3934" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */</span></td>
+ </tr>
+ <tr>
+ <td id="L3935" class="blob-num js-line-number" data-line-number="3935"></td>
+ <td id="LC3935" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> keyPrefix <span class="pl-k">=</span> <span class="pl-k">+</span><span class="pl-k">new</span> <span class="pl-en">Date</span> <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3936" class="blob-num js-line-number" data-line-number="3936"></td>
+ <td id="LC3936" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3937" class="blob-num js-line-number" data-line-number="3937"></td>
+ <td id="LC3937" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used as the size when optimizations are enabled for large arrays */</span></td>
+ </tr>
+ <tr>
+ <td id="L3938" class="blob-num js-line-number" data-line-number="3938"></td>
+ <td id="LC3938" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> largeArraySize <span class="pl-k">=</span> <span class="pl-c1">75</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3939" class="blob-num js-line-number" data-line-number="3939"></td>
+ <td id="LC3939" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3940" class="blob-num js-line-number" data-line-number="3940"></td>
+ <td id="LC3940" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used as the max size of the `arrayPool` and `objectPool` */</span></td>
+ </tr>
+ <tr>
+ <td id="L3941" class="blob-num js-line-number" data-line-number="3941"></td>
+ <td id="LC3941" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> maxPoolSize <span class="pl-k">=</span> <span class="pl-c1">40</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3942" class="blob-num js-line-number" data-line-number="3942"></td>
+ <td id="LC3942" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3943" class="blob-num js-line-number" data-line-number="3943"></td>
+ <td id="LC3943" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to detect and test whitespace */</span></td>
+ </tr>
+ <tr>
+ <td id="L3944" class="blob-num js-line-number" data-line-number="3944"></td>
+ <td id="LC3944" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> whitespace <span class="pl-k">=</span> (</td>
+ </tr>
+ <tr>
+ <td id="L3945" class="blob-num js-line-number" data-line-number="3945"></td>
+ <td id="LC3945" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// whitespace</span></td>
+ </tr>
+ <tr>
+ <td id="L3946" class="blob-num js-line-number" data-line-number="3946"></td>
+ <td id="LC3946" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span> <span class="pl-cce">\t\x</span>0B<span class="pl-cce">\f\x</span>A0<span class="pl-cce">\u</span>feff<span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L3947" class="blob-num js-line-number" data-line-number="3947"></td>
+ <td id="LC3947" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3948" class="blob-num js-line-number" data-line-number="3948"></td>
+ <td id="LC3948" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// line terminators</span></td>
+ </tr>
+ <tr>
+ <td id="L3949" class="blob-num js-line-number" data-line-number="3949"></td>
+ <td id="LC3949" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\n\r\u</span>2028<span class="pl-cce">\u</span>2029<span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L3950" class="blob-num js-line-number" data-line-number="3950"></td>
+ <td id="LC3950" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3951" class="blob-num js-line-number" data-line-number="3951"></td>
+ <td id="LC3951" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// unicode category "Zs" space separators</span></td>
+ </tr>
+ <tr>
+ <td id="L3952" class="blob-num js-line-number" data-line-number="3952"></td>
+ <td id="LC3952" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\u</span>1680<span class="pl-cce">\u</span>180e<span class="pl-cce">\u</span>2000<span class="pl-cce">\u</span>2001<span class="pl-cce">\u</span>2002<span class="pl-cce">\u</span>2003<span class="pl-cce">\u</span>2004<span class="pl-cce">\u</span>2005<span class="pl-cce">\u</span>2006<span class="pl-cce">\u</span>2007<span class="pl-cce">\u</ [...]
+ </tr>
+ <tr>
+ <td id="L3953" class="blob-num js-line-number" data-line-number="3953"></td>
+ <td id="LC3953" class="blob-code blob-code-inner js-file-line"> );</td>
+ </tr>
+ <tr>
+ <td id="L3954" class="blob-num js-line-number" data-line-number="3954"></td>
+ <td id="LC3954" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3955" class="blob-num js-line-number" data-line-number="3955"></td>
+ <td id="LC3955" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to match empty string literals in compiled template source */</span></td>
+ </tr>
+ <tr>
+ <td id="L3956" class="blob-num js-line-number" data-line-number="3956"></td>
+ <td id="LC3956" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reEmptyStringLeading <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">\b</span>__p <span class="pl-cce">\+</span>= '';<span class="pl-pds">/</span>g</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3957" class="blob-num js-line-number" data-line-number="3957"></td>
+ <td id="LC3957" class="blob-code blob-code-inner js-file-line"> reEmptyStringMiddle <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">\b</span>(__p <span class="pl-cce">\+</span>=) '' <span class="pl-cce">\+</span><span class="pl-pds">/</span>g</span>,</td>
+ </tr>
+ <tr>
+ <td id="L3958" class="blob-num js-line-number" data-line-number="3958"></td>
+ <td id="LC3958" class="blob-code blob-code-inner js-file-line"> reEmptyStringTrailing <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span>(__e<span class="pl-cce">\(</span><span class="pl-c1">.</span><span class="pl-k">*?</span><span class="pl-cce">\)</span><span class="pl-k">|</span><span class="pl-k">\b</span>__t<span class="pl-cce">\)</span>) <span class="pl-cce">\+\n</span>'';<span class="pl-pds">/</span>g</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3959" class="blob-num js-line-number" data-line-number="3959"></td>
+ <td id="LC3959" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3960" class="blob-num js-line-number" data-line-number="3960"></td>
+ <td id="LC3960" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L3961" class="blob-num js-line-number" data-line-number="3961"></td>
+ <td id="LC3961" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to match ES6 template delimiters</span></td>
+ </tr>
+ <tr>
+ <td id="L3962" class="blob-num js-line-number" data-line-number="3962"></td>
+ <td id="LC3962" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals</span></td>
+ </tr>
+ <tr>
+ <td id="L3963" class="blob-num js-line-number" data-line-number="3963"></td>
+ <td id="LC3963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L3964" class="blob-num js-line-number" data-line-number="3964"></td>
+ <td id="LC3964" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reEsTemplate <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-cce">\$\{</span>(<span class="pl-c1">[<span class="pl-k">^</span><span class="pl-cce">\\</span>}]</span><span class="pl-k">*</span>(?:<span class="pl-cce">\\</span><span class="pl-c1">.</span><span class="pl-c1">[<span class="pl-k">^</span><span class="pl-cce">\\</span>}]</span><spa [...]
+ </tr>
+ <tr>
+ <td id="L3965" class="blob-num js-line-number" data-line-number="3965"></td>
+ <td id="LC3965" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3966" class="blob-num js-line-number" data-line-number="3966"></td>
+ <td id="LC3966" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to match regexp flags from their coerced string values */</span></td>
+ </tr>
+ <tr>
+ <td id="L3967" class="blob-num js-line-number" data-line-number="3967"></td>
+ <td id="LC3967" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reFlags <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-c1">\w</span><span class="pl-k">*</span><span class="pl-k">$</span><span class="pl-pds">/</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3968" class="blob-num js-line-number" data-line-number="3968"></td>
+ <td id="LC3968" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3969" class="blob-num js-line-number" data-line-number="3969"></td>
+ <td id="LC3969" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to detected named functions */</span></td>
+ </tr>
+ <tr>
+ <td id="L3970" class="blob-num js-line-number" data-line-number="3970"></td>
+ <td id="LC3970" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reFuncName <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">^</span><span class="pl-c1">\s</span><span class="pl-k">*</span>function<span class="pl-c1">[ <span class="pl-cce">\n\r\t</span>]</span><span class="pl-k">+</span><span class="pl-c1">\w</span><span class="pl-pds">/</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3971" class="blob-num js-line-number" data-line-number="3971"></td>
+ <td id="LC3971" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3972" class="blob-num js-line-number" data-line-number="3972"></td>
+ <td id="LC3972" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to match "interpolate" template delimiters */</span></td>
+ </tr>
+ <tr>
+ <td id="L3973" class="blob-num js-line-number" data-line-number="3973"></td>
+ <td id="LC3973" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reInterpolate <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><%=(<span class="pl-c1">[<span class="pl-c1">\s\S</span>]</span><span class="pl-k">+?</span>)%><span class="pl-pds">/</span>g</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3974" class="blob-num js-line-number" data-line-number="3974"></td>
+ <td id="LC3974" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3975" class="blob-num js-line-number" data-line-number="3975"></td>
+ <td id="LC3975" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to match leading whitespace and zeros to be removed */</span></td>
+ </tr>
+ <tr>
+ <td id="L3976" class="blob-num js-line-number" data-line-number="3976"></td>
+ <td id="LC3976" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reLeadingSpacesAndZeros <span class="pl-k">=</span> <span class="pl-c1">RegExp</span>(<span class="pl-s"><span class="pl-pds">'</span>^[<span class="pl-pds">'</span></span> <span class="pl-k">+</span> whitespace <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>]*0+(?=.$)<span class="pl-pds">'</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L3977" class="blob-num js-line-number" data-line-number="3977"></td>
+ <td id="LC3977" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3978" class="blob-num js-line-number" data-line-number="3978"></td>
+ <td id="LC3978" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to ensure capturing order of template delimiters */</span></td>
+ </tr>
+ <tr>
+ <td id="L3979" class="blob-num js-line-number" data-line-number="3979"></td>
+ <td id="LC3979" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reNoMatch <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span>(<span class="pl-k">$^</span>)<span class="pl-pds">/</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3980" class="blob-num js-line-number" data-line-number="3980"></td>
+ <td id="LC3980" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3981" class="blob-num js-line-number" data-line-number="3981"></td>
+ <td id="LC3981" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to detect functions containing a `this` reference */</span></td>
+ </tr>
+ <tr>
+ <td id="L3982" class="blob-num js-line-number" data-line-number="3982"></td>
+ <td id="LC3982" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reThis <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-k">\b</span>this<span class="pl-k">\b</span><span class="pl-pds">/</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L3983" class="blob-num js-line-number" data-line-number="3983"></td>
+ <td id="LC3983" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3984" class="blob-num js-line-number" data-line-number="3984"></td>
+ <td id="LC3984" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to match unescaped characters in compiled string literals */</span></td>
+ </tr>
+ <tr>
+ <td id="L3985" class="blob-num js-line-number" data-line-number="3985"></td>
+ <td id="LC3985" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reUnescapedString <span class="pl-k">=</span><span class="pl-sr"> <span class="pl-pds">/</span><span class="pl-c1">['<span class="pl-cce">\n\r\t\u</span>2028<span class="pl-cce">\u</span>2029<span class="pl-cce">\\</span>]</span><span class="pl-pds">/</span>g</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3986" class="blob-num js-line-number" data-line-number="3986"></td>
+ <td id="LC3986" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3987" class="blob-num js-line-number" data-line-number="3987"></td>
+ <td id="LC3987" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to assign default `context` object properties */</span></td>
+ </tr>
+ <tr>
+ <td id="L3988" class="blob-num js-line-number" data-line-number="3988"></td>
+ <td id="LC3988" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> contextProps <span class="pl-k">=</span> [</td>
+ </tr>
+ <tr>
+ <td id="L3989" class="blob-num js-line-number" data-line-number="3989"></td>
+ <td id="LC3989" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>Array<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>Boolean<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>Date<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>Function<span class="pl-pds">'</span></span>, <span class="pl-s [...]
+ </tr>
+ <tr>
+ <td id="L3990" class="blob-num js-line-number" data-line-number="3990"></td>
+ <td id="LC3990" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>RegExp<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>String<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>_<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>attachEvent<span class="pl-pds">'</span></span>, <span class="pl-s [...]
+ </tr>
+ <tr>
+ <td id="L3991" class="blob-num js-line-number" data-line-number="3991"></td>
+ <td id="LC3991" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>parseInt<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>setTimeout<span class="pl-pds">'</span></span></td>
+ </tr>
+ <tr>
+ <td id="L3992" class="blob-num js-line-number" data-line-number="3992"></td>
+ <td id="LC3992" class="blob-code blob-code-inner js-file-line"> ];</td>
+ </tr>
+ <tr>
+ <td id="L3993" class="blob-num js-line-number" data-line-number="3993"></td>
+ <td id="LC3993" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3994" class="blob-num js-line-number" data-line-number="3994"></td>
+ <td id="LC3994" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to make template sourceURLs easier to identify */</span></td>
+ </tr>
+ <tr>
+ <td id="L3995" class="blob-num js-line-number" data-line-number="3995"></td>
+ <td id="LC3995" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> templateCounter <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L3996" class="blob-num js-line-number" data-line-number="3996"></td>
+ <td id="LC3996" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L3997" class="blob-num js-line-number" data-line-number="3997"></td>
+ <td id="LC3997" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** `Object#toString` result shortcuts */</span></td>
+ </tr>
+ <tr>
+ <td id="L3998" class="blob-num js-line-number" data-line-number="3998"></td>
+ <td id="LC3998" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> argsClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Arguments]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L3999" class="blob-num js-line-number" data-line-number="3999"></td>
+ <td id="LC3999" class="blob-code blob-code-inner js-file-line"> arrayClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Array]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4000" class="blob-num js-line-number" data-line-number="4000"></td>
+ <td id="LC4000" class="blob-code blob-code-inner js-file-line"> boolClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Boolean]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4001" class="blob-num js-line-number" data-line-number="4001"></td>
+ <td id="LC4001" class="blob-code blob-code-inner js-file-line"> dateClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Date]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4002" class="blob-num js-line-number" data-line-number="4002"></td>
+ <td id="LC4002" class="blob-code blob-code-inner js-file-line"> funcClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Function]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4003" class="blob-num js-line-number" data-line-number="4003"></td>
+ <td id="LC4003" class="blob-code blob-code-inner js-file-line"> numberClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Number]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4004" class="blob-num js-line-number" data-line-number="4004"></td>
+ <td id="LC4004" class="blob-code blob-code-inner js-file-line"> objectClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object Object]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4005" class="blob-num js-line-number" data-line-number="4005"></td>
+ <td id="LC4005" class="blob-code blob-code-inner js-file-line"> regexpClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object RegExp]<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4006" class="blob-num js-line-number" data-line-number="4006"></td>
+ <td id="LC4006" class="blob-code blob-code-inner js-file-line"> stringClass <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>[object String]<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L4007" class="blob-num js-line-number" data-line-number="4007"></td>
+ <td id="LC4007" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4008" class="blob-num js-line-number" data-line-number="4008"></td>
+ <td id="LC4008" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to identify object classifications that `_.clone` supports */</span></td>
+ </tr>
+ <tr>
+ <td id="L4009" class="blob-num js-line-number" data-line-number="4009"></td>
+ <td id="LC4009" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cloneableClasses <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L4010" class="blob-num js-line-number" data-line-number="4010"></td>
+ <td id="LC4010" class="blob-code blob-code-inner js-file-line"> cloneableClasses[funcClass] <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4011" class="blob-num js-line-number" data-line-number="4011"></td>
+ <td id="LC4011" class="blob-code blob-code-inner js-file-line"> cloneableClasses[argsClass] <span class="pl-k">=</span> cloneableClasses[arrayClass] <span class="pl-k">=</span></td>
+ </tr>
+ <tr>
+ <td id="L4012" class="blob-num js-line-number" data-line-number="4012"></td>
+ <td id="LC4012" class="blob-code blob-code-inner js-file-line"> cloneableClasses[boolClass] <span class="pl-k">=</span> cloneableClasses[dateClass] <span class="pl-k">=</span></td>
+ </tr>
+ <tr>
+ <td id="L4013" class="blob-num js-line-number" data-line-number="4013"></td>
+ <td id="LC4013" class="blob-code blob-code-inner js-file-line"> cloneableClasses[numberClass] <span class="pl-k">=</span> cloneableClasses[objectClass] <span class="pl-k">=</span></td>
+ </tr>
+ <tr>
+ <td id="L4014" class="blob-num js-line-number" data-line-number="4014"></td>
+ <td id="LC4014" class="blob-code blob-code-inner js-file-line"> cloneableClasses[regexpClass] <span class="pl-k">=</span> cloneableClasses[stringClass] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4015" class="blob-num js-line-number" data-line-number="4015"></td>
+ <td id="LC4015" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4016" class="blob-num js-line-number" data-line-number="4016"></td>
+ <td id="LC4016" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used as an internal `_.debounce` options object */</span></td>
+ </tr>
+ <tr>
+ <td id="L4017" class="blob-num js-line-number" data-line-number="4017"></td>
+ <td id="LC4017" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> debounceOptions <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4018" class="blob-num js-line-number" data-line-number="4018"></td>
+ <td id="LC4018" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>leading<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4019" class="blob-num js-line-number" data-line-number="4019"></td>
+ <td id="LC4019" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>maxWait<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4020" class="blob-num js-line-number" data-line-number="4020"></td>
+ <td id="LC4020" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>trailing<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span></td>
+ </tr>
+ <tr>
+ <td id="L4021" class="blob-num js-line-number" data-line-number="4021"></td>
+ <td id="LC4021" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4022" class="blob-num js-line-number" data-line-number="4022"></td>
+ <td id="LC4022" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4023" class="blob-num js-line-number" data-line-number="4023"></td>
+ <td id="LC4023" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used as the property descriptor for `__bindData__` */</span></td>
+ </tr>
+ <tr>
+ <td id="L4024" class="blob-num js-line-number" data-line-number="4024"></td>
+ <td id="LC4024" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> descriptor <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4025" class="blob-num js-line-number" data-line-number="4025"></td>
+ <td id="LC4025" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>configurable<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4026" class="blob-num js-line-number" data-line-number="4026"></td>
+ <td id="LC4026" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>enumerable<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4027" class="blob-num js-line-number" data-line-number="4027"></td>
+ <td id="LC4027" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>value<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4028" class="blob-num js-line-number" data-line-number="4028"></td>
+ <td id="LC4028" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>writable<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span></td>
+ </tr>
+ <tr>
+ <td id="L4029" class="blob-num js-line-number" data-line-number="4029"></td>
+ <td id="LC4029" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4030" class="blob-num js-line-number" data-line-number="4030"></td>
+ <td id="LC4030" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4031" class="blob-num js-line-number" data-line-number="4031"></td>
+ <td id="LC4031" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to determine if values are of the language type Object */</span></td>
+ </tr>
+ <tr>
+ <td id="L4032" class="blob-num js-line-number" data-line-number="4032"></td>
+ <td id="LC4032" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> objectTypes <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4033" class="blob-num js-line-number" data-line-number="4033"></td>
+ <td id="LC4033" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4034" class="blob-num js-line-number" data-line-number="4034"></td>
+ <td id="LC4034" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">true</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4035" class="blob-num js-line-number" data-line-number="4035"></td>
+ <td id="LC4035" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">true</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4036" class="blob-num js-line-number" data-line-number="4036"></td>
+ <td id="LC4036" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4037" class="blob-num js-line-number" data-line-number="4037"></td>
+ <td id="LC4037" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>string<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4038" class="blob-num js-line-number" data-line-number="4038"></td>
+ <td id="LC4038" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span></td>
+ </tr>
+ <tr>
+ <td id="L4039" class="blob-num js-line-number" data-line-number="4039"></td>
+ <td id="LC4039" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4040" class="blob-num js-line-number" data-line-number="4040"></td>
+ <td id="LC4040" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4041" class="blob-num js-line-number" data-line-number="4041"></td>
+ <td id="LC4041" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to escape characters for inclusion in compiled string literals */</span></td>
+ </tr>
+ <tr>
+ <td id="L4042" class="blob-num js-line-number" data-line-number="4042"></td>
+ <td id="LC4042" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> stringEscapes <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4043" class="blob-num js-line-number" data-line-number="4043"></td>
+ <td id="LC4043" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span><span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span><span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4044" class="blob-num js-line-number" data-line-number="4044"></td>
+ <td id="LC4044" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span>'<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">"</span>'<span class="pl-pds">"</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4045" class="blob-num js-line-number" data-line-number="4045"></td>
+ <td id="LC4045" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\n</span><span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>n<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4046" class="blob-num js-line-number" data-line-number="4046"></td>
+ <td id="LC4046" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\r</span><span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>r<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4047" class="blob-num js-line-number" data-line-number="4047"></td>
+ <td id="LC4047" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\t</span><span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>t<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4048" class="blob-num js-line-number" data-line-number="4048"></td>
+ <td id="LC4048" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\u</span>2028<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>u2028<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4049" class="blob-num js-line-number" data-line-number="4049"></td>
+ <td id="LC4049" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\u</span>2029<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>u2029<span class="pl-pds">'</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4050" class="blob-num js-line-number" data-line-number="4050"></td>
+ <td id="LC4050" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4051" class="blob-num js-line-number" data-line-number="4051"></td>
+ <td id="LC4051" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4052" class="blob-num js-line-number" data-line-number="4052"></td>
+ <td id="LC4052" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used as a reference to the global object */</span></td>
+ </tr>
+ <tr>
+ <td id="L4053" class="blob-num js-line-number" data-line-number="4053"></td>
+ <td id="LC4053" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> root <span class="pl-k">=</span> (objectTypes[<span class="pl-k">typeof</span> <span class="pl-c1">window</span>] <span class="pl-k">&&</span> <span class="pl-c1">window</span>) <span class="pl-k">||</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4054" class="blob-num js-line-number" data-line-number="4054"></td>
+ <td id="LC4054" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4055" class="blob-num js-line-number" data-line-number="4055"></td>
+ <td id="LC4055" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Detect free variable `exports` */</span></td>
+ </tr>
+ <tr>
+ <td id="L4056" class="blob-num js-line-number" data-line-number="4056"></td>
+ <td id="LC4056" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> freeExports <span class="pl-k">=</span> objectTypes[<span class="pl-k">typeof</span> <span class="pl-c1">exports</span>] <span class="pl-k">&&</span> <span class="pl-c1">exports</span> <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-c1">exports</span>.<span class="pl-c1">nodeType</span> <span class="pl-k">&&</span> <span class="pl-c1">expo [...]
+ </tr>
+ <tr>
+ <td id="L4057" class="blob-num js-line-number" data-line-number="4057"></td>
+ <td id="LC4057" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4058" class="blob-num js-line-number" data-line-number="4058"></td>
+ <td id="LC4058" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Detect free variable `module` */</span></td>
+ </tr>
+ <tr>
+ <td id="L4059" class="blob-num js-line-number" data-line-number="4059"></td>
+ <td id="LC4059" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> freeModule <span class="pl-k">=</span> objectTypes[<span class="pl-k">typeof</span> <span class="pl-c1">module</span>] <span class="pl-k">&&</span> <span class="pl-c1">module</span> <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-c1">module</span>.<span class="pl-c1">nodeType</span> <span class="pl-k">&&</span> <span class="pl-c1">module</ [...]
+ </tr>
+ <tr>
+ <td id="L4060" class="blob-num js-line-number" data-line-number="4060"></td>
+ <td id="LC4060" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4061" class="blob-num js-line-number" data-line-number="4061"></td>
+ <td id="LC4061" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Detect the popular CommonJS extension `module.exports` */</span></td>
+ </tr>
+ <tr>
+ <td id="L4062" class="blob-num js-line-number" data-line-number="4062"></td>
+ <td id="LC4062" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> moduleExports <span class="pl-k">=</span> freeModule <span class="pl-k">&&</span> <span class="pl-smi">freeModule</span>.<span class="pl-smi">exports</span> <span class="pl-k">===</span> freeExports <span class="pl-k">&&</span> freeExports;</td>
+ </tr>
+ <tr>
+ <td id="L4063" class="blob-num js-line-number" data-line-number="4063"></td>
+ <td id="LC4063" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4064" class="blob-num js-line-number" data-line-number="4064"></td>
+ <td id="LC4064" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Detect free variable `global` from Node.js or Browserified code and use it as `root` */</span></td>
+ </tr>
+ <tr>
+ <td id="L4065" class="blob-num js-line-number" data-line-number="4065"></td>
+ <td id="LC4065" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> freeGlobal <span class="pl-k">=</span> objectTypes[<span class="pl-k">typeof</span> <span class="pl-c1">global</span>] <span class="pl-k">&&</span> <span class="pl-c1">global</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4066" class="blob-num js-line-number" data-line-number="4066"></td>
+ <td id="LC4066" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (freeGlobal <span class="pl-k">&&</span> (<span class="pl-smi">freeGlobal</span>.<span class="pl-c1">global</span> <span class="pl-k">===</span> freeGlobal <span class="pl-k">||</span> <span class="pl-smi">freeGlobal</span>.<span class="pl-smi">window</span> <span class="pl-k">===</span> freeGlobal)) {</td>
+ </tr>
+ <tr>
+ <td id="L4067" class="blob-num js-line-number" data-line-number="4067"></td>
+ <td id="LC4067" class="blob-code blob-code-inner js-file-line"> root <span class="pl-k">=</span> freeGlobal;</td>
+ </tr>
+ <tr>
+ <td id="L4068" class="blob-num js-line-number" data-line-number="4068"></td>
+ <td id="LC4068" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4069" class="blob-num js-line-number" data-line-number="4069"></td>
+ <td id="LC4069" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4070" class="blob-num js-line-number" data-line-number="4070"></td>
+ <td id="LC4070" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L4071" class="blob-num js-line-number" data-line-number="4071"></td>
+ <td id="LC4071" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4072" class="blob-num js-line-number" data-line-number="4072"></td>
+ <td id="LC4072" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4073" class="blob-num js-line-number" data-line-number="4073"></td>
+ <td id="LC4073" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.indexOf` without support for binary searches</span></td>
+ </tr>
+ <tr>
+ <td id="L4074" class="blob-num js-line-number" data-line-number="4074"></td>
+ <td id="LC4074" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * or `fromIndex` constraints.</span></td>
+ </tr>
+ <tr>
+ <td id="L4075" class="blob-num js-line-number" data-line-number="4075"></td>
+ <td id="LC4075" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4076" class="blob-num js-line-number" data-line-number="4076"></td>
+ <td id="LC4076" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4077" class="blob-num js-line-number" data-line-number="4077"></td>
+ <td id="LC4077" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L4078" class="blob-num js-line-number" data-line-number="4078"></td>
+ <td id="LC4078" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to search for.</span></td>
+ </tr>
+ <tr>
+ <td id="L4079" class="blob-num js-line-number" data-line-number="4079"></td>
+ <td id="LC4079" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [fromIndex=0] The index to search from.</span></td>
+ </tr>
+ <tr>
+ <td id="L4080" class="blob-num js-line-number" data-line-number="4080"></td>
+ <td id="LC4080" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the index of the matched value or `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4081" class="blob-num js-line-number" data-line-number="4081"></td>
+ <td id="LC4081" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4082" class="blob-num js-line-number" data-line-number="4082"></td>
+ <td id="LC4082" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseIndexOf</span>(<span class="pl-smi">array</span>, <span class="pl-smi">value</span>, <span class="pl-smi">fromIndex</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4083" class="blob-num js-line-number" data-line-number="4083"></td>
+ <td id="LC4083" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> (fromIndex <span class="pl-k">||</span> <span class="pl-c1">0</span>) <span class="pl-k">-</span> <span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4084" class="blob-num js-line-number" data-line-number="4084"></td>
+ <td id="LC4084" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4085" class="blob-num js-line-number" data-line-number="4085"></td>
+ <td id="LC4085" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4086" class="blob-num js-line-number" data-line-number="4086"></td>
+ <td id="LC4086" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L4087" class="blob-num js-line-number" data-line-number="4087"></td>
+ <td id="LC4087" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (array[index] <span class="pl-k">===</span> value) {</td>
+ </tr>
+ <tr>
+ <td id="L4088" class="blob-num js-line-number" data-line-number="4088"></td>
+ <td id="LC4088" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> index;</td>
+ </tr>
+ <tr>
+ <td id="L4089" class="blob-num js-line-number" data-line-number="4089"></td>
+ <td id="LC4089" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4090" class="blob-num js-line-number" data-line-number="4090"></td>
+ <td id="LC4090" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4091" class="blob-num js-line-number" data-line-number="4091"></td>
+ <td id="LC4091" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4092" class="blob-num js-line-number" data-line-number="4092"></td>
+ <td id="LC4092" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4093" class="blob-num js-line-number" data-line-number="4093"></td>
+ <td id="LC4093" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4094" class="blob-num js-line-number" data-line-number="4094"></td>
+ <td id="LC4094" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4095" class="blob-num js-line-number" data-line-number="4095"></td>
+ <td id="LC4095" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * An implementation of `_.contains` for cache objects that mimics the return</span></td>
+ </tr>
+ <tr>
+ <td id="L4096" class="blob-num js-line-number" data-line-number="4096"></td>
+ <td id="LC4096" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4097" class="blob-num js-line-number" data-line-number="4097"></td>
+ <td id="LC4097" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4098" class="blob-num js-line-number" data-line-number="4098"></td>
+ <td id="LC4098" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4099" class="blob-num js-line-number" data-line-number="4099"></td>
+ <td id="LC4099" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">cache</span> The cache object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L4100" class="blob-num js-line-number" data-line-number="4100"></td>
+ <td id="LC4100" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to search for.</span></td>
+ </tr>
+ <tr>
+ <td id="L4101" class="blob-num js-line-number" data-line-number="4101"></td>
+ <td id="LC4101" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> `0` if `value` is found, else `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4102" class="blob-num js-line-number" data-line-number="4102"></td>
+ <td id="LC4102" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4103" class="blob-num js-line-number" data-line-number="4103"></td>
+ <td id="LC4103" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">cacheIndexOf</span>(<span class="pl-smi">cache</span>, <span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4104" class="blob-num js-line-number" data-line-number="4104"></td>
+ <td id="LC4104" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> type <span class="pl-k">=</span> <span class="pl-k">typeof</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L4105" class="blob-num js-line-number" data-line-number="4105"></td>
+ <td id="LC4105" class="blob-code blob-code-inner js-file-line"> cache <span class="pl-k">=</span> <span class="pl-smi">cache</span>.<span class="pl-smi">cache</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4106" class="blob-num js-line-number" data-line-number="4106"></td>
+ <td id="LC4106" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4107" class="blob-num js-line-number" data-line-number="4107"></td>
+ <td id="LC4107" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span> <span class="pl-k">||</span> value <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4108" class="blob-num js-line-number" data-line-number="4108"></td>
+ <td id="LC4108" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> cache[value] <span class="pl-k">?</span> <span class="pl-c1">0</span> <span class="pl-k">:</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4109" class="blob-num js-line-number" data-line-number="4109"></td>
+ <td id="LC4109" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4110" class="blob-num js-line-number" data-line-number="4110"></td>
+ <td id="LC4110" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (type <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> type <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>string<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4111" class="blob-num js-line-number" data-line-number="4111"></td>
+ <td id="LC4111" class="blob-code blob-code-inner js-file-line"> type <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L4112" class="blob-num js-line-number" data-line-number="4112"></td>
+ <td id="LC4112" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4113" class="blob-num js-line-number" data-line-number="4113"></td>
+ <td id="LC4113" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> value <span class="pl-k">:</span> keyPrefix <span class="pl-k">+</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L4114" class="blob-num js-line-number" data-line-number="4114"></td>
+ <td id="LC4114" class="blob-code blob-code-inner js-file-line"> cache <span class="pl-k">=</span> (cache <span class="pl-k">=</span> cache[type]) <span class="pl-k">&&</span> cache[key];</td>
+ </tr>
+ <tr>
+ <td id="L4115" class="blob-num js-line-number" data-line-number="4115"></td>
+ <td id="LC4115" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4116" class="blob-num js-line-number" data-line-number="4116"></td>
+ <td id="LC4116" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4117" class="blob-num js-line-number" data-line-number="4117"></td>
+ <td id="LC4117" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> (cache <span class="pl-k">&&</span> <span class="pl-en">baseIndexOf</span>(cache, value) <span class="pl-k">></span> <span class="pl-k">-</span><span class="pl-c1">1</span> <span class="pl-k">?</span> <span class="pl-c1">0</span> <span class="pl-k">:</span> <span class="pl-k">-</span><span class="pl-c1">1</span>)</td>
+ </tr>
+ <tr>
+ <td id="L4118" class="blob-num js-line-number" data-line-number="4118"></td>
+ <td id="LC4118" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> (cache <span class="pl-k">?</span> <span class="pl-c1">0</span> <span class="pl-k">:</span> <span class="pl-k">-</span><span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4119" class="blob-num js-line-number" data-line-number="4119"></td>
+ <td id="LC4119" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4120" class="blob-num js-line-number" data-line-number="4120"></td>
+ <td id="LC4120" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4121" class="blob-num js-line-number" data-line-number="4121"></td>
+ <td id="LC4121" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4122" class="blob-num js-line-number" data-line-number="4122"></td>
+ <td id="LC4122" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Adds a given value to the corresponding cache object.</span></td>
+ </tr>
+ <tr>
+ <td id="L4123" class="blob-num js-line-number" data-line-number="4123"></td>
+ <td id="LC4123" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4124" class="blob-num js-line-number" data-line-number="4124"></td>
+ <td id="LC4124" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4125" class="blob-num js-line-number" data-line-number="4125"></td>
+ <td id="LC4125" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to add to the cache.</span></td>
+ </tr>
+ <tr>
+ <td id="L4126" class="blob-num js-line-number" data-line-number="4126"></td>
+ <td id="LC4126" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4127" class="blob-num js-line-number" data-line-number="4127"></td>
+ <td id="LC4127" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">cachePush</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4128" class="blob-num js-line-number" data-line-number="4128"></td>
+ <td id="LC4128" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">cache</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4129" class="blob-num js-line-number" data-line-number="4129"></td>
+ <td id="LC4129" class="blob-code blob-code-inner js-file-line"> type <span class="pl-k">=</span> <span class="pl-k">typeof</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L4130" class="blob-num js-line-number" data-line-number="4130"></td>
+ <td id="LC4130" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4131" class="blob-num js-line-number" data-line-number="4131"></td>
+ <td id="LC4131" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span> <span class="pl-k">||</span> value <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4132" class="blob-num js-line-number" data-line-number="4132"></td>
+ <td id="LC4132" class="blob-code blob-code-inner js-file-line"> cache[value] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4133" class="blob-num js-line-number" data-line-number="4133"></td>
+ <td id="LC4133" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4134" class="blob-num js-line-number" data-line-number="4134"></td>
+ <td id="LC4134" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (type <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> type <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>string<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4135" class="blob-num js-line-number" data-line-number="4135"></td>
+ <td id="LC4135" class="blob-code blob-code-inner js-file-line"> type <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L4136" class="blob-num js-line-number" data-line-number="4136"></td>
+ <td id="LC4136" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4137" class="blob-num js-line-number" data-line-number="4137"></td>
+ <td id="LC4137" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> value <span class="pl-k">:</span> keyPrefix <span class="pl-k">+</span> value,</td>
+ </tr>
+ <tr>
+ <td id="L4138" class="blob-num js-line-number" data-line-number="4138"></td>
+ <td id="LC4138" class="blob-code blob-code-inner js-file-line"> typeCache <span class="pl-k">=</span> cache[type] <span class="pl-k">||</span> (cache[type] <span class="pl-k">=</span> {});</td>
+ </tr>
+ <tr>
+ <td id="L4139" class="blob-num js-line-number" data-line-number="4139"></td>
+ <td id="LC4139" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4140" class="blob-num js-line-number" data-line-number="4140"></td>
+ <td id="LC4140" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4141" class="blob-num js-line-number" data-line-number="4141"></td>
+ <td id="LC4141" class="blob-code blob-code-inner js-file-line"> (typeCache[key] <span class="pl-k">||</span> (typeCache[key] <span class="pl-k">=</span> [])).<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4142" class="blob-num js-line-number" data-line-number="4142"></td>
+ <td id="LC4142" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4143" class="blob-num js-line-number" data-line-number="4143"></td>
+ <td id="LC4143" class="blob-code blob-code-inner js-file-line"> typeCache[key] <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4144" class="blob-num js-line-number" data-line-number="4144"></td>
+ <td id="LC4144" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4145" class="blob-num js-line-number" data-line-number="4145"></td>
+ <td id="LC4145" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4146" class="blob-num js-line-number" data-line-number="4146"></td>
+ <td id="LC4146" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4147" class="blob-num js-line-number" data-line-number="4147"></td>
+ <td id="LC4147" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4148" class="blob-num js-line-number" data-line-number="4148"></td>
+ <td id="LC4148" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4149" class="blob-num js-line-number" data-line-number="4149"></td>
+ <td id="LC4149" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used by `_.max` and `_.min` as the default callback when a given</span></td>
+ </tr>
+ <tr>
+ <td id="L4150" class="blob-num js-line-number" data-line-number="4150"></td>
+ <td id="LC4150" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * collection is a string value.</span></td>
+ </tr>
+ <tr>
+ <td id="L4151" class="blob-num js-line-number" data-line-number="4151"></td>
+ <td id="LC4151" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4152" class="blob-num js-line-number" data-line-number="4152"></td>
+ <td id="LC4152" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4153" class="blob-num js-line-number" data-line-number="4153"></td>
+ <td id="LC4153" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">value</span> The character to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L4154" class="blob-num js-line-number" data-line-number="4154"></td>
+ <td id="LC4154" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the code unit of given character.</span></td>
+ </tr>
+ <tr>
+ <td id="L4155" class="blob-num js-line-number" data-line-number="4155"></td>
+ <td id="LC4155" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4156" class="blob-num js-line-number" data-line-number="4156"></td>
+ <td id="LC4156" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">charAtCallback</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4157" class="blob-num js-line-number" data-line-number="4157"></td>
+ <td id="LC4157" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">value</span>.<span class="pl-c1">charCodeAt</span>(<span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4158" class="blob-num js-line-number" data-line-number="4158"></td>
+ <td id="LC4158" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4159" class="blob-num js-line-number" data-line-number="4159"></td>
+ <td id="LC4159" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4160" class="blob-num js-line-number" data-line-number="4160"></td>
+ <td id="LC4160" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4161" class="blob-num js-line-number" data-line-number="4161"></td>
+ <td id="LC4161" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used by `sortBy` to compare transformed `collection` elements, stable sorting</span></td>
+ </tr>
+ <tr>
+ <td id="L4162" class="blob-num js-line-number" data-line-number="4162"></td>
+ <td id="LC4162" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * them in ascending order.</span></td>
+ </tr>
+ <tr>
+ <td id="L4163" class="blob-num js-line-number" data-line-number="4163"></td>
+ <td id="LC4163" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4164" class="blob-num js-line-number" data-line-number="4164"></td>
+ <td id="LC4164" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4165" class="blob-num js-line-number" data-line-number="4165"></td>
+ <td id="LC4165" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">a</span> The object to compare to `b`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4166" class="blob-num js-line-number" data-line-number="4166"></td>
+ <td id="LC4166" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">b</span> The object to compare to `a`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4167" class="blob-num js-line-number" data-line-number="4167"></td>
+ <td id="LC4167" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the sort order indicator of `1` or `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4168" class="blob-num js-line-number" data-line-number="4168"></td>
+ <td id="LC4168" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4169" class="blob-num js-line-number" data-line-number="4169"></td>
+ <td id="LC4169" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">compareAscending</span>(<span class="pl-smi">a</span>, <span class="pl-smi">b</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4170" class="blob-num js-line-number" data-line-number="4170"></td>
+ <td id="LC4170" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ac <span class="pl-k">=</span> <span class="pl-smi">a</span>.<span class="pl-smi">criteria</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4171" class="blob-num js-line-number" data-line-number="4171"></td>
+ <td id="LC4171" class="blob-code blob-code-inner js-file-line"> bc <span class="pl-k">=</span> <span class="pl-smi">b</span>.<span class="pl-smi">criteria</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4172" class="blob-num js-line-number" data-line-number="4172"></td>
+ <td id="LC4172" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4173" class="blob-num js-line-number" data-line-number="4173"></td>
+ <td id="LC4173" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">ac</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4174" class="blob-num js-line-number" data-line-number="4174"></td>
+ <td id="LC4174" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4175" class="blob-num js-line-number" data-line-number="4175"></td>
+ <td id="LC4175" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L4176" class="blob-num js-line-number" data-line-number="4176"></td>
+ <td id="LC4176" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> ac[index],</td>
+ </tr>
+ <tr>
+ <td id="L4177" class="blob-num js-line-number" data-line-number="4177"></td>
+ <td id="LC4177" class="blob-code blob-code-inner js-file-line"> other <span class="pl-k">=</span> bc[index];</td>
+ </tr>
+ <tr>
+ <td id="L4178" class="blob-num js-line-number" data-line-number="4178"></td>
+ <td id="LC4178" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4179" class="blob-num js-line-number" data-line-number="4179"></td>
+ <td id="LC4179" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k">!==</span> other) {</td>
+ </tr>
+ <tr>
+ <td id="L4180" class="blob-num js-line-number" data-line-number="4180"></td>
+ <td id="LC4180" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k">></span> other <span class="pl-k">||</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4181" class="blob-num js-line-number" data-line-number="4181"></td>
+ <td id="LC4181" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4182" class="blob-num js-line-number" data-line-number="4182"></td>
+ <td id="LC4182" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4183" class="blob-num js-line-number" data-line-number="4183"></td>
+ <td id="LC4183" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k"><</span> other <span class="pl-k">||</span> <span class="pl-k">typeof</span> other <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4184" class="blob-num js-line-number" data-line-number="4184"></td>
+ <td id="LC4184" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4185" class="blob-num js-line-number" data-line-number="4185"></td>
+ <td id="LC4185" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4186" class="blob-num js-line-number" data-line-number="4186"></td>
+ <td id="LC4186" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4187" class="blob-num js-line-number" data-line-number="4187"></td>
+ <td id="LC4187" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4188" class="blob-num js-line-number" data-line-number="4188"></td>
+ <td id="LC4188" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications</span></td>
+ </tr>
+ <tr>
+ <td id="L4189" class="blob-num js-line-number" data-line-number="4189"></td>
+ <td id="LC4189" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// that causes it, under certain circumstances, to return the same value for</span></td>
+ </tr>
+ <tr>
+ <td id="L4190" class="blob-num js-line-number" data-line-number="4190"></td>
+ <td id="LC4190" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247</span></td>
+ </tr>
+ <tr>
+ <td id="L4191" class="blob-num js-line-number" data-line-number="4191"></td>
+ <td id="LC4191" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">//</span></td>
+ </tr>
+ <tr>
+ <td id="L4192" class="blob-num js-line-number" data-line-number="4192"></td>
+ <td id="LC4192" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// This also ensures a stable sort in V8 and other engines.</span></td>
+ </tr>
+ <tr>
+ <td id="L4193" class="blob-num js-line-number" data-line-number="4193"></td>
+ <td id="LC4193" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// See http://code.google.com/p/v8/issues/detail?id=90</span></td>
+ </tr>
+ <tr>
+ <td id="L4194" class="blob-num js-line-number" data-line-number="4194"></td>
+ <td id="LC4194" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">a</span>.<span class="pl-c1">index</span> <span class="pl-k">-</span> <span class="pl-smi">b</span>.<span class="pl-c1">index</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4195" class="blob-num js-line-number" data-line-number="4195"></td>
+ <td id="LC4195" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4196" class="blob-num js-line-number" data-line-number="4196"></td>
+ <td id="LC4196" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4197" class="blob-num js-line-number" data-line-number="4197"></td>
+ <td id="LC4197" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4198" class="blob-num js-line-number" data-line-number="4198"></td>
+ <td id="LC4198" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a cache object to optimize linear searches of large arrays.</span></td>
+ </tr>
+ <tr>
+ <td id="L4199" class="blob-num js-line-number" data-line-number="4199"></td>
+ <td id="LC4199" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4200" class="blob-num js-line-number" data-line-number="4200"></td>
+ <td id="LC4200" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4201" class="blob-num js-line-number" data-line-number="4201"></td>
+ <td id="LC4201" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [array=[]] The array to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L4202" class="blob-num js-line-number" data-line-number="4202"></td>
+ <td id="LC4202" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {null|Object} Returns the cache object or `null` if caching should not be used.</span></td>
+ </tr>
+ <tr>
+ <td id="L4203" class="blob-num js-line-number" data-line-number="4203"></td>
+ <td id="LC4203" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4204" class="blob-num js-line-number" data-line-number="4204"></td>
+ <td id="LC4204" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">createCache</span>(<span class="pl-smi">array</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4205" class="blob-num js-line-number" data-line-number="4205"></td>
+ <td id="LC4205" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4206" class="blob-num js-line-number" data-line-number="4206"></td>
+ <td id="LC4206" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4207" class="blob-num js-line-number" data-line-number="4207"></td>
+ <td id="LC4207" class="blob-code blob-code-inner js-file-line"> first <span class="pl-k">=</span> array[<span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4208" class="blob-num js-line-number" data-line-number="4208"></td>
+ <td id="LC4208" class="blob-code blob-code-inner js-file-line"> mid <span class="pl-k">=</span> array[(length <span class="pl-k">/</span> <span class="pl-c1">2</span>) <span class="pl-k">|</span> <span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4209" class="blob-num js-line-number" data-line-number="4209"></td>
+ <td id="LC4209" class="blob-code blob-code-inner js-file-line"> last <span class="pl-k">=</span> array[length <span class="pl-k">-</span> <span class="pl-c1">1</span>];</td>
+ </tr>
+ <tr>
+ <td id="L4210" class="blob-num js-line-number" data-line-number="4210"></td>
+ <td id="LC4210" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4211" class="blob-num js-line-number" data-line-number="4211"></td>
+ <td id="LC4211" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (first <span class="pl-k">&&</span> <span class="pl-k">typeof</span> first <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span></td>
+ </tr>
+ <tr>
+ <td id="L4212" class="blob-num js-line-number" data-line-number="4212"></td>
+ <td id="LC4212" class="blob-code blob-code-inner js-file-line"> mid <span class="pl-k">&&</span> <span class="pl-k">typeof</span> mid <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> last <span class="pl-k">&&</span> <span class="pl-k">typeof</span> last <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<sp [...]
+ </tr>
+ <tr>
+ <td id="L4213" class="blob-num js-line-number" data-line-number="4213"></td>
+ <td id="LC4213" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4214" class="blob-num js-line-number" data-line-number="4214"></td>
+ <td id="LC4214" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4215" class="blob-num js-line-number" data-line-number="4215"></td>
+ <td id="LC4215" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> <span class="pl-en">getObject</span>();</td>
+ </tr>
+ <tr>
+ <td id="L4216" class="blob-num js-line-number" data-line-number="4216"></td>
+ <td id="LC4216" class="blob-code blob-code-inner js-file-line"> cache[<span class="pl-s"><span class="pl-pds">'</span>false<span class="pl-pds">'</span></span>] <span class="pl-k">=</span> cache[<span class="pl-s"><span class="pl-pds">'</span>null<span class="pl-pds">'</span></span>] <span class="pl-k">=</span> cache[<span class="pl-s"><span class="pl-pds">'</span>true<span class="pl-pds">'</span></span>] <span class="pl-k">=</span> cache[<span class="p [...]
+ </tr>
+ <tr>
+ <td id="L4217" class="blob-num js-line-number" data-line-number="4217"></td>
+ <td id="LC4217" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4218" class="blob-num js-line-number" data-line-number="4218"></td>
+ <td id="LC4218" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-en">getObject</span>();</td>
+ </tr>
+ <tr>
+ <td id="L4219" class="blob-num js-line-number" data-line-number="4219"></td>
+ <td id="LC4219" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-smi">array</span> <span class="pl-k">=</span> array;</td>
+ </tr>
+ <tr>
+ <td id="L4220" class="blob-num js-line-number" data-line-number="4220"></td>
+ <td id="LC4220" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-smi">cache</span> <span class="pl-k">=</span> cache;</td>
+ </tr>
+ <tr>
+ <td id="L4221" class="blob-num js-line-number" data-line-number="4221"></td>
+ <td id="LC4221" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-smi">push</span> <span class="pl-k">=</span> cachePush;</td>
+ </tr>
+ <tr>
+ <td id="L4222" class="blob-num js-line-number" data-line-number="4222"></td>
+ <td id="LC4222" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4223" class="blob-num js-line-number" data-line-number="4223"></td>
+ <td id="LC4223" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L4224" class="blob-num js-line-number" data-line-number="4224"></td>
+ <td id="LC4224" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(array[index]);</td>
+ </tr>
+ <tr>
+ <td id="L4225" class="blob-num js-line-number" data-line-number="4225"></td>
+ <td id="LC4225" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4226" class="blob-num js-line-number" data-line-number="4226"></td>
+ <td id="LC4226" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4227" class="blob-num js-line-number" data-line-number="4227"></td>
+ <td id="LC4227" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4228" class="blob-num js-line-number" data-line-number="4228"></td>
+ <td id="LC4228" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4229" class="blob-num js-line-number" data-line-number="4229"></td>
+ <td id="LC4229" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4230" class="blob-num js-line-number" data-line-number="4230"></td>
+ <td id="LC4230" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used by `template` to escape characters for inclusion in compiled</span></td>
+ </tr>
+ <tr>
+ <td id="L4231" class="blob-num js-line-number" data-line-number="4231"></td>
+ <td id="LC4231" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * string literals.</span></td>
+ </tr>
+ <tr>
+ <td id="L4232" class="blob-num js-line-number" data-line-number="4232"></td>
+ <td id="LC4232" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4233" class="blob-num js-line-number" data-line-number="4233"></td>
+ <td id="LC4233" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4234" class="blob-num js-line-number" data-line-number="4234"></td>
+ <td id="LC4234" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">match</span> The matched character to escape.</span></td>
+ </tr>
+ <tr>
+ <td id="L4235" class="blob-num js-line-number" data-line-number="4235"></td>
+ <td id="LC4235" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the escaped character.</span></td>
+ </tr>
+ <tr>
+ <td id="L4236" class="blob-num js-line-number" data-line-number="4236"></td>
+ <td id="LC4236" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4237" class="blob-num js-line-number" data-line-number="4237"></td>
+ <td id="LC4237" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">escapeStringChar</span>(<span class="pl-smi">match</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4238" class="blob-num js-line-number" data-line-number="4238"></td>
+ <td id="LC4238" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span><span class="pl-pds">'</span></span> <span class="pl-k">+</span> stringEscapes[match];</td>
+ </tr>
+ <tr>
+ <td id="L4239" class="blob-num js-line-number" data-line-number="4239"></td>
+ <td id="LC4239" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4240" class="blob-num js-line-number" data-line-number="4240"></td>
+ <td id="LC4240" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4241" class="blob-num js-line-number" data-line-number="4241"></td>
+ <td id="LC4241" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4242" class="blob-num js-line-number" data-line-number="4242"></td>
+ <td id="LC4242" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets an array from the array pool or creates a new one if the pool is empty.</span></td>
+ </tr>
+ <tr>
+ <td id="L4243" class="blob-num js-line-number" data-line-number="4243"></td>
+ <td id="LC4243" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4244" class="blob-num js-line-number" data-line-number="4244"></td>
+ <td id="LC4244" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4245" class="blob-num js-line-number" data-line-number="4245"></td>
+ <td id="LC4245" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">The</span> array from the pool.</span></td>
+ </tr>
+ <tr>
+ <td id="L4246" class="blob-num js-line-number" data-line-number="4246"></td>
+ <td id="LC4246" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4247" class="blob-num js-line-number" data-line-number="4247"></td>
+ <td id="LC4247" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">getArray</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L4248" class="blob-num js-line-number" data-line-number="4248"></td>
+ <td id="LC4248" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">arrayPool</span>.<span class="pl-c1">pop</span>() <span class="pl-k">||</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L4249" class="blob-num js-line-number" data-line-number="4249"></td>
+ <td id="LC4249" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4250" class="blob-num js-line-number" data-line-number="4250"></td>
+ <td id="LC4250" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4251" class="blob-num js-line-number" data-line-number="4251"></td>
+ <td id="LC4251" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4252" class="blob-num js-line-number" data-line-number="4252"></td>
+ <td id="LC4252" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets an object from the object pool or creates a new one if the pool is empty.</span></td>
+ </tr>
+ <tr>
+ <td id="L4253" class="blob-num js-line-number" data-line-number="4253"></td>
+ <td id="LC4253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4254" class="blob-num js-line-number" data-line-number="4254"></td>
+ <td id="LC4254" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4255" class="blob-num js-line-number" data-line-number="4255"></td>
+ <td id="LC4255" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">The</span> object from the pool.</span></td>
+ </tr>
+ <tr>
+ <td id="L4256" class="blob-num js-line-number" data-line-number="4256"></td>
+ <td id="LC4256" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4257" class="blob-num js-line-number" data-line-number="4257"></td>
+ <td id="LC4257" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">getObject</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L4258" class="blob-num js-line-number" data-line-number="4258"></td>
+ <td id="LC4258" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">objectPool</span>.<span class="pl-c1">pop</span>() <span class="pl-k">||</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4259" class="blob-num js-line-number" data-line-number="4259"></td>
+ <td id="LC4259" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>array<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4260" class="blob-num js-line-number" data-line-number="4260"></td>
+ <td id="LC4260" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>cache<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4261" class="blob-num js-line-number" data-line-number="4261"></td>
+ <td id="LC4261" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>criteria<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4262" class="blob-num js-line-number" data-line-number="4262"></td>
+ <td id="LC4262" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>false<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4263" class="blob-num js-line-number" data-line-number="4263"></td>
+ <td id="LC4263" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>index<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4264" class="blob-num js-line-number" data-line-number="4264"></td>
+ <td id="LC4264" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>null<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4265" class="blob-num js-line-number" data-line-number="4265"></td>
+ <td id="LC4265" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4266" class="blob-num js-line-number" data-line-number="4266"></td>
+ <td id="LC4266" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4267" class="blob-num js-line-number" data-line-number="4267"></td>
+ <td id="LC4267" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>push<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4268" class="blob-num js-line-number" data-line-number="4268"></td>
+ <td id="LC4268" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>string<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4269" class="blob-num js-line-number" data-line-number="4269"></td>
+ <td id="LC4269" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>true<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4270" class="blob-num js-line-number" data-line-number="4270"></td>
+ <td id="LC4270" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4271" class="blob-num js-line-number" data-line-number="4271"></td>
+ <td id="LC4271" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>value<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-c1">null</span></td>
+ </tr>
+ <tr>
+ <td id="L4272" class="blob-num js-line-number" data-line-number="4272"></td>
+ <td id="LC4272" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4273" class="blob-num js-line-number" data-line-number="4273"></td>
+ <td id="LC4273" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4274" class="blob-num js-line-number" data-line-number="4274"></td>
+ <td id="LC4274" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4275" class="blob-num js-line-number" data-line-number="4275"></td>
+ <td id="LC4275" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4276" class="blob-num js-line-number" data-line-number="4276"></td>
+ <td id="LC4276" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Releases the given array back to the array pool.</span></td>
+ </tr>
+ <tr>
+ <td id="L4277" class="blob-num js-line-number" data-line-number="4277"></td>
+ <td id="LC4277" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4278" class="blob-num js-line-number" data-line-number="4278"></td>
+ <td id="LC4278" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4279" class="blob-num js-line-number" data-line-number="4279"></td>
+ <td id="LC4279" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [array] The array to release.</span></td>
+ </tr>
+ <tr>
+ <td id="L4280" class="blob-num js-line-number" data-line-number="4280"></td>
+ <td id="LC4280" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4281" class="blob-num js-line-number" data-line-number="4281"></td>
+ <td id="LC4281" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">releaseArray</span>(<span class="pl-smi">array</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4282" class="blob-num js-line-number" data-line-number="4282"></td>
+ <td id="LC4282" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4283" class="blob-num js-line-number" data-line-number="4283"></td>
+ <td id="LC4283" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">arrayPool</span>.<span class="pl-c1">length</span> <span class="pl-k"><</span> maxPoolSize) {</td>
+ </tr>
+ <tr>
+ <td id="L4284" class="blob-num js-line-number" data-line-number="4284"></td>
+ <td id="LC4284" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">arrayPool</span>.<span class="pl-c1">push</span>(array);</td>
+ </tr>
+ <tr>
+ <td id="L4285" class="blob-num js-line-number" data-line-number="4285"></td>
+ <td id="LC4285" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4286" class="blob-num js-line-number" data-line-number="4286"></td>
+ <td id="LC4286" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4287" class="blob-num js-line-number" data-line-number="4287"></td>
+ <td id="LC4287" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4288" class="blob-num js-line-number" data-line-number="4288"></td>
+ <td id="LC4288" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4289" class="blob-num js-line-number" data-line-number="4289"></td>
+ <td id="LC4289" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Releases the given object back to the object pool.</span></td>
+ </tr>
+ <tr>
+ <td id="L4290" class="blob-num js-line-number" data-line-number="4290"></td>
+ <td id="LC4290" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4291" class="blob-num js-line-number" data-line-number="4291"></td>
+ <td id="LC4291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4292" class="blob-num js-line-number" data-line-number="4292"></td>
+ <td id="LC4292" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [object] The object to release.</span></td>
+ </tr>
+ <tr>
+ <td id="L4293" class="blob-num js-line-number" data-line-number="4293"></td>
+ <td id="LC4293" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4294" class="blob-num js-line-number" data-line-number="4294"></td>
+ <td id="LC4294" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">releaseObject</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4295" class="blob-num js-line-number" data-line-number="4295"></td>
+ <td id="LC4295" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> <span class="pl-smi">object</span>.<span class="pl-smi">cache</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4296" class="blob-num js-line-number" data-line-number="4296"></td>
+ <td id="LC4296" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (cache) {</td>
+ </tr>
+ <tr>
+ <td id="L4297" class="blob-num js-line-number" data-line-number="4297"></td>
+ <td id="LC4297" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseObject</span>(cache);</td>
+ </tr>
+ <tr>
+ <td id="L4298" class="blob-num js-line-number" data-line-number="4298"></td>
+ <td id="LC4298" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4299" class="blob-num js-line-number" data-line-number="4299"></td>
+ <td id="LC4299" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">object</span>.<span class="pl-smi">array</span> <span class="pl-k">=</span> <span class="pl-smi">object</span>.<span class="pl-smi">cache</span> <span class="pl-k">=</span> <span class="pl-smi">object</span>.<span class="pl-smi">criteria</span> <span class="pl-k">=</span> <span class="pl-smi">object</span>.<span class="pl-c1">object</span> <span class="pl-k">=</span> <span class="pl-smi">objec [...]
+ </tr>
+ <tr>
+ <td id="L4300" class="blob-num js-line-number" data-line-number="4300"></td>
+ <td id="LC4300" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">objectPool</span>.<span class="pl-c1">length</span> <span class="pl-k"><</span> maxPoolSize) {</td>
+ </tr>
+ <tr>
+ <td id="L4301" class="blob-num js-line-number" data-line-number="4301"></td>
+ <td id="LC4301" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">objectPool</span>.<span class="pl-c1">push</span>(object);</td>
+ </tr>
+ <tr>
+ <td id="L4302" class="blob-num js-line-number" data-line-number="4302"></td>
+ <td id="LC4302" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4303" class="blob-num js-line-number" data-line-number="4303"></td>
+ <td id="LC4303" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4304" class="blob-num js-line-number" data-line-number="4304"></td>
+ <td id="LC4304" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4305" class="blob-num js-line-number" data-line-number="4305"></td>
+ <td id="LC4305" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4306" class="blob-num js-line-number" data-line-number="4306"></td>
+ <td id="LC4306" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Slices the `collection` from the `start` index up to, but not including,</span></td>
+ </tr>
+ <tr>
+ <td id="L4307" class="blob-num js-line-number" data-line-number="4307"></td>
+ <td id="LC4307" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the `end` index.</span></td>
+ </tr>
+ <tr>
+ <td id="L4308" class="blob-num js-line-number" data-line-number="4308"></td>
+ <td id="LC4308" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4309" class="blob-num js-line-number" data-line-number="4309"></td>
+ <td id="LC4309" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: This function is used instead of `Array#slice` to support node lists</span></td>
+ </tr>
+ <tr>
+ <td id="L4310" class="blob-num js-line-number" data-line-number="4310"></td>
+ <td id="LC4310" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * in IE < 9 and to ensure dense arrays are returned.</span></td>
+ </tr>
+ <tr>
+ <td id="L4311" class="blob-num js-line-number" data-line-number="4311"></td>
+ <td id="LC4311" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4312" class="blob-num js-line-number" data-line-number="4312"></td>
+ <td id="LC4312" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4313" class="blob-num js-line-number" data-line-number="4313"></td>
+ <td id="LC4313" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to slice.</span></td>
+ </tr>
+ <tr>
+ <td id="L4314" class="blob-num js-line-number" data-line-number="4314"></td>
+ <td id="LC4314" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">start</span> The start index.</span></td>
+ </tr>
+ <tr>
+ <td id="L4315" class="blob-num js-line-number" data-line-number="4315"></td>
+ <td id="LC4315" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">end</span> The end index.</span></td>
+ </tr>
+ <tr>
+ <td id="L4316" class="blob-num js-line-number" data-line-number="4316"></td>
+ <td id="LC4316" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> the new array.</span></td>
+ </tr>
+ <tr>
+ <td id="L4317" class="blob-num js-line-number" data-line-number="4317"></td>
+ <td id="LC4317" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4318" class="blob-num js-line-number" data-line-number="4318"></td>
+ <td id="LC4318" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">slice</span>(<span class="pl-smi">array</span>, <span class="pl-smi">start</span>, <span class="pl-smi">end</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4319" class="blob-num js-line-number" data-line-number="4319"></td>
+ <td id="LC4319" class="blob-code blob-code-inner js-file-line"> start <span class="pl-k">||</span> (start <span class="pl-k">=</span> <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4320" class="blob-num js-line-number" data-line-number="4320"></td>
+ <td id="LC4320" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> end <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4321" class="blob-num js-line-number" data-line-number="4321"></td>
+ <td id="LC4321" class="blob-code blob-code-inner js-file-line"> end <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4322" class="blob-num js-line-number" data-line-number="4322"></td>
+ <td id="LC4322" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4323" class="blob-num js-line-number" data-line-number="4323"></td>
+ <td id="LC4323" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4324" class="blob-num js-line-number" data-line-number="4324"></td>
+ <td id="LC4324" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> end <span class="pl-k">-</span> start <span class="pl-k">||</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4325" class="blob-num js-line-number" data-line-number="4325"></td>
+ <td id="LC4325" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length <span class="pl-k"><</span> <span class="pl-c1">0</span> <span class="pl-k">?</span> <span class="pl-c1">0</span> <span class="pl-k">:</span> length);</td>
+ </tr>
+ <tr>
+ <td id="L4326" class="blob-num js-line-number" data-line-number="4326"></td>
+ <td id="LC4326" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4327" class="blob-num js-line-number" data-line-number="4327"></td>
+ <td id="LC4327" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L4328" class="blob-num js-line-number" data-line-number="4328"></td>
+ <td id="LC4328" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> array[start <span class="pl-k">+</span> index];</td>
+ </tr>
+ <tr>
+ <td id="L4329" class="blob-num js-line-number" data-line-number="4329"></td>
+ <td id="LC4329" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4330" class="blob-num js-line-number" data-line-number="4330"></td>
+ <td id="LC4330" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4331" class="blob-num js-line-number" data-line-number="4331"></td>
+ <td id="LC4331" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4332" class="blob-num js-line-number" data-line-number="4332"></td>
+ <td id="LC4332" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4333" class="blob-num js-line-number" data-line-number="4333"></td>
+ <td id="LC4333" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L4334" class="blob-num js-line-number" data-line-number="4334"></td>
+ <td id="LC4334" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4335" class="blob-num js-line-number" data-line-number="4335"></td>
+ <td id="LC4335" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4336" class="blob-num js-line-number" data-line-number="4336"></td>
+ <td id="LC4336" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Create a new `lodash` function using the given context object.</span></td>
+ </tr>
+ <tr>
+ <td id="L4337" class="blob-num js-line-number" data-line-number="4337"></td>
+ <td id="LC4337" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4338" class="blob-num js-line-number" data-line-number="4338"></td>
+ <td id="LC4338" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4339" class="blob-num js-line-number" data-line-number="4339"></td>
+ <td id="LC4339" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L4340" class="blob-num js-line-number" data-line-number="4340"></td>
+ <td id="LC4340" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L4341" class="blob-num js-line-number" data-line-number="4341"></td>
+ <td id="LC4341" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [context=root] The context object.</span></td>
+ </tr>
+ <tr>
+ <td id="L4342" class="blob-num js-line-number" data-line-number="4342"></td>
+ <td id="LC4342" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the `lodash` function.</span></td>
+ </tr>
+ <tr>
+ <td id="L4343" class="blob-num js-line-number" data-line-number="4343"></td>
+ <td id="LC4343" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4344" class="blob-num js-line-number" data-line-number="4344"></td>
+ <td id="LC4344" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">runInContext</span>(<span class="pl-smi">context</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4345" class="blob-num js-line-number" data-line-number="4345"></td>
+ <td id="LC4345" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Avoid issues with some ES3 environments that attempt to use values, named</span></td>
+ </tr>
+ <tr>
+ <td id="L4346" class="blob-num js-line-number" data-line-number="4346"></td>
+ <td id="LC4346" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// after built-in constructors like `Object`, for the creation of literals.</span></td>
+ </tr>
+ <tr>
+ <td id="L4347" class="blob-num js-line-number" data-line-number="4347"></td>
+ <td id="LC4347" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// ES5 clears this up by stating that literals must use built-in constructors.</span></td>
+ </tr>
+ <tr>
+ <td id="L4348" class="blob-num js-line-number" data-line-number="4348"></td>
+ <td id="LC4348" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// See http://es5.github.io/#x11.1.5.</span></td>
+ </tr>
+ <tr>
+ <td id="L4349" class="blob-num js-line-number" data-line-number="4349"></td>
+ <td id="LC4349" class="blob-code blob-code-inner js-file-line"> context <span class="pl-k">=</span> context <span class="pl-k">?</span> <span class="pl-smi">_</span>.<span class="pl-en">defaults</span>(<span class="pl-smi">root</span>.<span class="pl-en">Object</span>(), context, <span class="pl-smi">_</span>.<span class="pl-en">pick</span>(root, contextProps)) <span class="pl-k">:</span> root;</td>
+ </tr>
+ <tr>
+ <td id="L4350" class="blob-num js-line-number" data-line-number="4350"></td>
+ <td id="LC4350" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4351" class="blob-num js-line-number" data-line-number="4351"></td>
+ <td id="LC4351" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Native constructor references */</span></td>
+ </tr>
+ <tr>
+ <td id="L4352" class="blob-num js-line-number" data-line-number="4352"></td>
+ <td id="LC4352" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-c1">Array</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Array</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4353" class="blob-num js-line-number" data-line-number="4353"></td>
+ <td id="LC4353" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Boolean</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Boolean</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4354" class="blob-num js-line-number" data-line-number="4354"></td>
+ <td id="LC4354" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Date</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Date</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4355" class="blob-num js-line-number" data-line-number="4355"></td>
+ <td id="LC4355" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Function</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Function</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4356" class="blob-num js-line-number" data-line-number="4356"></td>
+ <td id="LC4356" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Math</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Math</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4357" class="blob-num js-line-number" data-line-number="4357"></td>
+ <td id="LC4357" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Number</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Number</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4358" class="blob-num js-line-number" data-line-number="4358"></td>
+ <td id="LC4358" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Object</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">Object</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4359" class="blob-num js-line-number" data-line-number="4359"></td>
+ <td id="LC4359" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">RegExp</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">RegExp</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4360" class="blob-num js-line-number" data-line-number="4360"></td>
+ <td id="LC4360" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">String</span> <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">String</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4361" class="blob-num js-line-number" data-line-number="4361"></td>
+ <td id="LC4361" class="blob-code blob-code-inner js-file-line"> TypeError <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4362" class="blob-num js-line-number" data-line-number="4362"></td>
+ <td id="LC4362" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4363" class="blob-num js-line-number" data-line-number="4363"></td>
+ <td id="LC4363" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4364" class="blob-num js-line-number" data-line-number="4364"></td>
+ <td id="LC4364" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used for `Array` method references.</span></td>
+ </tr>
+ <tr>
+ <td id="L4365" class="blob-num js-line-number" data-line-number="4365"></td>
+ <td id="LC4365" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4366" class="blob-num js-line-number" data-line-number="4366"></td>
+ <td id="LC4366" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Normally `Array.prototype` would suffice, however, using an array literal</span></td>
+ </tr>
+ <tr>
+ <td id="L4367" class="blob-num js-line-number" data-line-number="4367"></td>
+ <td id="LC4367" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * avoids issues in Narwhal.</span></td>
+ </tr>
+ <tr>
+ <td id="L4368" class="blob-num js-line-number" data-line-number="4368"></td>
+ <td id="LC4368" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4369" class="blob-num js-line-number" data-line-number="4369"></td>
+ <td id="LC4369" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> arrayRef <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L4370" class="blob-num js-line-number" data-line-number="4370"></td>
+ <td id="LC4370" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4371" class="blob-num js-line-number" data-line-number="4371"></td>
+ <td id="LC4371" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used for native method references */</span></td>
+ </tr>
+ <tr>
+ <td id="L4372" class="blob-num js-line-number" data-line-number="4372"></td>
+ <td id="LC4372" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> objectProto <span class="pl-k">=</span> <span class="pl-c1">Object</span>.<span class="pl-c1">prototype</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4373" class="blob-num js-line-number" data-line-number="4373"></td>
+ <td id="LC4373" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4374" class="blob-num js-line-number" data-line-number="4374"></td>
+ <td id="LC4374" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to restore the original `_` reference in `noConflict` */</span></td>
+ </tr>
+ <tr>
+ <td id="L4375" class="blob-num js-line-number" data-line-number="4375"></td>
+ <td id="LC4375" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> oldDash <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">_</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4376" class="blob-num js-line-number" data-line-number="4376"></td>
+ <td id="LC4376" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4377" class="blob-num js-line-number" data-line-number="4377"></td>
+ <td id="LC4377" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to resolve the internal [[Class]] of values */</span></td>
+ </tr>
+ <tr>
+ <td id="L4378" class="blob-num js-line-number" data-line-number="4378"></td>
+ <td id="LC4378" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> toString <span class="pl-k">=</span> <span class="pl-smi">objectProto</span>.<span class="pl-smi">toString</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4379" class="blob-num js-line-number" data-line-number="4379"></td>
+ <td id="LC4379" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4380" class="blob-num js-line-number" data-line-number="4380"></td>
+ <td id="LC4380" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to detect if a method is native */</span></td>
+ </tr>
+ <tr>
+ <td id="L4381" class="blob-num js-line-number" data-line-number="4381"></td>
+ <td id="LC4381" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reNative <span class="pl-k">=</span> <span class="pl-c1">RegExp</span>(<span class="pl-s"><span class="pl-pds">'</span>^<span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L4382" class="blob-num js-line-number" data-line-number="4382"></td>
+ <td id="LC4382" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">String</span>(toString)</td>
+ </tr>
+ <tr>
+ <td id="L4383" class="blob-num js-line-number" data-line-number="4383"></td>
+ <td id="LC4383" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span><span class="pl-c1">[<span class="pl-c1">.</span>*+?^${}()|[<span class="pl-cce">\]\\</span>]</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>$&<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L4384" class="blob-num js-line-number" data-line-number="4384"></td>
+ <td id="LC4384" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span>toString<span class="pl-k">|</span> for <span class="pl-c1">[<span class="pl-k">^</span><span class="pl-cce">\]</span>]</span><span class="pl-k">+</span><span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span>.*?<span class="pl-pds">'</span></span>) <span class="pl-k">+</span> <span class [...]
+ </tr>
+ <tr>
+ <td id="L4385" class="blob-num js-line-number" data-line-number="4385"></td>
+ <td id="LC4385" class="blob-code blob-code-inner js-file-line"> );</td>
+ </tr>
+ <tr>
+ <td id="L4386" class="blob-num js-line-number" data-line-number="4386"></td>
+ <td id="LC4386" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4387" class="blob-num js-line-number" data-line-number="4387"></td>
+ <td id="LC4387" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Native method shortcuts */</span></td>
+ </tr>
+ <tr>
+ <td id="L4388" class="blob-num js-line-number" data-line-number="4388"></td>
+ <td id="LC4388" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ceil <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-smi">ceil</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4389" class="blob-num js-line-number" data-line-number="4389"></td>
+ <td id="LC4389" class="blob-code blob-code-inner js-file-line"> clearTimeout <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">clearTimeout</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4390" class="blob-num js-line-number" data-line-number="4390"></td>
+ <td id="LC4390" class="blob-code blob-code-inner js-file-line"> floor <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-smi">floor</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4391" class="blob-num js-line-number" data-line-number="4391"></td>
+ <td id="LC4391" class="blob-code blob-code-inner js-file-line"> fnToString <span class="pl-k">=</span> <span class="pl-c1">Function</span>.<span class="pl-c1">prototype</span>.<span class="pl-smi">toString</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4392" class="blob-num js-line-number" data-line-number="4392"></td>
+ <td id="LC4392" class="blob-code blob-code-inner js-file-line"> getPrototypeOf <span class="pl-k">=</span> <span class="pl-en">isNative</span>(getPrototypeOf <span class="pl-k">=</span> <span class="pl-c1">Object</span>.<span class="pl-smi">getPrototypeOf</span>) <span class="pl-k">&&</span> getPrototypeOf,</td>
+ </tr>
+ <tr>
+ <td id="L4393" class="blob-num js-line-number" data-line-number="4393"></td>
+ <td id="LC4393" class="blob-code blob-code-inner js-file-line"> hasOwnProperty <span class="pl-k">=</span> <span class="pl-smi">objectProto</span>.<span class="pl-smi">hasOwnProperty</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4394" class="blob-num js-line-number" data-line-number="4394"></td>
+ <td id="LC4394" class="blob-code blob-code-inner js-file-line"> push <span class="pl-k">=</span> <span class="pl-smi">arrayRef</span>.<span class="pl-smi">push</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4395" class="blob-num js-line-number" data-line-number="4395"></td>
+ <td id="LC4395" class="blob-code blob-code-inner js-file-line"> setTimeout <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">setTimeout</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4396" class="blob-num js-line-number" data-line-number="4396"></td>
+ <td id="LC4396" class="blob-code blob-code-inner js-file-line"> splice <span class="pl-k">=</span> <span class="pl-smi">arrayRef</span>.<span class="pl-smi">splice</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4397" class="blob-num js-line-number" data-line-number="4397"></td>
+ <td id="LC4397" class="blob-code blob-code-inner js-file-line"> unshift <span class="pl-k">=</span> <span class="pl-smi">arrayRef</span>.<span class="pl-smi">unshift</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4398" class="blob-num js-line-number" data-line-number="4398"></td>
+ <td id="LC4398" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4399" class="blob-num js-line-number" data-line-number="4399"></td>
+ <td id="LC4399" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to set meta data on functions */</span></td>
+ </tr>
+ <tr>
+ <td id="L4400" class="blob-num js-line-number" data-line-number="4400"></td>
+ <td id="LC4400" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> defineProperty <span class="pl-k">=</span> (<span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L4401" class="blob-num js-line-number" data-line-number="4401"></td>
+ <td id="LC4401" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// IE 8 only accepts DOM elements</span></td>
+ </tr>
+ <tr>
+ <td id="L4402" class="blob-num js-line-number" data-line-number="4402"></td>
+ <td id="LC4402" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4403" class="blob-num js-line-number" data-line-number="4403"></td>
+ <td id="LC4403" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> o <span class="pl-k">=</span> {},</td>
+ </tr>
+ <tr>
+ <td id="L4404" class="blob-num js-line-number" data-line-number="4404"></td>
+ <td id="LC4404" class="blob-code blob-code-inner js-file-line"> func <span class="pl-k">=</span> <span class="pl-en">isNative</span>(func <span class="pl-k">=</span> <span class="pl-c1">Object</span>.<span class="pl-smi">defineProperty</span>) <span class="pl-k">&&</span> func,</td>
+ </tr>
+ <tr>
+ <td id="L4405" class="blob-num js-line-number" data-line-number="4405"></td>
+ <td id="LC4405" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-en">func</span>(o, o, o) <span class="pl-k">&&</span> func;</td>
+ </tr>
+ <tr>
+ <td id="L4406" class="blob-num js-line-number" data-line-number="4406"></td>
+ <td id="LC4406" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">catch</span>(e) { }</td>
+ </tr>
+ <tr>
+ <td id="L4407" class="blob-num js-line-number" data-line-number="4407"></td>
+ <td id="LC4407" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4408" class="blob-num js-line-number" data-line-number="4408"></td>
+ <td id="LC4408" class="blob-code blob-code-inner js-file-line"> }());</td>
+ </tr>
+ <tr>
+ <td id="L4409" class="blob-num js-line-number" data-line-number="4409"></td>
+ <td id="LC4409" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4410" class="blob-num js-line-number" data-line-number="4410"></td>
+ <td id="LC4410" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/* Native method shortcuts for methods with the same name as other `lodash` methods */</span></td>
+ </tr>
+ <tr>
+ <td id="L4411" class="blob-num js-line-number" data-line-number="4411"></td>
+ <td id="LC4411" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> nativeCreate <span class="pl-k">=</span> <span class="pl-en">isNative</span>(nativeCreate <span class="pl-k">=</span> <span class="pl-c1">Object</span>.<span class="pl-smi">create</span>) <span class="pl-k">&&</span> nativeCreate,</td>
+ </tr>
+ <tr>
+ <td id="L4412" class="blob-num js-line-number" data-line-number="4412"></td>
+ <td id="LC4412" class="blob-code blob-code-inner js-file-line"> nativeIsArray <span class="pl-k">=</span> <span class="pl-en">isNative</span>(nativeIsArray <span class="pl-k">=</span> <span class="pl-c1">Array</span>.<span class="pl-smi">isArray</span>) <span class="pl-k">&&</span> nativeIsArray,</td>
+ </tr>
+ <tr>
+ <td id="L4413" class="blob-num js-line-number" data-line-number="4413"></td>
+ <td id="LC4413" class="blob-code blob-code-inner js-file-line"> nativeIsFinite <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">isFinite</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4414" class="blob-num js-line-number" data-line-number="4414"></td>
+ <td id="LC4414" class="blob-code blob-code-inner js-file-line"> nativeIsNaN <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">isNaN</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4415" class="blob-num js-line-number" data-line-number="4415"></td>
+ <td id="LC4415" class="blob-code blob-code-inner js-file-line"> nativeKeys <span class="pl-k">=</span> <span class="pl-en">isNative</span>(nativeKeys <span class="pl-k">=</span> <span class="pl-c1">Object</span>.<span class="pl-smi">keys</span>) <span class="pl-k">&&</span> nativeKeys,</td>
+ </tr>
+ <tr>
+ <td id="L4416" class="blob-num js-line-number" data-line-number="4416"></td>
+ <td id="LC4416" class="blob-code blob-code-inner js-file-line"> nativeMax <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-smi">max</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4417" class="blob-num js-line-number" data-line-number="4417"></td>
+ <td id="LC4417" class="blob-code blob-code-inner js-file-line"> nativeMin <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-smi">min</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4418" class="blob-num js-line-number" data-line-number="4418"></td>
+ <td id="LC4418" class="blob-code blob-code-inner js-file-line"> nativeParseInt <span class="pl-k">=</span> <span class="pl-smi">context</span>.<span class="pl-smi">parseInt</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4419" class="blob-num js-line-number" data-line-number="4419"></td>
+ <td id="LC4419" class="blob-code blob-code-inner js-file-line"> nativeRandom <span class="pl-k">=</span> <span class="pl-c1">Math</span>.<span class="pl-smi">random</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4420" class="blob-num js-line-number" data-line-number="4420"></td>
+ <td id="LC4420" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4421" class="blob-num js-line-number" data-line-number="4421"></td>
+ <td id="LC4421" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to lookup a built-in constructor by [[Class]] */</span></td>
+ </tr>
+ <tr>
+ <td id="L4422" class="blob-num js-line-number" data-line-number="4422"></td>
+ <td id="LC4422" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ctorByClass <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L4423" class="blob-num js-line-number" data-line-number="4423"></td>
+ <td id="LC4423" class="blob-code blob-code-inner js-file-line"> ctorByClass[arrayClass] <span class="pl-k">=</span> <span class="pl-c1">Array</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4424" class="blob-num js-line-number" data-line-number="4424"></td>
+ <td id="LC4424" class="blob-code blob-code-inner js-file-line"> ctorByClass[boolClass] <span class="pl-k">=</span> <span class="pl-c1">Boolean</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4425" class="blob-num js-line-number" data-line-number="4425"></td>
+ <td id="LC4425" class="blob-code blob-code-inner js-file-line"> ctorByClass[dateClass] <span class="pl-k">=</span> <span class="pl-c1">Date</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4426" class="blob-num js-line-number" data-line-number="4426"></td>
+ <td id="LC4426" class="blob-code blob-code-inner js-file-line"> ctorByClass[funcClass] <span class="pl-k">=</span> <span class="pl-c1">Function</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4427" class="blob-num js-line-number" data-line-number="4427"></td>
+ <td id="LC4427" class="blob-code blob-code-inner js-file-line"> ctorByClass[objectClass] <span class="pl-k">=</span> <span class="pl-c1">Object</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4428" class="blob-num js-line-number" data-line-number="4428"></td>
+ <td id="LC4428" class="blob-code blob-code-inner js-file-line"> ctorByClass[numberClass] <span class="pl-k">=</span> <span class="pl-c1">Number</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4429" class="blob-num js-line-number" data-line-number="4429"></td>
+ <td id="LC4429" class="blob-code blob-code-inner js-file-line"> ctorByClass[regexpClass] <span class="pl-k">=</span> <span class="pl-c1">RegExp</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4430" class="blob-num js-line-number" data-line-number="4430"></td>
+ <td id="LC4430" class="blob-code blob-code-inner js-file-line"> ctorByClass[stringClass] <span class="pl-k">=</span> <span class="pl-c1">String</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4431" class="blob-num js-line-number" data-line-number="4431"></td>
+ <td id="LC4431" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4432" class="blob-num js-line-number" data-line-number="4432"></td>
+ <td id="LC4432" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L4433" class="blob-num js-line-number" data-line-number="4433"></td>
+ <td id="LC4433" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4434" class="blob-num js-line-number" data-line-number="4434"></td>
+ <td id="LC4434" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4435" class="blob-num js-line-number" data-line-number="4435"></td>
+ <td id="LC4435" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a `lodash` object which wraps the given value to enable intuitive</span></td>
+ </tr>
+ <tr>
+ <td id="L4436" class="blob-num js-line-number" data-line-number="4436"></td>
+ <td id="LC4436" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * method chaining.</span></td>
+ </tr>
+ <tr>
+ <td id="L4437" class="blob-num js-line-number" data-line-number="4437"></td>
+ <td id="LC4437" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4438" class="blob-num js-line-number" data-line-number="4438"></td>
+ <td id="LC4438" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:</span></td>
+ </tr>
+ <tr>
+ <td id="L4439" class="blob-num js-line-number" data-line-number="4439"></td>
+ <td id="LC4439" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4440" class="blob-num js-line-number" data-line-number="4440"></td>
+ <td id="LC4440" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and `unshift`</span></td>
+ </tr>
+ <tr>
+ <td id="L4441" class="blob-num js-line-number" data-line-number="4441"></td>
+ <td id="LC4441" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4442" class="blob-num js-line-number" data-line-number="4442"></td>
+ <td id="LC4442" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Chaining is supported in custom builds as long as the `value` method is</span></td>
+ </tr>
+ <tr>
+ <td id="L4443" class="blob-num js-line-number" data-line-number="4443"></td>
+ <td id="LC4443" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * implicitly or explicitly included in the build.</span></td>
+ </tr>
+ <tr>
+ <td id="L4444" class="blob-num js-line-number" data-line-number="4444"></td>
+ <td id="LC4444" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4445" class="blob-num js-line-number" data-line-number="4445"></td>
+ <td id="LC4445" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The chainable wrapper functions are:</span></td>
+ </tr>
+ <tr>
+ <td id="L4446" class="blob-num js-line-number" data-line-number="4446"></td>
+ <td id="LC4446" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4447" class="blob-num js-line-number" data-line-number="4447"></td>
+ <td id="LC4447" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4448" class="blob-num js-line-number" data-line-number="4448"></td>
+ <td id="LC4448" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4449" class="blob-num js-line-number" data-line-number="4449"></td>
+ <td id="LC4449" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4450" class="blob-num js-line-number" data-line-number="4450"></td>
+ <td id="LC4450" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4451" class="blob-num js-line-number" data-line-number="4451"></td>
+ <td id="LC4451" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4452" class="blob-num js-line-number" data-line-number="4452"></td>
+ <td id="LC4452" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4453" class="blob-num js-line-number" data-line-number="4453"></td>
+ <td id="LC4453" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4454" class="blob-num js-line-number" data-line-number="4454"></td>
+ <td id="LC4454" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4455" class="blob-num js-line-number" data-line-number="4455"></td>
+ <td id="LC4455" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4456" class="blob-num js-line-number" data-line-number="4456"></td>
+ <td id="LC4456" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and `zip`</span></td>
+ </tr>
+ <tr>
+ <td id="L4457" class="blob-num js-line-number" data-line-number="4457"></td>
+ <td id="LC4457" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4458" class="blob-num js-line-number" data-line-number="4458"></td>
+ <td id="LC4458" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The non-chainable wrapper functions are:</span></td>
+ </tr>
+ <tr>
+ <td id="L4459" class="blob-num js-line-number" data-line-number="4459"></td>
+ <td id="LC4459" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4460" class="blob-num js-line-number" data-line-number="4460"></td>
+ <td id="LC4460" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4461" class="blob-num js-line-number" data-line-number="4461"></td>
+ <td id="LC4461" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4462" class="blob-num js-line-number" data-line-number="4462"></td>
+ <td id="LC4462" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4463" class="blob-num js-line-number" data-line-number="4463"></td>
+ <td id="LC4463" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4464" class="blob-num js-line-number" data-line-number="4464"></td>
+ <td id="LC4464" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4465" class="blob-num js-line-number" data-line-number="4465"></td>
+ <td id="LC4465" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`,</span></td>
+ </tr>
+ <tr>
+ <td id="L4466" class="blob-num js-line-number" data-line-number="4466"></td>
+ <td id="LC4466" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `template`, `unescape`, `uniqueId`, and `value`</span></td>
+ </tr>
+ <tr>
+ <td id="L4467" class="blob-num js-line-number" data-line-number="4467"></td>
+ <td id="LC4467" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4468" class="blob-num js-line-number" data-line-number="4468"></td>
+ <td id="LC4468" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The wrapper functions `first` and `last` return wrapped values when `n` is</span></td>
+ </tr>
+ <tr>
+ <td id="L4469" class="blob-num js-line-number" data-line-number="4469"></td>
+ <td id="LC4469" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided, otherwise they return unwrapped values.</span></td>
+ </tr>
+ <tr>
+ <td id="L4470" class="blob-num js-line-number" data-line-number="4470"></td>
+ <td id="LC4470" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4471" class="blob-num js-line-number" data-line-number="4471"></td>
+ <td id="LC4471" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Explicit chaining can be enabled by using the `_.chain` method.</span></td>
+ </tr>
+ <tr>
+ <td id="L4472" class="blob-num js-line-number" data-line-number="4472"></td>
+ <td id="LC4472" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4473" class="blob-num js-line-number" data-line-number="4473"></td>
+ <td id="LC4473" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@name</span> _</span></td>
+ </tr>
+ <tr>
+ <td id="L4474" class="blob-num js-line-number" data-line-number="4474"></td>
+ <td id="LC4474" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@constructor</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4475" class="blob-num js-line-number" data-line-number="4475"></td>
+ <td id="LC4475" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L4476" class="blob-num js-line-number" data-line-number="4476"></td>
+ <td id="LC4476" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to wrap in a `lodash` instance.</span></td>
+ </tr>
+ <tr>
+ <td id="L4477" class="blob-num js-line-number" data-line-number="4477"></td>
+ <td id="LC4477" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> a `lodash` instance.</span></td>
+ </tr>
+ <tr>
+ <td id="L4478" class="blob-num js-line-number" data-line-number="4478"></td>
+ <td id="LC4478" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4479" class="blob-num js-line-number" data-line-number="4479"></td>
+ <td id="LC4479" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4480" class="blob-num js-line-number" data-line-number="4480"></td>
+ <td id="LC4480" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var wrapped = _([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L4481" class="blob-num js-line-number" data-line-number="4481"></td>
+ <td id="LC4481" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4482" class="blob-num js-line-number" data-line-number="4482"></td>
+ <td id="LC4482" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // returns an unwrapped value</span></td>
+ </tr>
+ <tr>
+ <td id="L4483" class="blob-num js-line-number" data-line-number="4483"></td>
+ <td id="LC4483" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * wrapped.reduce(function(sum, num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L4484" class="blob-num js-line-number" data-line-number="4484"></td>
+ <td id="LC4484" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return sum + num;</span></td>
+ </tr>
+ <tr>
+ <td id="L4485" class="blob-num js-line-number" data-line-number="4485"></td>
+ <td id="LC4485" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L4486" class="blob-num js-line-number" data-line-number="4486"></td>
+ <td id="LC4486" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 6</span></td>
+ </tr>
+ <tr>
+ <td id="L4487" class="blob-num js-line-number" data-line-number="4487"></td>
+ <td id="LC4487" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4488" class="blob-num js-line-number" data-line-number="4488"></td>
+ <td id="LC4488" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // returns a wrapped value</span></td>
+ </tr>
+ <tr>
+ <td id="L4489" class="blob-num js-line-number" data-line-number="4489"></td>
+ <td id="LC4489" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var squares = wrapped.map(function(num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L4490" class="blob-num js-line-number" data-line-number="4490"></td>
+ <td id="LC4490" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return num * num;</span></td>
+ </tr>
+ <tr>
+ <td id="L4491" class="blob-num js-line-number" data-line-number="4491"></td>
+ <td id="LC4491" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L4492" class="blob-num js-line-number" data-line-number="4492"></td>
+ <td id="LC4492" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4493" class="blob-num js-line-number" data-line-number="4493"></td>
+ <td id="LC4493" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isArray(squares);</span></td>
+ </tr>
+ <tr>
+ <td id="L4494" class="blob-num js-line-number" data-line-number="4494"></td>
+ <td id="LC4494" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L4495" class="blob-num js-line-number" data-line-number="4495"></td>
+ <td id="LC4495" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4496" class="blob-num js-line-number" data-line-number="4496"></td>
+ <td id="LC4496" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isArray(squares.value());</span></td>
+ </tr>
+ <tr>
+ <td id="L4497" class="blob-num js-line-number" data-line-number="4497"></td>
+ <td id="LC4497" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L4498" class="blob-num js-line-number" data-line-number="4498"></td>
+ <td id="LC4498" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4499" class="blob-num js-line-number" data-line-number="4499"></td>
+ <td id="LC4499" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">lodash</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4500" class="blob-num js-line-number" data-line-number="4500"></td>
+ <td id="LC4500" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// don't wrap if already wrapped, even if wrapped by a different `lodash` constructor</span></td>
+ </tr>
+ <tr>
+ <td id="L4501" class="blob-num js-line-number" data-line-number="4501"></td>
+ <td id="LC4501" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-en">isArray</span>(value) <span class="pl-k">&&</span> <span class="pl-smi">hasOwnP [...]
+ </tr>
+ <tr>
+ <td id="L4502" class="blob-num js-line-number" data-line-number="4502"></td>
+ <td id="LC4502" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> value</td>
+ </tr>
+ <tr>
+ <td id="L4503" class="blob-num js-line-number" data-line-number="4503"></td>
+ <td id="LC4503" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-k">new</span> <span class="pl-en">lodashWrapper</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4504" class="blob-num js-line-number" data-line-number="4504"></td>
+ <td id="LC4504" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4505" class="blob-num js-line-number" data-line-number="4505"></td>
+ <td id="LC4505" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4506" class="blob-num js-line-number" data-line-number="4506"></td>
+ <td id="LC4506" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4507" class="blob-num js-line-number" data-line-number="4507"></td>
+ <td id="LC4507" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A fast path for creating `lodash` wrapper objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L4508" class="blob-num js-line-number" data-line-number="4508"></td>
+ <td id="LC4508" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4509" class="blob-num js-line-number" data-line-number="4509"></td>
+ <td id="LC4509" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4510" class="blob-num js-line-number" data-line-number="4510"></td>
+ <td id="LC4510" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to wrap in a `lodash` instance.</span></td>
+ </tr>
+ <tr>
+ <td id="L4511" class="blob-num js-line-number" data-line-number="4511"></td>
+ <td id="LC4511" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">chainAll</span> A flag to enable chaining for all methods</span></td>
+ </tr>
+ <tr>
+ <td id="L4512" class="blob-num js-line-number" data-line-number="4512"></td>
+ <td id="LC4512" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> a `lodash` instance.</span></td>
+ </tr>
+ <tr>
+ <td id="L4513" class="blob-num js-line-number" data-line-number="4513"></td>
+ <td id="LC4513" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4514" class="blob-num js-line-number" data-line-number="4514"></td>
+ <td id="LC4514" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">lodashWrapper</span>(<span class="pl-smi">value</span>, <span class="pl-smi">chainAll</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4515" class="blob-num js-line-number" data-line-number="4515"></td>
+ <td id="LC4515" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">__chain__</span> <span class="pl-k">=</span> <span class="pl-k">!!</span>chainAll;</td>
+ </tr>
+ <tr>
+ <td id="L4516" class="blob-num js-line-number" data-line-number="4516"></td>
+ <td id="LC4516" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span> <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L4517" class="blob-num js-line-number" data-line-number="4517"></td>
+ <td id="LC4517" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4518" class="blob-num js-line-number" data-line-number="4518"></td>
+ <td id="LC4518" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// ensure `new lodashWrapper` is an instance of `lodash`</span></td>
+ </tr>
+ <tr>
+ <td id="L4519" class="blob-num js-line-number" data-line-number="4519"></td>
+ <td id="LC4519" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodashWrapper</span>.<span class="pl-c1">prototype</span> <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4520" class="blob-num js-line-number" data-line-number="4520"></td>
+ <td id="LC4520" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4521" class="blob-num js-line-number" data-line-number="4521"></td>
+ <td id="LC4521" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4522" class="blob-num js-line-number" data-line-number="4522"></td>
+ <td id="LC4522" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * An object used to flag environments features.</span></td>
+ </tr>
+ <tr>
+ <td id="L4523" class="blob-num js-line-number" data-line-number="4523"></td>
+ <td id="LC4523" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4524" class="blob-num js-line-number" data-line-number="4524"></td>
+ <td id="LC4524" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4525" class="blob-num js-line-number" data-line-number="4525"></td>
+ <td id="LC4525" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L4526" class="blob-num js-line-number" data-line-number="4526"></td>
+ <td id="LC4526" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Object</span></td>
+ </tr>
+ <tr>
+ <td id="L4527" class="blob-num js-line-number" data-line-number="4527"></td>
+ <td id="LC4527" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4528" class="blob-num js-line-number" data-line-number="4528"></td>
+ <td id="LC4528" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> support <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-smi">support</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L4529" class="blob-num js-line-number" data-line-number="4529"></td>
+ <td id="LC4529" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4530" class="blob-num js-line-number" data-line-number="4530"></td>
+ <td id="LC4530" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4531" class="blob-num js-line-number" data-line-number="4531"></td>
+ <td id="LC4531" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Detect if functions can be decompiled by `Function#toString`</span></td>
+ </tr>
+ <tr>
+ <td id="L4532" class="blob-num js-line-number" data-line-number="4532"></td>
+ <td id="LC4532" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).</span></td>
+ </tr>
+ <tr>
+ <td id="L4533" class="blob-num js-line-number" data-line-number="4533"></td>
+ <td id="LC4533" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4534" class="blob-num js-line-number" data-line-number="4534"></td>
+ <td id="LC4534" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.support</span></td>
+ </tr>
+ <tr>
+ <td id="L4535" class="blob-num js-line-number" data-line-number="4535"></td>
+ <td id="LC4535" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> boolean</span></td>
+ </tr>
+ <tr>
+ <td id="L4536" class="blob-num js-line-number" data-line-number="4536"></td>
+ <td id="LC4536" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4537" class="blob-num js-line-number" data-line-number="4537"></td>
+ <td id="LC4537" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">support</span>.<span class="pl-smi">funcDecomp</span> <span class="pl-k">=</span> <span class="pl-k">!</span><span class="pl-en">isNative</span>(<span class="pl-smi">context</span>.<span class="pl-smi">WinRTError</span>) <span class="pl-k">&&</span> <span class="pl-smi">reThis</span>.<span class="pl-c1">test</span>(runInContext);</td>
+ </tr>
+ <tr>
+ <td id="L4538" class="blob-num js-line-number" data-line-number="4538"></td>
+ <td id="LC4538" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4539" class="blob-num js-line-number" data-line-number="4539"></td>
+ <td id="LC4539" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4540" class="blob-num js-line-number" data-line-number="4540"></td>
+ <td id="LC4540" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Detect if `Function#name` is supported (all but IE).</span></td>
+ </tr>
+ <tr>
+ <td id="L4541" class="blob-num js-line-number" data-line-number="4541"></td>
+ <td id="LC4541" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4542" class="blob-num js-line-number" data-line-number="4542"></td>
+ <td id="LC4542" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.support</span></td>
+ </tr>
+ <tr>
+ <td id="L4543" class="blob-num js-line-number" data-line-number="4543"></td>
+ <td id="LC4543" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> boolean</span></td>
+ </tr>
+ <tr>
+ <td id="L4544" class="blob-num js-line-number" data-line-number="4544"></td>
+ <td id="LC4544" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4545" class="blob-num js-line-number" data-line-number="4545"></td>
+ <td id="LC4545" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">support</span>.<span class="pl-smi">funcNames</span> <span class="pl-k">=</span> <span class="pl-k">typeof</span> <span class="pl-c1">Function</span>.<span class="pl-c1">name</span> <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>string<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L4546" class="blob-num js-line-number" data-line-number="4546"></td>
+ <td id="LC4546" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4547" class="blob-num js-line-number" data-line-number="4547"></td>
+ <td id="LC4547" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4548" class="blob-num js-line-number" data-line-number="4548"></td>
+ <td id="LC4548" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * By default, the template delimiters used by Lo-Dash are similar to those in</span></td>
+ </tr>
+ <tr>
+ <td id="L4549" class="blob-num js-line-number" data-line-number="4549"></td>
+ <td id="LC4549" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * embedded Ruby (ERB). Change the following template settings to use alternative</span></td>
+ </tr>
+ <tr>
+ <td id="L4550" class="blob-num js-line-number" data-line-number="4550"></td>
+ <td id="LC4550" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * delimiters.</span></td>
+ </tr>
+ <tr>
+ <td id="L4551" class="blob-num js-line-number" data-line-number="4551"></td>
+ <td id="LC4551" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4552" class="blob-num js-line-number" data-line-number="4552"></td>
+ <td id="LC4552" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4553" class="blob-num js-line-number" data-line-number="4553"></td>
+ <td id="LC4553" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L4554" class="blob-num js-line-number" data-line-number="4554"></td>
+ <td id="LC4554" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Object</span></td>
+ </tr>
+ <tr>
+ <td id="L4555" class="blob-num js-line-number" data-line-number="4555"></td>
+ <td id="LC4555" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4556" class="blob-num js-line-number" data-line-number="4556"></td>
+ <td id="LC4556" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">templateSettings</span> <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4557" class="blob-num js-line-number" data-line-number="4557"></td>
+ <td id="LC4557" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4558" class="blob-num js-line-number" data-line-number="4558"></td>
+ <td id="LC4558" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4559" class="blob-num js-line-number" data-line-number="4559"></td>
+ <td id="LC4559" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to detect `data` property values to be HTML-escaped.</span></td>
+ </tr>
+ <tr>
+ <td id="L4560" class="blob-num js-line-number" data-line-number="4560"></td>
+ <td id="LC4560" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4561" class="blob-num js-line-number" data-line-number="4561"></td>
+ <td id="LC4561" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.templateSettings</span></td>
+ </tr>
+ <tr>
+ <td id="L4562" class="blob-num js-line-number" data-line-number="4562"></td>
+ <td id="LC4562" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> RegExp</span></td>
+ </tr>
+ <tr>
+ <td id="L4563" class="blob-num js-line-number" data-line-number="4563"></td>
+ <td id="LC4563" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4564" class="blob-num js-line-number" data-line-number="4564"></td>
+ <td id="LC4564" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>escape<span class="pl-pds">'</span></span><span class="pl-k">:</span><span class="pl-sr"> <span class="pl-pds">/</span><%-(<span class="pl-c1">[<span class="pl-c1">\s\S</span>]</span><span class="pl-k">+?</span>)%><span class="pl-pds">/</span>g</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4565" class="blob-num js-line-number" data-line-number="4565"></td>
+ <td id="LC4565" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4566" class="blob-num js-line-number" data-line-number="4566"></td>
+ <td id="LC4566" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4567" class="blob-num js-line-number" data-line-number="4567"></td>
+ <td id="LC4567" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to detect code to be evaluated.</span></td>
+ </tr>
+ <tr>
+ <td id="L4568" class="blob-num js-line-number" data-line-number="4568"></td>
+ <td id="LC4568" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4569" class="blob-num js-line-number" data-line-number="4569"></td>
+ <td id="LC4569" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.templateSettings</span></td>
+ </tr>
+ <tr>
+ <td id="L4570" class="blob-num js-line-number" data-line-number="4570"></td>
+ <td id="LC4570" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> RegExp</span></td>
+ </tr>
+ <tr>
+ <td id="L4571" class="blob-num js-line-number" data-line-number="4571"></td>
+ <td id="LC4571" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4572" class="blob-num js-line-number" data-line-number="4572"></td>
+ <td id="LC4572" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>evaluate<span class="pl-pds">'</span></span><span class="pl-k">:</span><span class="pl-sr"> <span class="pl-pds">/</span><%(<span class="pl-c1">[<span class="pl-c1">\s\S</span>]</span><span class="pl-k">+?</span>)%><span class="pl-pds">/</span>g</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4573" class="blob-num js-line-number" data-line-number="4573"></td>
+ <td id="LC4573" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4574" class="blob-num js-line-number" data-line-number="4574"></td>
+ <td id="LC4574" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4575" class="blob-num js-line-number" data-line-number="4575"></td>
+ <td id="LC4575" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to detect `data` property values to inject.</span></td>
+ </tr>
+ <tr>
+ <td id="L4576" class="blob-num js-line-number" data-line-number="4576"></td>
+ <td id="LC4576" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4577" class="blob-num js-line-number" data-line-number="4577"></td>
+ <td id="LC4577" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.templateSettings</span></td>
+ </tr>
+ <tr>
+ <td id="L4578" class="blob-num js-line-number" data-line-number="4578"></td>
+ <td id="LC4578" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> RegExp</span></td>
+ </tr>
+ <tr>
+ <td id="L4579" class="blob-num js-line-number" data-line-number="4579"></td>
+ <td id="LC4579" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4580" class="blob-num js-line-number" data-line-number="4580"></td>
+ <td id="LC4580" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>interpolate<span class="pl-pds">'</span></span><span class="pl-k">:</span> reInterpolate,</td>
+ </tr>
+ <tr>
+ <td id="L4581" class="blob-num js-line-number" data-line-number="4581"></td>
+ <td id="LC4581" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4582" class="blob-num js-line-number" data-line-number="4582"></td>
+ <td id="LC4582" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4583" class="blob-num js-line-number" data-line-number="4583"></td>
+ <td id="LC4583" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to reference the data object in the template text.</span></td>
+ </tr>
+ <tr>
+ <td id="L4584" class="blob-num js-line-number" data-line-number="4584"></td>
+ <td id="LC4584" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4585" class="blob-num js-line-number" data-line-number="4585"></td>
+ <td id="LC4585" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.templateSettings</span></td>
+ </tr>
+ <tr>
+ <td id="L4586" class="blob-num js-line-number" data-line-number="4586"></td>
+ <td id="LC4586" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> string</span></td>
+ </tr>
+ <tr>
+ <td id="L4587" class="blob-num js-line-number" data-line-number="4587"></td>
+ <td id="LC4587" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4588" class="blob-num js-line-number" data-line-number="4588"></td>
+ <td id="LC4588" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>variable<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L4589" class="blob-num js-line-number" data-line-number="4589"></td>
+ <td id="LC4589" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4590" class="blob-num js-line-number" data-line-number="4590"></td>
+ <td id="LC4590" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4591" class="blob-num js-line-number" data-line-number="4591"></td>
+ <td id="LC4591" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to import variables into the compiled template.</span></td>
+ </tr>
+ <tr>
+ <td id="L4592" class="blob-num js-line-number" data-line-number="4592"></td>
+ <td id="LC4592" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4593" class="blob-num js-line-number" data-line-number="4593"></td>
+ <td id="LC4593" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.templateSettings</span></td>
+ </tr>
+ <tr>
+ <td id="L4594" class="blob-num js-line-number" data-line-number="4594"></td>
+ <td id="LC4594" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Object</span></td>
+ </tr>
+ <tr>
+ <td id="L4595" class="blob-num js-line-number" data-line-number="4595"></td>
+ <td id="LC4595" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4596" class="blob-num js-line-number" data-line-number="4596"></td>
+ <td id="LC4596" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>imports<span class="pl-pds">'</span></span><span class="pl-k">:</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4597" class="blob-num js-line-number" data-line-number="4597"></td>
+ <td id="LC4597" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4598" class="blob-num js-line-number" data-line-number="4598"></td>
+ <td id="LC4598" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4599" class="blob-num js-line-number" data-line-number="4599"></td>
+ <td id="LC4599" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A reference to the `lodash` function.</span></td>
+ </tr>
+ <tr>
+ <td id="L4600" class="blob-num js-line-number" data-line-number="4600"></td>
+ <td id="LC4600" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4601" class="blob-num js-line-number" data-line-number="4601"></td>
+ <td id="LC4601" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _.templateSettings.imports</span></td>
+ </tr>
+ <tr>
+ <td id="L4602" class="blob-num js-line-number" data-line-number="4602"></td>
+ <td id="LC4602" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L4603" class="blob-num js-line-number" data-line-number="4603"></td>
+ <td id="LC4603" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4604" class="blob-num js-line-number" data-line-number="4604"></td>
+ <td id="LC4604" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>_<span class="pl-pds">'</span></span><span class="pl-k">:</span> lodash</td>
+ </tr>
+ <tr>
+ <td id="L4605" class="blob-num js-line-number" data-line-number="4605"></td>
+ <td id="LC4605" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4606" class="blob-num js-line-number" data-line-number="4606"></td>
+ <td id="LC4606" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4607" class="blob-num js-line-number" data-line-number="4607"></td>
+ <td id="LC4607" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4608" class="blob-num js-line-number" data-line-number="4608"></td>
+ <td id="LC4608" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L4609" class="blob-num js-line-number" data-line-number="4609"></td>
+ <td id="LC4609" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4610" class="blob-num js-line-number" data-line-number="4610"></td>
+ <td id="LC4610" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4611" class="blob-num js-line-number" data-line-number="4611"></td>
+ <td id="LC4611" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.bind` that creates the bound function and</span></td>
+ </tr>
+ <tr>
+ <td id="L4612" class="blob-num js-line-number" data-line-number="4612"></td>
+ <td id="LC4612" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * sets its meta data.</span></td>
+ </tr>
+ <tr>
+ <td id="L4613" class="blob-num js-line-number" data-line-number="4613"></td>
+ <td id="LC4613" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4614" class="blob-num js-line-number" data-line-number="4614"></td>
+ <td id="LC4614" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4615" class="blob-num js-line-number" data-line-number="4615"></td>
+ <td id="LC4615" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">bindData</span> The bind data array.</span></td>
+ </tr>
+ <tr>
+ <td id="L4616" class="blob-num js-line-number" data-line-number="4616"></td>
+ <td id="LC4616" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new bound function.</span></td>
+ </tr>
+ <tr>
+ <td id="L4617" class="blob-num js-line-number" data-line-number="4617"></td>
+ <td id="LC4617" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4618" class="blob-num js-line-number" data-line-number="4618"></td>
+ <td id="LC4618" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseBind</span>(<span class="pl-smi">bindData</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4619" class="blob-num js-line-number" data-line-number="4619"></td>
+ <td id="LC4619" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> func <span class="pl-k">=</span> bindData[<span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4620" class="blob-num js-line-number" data-line-number="4620"></td>
+ <td id="LC4620" class="blob-code blob-code-inner js-file-line"> partialArgs <span class="pl-k">=</span> bindData[<span class="pl-c1">2</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4621" class="blob-num js-line-number" data-line-number="4621"></td>
+ <td id="LC4621" class="blob-code blob-code-inner js-file-line"> thisArg <span class="pl-k">=</span> bindData[<span class="pl-c1">4</span>];</td>
+ </tr>
+ <tr>
+ <td id="L4622" class="blob-num js-line-number" data-line-number="4622"></td>
+ <td id="LC4622" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4623" class="blob-num js-line-number" data-line-number="4623"></td>
+ <td id="LC4623" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">bound</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L4624" class="blob-num js-line-number" data-line-number="4624"></td>
+ <td id="LC4624" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// `Function#bind` spec</span></td>
+ </tr>
+ <tr>
+ <td id="L4625" class="blob-num js-line-number" data-line-number="4625"></td>
+ <td id="LC4625" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://es5.github.io/#x15.3.4.5</span></td>
+ </tr>
+ <tr>
+ <td id="L4626" class="blob-num js-line-number" data-line-number="4626"></td>
+ <td id="LC4626" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (partialArgs) {</td>
+ </tr>
+ <tr>
+ <td id="L4627" class="blob-num js-line-number" data-line-number="4627"></td>
+ <td id="LC4627" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// avoid `arguments` object deoptimizations by using `slice` instead</span></td>
+ </tr>
+ <tr>
+ <td id="L4628" class="blob-num js-line-number" data-line-number="4628"></td>
+ <td id="LC4628" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// of `Array.prototype.slice.call` and not assigning `arguments` to a</span></td>
+ </tr>
+ <tr>
+ <td id="L4629" class="blob-num js-line-number" data-line-number="4629"></td>
+ <td id="LC4629" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// variable as a ternary expression</span></td>
+ </tr>
+ <tr>
+ <td id="L4630" class="blob-num js-line-number" data-line-number="4630"></td>
+ <td id="LC4630" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-en">slice</span>(partialArgs);</td>
+ </tr>
+ <tr>
+ <td id="L4631" class="blob-num js-line-number" data-line-number="4631"></td>
+ <td id="LC4631" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">push</span>.<span class="pl-c1">apply</span>(args, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4632" class="blob-num js-line-number" data-line-number="4632"></td>
+ <td id="LC4632" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4633" class="blob-num js-line-number" data-line-number="4633"></td>
+ <td id="LC4633" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// mimic the constructor's `return` behavior</span></td>
+ </tr>
+ <tr>
+ <td id="L4634" class="blob-num js-line-number" data-line-number="4634"></td>
+ <td id="LC4634" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://es5.github.io/#x13.2.2</span></td>
+ </tr>
+ <tr>
+ <td id="L4635" class="blob-num js-line-number" data-line-number="4635"></td>
+ <td id="LC4635" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span> <span class="pl-k">instanceof</span> bound) {</td>
+ </tr>
+ <tr>
+ <td id="L4636" class="blob-num js-line-number" data-line-number="4636"></td>
+ <td id="LC4636" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// ensure `new bound` is an instance of `func`</span></td>
+ </tr>
+ <tr>
+ <td id="L4637" class="blob-num js-line-number" data-line-number="4637"></td>
+ <td id="LC4637" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> thisBinding <span class="pl-k">=</span> <span class="pl-en">baseCreate</span>(<span class="pl-smi">func</span>.<span class="pl-c1">prototype</span>),</td>
+ </tr>
+ <tr>
+ <td id="L4638" class="blob-num js-line-number" data-line-number="4638"></td>
+ <td id="LC4638" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisBinding, args <span class="pl-k">||</span> <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4639" class="blob-num js-line-number" data-line-number="4639"></td>
+ <td id="LC4639" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">isObject</span>(result) <span class="pl-k">?</span> result <span class="pl-k">:</span> thisBinding;</td>
+ </tr>
+ <tr>
+ <td id="L4640" class="blob-num js-line-number" data-line-number="4640"></td>
+ <td id="LC4640" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4641" class="blob-num js-line-number" data-line-number="4641"></td>
+ <td id="LC4641" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisArg, args <span class="pl-k">||</span> <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4642" class="blob-num js-line-number" data-line-number="4642"></td>
+ <td id="LC4642" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4643" class="blob-num js-line-number" data-line-number="4643"></td>
+ <td id="LC4643" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">setBindData</span>(bound, bindData);</td>
+ </tr>
+ <tr>
+ <td id="L4644" class="blob-num js-line-number" data-line-number="4644"></td>
+ <td id="LC4644" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> bound;</td>
+ </tr>
+ <tr>
+ <td id="L4645" class="blob-num js-line-number" data-line-number="4645"></td>
+ <td id="LC4645" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4646" class="blob-num js-line-number" data-line-number="4646"></td>
+ <td id="LC4646" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4647" class="blob-num js-line-number" data-line-number="4647"></td>
+ <td id="LC4647" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4648" class="blob-num js-line-number" data-line-number="4648"></td>
+ <td id="LC4648" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.clone` without argument juggling or support</span></td>
+ </tr>
+ <tr>
+ <td id="L4649" class="blob-num js-line-number" data-line-number="4649"></td>
+ <td id="LC4649" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for `thisArg` binding.</span></td>
+ </tr>
+ <tr>
+ <td id="L4650" class="blob-num js-line-number" data-line-number="4650"></td>
+ <td id="LC4650" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4651" class="blob-num js-line-number" data-line-number="4651"></td>
+ <td id="LC4651" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4652" class="blob-num js-line-number" data-line-number="4652"></td>
+ <td id="LC4652" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to clone.</span></td>
+ </tr>
+ <tr>
+ <td id="L4653" class="blob-num js-line-number" data-line-number="4653"></td>
+ <td id="LC4653" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isDeep=false] Specify a deep clone.</span></td>
+ </tr>
+ <tr>
+ <td id="L4654" class="blob-num js-line-number" data-line-number="4654"></td>
+ <td id="LC4654" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize cloning values.</span></td>
+ </tr>
+ <tr>
+ <td id="L4655" class="blob-num js-line-number" data-line-number="4655"></td>
+ <td id="LC4655" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [stackA=[]] Tracks traversed source objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L4656" class="blob-num js-line-number" data-line-number="4656"></td>
+ <td id="LC4656" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [stackB=[]] Associates clones with source counterparts.</span></td>
+ </tr>
+ <tr>
+ <td id="L4657" class="blob-num js-line-number" data-line-number="4657"></td>
+ <td id="LC4657" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the cloned value.</span></td>
+ </tr>
+ <tr>
+ <td id="L4658" class="blob-num js-line-number" data-line-number="4658"></td>
+ <td id="LC4658" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4659" class="blob-num js-line-number" data-line-number="4659"></td>
+ <td id="LC4659" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseClone</span>(<span class="pl-smi">value</span>, <span class="pl-smi">isDeep</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">stackA</span>, <span class="pl-smi">stackB</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4660" class="blob-num js-line-number" data-line-number="4660"></td>
+ <td id="LC4660" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback) {</td>
+ </tr>
+ <tr>
+ <td id="L4661" class="blob-num js-line-number" data-line-number="4661"></td>
+ <td id="LC4661" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-en">callback</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4662" class="blob-num js-line-number" data-line-number="4662"></td>
+ <td id="LC4662" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> result <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4663" class="blob-num js-line-number" data-line-number="4663"></td>
+ <td id="LC4663" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4664" class="blob-num js-line-number" data-line-number="4664"></td>
+ <td id="LC4664" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4665" class="blob-num js-line-number" data-line-number="4665"></td>
+ <td id="LC4665" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4666" class="blob-num js-line-number" data-line-number="4666"></td>
+ <td id="LC4666" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// inspect [[Class]]</span></td>
+ </tr>
+ <tr>
+ <td id="L4667" class="blob-num js-line-number" data-line-number="4667"></td>
+ <td id="LC4667" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isObj <span class="pl-k">=</span> <span class="pl-en">isObject</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4668" class="blob-num js-line-number" data-line-number="4668"></td>
+ <td id="LC4668" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isObj) {</td>
+ </tr>
+ <tr>
+ <td id="L4669" class="blob-num js-line-number" data-line-number="4669"></td>
+ <td id="LC4669" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> className <span class="pl-k">=</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4670" class="blob-num js-line-number" data-line-number="4670"></td>
+ <td id="LC4670" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>cloneableClasses[className]) {</td>
+ </tr>
+ <tr>
+ <td id="L4671" class="blob-num js-line-number" data-line-number="4671"></td>
+ <td id="LC4671" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L4672" class="blob-num js-line-number" data-line-number="4672"></td>
+ <td id="LC4672" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4673" class="blob-num js-line-number" data-line-number="4673"></td>
+ <td id="LC4673" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ctor <span class="pl-k">=</span> ctorByClass[className];</td>
+ </tr>
+ <tr>
+ <td id="L4674" class="blob-num js-line-number" data-line-number="4674"></td>
+ <td id="LC4674" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">switch</span> (className) {</td>
+ </tr>
+ <tr>
+ <td id="L4675" class="blob-num js-line-number" data-line-number="4675"></td>
+ <td id="LC4675" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> boolClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L4676" class="blob-num js-line-number" data-line-number="4676"></td>
+ <td id="LC4676" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> dateClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L4677" class="blob-num js-line-number" data-line-number="4677"></td>
+ <td id="LC4677" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">new</span> <span class="pl-en">ctor</span>(<span class="pl-k">+</span>value);</td>
+ </tr>
+ <tr>
+ <td id="L4678" class="blob-num js-line-number" data-line-number="4678"></td>
+ <td id="LC4678" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4679" class="blob-num js-line-number" data-line-number="4679"></td>
+ <td id="LC4679" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> numberClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L4680" class="blob-num js-line-number" data-line-number="4680"></td>
+ <td id="LC4680" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> stringClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L4681" class="blob-num js-line-number" data-line-number="4681"></td>
+ <td id="LC4681" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">new</span> <span class="pl-en">ctor</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4682" class="blob-num js-line-number" data-line-number="4682"></td>
+ <td id="LC4682" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4683" class="blob-num js-line-number" data-line-number="4683"></td>
+ <td id="LC4683" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> regexpClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L4684" class="blob-num js-line-number" data-line-number="4684"></td>
+ <td id="LC4684" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-en">ctor</span>(<span class="pl-smi">value</span>.<span class="pl-c1">source</span>, <span class="pl-smi">reFlags</span>.<span class="pl-c1">exec</span>(value));</td>
+ </tr>
+ <tr>
+ <td id="L4685" class="blob-num js-line-number" data-line-number="4685"></td>
+ <td id="LC4685" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">lastIndex</span> <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-c1">lastIndex</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4686" class="blob-num js-line-number" data-line-number="4686"></td>
+ <td id="LC4686" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4687" class="blob-num js-line-number" data-line-number="4687"></td>
+ <td id="LC4687" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4688" class="blob-num js-line-number" data-line-number="4688"></td>
+ <td id="LC4688" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4689" class="blob-num js-line-number" data-line-number="4689"></td>
+ <td id="LC4689" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L4690" class="blob-num js-line-number" data-line-number="4690"></td>
+ <td id="LC4690" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4691" class="blob-num js-line-number" data-line-number="4691"></td>
+ <td id="LC4691" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isArr <span class="pl-k">=</span> <span class="pl-en">isArray</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4692" class="blob-num js-line-number" data-line-number="4692"></td>
+ <td id="LC4692" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isDeep) {</td>
+ </tr>
+ <tr>
+ <td id="L4693" class="blob-num js-line-number" data-line-number="4693"></td>
+ <td id="LC4693" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// check for circular references and return corresponding clone</span></td>
+ </tr>
+ <tr>
+ <td id="L4694" class="blob-num js-line-number" data-line-number="4694"></td>
+ <td id="LC4694" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> initedStack <span class="pl-k">=</span> <span class="pl-k">!</span>stackA;</td>
+ </tr>
+ <tr>
+ <td id="L4695" class="blob-num js-line-number" data-line-number="4695"></td>
+ <td id="LC4695" class="blob-code blob-code-inner js-file-line"> stackA <span class="pl-k">||</span> (stackA <span class="pl-k">=</span> <span class="pl-en">getArray</span>());</td>
+ </tr>
+ <tr>
+ <td id="L4696" class="blob-num js-line-number" data-line-number="4696"></td>
+ <td id="LC4696" class="blob-code blob-code-inner js-file-line"> stackB <span class="pl-k">||</span> (stackB <span class="pl-k">=</span> <span class="pl-en">getArray</span>());</td>
+ </tr>
+ <tr>
+ <td id="L4697" class="blob-num js-line-number" data-line-number="4697"></td>
+ <td id="LC4697" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4698" class="blob-num js-line-number" data-line-number="4698"></td>
+ <td id="LC4698" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> <span class="pl-smi">stackA</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4699" class="blob-num js-line-number" data-line-number="4699"></td>
+ <td id="LC4699" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4700" class="blob-num js-line-number" data-line-number="4700"></td>
+ <td id="LC4700" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (stackA[length] <span class="pl-k">==</span> value) {</td>
+ </tr>
+ <tr>
+ <td id="L4701" class="blob-num js-line-number" data-line-number="4701"></td>
+ <td id="LC4701" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> stackB[length];</td>
+ </tr>
+ <tr>
+ <td id="L4702" class="blob-num js-line-number" data-line-number="4702"></td>
+ <td id="LC4702" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4703" class="blob-num js-line-number" data-line-number="4703"></td>
+ <td id="LC4703" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4704" class="blob-num js-line-number" data-line-number="4704"></td>
+ <td id="LC4704" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> isArr <span class="pl-k">?</span> <span class="pl-en">ctor</span>(<span class="pl-smi">value</span>.<span class="pl-c1">length</span>) <span class="pl-k">:</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L4705" class="blob-num js-line-number" data-line-number="4705"></td>
+ <td id="LC4705" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4706" class="blob-num js-line-number" data-line-number="4706"></td>
+ <td id="LC4706" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4707" class="blob-num js-line-number" data-line-number="4707"></td>
+ <td id="LC4707" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> isArr <span class="pl-k">?</span> <span class="pl-en">slice</span>(value) <span class="pl-k">:</span> <span class="pl-en">assign</span>({}, value);</td>
+ </tr>
+ <tr>
+ <td id="L4708" class="blob-num js-line-number" data-line-number="4708"></td>
+ <td id="LC4708" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4709" class="blob-num js-line-number" data-line-number="4709"></td>
+ <td id="LC4709" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add array properties assigned by `RegExp#exec`</span></td>
+ </tr>
+ <tr>
+ <td id="L4710" class="blob-num js-line-number" data-line-number="4710"></td>
+ <td id="LC4710" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L4711" class="blob-num js-line-number" data-line-number="4711"></td>
+ <td id="LC4711" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(value, <span class="pl-s"><span class="pl-pds">'</span>index<span class="pl-pds">'</span></span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L4712" class="blob-num js-line-number" data-line-number="4712"></td>
+ <td id="LC4712" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">index</span> <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-c1">index</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4713" class="blob-num js-line-number" data-line-number="4713"></td>
+ <td id="LC4713" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4714" class="blob-num js-line-number" data-line-number="4714"></td>
+ <td id="LC4714" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(value, <span class="pl-s"><span class="pl-pds">'</span>input<span class="pl-pds">'</span></span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L4715" class="blob-num js-line-number" data-line-number="4715"></td>
+ <td id="LC4715" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">input</span> <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-c1">input</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4716" class="blob-num js-line-number" data-line-number="4716"></td>
+ <td id="LC4716" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4717" class="blob-num js-line-number" data-line-number="4717"></td>
+ <td id="LC4717" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4718" class="blob-num js-line-number" data-line-number="4718"></td>
+ <td id="LC4718" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit for shallow clone</span></td>
+ </tr>
+ <tr>
+ <td id="L4719" class="blob-num js-line-number" data-line-number="4719"></td>
+ <td id="LC4719" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isDeep) {</td>
+ </tr>
+ <tr>
+ <td id="L4720" class="blob-num js-line-number" data-line-number="4720"></td>
+ <td id="LC4720" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4721" class="blob-num js-line-number" data-line-number="4721"></td>
+ <td id="LC4721" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4722" class="blob-num js-line-number" data-line-number="4722"></td>
+ <td id="LC4722" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add the source value to the stack of traversed objects</span></td>
+ </tr>
+ <tr>
+ <td id="L4723" class="blob-num js-line-number" data-line-number="4723"></td>
+ <td id="LC4723" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// and associate it with its clone</span></td>
+ </tr>
+ <tr>
+ <td id="L4724" class="blob-num js-line-number" data-line-number="4724"></td>
+ <td id="LC4724" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackA</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4725" class="blob-num js-line-number" data-line-number="4725"></td>
+ <td id="LC4725" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackB</span>.<span class="pl-c1">push</span>(result);</td>
+ </tr>
+ <tr>
+ <td id="L4726" class="blob-num js-line-number" data-line-number="4726"></td>
+ <td id="LC4726" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4727" class="blob-num js-line-number" data-line-number="4727"></td>
+ <td id="LC4727" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// recursively populate clone (susceptible to call stack limits)</span></td>
+ </tr>
+ <tr>
+ <td id="L4728" class="blob-num js-line-number" data-line-number="4728"></td>
+ <td id="LC4728" class="blob-code blob-code-inner js-file-line"> (isArr <span class="pl-k">?</span> forEach <span class="pl-k">:</span> forOwn)(value, <span class="pl-k">function</span>(<span class="pl-smi">objValue</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4729" class="blob-num js-line-number" data-line-number="4729"></td>
+ <td id="LC4729" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> <span class="pl-en">baseClone</span>(objValue, isDeep, callback, stackA, stackB);</td>
+ </tr>
+ <tr>
+ <td id="L4730" class="blob-num js-line-number" data-line-number="4730"></td>
+ <td id="LC4730" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L4731" class="blob-num js-line-number" data-line-number="4731"></td>
+ <td id="LC4731" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4732" class="blob-num js-line-number" data-line-number="4732"></td>
+ <td id="LC4732" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (initedStack) {</td>
+ </tr>
+ <tr>
+ <td id="L4733" class="blob-num js-line-number" data-line-number="4733"></td>
+ <td id="LC4733" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(stackA);</td>
+ </tr>
+ <tr>
+ <td id="L4734" class="blob-num js-line-number" data-line-number="4734"></td>
+ <td id="LC4734" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(stackB);</td>
+ </tr>
+ <tr>
+ <td id="L4735" class="blob-num js-line-number" data-line-number="4735"></td>
+ <td id="LC4735" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4736" class="blob-num js-line-number" data-line-number="4736"></td>
+ <td id="LC4736" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4737" class="blob-num js-line-number" data-line-number="4737"></td>
+ <td id="LC4737" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4738" class="blob-num js-line-number" data-line-number="4738"></td>
+ <td id="LC4738" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4739" class="blob-num js-line-number" data-line-number="4739"></td>
+ <td id="LC4739" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4740" class="blob-num js-line-number" data-line-number="4740"></td>
+ <td id="LC4740" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.create` without support for assigning</span></td>
+ </tr>
+ <tr>
+ <td id="L4741" class="blob-num js-line-number" data-line-number="4741"></td>
+ <td id="LC4741" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * properties to the created object.</span></td>
+ </tr>
+ <tr>
+ <td id="L4742" class="blob-num js-line-number" data-line-number="4742"></td>
+ <td id="LC4742" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4743" class="blob-num js-line-number" data-line-number="4743"></td>
+ <td id="LC4743" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4744" class="blob-num js-line-number" data-line-number="4744"></td>
+ <td id="LC4744" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">prototype</span> The object to inherit from.</span></td>
+ </tr>
+ <tr>
+ <td id="L4745" class="blob-num js-line-number" data-line-number="4745"></td>
+ <td id="LC4745" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the new object.</span></td>
+ </tr>
+ <tr>
+ <td id="L4746" class="blob-num js-line-number" data-line-number="4746"></td>
+ <td id="LC4746" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4747" class="blob-num js-line-number" data-line-number="4747"></td>
+ <td id="LC4747" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseCreate</span>(<span class="pl-smi">prototype</span>, <span class="pl-smi">properties</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4748" class="blob-num js-line-number" data-line-number="4748"></td>
+ <td id="LC4748" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">isObject</span>(prototype) <span class="pl-k">?</span> <span class="pl-en">nativeCreate</span>(prototype) <span class="pl-k">:</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L4749" class="blob-num js-line-number" data-line-number="4749"></td>
+ <td id="LC4749" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4750" class="blob-num js-line-number" data-line-number="4750"></td>
+ <td id="LC4750" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// fallback for browsers without `Object.create`</span></td>
+ </tr>
+ <tr>
+ <td id="L4751" class="blob-num js-line-number" data-line-number="4751"></td>
+ <td id="LC4751" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>nativeCreate) {</td>
+ </tr>
+ <tr>
+ <td id="L4752" class="blob-num js-line-number" data-line-number="4752"></td>
+ <td id="LC4752" class="blob-code blob-code-inner js-file-line"> baseCreate <span class="pl-k">=</span> (<span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L4753" class="blob-num js-line-number" data-line-number="4753"></td>
+ <td id="LC4753" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">Object</span>() {}</td>
+ </tr>
+ <tr>
+ <td id="L4754" class="blob-num js-line-number" data-line-number="4754"></td>
+ <td id="LC4754" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">prototype</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4755" class="blob-num js-line-number" data-line-number="4755"></td>
+ <td id="LC4755" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">isObject</span>(prototype)) {</td>
+ </tr>
+ <tr>
+ <td id="L4756" class="blob-num js-line-number" data-line-number="4756"></td>
+ <td id="LC4756" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Object</span>.<span class="pl-c1">prototype</span> <span class="pl-k">=</span> prototype;</td>
+ </tr>
+ <tr>
+ <td id="L4757" class="blob-num js-line-number" data-line-number="4757"></td>
+ <td id="LC4757" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">Object</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4758" class="blob-num js-line-number" data-line-number="4758"></td>
+ <td id="LC4758" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">Object</span>.<span class="pl-c1">prototype</span> <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4759" class="blob-num js-line-number" data-line-number="4759"></td>
+ <td id="LC4759" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4760" class="blob-num js-line-number" data-line-number="4760"></td>
+ <td id="LC4760" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result <span class="pl-k">||</span> <span class="pl-smi">context</span>.<span class="pl-en">Object</span>();</td>
+ </tr>
+ <tr>
+ <td id="L4761" class="blob-num js-line-number" data-line-number="4761"></td>
+ <td id="LC4761" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4762" class="blob-num js-line-number" data-line-number="4762"></td>
+ <td id="LC4762" class="blob-code blob-code-inner js-file-line"> }());</td>
+ </tr>
+ <tr>
+ <td id="L4763" class="blob-num js-line-number" data-line-number="4763"></td>
+ <td id="LC4763" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4764" class="blob-num js-line-number" data-line-number="4764"></td>
+ <td id="LC4764" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4765" class="blob-num js-line-number" data-line-number="4765"></td>
+ <td id="LC4765" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4766" class="blob-num js-line-number" data-line-number="4766"></td>
+ <td id="LC4766" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.createCallback` without support for creating</span></td>
+ </tr>
+ <tr>
+ <td id="L4767" class="blob-num js-line-number" data-line-number="4767"></td>
+ <td id="LC4767" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * "_.pluck" or "_.where" style callbacks.</span></td>
+ </tr>
+ <tr>
+ <td id="L4768" class="blob-num js-line-number" data-line-number="4768"></td>
+ <td id="LC4768" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4769" class="blob-num js-line-number" data-line-number="4769"></td>
+ <td id="LC4769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4770" class="blob-num js-line-number" data-line-number="4770"></td>
+ <td id="LC4770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [func=identity] The value to convert to a callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L4771" class="blob-num js-line-number" data-line-number="4771"></td>
+ <td id="LC4771" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of the created callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L4772" class="blob-num js-line-number" data-line-number="4772"></td>
+ <td id="LC4772" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [argCount] The number of arguments the callback accepts.</span></td>
+ </tr>
+ <tr>
+ <td id="L4773" class="blob-num js-line-number" data-line-number="4773"></td>
+ <td id="LC4773" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> a callback function.</span></td>
+ </tr>
+ <tr>
+ <td id="L4774" class="blob-num js-line-number" data-line-number="4774"></td>
+ <td id="LC4774" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4775" class="blob-num js-line-number" data-line-number="4775"></td>
+ <td id="LC4775" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseCreateCallback</span>(<span class="pl-smi">func</span>, <span class="pl-smi">thisArg</span>, <span class="pl-smi">argCount</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4776" class="blob-num js-line-number" data-line-number="4776"></td>
+ <td id="LC4776" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> func <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4777" class="blob-num js-line-number" data-line-number="4777"></td>
+ <td id="LC4777" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> identity;</td>
+ </tr>
+ <tr>
+ <td id="L4778" class="blob-num js-line-number" data-line-number="4778"></td>
+ <td id="LC4778" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4779" class="blob-num js-line-number" data-line-number="4779"></td>
+ <td id="LC4779" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit early for no `thisArg` or already bound by `Function#bind`</span></td>
+ </tr>
+ <tr>
+ <td id="L4780" class="blob-num js-line-number" data-line-number="4780"></td>
+ <td id="LC4780" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> thisArg <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span> <span class="pl-k">||</span> <span class="pl-k">!</span>(<span class="pl-s"><span class="pl-pds">'</span>prototype<span class="pl-pds">'</span></span> <span class="pl-k">in</span> func)) {</td>
+ </tr>
+ <tr>
+ <td id="L4781" class="blob-num js-line-number" data-line-number="4781"></td>
+ <td id="LC4781" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> func;</td>
+ </tr>
+ <tr>
+ <td id="L4782" class="blob-num js-line-number" data-line-number="4782"></td>
+ <td id="LC4782" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4783" class="blob-num js-line-number" data-line-number="4783"></td>
+ <td id="LC4783" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> bindData <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-smi">__bindData__</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4784" class="blob-num js-line-number" data-line-number="4784"></td>
+ <td id="LC4784" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> bindData <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4785" class="blob-num js-line-number" data-line-number="4785"></td>
+ <td id="LC4785" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">support</span>.<span class="pl-smi">funcNames</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4786" class="blob-num js-line-number" data-line-number="4786"></td>
+ <td id="LC4786" class="blob-code blob-code-inner js-file-line"> bindData <span class="pl-k">=</span> <span class="pl-k">!</span><span class="pl-smi">func</span>.<span class="pl-c1">name</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4787" class="blob-num js-line-number" data-line-number="4787"></td>
+ <td id="LC4787" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4788" class="blob-num js-line-number" data-line-number="4788"></td>
+ <td id="LC4788" class="blob-code blob-code-inner js-file-line"> bindData <span class="pl-k">=</span> bindData <span class="pl-k">||</span> <span class="pl-k">!</span><span class="pl-smi">support</span>.<span class="pl-smi">funcDecomp</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4789" class="blob-num js-line-number" data-line-number="4789"></td>
+ <td id="LC4789" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>bindData) {</td>
+ </tr>
+ <tr>
+ <td id="L4790" class="blob-num js-line-number" data-line-number="4790"></td>
+ <td id="LC4790" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> source <span class="pl-k">=</span> <span class="pl-smi">fnToString</span>.<span class="pl-c1">call</span>(func);</td>
+ </tr>
+ <tr>
+ <td id="L4791" class="blob-num js-line-number" data-line-number="4791"></td>
+ <td id="LC4791" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">support</span>.<span class="pl-smi">funcNames</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4792" class="blob-num js-line-number" data-line-number="4792"></td>
+ <td id="LC4792" class="blob-code blob-code-inner js-file-line"> bindData <span class="pl-k">=</span> <span class="pl-k">!</span><span class="pl-smi">reFuncName</span>.<span class="pl-c1">test</span>(source);</td>
+ </tr>
+ <tr>
+ <td id="L4793" class="blob-num js-line-number" data-line-number="4793"></td>
+ <td id="LC4793" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4794" class="blob-num js-line-number" data-line-number="4794"></td>
+ <td id="LC4794" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>bindData) {</td>
+ </tr>
+ <tr>
+ <td id="L4795" class="blob-num js-line-number" data-line-number="4795"></td>
+ <td id="LC4795" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// checks if `func` references the `this` keyword and stores the result</span></td>
+ </tr>
+ <tr>
+ <td id="L4796" class="blob-num js-line-number" data-line-number="4796"></td>
+ <td id="LC4796" class="blob-code blob-code-inner js-file-line"> bindData <span class="pl-k">=</span> <span class="pl-smi">reThis</span>.<span class="pl-c1">test</span>(source);</td>
+ </tr>
+ <tr>
+ <td id="L4797" class="blob-num js-line-number" data-line-number="4797"></td>
+ <td id="LC4797" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">setBindData</span>(func, bindData);</td>
+ </tr>
+ <tr>
+ <td id="L4798" class="blob-num js-line-number" data-line-number="4798"></td>
+ <td id="LC4798" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4799" class="blob-num js-line-number" data-line-number="4799"></td>
+ <td id="LC4799" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4800" class="blob-num js-line-number" data-line-number="4800"></td>
+ <td id="LC4800" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4801" class="blob-num js-line-number" data-line-number="4801"></td>
+ <td id="LC4801" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit early if there are no `this` references or `func` is bound</span></td>
+ </tr>
+ <tr>
+ <td id="L4802" class="blob-num js-line-number" data-line-number="4802"></td>
+ <td id="LC4802" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (bindData <span class="pl-k">===</span> <span class="pl-c1">false</span> <span class="pl-k">||</span> (bindData <span class="pl-k">!==</span> <span class="pl-c1">true</span> <span class="pl-k">&&</span> bindData[<span class="pl-c1">1</span>] <span class="pl-k">&</span> <span class="pl-c1">1</span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L4803" class="blob-num js-line-number" data-line-number="4803"></td>
+ <td id="LC4803" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> func;</td>
+ </tr>
+ <tr>
+ <td id="L4804" class="blob-num js-line-number" data-line-number="4804"></td>
+ <td id="LC4804" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4805" class="blob-num js-line-number" data-line-number="4805"></td>
+ <td id="LC4805" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">switch</span> (argCount) {</td>
+ </tr>
+ <tr>
+ <td id="L4806" class="blob-num js-line-number" data-line-number="4806"></td>
+ <td id="LC4806" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-c1">1</span><span class="pl-k">:</span> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4807" class="blob-num js-line-number" data-line-number="4807"></td>
+ <td id="LC4807" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">call</span>(thisArg, value);</td>
+ </tr>
+ <tr>
+ <td id="L4808" class="blob-num js-line-number" data-line-number="4808"></td>
+ <td id="LC4808" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4809" class="blob-num js-line-number" data-line-number="4809"></td>
+ <td id="LC4809" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-c1">2</span><span class="pl-k">:</span> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">a</span>, <span class="pl-smi">b</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4810" class="blob-num js-line-number" data-line-number="4810"></td>
+ <td id="LC4810" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">call</span>(thisArg, a, b);</td>
+ </tr>
+ <tr>
+ <td id="L4811" class="blob-num js-line-number" data-line-number="4811"></td>
+ <td id="LC4811" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4812" class="blob-num js-line-number" data-line-number="4812"></td>
+ <td id="LC4812" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-c1">3</span><span class="pl-k">:</span> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4813" class="blob-num js-line-number" data-line-number="4813"></td>
+ <td id="LC4813" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">call</span>(thisArg, value, index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L4814" class="blob-num js-line-number" data-line-number="4814"></td>
+ <td id="LC4814" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4815" class="blob-num js-line-number" data-line-number="4815"></td>
+ <td id="LC4815" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> <span class="pl-c1">4</span><span class="pl-k">:</span> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">accumulator</span>, <span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4816" class="blob-num js-line-number" data-line-number="4816"></td>
+ <td id="LC4816" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">call</span>(thisArg, accumulator, value, index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L4817" class="blob-num js-line-number" data-line-number="4817"></td>
+ <td id="LC4817" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L4818" class="blob-num js-line-number" data-line-number="4818"></td>
+ <td id="LC4818" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4819" class="blob-num js-line-number" data-line-number="4819"></td>
+ <td id="LC4819" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">bind</span>(func, thisArg);</td>
+ </tr>
+ <tr>
+ <td id="L4820" class="blob-num js-line-number" data-line-number="4820"></td>
+ <td id="LC4820" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4821" class="blob-num js-line-number" data-line-number="4821"></td>
+ <td id="LC4821" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4822" class="blob-num js-line-number" data-line-number="4822"></td>
+ <td id="LC4822" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4823" class="blob-num js-line-number" data-line-number="4823"></td>
+ <td id="LC4823" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `createWrapper` that creates the wrapper and</span></td>
+ </tr>
+ <tr>
+ <td id="L4824" class="blob-num js-line-number" data-line-number="4824"></td>
+ <td id="LC4824" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * sets its meta data.</span></td>
+ </tr>
+ <tr>
+ <td id="L4825" class="blob-num js-line-number" data-line-number="4825"></td>
+ <td id="LC4825" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4826" class="blob-num js-line-number" data-line-number="4826"></td>
+ <td id="LC4826" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4827" class="blob-num js-line-number" data-line-number="4827"></td>
+ <td id="LC4827" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">bindData</span> The bind data array.</span></td>
+ </tr>
+ <tr>
+ <td id="L4828" class="blob-num js-line-number" data-line-number="4828"></td>
+ <td id="LC4828" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L4829" class="blob-num js-line-number" data-line-number="4829"></td>
+ <td id="LC4829" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4830" class="blob-num js-line-number" data-line-number="4830"></td>
+ <td id="LC4830" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseCreateWrapper</span>(<span class="pl-smi">bindData</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4831" class="blob-num js-line-number" data-line-number="4831"></td>
+ <td id="LC4831" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> func <span class="pl-k">=</span> bindData[<span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4832" class="blob-num js-line-number" data-line-number="4832"></td>
+ <td id="LC4832" class="blob-code blob-code-inner js-file-line"> bitmask <span class="pl-k">=</span> bindData[<span class="pl-c1">1</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4833" class="blob-num js-line-number" data-line-number="4833"></td>
+ <td id="LC4833" class="blob-code blob-code-inner js-file-line"> partialArgs <span class="pl-k">=</span> bindData[<span class="pl-c1">2</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4834" class="blob-num js-line-number" data-line-number="4834"></td>
+ <td id="LC4834" class="blob-code blob-code-inner js-file-line"> partialRightArgs <span class="pl-k">=</span> bindData[<span class="pl-c1">3</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4835" class="blob-num js-line-number" data-line-number="4835"></td>
+ <td id="LC4835" class="blob-code blob-code-inner js-file-line"> thisArg <span class="pl-k">=</span> bindData[<span class="pl-c1">4</span>],</td>
+ </tr>
+ <tr>
+ <td id="L4836" class="blob-num js-line-number" data-line-number="4836"></td>
+ <td id="LC4836" class="blob-code blob-code-inner js-file-line"> arity <span class="pl-k">=</span> bindData[<span class="pl-c1">5</span>];</td>
+ </tr>
+ <tr>
+ <td id="L4837" class="blob-num js-line-number" data-line-number="4837"></td>
+ <td id="LC4837" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4838" class="blob-num js-line-number" data-line-number="4838"></td>
+ <td id="LC4838" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isBind <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4839" class="blob-num js-line-number" data-line-number="4839"></td>
+ <td id="LC4839" class="blob-code blob-code-inner js-file-line"> isBindKey <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">2</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4840" class="blob-num js-line-number" data-line-number="4840"></td>
+ <td id="LC4840" class="blob-code blob-code-inner js-file-line"> isCurry <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">4</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4841" class="blob-num js-line-number" data-line-number="4841"></td>
+ <td id="LC4841" class="blob-code blob-code-inner js-file-line"> isCurryBound <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">8</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4842" class="blob-num js-line-number" data-line-number="4842"></td>
+ <td id="LC4842" class="blob-code blob-code-inner js-file-line"> key <span class="pl-k">=</span> func;</td>
+ </tr>
+ <tr>
+ <td id="L4843" class="blob-num js-line-number" data-line-number="4843"></td>
+ <td id="LC4843" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4844" class="blob-num js-line-number" data-line-number="4844"></td>
+ <td id="LC4844" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">bound</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L4845" class="blob-num js-line-number" data-line-number="4845"></td>
+ <td id="LC4845" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> thisBinding <span class="pl-k">=</span> isBind <span class="pl-k">?</span> thisArg <span class="pl-k">:</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4846" class="blob-num js-line-number" data-line-number="4846"></td>
+ <td id="LC4846" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (partialArgs) {</td>
+ </tr>
+ <tr>
+ <td id="L4847" class="blob-num js-line-number" data-line-number="4847"></td>
+ <td id="LC4847" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-en">slice</span>(partialArgs);</td>
+ </tr>
+ <tr>
+ <td id="L4848" class="blob-num js-line-number" data-line-number="4848"></td>
+ <td id="LC4848" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">push</span>.<span class="pl-c1">apply</span>(args, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4849" class="blob-num js-line-number" data-line-number="4849"></td>
+ <td id="LC4849" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4850" class="blob-num js-line-number" data-line-number="4850"></td>
+ <td id="LC4850" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (partialRightArgs <span class="pl-k">||</span> isCurry) {</td>
+ </tr>
+ <tr>
+ <td id="L4851" class="blob-num js-line-number" data-line-number="4851"></td>
+ <td id="LC4851" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">||</span> (args <span class="pl-k">=</span> <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>));</td>
+ </tr>
+ <tr>
+ <td id="L4852" class="blob-num js-line-number" data-line-number="4852"></td>
+ <td id="LC4852" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (partialRightArgs) {</td>
+ </tr>
+ <tr>
+ <td id="L4853" class="blob-num js-line-number" data-line-number="4853"></td>
+ <td id="LC4853" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">push</span>.<span class="pl-c1">apply</span>(args, partialRightArgs);</td>
+ </tr>
+ <tr>
+ <td id="L4854" class="blob-num js-line-number" data-line-number="4854"></td>
+ <td id="LC4854" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4855" class="blob-num js-line-number" data-line-number="4855"></td>
+ <td id="LC4855" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isCurry <span class="pl-k">&&</span> <span class="pl-smi">args</span>.<span class="pl-c1">length</span> <span class="pl-k"><</span> arity) {</td>
+ </tr>
+ <tr>
+ <td id="L4856" class="blob-num js-line-number" data-line-number="4856"></td>
+ <td id="LC4856" class="blob-code blob-code-inner js-file-line"> bitmask <span class="pl-k">|=</span> <span class="pl-c1">16</span> <span class="pl-k">&</span> <span class="pl-k">~</span><span class="pl-c1">32</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4857" class="blob-num js-line-number" data-line-number="4857"></td>
+ <td id="LC4857" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseCreateWrapper</span>([func, (isCurryBound <span class="pl-k">?</span> bitmask <span class="pl-k">:</span> bitmask <span class="pl-k">&</span> <span class="pl-k">~</span><span class="pl-c1">3</span>), args, <span class="pl-c1">null</span>, thisArg, arity]);</td>
+ </tr>
+ <tr>
+ <td id="L4858" class="blob-num js-line-number" data-line-number="4858"></td>
+ <td id="LC4858" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4859" class="blob-num js-line-number" data-line-number="4859"></td>
+ <td id="LC4859" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4860" class="blob-num js-line-number" data-line-number="4860"></td>
+ <td id="LC4860" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">||</span> (args <span class="pl-k">=</span> <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4861" class="blob-num js-line-number" data-line-number="4861"></td>
+ <td id="LC4861" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isBindKey) {</td>
+ </tr>
+ <tr>
+ <td id="L4862" class="blob-num js-line-number" data-line-number="4862"></td>
+ <td id="LC4862" class="blob-code blob-code-inner js-file-line"> func <span class="pl-k">=</span> thisBinding[key];</td>
+ </tr>
+ <tr>
+ <td id="L4863" class="blob-num js-line-number" data-line-number="4863"></td>
+ <td id="LC4863" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4864" class="blob-num js-line-number" data-line-number="4864"></td>
+ <td id="LC4864" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-v">this</span> <span class="pl-k">instanceof</span> bound) {</td>
+ </tr>
+ <tr>
+ <td id="L4865" class="blob-num js-line-number" data-line-number="4865"></td>
+ <td id="LC4865" class="blob-code blob-code-inner js-file-line"> thisBinding <span class="pl-k">=</span> <span class="pl-en">baseCreate</span>(<span class="pl-smi">func</span>.<span class="pl-c1">prototype</span>);</td>
+ </tr>
+ <tr>
+ <td id="L4866" class="blob-num js-line-number" data-line-number="4866"></td>
+ <td id="LC4866" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisBinding, args);</td>
+ </tr>
+ <tr>
+ <td id="L4867" class="blob-num js-line-number" data-line-number="4867"></td>
+ <td id="LC4867" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">isObject</span>(result) <span class="pl-k">?</span> result <span class="pl-k">:</span> thisBinding;</td>
+ </tr>
+ <tr>
+ <td id="L4868" class="blob-num js-line-number" data-line-number="4868"></td>
+ <td id="LC4868" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4869" class="blob-num js-line-number" data-line-number="4869"></td>
+ <td id="LC4869" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisBinding, args);</td>
+ </tr>
+ <tr>
+ <td id="L4870" class="blob-num js-line-number" data-line-number="4870"></td>
+ <td id="LC4870" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4871" class="blob-num js-line-number" data-line-number="4871"></td>
+ <td id="LC4871" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">setBindData</span>(bound, bindData);</td>
+ </tr>
+ <tr>
+ <td id="L4872" class="blob-num js-line-number" data-line-number="4872"></td>
+ <td id="LC4872" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> bound;</td>
+ </tr>
+ <tr>
+ <td id="L4873" class="blob-num js-line-number" data-line-number="4873"></td>
+ <td id="LC4873" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4874" class="blob-num js-line-number" data-line-number="4874"></td>
+ <td id="LC4874" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4875" class="blob-num js-line-number" data-line-number="4875"></td>
+ <td id="LC4875" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4876" class="blob-num js-line-number" data-line-number="4876"></td>
+ <td id="LC4876" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.difference` that accepts a single array</span></td>
+ </tr>
+ <tr>
+ <td id="L4877" class="blob-num js-line-number" data-line-number="4877"></td>
+ <td id="LC4877" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of values to exclude.</span></td>
+ </tr>
+ <tr>
+ <td id="L4878" class="blob-num js-line-number" data-line-number="4878"></td>
+ <td id="LC4878" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4879" class="blob-num js-line-number" data-line-number="4879"></td>
+ <td id="LC4879" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4880" class="blob-num js-line-number" data-line-number="4880"></td>
+ <td id="LC4880" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to process.</span></td>
+ </tr>
+ <tr>
+ <td id="L4881" class="blob-num js-line-number" data-line-number="4881"></td>
+ <td id="LC4881" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [values] The array of values to exclude.</span></td>
+ </tr>
+ <tr>
+ <td id="L4882" class="blob-num js-line-number" data-line-number="4882"></td>
+ <td id="LC4882" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of filtered values.</span></td>
+ </tr>
+ <tr>
+ <td id="L4883" class="blob-num js-line-number" data-line-number="4883"></td>
+ <td id="LC4883" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4884" class="blob-num js-line-number" data-line-number="4884"></td>
+ <td id="LC4884" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseDifference</span>(<span class="pl-smi">array</span>, <span class="pl-smi">values</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4885" class="blob-num js-line-number" data-line-number="4885"></td>
+ <td id="LC4885" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4886" class="blob-num js-line-number" data-line-number="4886"></td>
+ <td id="LC4886" class="blob-code blob-code-inner js-file-line"> indexOf <span class="pl-k">=</span> <span class="pl-en">getIndexOf</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L4887" class="blob-num js-line-number" data-line-number="4887"></td>
+ <td id="LC4887" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4888" class="blob-num js-line-number" data-line-number="4888"></td>
+ <td id="LC4888" class="blob-code blob-code-inner js-file-line"> isLarge <span class="pl-k">=</span> length <span class="pl-k">>=</span> largeArraySize <span class="pl-k">&&</span> indexOf <span class="pl-k">===</span> baseIndexOf,</td>
+ </tr>
+ <tr>
+ <td id="L4889" class="blob-num js-line-number" data-line-number="4889"></td>
+ <td id="LC4889" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L4890" class="blob-num js-line-number" data-line-number="4890"></td>
+ <td id="LC4890" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4891" class="blob-num js-line-number" data-line-number="4891"></td>
+ <td id="LC4891" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isLarge) {</td>
+ </tr>
+ <tr>
+ <td id="L4892" class="blob-num js-line-number" data-line-number="4892"></td>
+ <td id="LC4892" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> <span class="pl-en">createCache</span>(values);</td>
+ </tr>
+ <tr>
+ <td id="L4893" class="blob-num js-line-number" data-line-number="4893"></td>
+ <td id="LC4893" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (cache) {</td>
+ </tr>
+ <tr>
+ <td id="L4894" class="blob-num js-line-number" data-line-number="4894"></td>
+ <td id="LC4894" class="blob-code blob-code-inner js-file-line"> indexOf <span class="pl-k">=</span> cacheIndexOf;</td>
+ </tr>
+ <tr>
+ <td id="L4895" class="blob-num js-line-number" data-line-number="4895"></td>
+ <td id="LC4895" class="blob-code blob-code-inner js-file-line"> values <span class="pl-k">=</span> cache;</td>
+ </tr>
+ <tr>
+ <td id="L4896" class="blob-num js-line-number" data-line-number="4896"></td>
+ <td id="LC4896" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L4897" class="blob-num js-line-number" data-line-number="4897"></td>
+ <td id="LC4897" class="blob-code blob-code-inner js-file-line"> isLarge <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4898" class="blob-num js-line-number" data-line-number="4898"></td>
+ <td id="LC4898" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4899" class="blob-num js-line-number" data-line-number="4899"></td>
+ <td id="LC4899" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4900" class="blob-num js-line-number" data-line-number="4900"></td>
+ <td id="LC4900" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L4901" class="blob-num js-line-number" data-line-number="4901"></td>
+ <td id="LC4901" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> array[index];</td>
+ </tr>
+ <tr>
+ <td id="L4902" class="blob-num js-line-number" data-line-number="4902"></td>
+ <td id="LC4902" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">indexOf</span>(values, value) <span class="pl-k"><</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4903" class="blob-num js-line-number" data-line-number="4903"></td>
+ <td id="LC4903" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4904" class="blob-num js-line-number" data-line-number="4904"></td>
+ <td id="LC4904" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4905" class="blob-num js-line-number" data-line-number="4905"></td>
+ <td id="LC4905" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4906" class="blob-num js-line-number" data-line-number="4906"></td>
+ <td id="LC4906" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isLarge) {</td>
+ </tr>
+ <tr>
+ <td id="L4907" class="blob-num js-line-number" data-line-number="4907"></td>
+ <td id="LC4907" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseObject</span>(values);</td>
+ </tr>
+ <tr>
+ <td id="L4908" class="blob-num js-line-number" data-line-number="4908"></td>
+ <td id="LC4908" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4909" class="blob-num js-line-number" data-line-number="4909"></td>
+ <td id="LC4909" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4910" class="blob-num js-line-number" data-line-number="4910"></td>
+ <td id="LC4910" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4911" class="blob-num js-line-number" data-line-number="4911"></td>
+ <td id="LC4911" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4912" class="blob-num js-line-number" data-line-number="4912"></td>
+ <td id="LC4912" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4913" class="blob-num js-line-number" data-line-number="4913"></td>
+ <td id="LC4913" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.flatten` without support for callback</span></td>
+ </tr>
+ <tr>
+ <td id="L4914" class="blob-num js-line-number" data-line-number="4914"></td>
+ <td id="LC4914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * shorthands or `thisArg` binding.</span></td>
+ </tr>
+ <tr>
+ <td id="L4915" class="blob-num js-line-number" data-line-number="4915"></td>
+ <td id="LC4915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4916" class="blob-num js-line-number" data-line-number="4916"></td>
+ <td id="LC4916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4917" class="blob-num js-line-number" data-line-number="4917"></td>
+ <td id="LC4917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to flatten.</span></td>
+ </tr>
+ <tr>
+ <td id="L4918" class="blob-num js-line-number" data-line-number="4918"></td>
+ <td id="LC4918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isShallow=false] A flag to restrict flattening to a single level.</span></td>
+ </tr>
+ <tr>
+ <td id="L4919" class="blob-num js-line-number" data-line-number="4919"></td>
+ <td id="LC4919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isStrict=false] A flag to restrict flattening to arrays and `arguments` objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L4920" class="blob-num js-line-number" data-line-number="4920"></td>
+ <td id="LC4920" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [fromIndex=0] The index to start from.</span></td>
+ </tr>
+ <tr>
+ <td id="L4921" class="blob-num js-line-number" data-line-number="4921"></td>
+ <td id="LC4921" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new flattened array.</span></td>
+ </tr>
+ <tr>
+ <td id="L4922" class="blob-num js-line-number" data-line-number="4922"></td>
+ <td id="LC4922" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4923" class="blob-num js-line-number" data-line-number="4923"></td>
+ <td id="LC4923" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseFlatten</span>(<span class="pl-smi">array</span>, <span class="pl-smi">isShallow</span>, <span class="pl-smi">isStrict</span>, <span class="pl-smi">fromIndex</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4924" class="blob-num js-line-number" data-line-number="4924"></td>
+ <td id="LC4924" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> (fromIndex <span class="pl-k">||</span> <span class="pl-c1">0</span>) <span class="pl-k">-</span> <span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4925" class="blob-num js-line-number" data-line-number="4925"></td>
+ <td id="LC4925" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4926" class="blob-num js-line-number" data-line-number="4926"></td>
+ <td id="LC4926" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L4927" class="blob-num js-line-number" data-line-number="4927"></td>
+ <td id="LC4927" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4928" class="blob-num js-line-number" data-line-number="4928"></td>
+ <td id="LC4928" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L4929" class="blob-num js-line-number" data-line-number="4929"></td>
+ <td id="LC4929" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> array[index];</td>
+ </tr>
+ <tr>
+ <td id="L4930" class="blob-num js-line-number" data-line-number="4930"></td>
+ <td id="LC4930" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4931" class="blob-num js-line-number" data-line-number="4931"></td>
+ <td id="LC4931" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> <span class="pl-smi">value</span>.<span class="pl-c1">length</span> <span class="pl-k">==</span> <span [...]
+ </tr>
+ <tr>
+ <td id="L4932" class="blob-num js-line-number" data-line-number="4932"></td>
+ <td id="LC4932" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">&&</span> (<span class="pl-en">isArray</span>(value) <span class="pl-k">||</span> <span class="pl-en">isArguments</span>(value))) {</td>
+ </tr>
+ <tr>
+ <td id="L4933" class="blob-num js-line-number" data-line-number="4933"></td>
+ <td id="LC4933" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// recursively flatten arrays (susceptible to call stack limits)</span></td>
+ </tr>
+ <tr>
+ <td id="L4934" class="blob-num js-line-number" data-line-number="4934"></td>
+ <td id="LC4934" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isShallow) {</td>
+ </tr>
+ <tr>
+ <td id="L4935" class="blob-num js-line-number" data-line-number="4935"></td>
+ <td id="LC4935" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> <span class="pl-en">baseFlatten</span>(value, isShallow, isStrict);</td>
+ </tr>
+ <tr>
+ <td id="L4936" class="blob-num js-line-number" data-line-number="4936"></td>
+ <td id="LC4936" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4937" class="blob-num js-line-number" data-line-number="4937"></td>
+ <td id="LC4937" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> valIndex <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4938" class="blob-num js-line-number" data-line-number="4938"></td>
+ <td id="LC4938" class="blob-code blob-code-inner js-file-line"> valLength <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L4939" class="blob-num js-line-number" data-line-number="4939"></td>
+ <td id="LC4939" class="blob-code blob-code-inner js-file-line"> resIndex <span class="pl-k">=</span> <span class="pl-smi">result</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4940" class="blob-num js-line-number" data-line-number="4940"></td>
+ <td id="LC4940" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4941" class="blob-num js-line-number" data-line-number="4941"></td>
+ <td id="LC4941" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">length</span> <span class="pl-k">+=</span> valLength;</td>
+ </tr>
+ <tr>
+ <td id="L4942" class="blob-num js-line-number" data-line-number="4942"></td>
+ <td id="LC4942" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>valIndex <span class="pl-k"><</span> valLength) {</td>
+ </tr>
+ <tr>
+ <td id="L4943" class="blob-num js-line-number" data-line-number="4943"></td>
+ <td id="LC4943" class="blob-code blob-code-inner js-file-line"> result[resIndex<span class="pl-k">++</span>] <span class="pl-k">=</span> value[valIndex];</td>
+ </tr>
+ <tr>
+ <td id="L4944" class="blob-num js-line-number" data-line-number="4944"></td>
+ <td id="LC4944" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4945" class="blob-num js-line-number" data-line-number="4945"></td>
+ <td id="LC4945" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-k">!</span>isStrict) {</td>
+ </tr>
+ <tr>
+ <td id="L4946" class="blob-num js-line-number" data-line-number="4946"></td>
+ <td id="LC4946" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L4947" class="blob-num js-line-number" data-line-number="4947"></td>
+ <td id="LC4947" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4948" class="blob-num js-line-number" data-line-number="4948"></td>
+ <td id="LC4948" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4949" class="blob-num js-line-number" data-line-number="4949"></td>
+ <td id="LC4949" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L4950" class="blob-num js-line-number" data-line-number="4950"></td>
+ <td id="LC4950" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4951" class="blob-num js-line-number" data-line-number="4951"></td>
+ <td id="LC4951" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4952" class="blob-num js-line-number" data-line-number="4952"></td>
+ <td id="LC4952" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L4953" class="blob-num js-line-number" data-line-number="4953"></td>
+ <td id="LC4953" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.isEqual`, without support for `thisArg` binding,</span></td>
+ </tr>
+ <tr>
+ <td id="L4954" class="blob-num js-line-number" data-line-number="4954"></td>
+ <td id="LC4954" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * that allows partial "_.where" style comparisons.</span></td>
+ </tr>
+ <tr>
+ <td id="L4955" class="blob-num js-line-number" data-line-number="4955"></td>
+ <td id="LC4955" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L4956" class="blob-num js-line-number" data-line-number="4956"></td>
+ <td id="LC4956" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L4957" class="blob-num js-line-number" data-line-number="4957"></td>
+ <td id="LC4957" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} a The value to compare.</span></td>
+ </tr>
+ <tr>
+ <td id="L4958" class="blob-num js-line-number" data-line-number="4958"></td>
+ <td id="LC4958" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} b The other value to compare.</span></td>
+ </tr>
+ <tr>
+ <td id="L4959" class="blob-num js-line-number" data-line-number="4959"></td>
+ <td id="LC4959" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize comparing values.</span></td>
+ </tr>
+ <tr>
+ <td id="L4960" class="blob-num js-line-number" data-line-number="4960"></td>
+ <td id="LC4960" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [isWhere=false] A flag to indicate performing partial comparisons.</span></td>
+ </tr>
+ <tr>
+ <td id="L4961" class="blob-num js-line-number" data-line-number="4961"></td>
+ <td id="LC4961" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [stackA=[]] Tracks traversed `a` objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L4962" class="blob-num js-line-number" data-line-number="4962"></td>
+ <td id="LC4962" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [stackB=[]] Tracks traversed `b` objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L4963" class="blob-num js-line-number" data-line-number="4963"></td>
+ <td id="LC4963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the values are equivalent, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L4964" class="blob-num js-line-number" data-line-number="4964"></td>
+ <td id="LC4964" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L4965" class="blob-num js-line-number" data-line-number="4965"></td>
+ <td id="LC4965" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseIsEqual</span>(<span class="pl-smi">a</span>, <span class="pl-smi">b</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">isWhere</span>, <span class="pl-smi">stackA</span>, <span class="pl-smi">stackB</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4966" class="blob-num js-line-number" data-line-number="4966"></td>
+ <td id="LC4966" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// used to indicate that when comparing objects, `a` has at least the properties of `b`</span></td>
+ </tr>
+ <tr>
+ <td id="L4967" class="blob-num js-line-number" data-line-number="4967"></td>
+ <td id="LC4967" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback) {</td>
+ </tr>
+ <tr>
+ <td id="L4968" class="blob-num js-line-number" data-line-number="4968"></td>
+ <td id="LC4968" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-en">callback</span>(a, b);</td>
+ </tr>
+ <tr>
+ <td id="L4969" class="blob-num js-line-number" data-line-number="4969"></td>
+ <td id="LC4969" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> result <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4970" class="blob-num js-line-number" data-line-number="4970"></td>
+ <td id="LC4970" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!!</span>result;</td>
+ </tr>
+ <tr>
+ <td id="L4971" class="blob-num js-line-number" data-line-number="4971"></td>
+ <td id="LC4971" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4972" class="blob-num js-line-number" data-line-number="4972"></td>
+ <td id="LC4972" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4973" class="blob-num js-line-number" data-line-number="4973"></td>
+ <td id="LC4973" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit early for identical values</span></td>
+ </tr>
+ <tr>
+ <td id="L4974" class="blob-num js-line-number" data-line-number="4974"></td>
+ <td id="LC4974" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (a <span class="pl-k">===</span> b) {</td>
+ </tr>
+ <tr>
+ <td id="L4975" class="blob-num js-line-number" data-line-number="4975"></td>
+ <td id="LC4975" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// treat `+0` vs. `-0` as not equal</span></td>
+ </tr>
+ <tr>
+ <td id="L4976" class="blob-num js-line-number" data-line-number="4976"></td>
+ <td id="LC4976" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> a <span class="pl-k">!==</span> <span class="pl-c1">0</span> <span class="pl-k">||</span> (<span class="pl-c1">1</span> <span class="pl-k">/</span> a <span class="pl-k">==</span> <span class="pl-c1">1</span> <span class="pl-k">/</span> b);</td>
+ </tr>
+ <tr>
+ <td id="L4977" class="blob-num js-line-number" data-line-number="4977"></td>
+ <td id="LC4977" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4978" class="blob-num js-line-number" data-line-number="4978"></td>
+ <td id="LC4978" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> type <span class="pl-k">=</span> <span class="pl-k">typeof</span> a,</td>
+ </tr>
+ <tr>
+ <td id="L4979" class="blob-num js-line-number" data-line-number="4979"></td>
+ <td id="LC4979" class="blob-code blob-code-inner js-file-line"> otherType <span class="pl-k">=</span> <span class="pl-k">typeof</span> b;</td>
+ </tr>
+ <tr>
+ <td id="L4980" class="blob-num js-line-number" data-line-number="4980"></td>
+ <td id="LC4980" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4981" class="blob-num js-line-number" data-line-number="4981"></td>
+ <td id="LC4981" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit early for unlike primitive values</span></td>
+ </tr>
+ <tr>
+ <td id="L4982" class="blob-num js-line-number" data-line-number="4982"></td>
+ <td id="LC4982" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (a <span class="pl-k">===</span> a <span class="pl-k">&&</span></td>
+ </tr>
+ <tr>
+ <td id="L4983" class="blob-num js-line-number" data-line-number="4983"></td>
+ <td id="LC4983" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">!</span>(a <span class="pl-k">&&</span> objectTypes[type]) <span class="pl-k">&&</span></td>
+ </tr>
+ <tr>
+ <td id="L4984" class="blob-num js-line-number" data-line-number="4984"></td>
+ <td id="LC4984" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">!</span>(b <span class="pl-k">&&</span> objectTypes[otherType])) {</td>
+ </tr>
+ <tr>
+ <td id="L4985" class="blob-num js-line-number" data-line-number="4985"></td>
+ <td id="LC4985" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L4986" class="blob-num js-line-number" data-line-number="4986"></td>
+ <td id="LC4986" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4987" class="blob-num js-line-number" data-line-number="4987"></td>
+ <td id="LC4987" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit early for `null` and `undefined` avoiding ES3's Function#call behavior</span></td>
+ </tr>
+ <tr>
+ <td id="L4988" class="blob-num js-line-number" data-line-number="4988"></td>
+ <td id="LC4988" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://es5.github.io/#x15.3.4.4</span></td>
+ </tr>
+ <tr>
+ <td id="L4989" class="blob-num js-line-number" data-line-number="4989"></td>
+ <td id="LC4989" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (a <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> b <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L4990" class="blob-num js-line-number" data-line-number="4990"></td>
+ <td id="LC4990" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> a <span class="pl-k">===</span> b;</td>
+ </tr>
+ <tr>
+ <td id="L4991" class="blob-num js-line-number" data-line-number="4991"></td>
+ <td id="LC4991" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4992" class="blob-num js-line-number" data-line-number="4992"></td>
+ <td id="LC4992" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// compare [[Class]] names</span></td>
+ </tr>
+ <tr>
+ <td id="L4993" class="blob-num js-line-number" data-line-number="4993"></td>
+ <td id="LC4993" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> className <span class="pl-k">=</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(a),</td>
+ </tr>
+ <tr>
+ <td id="L4994" class="blob-num js-line-number" data-line-number="4994"></td>
+ <td id="LC4994" class="blob-code blob-code-inner js-file-line"> otherClass <span class="pl-k">=</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(b);</td>
+ </tr>
+ <tr>
+ <td id="L4995" class="blob-num js-line-number" data-line-number="4995"></td>
+ <td id="LC4995" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L4996" class="blob-num js-line-number" data-line-number="4996"></td>
+ <td id="LC4996" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (className <span class="pl-k">==</span> argsClass) {</td>
+ </tr>
+ <tr>
+ <td id="L4997" class="blob-num js-line-number" data-line-number="4997"></td>
+ <td id="LC4997" class="blob-code blob-code-inner js-file-line"> className <span class="pl-k">=</span> objectClass;</td>
+ </tr>
+ <tr>
+ <td id="L4998" class="blob-num js-line-number" data-line-number="4998"></td>
+ <td id="LC4998" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L4999" class="blob-num js-line-number" data-line-number="4999"></td>
+ <td id="LC4999" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (otherClass <span class="pl-k">==</span> argsClass) {</td>
+ </tr>
+ <tr>
+ <td id="L5000" class="blob-num js-line-number" data-line-number="5000"></td>
+ <td id="LC5000" class="blob-code blob-code-inner js-file-line"> otherClass <span class="pl-k">=</span> objectClass;</td>
+ </tr>
+ <tr>
+ <td id="L5001" class="blob-num js-line-number" data-line-number="5001"></td>
+ <td id="LC5001" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5002" class="blob-num js-line-number" data-line-number="5002"></td>
+ <td id="LC5002" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (className <span class="pl-k">!=</span> otherClass) {</td>
+ </tr>
+ <tr>
+ <td id="L5003" class="blob-num js-line-number" data-line-number="5003"></td>
+ <td id="LC5003" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5004" class="blob-num js-line-number" data-line-number="5004"></td>
+ <td id="LC5004" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5005" class="blob-num js-line-number" data-line-number="5005"></td>
+ <td id="LC5005" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">switch</span> (className) {</td>
+ </tr>
+ <tr>
+ <td id="L5006" class="blob-num js-line-number" data-line-number="5006"></td>
+ <td id="LC5006" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> boolClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L5007" class="blob-num js-line-number" data-line-number="5007"></td>
+ <td id="LC5007" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> dateClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L5008" class="blob-num js-line-number" data-line-number="5008"></td>
+ <td id="LC5008" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// coerce dates and booleans to numbers, dates to milliseconds and booleans</span></td>
+ </tr>
+ <tr>
+ <td id="L5009" class="blob-num js-line-number" data-line-number="5009"></td>
+ <td id="LC5009" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// to `1` or `0` treating invalid dates coerced to `NaN` as not equal</span></td>
+ </tr>
+ <tr>
+ <td id="L5010" class="blob-num js-line-number" data-line-number="5010"></td>
+ <td id="LC5010" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">+</span>a <span class="pl-k">==</span> <span class="pl-k">+</span>b;</td>
+ </tr>
+ <tr>
+ <td id="L5011" class="blob-num js-line-number" data-line-number="5011"></td>
+ <td id="LC5011" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5012" class="blob-num js-line-number" data-line-number="5012"></td>
+ <td id="LC5012" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> numberClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L5013" class="blob-num js-line-number" data-line-number="5013"></td>
+ <td id="LC5013" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// treat `NaN` vs. `NaN` as equal</span></td>
+ </tr>
+ <tr>
+ <td id="L5014" class="blob-num js-line-number" data-line-number="5014"></td>
+ <td id="LC5014" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (a <span class="pl-k">!=</span> <span class="pl-k">+</span>a)</td>
+ </tr>
+ <tr>
+ <td id="L5015" class="blob-num js-line-number" data-line-number="5015"></td>
+ <td id="LC5015" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> b <span class="pl-k">!=</span> <span class="pl-k">+</span>b</td>
+ </tr>
+ <tr>
+ <td id="L5016" class="blob-num js-line-number" data-line-number="5016"></td>
+ <td id="LC5016" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// but treat `+0` vs. `-0` as not equal</span></td>
+ </tr>
+ <tr>
+ <td id="L5017" class="blob-num js-line-number" data-line-number="5017"></td>
+ <td id="LC5017" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> (a <span class="pl-k">==</span> <span class="pl-c1">0</span> <span class="pl-k">?</span> (<span class="pl-c1">1</span> <span class="pl-k">/</span> a <span class="pl-k">==</span> <span class="pl-c1">1</span> <span class="pl-k">/</span> b) <span class="pl-k">:</span> a <span class="pl-k">==</span> <span class="pl-k">+</span>b);</td>
+ </tr>
+ <tr>
+ <td id="L5018" class="blob-num js-line-number" data-line-number="5018"></td>
+ <td id="LC5018" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5019" class="blob-num js-line-number" data-line-number="5019"></td>
+ <td id="LC5019" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> regexpClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L5020" class="blob-num js-line-number" data-line-number="5020"></td>
+ <td id="LC5020" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">case</span> stringClass<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L5021" class="blob-num js-line-number" data-line-number="5021"></td>
+ <td id="LC5021" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// coerce regexes to strings (http://es5.github.io/#x15.10.6.4)</span></td>
+ </tr>
+ <tr>
+ <td id="L5022" class="blob-num js-line-number" data-line-number="5022"></td>
+ <td id="LC5022" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// treat string primitives and their corresponding object instances as equal</span></td>
+ </tr>
+ <tr>
+ <td id="L5023" class="blob-num js-line-number" data-line-number="5023"></td>
+ <td id="LC5023" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> a <span class="pl-k">==</span> <span class="pl-c1">String</span>(b);</td>
+ </tr>
+ <tr>
+ <td id="L5024" class="blob-num js-line-number" data-line-number="5024"></td>
+ <td id="LC5024" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5025" class="blob-num js-line-number" data-line-number="5025"></td>
+ <td id="LC5025" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isArr <span class="pl-k">=</span> className <span class="pl-k">==</span> arrayClass;</td>
+ </tr>
+ <tr>
+ <td id="L5026" class="blob-num js-line-number" data-line-number="5026"></td>
+ <td id="LC5026" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L5027" class="blob-num js-line-number" data-line-number="5027"></td>
+ <td id="LC5027" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// unwrap any `lodash` wrapped values</span></td>
+ </tr>
+ <tr>
+ <td id="L5028" class="blob-num js-line-number" data-line-number="5028"></td>
+ <td id="LC5028" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> aWrapped <span class="pl-k">=</span> <span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(a, <span class="pl-s"><span class="pl-pds">'</span>__wrapped__<span class="pl-pds">'</span></span>),</td>
+ </tr>
+ <tr>
+ <td id="L5029" class="blob-num js-line-number" data-line-number="5029"></td>
+ <td id="LC5029" class="blob-code blob-code-inner js-file-line"> bWrapped <span class="pl-k">=</span> <span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(b, <span class="pl-s"><span class="pl-pds">'</span>__wrapped__<span class="pl-pds">'</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L5030" class="blob-num js-line-number" data-line-number="5030"></td>
+ <td id="LC5030" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5031" class="blob-num js-line-number" data-line-number="5031"></td>
+ <td id="LC5031" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (aWrapped <span class="pl-k">||</span> bWrapped) {</td>
+ </tr>
+ <tr>
+ <td id="L5032" class="blob-num js-line-number" data-line-number="5032"></td>
+ <td id="LC5032" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseIsEqual</span>(aWrapped <span class="pl-k">?</span> <span class="pl-smi">a</span>.<span class="pl-smi">__wrapped__</span> <span class="pl-k">:</span> a, bWrapped <span class="pl-k">?</span> <span class="pl-smi">b</span>.<span class="pl-smi">__wrapped__</span> <span class="pl-k">:</span> b, callback, isWhere, stackA, stackB);</td>
+ </tr>
+ <tr>
+ <td id="L5033" class="blob-num js-line-number" data-line-number="5033"></td>
+ <td id="LC5033" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5034" class="blob-num js-line-number" data-line-number="5034"></td>
+ <td id="LC5034" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// exit for functions and DOM nodes</span></td>
+ </tr>
+ <tr>
+ <td id="L5035" class="blob-num js-line-number" data-line-number="5035"></td>
+ <td id="LC5035" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (className <span class="pl-k">!=</span> objectClass) {</td>
+ </tr>
+ <tr>
+ <td id="L5036" class="blob-num js-line-number" data-line-number="5036"></td>
+ <td id="LC5036" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5037" class="blob-num js-line-number" data-line-number="5037"></td>
+ <td id="LC5037" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5038" class="blob-num js-line-number" data-line-number="5038"></td>
+ <td id="LC5038" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// in older versions of Opera, `arguments` objects have `Array` constructors</span></td>
+ </tr>
+ <tr>
+ <td id="L5039" class="blob-num js-line-number" data-line-number="5039"></td>
+ <td id="LC5039" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ctorA <span class="pl-k">=</span> <span class="pl-smi">a</span>.<span class="pl-c1">constructor</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5040" class="blob-num js-line-number" data-line-number="5040"></td>
+ <td id="LC5040" class="blob-code blob-code-inner js-file-line"> ctorB <span class="pl-k">=</span> <span class="pl-smi">b</span>.<span class="pl-c1">constructor</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5041" class="blob-num js-line-number" data-line-number="5041"></td>
+ <td id="LC5041" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5042" class="blob-num js-line-number" data-line-number="5042"></td>
+ <td id="LC5042" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// non `Object` object instances with different constructors are not equal</span></td>
+ </tr>
+ <tr>
+ <td id="L5043" class="blob-num js-line-number" data-line-number="5043"></td>
+ <td id="LC5043" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (ctorA <span class="pl-k">!=</span> ctorB <span class="pl-k">&&</span></td>
+ </tr>
+ <tr>
+ <td id="L5044" class="blob-num js-line-number" data-line-number="5044"></td>
+ <td id="LC5044" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">!</span>(<span class="pl-en">isFunction</span>(ctorA) <span class="pl-k">&&</span> ctorA <span class="pl-k">instanceof</span> ctorA <span class="pl-k">&&</span> <span class="pl-en">isFunction</span>(ctorB) <span class="pl-k">&&</span> ctorB <span class="pl-k">instanceof</span> ctorB) <span class="pl-k">&&</span></td>
+ </tr>
+ <tr>
+ <td id="L5045" class="blob-num js-line-number" data-line-number="5045"></td>
+ <td id="LC5045" class="blob-code blob-code-inner js-file-line"> (<span class="pl-s"><span class="pl-pds">'</span>constructor<span class="pl-pds">'</span></span> <span class="pl-k">in</span> a <span class="pl-k">&&</span> <span class="pl-s"><span class="pl-pds">'</span>constructor<span class="pl-pds">'</span></span> <span class="pl-k">in</span> b)</td>
+ </tr>
+ <tr>
+ <td id="L5046" class="blob-num js-line-number" data-line-number="5046"></td>
+ <td id="LC5046" class="blob-code blob-code-inner js-file-line"> ) {</td>
+ </tr>
+ <tr>
+ <td id="L5047" class="blob-num js-line-number" data-line-number="5047"></td>
+ <td id="LC5047" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5048" class="blob-num js-line-number" data-line-number="5048"></td>
+ <td id="LC5048" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5049" class="blob-num js-line-number" data-line-number="5049"></td>
+ <td id="LC5049" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5050" class="blob-num js-line-number" data-line-number="5050"></td>
+ <td id="LC5050" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// assume cyclic structures are equal</span></td>
+ </tr>
+ <tr>
+ <td id="L5051" class="blob-num js-line-number" data-line-number="5051"></td>
+ <td id="LC5051" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// the algorithm for detecting cyclic structures is adapted from ES 5.1</span></td>
+ </tr>
+ <tr>
+ <td id="L5052" class="blob-num js-line-number" data-line-number="5052"></td>
+ <td id="LC5052" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)</span></td>
+ </tr>
+ <tr>
+ <td id="L5053" class="blob-num js-line-number" data-line-number="5053"></td>
+ <td id="LC5053" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> initedStack <span class="pl-k">=</span> <span class="pl-k">!</span>stackA;</td>
+ </tr>
+ <tr>
+ <td id="L5054" class="blob-num js-line-number" data-line-number="5054"></td>
+ <td id="LC5054" class="blob-code blob-code-inner js-file-line"> stackA <span class="pl-k">||</span> (stackA <span class="pl-k">=</span> <span class="pl-en">getArray</span>());</td>
+ </tr>
+ <tr>
+ <td id="L5055" class="blob-num js-line-number" data-line-number="5055"></td>
+ <td id="LC5055" class="blob-code blob-code-inner js-file-line"> stackB <span class="pl-k">||</span> (stackB <span class="pl-k">=</span> <span class="pl-en">getArray</span>());</td>
+ </tr>
+ <tr>
+ <td id="L5056" class="blob-num js-line-number" data-line-number="5056"></td>
+ <td id="LC5056" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5057" class="blob-num js-line-number" data-line-number="5057"></td>
+ <td id="LC5057" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> <span class="pl-smi">stackA</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5058" class="blob-num js-line-number" data-line-number="5058"></td>
+ <td id="LC5058" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5059" class="blob-num js-line-number" data-line-number="5059"></td>
+ <td id="LC5059" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (stackA[length] <span class="pl-k">==</span> a) {</td>
+ </tr>
+ <tr>
+ <td id="L5060" class="blob-num js-line-number" data-line-number="5060"></td>
+ <td id="LC5060" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> stackB[length] <span class="pl-k">==</span> b;</td>
+ </tr>
+ <tr>
+ <td id="L5061" class="blob-num js-line-number" data-line-number="5061"></td>
+ <td id="LC5061" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5062" class="blob-num js-line-number" data-line-number="5062"></td>
+ <td id="LC5062" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5063" class="blob-num js-line-number" data-line-number="5063"></td>
+ <td id="LC5063" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> size <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5064" class="blob-num js-line-number" data-line-number="5064"></td>
+ <td id="LC5064" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5065" class="blob-num js-line-number" data-line-number="5065"></td>
+ <td id="LC5065" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5066" class="blob-num js-line-number" data-line-number="5066"></td>
+ <td id="LC5066" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add `a` and `b` to the stack of traversed objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5067" class="blob-num js-line-number" data-line-number="5067"></td>
+ <td id="LC5067" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackA</span>.<span class="pl-c1">push</span>(a);</td>
+ </tr>
+ <tr>
+ <td id="L5068" class="blob-num js-line-number" data-line-number="5068"></td>
+ <td id="LC5068" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackB</span>.<span class="pl-c1">push</span>(b);</td>
+ </tr>
+ <tr>
+ <td id="L5069" class="blob-num js-line-number" data-line-number="5069"></td>
+ <td id="LC5069" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5070" class="blob-num js-line-number" data-line-number="5070"></td>
+ <td id="LC5070" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// recursively compare objects and arrays (susceptible to call stack limits)</span></td>
+ </tr>
+ <tr>
+ <td id="L5071" class="blob-num js-line-number" data-line-number="5071"></td>
+ <td id="LC5071" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L5072" class="blob-num js-line-number" data-line-number="5072"></td>
+ <td id="LC5072" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// compare lengths to determine if a deep comparison is necessary</span></td>
+ </tr>
+ <tr>
+ <td id="L5073" class="blob-num js-line-number" data-line-number="5073"></td>
+ <td id="LC5073" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">a</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5074" class="blob-num js-line-number" data-line-number="5074"></td>
+ <td id="LC5074" class="blob-code blob-code-inner js-file-line"> size <span class="pl-k">=</span> <span class="pl-smi">b</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5075" class="blob-num js-line-number" data-line-number="5075"></td>
+ <td id="LC5075" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> size <span class="pl-k">==</span> length;</td>
+ </tr>
+ <tr>
+ <td id="L5076" class="blob-num js-line-number" data-line-number="5076"></td>
+ <td id="LC5076" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5077" class="blob-num js-line-number" data-line-number="5077"></td>
+ <td id="LC5077" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (result <span class="pl-k">||</span> isWhere) {</td>
+ </tr>
+ <tr>
+ <td id="L5078" class="blob-num js-line-number" data-line-number="5078"></td>
+ <td id="LC5078" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// deep compare the contents, ignoring non-numeric properties</span></td>
+ </tr>
+ <tr>
+ <td id="L5079" class="blob-num js-line-number" data-line-number="5079"></td>
+ <td id="LC5079" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (size<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5080" class="blob-num js-line-number" data-line-number="5080"></td>
+ <td id="LC5080" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> length,</td>
+ </tr>
+ <tr>
+ <td id="L5081" class="blob-num js-line-number" data-line-number="5081"></td>
+ <td id="LC5081" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> b[size];</td>
+ </tr>
+ <tr>
+ <td id="L5082" class="blob-num js-line-number" data-line-number="5082"></td>
+ <td id="LC5082" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5083" class="blob-num js-line-number" data-line-number="5083"></td>
+ <td id="LC5083" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isWhere) {</td>
+ </tr>
+ <tr>
+ <td id="L5084" class="blob-num js-line-number" data-line-number="5084"></td>
+ <td id="LC5084" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (index<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5085" class="blob-num js-line-number" data-line-number="5085"></td>
+ <td id="LC5085" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((result <span class="pl-k">=</span> <span class="pl-en">baseIsEqual</span>(a[index], value, callback, isWhere, stackA, stackB))) {</td>
+ </tr>
+ <tr>
+ <td id="L5086" class="blob-num js-line-number" data-line-number="5086"></td>
+ <td id="LC5086" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5087" class="blob-num js-line-number" data-line-number="5087"></td>
+ <td id="LC5087" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5088" class="blob-num js-line-number" data-line-number="5088"></td>
+ <td id="LC5088" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5089" class="blob-num js-line-number" data-line-number="5089"></td>
+ <td id="LC5089" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-k">!</span>(result <span class="pl-k">=</span> <span class="pl-en">baseIsEqual</span>(a[size], value, callback, isWhere, stackA, stackB))) {</td>
+ </tr>
+ <tr>
+ <td id="L5090" class="blob-num js-line-number" data-line-number="5090"></td>
+ <td id="LC5090" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5091" class="blob-num js-line-number" data-line-number="5091"></td>
+ <td id="LC5091" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5092" class="blob-num js-line-number" data-line-number="5092"></td>
+ <td id="LC5092" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5093" class="blob-num js-line-number" data-line-number="5093"></td>
+ <td id="LC5093" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5094" class="blob-num js-line-number" data-line-number="5094"></td>
+ <td id="LC5094" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5095" class="blob-num js-line-number" data-line-number="5095"></td>
+ <td id="LC5095" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L5096" class="blob-num js-line-number" data-line-number="5096"></td>
+ <td id="LC5096" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`</span></td>
+ </tr>
+ <tr>
+ <td id="L5097" class="blob-num js-line-number" data-line-number="5097"></td>
+ <td id="LC5097" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// which, in this case, is more costly</span></td>
+ </tr>
+ <tr>
+ <td id="L5098" class="blob-num js-line-number" data-line-number="5098"></td>
+ <td id="LC5098" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(b, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">b</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5099" class="blob-num js-line-number" data-line-number="5099"></td>
+ <td id="LC5099" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(b, key)) {</td>
+ </tr>
+ <tr>
+ <td id="L5100" class="blob-num js-line-number" data-line-number="5100"></td>
+ <td id="LC5100" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// count the number of properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L5101" class="blob-num js-line-number" data-line-number="5101"></td>
+ <td id="LC5101" class="blob-code blob-code-inner js-file-line"> size<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5102" class="blob-num js-line-number" data-line-number="5102"></td>
+ <td id="LC5102" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// deep compare each property value.</span></td>
+ </tr>
+ <tr>
+ <td id="L5103" class="blob-num js-line-number" data-line-number="5103"></td>
+ <td id="LC5103" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (result <span class="pl-k">=</span> <span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(a, key) <span class="pl-k">&&</span> <span class="pl-en">baseIsEqual</span>(a[key], value, callback, isWhere, stackA, stackB));</td>
+ </tr>
+ <tr>
+ <td id="L5104" class="blob-num js-line-number" data-line-number="5104"></td>
+ <td id="LC5104" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5105" class="blob-num js-line-number" data-line-number="5105"></td>
+ <td id="LC5105" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5106" class="blob-num js-line-number" data-line-number="5106"></td>
+ <td id="LC5106" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5107" class="blob-num js-line-number" data-line-number="5107"></td>
+ <td id="LC5107" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (result <span class="pl-k">&&</span> <span class="pl-k">!</span>isWhere) {</td>
+ </tr>
+ <tr>
+ <td id="L5108" class="blob-num js-line-number" data-line-number="5108"></td>
+ <td id="LC5108" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// ensure both objects have the same number of properties</span></td>
+ </tr>
+ <tr>
+ <td id="L5109" class="blob-num js-line-number" data-line-number="5109"></td>
+ <td id="LC5109" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(a, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">a</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5110" class="blob-num js-line-number" data-line-number="5110"></td>
+ <td id="LC5110" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(a, key)) {</td>
+ </tr>
+ <tr>
+ <td id="L5111" class="blob-num js-line-number" data-line-number="5111"></td>
+ <td id="LC5111" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// `size` will be `-1` if `a` has more properties than `b`</span></td>
+ </tr>
+ <tr>
+ <td id="L5112" class="blob-num js-line-number" data-line-number="5112"></td>
+ <td id="LC5112" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (result <span class="pl-k">=</span> <span class="pl-k">--</span>size <span class="pl-k">></span> <span class="pl-k">-</span><span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5113" class="blob-num js-line-number" data-line-number="5113"></td>
+ <td id="LC5113" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5114" class="blob-num js-line-number" data-line-number="5114"></td>
+ <td id="LC5114" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5115" class="blob-num js-line-number" data-line-number="5115"></td>
+ <td id="LC5115" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5116" class="blob-num js-line-number" data-line-number="5116"></td>
+ <td id="LC5116" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5117" class="blob-num js-line-number" data-line-number="5117"></td>
+ <td id="LC5117" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackA</span>.<span class="pl-c1">pop</span>();</td>
+ </tr>
+ <tr>
+ <td id="L5118" class="blob-num js-line-number" data-line-number="5118"></td>
+ <td id="LC5118" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackB</span>.<span class="pl-c1">pop</span>();</td>
+ </tr>
+ <tr>
+ <td id="L5119" class="blob-num js-line-number" data-line-number="5119"></td>
+ <td id="LC5119" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5120" class="blob-num js-line-number" data-line-number="5120"></td>
+ <td id="LC5120" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (initedStack) {</td>
+ </tr>
+ <tr>
+ <td id="L5121" class="blob-num js-line-number" data-line-number="5121"></td>
+ <td id="LC5121" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(stackA);</td>
+ </tr>
+ <tr>
+ <td id="L5122" class="blob-num js-line-number" data-line-number="5122"></td>
+ <td id="LC5122" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(stackB);</td>
+ </tr>
+ <tr>
+ <td id="L5123" class="blob-num js-line-number" data-line-number="5123"></td>
+ <td id="LC5123" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5124" class="blob-num js-line-number" data-line-number="5124"></td>
+ <td id="LC5124" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5125" class="blob-num js-line-number" data-line-number="5125"></td>
+ <td id="LC5125" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5126" class="blob-num js-line-number" data-line-number="5126"></td>
+ <td id="LC5126" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5127" class="blob-num js-line-number" data-line-number="5127"></td>
+ <td id="LC5127" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5128" class="blob-num js-line-number" data-line-number="5128"></td>
+ <td id="LC5128" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.merge` without argument juggling or support</span></td>
+ </tr>
+ <tr>
+ <td id="L5129" class="blob-num js-line-number" data-line-number="5129"></td>
+ <td id="LC5129" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for `thisArg` binding.</span></td>
+ </tr>
+ <tr>
+ <td id="L5130" class="blob-num js-line-number" data-line-number="5130"></td>
+ <td id="LC5130" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5131" class="blob-num js-line-number" data-line-number="5131"></td>
+ <td id="LC5131" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5132" class="blob-num js-line-number" data-line-number="5132"></td>
+ <td id="LC5132" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5133" class="blob-num js-line-number" data-line-number="5133"></td>
+ <td id="LC5133" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">source</span> The source object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5134" class="blob-num js-line-number" data-line-number="5134"></td>
+ <td id="LC5134" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize merging properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L5135" class="blob-num js-line-number" data-line-number="5135"></td>
+ <td id="LC5135" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [stackA=[]] Tracks traversed source objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L5136" class="blob-num js-line-number" data-line-number="5136"></td>
+ <td id="LC5136" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [stackB=[]] Associates values with source counterparts.</span></td>
+ </tr>
+ <tr>
+ <td id="L5137" class="blob-num js-line-number" data-line-number="5137"></td>
+ <td id="LC5137" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5138" class="blob-num js-line-number" data-line-number="5138"></td>
+ <td id="LC5138" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseMerge</span>(<span class="pl-smi">object</span>, <span class="pl-smi">source</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">stackA</span>, <span class="pl-smi">stackB</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5139" class="blob-num js-line-number" data-line-number="5139"></td>
+ <td id="LC5139" class="blob-code blob-code-inner js-file-line"> (<span class="pl-en">isArray</span>(source) <span class="pl-k">?</span> forEach <span class="pl-k">:</span> forOwn)(source, <span class="pl-k">function</span>(<span class="pl-smi">source</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5140" class="blob-num js-line-number" data-line-number="5140"></td>
+ <td id="LC5140" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> found,</td>
+ </tr>
+ <tr>
+ <td id="L5141" class="blob-num js-line-number" data-line-number="5141"></td>
+ <td id="LC5141" class="blob-code blob-code-inner js-file-line"> isArr,</td>
+ </tr>
+ <tr>
+ <td id="L5142" class="blob-num js-line-number" data-line-number="5142"></td>
+ <td id="LC5142" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> source,</td>
+ </tr>
+ <tr>
+ <td id="L5143" class="blob-num js-line-number" data-line-number="5143"></td>
+ <td id="LC5143" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> object[key];</td>
+ </tr>
+ <tr>
+ <td id="L5144" class="blob-num js-line-number" data-line-number="5144"></td>
+ <td id="LC5144" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5145" class="blob-num js-line-number" data-line-number="5145"></td>
+ <td id="LC5145" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (source <span class="pl-k">&&</span> ((isArr <span class="pl-k">=</span> <span class="pl-en">isArray</span>(source)) <span class="pl-k">||</span> <span class="pl-en">isPlainObject</span>(source))) {</td>
+ </tr>
+ <tr>
+ <td id="L5146" class="blob-num js-line-number" data-line-number="5146"></td>
+ <td id="LC5146" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// avoid merging previously merged cyclic sources</span></td>
+ </tr>
+ <tr>
+ <td id="L5147" class="blob-num js-line-number" data-line-number="5147"></td>
+ <td id="LC5147" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> stackLength <span class="pl-k">=</span> <span class="pl-smi">stackA</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5148" class="blob-num js-line-number" data-line-number="5148"></td>
+ <td id="LC5148" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (stackLength<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5149" class="blob-num js-line-number" data-line-number="5149"></td>
+ <td id="LC5149" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((found <span class="pl-k">=</span> stackA[stackLength] <span class="pl-k">==</span> source)) {</td>
+ </tr>
+ <tr>
+ <td id="L5150" class="blob-num js-line-number" data-line-number="5150"></td>
+ <td id="LC5150" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> stackB[stackLength];</td>
+ </tr>
+ <tr>
+ <td id="L5151" class="blob-num js-line-number" data-line-number="5151"></td>
+ <td id="LC5151" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5152" class="blob-num js-line-number" data-line-number="5152"></td>
+ <td id="LC5152" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5153" class="blob-num js-line-number" data-line-number="5153"></td>
+ <td id="LC5153" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5154" class="blob-num js-line-number" data-line-number="5154"></td>
+ <td id="LC5154" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>found) {</td>
+ </tr>
+ <tr>
+ <td id="L5155" class="blob-num js-line-number" data-line-number="5155"></td>
+ <td id="LC5155" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isShallow;</td>
+ </tr>
+ <tr>
+ <td id="L5156" class="blob-num js-line-number" data-line-number="5156"></td>
+ <td id="LC5156" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback) {</td>
+ </tr>
+ <tr>
+ <td id="L5157" class="blob-num js-line-number" data-line-number="5157"></td>
+ <td id="LC5157" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, source);</td>
+ </tr>
+ <tr>
+ <td id="L5158" class="blob-num js-line-number" data-line-number="5158"></td>
+ <td id="LC5158" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((isShallow <span class="pl-k">=</span> <span class="pl-k">typeof</span> result <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L5159" class="blob-num js-line-number" data-line-number="5159"></td>
+ <td id="LC5159" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5160" class="blob-num js-line-number" data-line-number="5160"></td>
+ <td id="LC5160" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5161" class="blob-num js-line-number" data-line-number="5161"></td>
+ <td id="LC5161" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5162" class="blob-num js-line-number" data-line-number="5162"></td>
+ <td id="LC5162" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isShallow) {</td>
+ </tr>
+ <tr>
+ <td id="L5163" class="blob-num js-line-number" data-line-number="5163"></td>
+ <td id="LC5163" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> isArr</td>
+ </tr>
+ <tr>
+ <td id="L5164" class="blob-num js-line-number" data-line-number="5164"></td>
+ <td id="LC5164" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> (<span class="pl-en">isArray</span>(value) <span class="pl-k">?</span> value <span class="pl-k">:</span> [])</td>
+ </tr>
+ <tr>
+ <td id="L5165" class="blob-num js-line-number" data-line-number="5165"></td>
+ <td id="LC5165" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> (<span class="pl-en">isPlainObject</span>(value) <span class="pl-k">?</span> value <span class="pl-k">:</span> {});</td>
+ </tr>
+ <tr>
+ <td id="L5166" class="blob-num js-line-number" data-line-number="5166"></td>
+ <td id="LC5166" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5167" class="blob-num js-line-number" data-line-number="5167"></td>
+ <td id="LC5167" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add `source` and associated `value` to the stack of traversed objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5168" class="blob-num js-line-number" data-line-number="5168"></td>
+ <td id="LC5168" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackA</span>.<span class="pl-c1">push</span>(source);</td>
+ </tr>
+ <tr>
+ <td id="L5169" class="blob-num js-line-number" data-line-number="5169"></td>
+ <td id="LC5169" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">stackB</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L5170" class="blob-num js-line-number" data-line-number="5170"></td>
+ <td id="LC5170" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5171" class="blob-num js-line-number" data-line-number="5171"></td>
+ <td id="LC5171" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// recursively merge objects and arrays (susceptible to call stack limits)</span></td>
+ </tr>
+ <tr>
+ <td id="L5172" class="blob-num js-line-number" data-line-number="5172"></td>
+ <td id="LC5172" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isShallow) {</td>
+ </tr>
+ <tr>
+ <td id="L5173" class="blob-num js-line-number" data-line-number="5173"></td>
+ <td id="LC5173" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">baseMerge</span>(value, source, callback, stackA, stackB);</td>
+ </tr>
+ <tr>
+ <td id="L5174" class="blob-num js-line-number" data-line-number="5174"></td>
+ <td id="LC5174" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5175" class="blob-num js-line-number" data-line-number="5175"></td>
+ <td id="LC5175" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5176" class="blob-num js-line-number" data-line-number="5176"></td>
+ <td id="LC5176" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5177" class="blob-num js-line-number" data-line-number="5177"></td>
+ <td id="LC5177" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L5178" class="blob-num js-line-number" data-line-number="5178"></td>
+ <td id="LC5178" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback) {</td>
+ </tr>
+ <tr>
+ <td id="L5179" class="blob-num js-line-number" data-line-number="5179"></td>
+ <td id="LC5179" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, source);</td>
+ </tr>
+ <tr>
+ <td id="L5180" class="blob-num js-line-number" data-line-number="5180"></td>
+ <td id="LC5180" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> result <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5181" class="blob-num js-line-number" data-line-number="5181"></td>
+ <td id="LC5181" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> source;</td>
+ </tr>
+ <tr>
+ <td id="L5182" class="blob-num js-line-number" data-line-number="5182"></td>
+ <td id="LC5182" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5183" class="blob-num js-line-number" data-line-number="5183"></td>
+ <td id="LC5183" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5184" class="blob-num js-line-number" data-line-number="5184"></td>
+ <td id="LC5184" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> result <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5185" class="blob-num js-line-number" data-line-number="5185"></td>
+ <td id="LC5185" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5186" class="blob-num js-line-number" data-line-number="5186"></td>
+ <td id="LC5186" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5187" class="blob-num js-line-number" data-line-number="5187"></td>
+ <td id="LC5187" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5188" class="blob-num js-line-number" data-line-number="5188"></td>
+ <td id="LC5188" class="blob-code blob-code-inner js-file-line"> object[key] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L5189" class="blob-num js-line-number" data-line-number="5189"></td>
+ <td id="LC5189" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5190" class="blob-num js-line-number" data-line-number="5190"></td>
+ <td id="LC5190" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5191" class="blob-num js-line-number" data-line-number="5191"></td>
+ <td id="LC5191" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5192" class="blob-num js-line-number" data-line-number="5192"></td>
+ <td id="LC5192" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5193" class="blob-num js-line-number" data-line-number="5193"></td>
+ <td id="LC5193" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.random` without argument juggling or support</span></td>
+ </tr>
+ <tr>
+ <td id="L5194" class="blob-num js-line-number" data-line-number="5194"></td>
+ <td id="LC5194" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for returning floating-point numbers.</span></td>
+ </tr>
+ <tr>
+ <td id="L5195" class="blob-num js-line-number" data-line-number="5195"></td>
+ <td id="LC5195" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5196" class="blob-num js-line-number" data-line-number="5196"></td>
+ <td id="LC5196" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5197" class="blob-num js-line-number" data-line-number="5197"></td>
+ <td id="LC5197" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">min</span> The minimum possible value.</span></td>
+ </tr>
+ <tr>
+ <td id="L5198" class="blob-num js-line-number" data-line-number="5198"></td>
+ <td id="LC5198" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">max</span> The maximum possible value.</span></td>
+ </tr>
+ <tr>
+ <td id="L5199" class="blob-num js-line-number" data-line-number="5199"></td>
+ <td id="LC5199" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> a random number.</span></td>
+ </tr>
+ <tr>
+ <td id="L5200" class="blob-num js-line-number" data-line-number="5200"></td>
+ <td id="LC5200" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5201" class="blob-num js-line-number" data-line-number="5201"></td>
+ <td id="LC5201" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseRandom</span>(<span class="pl-smi">min</span>, <span class="pl-smi">max</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5202" class="blob-num js-line-number" data-line-number="5202"></td>
+ <td id="LC5202" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> min <span class="pl-k">+</span> <span class="pl-en">floor</span>(<span class="pl-en">nativeRandom</span>() <span class="pl-k">*</span> (max <span class="pl-k">-</span> min <span class="pl-k">+</span> <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L5203" class="blob-num js-line-number" data-line-number="5203"></td>
+ <td id="LC5203" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5204" class="blob-num js-line-number" data-line-number="5204"></td>
+ <td id="LC5204" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5205" class="blob-num js-line-number" data-line-number="5205"></td>
+ <td id="LC5205" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5206" class="blob-num js-line-number" data-line-number="5206"></td>
+ <td id="LC5206" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The base implementation of `_.uniq` without support for callback shorthands</span></td>
+ </tr>
+ <tr>
+ <td id="L5207" class="blob-num js-line-number" data-line-number="5207"></td>
+ <td id="LC5207" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * or `thisArg` binding.</span></td>
+ </tr>
+ <tr>
+ <td id="L5208" class="blob-num js-line-number" data-line-number="5208"></td>
+ <td id="LC5208" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5209" class="blob-num js-line-number" data-line-number="5209"></td>
+ <td id="LC5209" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5210" class="blob-num js-line-number" data-line-number="5210"></td>
+ <td id="LC5210" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to process.</span></td>
+ </tr>
+ <tr>
+ <td id="L5211" class="blob-num js-line-number" data-line-number="5211"></td>
+ <td id="LC5211" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isSorted=false] A flag to indicate that `array` is sorted.</span></td>
+ </tr>
+ <tr>
+ <td id="L5212" class="blob-num js-line-number" data-line-number="5212"></td>
+ <td id="LC5212" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L5213" class="blob-num js-line-number" data-line-number="5213"></td>
+ <td id="LC5213" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a duplicate-value-free array.</span></td>
+ </tr>
+ <tr>
+ <td id="L5214" class="blob-num js-line-number" data-line-number="5214"></td>
+ <td id="LC5214" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5215" class="blob-num js-line-number" data-line-number="5215"></td>
+ <td id="LC5215" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">baseUniq</span>(<span class="pl-smi">array</span>, <span class="pl-smi">isSorted</span>, <span class="pl-smi">callback</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5216" class="blob-num js-line-number" data-line-number="5216"></td>
+ <td id="LC5216" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5217" class="blob-num js-line-number" data-line-number="5217"></td>
+ <td id="LC5217" class="blob-code blob-code-inner js-file-line"> indexOf <span class="pl-k">=</span> <span class="pl-en">getIndexOf</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L5218" class="blob-num js-line-number" data-line-number="5218"></td>
+ <td id="LC5218" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5219" class="blob-num js-line-number" data-line-number="5219"></td>
+ <td id="LC5219" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L5220" class="blob-num js-line-number" data-line-number="5220"></td>
+ <td id="LC5220" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5221" class="blob-num js-line-number" data-line-number="5221"></td>
+ <td id="LC5221" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isLarge <span class="pl-k">=</span> <span class="pl-k">!</span>isSorted <span class="pl-k">&&</span> length <span class="pl-k">>=</span> largeArraySize <span class="pl-k">&&</span> indexOf <span class="pl-k">===</span> baseIndexOf,</td>
+ </tr>
+ <tr>
+ <td id="L5222" class="blob-num js-line-number" data-line-number="5222"></td>
+ <td id="LC5222" class="blob-code blob-code-inner js-file-line"> seen <span class="pl-k">=</span> (callback <span class="pl-k">||</span> isLarge) <span class="pl-k">?</span> <span class="pl-en">getArray</span>() <span class="pl-k">:</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5223" class="blob-num js-line-number" data-line-number="5223"></td>
+ <td id="LC5223" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5224" class="blob-num js-line-number" data-line-number="5224"></td>
+ <td id="LC5224" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isLarge) {</td>
+ </tr>
+ <tr>
+ <td id="L5225" class="blob-num js-line-number" data-line-number="5225"></td>
+ <td id="LC5225" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> <span class="pl-en">createCache</span>(seen);</td>
+ </tr>
+ <tr>
+ <td id="L5226" class="blob-num js-line-number" data-line-number="5226"></td>
+ <td id="LC5226" class="blob-code blob-code-inner js-file-line"> indexOf <span class="pl-k">=</span> cacheIndexOf;</td>
+ </tr>
+ <tr>
+ <td id="L5227" class="blob-num js-line-number" data-line-number="5227"></td>
+ <td id="LC5227" class="blob-code blob-code-inner js-file-line"> seen <span class="pl-k">=</span> cache;</td>
+ </tr>
+ <tr>
+ <td id="L5228" class="blob-num js-line-number" data-line-number="5228"></td>
+ <td id="LC5228" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5229" class="blob-num js-line-number" data-line-number="5229"></td>
+ <td id="LC5229" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L5230" class="blob-num js-line-number" data-line-number="5230"></td>
+ <td id="LC5230" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> array[index],</td>
+ </tr>
+ <tr>
+ <td id="L5231" class="blob-num js-line-number" data-line-number="5231"></td>
+ <td id="LC5231" class="blob-code blob-code-inner js-file-line"> computed <span class="pl-k">=</span> callback <span class="pl-k">?</span> <span class="pl-en">callback</span>(value, index, array) <span class="pl-k">:</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L5232" class="blob-num js-line-number" data-line-number="5232"></td>
+ <td id="LC5232" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5233" class="blob-num js-line-number" data-line-number="5233"></td>
+ <td id="LC5233" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isSorted</td>
+ </tr>
+ <tr>
+ <td id="L5234" class="blob-num js-line-number" data-line-number="5234"></td>
+ <td id="LC5234" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-k">!</span>index <span class="pl-k">||</span> seen[<span class="pl-smi">seen</span>.<span class="pl-c1">length</span> <span class="pl-k">-</span> <span class="pl-c1">1</span>] <span class="pl-k">!==</span> computed</td>
+ </tr>
+ <tr>
+ <td id="L5235" class="blob-num js-line-number" data-line-number="5235"></td>
+ <td id="LC5235" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">indexOf</span>(seen, computed) <span class="pl-k"><</span> <span class="pl-c1">0</span></td>
+ </tr>
+ <tr>
+ <td id="L5236" class="blob-num js-line-number" data-line-number="5236"></td>
+ <td id="LC5236" class="blob-code blob-code-inner js-file-line"> ) {</td>
+ </tr>
+ <tr>
+ <td id="L5237" class="blob-num js-line-number" data-line-number="5237"></td>
+ <td id="LC5237" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback <span class="pl-k">||</span> isLarge) {</td>
+ </tr>
+ <tr>
+ <td id="L5238" class="blob-num js-line-number" data-line-number="5238"></td>
+ <td id="LC5238" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">seen</span>.<span class="pl-c1">push</span>(computed);</td>
+ </tr>
+ <tr>
+ <td id="L5239" class="blob-num js-line-number" data-line-number="5239"></td>
+ <td id="LC5239" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5240" class="blob-num js-line-number" data-line-number="5240"></td>
+ <td id="LC5240" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L5241" class="blob-num js-line-number" data-line-number="5241"></td>
+ <td id="LC5241" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5242" class="blob-num js-line-number" data-line-number="5242"></td>
+ <td id="LC5242" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5243" class="blob-num js-line-number" data-line-number="5243"></td>
+ <td id="LC5243" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isLarge) {</td>
+ </tr>
+ <tr>
+ <td id="L5244" class="blob-num js-line-number" data-line-number="5244"></td>
+ <td id="LC5244" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(<span class="pl-smi">seen</span>.<span class="pl-smi">array</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5245" class="blob-num js-line-number" data-line-number="5245"></td>
+ <td id="LC5245" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseObject</span>(seen);</td>
+ </tr>
+ <tr>
+ <td id="L5246" class="blob-num js-line-number" data-line-number="5246"></td>
+ <td id="LC5246" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (callback) {</td>
+ </tr>
+ <tr>
+ <td id="L5247" class="blob-num js-line-number" data-line-number="5247"></td>
+ <td id="LC5247" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(seen);</td>
+ </tr>
+ <tr>
+ <td id="L5248" class="blob-num js-line-number" data-line-number="5248"></td>
+ <td id="LC5248" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5249" class="blob-num js-line-number" data-line-number="5249"></td>
+ <td id="LC5249" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5250" class="blob-num js-line-number" data-line-number="5250"></td>
+ <td id="LC5250" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5251" class="blob-num js-line-number" data-line-number="5251"></td>
+ <td id="LC5251" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5252" class="blob-num js-line-number" data-line-number="5252"></td>
+ <td id="LC5252" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5253" class="blob-num js-line-number" data-line-number="5253"></td>
+ <td id="LC5253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that aggregates a collection, creating an object composed</span></td>
+ </tr>
+ <tr>
+ <td id="L5254" class="blob-num js-line-number" data-line-number="5254"></td>
+ <td id="LC5254" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of keys generated from the results of running each element of the collection</span></td>
+ </tr>
+ <tr>
+ <td id="L5255" class="blob-num js-line-number" data-line-number="5255"></td>
+ <td id="LC5255" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * through a callback. The given `setter` function sets the keys and values</span></td>
+ </tr>
+ <tr>
+ <td id="L5256" class="blob-num js-line-number" data-line-number="5256"></td>
+ <td id="LC5256" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of the composed object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5257" class="blob-num js-line-number" data-line-number="5257"></td>
+ <td id="LC5257" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5258" class="blob-num js-line-number" data-line-number="5258"></td>
+ <td id="LC5258" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5259" class="blob-num js-line-number" data-line-number="5259"></td>
+ <td id="LC5259" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">setter</span> The setter function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5260" class="blob-num js-line-number" data-line-number="5260"></td>
+ <td id="LC5260" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new aggregator function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5261" class="blob-num js-line-number" data-line-number="5261"></td>
+ <td id="LC5261" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5262" class="blob-num js-line-number" data-line-number="5262"></td>
+ <td id="LC5262" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">createAggregator</span>(<span class="pl-smi">setter</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5263" class="blob-num js-line-number" data-line-number="5263"></td>
+ <td id="LC5263" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5264" class="blob-num js-line-number" data-line-number="5264"></td>
+ <td id="LC5264" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L5265" class="blob-num js-line-number" data-line-number="5265"></td>
+ <td id="LC5265" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5266" class="blob-num js-line-number" data-line-number="5266"></td>
+ <td id="LC5266" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5267" class="blob-num js-line-number" data-line-number="5267"></td>
+ <td id="LC5267" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5268" class="blob-num js-line-number" data-line-number="5268"></td>
+ <td id="LC5268" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5269" class="blob-num js-line-number" data-line-number="5269"></td>
+ <td id="LC5269" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5270" class="blob-num js-line-number" data-line-number="5270"></td>
+ <td id="LC5270" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5271" class="blob-num js-line-number" data-line-number="5271"></td>
+ <td id="LC5271" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L5272" class="blob-num js-line-number" data-line-number="5272"></td>
+ <td id="LC5272" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> collection[index];</td>
+ </tr>
+ <tr>
+ <td id="L5273" class="blob-num js-line-number" data-line-number="5273"></td>
+ <td id="LC5273" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">setter</span>(result, value, <span class="pl-en">callback</span>(value, index, collection), collection);</td>
+ </tr>
+ <tr>
+ <td id="L5274" class="blob-num js-line-number" data-line-number="5274"></td>
+ <td id="LC5274" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5275" class="blob-num js-line-number" data-line-number="5275"></td>
+ <td id="LC5275" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L5276" class="blob-num js-line-number" data-line-number="5276"></td>
+ <td id="LC5276" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5277" class="blob-num js-line-number" data-line-number="5277"></td>
+ <td id="LC5277" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">setter</span>(result, value, <span class="pl-en">callback</span>(value, key, collection), collection);</td>
+ </tr>
+ <tr>
+ <td id="L5278" class="blob-num js-line-number" data-line-number="5278"></td>
+ <td id="LC5278" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5279" class="blob-num js-line-number" data-line-number="5279"></td>
+ <td id="LC5279" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5280" class="blob-num js-line-number" data-line-number="5280"></td>
+ <td id="LC5280" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5281" class="blob-num js-line-number" data-line-number="5281"></td>
+ <td id="LC5281" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5282" class="blob-num js-line-number" data-line-number="5282"></td>
+ <td id="LC5282" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5283" class="blob-num js-line-number" data-line-number="5283"></td>
+ <td id="LC5283" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5284" class="blob-num js-line-number" data-line-number="5284"></td>
+ <td id="LC5284" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5285" class="blob-num js-line-number" data-line-number="5285"></td>
+ <td id="LC5285" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that, when called, either curries or invokes `func`</span></td>
+ </tr>
+ <tr>
+ <td id="L5286" class="blob-num js-line-number" data-line-number="5286"></td>
+ <td id="LC5286" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * with an optional `this` binding and partially applied arguments.</span></td>
+ </tr>
+ <tr>
+ <td id="L5287" class="blob-num js-line-number" data-line-number="5287"></td>
+ <td id="LC5287" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5288" class="blob-num js-line-number" data-line-number="5288"></td>
+ <td id="LC5288" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5289" class="blob-num js-line-number" data-line-number="5289"></td>
+ <td id="LC5289" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|string} func The function or method name to reference.</span></td>
+ </tr>
+ <tr>
+ <td id="L5290" class="blob-num js-line-number" data-line-number="5290"></td>
+ <td id="LC5290" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">bitmask</span> The bitmask of method flags to compose.</span></td>
+ </tr>
+ <tr>
+ <td id="L5291" class="blob-num js-line-number" data-line-number="5291"></td>
+ <td id="LC5291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The bitmask may be composed of the following flags:</span></td>
+ </tr>
+ <tr>
+ <td id="L5292" class="blob-num js-line-number" data-line-number="5292"></td>
+ <td id="LC5292" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 1 - `_.bind`</span></td>
+ </tr>
+ <tr>
+ <td id="L5293" class="blob-num js-line-number" data-line-number="5293"></td>
+ <td id="LC5293" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 2 - `_.bindKey`</span></td>
+ </tr>
+ <tr>
+ <td id="L5294" class="blob-num js-line-number" data-line-number="5294"></td>
+ <td id="LC5294" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 4 - `_.curry`</span></td>
+ </tr>
+ <tr>
+ <td id="L5295" class="blob-num js-line-number" data-line-number="5295"></td>
+ <td id="LC5295" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 8 - `_.curry` (bound)</span></td>
+ </tr>
+ <tr>
+ <td id="L5296" class="blob-num js-line-number" data-line-number="5296"></td>
+ <td id="LC5296" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 16 - `_.partial`</span></td>
+ </tr>
+ <tr>
+ <td id="L5297" class="blob-num js-line-number" data-line-number="5297"></td>
+ <td id="LC5297" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 32 - `_.partialRight`</span></td>
+ </tr>
+ <tr>
+ <td id="L5298" class="blob-num js-line-number" data-line-number="5298"></td>
+ <td id="LC5298" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [partialArgs] An array of arguments to prepend to those</span></td>
+ </tr>
+ <tr>
+ <td id="L5299" class="blob-num js-line-number" data-line-number="5299"></td>
+ <td id="LC5299" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided to the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5300" class="blob-num js-line-number" data-line-number="5300"></td>
+ <td id="LC5300" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [partialRightArgs] An array of arguments to append to those</span></td>
+ </tr>
+ <tr>
+ <td id="L5301" class="blob-num js-line-number" data-line-number="5301"></td>
+ <td id="LC5301" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided to the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5302" class="blob-num js-line-number" data-line-number="5302"></td>
+ <td id="LC5302" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `func`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5303" class="blob-num js-line-number" data-line-number="5303"></td>
+ <td id="LC5303" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [arity] The arity of `func`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5304" class="blob-num js-line-number" data-line-number="5304"></td>
+ <td id="LC5304" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5305" class="blob-num js-line-number" data-line-number="5305"></td>
+ <td id="LC5305" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5306" class="blob-num js-line-number" data-line-number="5306"></td>
+ <td id="LC5306" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">createWrapper</span>(<span class="pl-smi">func</span>, <span class="pl-smi">bitmask</span>, <span class="pl-smi">partialArgs</span>, <span class="pl-smi">partialRightArgs</span>, <span class="pl-smi">thisArg</span>, <span class="pl-smi">arity</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5307" class="blob-num js-line-number" data-line-number="5307"></td>
+ <td id="LC5307" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isBind <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5308" class="blob-num js-line-number" data-line-number="5308"></td>
+ <td id="LC5308" class="blob-code blob-code-inner js-file-line"> isBindKey <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">2</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5309" class="blob-num js-line-number" data-line-number="5309"></td>
+ <td id="LC5309" class="blob-code blob-code-inner js-file-line"> isCurry <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">4</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5310" class="blob-num js-line-number" data-line-number="5310"></td>
+ <td id="LC5310" class="blob-code blob-code-inner js-file-line"> isCurryBound <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">8</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5311" class="blob-num js-line-number" data-line-number="5311"></td>
+ <td id="LC5311" class="blob-code blob-code-inner js-file-line"> isPartial <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">16</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5312" class="blob-num js-line-number" data-line-number="5312"></td>
+ <td id="LC5312" class="blob-code blob-code-inner js-file-line"> isPartialRight <span class="pl-k">=</span> bitmask <span class="pl-k">&</span> <span class="pl-c1">32</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5313" class="blob-num js-line-number" data-line-number="5313"></td>
+ <td id="LC5313" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5314" class="blob-num js-line-number" data-line-number="5314"></td>
+ <td id="LC5314" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isBindKey <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L5315" class="blob-num js-line-number" data-line-number="5315"></td>
+ <td id="LC5315" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5316" class="blob-num js-line-number" data-line-number="5316"></td>
+ <td id="LC5316" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5317" class="blob-num js-line-number" data-line-number="5317"></td>
+ <td id="LC5317" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isPartial <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-smi">partialArgs</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5318" class="blob-num js-line-number" data-line-number="5318"></td>
+ <td id="LC5318" class="blob-code blob-code-inner js-file-line"> bitmask <span class="pl-k">&=</span> <span class="pl-k">~</span><span class="pl-c1">16</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5319" class="blob-num js-line-number" data-line-number="5319"></td>
+ <td id="LC5319" class="blob-code blob-code-inner js-file-line"> isPartial <span class="pl-k">=</span> partialArgs <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5320" class="blob-num js-line-number" data-line-number="5320"></td>
+ <td id="LC5320" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5321" class="blob-num js-line-number" data-line-number="5321"></td>
+ <td id="LC5321" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isPartialRight <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-smi">partialRightArgs</span>.<span class="pl-c1">length</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5322" class="blob-num js-line-number" data-line-number="5322"></td>
+ <td id="LC5322" class="blob-code blob-code-inner js-file-line"> bitmask <span class="pl-k">&=</span> <span class="pl-k">~</span><span class="pl-c1">32</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5323" class="blob-num js-line-number" data-line-number="5323"></td>
+ <td id="LC5323" class="blob-code blob-code-inner js-file-line"> isPartialRight <span class="pl-k">=</span> partialRightArgs <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5324" class="blob-num js-line-number" data-line-number="5324"></td>
+ <td id="LC5324" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5325" class="blob-num js-line-number" data-line-number="5325"></td>
+ <td id="LC5325" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> bindData <span class="pl-k">=</span> func <span class="pl-k">&&</span> <span class="pl-smi">func</span>.<span class="pl-smi">__bindData__</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5326" class="blob-num js-line-number" data-line-number="5326"></td>
+ <td id="LC5326" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (bindData <span class="pl-k">&&</span> bindData <span class="pl-k">!==</span> <span class="pl-c1">true</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5327" class="blob-num js-line-number" data-line-number="5327"></td>
+ <td id="LC5327" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// clone `bindData`</span></td>
+ </tr>
+ <tr>
+ <td id="L5328" class="blob-num js-line-number" data-line-number="5328"></td>
+ <td id="LC5328" class="blob-code blob-code-inner js-file-line"> bindData <span class="pl-k">=</span> <span class="pl-en">slice</span>(bindData);</td>
+ </tr>
+ <tr>
+ <td id="L5329" class="blob-num js-line-number" data-line-number="5329"></td>
+ <td id="LC5329" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (bindData[<span class="pl-c1">2</span>]) {</td>
+ </tr>
+ <tr>
+ <td id="L5330" class="blob-num js-line-number" data-line-number="5330"></td>
+ <td id="LC5330" class="blob-code blob-code-inner js-file-line"> bindData[<span class="pl-c1">2</span>] <span class="pl-k">=</span> <span class="pl-en">slice</span>(bindData[<span class="pl-c1">2</span>]);</td>
+ </tr>
+ <tr>
+ <td id="L5331" class="blob-num js-line-number" data-line-number="5331"></td>
+ <td id="LC5331" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5332" class="blob-num js-line-number" data-line-number="5332"></td>
+ <td id="LC5332" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (bindData[<span class="pl-c1">3</span>]) {</td>
+ </tr>
+ <tr>
+ <td id="L5333" class="blob-num js-line-number" data-line-number="5333"></td>
+ <td id="LC5333" class="blob-code blob-code-inner js-file-line"> bindData[<span class="pl-c1">3</span>] <span class="pl-k">=</span> <span class="pl-en">slice</span>(bindData[<span class="pl-c1">3</span>]);</td>
+ </tr>
+ <tr>
+ <td id="L5334" class="blob-num js-line-number" data-line-number="5334"></td>
+ <td id="LC5334" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5335" class="blob-num js-line-number" data-line-number="5335"></td>
+ <td id="LC5335" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// set `thisBinding` is not previously bound</span></td>
+ </tr>
+ <tr>
+ <td id="L5336" class="blob-num js-line-number" data-line-number="5336"></td>
+ <td id="LC5336" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isBind <span class="pl-k">&&</span> <span class="pl-k">!</span>(bindData[<span class="pl-c1">1</span>] <span class="pl-k">&</span> <span class="pl-c1">1</span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L5337" class="blob-num js-line-number" data-line-number="5337"></td>
+ <td id="LC5337" class="blob-code blob-code-inner js-file-line"> bindData[<span class="pl-c1">4</span>] <span class="pl-k">=</span> thisArg;</td>
+ </tr>
+ <tr>
+ <td id="L5338" class="blob-num js-line-number" data-line-number="5338"></td>
+ <td id="LC5338" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5339" class="blob-num js-line-number" data-line-number="5339"></td>
+ <td id="LC5339" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// set if previously bound but not currently (subsequent curried functions)</span></td>
+ </tr>
+ <tr>
+ <td id="L5340" class="blob-num js-line-number" data-line-number="5340"></td>
+ <td id="LC5340" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isBind <span class="pl-k">&&</span> bindData[<span class="pl-c1">1</span>] <span class="pl-k">&</span> <span class="pl-c1">1</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5341" class="blob-num js-line-number" data-line-number="5341"></td>
+ <td id="LC5341" class="blob-code blob-code-inner js-file-line"> bitmask <span class="pl-k">|=</span> <span class="pl-c1">8</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5342" class="blob-num js-line-number" data-line-number="5342"></td>
+ <td id="LC5342" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5343" class="blob-num js-line-number" data-line-number="5343"></td>
+ <td id="LC5343" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// set curried arity if not yet set</span></td>
+ </tr>
+ <tr>
+ <td id="L5344" class="blob-num js-line-number" data-line-number="5344"></td>
+ <td id="LC5344" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isCurry <span class="pl-k">&&</span> <span class="pl-k">!</span>(bindData[<span class="pl-c1">1</span>] <span class="pl-k">&</span> <span class="pl-c1">4</span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L5345" class="blob-num js-line-number" data-line-number="5345"></td>
+ <td id="LC5345" class="blob-code blob-code-inner js-file-line"> bindData[<span class="pl-c1">5</span>] <span class="pl-k">=</span> arity;</td>
+ </tr>
+ <tr>
+ <td id="L5346" class="blob-num js-line-number" data-line-number="5346"></td>
+ <td id="LC5346" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5347" class="blob-num js-line-number" data-line-number="5347"></td>
+ <td id="LC5347" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// append partial left arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L5348" class="blob-num js-line-number" data-line-number="5348"></td>
+ <td id="LC5348" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isPartial) {</td>
+ </tr>
+ <tr>
+ <td id="L5349" class="blob-num js-line-number" data-line-number="5349"></td>
+ <td id="LC5349" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">push</span>.<span class="pl-c1">apply</span>(bindData[<span class="pl-c1">2</span>] <span class="pl-k">||</span> (bindData[<span class="pl-c1">2</span>] <span class="pl-k">=</span> []), partialArgs);</td>
+ </tr>
+ <tr>
+ <td id="L5350" class="blob-num js-line-number" data-line-number="5350"></td>
+ <td id="LC5350" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5351" class="blob-num js-line-number" data-line-number="5351"></td>
+ <td id="LC5351" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// append partial right arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L5352" class="blob-num js-line-number" data-line-number="5352"></td>
+ <td id="LC5352" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isPartialRight) {</td>
+ </tr>
+ <tr>
+ <td id="L5353" class="blob-num js-line-number" data-line-number="5353"></td>
+ <td id="LC5353" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">unshift</span>.<span class="pl-c1">apply</span>(bindData[<span class="pl-c1">3</span>] <span class="pl-k">||</span> (bindData[<span class="pl-c1">3</span>] <span class="pl-k">=</span> []), partialRightArgs);</td>
+ </tr>
+ <tr>
+ <td id="L5354" class="blob-num js-line-number" data-line-number="5354"></td>
+ <td id="LC5354" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5355" class="blob-num js-line-number" data-line-number="5355"></td>
+ <td id="LC5355" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// merge flags</span></td>
+ </tr>
+ <tr>
+ <td id="L5356" class="blob-num js-line-number" data-line-number="5356"></td>
+ <td id="LC5356" class="blob-code blob-code-inner js-file-line"> bindData[<span class="pl-c1">1</span>] <span class="pl-k">|=</span> bitmask;</td>
+ </tr>
+ <tr>
+ <td id="L5357" class="blob-num js-line-number" data-line-number="5357"></td>
+ <td id="LC5357" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">createWrapper</span>.<span class="pl-c1">apply</span>(<span class="pl-c1">null</span>, bindData);</td>
+ </tr>
+ <tr>
+ <td id="L5358" class="blob-num js-line-number" data-line-number="5358"></td>
+ <td id="LC5358" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5359" class="blob-num js-line-number" data-line-number="5359"></td>
+ <td id="LC5359" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// fast path for `_.bind`</span></td>
+ </tr>
+ <tr>
+ <td id="L5360" class="blob-num js-line-number" data-line-number="5360"></td>
+ <td id="LC5360" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> creater <span class="pl-k">=</span> (bitmask <span class="pl-k">==</span> <span class="pl-c1">1</span> <span class="pl-k">||</span> bitmask <span class="pl-k">===</span> <span class="pl-c1">17</span>) <span class="pl-k">?</span> baseBind <span class="pl-k">:</span> baseCreateWrapper;</td>
+ </tr>
+ <tr>
+ <td id="L5361" class="blob-num js-line-number" data-line-number="5361"></td>
+ <td id="LC5361" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">creater</span>([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);</td>
+ </tr>
+ <tr>
+ <td id="L5362" class="blob-num js-line-number" data-line-number="5362"></td>
+ <td id="LC5362" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5363" class="blob-num js-line-number" data-line-number="5363"></td>
+ <td id="LC5363" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5364" class="blob-num js-line-number" data-line-number="5364"></td>
+ <td id="LC5364" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5365" class="blob-num js-line-number" data-line-number="5365"></td>
+ <td id="LC5365" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used by `escape` to convert characters to HTML entities.</span></td>
+ </tr>
+ <tr>
+ <td id="L5366" class="blob-num js-line-number" data-line-number="5366"></td>
+ <td id="LC5366" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5367" class="blob-num js-line-number" data-line-number="5367"></td>
+ <td id="LC5367" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5368" class="blob-num js-line-number" data-line-number="5368"></td>
+ <td id="LC5368" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">match</span> The matched character to escape.</span></td>
+ </tr>
+ <tr>
+ <td id="L5369" class="blob-num js-line-number" data-line-number="5369"></td>
+ <td id="LC5369" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the escaped character.</span></td>
+ </tr>
+ <tr>
+ <td id="L5370" class="blob-num js-line-number" data-line-number="5370"></td>
+ <td id="LC5370" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5371" class="blob-num js-line-number" data-line-number="5371"></td>
+ <td id="LC5371" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">escapeHtmlChar</span>(<span class="pl-smi">match</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5372" class="blob-num js-line-number" data-line-number="5372"></td>
+ <td id="LC5372" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> htmlEscapes[match];</td>
+ </tr>
+ <tr>
+ <td id="L5373" class="blob-num js-line-number" data-line-number="5373"></td>
+ <td id="LC5373" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5374" class="blob-num js-line-number" data-line-number="5374"></td>
+ <td id="LC5374" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5375" class="blob-num js-line-number" data-line-number="5375"></td>
+ <td id="LC5375" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5376" class="blob-num js-line-number" data-line-number="5376"></td>
+ <td id="LC5376" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the appropriate "indexOf" function. If the `_.indexOf` method is</span></td>
+ </tr>
+ <tr>
+ <td id="L5377" class="blob-num js-line-number" data-line-number="5377"></td>
+ <td id="LC5377" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * customized, this method returns the custom method, otherwise it returns</span></td>
+ </tr>
+ <tr>
+ <td id="L5378" class="blob-num js-line-number" data-line-number="5378"></td>
+ <td id="LC5378" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the `baseIndexOf` function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5379" class="blob-num js-line-number" data-line-number="5379"></td>
+ <td id="LC5379" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5380" class="blob-num js-line-number" data-line-number="5380"></td>
+ <td id="LC5380" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5381" class="blob-num js-line-number" data-line-number="5381"></td>
+ <td id="LC5381" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the "indexOf" function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5382" class="blob-num js-line-number" data-line-number="5382"></td>
+ <td id="LC5382" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5383" class="blob-num js-line-number" data-line-number="5383"></td>
+ <td id="LC5383" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">getIndexOf</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L5384" class="blob-num js-line-number" data-line-number="5384"></td>
+ <td id="LC5384" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> (result <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-smi">indexOf</span>) <span class="pl-k">===</span> indexOf <span class="pl-k">?</span> baseIndexOf <span class="pl-k">:</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5385" class="blob-num js-line-number" data-line-number="5385"></td>
+ <td id="LC5385" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5386" class="blob-num js-line-number" data-line-number="5386"></td>
+ <td id="LC5386" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5387" class="blob-num js-line-number" data-line-number="5387"></td>
+ <td id="LC5387" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5388" class="blob-num js-line-number" data-line-number="5388"></td>
+ <td id="LC5388" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5389" class="blob-num js-line-number" data-line-number="5389"></td>
+ <td id="LC5389" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a native function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5390" class="blob-num js-line-number" data-line-number="5390"></td>
+ <td id="LC5390" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5391" class="blob-num js-line-number" data-line-number="5391"></td>
+ <td id="LC5391" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5392" class="blob-num js-line-number" data-line-number="5392"></td>
+ <td id="LC5392" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L5393" class="blob-num js-line-number" data-line-number="5393"></td>
+ <td id="LC5393" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a native function, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5394" class="blob-num js-line-number" data-line-number="5394"></td>
+ <td id="LC5394" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5395" class="blob-num js-line-number" data-line-number="5395"></td>
+ <td id="LC5395" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isNative</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5396" class="blob-num js-line-number" data-line-number="5396"></td>
+ <td id="LC5396" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-smi">reNative</span>.<span class="pl-c1">test</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L5397" class="blob-num js-line-number" data-line-number="5397"></td>
+ <td id="LC5397" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5398" class="blob-num js-line-number" data-line-number="5398"></td>
+ <td id="LC5398" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5399" class="blob-num js-line-number" data-line-number="5399"></td>
+ <td id="LC5399" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5400" class="blob-num js-line-number" data-line-number="5400"></td>
+ <td id="LC5400" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Sets `this` binding data on a given function.</span></td>
+ </tr>
+ <tr>
+ <td id="L5401" class="blob-num js-line-number" data-line-number="5401"></td>
+ <td id="LC5401" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5402" class="blob-num js-line-number" data-line-number="5402"></td>
+ <td id="LC5402" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5403" class="blob-num js-line-number" data-line-number="5403"></td>
+ <td id="LC5403" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to set data on.</span></td>
+ </tr>
+ <tr>
+ <td id="L5404" class="blob-num js-line-number" data-line-number="5404"></td>
+ <td id="LC5404" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">value</span> The data array to set.</span></td>
+ </tr>
+ <tr>
+ <td id="L5405" class="blob-num js-line-number" data-line-number="5405"></td>
+ <td id="LC5405" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5406" class="blob-num js-line-number" data-line-number="5406"></td>
+ <td id="LC5406" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> setBindData <span class="pl-k">=</span> <span class="pl-k">!</span>defineProperty <span class="pl-k">?</span> <span class="pl-en">noop</span> <span class="pl-k">:</span> <span class="pl-k">function</span>(<span class="pl-smi">func</span>, <span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5407" class="blob-num js-line-number" data-line-number="5407"></td>
+ <td id="LC5407" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">descriptor</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L5408" class="blob-num js-line-number" data-line-number="5408"></td>
+ <td id="LC5408" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">defineProperty</span>(func, <span class="pl-s"><span class="pl-pds">'</span>__bindData__<span class="pl-pds">'</span></span>, descriptor);</td>
+ </tr>
+ <tr>
+ <td id="L5409" class="blob-num js-line-number" data-line-number="5409"></td>
+ <td id="LC5409" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">descriptor</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5410" class="blob-num js-line-number" data-line-number="5410"></td>
+ <td id="LC5410" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5411" class="blob-num js-line-number" data-line-number="5411"></td>
+ <td id="LC5411" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5412" class="blob-num js-line-number" data-line-number="5412"></td>
+ <td id="LC5412" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5413" class="blob-num js-line-number" data-line-number="5413"></td>
+ <td id="LC5413" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A fallback implementation of `isPlainObject` which checks if a given value</span></td>
+ </tr>
+ <tr>
+ <td id="L5414" class="blob-num js-line-number" data-line-number="5414"></td>
+ <td id="LC5414" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is an object created by the `Object` constructor, assuming objects created</span></td>
+ </tr>
+ <tr>
+ <td id="L5415" class="blob-num js-line-number" data-line-number="5415"></td>
+ <td id="LC5415" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * by the `Object` constructor have no inherited enumerable properties and that</span></td>
+ </tr>
+ <tr>
+ <td id="L5416" class="blob-num js-line-number" data-line-number="5416"></td>
+ <td id="LC5416" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * there are no `Object.prototype` extensions.</span></td>
+ </tr>
+ <tr>
+ <td id="L5417" class="blob-num js-line-number" data-line-number="5417"></td>
+ <td id="LC5417" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5418" class="blob-num js-line-number" data-line-number="5418"></td>
+ <td id="LC5418" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5419" class="blob-num js-line-number" data-line-number="5419"></td>
+ <td id="LC5419" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L5420" class="blob-num js-line-number" data-line-number="5420"></td>
+ <td id="LC5420" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if `value` is a plain object, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5421" class="blob-num js-line-number" data-line-number="5421"></td>
+ <td id="LC5421" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5422" class="blob-num js-line-number" data-line-number="5422"></td>
+ <td id="LC5422" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">shimIsPlainObject</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5423" class="blob-num js-line-number" data-line-number="5423"></td>
+ <td id="LC5423" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ctor,</td>
+ </tr>
+ <tr>
+ <td id="L5424" class="blob-num js-line-number" data-line-number="5424"></td>
+ <td id="LC5424" class="blob-code blob-code-inner js-file-line"> result;</td>
+ </tr>
+ <tr>
+ <td id="L5425" class="blob-num js-line-number" data-line-number="5425"></td>
+ <td id="LC5425" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5426" class="blob-num js-line-number" data-line-number="5426"></td>
+ <td id="LC5426" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// avoid non Object objects, `arguments` objects, and DOM elements</span></td>
+ </tr>
+ <tr>
+ <td id="L5427" class="blob-num js-line-number" data-line-number="5427"></td>
+ <td id="LC5427" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>(value <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> objectClass) <span class="pl-k">||</span></td>
+ </tr>
+ <tr>
+ <td id="L5428" class="blob-num js-line-number" data-line-number="5428"></td>
+ <td id="LC5428" class="blob-code blob-code-inner js-file-line"> (ctor <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-c1">constructor</span>, <span class="pl-en">isFunction</span>(ctor) <span class="pl-k">&&</span> <span class="pl-k">!</span>(ctor <span class="pl-k">instanceof</span> ctor))) {</td>
+ </tr>
+ <tr>
+ <td id="L5429" class="blob-num js-line-number" data-line-number="5429"></td>
+ <td id="LC5429" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5430" class="blob-num js-line-number" data-line-number="5430"></td>
+ <td id="LC5430" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5431" class="blob-num js-line-number" data-line-number="5431"></td>
+ <td id="LC5431" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// In most environments an object's own properties are iterated before</span></td>
+ </tr>
+ <tr>
+ <td id="L5432" class="blob-num js-line-number" data-line-number="5432"></td>
+ <td id="LC5432" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// its inherited properties. If the last iterated property is an object's</span></td>
+ </tr>
+ <tr>
+ <td id="L5433" class="blob-num js-line-number" data-line-number="5433"></td>
+ <td id="LC5433" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// own property then there are no inherited enumerable properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L5434" class="blob-num js-line-number" data-line-number="5434"></td>
+ <td id="LC5434" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(value, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5435" class="blob-num js-line-number" data-line-number="5435"></td>
+ <td id="LC5435" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> key;</td>
+ </tr>
+ <tr>
+ <td id="L5436" class="blob-num js-line-number" data-line-number="5436"></td>
+ <td id="LC5436" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5437" class="blob-num js-line-number" data-line-number="5437"></td>
+ <td id="LC5437" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> result <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span> <span class="pl-k">||</span> <span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(value, result);</td>
+ </tr>
+ <tr>
+ <td id="L5438" class="blob-num js-line-number" data-line-number="5438"></td>
+ <td id="LC5438" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5439" class="blob-num js-line-number" data-line-number="5439"></td>
+ <td id="LC5439" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5440" class="blob-num js-line-number" data-line-number="5440"></td>
+ <td id="LC5440" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5441" class="blob-num js-line-number" data-line-number="5441"></td>
+ <td id="LC5441" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used by `unescape` to convert HTML entities to characters.</span></td>
+ </tr>
+ <tr>
+ <td id="L5442" class="blob-num js-line-number" data-line-number="5442"></td>
+ <td id="LC5442" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5443" class="blob-num js-line-number" data-line-number="5443"></td>
+ <td id="LC5443" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5444" class="blob-num js-line-number" data-line-number="5444"></td>
+ <td id="LC5444" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">match</span> The matched character to unescape.</span></td>
+ </tr>
+ <tr>
+ <td id="L5445" class="blob-num js-line-number" data-line-number="5445"></td>
+ <td id="LC5445" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the unescaped character.</span></td>
+ </tr>
+ <tr>
+ <td id="L5446" class="blob-num js-line-number" data-line-number="5446"></td>
+ <td id="LC5446" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5447" class="blob-num js-line-number" data-line-number="5447"></td>
+ <td id="LC5447" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">unescapeHtmlChar</span>(<span class="pl-smi">match</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5448" class="blob-num js-line-number" data-line-number="5448"></td>
+ <td id="LC5448" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> htmlUnescapes[match];</td>
+ </tr>
+ <tr>
+ <td id="L5449" class="blob-num js-line-number" data-line-number="5449"></td>
+ <td id="LC5449" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5450" class="blob-num js-line-number" data-line-number="5450"></td>
+ <td id="LC5450" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5451" class="blob-num js-line-number" data-line-number="5451"></td>
+ <td id="LC5451" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L5452" class="blob-num js-line-number" data-line-number="5452"></td>
+ <td id="LC5452" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5453" class="blob-num js-line-number" data-line-number="5453"></td>
+ <td id="LC5453" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5454" class="blob-num js-line-number" data-line-number="5454"></td>
+ <td id="LC5454" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is an `arguments` object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5455" class="blob-num js-line-number" data-line-number="5455"></td>
+ <td id="LC5455" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5456" class="blob-num js-line-number" data-line-number="5456"></td>
+ <td id="LC5456" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5457" class="blob-num js-line-number" data-line-number="5457"></td>
+ <td id="LC5457" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5458" class="blob-num js-line-number" data-line-number="5458"></td>
+ <td id="LC5458" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5459" class="blob-num js-line-number" data-line-number="5459"></td>
+ <td id="LC5459" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L5460" class="blob-num js-line-number" data-line-number="5460"></td>
+ <td id="LC5460" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is an `arguments` object, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5461" class="blob-num js-line-number" data-line-number="5461"></td>
+ <td id="LC5461" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5462" class="blob-num js-line-number" data-line-number="5462"></td>
+ <td id="LC5462" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5463" class="blob-num js-line-number" data-line-number="5463"></td>
+ <td id="LC5463" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (function() { return _.isArguments(arguments); })(1, 2, 3);</span></td>
+ </tr>
+ <tr>
+ <td id="L5464" class="blob-num js-line-number" data-line-number="5464"></td>
+ <td id="LC5464" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L5465" class="blob-num js-line-number" data-line-number="5465"></td>
+ <td id="LC5465" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5466" class="blob-num js-line-number" data-line-number="5466"></td>
+ <td id="LC5466" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isArguments([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L5467" class="blob-num js-line-number" data-line-number="5467"></td>
+ <td id="LC5467" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L5468" class="blob-num js-line-number" data-line-number="5468"></td>
+ <td id="LC5468" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5469" class="blob-num js-line-number" data-line-number="5469"></td>
+ <td id="LC5469" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isArguments</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5470" class="blob-num js-line-number" data-line-number="5470"></td>
+ <td id="LC5470" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> <span class="pl-smi">value</span>.<span class="pl-c1">length</span> <span class="pl-k">==</span> <span [...]
+ </tr>
+ <tr>
+ <td id="L5471" class="blob-num js-line-number" data-line-number="5471"></td>
+ <td id="LC5471" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> argsClass <span class="pl-k">||</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5472" class="blob-num js-line-number" data-line-number="5472"></td>
+ <td id="LC5472" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5473" class="blob-num js-line-number" data-line-number="5473"></td>
+ <td id="LC5473" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5474" class="blob-num js-line-number" data-line-number="5474"></td>
+ <td id="LC5474" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5475" class="blob-num js-line-number" data-line-number="5475"></td>
+ <td id="LC5475" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is an array.</span></td>
+ </tr>
+ <tr>
+ <td id="L5476" class="blob-num js-line-number" data-line-number="5476"></td>
+ <td id="LC5476" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5477" class="blob-num js-line-number" data-line-number="5477"></td>
+ <td id="LC5477" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5478" class="blob-num js-line-number" data-line-number="5478"></td>
+ <td id="LC5478" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5479" class="blob-num js-line-number" data-line-number="5479"></td>
+ <td id="LC5479" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L5480" class="blob-num js-line-number" data-line-number="5480"></td>
+ <td id="LC5480" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5481" class="blob-num js-line-number" data-line-number="5481"></td>
+ <td id="LC5481" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L5482" class="blob-num js-line-number" data-line-number="5482"></td>
+ <td id="LC5482" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is an array, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5483" class="blob-num js-line-number" data-line-number="5483"></td>
+ <td id="LC5483" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5484" class="blob-num js-line-number" data-line-number="5484"></td>
+ <td id="LC5484" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5485" class="blob-num js-line-number" data-line-number="5485"></td>
+ <td id="LC5485" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (function() { return _.isArray(arguments); })();</span></td>
+ </tr>
+ <tr>
+ <td id="L5486" class="blob-num js-line-number" data-line-number="5486"></td>
+ <td id="LC5486" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L5487" class="blob-num js-line-number" data-line-number="5487"></td>
+ <td id="LC5487" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5488" class="blob-num js-line-number" data-line-number="5488"></td>
+ <td id="LC5488" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isArray([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L5489" class="blob-num js-line-number" data-line-number="5489"></td>
+ <td id="LC5489" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L5490" class="blob-num js-line-number" data-line-number="5490"></td>
+ <td id="LC5490" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5491" class="blob-num js-line-number" data-line-number="5491"></td>
+ <td id="LC5491" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isArray <span class="pl-k">=</span> nativeIsArray <span class="pl-k">||</span> <span class="pl-k">function</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5492" class="blob-num js-line-number" data-line-number="5492"></td>
+ <td id="LC5492" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> <span class="pl-smi">value</span>.<span class="pl-c1">length</span> <span class="pl-k">==</span> <span [...]
+ </tr>
+ <tr>
+ <td id="L5493" class="blob-num js-line-number" data-line-number="5493"></td>
+ <td id="LC5493" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> arrayClass <span class="pl-k">||</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5494" class="blob-num js-line-number" data-line-number="5494"></td>
+ <td id="LC5494" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5495" class="blob-num js-line-number" data-line-number="5495"></td>
+ <td id="LC5495" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5496" class="blob-num js-line-number" data-line-number="5496"></td>
+ <td id="LC5496" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5497" class="blob-num js-line-number" data-line-number="5497"></td>
+ <td id="LC5497" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A fallback implementation of `Object.keys` which produces an array of the</span></td>
+ </tr>
+ <tr>
+ <td id="L5498" class="blob-num js-line-number" data-line-number="5498"></td>
+ <td id="LC5498" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * given object's own enumerable property names.</span></td>
+ </tr>
+ <tr>
+ <td id="L5499" class="blob-num js-line-number" data-line-number="5499"></td>
+ <td id="LC5499" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5500" class="blob-num js-line-number" data-line-number="5500"></td>
+ <td id="LC5500" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@private</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5501" class="blob-num js-line-number" data-line-number="5501"></td>
+ <td id="LC5501" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L5502" class="blob-num js-line-number" data-line-number="5502"></td>
+ <td id="LC5502" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L5503" class="blob-num js-line-number" data-line-number="5503"></td>
+ <td id="LC5503" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of property names.</span></td>
+ </tr>
+ <tr>
+ <td id="L5504" class="blob-num js-line-number" data-line-number="5504"></td>
+ <td id="LC5504" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5505" class="blob-num js-line-number" data-line-number="5505"></td>
+ <td id="LC5505" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">shimKeys</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5506" class="blob-num js-line-number" data-line-number="5506"></td>
+ <td id="LC5506" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index, iterable <span class="pl-k">=</span> object, result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L5507" class="blob-num js-line-number" data-line-number="5507"></td>
+ <td id="LC5507" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>iterable) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5508" class="blob-num js-line-number" data-line-number="5508"></td>
+ <td id="LC5508" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>(objectTypes[<span class="pl-k">typeof</span> object])) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5509" class="blob-num js-line-number" data-line-number="5509"></td>
+ <td id="LC5509" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (index <span class="pl-k">in</span> iterable) {</td>
+ </tr>
+ <tr>
+ <td id="L5510" class="blob-num js-line-number" data-line-number="5510"></td>
+ <td id="LC5510" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(iterable, index)) {</td>
+ </tr>
+ <tr>
+ <td id="L5511" class="blob-num js-line-number" data-line-number="5511"></td>
+ <td id="LC5511" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(index);</td>
+ </tr>
+ <tr>
+ <td id="L5512" class="blob-num js-line-number" data-line-number="5512"></td>
+ <td id="LC5512" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5513" class="blob-num js-line-number" data-line-number="5513"></td>
+ <td id="LC5513" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5514" class="blob-num js-line-number" data-line-number="5514"></td>
+ <td id="LC5514" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result</td>
+ </tr>
+ <tr>
+ <td id="L5515" class="blob-num js-line-number" data-line-number="5515"></td>
+ <td id="LC5515" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5516" class="blob-num js-line-number" data-line-number="5516"></td>
+ <td id="LC5516" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5517" class="blob-num js-line-number" data-line-number="5517"></td>
+ <td id="LC5517" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5518" class="blob-num js-line-number" data-line-number="5518"></td>
+ <td id="LC5518" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array composed of the own enumerable property names of an object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5519" class="blob-num js-line-number" data-line-number="5519"></td>
+ <td id="LC5519" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5520" class="blob-num js-line-number" data-line-number="5520"></td>
+ <td id="LC5520" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5521" class="blob-num js-line-number" data-line-number="5521"></td>
+ <td id="LC5521" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5522" class="blob-num js-line-number" data-line-number="5522"></td>
+ <td id="LC5522" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5523" class="blob-num js-line-number" data-line-number="5523"></td>
+ <td id="LC5523" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L5524" class="blob-num js-line-number" data-line-number="5524"></td>
+ <td id="LC5524" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of property names.</span></td>
+ </tr>
+ <tr>
+ <td id="L5525" class="blob-num js-line-number" data-line-number="5525"></td>
+ <td id="LC5525" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5526" class="blob-num js-line-number" data-line-number="5526"></td>
+ <td id="LC5526" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5527" class="blob-num js-line-number" data-line-number="5527"></td>
+ <td id="LC5527" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.keys({ 'one': 1, 'two': 2, 'three': 3 });</span></td>
+ </tr>
+ <tr>
+ <td id="L5528" class="blob-num js-line-number" data-line-number="5528"></td>
+ <td id="LC5528" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L5529" class="blob-num js-line-number" data-line-number="5529"></td>
+ <td id="LC5529" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5530" class="blob-num js-line-number" data-line-number="5530"></td>
+ <td id="LC5530" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> keys <span class="pl-k">=</span> <span class="pl-k">!</span>nativeKeys <span class="pl-k">?</span> <span class="pl-en">shimKeys</span> <span class="pl-k">:</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5531" class="blob-num js-line-number" data-line-number="5531"></td>
+ <td id="LC5531" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isObject</span>(object)) {</td>
+ </tr>
+ <tr>
+ <td id="L5532" class="blob-num js-line-number" data-line-number="5532"></td>
+ <td id="LC5532" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L5533" class="blob-num js-line-number" data-line-number="5533"></td>
+ <td id="LC5533" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5534" class="blob-num js-line-number" data-line-number="5534"></td>
+ <td id="LC5534" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">nativeKeys</span>(object);</td>
+ </tr>
+ <tr>
+ <td id="L5535" class="blob-num js-line-number" data-line-number="5535"></td>
+ <td id="LC5535" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5536" class="blob-num js-line-number" data-line-number="5536"></td>
+ <td id="LC5536" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5537" class="blob-num js-line-number" data-line-number="5537"></td>
+ <td id="LC5537" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5538" class="blob-num js-line-number" data-line-number="5538"></td>
+ <td id="LC5538" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Used to convert characters to HTML entities:</span></td>
+ </tr>
+ <tr>
+ <td id="L5539" class="blob-num js-line-number" data-line-number="5539"></td>
+ <td id="LC5539" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5540" class="blob-num js-line-number" data-line-number="5540"></td>
+ <td id="LC5540" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Though the `>` character is escaped for symmetry, characters like `>` and `/`</span></td>
+ </tr>
+ <tr>
+ <td id="L5541" class="blob-num js-line-number" data-line-number="5541"></td>
+ <td id="LC5541" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * don't require escaping in HTML and have no special meaning unless they're part</span></td>
+ </tr>
+ <tr>
+ <td id="L5542" class="blob-num js-line-number" data-line-number="5542"></td>
+ <td id="LC5542" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a tag or an unquoted attribute value.</span></td>
+ </tr>
+ <tr>
+ <td id="L5543" class="blob-num js-line-number" data-line-number="5543"></td>
+ <td id="LC5543" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")</span></td>
+ </tr>
+ <tr>
+ <td id="L5544" class="blob-num js-line-number" data-line-number="5544"></td>
+ <td id="LC5544" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5545" class="blob-num js-line-number" data-line-number="5545"></td>
+ <td id="LC5545" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> htmlEscapes <span class="pl-k">=</span> {</td>
+ </tr>
+ <tr>
+ <td id="L5546" class="blob-num js-line-number" data-line-number="5546"></td>
+ <td id="LC5546" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>&<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>&<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L5547" class="blob-num js-line-number" data-line-number="5547"></td>
+ <td id="LC5547" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span><<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span><<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L5548" class="blob-num js-line-number" data-line-number="5548"></td>
+ <td id="LC5548" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>><span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>><span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L5549" class="blob-num js-line-number" data-line-number="5549"></td>
+ <td id="LC5549" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>"<span class="pl-pds">'</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>"<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L5550" class="blob-num js-line-number" data-line-number="5550"></td>
+ <td id="LC5550" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span>'<span class="pl-pds">"</span></span><span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>'<span class="pl-pds">'</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5551" class="blob-num js-line-number" data-line-number="5551"></td>
+ <td id="LC5551" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5552" class="blob-num js-line-number" data-line-number="5552"></td>
+ <td id="LC5552" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5553" class="blob-num js-line-number" data-line-number="5553"></td>
+ <td id="LC5553" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to convert HTML entities to characters */</span></td>
+ </tr>
+ <tr>
+ <td id="L5554" class="blob-num js-line-number" data-line-number="5554"></td>
+ <td id="LC5554" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> htmlUnescapes <span class="pl-k">=</span> <span class="pl-en">invert</span>(htmlEscapes);</td>
+ </tr>
+ <tr>
+ <td id="L5555" class="blob-num js-line-number" data-line-number="5555"></td>
+ <td id="LC5555" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5556" class="blob-num js-line-number" data-line-number="5556"></td>
+ <td id="LC5556" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/** Used to match HTML entities and HTML characters */</span></td>
+ </tr>
+ <tr>
+ <td id="L5557" class="blob-num js-line-number" data-line-number="5557"></td>
+ <td id="LC5557" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reEscapedHtml <span class="pl-k">=</span> <span class="pl-c1">RegExp</span>(<span class="pl-s"><span class="pl-pds">'</span>(<span class="pl-pds">'</span></span> <span class="pl-k">+</span> <span class="pl-en">keys</span>(htmlUnescapes).<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">'</span>|<span class="pl-pds">'</span></span>) <span class="pl [...]
+ </tr>
+ <tr>
+ <td id="L5558" class="blob-num js-line-number" data-line-number="5558"></td>
+ <td id="LC5558" class="blob-code blob-code-inner js-file-line"> reUnescapedHtml <span class="pl-k">=</span> <span class="pl-c1">RegExp</span>(<span class="pl-s"><span class="pl-pds">'</span>[<span class="pl-pds">'</span></span> <span class="pl-k">+</span> <span class="pl-en">keys</span>(htmlEscapes).<span class="pl-c1">join</span>(<span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>) <span class="pl-k">+</span> <span class="p [...]
+ </tr>
+ <tr>
+ <td id="L5559" class="blob-num js-line-number" data-line-number="5559"></td>
+ <td id="LC5559" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5560" class="blob-num js-line-number" data-line-number="5560"></td>
+ <td id="LC5560" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L5561" class="blob-num js-line-number" data-line-number="5561"></td>
+ <td id="LC5561" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5562" class="blob-num js-line-number" data-line-number="5562"></td>
+ <td id="LC5562" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5563" class="blob-num js-line-number" data-line-number="5563"></td>
+ <td id="LC5563" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Assigns own enumerable properties of source object(s) to the destination</span></td>
+ </tr>
+ <tr>
+ <td id="L5564" class="blob-num js-line-number" data-line-number="5564"></td>
+ <td id="LC5564" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object. Subsequent sources will overwrite property assignments of previous</span></td>
+ </tr>
+ <tr>
+ <td id="L5565" class="blob-num js-line-number" data-line-number="5565"></td>
+ <td id="LC5565" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * sources. If a callback is provided it will be executed to produce the</span></td>
+ </tr>
+ <tr>
+ <td id="L5566" class="blob-num js-line-number" data-line-number="5566"></td>
+ <td id="LC5566" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * assigned values. The callback is bound to `thisArg` and invoked with two</span></td>
+ </tr>
+ <tr>
+ <td id="L5567" class="blob-num js-line-number" data-line-number="5567"></td>
+ <td id="LC5567" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (objectValue, sourceValue).</span></td>
+ </tr>
+ <tr>
+ <td id="L5568" class="blob-num js-line-number" data-line-number="5568"></td>
+ <td id="LC5568" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5569" class="blob-num js-line-number" data-line-number="5569"></td>
+ <td id="LC5569" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5570" class="blob-num js-line-number" data-line-number="5570"></td>
+ <td id="LC5570" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5571" class="blob-num js-line-number" data-line-number="5571"></td>
+ <td id="LC5571" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L5572" class="blob-num js-line-number" data-line-number="5572"></td>
+ <td id="LC5572" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> extend</span></td>
+ </tr>
+ <tr>
+ <td id="L5573" class="blob-num js-line-number" data-line-number="5573"></td>
+ <td id="LC5573" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5574" class="blob-num js-line-number" data-line-number="5574"></td>
+ <td id="LC5574" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5575" class="blob-num js-line-number" data-line-number="5575"></td>
+ <td id="LC5575" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Object} [source] The source objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L5576" class="blob-num js-line-number" data-line-number="5576"></td>
+ <td id="LC5576" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize assigning values.</span></td>
+ </tr>
+ <tr>
+ <td id="L5577" class="blob-num js-line-number" data-line-number="5577"></td>
+ <td id="LC5577" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5578" class="blob-num js-line-number" data-line-number="5578"></td>
+ <td id="LC5578" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5579" class="blob-num js-line-number" data-line-number="5579"></td>
+ <td id="LC5579" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5580" class="blob-num js-line-number" data-line-number="5580"></td>
+ <td id="LC5580" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5581" class="blob-num js-line-number" data-line-number="5581"></td>
+ <td id="LC5581" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.assign({ 'name': 'fred' }, { 'employer': 'slate' });</span></td>
+ </tr>
+ <tr>
+ <td id="L5582" class="blob-num js-line-number" data-line-number="5582"></td>
+ <td id="LC5582" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred', 'employer': 'slate' }</span></td>
+ </tr>
+ <tr>
+ <td id="L5583" class="blob-num js-line-number" data-line-number="5583"></td>
+ <td id="LC5583" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5584" class="blob-num js-line-number" data-line-number="5584"></td>
+ <td id="LC5584" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var defaults = _.partialRight(_.assign, function(a, b) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5585" class="blob-num js-line-number" data-line-number="5585"></td>
+ <td id="LC5585" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return typeof a == 'undefined' ? b : a;</span></td>
+ </tr>
+ <tr>
+ <td id="L5586" class="blob-num js-line-number" data-line-number="5586"></td>
+ <td id="LC5586" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5587" class="blob-num js-line-number" data-line-number="5587"></td>
+ <td id="LC5587" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5588" class="blob-num js-line-number" data-line-number="5588"></td>
+ <td id="LC5588" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = { 'name': 'barney' };</span></td>
+ </tr>
+ <tr>
+ <td id="L5589" class="blob-num js-line-number" data-line-number="5589"></td>
+ <td id="LC5589" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * defaults(object, { 'name': 'fred', 'employer': 'slate' });</span></td>
+ </tr>
+ <tr>
+ <td id="L5590" class="blob-num js-line-number" data-line-number="5590"></td>
+ <td id="LC5590" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'barney', 'employer': 'slate' }</span></td>
+ </tr>
+ <tr>
+ <td id="L5591" class="blob-num js-line-number" data-line-number="5591"></td>
+ <td id="LC5591" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5592" class="blob-num js-line-number" data-line-number="5592"></td>
+ <td id="LC5592" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">assign</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>, <span class="pl-smi">source</span>, <span class="pl-smi">guard</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5593" class="blob-num js-line-number" data-line-number="5593"></td>
+ <td id="LC5593" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index, iterable <span class="pl-k">=</span> object, result <span class="pl-k">=</span> iterable;</td>
+ </tr>
+ <tr>
+ <td id="L5594" class="blob-num js-line-number" data-line-number="5594"></td>
+ <td id="LC5594" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>iterable) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5595" class="blob-num js-line-number" data-line-number="5595"></td>
+ <td id="LC5595" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5596" class="blob-num js-line-number" data-line-number="5596"></td>
+ <td id="LC5596" class="blob-code blob-code-inner js-file-line"> argsIndex <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5597" class="blob-num js-line-number" data-line-number="5597"></td>
+ <td id="LC5597" class="blob-code blob-code-inner js-file-line"> argsLength <span class="pl-k">=</span> <span class="pl-k">typeof</span> guard <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> <span class="pl-c1">2</span> <span class="pl-k">:</span> <span class="pl-smi">args</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5598" class="blob-num js-line-number" data-line-number="5598"></td>
+ <td id="LC5598" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (argsLength <span class="pl-k">></span> <span class="pl-c1">3</span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> args[argsLength <span class="pl-k">-</span> <span class="pl-c1">2</span>] <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5599" class="blob-num js-line-number" data-line-number="5599"></td>
+ <td id="LC5599" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> callback <span class="pl-k">=</span> <span class="pl-en">baseCreateCallback</span>(args[<span class="pl-k">--</span>argsLength <span class="pl-k">-</span> <span class="pl-c1">1</span>], args[argsLength<span class="pl-k">--</span>], <span class="pl-c1">2</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5600" class="blob-num js-line-number" data-line-number="5600"></td>
+ <td id="LC5600" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (argsLength <span class="pl-k">></span> <span class="pl-c1">2</span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> args[argsLength <span class="pl-k">-</span> <span class="pl-c1">1</span>] <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5601" class="blob-num js-line-number" data-line-number="5601"></td>
+ <td id="LC5601" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> args[<span class="pl-k">--</span>argsLength];</td>
+ </tr>
+ <tr>
+ <td id="L5602" class="blob-num js-line-number" data-line-number="5602"></td>
+ <td id="LC5602" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5603" class="blob-num js-line-number" data-line-number="5603"></td>
+ <td id="LC5603" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>argsIndex <span class="pl-k"><</span> argsLength) {</td>
+ </tr>
+ <tr>
+ <td id="L5604" class="blob-num js-line-number" data-line-number="5604"></td>
+ <td id="LC5604" class="blob-code blob-code-inner js-file-line"> iterable <span class="pl-k">=</span> args[argsIndex];</td>
+ </tr>
+ <tr>
+ <td id="L5605" class="blob-num js-line-number" data-line-number="5605"></td>
+ <td id="LC5605" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (iterable <span class="pl-k">&&</span> objectTypes[<span class="pl-k">typeof</span> iterable]) {</td>
+ </tr>
+ <tr>
+ <td id="L5606" class="blob-num js-line-number" data-line-number="5606"></td>
+ <td id="LC5606" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ownIndex <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5607" class="blob-num js-line-number" data-line-number="5607"></td>
+ <td id="LC5607" class="blob-code blob-code-inner js-file-line"> ownProps <span class="pl-k">=</span> objectTypes[<span class="pl-k">typeof</span> iterable] <span class="pl-k">&&</span> <span class="pl-en">keys</span>(iterable),</td>
+ </tr>
+ <tr>
+ <td id="L5608" class="blob-num js-line-number" data-line-number="5608"></td>
+ <td id="LC5608" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> ownProps <span class="pl-k">?</span> <span class="pl-smi">ownProps</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5609" class="blob-num js-line-number" data-line-number="5609"></td>
+ <td id="LC5609" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5610" class="blob-num js-line-number" data-line-number="5610"></td>
+ <td id="LC5610" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>ownIndex <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L5611" class="blob-num js-line-number" data-line-number="5611"></td>
+ <td id="LC5611" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> ownProps[ownIndex];</td>
+ </tr>
+ <tr>
+ <td id="L5612" class="blob-num js-line-number" data-line-number="5612"></td>
+ <td id="LC5612" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> callback <span class="pl-k">?</span> <span class="pl-en">callback</span>(result[index], iterable[index]) <span class="pl-k">:</span> iterable[index];</td>
+ </tr>
+ <tr>
+ <td id="L5613" class="blob-num js-line-number" data-line-number="5613"></td>
+ <td id="LC5613" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5614" class="blob-num js-line-number" data-line-number="5614"></td>
+ <td id="LC5614" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5615" class="blob-num js-line-number" data-line-number="5615"></td>
+ <td id="LC5615" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5616" class="blob-num js-line-number" data-line-number="5616"></td>
+ <td id="LC5616" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result</td>
+ </tr>
+ <tr>
+ <td id="L5617" class="blob-num js-line-number" data-line-number="5617"></td>
+ <td id="LC5617" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5618" class="blob-num js-line-number" data-line-number="5618"></td>
+ <td id="LC5618" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5619" class="blob-num js-line-number" data-line-number="5619"></td>
+ <td id="LC5619" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5620" class="blob-num js-line-number" data-line-number="5620"></td>
+ <td id="LC5620" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a clone of `value`. If `isDeep` is `true` nested objects will also</span></td>
+ </tr>
+ <tr>
+ <td id="L5621" class="blob-num js-line-number" data-line-number="5621"></td>
+ <td id="LC5621" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * be cloned, otherwise they will be assigned by reference. If a callback</span></td>
+ </tr>
+ <tr>
+ <td id="L5622" class="blob-num js-line-number" data-line-number="5622"></td>
+ <td id="LC5622" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is provided it will be executed to produce the cloned values. If the</span></td>
+ </tr>
+ <tr>
+ <td id="L5623" class="blob-num js-line-number" data-line-number="5623"></td>
+ <td id="LC5623" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback returns `undefined` cloning will be handled by the method instead.</span></td>
+ </tr>
+ <tr>
+ <td id="L5624" class="blob-num js-line-number" data-line-number="5624"></td>
+ <td id="LC5624" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The callback is bound to `thisArg` and invoked with one argument; (value).</span></td>
+ </tr>
+ <tr>
+ <td id="L5625" class="blob-num js-line-number" data-line-number="5625"></td>
+ <td id="LC5625" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5626" class="blob-num js-line-number" data-line-number="5626"></td>
+ <td id="LC5626" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5627" class="blob-num js-line-number" data-line-number="5627"></td>
+ <td id="LC5627" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5628" class="blob-num js-line-number" data-line-number="5628"></td>
+ <td id="LC5628" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5629" class="blob-num js-line-number" data-line-number="5629"></td>
+ <td id="LC5629" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to clone.</span></td>
+ </tr>
+ <tr>
+ <td id="L5630" class="blob-num js-line-number" data-line-number="5630"></td>
+ <td id="LC5630" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isDeep=false] Specify a deep clone.</span></td>
+ </tr>
+ <tr>
+ <td id="L5631" class="blob-num js-line-number" data-line-number="5631"></td>
+ <td id="LC5631" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize cloning values.</span></td>
+ </tr>
+ <tr>
+ <td id="L5632" class="blob-num js-line-number" data-line-number="5632"></td>
+ <td id="LC5632" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5633" class="blob-num js-line-number" data-line-number="5633"></td>
+ <td id="LC5633" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the cloned value.</span></td>
+ </tr>
+ <tr>
+ <td id="L5634" class="blob-num js-line-number" data-line-number="5634"></td>
+ <td id="LC5634" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5635" class="blob-num js-line-number" data-line-number="5635"></td>
+ <td id="LC5635" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5636" class="blob-num js-line-number" data-line-number="5636"></td>
+ <td id="LC5636" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L5637" class="blob-num js-line-number" data-line-number="5637"></td>
+ <td id="LC5637" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L5638" class="blob-num js-line-number" data-line-number="5638"></td>
+ <td id="LC5638" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L5639" class="blob-num js-line-number" data-line-number="5639"></td>
+ <td id="LC5639" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L5640" class="blob-num js-line-number" data-line-number="5640"></td>
+ <td id="LC5640" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5641" class="blob-num js-line-number" data-line-number="5641"></td>
+ <td id="LC5641" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var shallow = _.clone(characters);</span></td>
+ </tr>
+ <tr>
+ <td id="L5642" class="blob-num js-line-number" data-line-number="5642"></td>
+ <td id="LC5642" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * shallow[0] === characters[0];</span></td>
+ </tr>
+ <tr>
+ <td id="L5643" class="blob-num js-line-number" data-line-number="5643"></td>
+ <td id="LC5643" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L5644" class="blob-num js-line-number" data-line-number="5644"></td>
+ <td id="LC5644" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5645" class="blob-num js-line-number" data-line-number="5645"></td>
+ <td id="LC5645" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var deep = _.clone(characters, true);</span></td>
+ </tr>
+ <tr>
+ <td id="L5646" class="blob-num js-line-number" data-line-number="5646"></td>
+ <td id="LC5646" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * deep[0] === characters[0];</span></td>
+ </tr>
+ <tr>
+ <td id="L5647" class="blob-num js-line-number" data-line-number="5647"></td>
+ <td id="LC5647" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L5648" class="blob-num js-line-number" data-line-number="5648"></td>
+ <td id="LC5648" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5649" class="blob-num js-line-number" data-line-number="5649"></td>
+ <td id="LC5649" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.mixin({</span></td>
+ </tr>
+ <tr>
+ <td id="L5650" class="blob-num js-line-number" data-line-number="5650"></td>
+ <td id="LC5650" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'clone': _.partialRight(_.clone, function(value) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5651" class="blob-num js-line-number" data-line-number="5651"></td>
+ <td id="LC5651" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return _.isElement(value) ? value.cloneNode(false) : undefined;</span></td>
+ </tr>
+ <tr>
+ <td id="L5652" class="blob-num js-line-number" data-line-number="5652"></td>
+ <td id="LC5652" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * })</span></td>
+ </tr>
+ <tr>
+ <td id="L5653" class="blob-num js-line-number" data-line-number="5653"></td>
+ <td id="LC5653" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5654" class="blob-num js-line-number" data-line-number="5654"></td>
+ <td id="LC5654" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5655" class="blob-num js-line-number" data-line-number="5655"></td>
+ <td id="LC5655" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var clone = _.clone(document.body);</span></td>
+ </tr>
+ <tr>
+ <td id="L5656" class="blob-num js-line-number" data-line-number="5656"></td>
+ <td id="LC5656" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * clone.childNodes.length;</span></td>
+ </tr>
+ <tr>
+ <td id="L5657" class="blob-num js-line-number" data-line-number="5657"></td>
+ <td id="LC5657" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 0</span></td>
+ </tr>
+ <tr>
+ <td id="L5658" class="blob-num js-line-number" data-line-number="5658"></td>
+ <td id="LC5658" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5659" class="blob-num js-line-number" data-line-number="5659"></td>
+ <td id="LC5659" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">clone</span>(<span class="pl-smi">value</span>, <span class="pl-smi">isDeep</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5660" class="blob-num js-line-number" data-line-number="5660"></td>
+ <td id="LC5660" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// allows working with "Collections" methods without using their `index`</span></td>
+ </tr>
+ <tr>
+ <td id="L5661" class="blob-num js-line-number" data-line-number="5661"></td>
+ <td id="LC5661" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// and `collection` arguments for `isDeep` and `callback`</span></td>
+ </tr>
+ <tr>
+ <td id="L5662" class="blob-num js-line-number" data-line-number="5662"></td>
+ <td id="LC5662" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> isDeep <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> isDeep <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5663" class="blob-num js-line-number" data-line-number="5663"></td>
+ <td id="LC5663" class="blob-code blob-code-inner js-file-line"> thisArg <span class="pl-k">=</span> callback;</td>
+ </tr>
+ <tr>
+ <td id="L5664" class="blob-num js-line-number" data-line-number="5664"></td>
+ <td id="LC5664" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> isDeep;</td>
+ </tr>
+ <tr>
+ <td id="L5665" class="blob-num js-line-number" data-line-number="5665"></td>
+ <td id="LC5665" class="blob-code blob-code-inner js-file-line"> isDeep <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5666" class="blob-num js-line-number" data-line-number="5666"></td>
+ <td id="LC5666" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5667" class="blob-num js-line-number" data-line-number="5667"></td>
+ <td id="LC5667" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseClone</span>(value, isDeep, <span class="pl-k">typeof</span> callback <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L5668" class="blob-num js-line-number" data-line-number="5668"></td>
+ <td id="LC5668" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5669" class="blob-num js-line-number" data-line-number="5669"></td>
+ <td id="LC5669" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5670" class="blob-num js-line-number" data-line-number="5670"></td>
+ <td id="LC5670" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5671" class="blob-num js-line-number" data-line-number="5671"></td>
+ <td id="LC5671" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a deep clone of `value`. If a callback is provided it will be</span></td>
+ </tr>
+ <tr>
+ <td id="L5672" class="blob-num js-line-number" data-line-number="5672"></td>
+ <td id="LC5672" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * executed to produce the cloned values. If the callback returns `undefined`</span></td>
+ </tr>
+ <tr>
+ <td id="L5673" class="blob-num js-line-number" data-line-number="5673"></td>
+ <td id="LC5673" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * cloning will be handled by the method instead. The callback is bound to</span></td>
+ </tr>
+ <tr>
+ <td id="L5674" class="blob-num js-line-number" data-line-number="5674"></td>
+ <td id="LC5674" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `thisArg` and invoked with one argument; (value).</span></td>
+ </tr>
+ <tr>
+ <td id="L5675" class="blob-num js-line-number" data-line-number="5675"></td>
+ <td id="LC5675" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5676" class="blob-num js-line-number" data-line-number="5676"></td>
+ <td id="LC5676" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: This method is loosely based on the structured clone algorithm. Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L5677" class="blob-num js-line-number" data-line-number="5677"></td>
+ <td id="LC5677" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and</span></td>
+ </tr>
+ <tr>
+ <td id="L5678" class="blob-num js-line-number" data-line-number="5678"></td>
+ <td id="LC5678" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * objects created by constructors other than `Object` are cloned to plain `Object` objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L5679" class="blob-num js-line-number" data-line-number="5679"></td>
+ <td id="LC5679" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.</span></td>
+ </tr>
+ <tr>
+ <td id="L5680" class="blob-num js-line-number" data-line-number="5680"></td>
+ <td id="LC5680" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5681" class="blob-num js-line-number" data-line-number="5681"></td>
+ <td id="LC5681" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5682" class="blob-num js-line-number" data-line-number="5682"></td>
+ <td id="LC5682" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5683" class="blob-num js-line-number" data-line-number="5683"></td>
+ <td id="LC5683" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5684" class="blob-num js-line-number" data-line-number="5684"></td>
+ <td id="LC5684" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to deep clone.</span></td>
+ </tr>
+ <tr>
+ <td id="L5685" class="blob-num js-line-number" data-line-number="5685"></td>
+ <td id="LC5685" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize cloning values.</span></td>
+ </tr>
+ <tr>
+ <td id="L5686" class="blob-num js-line-number" data-line-number="5686"></td>
+ <td id="LC5686" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5687" class="blob-num js-line-number" data-line-number="5687"></td>
+ <td id="LC5687" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the deep cloned value.</span></td>
+ </tr>
+ <tr>
+ <td id="L5688" class="blob-num js-line-number" data-line-number="5688"></td>
+ <td id="LC5688" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5689" class="blob-num js-line-number" data-line-number="5689"></td>
+ <td id="LC5689" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5690" class="blob-num js-line-number" data-line-number="5690"></td>
+ <td id="LC5690" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L5691" class="blob-num js-line-number" data-line-number="5691"></td>
+ <td id="LC5691" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L5692" class="blob-num js-line-number" data-line-number="5692"></td>
+ <td id="LC5692" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L5693" class="blob-num js-line-number" data-line-number="5693"></td>
+ <td id="LC5693" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L5694" class="blob-num js-line-number" data-line-number="5694"></td>
+ <td id="LC5694" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5695" class="blob-num js-line-number" data-line-number="5695"></td>
+ <td id="LC5695" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var deep = _.cloneDeep(characters);</span></td>
+ </tr>
+ <tr>
+ <td id="L5696" class="blob-num js-line-number" data-line-number="5696"></td>
+ <td id="LC5696" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * deep[0] === characters[0];</span></td>
+ </tr>
+ <tr>
+ <td id="L5697" class="blob-num js-line-number" data-line-number="5697"></td>
+ <td id="LC5697" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L5698" class="blob-num js-line-number" data-line-number="5698"></td>
+ <td id="LC5698" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5699" class="blob-num js-line-number" data-line-number="5699"></td>
+ <td id="LC5699" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var view = {</span></td>
+ </tr>
+ <tr>
+ <td id="L5700" class="blob-num js-line-number" data-line-number="5700"></td>
+ <td id="LC5700" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'label': 'docs',</span></td>
+ </tr>
+ <tr>
+ <td id="L5701" class="blob-num js-line-number" data-line-number="5701"></td>
+ <td id="LC5701" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'node': element</span></td>
+ </tr>
+ <tr>
+ <td id="L5702" class="blob-num js-line-number" data-line-number="5702"></td>
+ <td id="LC5702" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L5703" class="blob-num js-line-number" data-line-number="5703"></td>
+ <td id="LC5703" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5704" class="blob-num js-line-number" data-line-number="5704"></td>
+ <td id="LC5704" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var clone = _.cloneDeep(view, function(value) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5705" class="blob-num js-line-number" data-line-number="5705"></td>
+ <td id="LC5705" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return _.isElement(value) ? value.cloneNode(true) : undefined;</span></td>
+ </tr>
+ <tr>
+ <td id="L5706" class="blob-num js-line-number" data-line-number="5706"></td>
+ <td id="LC5706" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5707" class="blob-num js-line-number" data-line-number="5707"></td>
+ <td id="LC5707" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5708" class="blob-num js-line-number" data-line-number="5708"></td>
+ <td id="LC5708" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * clone.node == view.node;</span></td>
+ </tr>
+ <tr>
+ <td id="L5709" class="blob-num js-line-number" data-line-number="5709"></td>
+ <td id="LC5709" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L5710" class="blob-num js-line-number" data-line-number="5710"></td>
+ <td id="LC5710" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5711" class="blob-num js-line-number" data-line-number="5711"></td>
+ <td id="LC5711" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">cloneDeep</span>(<span class="pl-smi">value</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5712" class="blob-num js-line-number" data-line-number="5712"></td>
+ <td id="LC5712" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseClone</span>(value, <span class="pl-c1">true</span>, <span class="pl-k">typeof</span> callback <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L5713" class="blob-num js-line-number" data-line-number="5713"></td>
+ <td id="LC5713" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5714" class="blob-num js-line-number" data-line-number="5714"></td>
+ <td id="LC5714" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5715" class="blob-num js-line-number" data-line-number="5715"></td>
+ <td id="LC5715" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5716" class="blob-num js-line-number" data-line-number="5716"></td>
+ <td id="LC5716" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object that inherits from the given `prototype` object. If a</span></td>
+ </tr>
+ <tr>
+ <td id="L5717" class="blob-num js-line-number" data-line-number="5717"></td>
+ <td id="LC5717" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `properties` object is provided its own enumerable properties are assigned</span></td>
+ </tr>
+ <tr>
+ <td id="L5718" class="blob-num js-line-number" data-line-number="5718"></td>
+ <td id="LC5718" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to the created object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5719" class="blob-num js-line-number" data-line-number="5719"></td>
+ <td id="LC5719" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5720" class="blob-num js-line-number" data-line-number="5720"></td>
+ <td id="LC5720" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5721" class="blob-num js-line-number" data-line-number="5721"></td>
+ <td id="LC5721" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5722" class="blob-num js-line-number" data-line-number="5722"></td>
+ <td id="LC5722" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5723" class="blob-num js-line-number" data-line-number="5723"></td>
+ <td id="LC5723" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">prototype</span> The object to inherit from.</span></td>
+ </tr>
+ <tr>
+ <td id="L5724" class="blob-num js-line-number" data-line-number="5724"></td>
+ <td id="LC5724" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [properties] The properties to assign to the object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5725" class="blob-num js-line-number" data-line-number="5725"></td>
+ <td id="LC5725" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the new object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5726" class="blob-num js-line-number" data-line-number="5726"></td>
+ <td id="LC5726" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5727" class="blob-num js-line-number" data-line-number="5727"></td>
+ <td id="LC5727" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5728" class="blob-num js-line-number" data-line-number="5728"></td>
+ <td id="LC5728" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function Shape() {</span></td>
+ </tr>
+ <tr>
+ <td id="L5729" class="blob-num js-line-number" data-line-number="5729"></td>
+ <td id="LC5729" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.x = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L5730" class="blob-num js-line-number" data-line-number="5730"></td>
+ <td id="LC5730" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.y = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L5731" class="blob-num js-line-number" data-line-number="5731"></td>
+ <td id="LC5731" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L5732" class="blob-num js-line-number" data-line-number="5732"></td>
+ <td id="LC5732" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5733" class="blob-num js-line-number" data-line-number="5733"></td>
+ <td id="LC5733" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function Circle() {</span></td>
+ </tr>
+ <tr>
+ <td id="L5734" class="blob-num js-line-number" data-line-number="5734"></td>
+ <td id="LC5734" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Shape.call(this);</span></td>
+ </tr>
+ <tr>
+ <td id="L5735" class="blob-num js-line-number" data-line-number="5735"></td>
+ <td id="LC5735" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L5736" class="blob-num js-line-number" data-line-number="5736"></td>
+ <td id="LC5736" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5737" class="blob-num js-line-number" data-line-number="5737"></td>
+ <td id="LC5737" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle });</span></td>
+ </tr>
+ <tr>
+ <td id="L5738" class="blob-num js-line-number" data-line-number="5738"></td>
+ <td id="LC5738" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5739" class="blob-num js-line-number" data-line-number="5739"></td>
+ <td id="LC5739" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var circle = new Circle;</span></td>
+ </tr>
+ <tr>
+ <td id="L5740" class="blob-num js-line-number" data-line-number="5740"></td>
+ <td id="LC5740" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * circle instanceof Circle;</span></td>
+ </tr>
+ <tr>
+ <td id="L5741" class="blob-num js-line-number" data-line-number="5741"></td>
+ <td id="LC5741" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L5742" class="blob-num js-line-number" data-line-number="5742"></td>
+ <td id="LC5742" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5743" class="blob-num js-line-number" data-line-number="5743"></td>
+ <td id="LC5743" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * circle instanceof Shape;</span></td>
+ </tr>
+ <tr>
+ <td id="L5744" class="blob-num js-line-number" data-line-number="5744"></td>
+ <td id="LC5744" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L5745" class="blob-num js-line-number" data-line-number="5745"></td>
+ <td id="LC5745" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5746" class="blob-num js-line-number" data-line-number="5746"></td>
+ <td id="LC5746" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">create</span>(<span class="pl-smi">prototype</span>, <span class="pl-smi">properties</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5747" class="blob-num js-line-number" data-line-number="5747"></td>
+ <td id="LC5747" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-en">baseCreate</span>(prototype);</td>
+ </tr>
+ <tr>
+ <td id="L5748" class="blob-num js-line-number" data-line-number="5748"></td>
+ <td id="LC5748" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> properties <span class="pl-k">?</span> <span class="pl-en">assign</span>(result, properties) <span class="pl-k">:</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5749" class="blob-num js-line-number" data-line-number="5749"></td>
+ <td id="LC5749" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5750" class="blob-num js-line-number" data-line-number="5750"></td>
+ <td id="LC5750" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5751" class="blob-num js-line-number" data-line-number="5751"></td>
+ <td id="LC5751" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5752" class="blob-num js-line-number" data-line-number="5752"></td>
+ <td id="LC5752" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Assigns own enumerable properties of source object(s) to the destination</span></td>
+ </tr>
+ <tr>
+ <td id="L5753" class="blob-num js-line-number" data-line-number="5753"></td>
+ <td id="LC5753" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object for all destination properties that resolve to `undefined`. Once a</span></td>
+ </tr>
+ <tr>
+ <td id="L5754" class="blob-num js-line-number" data-line-number="5754"></td>
+ <td id="LC5754" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * property is set, additional defaults of the same property will be ignored.</span></td>
+ </tr>
+ <tr>
+ <td id="L5755" class="blob-num js-line-number" data-line-number="5755"></td>
+ <td id="LC5755" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5756" class="blob-num js-line-number" data-line-number="5756"></td>
+ <td id="LC5756" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5757" class="blob-num js-line-number" data-line-number="5757"></td>
+ <td id="LC5757" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5758" class="blob-num js-line-number" data-line-number="5758"></td>
+ <td id="LC5758" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L5759" class="blob-num js-line-number" data-line-number="5759"></td>
+ <td id="LC5759" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5760" class="blob-num js-line-number" data-line-number="5760"></td>
+ <td id="LC5760" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5761" class="blob-num js-line-number" data-line-number="5761"></td>
+ <td id="LC5761" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Object} [source] The source objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L5762" class="blob-num js-line-number" data-line-number="5762"></td>
+ <td id="LC5762" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span>- {Object} [guard] Allows working with `_.reduce` without using its</span></td>
+ </tr>
+ <tr>
+ <td id="L5763" class="blob-num js-line-number" data-line-number="5763"></td>
+ <td id="LC5763" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `key` and `object` arguments as sources.</span></td>
+ </tr>
+ <tr>
+ <td id="L5764" class="blob-num js-line-number" data-line-number="5764"></td>
+ <td id="LC5764" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L5765" class="blob-num js-line-number" data-line-number="5765"></td>
+ <td id="LC5765" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5766" class="blob-num js-line-number" data-line-number="5766"></td>
+ <td id="LC5766" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5767" class="blob-num js-line-number" data-line-number="5767"></td>
+ <td id="LC5767" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = { 'name': 'barney' };</span></td>
+ </tr>
+ <tr>
+ <td id="L5768" class="blob-num js-line-number" data-line-number="5768"></td>
+ <td id="LC5768" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.defaults(object, { 'name': 'fred', 'employer': 'slate' });</span></td>
+ </tr>
+ <tr>
+ <td id="L5769" class="blob-num js-line-number" data-line-number="5769"></td>
+ <td id="LC5769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'barney', 'employer': 'slate' }</span></td>
+ </tr>
+ <tr>
+ <td id="L5770" class="blob-num js-line-number" data-line-number="5770"></td>
+ <td id="LC5770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5771" class="blob-num js-line-number" data-line-number="5771"></td>
+ <td id="LC5771" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">defaults</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>, <span class="pl-smi">source</span>, <span class="pl-smi">guard</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5772" class="blob-num js-line-number" data-line-number="5772"></td>
+ <td id="LC5772" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index, iterable <span class="pl-k">=</span> object, result <span class="pl-k">=</span> iterable;</td>
+ </tr>
+ <tr>
+ <td id="L5773" class="blob-num js-line-number" data-line-number="5773"></td>
+ <td id="LC5773" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>iterable) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5774" class="blob-num js-line-number" data-line-number="5774"></td>
+ <td id="LC5774" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5775" class="blob-num js-line-number" data-line-number="5775"></td>
+ <td id="LC5775" class="blob-code blob-code-inner js-file-line"> argsIndex <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5776" class="blob-num js-line-number" data-line-number="5776"></td>
+ <td id="LC5776" class="blob-code blob-code-inner js-file-line"> argsLength <span class="pl-k">=</span> <span class="pl-k">typeof</span> guard <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> <span class="pl-c1">2</span> <span class="pl-k">:</span> <span class="pl-smi">args</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5777" class="blob-num js-line-number" data-line-number="5777"></td>
+ <td id="LC5777" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>argsIndex <span class="pl-k"><</span> argsLength) {</td>
+ </tr>
+ <tr>
+ <td id="L5778" class="blob-num js-line-number" data-line-number="5778"></td>
+ <td id="LC5778" class="blob-code blob-code-inner js-file-line"> iterable <span class="pl-k">=</span> args[argsIndex];</td>
+ </tr>
+ <tr>
+ <td id="L5779" class="blob-num js-line-number" data-line-number="5779"></td>
+ <td id="LC5779" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (iterable <span class="pl-k">&&</span> objectTypes[<span class="pl-k">typeof</span> iterable]) {</td>
+ </tr>
+ <tr>
+ <td id="L5780" class="blob-num js-line-number" data-line-number="5780"></td>
+ <td id="LC5780" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ownIndex <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L5781" class="blob-num js-line-number" data-line-number="5781"></td>
+ <td id="LC5781" class="blob-code blob-code-inner js-file-line"> ownProps <span class="pl-k">=</span> objectTypes[<span class="pl-k">typeof</span> iterable] <span class="pl-k">&&</span> <span class="pl-en">keys</span>(iterable),</td>
+ </tr>
+ <tr>
+ <td id="L5782" class="blob-num js-line-number" data-line-number="5782"></td>
+ <td id="LC5782" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> ownProps <span class="pl-k">?</span> <span class="pl-smi">ownProps</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5783" class="blob-num js-line-number" data-line-number="5783"></td>
+ <td id="LC5783" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5784" class="blob-num js-line-number" data-line-number="5784"></td>
+ <td id="LC5784" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>ownIndex <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L5785" class="blob-num js-line-number" data-line-number="5785"></td>
+ <td id="LC5785" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> ownProps[ownIndex];</td>
+ </tr>
+ <tr>
+ <td id="L5786" class="blob-num js-line-number" data-line-number="5786"></td>
+ <td id="LC5786" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> result[index] <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>) result[index] <span class="pl-k">=</span> iterable[index];</td>
+ </tr>
+ <tr>
+ <td id="L5787" class="blob-num js-line-number" data-line-number="5787"></td>
+ <td id="LC5787" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5788" class="blob-num js-line-number" data-line-number="5788"></td>
+ <td id="LC5788" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5789" class="blob-num js-line-number" data-line-number="5789"></td>
+ <td id="LC5789" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5790" class="blob-num js-line-number" data-line-number="5790"></td>
+ <td id="LC5790" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result</td>
+ </tr>
+ <tr>
+ <td id="L5791" class="blob-num js-line-number" data-line-number="5791"></td>
+ <td id="LC5791" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5792" class="blob-num js-line-number" data-line-number="5792"></td>
+ <td id="LC5792" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5793" class="blob-num js-line-number" data-line-number="5793"></td>
+ <td id="LC5793" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5794" class="blob-num js-line-number" data-line-number="5794"></td>
+ <td id="LC5794" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.findIndex` except that it returns the key of the</span></td>
+ </tr>
+ <tr>
+ <td id="L5795" class="blob-num js-line-number" data-line-number="5795"></td>
+ <td id="LC5795" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * first element that passes the callback check, instead of the element itself.</span></td>
+ </tr>
+ <tr>
+ <td id="L5796" class="blob-num js-line-number" data-line-number="5796"></td>
+ <td id="LC5796" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5797" class="blob-num js-line-number" data-line-number="5797"></td>
+ <td id="LC5797" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L5798" class="blob-num js-line-number" data-line-number="5798"></td>
+ <td id="LC5798" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L5799" class="blob-num js-line-number" data-line-number="5799"></td>
+ <td id="LC5799" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5800" class="blob-num js-line-number" data-line-number="5800"></td>
+ <td id="LC5800" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L5801" class="blob-num js-line-number" data-line-number="5801"></td>
+ <td id="LC5801" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L5802" class="blob-num js-line-number" data-line-number="5802"></td>
+ <td id="LC5802" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5803" class="blob-num js-line-number" data-line-number="5803"></td>
+ <td id="LC5803" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5804" class="blob-num js-line-number" data-line-number="5804"></td>
+ <td id="LC5804" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5805" class="blob-num js-line-number" data-line-number="5805"></td>
+ <td id="LC5805" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5806" class="blob-num js-line-number" data-line-number="5806"></td>
+ <td id="LC5806" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5807" class="blob-num js-line-number" data-line-number="5807"></td>
+ <td id="LC5807" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L5808" class="blob-num js-line-number" data-line-number="5808"></td>
+ <td id="LC5808" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called per</span></td>
+ </tr>
+ <tr>
+ <td id="L5809" class="blob-num js-line-number" data-line-number="5809"></td>
+ <td id="LC5809" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * iteration. If a property name or object is provided it will be used to</span></td>
+ </tr>
+ <tr>
+ <td id="L5810" class="blob-num js-line-number" data-line-number="5810"></td>
+ <td id="LC5810" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L5811" class="blob-num js-line-number" data-line-number="5811"></td>
+ <td id="LC5811" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5812" class="blob-num js-line-number" data-line-number="5812"></td>
+ <td id="LC5812" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {string|undefined} Returns the key of the found element, else `undefined`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5813" class="blob-num js-line-number" data-line-number="5813"></td>
+ <td id="LC5813" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5814" class="blob-num js-line-number" data-line-number="5814"></td>
+ <td id="LC5814" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5815" class="blob-num js-line-number" data-line-number="5815"></td>
+ <td id="LC5815" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = {</span></td>
+ </tr>
+ <tr>
+ <td id="L5816" class="blob-num js-line-number" data-line-number="5816"></td>
+ <td id="LC5816" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'barney': { 'age': 36, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L5817" class="blob-num js-line-number" data-line-number="5817"></td>
+ <td id="LC5817" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'fred': { 'age': 40, 'blocked': true },</span></td>
+ </tr>
+ <tr>
+ <td id="L5818" class="blob-num js-line-number" data-line-number="5818"></td>
+ <td id="LC5818" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'pebbles': { 'age': 1, 'blocked': false }</span></td>
+ </tr>
+ <tr>
+ <td id="L5819" class="blob-num js-line-number" data-line-number="5819"></td>
+ <td id="LC5819" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L5820" class="blob-num js-line-number" data-line-number="5820"></td>
+ <td id="LC5820" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5821" class="blob-num js-line-number" data-line-number="5821"></td>
+ <td id="LC5821" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findKey(characters, function(chr) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5822" class="blob-num js-line-number" data-line-number="5822"></td>
+ <td id="LC5822" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return chr.age < 40;</span></td>
+ </tr>
+ <tr>
+ <td id="L5823" class="blob-num js-line-number" data-line-number="5823"></td>
+ <td id="LC5823" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5824" class="blob-num js-line-number" data-line-number="5824"></td>
+ <td id="LC5824" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'barney' (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L5825" class="blob-num js-line-number" data-line-number="5825"></td>
+ <td id="LC5825" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5826" class="blob-num js-line-number" data-line-number="5826"></td>
+ <td id="LC5826" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L5827" class="blob-num js-line-number" data-line-number="5827"></td>
+ <td id="LC5827" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findKey(characters, { 'age': 1 });</span></td>
+ </tr>
+ <tr>
+ <td id="L5828" class="blob-num js-line-number" data-line-number="5828"></td>
+ <td id="LC5828" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'pebbles'</span></td>
+ </tr>
+ <tr>
+ <td id="L5829" class="blob-num js-line-number" data-line-number="5829"></td>
+ <td id="LC5829" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5830" class="blob-num js-line-number" data-line-number="5830"></td>
+ <td id="LC5830" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L5831" class="blob-num js-line-number" data-line-number="5831"></td>
+ <td id="LC5831" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findKey(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L5832" class="blob-num js-line-number" data-line-number="5832"></td>
+ <td id="LC5832" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L5833" class="blob-num js-line-number" data-line-number="5833"></td>
+ <td id="LC5833" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5834" class="blob-num js-line-number" data-line-number="5834"></td>
+ <td id="LC5834" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">findKey</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5835" class="blob-num js-line-number" data-line-number="5835"></td>
+ <td id="LC5835" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5836" class="blob-num js-line-number" data-line-number="5836"></td>
+ <td id="LC5836" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5837" class="blob-num js-line-number" data-line-number="5837"></td>
+ <td id="LC5837" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5838" class="blob-num js-line-number" data-line-number="5838"></td>
+ <td id="LC5838" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, key, object)) {</td>
+ </tr>
+ <tr>
+ <td id="L5839" class="blob-num js-line-number" data-line-number="5839"></td>
+ <td id="LC5839" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> key;</td>
+ </tr>
+ <tr>
+ <td id="L5840" class="blob-num js-line-number" data-line-number="5840"></td>
+ <td id="LC5840" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5841" class="blob-num js-line-number" data-line-number="5841"></td>
+ <td id="LC5841" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5842" class="blob-num js-line-number" data-line-number="5842"></td>
+ <td id="LC5842" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5843" class="blob-num js-line-number" data-line-number="5843"></td>
+ <td id="LC5843" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5844" class="blob-num js-line-number" data-line-number="5844"></td>
+ <td id="LC5844" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5845" class="blob-num js-line-number" data-line-number="5845"></td>
+ <td id="LC5845" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5846" class="blob-num js-line-number" data-line-number="5846"></td>
+ <td id="LC5846" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5847" class="blob-num js-line-number" data-line-number="5847"></td>
+ <td id="LC5847" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.findKey` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L5848" class="blob-num js-line-number" data-line-number="5848"></td>
+ <td id="LC5848" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` in the opposite order.</span></td>
+ </tr>
+ <tr>
+ <td id="L5849" class="blob-num js-line-number" data-line-number="5849"></td>
+ <td id="LC5849" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5850" class="blob-num js-line-number" data-line-number="5850"></td>
+ <td id="LC5850" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L5851" class="blob-num js-line-number" data-line-number="5851"></td>
+ <td id="LC5851" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L5852" class="blob-num js-line-number" data-line-number="5852"></td>
+ <td id="LC5852" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5853" class="blob-num js-line-number" data-line-number="5853"></td>
+ <td id="LC5853" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L5854" class="blob-num js-line-number" data-line-number="5854"></td>
+ <td id="LC5854" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L5855" class="blob-num js-line-number" data-line-number="5855"></td>
+ <td id="LC5855" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5856" class="blob-num js-line-number" data-line-number="5856"></td>
+ <td id="LC5856" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5857" class="blob-num js-line-number" data-line-number="5857"></td>
+ <td id="LC5857" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5858" class="blob-num js-line-number" data-line-number="5858"></td>
+ <td id="LC5858" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5859" class="blob-num js-line-number" data-line-number="5859"></td>
+ <td id="LC5859" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5860" class="blob-num js-line-number" data-line-number="5860"></td>
+ <td id="LC5860" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L5861" class="blob-num js-line-number" data-line-number="5861"></td>
+ <td id="LC5861" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called per</span></td>
+ </tr>
+ <tr>
+ <td id="L5862" class="blob-num js-line-number" data-line-number="5862"></td>
+ <td id="LC5862" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * iteration. If a property name or object is provided it will be used to</span></td>
+ </tr>
+ <tr>
+ <td id="L5863" class="blob-num js-line-number" data-line-number="5863"></td>
+ <td id="LC5863" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L5864" class="blob-num js-line-number" data-line-number="5864"></td>
+ <td id="LC5864" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5865" class="blob-num js-line-number" data-line-number="5865"></td>
+ <td id="LC5865" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {string|undefined} Returns the key of the found element, else `undefined`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5866" class="blob-num js-line-number" data-line-number="5866"></td>
+ <td id="LC5866" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5867" class="blob-num js-line-number" data-line-number="5867"></td>
+ <td id="LC5867" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5868" class="blob-num js-line-number" data-line-number="5868"></td>
+ <td id="LC5868" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = {</span></td>
+ </tr>
+ <tr>
+ <td id="L5869" class="blob-num js-line-number" data-line-number="5869"></td>
+ <td id="LC5869" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'barney': { 'age': 36, 'blocked': true },</span></td>
+ </tr>
+ <tr>
+ <td id="L5870" class="blob-num js-line-number" data-line-number="5870"></td>
+ <td id="LC5870" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'fred': { 'age': 40, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L5871" class="blob-num js-line-number" data-line-number="5871"></td>
+ <td id="LC5871" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'pebbles': { 'age': 1, 'blocked': true }</span></td>
+ </tr>
+ <tr>
+ <td id="L5872" class="blob-num js-line-number" data-line-number="5872"></td>
+ <td id="LC5872" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L5873" class="blob-num js-line-number" data-line-number="5873"></td>
+ <td id="LC5873" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5874" class="blob-num js-line-number" data-line-number="5874"></td>
+ <td id="LC5874" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLastKey(characters, function(chr) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5875" class="blob-num js-line-number" data-line-number="5875"></td>
+ <td id="LC5875" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return chr.age < 40;</span></td>
+ </tr>
+ <tr>
+ <td id="L5876" class="blob-num js-line-number" data-line-number="5876"></td>
+ <td id="LC5876" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5877" class="blob-num js-line-number" data-line-number="5877"></td>
+ <td id="LC5877" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => returns `pebbles`, assuming `_.findKey` returns `barney`</span></td>
+ </tr>
+ <tr>
+ <td id="L5878" class="blob-num js-line-number" data-line-number="5878"></td>
+ <td id="LC5878" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5879" class="blob-num js-line-number" data-line-number="5879"></td>
+ <td id="LC5879" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L5880" class="blob-num js-line-number" data-line-number="5880"></td>
+ <td id="LC5880" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLastKey(characters, { 'age': 40 });</span></td>
+ </tr>
+ <tr>
+ <td id="L5881" class="blob-num js-line-number" data-line-number="5881"></td>
+ <td id="LC5881" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L5882" class="blob-num js-line-number" data-line-number="5882"></td>
+ <td id="LC5882" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5883" class="blob-num js-line-number" data-line-number="5883"></td>
+ <td id="LC5883" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L5884" class="blob-num js-line-number" data-line-number="5884"></td>
+ <td id="LC5884" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLastKey(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L5885" class="blob-num js-line-number" data-line-number="5885"></td>
+ <td id="LC5885" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'pebbles'</span></td>
+ </tr>
+ <tr>
+ <td id="L5886" class="blob-num js-line-number" data-line-number="5886"></td>
+ <td id="LC5886" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5887" class="blob-num js-line-number" data-line-number="5887"></td>
+ <td id="LC5887" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">findLastKey</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5888" class="blob-num js-line-number" data-line-number="5888"></td>
+ <td id="LC5888" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5889" class="blob-num js-line-number" data-line-number="5889"></td>
+ <td id="LC5889" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5890" class="blob-num js-line-number" data-line-number="5890"></td>
+ <td id="LC5890" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwnRight</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5891" class="blob-num js-line-number" data-line-number="5891"></td>
+ <td id="LC5891" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, key, object)) {</td>
+ </tr>
+ <tr>
+ <td id="L5892" class="blob-num js-line-number" data-line-number="5892"></td>
+ <td id="LC5892" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> key;</td>
+ </tr>
+ <tr>
+ <td id="L5893" class="blob-num js-line-number" data-line-number="5893"></td>
+ <td id="LC5893" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5894" class="blob-num js-line-number" data-line-number="5894"></td>
+ <td id="LC5894" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5895" class="blob-num js-line-number" data-line-number="5895"></td>
+ <td id="LC5895" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5896" class="blob-num js-line-number" data-line-number="5896"></td>
+ <td id="LC5896" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5897" class="blob-num js-line-number" data-line-number="5897"></td>
+ <td id="LC5897" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5898" class="blob-num js-line-number" data-line-number="5898"></td>
+ <td id="LC5898" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5899" class="blob-num js-line-number" data-line-number="5899"></td>
+ <td id="LC5899" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5900" class="blob-num js-line-number" data-line-number="5900"></td>
+ <td id="LC5900" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Iterates over own and inherited enumerable properties of an object,</span></td>
+ </tr>
+ <tr>
+ <td id="L5901" class="blob-num js-line-number" data-line-number="5901"></td>
+ <td id="LC5901" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * executing the callback for each property. The callback is bound to `thisArg`</span></td>
+ </tr>
+ <tr>
+ <td id="L5902" class="blob-num js-line-number" data-line-number="5902"></td>
+ <td id="LC5902" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and invoked with three arguments; (value, key, object). Callbacks may exit</span></td>
+ </tr>
+ <tr>
+ <td id="L5903" class="blob-num js-line-number" data-line-number="5903"></td>
+ <td id="LC5903" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * iteration early by explicitly returning `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5904" class="blob-num js-line-number" data-line-number="5904"></td>
+ <td id="LC5904" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5905" class="blob-num js-line-number" data-line-number="5905"></td>
+ <td id="LC5905" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5906" class="blob-num js-line-number" data-line-number="5906"></td>
+ <td id="LC5906" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5907" class="blob-num js-line-number" data-line-number="5907"></td>
+ <td id="LC5907" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L5908" class="blob-num js-line-number" data-line-number="5908"></td>
+ <td id="LC5908" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5909" class="blob-num js-line-number" data-line-number="5909"></td>
+ <td id="LC5909" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L5910" class="blob-num js-line-number" data-line-number="5910"></td>
+ <td id="LC5910" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L5911" class="blob-num js-line-number" data-line-number="5911"></td>
+ <td id="LC5911" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5912" class="blob-num js-line-number" data-line-number="5912"></td>
+ <td id="LC5912" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> `object`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5913" class="blob-num js-line-number" data-line-number="5913"></td>
+ <td id="LC5913" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5914" class="blob-num js-line-number" data-line-number="5914"></td>
+ <td id="LC5914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5915" class="blob-num js-line-number" data-line-number="5915"></td>
+ <td id="LC5915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function Shape() {</span></td>
+ </tr>
+ <tr>
+ <td id="L5916" class="blob-num js-line-number" data-line-number="5916"></td>
+ <td id="LC5916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.x = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L5917" class="blob-num js-line-number" data-line-number="5917"></td>
+ <td id="LC5917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.y = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L5918" class="blob-num js-line-number" data-line-number="5918"></td>
+ <td id="LC5918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L5919" class="blob-num js-line-number" data-line-number="5919"></td>
+ <td id="LC5919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5920" class="blob-num js-line-number" data-line-number="5920"></td>
+ <td id="LC5920" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Shape.prototype.move = function(x, y) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5921" class="blob-num js-line-number" data-line-number="5921"></td>
+ <td id="LC5921" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.x += x;</span></td>
+ </tr>
+ <tr>
+ <td id="L5922" class="blob-num js-line-number" data-line-number="5922"></td>
+ <td id="LC5922" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.y += y;</span></td>
+ </tr>
+ <tr>
+ <td id="L5923" class="blob-num js-line-number" data-line-number="5923"></td>
+ <td id="LC5923" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L5924" class="blob-num js-line-number" data-line-number="5924"></td>
+ <td id="LC5924" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5925" class="blob-num js-line-number" data-line-number="5925"></td>
+ <td id="LC5925" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.forIn(new Shape, function(value, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5926" class="blob-num js-line-number" data-line-number="5926"></td>
+ <td id="LC5926" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(key);</span></td>
+ </tr>
+ <tr>
+ <td id="L5927" class="blob-num js-line-number" data-line-number="5927"></td>
+ <td id="LC5927" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5928" class="blob-num js-line-number" data-line-number="5928"></td>
+ <td id="LC5928" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L5929" class="blob-num js-line-number" data-line-number="5929"></td>
+ <td id="LC5929" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5930" class="blob-num js-line-number" data-line-number="5930"></td>
+ <td id="LC5930" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">forIn</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5931" class="blob-num js-line-number" data-line-number="5931"></td>
+ <td id="LC5931" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index, iterable <span class="pl-k">=</span> collection, result <span class="pl-k">=</span> iterable;</td>
+ </tr>
+ <tr>
+ <td id="L5932" class="blob-num js-line-number" data-line-number="5932"></td>
+ <td id="LC5932" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>iterable) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5933" class="blob-num js-line-number" data-line-number="5933"></td>
+ <td id="LC5933" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>objectTypes[<span class="pl-k">typeof</span> iterable]) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5934" class="blob-num js-line-number" data-line-number="5934"></td>
+ <td id="LC5934" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> callback <span class="pl-k">&&</span> <span class="pl-k">typeof</span> thisArg <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span> <span class="pl-k">?</span> callback <span class="pl-k">:</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5935" class="blob-num js-line-number" data-line-number="5935"></td>
+ <td id="LC5935" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> (index <span class="pl-k">in</span> iterable) {</td>
+ </tr>
+ <tr>
+ <td id="L5936" class="blob-num js-line-number" data-line-number="5936"></td>
+ <td id="LC5936" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(iterable[index], index, collection) <span class="pl-k">===</span> <span class="pl-c1">false</span>) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L5937" class="blob-num js-line-number" data-line-number="5937"></td>
+ <td id="LC5937" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5938" class="blob-num js-line-number" data-line-number="5938"></td>
+ <td id="LC5938" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result</td>
+ </tr>
+ <tr>
+ <td id="L5939" class="blob-num js-line-number" data-line-number="5939"></td>
+ <td id="LC5939" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L5940" class="blob-num js-line-number" data-line-number="5940"></td>
+ <td id="LC5940" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5941" class="blob-num js-line-number" data-line-number="5941"></td>
+ <td id="LC5941" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5942" class="blob-num js-line-number" data-line-number="5942"></td>
+ <td id="LC5942" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.forIn` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L5943" class="blob-num js-line-number" data-line-number="5943"></td>
+ <td id="LC5943" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` in the opposite order.</span></td>
+ </tr>
+ <tr>
+ <td id="L5944" class="blob-num js-line-number" data-line-number="5944"></td>
+ <td id="LC5944" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5945" class="blob-num js-line-number" data-line-number="5945"></td>
+ <td id="LC5945" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5946" class="blob-num js-line-number" data-line-number="5946"></td>
+ <td id="LC5946" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5947" class="blob-num js-line-number" data-line-number="5947"></td>
+ <td id="LC5947" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5948" class="blob-num js-line-number" data-line-number="5948"></td>
+ <td id="LC5948" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L5949" class="blob-num js-line-number" data-line-number="5949"></td>
+ <td id="LC5949" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L5950" class="blob-num js-line-number" data-line-number="5950"></td>
+ <td id="LC5950" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5951" class="blob-num js-line-number" data-line-number="5951"></td>
+ <td id="LC5951" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> `object`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5952" class="blob-num js-line-number" data-line-number="5952"></td>
+ <td id="LC5952" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5953" class="blob-num js-line-number" data-line-number="5953"></td>
+ <td id="LC5953" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5954" class="blob-num js-line-number" data-line-number="5954"></td>
+ <td id="LC5954" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function Shape() {</span></td>
+ </tr>
+ <tr>
+ <td id="L5955" class="blob-num js-line-number" data-line-number="5955"></td>
+ <td id="LC5955" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.x = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L5956" class="blob-num js-line-number" data-line-number="5956"></td>
+ <td id="LC5956" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.y = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L5957" class="blob-num js-line-number" data-line-number="5957"></td>
+ <td id="LC5957" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L5958" class="blob-num js-line-number" data-line-number="5958"></td>
+ <td id="LC5958" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5959" class="blob-num js-line-number" data-line-number="5959"></td>
+ <td id="LC5959" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Shape.prototype.move = function(x, y) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5960" class="blob-num js-line-number" data-line-number="5960"></td>
+ <td id="LC5960" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.x += x;</span></td>
+ </tr>
+ <tr>
+ <td id="L5961" class="blob-num js-line-number" data-line-number="5961"></td>
+ <td id="LC5961" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.y += y;</span></td>
+ </tr>
+ <tr>
+ <td id="L5962" class="blob-num js-line-number" data-line-number="5962"></td>
+ <td id="LC5962" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L5963" class="blob-num js-line-number" data-line-number="5963"></td>
+ <td id="LC5963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5964" class="blob-num js-line-number" data-line-number="5964"></td>
+ <td id="LC5964" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.forInRight(new Shape, function(value, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L5965" class="blob-num js-line-number" data-line-number="5965"></td>
+ <td id="LC5965" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(key);</span></td>
+ </tr>
+ <tr>
+ <td id="L5966" class="blob-num js-line-number" data-line-number="5966"></td>
+ <td id="LC5966" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L5967" class="blob-num js-line-number" data-line-number="5967"></td>
+ <td id="LC5967" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move'</span></td>
+ </tr>
+ <tr>
+ <td id="L5968" class="blob-num js-line-number" data-line-number="5968"></td>
+ <td id="LC5968" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L5969" class="blob-num js-line-number" data-line-number="5969"></td>
+ <td id="LC5969" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">forInRight</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5970" class="blob-num js-line-number" data-line-number="5970"></td>
+ <td id="LC5970" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> pairs <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L5971" class="blob-num js-line-number" data-line-number="5971"></td>
+ <td id="LC5971" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5972" class="blob-num js-line-number" data-line-number="5972"></td>
+ <td id="LC5972" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5973" class="blob-num js-line-number" data-line-number="5973"></td>
+ <td id="LC5973" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">pairs</span>.<span class="pl-c1">push</span>(key, value);</td>
+ </tr>
+ <tr>
+ <td id="L5974" class="blob-num js-line-number" data-line-number="5974"></td>
+ <td id="LC5974" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L5975" class="blob-num js-line-number" data-line-number="5975"></td>
+ <td id="LC5975" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5976" class="blob-num js-line-number" data-line-number="5976"></td>
+ <td id="LC5976" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> <span class="pl-smi">pairs</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5977" class="blob-num js-line-number" data-line-number="5977"></td>
+ <td id="LC5977" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L5978" class="blob-num js-line-number" data-line-number="5978"></td>
+ <td id="LC5978" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5979" class="blob-num js-line-number" data-line-number="5979"></td>
+ <td id="LC5979" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(pairs[length<span class="pl-k">--</span>], pairs[length], object) <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L5980" class="blob-num js-line-number" data-line-number="5980"></td>
+ <td id="LC5980" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L5981" class="blob-num js-line-number" data-line-number="5981"></td>
+ <td id="LC5981" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5982" class="blob-num js-line-number" data-line-number="5982"></td>
+ <td id="LC5982" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5983" class="blob-num js-line-number" data-line-number="5983"></td>
+ <td id="LC5983" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object;</td>
+ </tr>
+ <tr>
+ <td id="L5984" class="blob-num js-line-number" data-line-number="5984"></td>
+ <td id="LC5984" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L5985" class="blob-num js-line-number" data-line-number="5985"></td>
+ <td id="LC5985" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L5986" class="blob-num js-line-number" data-line-number="5986"></td>
+ <td id="LC5986" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L5987" class="blob-num js-line-number" data-line-number="5987"></td>
+ <td id="LC5987" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Iterates over own enumerable properties of an object, executing the callback</span></td>
+ </tr>
+ <tr>
+ <td id="L5988" class="blob-num js-line-number" data-line-number="5988"></td>
+ <td id="LC5988" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for each property. The callback is bound to `thisArg` and invoked with three</span></td>
+ </tr>
+ <tr>
+ <td id="L5989" class="blob-num js-line-number" data-line-number="5989"></td>
+ <td id="LC5989" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (value, key, object). Callbacks may exit iteration early by</span></td>
+ </tr>
+ <tr>
+ <td id="L5990" class="blob-num js-line-number" data-line-number="5990"></td>
+ <td id="LC5990" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * explicitly returning `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5991" class="blob-num js-line-number" data-line-number="5991"></td>
+ <td id="LC5991" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L5992" class="blob-num js-line-number" data-line-number="5992"></td>
+ <td id="LC5992" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L5993" class="blob-num js-line-number" data-line-number="5993"></td>
+ <td id="LC5993" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L5994" class="blob-num js-line-number" data-line-number="5994"></td>
+ <td id="LC5994" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L5995" class="blob-num js-line-number" data-line-number="5995"></td>
+ <td id="LC5995" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L5996" class="blob-num js-line-number" data-line-number="5996"></td>
+ <td id="LC5996" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L5997" class="blob-num js-line-number" data-line-number="5997"></td>
+ <td id="LC5997" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L5998" class="blob-num js-line-number" data-line-number="5998"></td>
+ <td id="LC5998" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L5999" class="blob-num js-line-number" data-line-number="5999"></td>
+ <td id="LC5999" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> `object`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6000" class="blob-num js-line-number" data-line-number="6000"></td>
+ <td id="LC6000" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6001" class="blob-num js-line-number" data-line-number="6001"></td>
+ <td id="LC6001" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6002" class="blob-num js-line-number" data-line-number="6002"></td>
+ <td id="LC6002" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6003" class="blob-num js-line-number" data-line-number="6003"></td>
+ <td id="LC6003" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(key);</span></td>
+ </tr>
+ <tr>
+ <td id="L6004" class="blob-num js-line-number" data-line-number="6004"></td>
+ <td id="LC6004" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6005" class="blob-num js-line-number" data-line-number="6005"></td>
+ <td id="LC6005" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L6006" class="blob-num js-line-number" data-line-number="6006"></td>
+ <td id="LC6006" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6007" class="blob-num js-line-number" data-line-number="6007"></td>
+ <td id="LC6007" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">forOwn</span> <span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6008" class="blob-num js-line-number" data-line-number="6008"></td>
+ <td id="LC6008" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index, iterable <span class="pl-k">=</span> collection, result <span class="pl-k">=</span> iterable;</td>
+ </tr>
+ <tr>
+ <td id="L6009" class="blob-num js-line-number" data-line-number="6009"></td>
+ <td id="LC6009" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>iterable) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6010" class="blob-num js-line-number" data-line-number="6010"></td>
+ <td id="LC6010" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>objectTypes[<span class="pl-k">typeof</span> iterable]) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6011" class="blob-num js-line-number" data-line-number="6011"></td>
+ <td id="LC6011" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> callback <span class="pl-k">&&</span> <span class="pl-k">typeof</span> thisArg <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span> <span class="pl-k">?</span> callback <span class="pl-k">:</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6012" class="blob-num js-line-number" data-line-number="6012"></td>
+ <td id="LC6012" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ownIndex <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6013" class="blob-num js-line-number" data-line-number="6013"></td>
+ <td id="LC6013" class="blob-code blob-code-inner js-file-line"> ownProps <span class="pl-k">=</span> objectTypes[<span class="pl-k">typeof</span> iterable] <span class="pl-k">&&</span> <span class="pl-en">keys</span>(iterable),</td>
+ </tr>
+ <tr>
+ <td id="L6014" class="blob-num js-line-number" data-line-number="6014"></td>
+ <td id="LC6014" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> ownProps <span class="pl-k">?</span> <span class="pl-smi">ownProps</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6015" class="blob-num js-line-number" data-line-number="6015"></td>
+ <td id="LC6015" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6016" class="blob-num js-line-number" data-line-number="6016"></td>
+ <td id="LC6016" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>ownIndex <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6017" class="blob-num js-line-number" data-line-number="6017"></td>
+ <td id="LC6017" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> ownProps[ownIndex];</td>
+ </tr>
+ <tr>
+ <td id="L6018" class="blob-num js-line-number" data-line-number="6018"></td>
+ <td id="LC6018" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(iterable[index], index, collection) <span class="pl-k">===</span> <span class="pl-c1">false</span>) <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6019" class="blob-num js-line-number" data-line-number="6019"></td>
+ <td id="LC6019" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6020" class="blob-num js-line-number" data-line-number="6020"></td>
+ <td id="LC6020" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result</td>
+ </tr>
+ <tr>
+ <td id="L6021" class="blob-num js-line-number" data-line-number="6021"></td>
+ <td id="LC6021" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L6022" class="blob-num js-line-number" data-line-number="6022"></td>
+ <td id="LC6022" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6023" class="blob-num js-line-number" data-line-number="6023"></td>
+ <td id="LC6023" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6024" class="blob-num js-line-number" data-line-number="6024"></td>
+ <td id="LC6024" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.forOwn` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L6025" class="blob-num js-line-number" data-line-number="6025"></td>
+ <td id="LC6025" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` in the opposite order.</span></td>
+ </tr>
+ <tr>
+ <td id="L6026" class="blob-num js-line-number" data-line-number="6026"></td>
+ <td id="LC6026" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6027" class="blob-num js-line-number" data-line-number="6027"></td>
+ <td id="LC6027" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6028" class="blob-num js-line-number" data-line-number="6028"></td>
+ <td id="LC6028" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6029" class="blob-num js-line-number" data-line-number="6029"></td>
+ <td id="LC6029" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6030" class="blob-num js-line-number" data-line-number="6030"></td>
+ <td id="LC6030" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6031" class="blob-num js-line-number" data-line-number="6031"></td>
+ <td id="LC6031" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L6032" class="blob-num js-line-number" data-line-number="6032"></td>
+ <td id="LC6032" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6033" class="blob-num js-line-number" data-line-number="6033"></td>
+ <td id="LC6033" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> `object`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6034" class="blob-num js-line-number" data-line-number="6034"></td>
+ <td id="LC6034" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6035" class="blob-num js-line-number" data-line-number="6035"></td>
+ <td id="LC6035" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6036" class="blob-num js-line-number" data-line-number="6036"></td>
+ <td id="LC6036" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6037" class="blob-num js-line-number" data-line-number="6037"></td>
+ <td id="LC6037" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(key);</span></td>
+ </tr>
+ <tr>
+ <td id="L6038" class="blob-num js-line-number" data-line-number="6038"></td>
+ <td id="LC6038" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6039" class="blob-num js-line-number" data-line-number="6039"></td>
+ <td id="LC6039" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length'</span></td>
+ </tr>
+ <tr>
+ <td id="L6040" class="blob-num js-line-number" data-line-number="6040"></td>
+ <td id="LC6040" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6041" class="blob-num js-line-number" data-line-number="6041"></td>
+ <td id="LC6041" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">forOwnRight</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6042" class="blob-num js-line-number" data-line-number="6042"></td>
+ <td id="LC6042" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> props <span class="pl-k">=</span> <span class="pl-en">keys</span>(object),</td>
+ </tr>
+ <tr>
+ <td id="L6043" class="blob-num js-line-number" data-line-number="6043"></td>
+ <td id="LC6043" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6044" class="blob-num js-line-number" data-line-number="6044"></td>
+ <td id="LC6044" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6045" class="blob-num js-line-number" data-line-number="6045"></td>
+ <td id="LC6045" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6046" class="blob-num js-line-number" data-line-number="6046"></td>
+ <td id="LC6046" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6047" class="blob-num js-line-number" data-line-number="6047"></td>
+ <td id="LC6047" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> props[length];</td>
+ </tr>
+ <tr>
+ <td id="L6048" class="blob-num js-line-number" data-line-number="6048"></td>
+ <td id="LC6048" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(object[key], key, object) <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6049" class="blob-num js-line-number" data-line-number="6049"></td>
+ <td id="LC6049" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6050" class="blob-num js-line-number" data-line-number="6050"></td>
+ <td id="LC6050" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6051" class="blob-num js-line-number" data-line-number="6051"></td>
+ <td id="LC6051" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6052" class="blob-num js-line-number" data-line-number="6052"></td>
+ <td id="LC6052" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object;</td>
+ </tr>
+ <tr>
+ <td id="L6053" class="blob-num js-line-number" data-line-number="6053"></td>
+ <td id="LC6053" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6054" class="blob-num js-line-number" data-line-number="6054"></td>
+ <td id="LC6054" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6055" class="blob-num js-line-number" data-line-number="6055"></td>
+ <td id="LC6055" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6056" class="blob-num js-line-number" data-line-number="6056"></td>
+ <td id="LC6056" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a sorted array of property names of all enumerable properties,</span></td>
+ </tr>
+ <tr>
+ <td id="L6057" class="blob-num js-line-number" data-line-number="6057"></td>
+ <td id="LC6057" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * own and inherited, of `object` that have function values.</span></td>
+ </tr>
+ <tr>
+ <td id="L6058" class="blob-num js-line-number" data-line-number="6058"></td>
+ <td id="LC6058" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6059" class="blob-num js-line-number" data-line-number="6059"></td>
+ <td id="LC6059" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6060" class="blob-num js-line-number" data-line-number="6060"></td>
+ <td id="LC6060" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6061" class="blob-num js-line-number" data-line-number="6061"></td>
+ <td id="LC6061" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> methods</span></td>
+ </tr>
+ <tr>
+ <td id="L6062" class="blob-num js-line-number" data-line-number="6062"></td>
+ <td id="LC6062" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6063" class="blob-num js-line-number" data-line-number="6063"></td>
+ <td id="LC6063" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L6064" class="blob-num js-line-number" data-line-number="6064"></td>
+ <td id="LC6064" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of property names that have function values.</span></td>
+ </tr>
+ <tr>
+ <td id="L6065" class="blob-num js-line-number" data-line-number="6065"></td>
+ <td id="LC6065" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6066" class="blob-num js-line-number" data-line-number="6066"></td>
+ <td id="LC6066" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6067" class="blob-num js-line-number" data-line-number="6067"></td>
+ <td id="LC6067" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.functions(_);</span></td>
+ </tr>
+ <tr>
+ <td id="L6068" class="blob-num js-line-number" data-line-number="6068"></td>
+ <td id="LC6068" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]</span></td>
+ </tr>
+ <tr>
+ <td id="L6069" class="blob-num js-line-number" data-line-number="6069"></td>
+ <td id="LC6069" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6070" class="blob-num js-line-number" data-line-number="6070"></td>
+ <td id="LC6070" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">functions</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6071" class="blob-num js-line-number" data-line-number="6071"></td>
+ <td id="LC6071" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L6072" class="blob-num js-line-number" data-line-number="6072"></td>
+ <td id="LC6072" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6073" class="blob-num js-line-number" data-line-number="6073"></td>
+ <td id="LC6073" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">isFunction</span>(value)) {</td>
+ </tr>
+ <tr>
+ <td id="L6074" class="blob-num js-line-number" data-line-number="6074"></td>
+ <td id="LC6074" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(key);</td>
+ </tr>
+ <tr>
+ <td id="L6075" class="blob-num js-line-number" data-line-number="6075"></td>
+ <td id="LC6075" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6076" class="blob-num js-line-number" data-line-number="6076"></td>
+ <td id="LC6076" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6077" class="blob-num js-line-number" data-line-number="6077"></td>
+ <td id="LC6077" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">result</span>.<span class="pl-c1">sort</span>();</td>
+ </tr>
+ <tr>
+ <td id="L6078" class="blob-num js-line-number" data-line-number="6078"></td>
+ <td id="LC6078" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6079" class="blob-num js-line-number" data-line-number="6079"></td>
+ <td id="LC6079" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6080" class="blob-num js-line-number" data-line-number="6080"></td>
+ <td id="LC6080" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6081" class="blob-num js-line-number" data-line-number="6081"></td>
+ <td id="LC6081" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if the specified property name exists as a direct property of `object`,</span></td>
+ </tr>
+ <tr>
+ <td id="L6082" class="blob-num js-line-number" data-line-number="6082"></td>
+ <td id="LC6082" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * instead of an inherited property.</span></td>
+ </tr>
+ <tr>
+ <td id="L6083" class="blob-num js-line-number" data-line-number="6083"></td>
+ <td id="LC6083" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6084" class="blob-num js-line-number" data-line-number="6084"></td>
+ <td id="LC6084" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6085" class="blob-num js-line-number" data-line-number="6085"></td>
+ <td id="LC6085" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6086" class="blob-num js-line-number" data-line-number="6086"></td>
+ <td id="LC6086" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6087" class="blob-num js-line-number" data-line-number="6087"></td>
+ <td id="LC6087" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L6088" class="blob-num js-line-number" data-line-number="6088"></td>
+ <td id="LC6088" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">key</span> The name of the property to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6089" class="blob-num js-line-number" data-line-number="6089"></td>
+ <td id="LC6089" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if key is a direct property, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6090" class="blob-num js-line-number" data-line-number="6090"></td>
+ <td id="LC6090" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6091" class="blob-num js-line-number" data-line-number="6091"></td>
+ <td id="LC6091" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6092" class="blob-num js-line-number" data-line-number="6092"></td>
+ <td id="LC6092" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');</span></td>
+ </tr>
+ <tr>
+ <td id="L6093" class="blob-num js-line-number" data-line-number="6093"></td>
+ <td id="LC6093" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6094" class="blob-num js-line-number" data-line-number="6094"></td>
+ <td id="LC6094" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6095" class="blob-num js-line-number" data-line-number="6095"></td>
+ <td id="LC6095" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">has</span>(<span class="pl-smi">object</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6096" class="blob-num js-line-number" data-line-number="6096"></td>
+ <td id="LC6096" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object <span class="pl-k">?</span> <span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(object, key) <span class="pl-k">:</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6097" class="blob-num js-line-number" data-line-number="6097"></td>
+ <td id="LC6097" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6098" class="blob-num js-line-number" data-line-number="6098"></td>
+ <td id="LC6098" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6099" class="blob-num js-line-number" data-line-number="6099"></td>
+ <td id="LC6099" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6100" class="blob-num js-line-number" data-line-number="6100"></td>
+ <td id="LC6100" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object composed of the inverted keys and values of the given object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6101" class="blob-num js-line-number" data-line-number="6101"></td>
+ <td id="LC6101" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6102" class="blob-num js-line-number" data-line-number="6102"></td>
+ <td id="LC6102" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6103" class="blob-num js-line-number" data-line-number="6103"></td>
+ <td id="LC6103" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6104" class="blob-num js-line-number" data-line-number="6104"></td>
+ <td id="LC6104" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6105" class="blob-num js-line-number" data-line-number="6105"></td>
+ <td id="LC6105" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to invert.</span></td>
+ </tr>
+ <tr>
+ <td id="L6106" class="blob-num js-line-number" data-line-number="6106"></td>
+ <td id="LC6106" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the created inverted object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6107" class="blob-num js-line-number" data-line-number="6107"></td>
+ <td id="LC6107" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6108" class="blob-num js-line-number" data-line-number="6108"></td>
+ <td id="LC6108" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6109" class="blob-num js-line-number" data-line-number="6109"></td>
+ <td id="LC6109" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.invert({ 'first': 'fred', 'second': 'barney' });</span></td>
+ </tr>
+ <tr>
+ <td id="L6110" class="blob-num js-line-number" data-line-number="6110"></td>
+ <td id="LC6110" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'fred': 'first', 'barney': 'second' }</span></td>
+ </tr>
+ <tr>
+ <td id="L6111" class="blob-num js-line-number" data-line-number="6111"></td>
+ <td id="LC6111" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6112" class="blob-num js-line-number" data-line-number="6112"></td>
+ <td id="LC6112" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">invert</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6113" class="blob-num js-line-number" data-line-number="6113"></td>
+ <td id="LC6113" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6114" class="blob-num js-line-number" data-line-number="6114"></td>
+ <td id="LC6114" class="blob-code blob-code-inner js-file-line"> props <span class="pl-k">=</span> <span class="pl-en">keys</span>(object),</td>
+ </tr>
+ <tr>
+ <td id="L6115" class="blob-num js-line-number" data-line-number="6115"></td>
+ <td id="LC6115" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6116" class="blob-num js-line-number" data-line-number="6116"></td>
+ <td id="LC6116" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L6117" class="blob-num js-line-number" data-line-number="6117"></td>
+ <td id="LC6117" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6118" class="blob-num js-line-number" data-line-number="6118"></td>
+ <td id="LC6118" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6119" class="blob-num js-line-number" data-line-number="6119"></td>
+ <td id="LC6119" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> props[index];</td>
+ </tr>
+ <tr>
+ <td id="L6120" class="blob-num js-line-number" data-line-number="6120"></td>
+ <td id="LC6120" class="blob-code blob-code-inner js-file-line"> result[object[key]] <span class="pl-k">=</span> key;</td>
+ </tr>
+ <tr>
+ <td id="L6121" class="blob-num js-line-number" data-line-number="6121"></td>
+ <td id="LC6121" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6122" class="blob-num js-line-number" data-line-number="6122"></td>
+ <td id="LC6122" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6123" class="blob-num js-line-number" data-line-number="6123"></td>
+ <td id="LC6123" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6124" class="blob-num js-line-number" data-line-number="6124"></td>
+ <td id="LC6124" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6125" class="blob-num js-line-number" data-line-number="6125"></td>
+ <td id="LC6125" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6126" class="blob-num js-line-number" data-line-number="6126"></td>
+ <td id="LC6126" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a boolean value.</span></td>
+ </tr>
+ <tr>
+ <td id="L6127" class="blob-num js-line-number" data-line-number="6127"></td>
+ <td id="LC6127" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6128" class="blob-num js-line-number" data-line-number="6128"></td>
+ <td id="LC6128" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6129" class="blob-num js-line-number" data-line-number="6129"></td>
+ <td id="LC6129" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6130" class="blob-num js-line-number" data-line-number="6130"></td>
+ <td id="LC6130" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6131" class="blob-num js-line-number" data-line-number="6131"></td>
+ <td id="LC6131" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6132" class="blob-num js-line-number" data-line-number="6132"></td>
+ <td id="LC6132" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a boolean value, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6133" class="blob-num js-line-number" data-line-number="6133"></td>
+ <td id="LC6133" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6134" class="blob-num js-line-number" data-line-number="6134"></td>
+ <td id="LC6134" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6135" class="blob-num js-line-number" data-line-number="6135"></td>
+ <td id="LC6135" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isBoolean(null);</span></td>
+ </tr>
+ <tr>
+ <td id="L6136" class="blob-num js-line-number" data-line-number="6136"></td>
+ <td id="LC6136" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6137" class="blob-num js-line-number" data-line-number="6137"></td>
+ <td id="LC6137" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6138" class="blob-num js-line-number" data-line-number="6138"></td>
+ <td id="LC6138" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isBoolean</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6139" class="blob-num js-line-number" data-line-number="6139"></td>
+ <td id="LC6139" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">===</span> <span class="pl-c1">true</span> <span class="pl-k">||</span> value <span class="pl-k">===</span> <span class="pl-c1">false</span> <span class="pl-k">||</span></td>
+ </tr>
+ <tr>
+ <td id="L6140" class="blob-num js-line-number" data-line-number="6140"></td>
+ <td id="LC6140" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> boolClass <span class="pl-k">||</span> <span class="pl-c1">fa [...]
+ </tr>
+ <tr>
+ <td id="L6141" class="blob-num js-line-number" data-line-number="6141"></td>
+ <td id="LC6141" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6142" class="blob-num js-line-number" data-line-number="6142"></td>
+ <td id="LC6142" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6143" class="blob-num js-line-number" data-line-number="6143"></td>
+ <td id="LC6143" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6144" class="blob-num js-line-number" data-line-number="6144"></td>
+ <td id="LC6144" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a date.</span></td>
+ </tr>
+ <tr>
+ <td id="L6145" class="blob-num js-line-number" data-line-number="6145"></td>
+ <td id="LC6145" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6146" class="blob-num js-line-number" data-line-number="6146"></td>
+ <td id="LC6146" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6147" class="blob-num js-line-number" data-line-number="6147"></td>
+ <td id="LC6147" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6148" class="blob-num js-line-number" data-line-number="6148"></td>
+ <td id="LC6148" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6149" class="blob-num js-line-number" data-line-number="6149"></td>
+ <td id="LC6149" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6150" class="blob-num js-line-number" data-line-number="6150"></td>
+ <td id="LC6150" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a date, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6151" class="blob-num js-line-number" data-line-number="6151"></td>
+ <td id="LC6151" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6152" class="blob-num js-line-number" data-line-number="6152"></td>
+ <td id="LC6152" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6153" class="blob-num js-line-number" data-line-number="6153"></td>
+ <td id="LC6153" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isDate(new Date);</span></td>
+ </tr>
+ <tr>
+ <td id="L6154" class="blob-num js-line-number" data-line-number="6154"></td>
+ <td id="LC6154" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6155" class="blob-num js-line-number" data-line-number="6155"></td>
+ <td id="LC6155" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6156" class="blob-num js-line-number" data-line-number="6156"></td>
+ <td id="LC6156" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isDate</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6157" class="blob-num js-line-number" data-line-number="6157"></td>
+ <td id="LC6157" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> dateClass <span class="pl-k">| [...]
+ </tr>
+ <tr>
+ <td id="L6158" class="blob-num js-line-number" data-line-number="6158"></td>
+ <td id="LC6158" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6159" class="blob-num js-line-number" data-line-number="6159"></td>
+ <td id="LC6159" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6160" class="blob-num js-line-number" data-line-number="6160"></td>
+ <td id="LC6160" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6161" class="blob-num js-line-number" data-line-number="6161"></td>
+ <td id="LC6161" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a DOM element.</span></td>
+ </tr>
+ <tr>
+ <td id="L6162" class="blob-num js-line-number" data-line-number="6162"></td>
+ <td id="LC6162" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6163" class="blob-num js-line-number" data-line-number="6163"></td>
+ <td id="LC6163" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6164" class="blob-num js-line-number" data-line-number="6164"></td>
+ <td id="LC6164" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6165" class="blob-num js-line-number" data-line-number="6165"></td>
+ <td id="LC6165" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6166" class="blob-num js-line-number" data-line-number="6166"></td>
+ <td id="LC6166" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6167" class="blob-num js-line-number" data-line-number="6167"></td>
+ <td id="LC6167" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a DOM element, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6168" class="blob-num js-line-number" data-line-number="6168"></td>
+ <td id="LC6168" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6169" class="blob-num js-line-number" data-line-number="6169"></td>
+ <td id="LC6169" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6170" class="blob-num js-line-number" data-line-number="6170"></td>
+ <td id="LC6170" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isElement(document.body);</span></td>
+ </tr>
+ <tr>
+ <td id="L6171" class="blob-num js-line-number" data-line-number="6171"></td>
+ <td id="LC6171" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6172" class="blob-num js-line-number" data-line-number="6172"></td>
+ <td id="LC6172" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6173" class="blob-num js-line-number" data-line-number="6173"></td>
+ <td id="LC6173" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isElement</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6174" class="blob-num js-line-number" data-line-number="6174"></td>
+ <td id="LC6174" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">&&</span> <span class="pl-smi">value</span>.<span class="pl-c1">nodeType</span> <span class="pl-k">===</span> <span class="pl-c1">1</span> <span class="pl-k">||</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6175" class="blob-num js-line-number" data-line-number="6175"></td>
+ <td id="LC6175" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6176" class="blob-num js-line-number" data-line-number="6176"></td>
+ <td id="LC6176" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6177" class="blob-num js-line-number" data-line-number="6177"></td>
+ <td id="LC6177" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6178" class="blob-num js-line-number" data-line-number="6178"></td>
+ <td id="LC6178" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a</span></td>
+ </tr>
+ <tr>
+ <td id="L6179" class="blob-num js-line-number" data-line-number="6179"></td>
+ <td id="LC6179" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * length of `0` and objects with no own enumerable properties are considered</span></td>
+ </tr>
+ <tr>
+ <td id="L6180" class="blob-num js-line-number" data-line-number="6180"></td>
+ <td id="LC6180" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * "empty".</span></td>
+ </tr>
+ <tr>
+ <td id="L6181" class="blob-num js-line-number" data-line-number="6181"></td>
+ <td id="LC6181" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6182" class="blob-num js-line-number" data-line-number="6182"></td>
+ <td id="LC6182" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6183" class="blob-num js-line-number" data-line-number="6183"></td>
+ <td id="LC6183" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6184" class="blob-num js-line-number" data-line-number="6184"></td>
+ <td id="LC6184" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6185" class="blob-num js-line-number" data-line-number="6185"></td>
+ <td id="LC6185" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} value The value to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L6186" class="blob-num js-line-number" data-line-number="6186"></td>
+ <td id="LC6186" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is empty, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6187" class="blob-num js-line-number" data-line-number="6187"></td>
+ <td id="LC6187" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6188" class="blob-num js-line-number" data-line-number="6188"></td>
+ <td id="LC6188" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6189" class="blob-num js-line-number" data-line-number="6189"></td>
+ <td id="LC6189" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isEmpty([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L6190" class="blob-num js-line-number" data-line-number="6190"></td>
+ <td id="LC6190" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6191" class="blob-num js-line-number" data-line-number="6191"></td>
+ <td id="LC6191" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6192" class="blob-num js-line-number" data-line-number="6192"></td>
+ <td id="LC6192" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isEmpty({});</span></td>
+ </tr>
+ <tr>
+ <td id="L6193" class="blob-num js-line-number" data-line-number="6193"></td>
+ <td id="LC6193" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6194" class="blob-num js-line-number" data-line-number="6194"></td>
+ <td id="LC6194" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6195" class="blob-num js-line-number" data-line-number="6195"></td>
+ <td id="LC6195" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isEmpty('');</span></td>
+ </tr>
+ <tr>
+ <td id="L6196" class="blob-num js-line-number" data-line-number="6196"></td>
+ <td id="LC6196" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6197" class="blob-num js-line-number" data-line-number="6197"></td>
+ <td id="LC6197" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6198" class="blob-num js-line-number" data-line-number="6198"></td>
+ <td id="LC6198" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isEmpty</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6199" class="blob-num js-line-number" data-line-number="6199"></td>
+ <td id="LC6199" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6200" class="blob-num js-line-number" data-line-number="6200"></td>
+ <td id="LC6200" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>value) {</td>
+ </tr>
+ <tr>
+ <td id="L6201" class="blob-num js-line-number" data-line-number="6201"></td>
+ <td id="LC6201" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6202" class="blob-num js-line-number" data-line-number="6202"></td>
+ <td id="LC6202" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6203" class="blob-num js-line-number" data-line-number="6203"></td>
+ <td id="LC6203" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> className <span class="pl-k">=</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value),</td>
+ </tr>
+ <tr>
+ <td id="L6204" class="blob-num js-line-number" data-line-number="6204"></td>
+ <td id="LC6204" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6205" class="blob-num js-line-number" data-line-number="6205"></td>
+ <td id="LC6205" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6206" class="blob-num js-line-number" data-line-number="6206"></td>
+ <td id="LC6206" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((className <span class="pl-k">==</span> arrayClass <span class="pl-k">||</span> className <span class="pl-k">==</span> stringClass <span class="pl-k">||</span> className <span class="pl-k">==</span> argsClass ) <span class="pl-k">||</span></td>
+ </tr>
+ <tr>
+ <td id="L6207" class="blob-num js-line-number" data-line-number="6207"></td>
+ <td id="LC6207" class="blob-code blob-code-inner js-file-line"> (className <span class="pl-k">==</span> objectClass <span class="pl-k">&&</span> <span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-en">isFunction</span>(<span class="pl-smi">value</span>.<span class="pl-smi">splice</span>))) {</td>
+ </tr>
+ <tr>
+ <td id="L6208" class="blob-num js-line-number" data-line-number="6208"></td>
+ <td id="LC6208" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!</span>length;</td>
+ </tr>
+ <tr>
+ <td id="L6209" class="blob-num js-line-number" data-line-number="6209"></td>
+ <td id="LC6209" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6210" class="blob-num js-line-number" data-line-number="6210"></td>
+ <td id="LC6210" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(value, <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L6211" class="blob-num js-line-number" data-line-number="6211"></td>
+ <td id="LC6211" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (result <span class="pl-k">=</span> <span class="pl-c1">false</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6212" class="blob-num js-line-number" data-line-number="6212"></td>
+ <td id="LC6212" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6213" class="blob-num js-line-number" data-line-number="6213"></td>
+ <td id="LC6213" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6214" class="blob-num js-line-number" data-line-number="6214"></td>
+ <td id="LC6214" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6215" class="blob-num js-line-number" data-line-number="6215"></td>
+ <td id="LC6215" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6216" class="blob-num js-line-number" data-line-number="6216"></td>
+ <td id="LC6216" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6217" class="blob-num js-line-number" data-line-number="6217"></td>
+ <td id="LC6217" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Performs a deep comparison between two values to determine if they are</span></td>
+ </tr>
+ <tr>
+ <td id="L6218" class="blob-num js-line-number" data-line-number="6218"></td>
+ <td id="LC6218" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * equivalent to each other. If a callback is provided it will be executed</span></td>
+ </tr>
+ <tr>
+ <td id="L6219" class="blob-num js-line-number" data-line-number="6219"></td>
+ <td id="LC6219" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to compare values. If the callback returns `undefined` comparisons will</span></td>
+ </tr>
+ <tr>
+ <td id="L6220" class="blob-num js-line-number" data-line-number="6220"></td>
+ <td id="LC6220" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * be handled by the method instead. The callback is bound to `thisArg` and</span></td>
+ </tr>
+ <tr>
+ <td id="L6221" class="blob-num js-line-number" data-line-number="6221"></td>
+ <td id="LC6221" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked with two arguments; (a, b).</span></td>
+ </tr>
+ <tr>
+ <td id="L6222" class="blob-num js-line-number" data-line-number="6222"></td>
+ <td id="LC6222" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6223" class="blob-num js-line-number" data-line-number="6223"></td>
+ <td id="LC6223" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6224" class="blob-num js-line-number" data-line-number="6224"></td>
+ <td id="LC6224" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6225" class="blob-num js-line-number" data-line-number="6225"></td>
+ <td id="LC6225" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6226" class="blob-num js-line-number" data-line-number="6226"></td>
+ <td id="LC6226" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} a The value to compare.</span></td>
+ </tr>
+ <tr>
+ <td id="L6227" class="blob-num js-line-number" data-line-number="6227"></td>
+ <td id="LC6227" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} b The other value to compare.</span></td>
+ </tr>
+ <tr>
+ <td id="L6228" class="blob-num js-line-number" data-line-number="6228"></td>
+ <td id="LC6228" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize comparing values.</span></td>
+ </tr>
+ <tr>
+ <td id="L6229" class="blob-num js-line-number" data-line-number="6229"></td>
+ <td id="LC6229" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6230" class="blob-num js-line-number" data-line-number="6230"></td>
+ <td id="LC6230" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the values are equivalent, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6231" class="blob-num js-line-number" data-line-number="6231"></td>
+ <td id="LC6231" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6232" class="blob-num js-line-number" data-line-number="6232"></td>
+ <td id="LC6232" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6233" class="blob-num js-line-number" data-line-number="6233"></td>
+ <td id="LC6233" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = { 'name': 'fred' };</span></td>
+ </tr>
+ <tr>
+ <td id="L6234" class="blob-num js-line-number" data-line-number="6234"></td>
+ <td id="LC6234" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var copy = { 'name': 'fred' };</span></td>
+ </tr>
+ <tr>
+ <td id="L6235" class="blob-num js-line-number" data-line-number="6235"></td>
+ <td id="LC6235" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6236" class="blob-num js-line-number" data-line-number="6236"></td>
+ <td id="LC6236" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object == copy;</span></td>
+ </tr>
+ <tr>
+ <td id="L6237" class="blob-num js-line-number" data-line-number="6237"></td>
+ <td id="LC6237" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6238" class="blob-num js-line-number" data-line-number="6238"></td>
+ <td id="LC6238" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6239" class="blob-num js-line-number" data-line-number="6239"></td>
+ <td id="LC6239" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isEqual(object, copy);</span></td>
+ </tr>
+ <tr>
+ <td id="L6240" class="blob-num js-line-number" data-line-number="6240"></td>
+ <td id="LC6240" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6241" class="blob-num js-line-number" data-line-number="6241"></td>
+ <td id="LC6241" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6242" class="blob-num js-line-number" data-line-number="6242"></td>
+ <td id="LC6242" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var words = ['hello', 'goodbye'];</span></td>
+ </tr>
+ <tr>
+ <td id="L6243" class="blob-num js-line-number" data-line-number="6243"></td>
+ <td id="LC6243" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var otherWords = ['hi', 'goodbye'];</span></td>
+ </tr>
+ <tr>
+ <td id="L6244" class="blob-num js-line-number" data-line-number="6244"></td>
+ <td id="LC6244" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6245" class="blob-num js-line-number" data-line-number="6245"></td>
+ <td id="LC6245" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isEqual(words, otherWords, function(a, b) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6246" class="blob-num js-line-number" data-line-number="6246"></td>
+ <td id="LC6246" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var reGreet = /^(?:hello|hi)$/i,</span></td>
+ </tr>
+ <tr>
+ <td id="L6247" class="blob-num js-line-number" data-line-number="6247"></td>
+ <td id="LC6247" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * aGreet = _.isString(a) && reGreet.test(a),</span></td>
+ </tr>
+ <tr>
+ <td id="L6248" class="blob-num js-line-number" data-line-number="6248"></td>
+ <td id="LC6248" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * bGreet = _.isString(b) && reGreet.test(b);</span></td>
+ </tr>
+ <tr>
+ <td id="L6249" class="blob-num js-line-number" data-line-number="6249"></td>
+ <td id="LC6249" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6250" class="blob-num js-line-number" data-line-number="6250"></td>
+ <td id="LC6250" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;</span></td>
+ </tr>
+ <tr>
+ <td id="L6251" class="blob-num js-line-number" data-line-number="6251"></td>
+ <td id="LC6251" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6252" class="blob-num js-line-number" data-line-number="6252"></td>
+ <td id="LC6252" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6253" class="blob-num js-line-number" data-line-number="6253"></td>
+ <td id="LC6253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6254" class="blob-num js-line-number" data-line-number="6254"></td>
+ <td id="LC6254" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isEqual</span>(<span class="pl-smi">a</span>, <span class="pl-smi">b</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6255" class="blob-num js-line-number" data-line-number="6255"></td>
+ <td id="LC6255" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseIsEqual</span>(a, b, <span class="pl-k">typeof</span> callback <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">2</span>));</td>
+ </tr>
+ <tr>
+ <td id="L6256" class="blob-num js-line-number" data-line-number="6256"></td>
+ <td id="LC6256" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6257" class="blob-num js-line-number" data-line-number="6257"></td>
+ <td id="LC6257" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6258" class="blob-num js-line-number" data-line-number="6258"></td>
+ <td id="LC6258" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6259" class="blob-num js-line-number" data-line-number="6259"></td>
+ <td id="LC6259" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is, or can be coerced to, a finite number.</span></td>
+ </tr>
+ <tr>
+ <td id="L6260" class="blob-num js-line-number" data-line-number="6260"></td>
+ <td id="LC6260" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6261" class="blob-num js-line-number" data-line-number="6261"></td>
+ <td id="LC6261" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: This is not the same as native `isFinite` which will return true for</span></td>
+ </tr>
+ <tr>
+ <td id="L6262" class="blob-num js-line-number" data-line-number="6262"></td>
+ <td id="LC6262" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * booleans and empty strings. See http://es5.github.io/#x15.1.2.5.</span></td>
+ </tr>
+ <tr>
+ <td id="L6263" class="blob-num js-line-number" data-line-number="6263"></td>
+ <td id="LC6263" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6264" class="blob-num js-line-number" data-line-number="6264"></td>
+ <td id="LC6264" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6265" class="blob-num js-line-number" data-line-number="6265"></td>
+ <td id="LC6265" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6266" class="blob-num js-line-number" data-line-number="6266"></td>
+ <td id="LC6266" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6267" class="blob-num js-line-number" data-line-number="6267"></td>
+ <td id="LC6267" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6268" class="blob-num js-line-number" data-line-number="6268"></td>
+ <td id="LC6268" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is finite, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6269" class="blob-num js-line-number" data-line-number="6269"></td>
+ <td id="LC6269" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6270" class="blob-num js-line-number" data-line-number="6270"></td>
+ <td id="LC6270" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6271" class="blob-num js-line-number" data-line-number="6271"></td>
+ <td id="LC6271" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isFinite(-101);</span></td>
+ </tr>
+ <tr>
+ <td id="L6272" class="blob-num js-line-number" data-line-number="6272"></td>
+ <td id="LC6272" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6273" class="blob-num js-line-number" data-line-number="6273"></td>
+ <td id="LC6273" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6274" class="blob-num js-line-number" data-line-number="6274"></td>
+ <td id="LC6274" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isFinite('10');</span></td>
+ </tr>
+ <tr>
+ <td id="L6275" class="blob-num js-line-number" data-line-number="6275"></td>
+ <td id="LC6275" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6276" class="blob-num js-line-number" data-line-number="6276"></td>
+ <td id="LC6276" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6277" class="blob-num js-line-number" data-line-number="6277"></td>
+ <td id="LC6277" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isFinite(true);</span></td>
+ </tr>
+ <tr>
+ <td id="L6278" class="blob-num js-line-number" data-line-number="6278"></td>
+ <td id="LC6278" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6279" class="blob-num js-line-number" data-line-number="6279"></td>
+ <td id="LC6279" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6280" class="blob-num js-line-number" data-line-number="6280"></td>
+ <td id="LC6280" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isFinite('');</span></td>
+ </tr>
+ <tr>
+ <td id="L6281" class="blob-num js-line-number" data-line-number="6281"></td>
+ <td id="LC6281" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6282" class="blob-num js-line-number" data-line-number="6282"></td>
+ <td id="LC6282" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6283" class="blob-num js-line-number" data-line-number="6283"></td>
+ <td id="LC6283" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isFinite(Infinity);</span></td>
+ </tr>
+ <tr>
+ <td id="L6284" class="blob-num js-line-number" data-line-number="6284"></td>
+ <td id="LC6284" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6285" class="blob-num js-line-number" data-line-number="6285"></td>
+ <td id="LC6285" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6286" class="blob-num js-line-number" data-line-number="6286"></td>
+ <td id="LC6286" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isFinite</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6287" class="blob-num js-line-number" data-line-number="6287"></td>
+ <td id="LC6287" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">nativeIsFinite</span>(value) <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-en">nativeIsNaN</span>(<span class="pl-c1">parseFloat</span>(value));</td>
+ </tr>
+ <tr>
+ <td id="L6288" class="blob-num js-line-number" data-line-number="6288"></td>
+ <td id="LC6288" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6289" class="blob-num js-line-number" data-line-number="6289"></td>
+ <td id="LC6289" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6290" class="blob-num js-line-number" data-line-number="6290"></td>
+ <td id="LC6290" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6291" class="blob-num js-line-number" data-line-number="6291"></td>
+ <td id="LC6291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a function.</span></td>
+ </tr>
+ <tr>
+ <td id="L6292" class="blob-num js-line-number" data-line-number="6292"></td>
+ <td id="LC6292" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6293" class="blob-num js-line-number" data-line-number="6293"></td>
+ <td id="LC6293" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6294" class="blob-num js-line-number" data-line-number="6294"></td>
+ <td id="LC6294" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6295" class="blob-num js-line-number" data-line-number="6295"></td>
+ <td id="LC6295" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6296" class="blob-num js-line-number" data-line-number="6296"></td>
+ <td id="LC6296" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6297" class="blob-num js-line-number" data-line-number="6297"></td>
+ <td id="LC6297" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a function, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6298" class="blob-num js-line-number" data-line-number="6298"></td>
+ <td id="LC6298" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6299" class="blob-num js-line-number" data-line-number="6299"></td>
+ <td id="LC6299" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6300" class="blob-num js-line-number" data-line-number="6300"></td>
+ <td id="LC6300" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isFunction(_);</span></td>
+ </tr>
+ <tr>
+ <td id="L6301" class="blob-num js-line-number" data-line-number="6301"></td>
+ <td id="LC6301" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6302" class="blob-num js-line-number" data-line-number="6302"></td>
+ <td id="LC6302" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6303" class="blob-num js-line-number" data-line-number="6303"></td>
+ <td id="LC6303" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isFunction</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6304" class="blob-num js-line-number" data-line-number="6304"></td>
+ <td id="LC6304" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L6305" class="blob-num js-line-number" data-line-number="6305"></td>
+ <td id="LC6305" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6306" class="blob-num js-line-number" data-line-number="6306"></td>
+ <td id="LC6306" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6307" class="blob-num js-line-number" data-line-number="6307"></td>
+ <td id="LC6307" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6308" class="blob-num js-line-number" data-line-number="6308"></td>
+ <td id="LC6308" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is the language type of Object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6309" class="blob-num js-line-number" data-line-number="6309"></td>
+ <td id="LC6309" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)</span></td>
+ </tr>
+ <tr>
+ <td id="L6310" class="blob-num js-line-number" data-line-number="6310"></td>
+ <td id="LC6310" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6311" class="blob-num js-line-number" data-line-number="6311"></td>
+ <td id="LC6311" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6312" class="blob-num js-line-number" data-line-number="6312"></td>
+ <td id="LC6312" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6313" class="blob-num js-line-number" data-line-number="6313"></td>
+ <td id="LC6313" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6314" class="blob-num js-line-number" data-line-number="6314"></td>
+ <td id="LC6314" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6315" class="blob-num js-line-number" data-line-number="6315"></td>
+ <td id="LC6315" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is an object, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6316" class="blob-num js-line-number" data-line-number="6316"></td>
+ <td id="LC6316" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6317" class="blob-num js-line-number" data-line-number="6317"></td>
+ <td id="LC6317" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6318" class="blob-num js-line-number" data-line-number="6318"></td>
+ <td id="LC6318" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isObject({});</span></td>
+ </tr>
+ <tr>
+ <td id="L6319" class="blob-num js-line-number" data-line-number="6319"></td>
+ <td id="LC6319" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6320" class="blob-num js-line-number" data-line-number="6320"></td>
+ <td id="LC6320" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6321" class="blob-num js-line-number" data-line-number="6321"></td>
+ <td id="LC6321" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isObject([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L6322" class="blob-num js-line-number" data-line-number="6322"></td>
+ <td id="LC6322" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6323" class="blob-num js-line-number" data-line-number="6323"></td>
+ <td id="LC6323" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6324" class="blob-num js-line-number" data-line-number="6324"></td>
+ <td id="LC6324" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isObject(1);</span></td>
+ </tr>
+ <tr>
+ <td id="L6325" class="blob-num js-line-number" data-line-number="6325"></td>
+ <td id="LC6325" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6326" class="blob-num js-line-number" data-line-number="6326"></td>
+ <td id="LC6326" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6327" class="blob-num js-line-number" data-line-number="6327"></td>
+ <td id="LC6327" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isObject</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6328" class="blob-num js-line-number" data-line-number="6328"></td>
+ <td id="LC6328" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// check if the value is the ECMAScript language type of Object</span></td>
+ </tr>
+ <tr>
+ <td id="L6329" class="blob-num js-line-number" data-line-number="6329"></td>
+ <td id="LC6329" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://es5.github.io/#x8</span></td>
+ </tr>
+ <tr>
+ <td id="L6330" class="blob-num js-line-number" data-line-number="6330"></td>
+ <td id="LC6330" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// and avoid a V8 bug</span></td>
+ </tr>
+ <tr>
+ <td id="L6331" class="blob-num js-line-number" data-line-number="6331"></td>
+ <td id="LC6331" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://code.google.com/p/v8/issues/detail?id=2291</span></td>
+ </tr>
+ <tr>
+ <td id="L6332" class="blob-num js-line-number" data-line-number="6332"></td>
+ <td id="LC6332" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!!</span>(value <span class="pl-k">&&</span> objectTypes[<span class="pl-k">typeof</span> value]);</td>
+ </tr>
+ <tr>
+ <td id="L6333" class="blob-num js-line-number" data-line-number="6333"></td>
+ <td id="LC6333" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6334" class="blob-num js-line-number" data-line-number="6334"></td>
+ <td id="LC6334" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6335" class="blob-num js-line-number" data-line-number="6335"></td>
+ <td id="LC6335" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6336" class="blob-num js-line-number" data-line-number="6336"></td>
+ <td id="LC6336" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is `NaN`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6337" class="blob-num js-line-number" data-line-number="6337"></td>
+ <td id="LC6337" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6338" class="blob-num js-line-number" data-line-number="6338"></td>
+ <td id="LC6338" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: This is not the same as native `isNaN` which will return `true` for</span></td>
+ </tr>
+ <tr>
+ <td id="L6339" class="blob-num js-line-number" data-line-number="6339"></td>
+ <td id="LC6339" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4.</span></td>
+ </tr>
+ <tr>
+ <td id="L6340" class="blob-num js-line-number" data-line-number="6340"></td>
+ <td id="LC6340" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6341" class="blob-num js-line-number" data-line-number="6341"></td>
+ <td id="LC6341" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6342" class="blob-num js-line-number" data-line-number="6342"></td>
+ <td id="LC6342" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6343" class="blob-num js-line-number" data-line-number="6343"></td>
+ <td id="LC6343" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6344" class="blob-num js-line-number" data-line-number="6344"></td>
+ <td id="LC6344" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6345" class="blob-num js-line-number" data-line-number="6345"></td>
+ <td id="LC6345" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is `NaN`, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6346" class="blob-num js-line-number" data-line-number="6346"></td>
+ <td id="LC6346" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6347" class="blob-num js-line-number" data-line-number="6347"></td>
+ <td id="LC6347" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6348" class="blob-num js-line-number" data-line-number="6348"></td>
+ <td id="LC6348" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isNaN(NaN);</span></td>
+ </tr>
+ <tr>
+ <td id="L6349" class="blob-num js-line-number" data-line-number="6349"></td>
+ <td id="LC6349" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6350" class="blob-num js-line-number" data-line-number="6350"></td>
+ <td id="LC6350" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6351" class="blob-num js-line-number" data-line-number="6351"></td>
+ <td id="LC6351" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isNaN(new Number(NaN));</span></td>
+ </tr>
+ <tr>
+ <td id="L6352" class="blob-num js-line-number" data-line-number="6352"></td>
+ <td id="LC6352" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6353" class="blob-num js-line-number" data-line-number="6353"></td>
+ <td id="LC6353" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6354" class="blob-num js-line-number" data-line-number="6354"></td>
+ <td id="LC6354" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * isNaN(undefined);</span></td>
+ </tr>
+ <tr>
+ <td id="L6355" class="blob-num js-line-number" data-line-number="6355"></td>
+ <td id="LC6355" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6356" class="blob-num js-line-number" data-line-number="6356"></td>
+ <td id="LC6356" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6357" class="blob-num js-line-number" data-line-number="6357"></td>
+ <td id="LC6357" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isNaN(undefined);</span></td>
+ </tr>
+ <tr>
+ <td id="L6358" class="blob-num js-line-number" data-line-number="6358"></td>
+ <td id="LC6358" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6359" class="blob-num js-line-number" data-line-number="6359"></td>
+ <td id="LC6359" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6360" class="blob-num js-line-number" data-line-number="6360"></td>
+ <td id="LC6360" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isNaN</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6361" class="blob-num js-line-number" data-line-number="6361"></td>
+ <td id="LC6361" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// `NaN` as a primitive is the only value that is not equal to itself</span></td>
+ </tr>
+ <tr>
+ <td id="L6362" class="blob-num js-line-number" data-line-number="6362"></td>
+ <td id="LC6362" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// (perform the [[Class]] check first to avoid errors with some host objects in IE)</span></td>
+ </tr>
+ <tr>
+ <td id="L6363" class="blob-num js-line-number" data-line-number="6363"></td>
+ <td id="LC6363" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">isNumber</span>(value) <span class="pl-k">&&</span> value <span class="pl-k">!=</span> <span class="pl-k">+</span>value;</td>
+ </tr>
+ <tr>
+ <td id="L6364" class="blob-num js-line-number" data-line-number="6364"></td>
+ <td id="LC6364" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6365" class="blob-num js-line-number" data-line-number="6365"></td>
+ <td id="LC6365" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6366" class="blob-num js-line-number" data-line-number="6366"></td>
+ <td id="LC6366" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6367" class="blob-num js-line-number" data-line-number="6367"></td>
+ <td id="LC6367" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is `null`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6368" class="blob-num js-line-number" data-line-number="6368"></td>
+ <td id="LC6368" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6369" class="blob-num js-line-number" data-line-number="6369"></td>
+ <td id="LC6369" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6370" class="blob-num js-line-number" data-line-number="6370"></td>
+ <td id="LC6370" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6371" class="blob-num js-line-number" data-line-number="6371"></td>
+ <td id="LC6371" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6372" class="blob-num js-line-number" data-line-number="6372"></td>
+ <td id="LC6372" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6373" class="blob-num js-line-number" data-line-number="6373"></td>
+ <td id="LC6373" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is `null`, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6374" class="blob-num js-line-number" data-line-number="6374"></td>
+ <td id="LC6374" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6375" class="blob-num js-line-number" data-line-number="6375"></td>
+ <td id="LC6375" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6376" class="blob-num js-line-number" data-line-number="6376"></td>
+ <td id="LC6376" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isNull(null);</span></td>
+ </tr>
+ <tr>
+ <td id="L6377" class="blob-num js-line-number" data-line-number="6377"></td>
+ <td id="LC6377" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6378" class="blob-num js-line-number" data-line-number="6378"></td>
+ <td id="LC6378" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6379" class="blob-num js-line-number" data-line-number="6379"></td>
+ <td id="LC6379" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isNull(undefined);</span></td>
+ </tr>
+ <tr>
+ <td id="L6380" class="blob-num js-line-number" data-line-number="6380"></td>
+ <td id="LC6380" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6381" class="blob-num js-line-number" data-line-number="6381"></td>
+ <td id="LC6381" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6382" class="blob-num js-line-number" data-line-number="6382"></td>
+ <td id="LC6382" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isNull</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6383" class="blob-num js-line-number" data-line-number="6383"></td>
+ <td id="LC6383" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">===</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6384" class="blob-num js-line-number" data-line-number="6384"></td>
+ <td id="LC6384" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6385" class="blob-num js-line-number" data-line-number="6385"></td>
+ <td id="LC6385" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6386" class="blob-num js-line-number" data-line-number="6386"></td>
+ <td id="LC6386" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6387" class="blob-num js-line-number" data-line-number="6387"></td>
+ <td id="LC6387" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a number.</span></td>
+ </tr>
+ <tr>
+ <td id="L6388" class="blob-num js-line-number" data-line-number="6388"></td>
+ <td id="LC6388" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6389" class="blob-num js-line-number" data-line-number="6389"></td>
+ <td id="LC6389" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5.</span></td>
+ </tr>
+ <tr>
+ <td id="L6390" class="blob-num js-line-number" data-line-number="6390"></td>
+ <td id="LC6390" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6391" class="blob-num js-line-number" data-line-number="6391"></td>
+ <td id="LC6391" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6392" class="blob-num js-line-number" data-line-number="6392"></td>
+ <td id="LC6392" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6393" class="blob-num js-line-number" data-line-number="6393"></td>
+ <td id="LC6393" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6394" class="blob-num js-line-number" data-line-number="6394"></td>
+ <td id="LC6394" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6395" class="blob-num js-line-number" data-line-number="6395"></td>
+ <td id="LC6395" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a number, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6396" class="blob-num js-line-number" data-line-number="6396"></td>
+ <td id="LC6396" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6397" class="blob-num js-line-number" data-line-number="6397"></td>
+ <td id="LC6397" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6398" class="blob-num js-line-number" data-line-number="6398"></td>
+ <td id="LC6398" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isNumber(8.4 * 5);</span></td>
+ </tr>
+ <tr>
+ <td id="L6399" class="blob-num js-line-number" data-line-number="6399"></td>
+ <td id="LC6399" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6400" class="blob-num js-line-number" data-line-number="6400"></td>
+ <td id="LC6400" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6401" class="blob-num js-line-number" data-line-number="6401"></td>
+ <td id="LC6401" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isNumber</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6402" class="blob-num js-line-number" data-line-number="6402"></td>
+ <td id="LC6402" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">||</span></td>
+ </tr>
+ <tr>
+ <td id="L6403" class="blob-num js-line-number" data-line-number="6403"></td>
+ <td id="LC6403" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> numberClass <span class="pl-k">||</span> <span class="pl-c1"> [...]
+ </tr>
+ <tr>
+ <td id="L6404" class="blob-num js-line-number" data-line-number="6404"></td>
+ <td id="LC6404" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6405" class="blob-num js-line-number" data-line-number="6405"></td>
+ <td id="LC6405" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6406" class="blob-num js-line-number" data-line-number="6406"></td>
+ <td id="LC6406" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6407" class="blob-num js-line-number" data-line-number="6407"></td>
+ <td id="LC6407" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is an object created by the `Object` constructor.</span></td>
+ </tr>
+ <tr>
+ <td id="L6408" class="blob-num js-line-number" data-line-number="6408"></td>
+ <td id="LC6408" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6409" class="blob-num js-line-number" data-line-number="6409"></td>
+ <td id="LC6409" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6410" class="blob-num js-line-number" data-line-number="6410"></td>
+ <td id="LC6410" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6411" class="blob-num js-line-number" data-line-number="6411"></td>
+ <td id="LC6411" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6412" class="blob-num js-line-number" data-line-number="6412"></td>
+ <td id="LC6412" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6413" class="blob-num js-line-number" data-line-number="6413"></td>
+ <td id="LC6413" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if `value` is a plain object, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6414" class="blob-num js-line-number" data-line-number="6414"></td>
+ <td id="LC6414" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6415" class="blob-num js-line-number" data-line-number="6415"></td>
+ <td id="LC6415" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6416" class="blob-num js-line-number" data-line-number="6416"></td>
+ <td id="LC6416" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function Shape() {</span></td>
+ </tr>
+ <tr>
+ <td id="L6417" class="blob-num js-line-number" data-line-number="6417"></td>
+ <td id="LC6417" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.x = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L6418" class="blob-num js-line-number" data-line-number="6418"></td>
+ <td id="LC6418" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * this.y = 0;</span></td>
+ </tr>
+ <tr>
+ <td id="L6419" class="blob-num js-line-number" data-line-number="6419"></td>
+ <td id="LC6419" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L6420" class="blob-num js-line-number" data-line-number="6420"></td>
+ <td id="LC6420" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6421" class="blob-num js-line-number" data-line-number="6421"></td>
+ <td id="LC6421" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isPlainObject(new Shape);</span></td>
+ </tr>
+ <tr>
+ <td id="L6422" class="blob-num js-line-number" data-line-number="6422"></td>
+ <td id="LC6422" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6423" class="blob-num js-line-number" data-line-number="6423"></td>
+ <td id="LC6423" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6424" class="blob-num js-line-number" data-line-number="6424"></td>
+ <td id="LC6424" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isPlainObject([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L6425" class="blob-num js-line-number" data-line-number="6425"></td>
+ <td id="LC6425" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6426" class="blob-num js-line-number" data-line-number="6426"></td>
+ <td id="LC6426" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6427" class="blob-num js-line-number" data-line-number="6427"></td>
+ <td id="LC6427" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isPlainObject({ 'x': 0, 'y': 0 });</span></td>
+ </tr>
+ <tr>
+ <td id="L6428" class="blob-num js-line-number" data-line-number="6428"></td>
+ <td id="LC6428" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6429" class="blob-num js-line-number" data-line-number="6429"></td>
+ <td id="LC6429" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6430" class="blob-num js-line-number" data-line-number="6430"></td>
+ <td id="LC6430" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isPlainObject <span class="pl-k">=</span> <span class="pl-k">!</span>getPrototypeOf <span class="pl-k">?</span> <span class="pl-en">shimIsPlainObject</span> <span class="pl-k">:</span> <span class="pl-k">function</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6431" class="blob-num js-line-number" data-line-number="6431"></td>
+ <td id="LC6431" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>(value <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> objectClass)) {</td>
+ </tr>
+ <tr>
+ <td id="L6432" class="blob-num js-line-number" data-line-number="6432"></td>
+ <td id="LC6432" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6433" class="blob-num js-line-number" data-line-number="6433"></td>
+ <td id="LC6433" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6434" class="blob-num js-line-number" data-line-number="6434"></td>
+ <td id="LC6434" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> valueOf <span class="pl-k">=</span> <span class="pl-smi">value</span>.<span class="pl-smi">valueOf</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6435" class="blob-num js-line-number" data-line-number="6435"></td>
+ <td id="LC6435" class="blob-code blob-code-inner js-file-line"> objProto <span class="pl-k">=</span> <span class="pl-en">isNative</span>(valueOf) <span class="pl-k">&&</span> (objProto <span class="pl-k">=</span> <span class="pl-en">getPrototypeOf</span>(valueOf)) <span class="pl-k">&&</span> <span class="pl-en">getPrototypeOf</span>(objProto);</td>
+ </tr>
+ <tr>
+ <td id="L6436" class="blob-num js-line-number" data-line-number="6436"></td>
+ <td id="LC6436" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6437" class="blob-num js-line-number" data-line-number="6437"></td>
+ <td id="LC6437" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> objProto</td>
+ </tr>
+ <tr>
+ <td id="L6438" class="blob-num js-line-number" data-line-number="6438"></td>
+ <td id="LC6438" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> (value <span class="pl-k">==</span> objProto <span class="pl-k">||</span> <span class="pl-en">getPrototypeOf</span>(value) <span class="pl-k">==</span> objProto)</td>
+ </tr>
+ <tr>
+ <td id="L6439" class="blob-num js-line-number" data-line-number="6439"></td>
+ <td id="LC6439" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">shimIsPlainObject</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L6440" class="blob-num js-line-number" data-line-number="6440"></td>
+ <td id="LC6440" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L6441" class="blob-num js-line-number" data-line-number="6441"></td>
+ <td id="LC6441" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6442" class="blob-num js-line-number" data-line-number="6442"></td>
+ <td id="LC6442" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6443" class="blob-num js-line-number" data-line-number="6443"></td>
+ <td id="LC6443" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a regular expression.</span></td>
+ </tr>
+ <tr>
+ <td id="L6444" class="blob-num js-line-number" data-line-number="6444"></td>
+ <td id="LC6444" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6445" class="blob-num js-line-number" data-line-number="6445"></td>
+ <td id="LC6445" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6446" class="blob-num js-line-number" data-line-number="6446"></td>
+ <td id="LC6446" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6447" class="blob-num js-line-number" data-line-number="6447"></td>
+ <td id="LC6447" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6448" class="blob-num js-line-number" data-line-number="6448"></td>
+ <td id="LC6448" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6449" class="blob-num js-line-number" data-line-number="6449"></td>
+ <td id="LC6449" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a regular expression, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6450" class="blob-num js-line-number" data-line-number="6450"></td>
+ <td id="LC6450" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6451" class="blob-num js-line-number" data-line-number="6451"></td>
+ <td id="LC6451" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6452" class="blob-num js-line-number" data-line-number="6452"></td>
+ <td id="LC6452" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isRegExp(/fred/);</span></td>
+ </tr>
+ <tr>
+ <td id="L6453" class="blob-num js-line-number" data-line-number="6453"></td>
+ <td id="LC6453" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6454" class="blob-num js-line-number" data-line-number="6454"></td>
+ <td id="LC6454" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6455" class="blob-num js-line-number" data-line-number="6455"></td>
+ <td id="LC6455" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isRegExp</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6456" class="blob-num js-line-number" data-line-number="6456"></td>
+ <td id="LC6456" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> regexpClass <span class="pl-k" [...]
+ </tr>
+ <tr>
+ <td id="L6457" class="blob-num js-line-number" data-line-number="6457"></td>
+ <td id="LC6457" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6458" class="blob-num js-line-number" data-line-number="6458"></td>
+ <td id="LC6458" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6459" class="blob-num js-line-number" data-line-number="6459"></td>
+ <td id="LC6459" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6460" class="blob-num js-line-number" data-line-number="6460"></td>
+ <td id="LC6460" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is a string.</span></td>
+ </tr>
+ <tr>
+ <td id="L6461" class="blob-num js-line-number" data-line-number="6461"></td>
+ <td id="LC6461" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6462" class="blob-num js-line-number" data-line-number="6462"></td>
+ <td id="LC6462" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6463" class="blob-num js-line-number" data-line-number="6463"></td>
+ <td id="LC6463" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6464" class="blob-num js-line-number" data-line-number="6464"></td>
+ <td id="LC6464" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6465" class="blob-num js-line-number" data-line-number="6465"></td>
+ <td id="LC6465" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6466" class="blob-num js-line-number" data-line-number="6466"></td>
+ <td id="LC6466" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is a string, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6467" class="blob-num js-line-number" data-line-number="6467"></td>
+ <td id="LC6467" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6468" class="blob-num js-line-number" data-line-number="6468"></td>
+ <td id="LC6468" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6469" class="blob-num js-line-number" data-line-number="6469"></td>
+ <td id="LC6469" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isString('fred');</span></td>
+ </tr>
+ <tr>
+ <td id="L6470" class="blob-num js-line-number" data-line-number="6470"></td>
+ <td id="LC6470" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6471" class="blob-num js-line-number" data-line-number="6471"></td>
+ <td id="LC6471" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6472" class="blob-num js-line-number" data-line-number="6472"></td>
+ <td id="LC6472" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isString</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6473" class="blob-num js-line-number" data-line-number="6473"></td>
+ <td id="LC6473" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>string<span class="pl-pds">'</span></span> <span class="pl-k">||</span></td>
+ </tr>
+ <tr>
+ <td id="L6474" class="blob-num js-line-number" data-line-number="6474"></td>
+ <td id="LC6474" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">&&</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-smi">toString</span>.<span class="pl-c1">call</span>(value) <span class="pl-k">==</span> stringClass <span class="pl-k">||</span> <span class="pl-c1"> [...]
+ </tr>
+ <tr>
+ <td id="L6475" class="blob-num js-line-number" data-line-number="6475"></td>
+ <td id="LC6475" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6476" class="blob-num js-line-number" data-line-number="6476"></td>
+ <td id="LC6476" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6477" class="blob-num js-line-number" data-line-number="6477"></td>
+ <td id="LC6477" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6478" class="blob-num js-line-number" data-line-number="6478"></td>
+ <td id="LC6478" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if `value` is `undefined`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6479" class="blob-num js-line-number" data-line-number="6479"></td>
+ <td id="LC6479" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6480" class="blob-num js-line-number" data-line-number="6480"></td>
+ <td id="LC6480" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6481" class="blob-num js-line-number" data-line-number="6481"></td>
+ <td id="LC6481" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6482" class="blob-num js-line-number" data-line-number="6482"></td>
+ <td id="LC6482" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6483" class="blob-num js-line-number" data-line-number="6483"></td>
+ <td id="LC6483" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to check.</span></td>
+ </tr>
+ <tr>
+ <td id="L6484" class="blob-num js-line-number" data-line-number="6484"></td>
+ <td id="LC6484" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `value` is `undefined`, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6485" class="blob-num js-line-number" data-line-number="6485"></td>
+ <td id="LC6485" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6486" class="blob-num js-line-number" data-line-number="6486"></td>
+ <td id="LC6486" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6487" class="blob-num js-line-number" data-line-number="6487"></td>
+ <td id="LC6487" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.isUndefined(void 0);</span></td>
+ </tr>
+ <tr>
+ <td id="L6488" class="blob-num js-line-number" data-line-number="6488"></td>
+ <td id="LC6488" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6489" class="blob-num js-line-number" data-line-number="6489"></td>
+ <td id="LC6489" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6490" class="blob-num js-line-number" data-line-number="6490"></td>
+ <td id="LC6490" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">isUndefined</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6491" class="blob-num js-line-number" data-line-number="6491"></td>
+ <td id="LC6491" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> value <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L6492" class="blob-num js-line-number" data-line-number="6492"></td>
+ <td id="LC6492" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6493" class="blob-num js-line-number" data-line-number="6493"></td>
+ <td id="LC6493" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6494" class="blob-num js-line-number" data-line-number="6494"></td>
+ <td id="LC6494" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6495" class="blob-num js-line-number" data-line-number="6495"></td>
+ <td id="LC6495" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object with the same keys as `object` and values generated by</span></td>
+ </tr>
+ <tr>
+ <td id="L6496" class="blob-num js-line-number" data-line-number="6496"></td>
+ <td id="LC6496" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * running each own enumerable property of `object` through the callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L6497" class="blob-num js-line-number" data-line-number="6497"></td>
+ <td id="LC6497" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L6498" class="blob-num js-line-number" data-line-number="6498"></td>
+ <td id="LC6498" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, key, object).</span></td>
+ </tr>
+ <tr>
+ <td id="L6499" class="blob-num js-line-number" data-line-number="6499"></td>
+ <td id="LC6499" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6500" class="blob-num js-line-number" data-line-number="6500"></td>
+ <td id="LC6500" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L6501" class="blob-num js-line-number" data-line-number="6501"></td>
+ <td id="LC6501" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L6502" class="blob-num js-line-number" data-line-number="6502"></td>
+ <td id="LC6502" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6503" class="blob-num js-line-number" data-line-number="6503"></td>
+ <td id="LC6503" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L6504" class="blob-num js-line-number" data-line-number="6504"></td>
+ <td id="LC6504" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L6505" class="blob-num js-line-number" data-line-number="6505"></td>
+ <td id="LC6505" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6506" class="blob-num js-line-number" data-line-number="6506"></td>
+ <td id="LC6506" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6507" class="blob-num js-line-number" data-line-number="6507"></td>
+ <td id="LC6507" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6508" class="blob-num js-line-number" data-line-number="6508"></td>
+ <td id="LC6508" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6509" class="blob-num js-line-number" data-line-number="6509"></td>
+ <td id="LC6509" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6510" class="blob-num js-line-number" data-line-number="6510"></td>
+ <td id="LC6510" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6511" class="blob-num js-line-number" data-line-number="6511"></td>
+ <td id="LC6511" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L6512" class="blob-num js-line-number" data-line-number="6512"></td>
+ <td id="LC6512" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L6513" class="blob-num js-line-number" data-line-number="6513"></td>
+ <td id="LC6513" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L6514" class="blob-num js-line-number" data-line-number="6514"></td>
+ <td id="LC6514" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6515" class="blob-num js-line-number" data-line-number="6515"></td>
+ <td id="LC6515" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new object with values of the results of each `callback` execution.</span></td>
+ </tr>
+ <tr>
+ <td id="L6516" class="blob-num js-line-number" data-line-number="6516"></td>
+ <td id="LC6516" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6517" class="blob-num js-line-number" data-line-number="6517"></td>
+ <td id="LC6517" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6518" class="blob-num js-line-number" data-line-number="6518"></td>
+ <td id="LC6518" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });</span></td>
+ </tr>
+ <tr>
+ <td id="L6519" class="blob-num js-line-number" data-line-number="6519"></td>
+ <td id="LC6519" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'a': 3, 'b': 6, 'c': 9 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6520" class="blob-num js-line-number" data-line-number="6520"></td>
+ <td id="LC6520" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6521" class="blob-num js-line-number" data-line-number="6521"></td>
+ <td id="LC6521" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = {</span></td>
+ </tr>
+ <tr>
+ <td id="L6522" class="blob-num js-line-number" data-line-number="6522"></td>
+ <td id="LC6522" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'fred': { 'name': 'fred', 'age': 40 },</span></td>
+ </tr>
+ <tr>
+ <td id="L6523" class="blob-num js-line-number" data-line-number="6523"></td>
+ <td id="LC6523" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'pebbles': { 'name': 'pebbles', 'age': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6524" class="blob-num js-line-number" data-line-number="6524"></td>
+ <td id="LC6524" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L6525" class="blob-num js-line-number" data-line-number="6525"></td>
+ <td id="LC6525" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6526" class="blob-num js-line-number" data-line-number="6526"></td>
+ <td id="LC6526" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L6527" class="blob-num js-line-number" data-line-number="6527"></td>
+ <td id="LC6527" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.mapValues(characters, 'age');</span></td>
+ </tr>
+ <tr>
+ <td id="L6528" class="blob-num js-line-number" data-line-number="6528"></td>
+ <td id="LC6528" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'fred': 40, 'pebbles': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6529" class="blob-num js-line-number" data-line-number="6529"></td>
+ <td id="LC6529" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6530" class="blob-num js-line-number" data-line-number="6530"></td>
+ <td id="LC6530" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">mapValues</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6531" class="blob-num js-line-number" data-line-number="6531"></td>
+ <td id="LC6531" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L6532" class="blob-num js-line-number" data-line-number="6532"></td>
+ <td id="LC6532" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6533" class="blob-num js-line-number" data-line-number="6533"></td>
+ <td id="LC6533" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6534" class="blob-num js-line-number" data-line-number="6534"></td>
+ <td id="LC6534" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6535" class="blob-num js-line-number" data-line-number="6535"></td>
+ <td id="LC6535" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, key, object);</td>
+ </tr>
+ <tr>
+ <td id="L6536" class="blob-num js-line-number" data-line-number="6536"></td>
+ <td id="LC6536" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6537" class="blob-num js-line-number" data-line-number="6537"></td>
+ <td id="LC6537" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6538" class="blob-num js-line-number" data-line-number="6538"></td>
+ <td id="LC6538" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6539" class="blob-num js-line-number" data-line-number="6539"></td>
+ <td id="LC6539" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6540" class="blob-num js-line-number" data-line-number="6540"></td>
+ <td id="LC6540" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6541" class="blob-num js-line-number" data-line-number="6541"></td>
+ <td id="LC6541" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Recursively merges own enumerable properties of the source object(s), that</span></td>
+ </tr>
+ <tr>
+ <td id="L6542" class="blob-num js-line-number" data-line-number="6542"></td>
+ <td id="LC6542" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * don't resolve to `undefined` into the destination object. Subsequent sources</span></td>
+ </tr>
+ <tr>
+ <td id="L6543" class="blob-num js-line-number" data-line-number="6543"></td>
+ <td id="LC6543" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will overwrite property assignments of previous sources. If a callback is</span></td>
+ </tr>
+ <tr>
+ <td id="L6544" class="blob-num js-line-number" data-line-number="6544"></td>
+ <td id="LC6544" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided it will be executed to produce the merged values of the destination</span></td>
+ </tr>
+ <tr>
+ <td id="L6545" class="blob-num js-line-number" data-line-number="6545"></td>
+ <td id="LC6545" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and source properties. If the callback returns `undefined` merging will</span></td>
+ </tr>
+ <tr>
+ <td id="L6546" class="blob-num js-line-number" data-line-number="6546"></td>
+ <td id="LC6546" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * be handled by the method instead. The callback is bound to `thisArg` and</span></td>
+ </tr>
+ <tr>
+ <td id="L6547" class="blob-num js-line-number" data-line-number="6547"></td>
+ <td id="LC6547" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked with two arguments; (objectValue, sourceValue).</span></td>
+ </tr>
+ <tr>
+ <td id="L6548" class="blob-num js-line-number" data-line-number="6548"></td>
+ <td id="LC6548" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6549" class="blob-num js-line-number" data-line-number="6549"></td>
+ <td id="LC6549" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6550" class="blob-num js-line-number" data-line-number="6550"></td>
+ <td id="LC6550" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6551" class="blob-num js-line-number" data-line-number="6551"></td>
+ <td id="LC6551" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6552" class="blob-num js-line-number" data-line-number="6552"></td>
+ <td id="LC6552" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6553" class="blob-num js-line-number" data-line-number="6553"></td>
+ <td id="LC6553" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Object} [source] The source objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L6554" class="blob-num js-line-number" data-line-number="6554"></td>
+ <td id="LC6554" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback] The function to customize merging properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L6555" class="blob-num js-line-number" data-line-number="6555"></td>
+ <td id="LC6555" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6556" class="blob-num js-line-number" data-line-number="6556"></td>
+ <td id="LC6556" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6557" class="blob-num js-line-number" data-line-number="6557"></td>
+ <td id="LC6557" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6558" class="blob-num js-line-number" data-line-number="6558"></td>
+ <td id="LC6558" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6559" class="blob-num js-line-number" data-line-number="6559"></td>
+ <td id="LC6559" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var names = {</span></td>
+ </tr>
+ <tr>
+ <td id="L6560" class="blob-num js-line-number" data-line-number="6560"></td>
+ <td id="LC6560" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'characters': [</span></td>
+ </tr>
+ <tr>
+ <td id="L6561" class="blob-num js-line-number" data-line-number="6561"></td>
+ <td id="LC6561" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney' },</span></td>
+ </tr>
+ <tr>
+ <td id="L6562" class="blob-num js-line-number" data-line-number="6562"></td>
+ <td id="LC6562" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred' }</span></td>
+ </tr>
+ <tr>
+ <td id="L6563" class="blob-num js-line-number" data-line-number="6563"></td>
+ <td id="LC6563" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ]</span></td>
+ </tr>
+ <tr>
+ <td id="L6564" class="blob-num js-line-number" data-line-number="6564"></td>
+ <td id="LC6564" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L6565" class="blob-num js-line-number" data-line-number="6565"></td>
+ <td id="LC6565" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6566" class="blob-num js-line-number" data-line-number="6566"></td>
+ <td id="LC6566" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var ages = {</span></td>
+ </tr>
+ <tr>
+ <td id="L6567" class="blob-num js-line-number" data-line-number="6567"></td>
+ <td id="LC6567" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'characters': [</span></td>
+ </tr>
+ <tr>
+ <td id="L6568" class="blob-num js-line-number" data-line-number="6568"></td>
+ <td id="LC6568" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L6569" class="blob-num js-line-number" data-line-number="6569"></td>
+ <td id="LC6569" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6570" class="blob-num js-line-number" data-line-number="6570"></td>
+ <td id="LC6570" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ]</span></td>
+ </tr>
+ <tr>
+ <td id="L6571" class="blob-num js-line-number" data-line-number="6571"></td>
+ <td id="LC6571" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L6572" class="blob-num js-line-number" data-line-number="6572"></td>
+ <td id="LC6572" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6573" class="blob-num js-line-number" data-line-number="6573"></td>
+ <td id="LC6573" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.merge(names, ages);</span></td>
+ </tr>
+ <tr>
+ <td id="L6574" class="blob-num js-line-number" data-line-number="6574"></td>
+ <td id="LC6574" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] }</span></td>
+ </tr>
+ <tr>
+ <td id="L6575" class="blob-num js-line-number" data-line-number="6575"></td>
+ <td id="LC6575" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6576" class="blob-num js-line-number" data-line-number="6576"></td>
+ <td id="LC6576" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var food = {</span></td>
+ </tr>
+ <tr>
+ <td id="L6577" class="blob-num js-line-number" data-line-number="6577"></td>
+ <td id="LC6577" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'fruits': ['apple'],</span></td>
+ </tr>
+ <tr>
+ <td id="L6578" class="blob-num js-line-number" data-line-number="6578"></td>
+ <td id="LC6578" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'vegetables': ['beet']</span></td>
+ </tr>
+ <tr>
+ <td id="L6579" class="blob-num js-line-number" data-line-number="6579"></td>
+ <td id="LC6579" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L6580" class="blob-num js-line-number" data-line-number="6580"></td>
+ <td id="LC6580" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6581" class="blob-num js-line-number" data-line-number="6581"></td>
+ <td id="LC6581" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var otherFood = {</span></td>
+ </tr>
+ <tr>
+ <td id="L6582" class="blob-num js-line-number" data-line-number="6582"></td>
+ <td id="LC6582" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'fruits': ['banana'],</span></td>
+ </tr>
+ <tr>
+ <td id="L6583" class="blob-num js-line-number" data-line-number="6583"></td>
+ <td id="LC6583" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'vegetables': ['carrot']</span></td>
+ </tr>
+ <tr>
+ <td id="L6584" class="blob-num js-line-number" data-line-number="6584"></td>
+ <td id="LC6584" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L6585" class="blob-num js-line-number" data-line-number="6585"></td>
+ <td id="LC6585" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6586" class="blob-num js-line-number" data-line-number="6586"></td>
+ <td id="LC6586" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.merge(food, otherFood, function(a, b) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6587" class="blob-num js-line-number" data-line-number="6587"></td>
+ <td id="LC6587" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return _.isArray(a) ? a.concat(b) : undefined;</span></td>
+ </tr>
+ <tr>
+ <td id="L6588" class="blob-num js-line-number" data-line-number="6588"></td>
+ <td id="LC6588" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6589" class="blob-num js-line-number" data-line-number="6589"></td>
+ <td id="LC6589" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }</span></td>
+ </tr>
+ <tr>
+ <td id="L6590" class="blob-num js-line-number" data-line-number="6590"></td>
+ <td id="LC6590" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6591" class="blob-num js-line-number" data-line-number="6591"></td>
+ <td id="LC6591" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">merge</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6592" class="blob-num js-line-number" data-line-number="6592"></td>
+ <td id="LC6592" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6593" class="blob-num js-line-number" data-line-number="6593"></td>
+ <td id="LC6593" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-c1">2</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6594" class="blob-num js-line-number" data-line-number="6594"></td>
+ <td id="LC6594" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6595" class="blob-num js-line-number" data-line-number="6595"></td>
+ <td id="LC6595" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isObject</span>(object)) {</td>
+ </tr>
+ <tr>
+ <td id="L6596" class="blob-num js-line-number" data-line-number="6596"></td>
+ <td id="LC6596" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object;</td>
+ </tr>
+ <tr>
+ <td id="L6597" class="blob-num js-line-number" data-line-number="6597"></td>
+ <td id="LC6597" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6598" class="blob-num js-line-number" data-line-number="6598"></td>
+ <td id="LC6598" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// allows working with `_.reduce` and `_.reduceRight` without using</span></td>
+ </tr>
+ <tr>
+ <td id="L6599" class="blob-num js-line-number" data-line-number="6599"></td>
+ <td id="LC6599" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// their `index` and `collection` arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L6600" class="blob-num js-line-number" data-line-number="6600"></td>
+ <td id="LC6600" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> args[<span class="pl-c1">2</span>] <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6601" class="blob-num js-line-number" data-line-number="6601"></td>
+ <td id="LC6601" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">args</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6602" class="blob-num js-line-number" data-line-number="6602"></td>
+ <td id="LC6602" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6603" class="blob-num js-line-number" data-line-number="6603"></td>
+ <td id="LC6603" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (length <span class="pl-k">></span> <span class="pl-c1">3</span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> args[length <span class="pl-k">-</span> <span class="pl-c1">2</span>] <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6604" class="blob-num js-line-number" data-line-number="6604"></td>
+ <td id="LC6604" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> callback <span class="pl-k">=</span> <span class="pl-en">baseCreateCallback</span>(args[<span class="pl-k">--</span>length <span class="pl-k">-</span> <span class="pl-c1">1</span>], args[length<span class="pl-k">--</span>], <span class="pl-c1">2</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6605" class="blob-num js-line-number" data-line-number="6605"></td>
+ <td id="LC6605" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (length <span class="pl-k">></span> <span class="pl-c1">2</span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> args[length <span class="pl-k">-</span> <span class="pl-c1">1</span>] <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6606" class="blob-num js-line-number" data-line-number="6606"></td>
+ <td id="LC6606" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> args[<span class="pl-k">--</span>length];</td>
+ </tr>
+ <tr>
+ <td id="L6607" class="blob-num js-line-number" data-line-number="6607"></td>
+ <td id="LC6607" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6608" class="blob-num js-line-number" data-line-number="6608"></td>
+ <td id="LC6608" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> sources <span class="pl-k">=</span> <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">1</span>, length),</td>
+ </tr>
+ <tr>
+ <td id="L6609" class="blob-num js-line-number" data-line-number="6609"></td>
+ <td id="LC6609" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6610" class="blob-num js-line-number" data-line-number="6610"></td>
+ <td id="LC6610" class="blob-code blob-code-inner js-file-line"> stackA <span class="pl-k">=</span> <span class="pl-en">getArray</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L6611" class="blob-num js-line-number" data-line-number="6611"></td>
+ <td id="LC6611" class="blob-code blob-code-inner js-file-line"> stackB <span class="pl-k">=</span> <span class="pl-en">getArray</span>();</td>
+ </tr>
+ <tr>
+ <td id="L6612" class="blob-num js-line-number" data-line-number="6612"></td>
+ <td id="LC6612" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6613" class="blob-num js-line-number" data-line-number="6613"></td>
+ <td id="LC6613" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6614" class="blob-num js-line-number" data-line-number="6614"></td>
+ <td id="LC6614" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">baseMerge</span>(object, sources[index], callback, stackA, stackB);</td>
+ </tr>
+ <tr>
+ <td id="L6615" class="blob-num js-line-number" data-line-number="6615"></td>
+ <td id="LC6615" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6616" class="blob-num js-line-number" data-line-number="6616"></td>
+ <td id="LC6616" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(stackA);</td>
+ </tr>
+ <tr>
+ <td id="L6617" class="blob-num js-line-number" data-line-number="6617"></td>
+ <td id="LC6617" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(stackB);</td>
+ </tr>
+ <tr>
+ <td id="L6618" class="blob-num js-line-number" data-line-number="6618"></td>
+ <td id="LC6618" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object;</td>
+ </tr>
+ <tr>
+ <td id="L6619" class="blob-num js-line-number" data-line-number="6619"></td>
+ <td id="LC6619" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6620" class="blob-num js-line-number" data-line-number="6620"></td>
+ <td id="LC6620" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6621" class="blob-num js-line-number" data-line-number="6621"></td>
+ <td id="LC6621" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6622" class="blob-num js-line-number" data-line-number="6622"></td>
+ <td id="LC6622" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a shallow clone of `object` excluding the specified properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L6623" class="blob-num js-line-number" data-line-number="6623"></td>
+ <td id="LC6623" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Property names may be specified as individual arguments or as arrays of</span></td>
+ </tr>
+ <tr>
+ <td id="L6624" class="blob-num js-line-number" data-line-number="6624"></td>
+ <td id="LC6624" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * property names. If a callback is provided it will be executed for each</span></td>
+ </tr>
+ <tr>
+ <td id="L6625" class="blob-num js-line-number" data-line-number="6625"></td>
+ <td id="LC6625" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * property of `object` omitting the properties the callback returns truey</span></td>
+ </tr>
+ <tr>
+ <td id="L6626" class="blob-num js-line-number" data-line-number="6626"></td>
+ <td id="LC6626" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for. The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L6627" class="blob-num js-line-number" data-line-number="6627"></td>
+ <td id="LC6627" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, key, object).</span></td>
+ </tr>
+ <tr>
+ <td id="L6628" class="blob-num js-line-number" data-line-number="6628"></td>
+ <td id="LC6628" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6629" class="blob-num js-line-number" data-line-number="6629"></td>
+ <td id="LC6629" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6630" class="blob-num js-line-number" data-line-number="6630"></td>
+ <td id="LC6630" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6631" class="blob-num js-line-number" data-line-number="6631"></td>
+ <td id="LC6631" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6632" class="blob-num js-line-number" data-line-number="6632"></td>
+ <td id="LC6632" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The source object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6633" class="blob-num js-line-number" data-line-number="6633"></td>
+ <td id="LC6633" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|...string|string[]} [callback] The properties to omit or the</span></td>
+ </tr>
+ <tr>
+ <td id="L6634" class="blob-num js-line-number" data-line-number="6634"></td>
+ <td id="LC6634" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L6635" class="blob-num js-line-number" data-line-number="6635"></td>
+ <td id="LC6635" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6636" class="blob-num js-line-number" data-line-number="6636"></td>
+ <td id="LC6636" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> an object without the omitted properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L6637" class="blob-num js-line-number" data-line-number="6637"></td>
+ <td id="LC6637" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6638" class="blob-num js-line-number" data-line-number="6638"></td>
+ <td id="LC6638" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6639" class="blob-num js-line-number" data-line-number="6639"></td>
+ <td id="LC6639" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.omit({ 'name': 'fred', 'age': 40 }, 'age');</span></td>
+ </tr>
+ <tr>
+ <td id="L6640" class="blob-num js-line-number" data-line-number="6640"></td>
+ <td id="LC6640" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred' }</span></td>
+ </tr>
+ <tr>
+ <td id="L6641" class="blob-num js-line-number" data-line-number="6641"></td>
+ <td id="LC6641" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6642" class="blob-num js-line-number" data-line-number="6642"></td>
+ <td id="LC6642" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.omit({ 'name': 'fred', 'age': 40 }, function(value) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6643" class="blob-num js-line-number" data-line-number="6643"></td>
+ <td id="LC6643" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return typeof value == 'number';</span></td>
+ </tr>
+ <tr>
+ <td id="L6644" class="blob-num js-line-number" data-line-number="6644"></td>
+ <td id="LC6644" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6645" class="blob-num js-line-number" data-line-number="6645"></td>
+ <td id="LC6645" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred' }</span></td>
+ </tr>
+ <tr>
+ <td id="L6646" class="blob-num js-line-number" data-line-number="6646"></td>
+ <td id="LC6646" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6647" class="blob-num js-line-number" data-line-number="6647"></td>
+ <td id="LC6647" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">omit</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6648" class="blob-num js-line-number" data-line-number="6648"></td>
+ <td id="LC6648" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L6649" class="blob-num js-line-number" data-line-number="6649"></td>
+ <td id="LC6649" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6650" class="blob-num js-line-number" data-line-number="6650"></td>
+ <td id="LC6650" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> props <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L6651" class="blob-num js-line-number" data-line-number="6651"></td>
+ <td id="LC6651" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6652" class="blob-num js-line-number" data-line-number="6652"></td>
+ <td id="LC6652" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">props</span>.<span class="pl-c1">push</span>(key);</td>
+ </tr>
+ <tr>
+ <td id="L6653" class="blob-num js-line-number" data-line-number="6653"></td>
+ <td id="LC6653" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6654" class="blob-num js-line-number" data-line-number="6654"></td>
+ <td id="LC6654" class="blob-code blob-code-inner js-file-line"> props <span class="pl-k">=</span> <span class="pl-en">baseDifference</span>(props, <span class="pl-en">baseFlatten</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">true</span>, <span class="pl-c1">false</span>, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L6655" class="blob-num js-line-number" data-line-number="6655"></td>
+ <td id="LC6655" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6656" class="blob-num js-line-number" data-line-number="6656"></td>
+ <td id="LC6656" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6657" class="blob-num js-line-number" data-line-number="6657"></td>
+ <td id="LC6657" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6658" class="blob-num js-line-number" data-line-number="6658"></td>
+ <td id="LC6658" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6659" class="blob-num js-line-number" data-line-number="6659"></td>
+ <td id="LC6659" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6660" class="blob-num js-line-number" data-line-number="6660"></td>
+ <td id="LC6660" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> props[index];</td>
+ </tr>
+ <tr>
+ <td id="L6661" class="blob-num js-line-number" data-line-number="6661"></td>
+ <td id="LC6661" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> object[key];</td>
+ </tr>
+ <tr>
+ <td id="L6662" class="blob-num js-line-number" data-line-number="6662"></td>
+ <td id="LC6662" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6663" class="blob-num js-line-number" data-line-number="6663"></td>
+ <td id="LC6663" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L6664" class="blob-num js-line-number" data-line-number="6664"></td>
+ <td id="LC6664" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6665" class="blob-num js-line-number" data-line-number="6665"></td>
+ <td id="LC6665" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6666" class="blob-num js-line-number" data-line-number="6666"></td>
+ <td id="LC6666" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">callback</span>(value, key, object)) {</td>
+ </tr>
+ <tr>
+ <td id="L6667" class="blob-num js-line-number" data-line-number="6667"></td>
+ <td id="LC6667" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L6668" class="blob-num js-line-number" data-line-number="6668"></td>
+ <td id="LC6668" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6669" class="blob-num js-line-number" data-line-number="6669"></td>
+ <td id="LC6669" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6670" class="blob-num js-line-number" data-line-number="6670"></td>
+ <td id="LC6670" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6671" class="blob-num js-line-number" data-line-number="6671"></td>
+ <td id="LC6671" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6672" class="blob-num js-line-number" data-line-number="6672"></td>
+ <td id="LC6672" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6673" class="blob-num js-line-number" data-line-number="6673"></td>
+ <td id="LC6673" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6674" class="blob-num js-line-number" data-line-number="6674"></td>
+ <td id="LC6674" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6675" class="blob-num js-line-number" data-line-number="6675"></td>
+ <td id="LC6675" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a two dimensional array of an object's key-value pairs,</span></td>
+ </tr>
+ <tr>
+ <td id="L6676" class="blob-num js-line-number" data-line-number="6676"></td>
+ <td id="LC6676" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * i.e. `[[key1, value1], [key2, value2]]`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6677" class="blob-num js-line-number" data-line-number="6677"></td>
+ <td id="LC6677" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6678" class="blob-num js-line-number" data-line-number="6678"></td>
+ <td id="LC6678" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6679" class="blob-num js-line-number" data-line-number="6679"></td>
+ <td id="LC6679" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6680" class="blob-num js-line-number" data-line-number="6680"></td>
+ <td id="LC6680" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6681" class="blob-num js-line-number" data-line-number="6681"></td>
+ <td id="LC6681" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L6682" class="blob-num js-line-number" data-line-number="6682"></td>
+ <td id="LC6682" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> new array of key-value pairs.</span></td>
+ </tr>
+ <tr>
+ <td id="L6683" class="blob-num js-line-number" data-line-number="6683"></td>
+ <td id="LC6683" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6684" class="blob-num js-line-number" data-line-number="6684"></td>
+ <td id="LC6684" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6685" class="blob-num js-line-number" data-line-number="6685"></td>
+ <td id="LC6685" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pairs({ 'barney': 36, 'fred': 40 });</span></td>
+ </tr>
+ <tr>
+ <td id="L6686" class="blob-num js-line-number" data-line-number="6686"></td>
+ <td id="LC6686" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L6687" class="blob-num js-line-number" data-line-number="6687"></td>
+ <td id="LC6687" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6688" class="blob-num js-line-number" data-line-number="6688"></td>
+ <td id="LC6688" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">pairs</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6689" class="blob-num js-line-number" data-line-number="6689"></td>
+ <td id="LC6689" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6690" class="blob-num js-line-number" data-line-number="6690"></td>
+ <td id="LC6690" class="blob-code blob-code-inner js-file-line"> props <span class="pl-k">=</span> <span class="pl-en">keys</span>(object),</td>
+ </tr>
+ <tr>
+ <td id="L6691" class="blob-num js-line-number" data-line-number="6691"></td>
+ <td id="LC6691" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6692" class="blob-num js-line-number" data-line-number="6692"></td>
+ <td id="LC6692" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length);</td>
+ </tr>
+ <tr>
+ <td id="L6693" class="blob-num js-line-number" data-line-number="6693"></td>
+ <td id="LC6693" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6694" class="blob-num js-line-number" data-line-number="6694"></td>
+ <td id="LC6694" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6695" class="blob-num js-line-number" data-line-number="6695"></td>
+ <td id="LC6695" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> props[index];</td>
+ </tr>
+ <tr>
+ <td id="L6696" class="blob-num js-line-number" data-line-number="6696"></td>
+ <td id="LC6696" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> [key, object[key]];</td>
+ </tr>
+ <tr>
+ <td id="L6697" class="blob-num js-line-number" data-line-number="6697"></td>
+ <td id="LC6697" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6698" class="blob-num js-line-number" data-line-number="6698"></td>
+ <td id="LC6698" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6699" class="blob-num js-line-number" data-line-number="6699"></td>
+ <td id="LC6699" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6700" class="blob-num js-line-number" data-line-number="6700"></td>
+ <td id="LC6700" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6701" class="blob-num js-line-number" data-line-number="6701"></td>
+ <td id="LC6701" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6702" class="blob-num js-line-number" data-line-number="6702"></td>
+ <td id="LC6702" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a shallow clone of `object` composed of the specified properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L6703" class="blob-num js-line-number" data-line-number="6703"></td>
+ <td id="LC6703" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Property names may be specified as individual arguments or as arrays of</span></td>
+ </tr>
+ <tr>
+ <td id="L6704" class="blob-num js-line-number" data-line-number="6704"></td>
+ <td id="LC6704" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * property names. If a callback is provided it will be executed for each</span></td>
+ </tr>
+ <tr>
+ <td id="L6705" class="blob-num js-line-number" data-line-number="6705"></td>
+ <td id="LC6705" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * property of `object` picking the properties the callback returns truey</span></td>
+ </tr>
+ <tr>
+ <td id="L6706" class="blob-num js-line-number" data-line-number="6706"></td>
+ <td id="LC6706" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for. The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L6707" class="blob-num js-line-number" data-line-number="6707"></td>
+ <td id="LC6707" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, key, object).</span></td>
+ </tr>
+ <tr>
+ <td id="L6708" class="blob-num js-line-number" data-line-number="6708"></td>
+ <td id="LC6708" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6709" class="blob-num js-line-number" data-line-number="6709"></td>
+ <td id="LC6709" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6710" class="blob-num js-line-number" data-line-number="6710"></td>
+ <td id="LC6710" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6711" class="blob-num js-line-number" data-line-number="6711"></td>
+ <td id="LC6711" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6712" class="blob-num js-line-number" data-line-number="6712"></td>
+ <td id="LC6712" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The source object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6713" class="blob-num js-line-number" data-line-number="6713"></td>
+ <td id="LC6713" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|...string|string[]} [callback] The function called per</span></td>
+ </tr>
+ <tr>
+ <td id="L6714" class="blob-num js-line-number" data-line-number="6714"></td>
+ <td id="LC6714" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * iteration or property names to pick, specified as individual property</span></td>
+ </tr>
+ <tr>
+ <td id="L6715" class="blob-num js-line-number" data-line-number="6715"></td>
+ <td id="LC6715" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * names or arrays of property names.</span></td>
+ </tr>
+ <tr>
+ <td id="L6716" class="blob-num js-line-number" data-line-number="6716"></td>
+ <td id="LC6716" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6717" class="blob-num js-line-number" data-line-number="6717"></td>
+ <td id="LC6717" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> an object composed of the picked properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L6718" class="blob-num js-line-number" data-line-number="6718"></td>
+ <td id="LC6718" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6719" class="blob-num js-line-number" data-line-number="6719"></td>
+ <td id="LC6719" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6720" class="blob-num js-line-number" data-line-number="6720"></td>
+ <td id="LC6720" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L6721" class="blob-num js-line-number" data-line-number="6721"></td>
+ <td id="LC6721" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred' }</span></td>
+ </tr>
+ <tr>
+ <td id="L6722" class="blob-num js-line-number" data-line-number="6722"></td>
+ <td id="LC6722" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6723" class="blob-num js-line-number" data-line-number="6723"></td>
+ <td id="LC6723" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6724" class="blob-num js-line-number" data-line-number="6724"></td>
+ <td id="LC6724" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return key.charAt(0) != '_';</span></td>
+ </tr>
+ <tr>
+ <td id="L6725" class="blob-num js-line-number" data-line-number="6725"></td>
+ <td id="LC6725" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6726" class="blob-num js-line-number" data-line-number="6726"></td>
+ <td id="LC6726" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred' }</span></td>
+ </tr>
+ <tr>
+ <td id="L6727" class="blob-num js-line-number" data-line-number="6727"></td>
+ <td id="LC6727" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6728" class="blob-num js-line-number" data-line-number="6728"></td>
+ <td id="LC6728" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">pick</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6729" class="blob-num js-line-number" data-line-number="6729"></td>
+ <td id="LC6729" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L6730" class="blob-num js-line-number" data-line-number="6730"></td>
+ <td id="LC6730" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6731" class="blob-num js-line-number" data-line-number="6731"></td>
+ <td id="LC6731" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6732" class="blob-num js-line-number" data-line-number="6732"></td>
+ <td id="LC6732" class="blob-code blob-code-inner js-file-line"> props <span class="pl-k">=</span> <span class="pl-en">baseFlatten</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">true</span>, <span class="pl-c1">false</span>, <span class="pl-c1">1</span>),</td>
+ </tr>
+ <tr>
+ <td id="L6733" class="blob-num js-line-number" data-line-number="6733"></td>
+ <td id="LC6733" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-en">isObject</span>(object) <span class="pl-k">?</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6734" class="blob-num js-line-number" data-line-number="6734"></td>
+ <td id="LC6734" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6735" class="blob-num js-line-number" data-line-number="6735"></td>
+ <td id="LC6735" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6736" class="blob-num js-line-number" data-line-number="6736"></td>
+ <td id="LC6736" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> props[index];</td>
+ </tr>
+ <tr>
+ <td id="L6737" class="blob-num js-line-number" data-line-number="6737"></td>
+ <td id="LC6737" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (key <span class="pl-k">in</span> object) {</td>
+ </tr>
+ <tr>
+ <td id="L6738" class="blob-num js-line-number" data-line-number="6738"></td>
+ <td id="LC6738" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> object[key];</td>
+ </tr>
+ <tr>
+ <td id="L6739" class="blob-num js-line-number" data-line-number="6739"></td>
+ <td id="LC6739" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6740" class="blob-num js-line-number" data-line-number="6740"></td>
+ <td id="LC6740" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6741" class="blob-num js-line-number" data-line-number="6741"></td>
+ <td id="LC6741" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L6742" class="blob-num js-line-number" data-line-number="6742"></td>
+ <td id="LC6742" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6743" class="blob-num js-line-number" data-line-number="6743"></td>
+ <td id="LC6743" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forIn</span>(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6744" class="blob-num js-line-number" data-line-number="6744"></td>
+ <td id="LC6744" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, key, object)) {</td>
+ </tr>
+ <tr>
+ <td id="L6745" class="blob-num js-line-number" data-line-number="6745"></td>
+ <td id="LC6745" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L6746" class="blob-num js-line-number" data-line-number="6746"></td>
+ <td id="LC6746" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6747" class="blob-num js-line-number" data-line-number="6747"></td>
+ <td id="LC6747" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6748" class="blob-num js-line-number" data-line-number="6748"></td>
+ <td id="LC6748" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6749" class="blob-num js-line-number" data-line-number="6749"></td>
+ <td id="LC6749" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6750" class="blob-num js-line-number" data-line-number="6750"></td>
+ <td id="LC6750" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6751" class="blob-num js-line-number" data-line-number="6751"></td>
+ <td id="LC6751" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6752" class="blob-num js-line-number" data-line-number="6752"></td>
+ <td id="LC6752" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6753" class="blob-num js-line-number" data-line-number="6753"></td>
+ <td id="LC6753" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * An alternative to `_.reduce` this method transforms `object` to a new</span></td>
+ </tr>
+ <tr>
+ <td id="L6754" class="blob-num js-line-number" data-line-number="6754"></td>
+ <td id="LC6754" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `accumulator` object which is the result of running each of its own</span></td>
+ </tr>
+ <tr>
+ <td id="L6755" class="blob-num js-line-number" data-line-number="6755"></td>
+ <td id="LC6755" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * enumerable properties through a callback, with each callback execution</span></td>
+ </tr>
+ <tr>
+ <td id="L6756" class="blob-num js-line-number" data-line-number="6756"></td>
+ <td id="LC6756" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * potentially mutating the `accumulator` object. The callback is bound to</span></td>
+ </tr>
+ <tr>
+ <td id="L6757" class="blob-num js-line-number" data-line-number="6757"></td>
+ <td id="LC6757" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `thisArg` and invoked with four arguments; (accumulator, value, key, object).</span></td>
+ </tr>
+ <tr>
+ <td id="L6758" class="blob-num js-line-number" data-line-number="6758"></td>
+ <td id="LC6758" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Callbacks may exit iteration early by explicitly returning `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6759" class="blob-num js-line-number" data-line-number="6759"></td>
+ <td id="LC6759" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6760" class="blob-num js-line-number" data-line-number="6760"></td>
+ <td id="LC6760" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6761" class="blob-num js-line-number" data-line-number="6761"></td>
+ <td id="LC6761" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6762" class="blob-num js-line-number" data-line-number="6762"></td>
+ <td id="LC6762" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6763" class="blob-num js-line-number" data-line-number="6763"></td>
+ <td id="LC6763" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object} object The object to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6764" class="blob-num js-line-number" data-line-number="6764"></td>
+ <td id="LC6764" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L6765" class="blob-num js-line-number" data-line-number="6765"></td>
+ <td id="LC6765" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [accumulator] The custom accumulator value.</span></td>
+ </tr>
+ <tr>
+ <td id="L6766" class="blob-num js-line-number" data-line-number="6766"></td>
+ <td id="LC6766" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6767" class="blob-num js-line-number" data-line-number="6767"></td>
+ <td id="LC6767" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the accumulated value.</span></td>
+ </tr>
+ <tr>
+ <td id="L6768" class="blob-num js-line-number" data-line-number="6768"></td>
+ <td id="LC6768" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6769" class="blob-num js-line-number" data-line-number="6769"></td>
+ <td id="LC6769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6770" class="blob-num js-line-number" data-line-number="6770"></td>
+ <td id="LC6770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6771" class="blob-num js-line-number" data-line-number="6771"></td>
+ <td id="LC6771" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * num *= num;</span></td>
+ </tr>
+ <tr>
+ <td id="L6772" class="blob-num js-line-number" data-line-number="6772"></td>
+ <td id="LC6772" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * if (num % 2) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6773" class="blob-num js-line-number" data-line-number="6773"></td>
+ <td id="LC6773" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return result.push(num) < 3;</span></td>
+ </tr>
+ <tr>
+ <td id="L6774" class="blob-num js-line-number" data-line-number="6774"></td>
+ <td id="LC6774" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L6775" class="blob-num js-line-number" data-line-number="6775"></td>
+ <td id="LC6775" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6776" class="blob-num js-line-number" data-line-number="6776"></td>
+ <td id="LC6776" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 9, 25]</span></td>
+ </tr>
+ <tr>
+ <td id="L6777" class="blob-num js-line-number" data-line-number="6777"></td>
+ <td id="LC6777" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6778" class="blob-num js-line-number" data-line-number="6778"></td>
+ <td id="LC6778" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L6779" class="blob-num js-line-number" data-line-number="6779"></td>
+ <td id="LC6779" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * result[key] = num * 3;</span></td>
+ </tr>
+ <tr>
+ <td id="L6780" class="blob-num js-line-number" data-line-number="6780"></td>
+ <td id="LC6780" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L6781" class="blob-num js-line-number" data-line-number="6781"></td>
+ <td id="LC6781" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'a': 3, 'b': 6, 'c': 9 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6782" class="blob-num js-line-number" data-line-number="6782"></td>
+ <td id="LC6782" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6783" class="blob-num js-line-number" data-line-number="6783"></td>
+ <td id="LC6783" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">transform</span>(<span class="pl-smi">object</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">accumulator</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6784" class="blob-num js-line-number" data-line-number="6784"></td>
+ <td id="LC6784" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isArr <span class="pl-k">=</span> <span class="pl-en">isArray</span>(object);</td>
+ </tr>
+ <tr>
+ <td id="L6785" class="blob-num js-line-number" data-line-number="6785"></td>
+ <td id="LC6785" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (accumulator <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6786" class="blob-num js-line-number" data-line-number="6786"></td>
+ <td id="LC6786" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L6787" class="blob-num js-line-number" data-line-number="6787"></td>
+ <td id="LC6787" class="blob-code blob-code-inner js-file-line"> accumulator <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L6788" class="blob-num js-line-number" data-line-number="6788"></td>
+ <td id="LC6788" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L6789" class="blob-num js-line-number" data-line-number="6789"></td>
+ <td id="LC6789" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ctor <span class="pl-k">=</span> object <span class="pl-k">&&</span> <span class="pl-smi">object</span>.<span class="pl-c1">constructor</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6790" class="blob-num js-line-number" data-line-number="6790"></td>
+ <td id="LC6790" class="blob-code blob-code-inner js-file-line"> proto <span class="pl-k">=</span> ctor <span class="pl-k">&&</span> <span class="pl-smi">ctor</span>.<span class="pl-c1">prototype</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6791" class="blob-num js-line-number" data-line-number="6791"></td>
+ <td id="LC6791" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6792" class="blob-num js-line-number" data-line-number="6792"></td>
+ <td id="LC6792" class="blob-code blob-code-inner js-file-line"> accumulator <span class="pl-k">=</span> <span class="pl-en">baseCreate</span>(proto);</td>
+ </tr>
+ <tr>
+ <td id="L6793" class="blob-num js-line-number" data-line-number="6793"></td>
+ <td id="LC6793" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6794" class="blob-num js-line-number" data-line-number="6794"></td>
+ <td id="LC6794" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6795" class="blob-num js-line-number" data-line-number="6795"></td>
+ <td id="LC6795" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback) {</td>
+ </tr>
+ <tr>
+ <td id="L6796" class="blob-num js-line-number" data-line-number="6796"></td>
+ <td id="LC6796" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">4</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6797" class="blob-num js-line-number" data-line-number="6797"></td>
+ <td id="LC6797" class="blob-code blob-code-inner js-file-line"> (isArr <span class="pl-k">?</span> forEach <span class="pl-k">:</span> forOwn)(object, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6798" class="blob-num js-line-number" data-line-number="6798"></td>
+ <td id="LC6798" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">callback</span>(accumulator, value, index, object);</td>
+ </tr>
+ <tr>
+ <td id="L6799" class="blob-num js-line-number" data-line-number="6799"></td>
+ <td id="LC6799" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6800" class="blob-num js-line-number" data-line-number="6800"></td>
+ <td id="LC6800" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6801" class="blob-num js-line-number" data-line-number="6801"></td>
+ <td id="LC6801" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> accumulator;</td>
+ </tr>
+ <tr>
+ <td id="L6802" class="blob-num js-line-number" data-line-number="6802"></td>
+ <td id="LC6802" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6803" class="blob-num js-line-number" data-line-number="6803"></td>
+ <td id="LC6803" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6804" class="blob-num js-line-number" data-line-number="6804"></td>
+ <td id="LC6804" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6805" class="blob-num js-line-number" data-line-number="6805"></td>
+ <td id="LC6805" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array composed of the own enumerable property values of `object`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6806" class="blob-num js-line-number" data-line-number="6806"></td>
+ <td id="LC6806" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6807" class="blob-num js-line-number" data-line-number="6807"></td>
+ <td id="LC6807" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6808" class="blob-num js-line-number" data-line-number="6808"></td>
+ <td id="LC6808" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6809" class="blob-num js-line-number" data-line-number="6809"></td>
+ <td id="LC6809" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Objects</span></td>
+ </tr>
+ <tr>
+ <td id="L6810" class="blob-num js-line-number" data-line-number="6810"></td>
+ <td id="LC6810" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L6811" class="blob-num js-line-number" data-line-number="6811"></td>
+ <td id="LC6811" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of property values.</span></td>
+ </tr>
+ <tr>
+ <td id="L6812" class="blob-num js-line-number" data-line-number="6812"></td>
+ <td id="LC6812" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6813" class="blob-num js-line-number" data-line-number="6813"></td>
+ <td id="LC6813" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6814" class="blob-num js-line-number" data-line-number="6814"></td>
+ <td id="LC6814" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.values({ 'one': 1, 'two': 2, 'three': 3 });</span></td>
+ </tr>
+ <tr>
+ <td id="L6815" class="blob-num js-line-number" data-line-number="6815"></td>
+ <td id="LC6815" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3] (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L6816" class="blob-num js-line-number" data-line-number="6816"></td>
+ <td id="LC6816" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6817" class="blob-num js-line-number" data-line-number="6817"></td>
+ <td id="LC6817" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">values</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6818" class="blob-num js-line-number" data-line-number="6818"></td>
+ <td id="LC6818" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6819" class="blob-num js-line-number" data-line-number="6819"></td>
+ <td id="LC6819" class="blob-code blob-code-inner js-file-line"> props <span class="pl-k">=</span> <span class="pl-en">keys</span>(object),</td>
+ </tr>
+ <tr>
+ <td id="L6820" class="blob-num js-line-number" data-line-number="6820"></td>
+ <td id="LC6820" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6821" class="blob-num js-line-number" data-line-number="6821"></td>
+ <td id="LC6821" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length);</td>
+ </tr>
+ <tr>
+ <td id="L6822" class="blob-num js-line-number" data-line-number="6822"></td>
+ <td id="LC6822" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6823" class="blob-num js-line-number" data-line-number="6823"></td>
+ <td id="LC6823" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6824" class="blob-num js-line-number" data-line-number="6824"></td>
+ <td id="LC6824" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> object[props[index]];</td>
+ </tr>
+ <tr>
+ <td id="L6825" class="blob-num js-line-number" data-line-number="6825"></td>
+ <td id="LC6825" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6826" class="blob-num js-line-number" data-line-number="6826"></td>
+ <td id="LC6826" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6827" class="blob-num js-line-number" data-line-number="6827"></td>
+ <td id="LC6827" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6828" class="blob-num js-line-number" data-line-number="6828"></td>
+ <td id="LC6828" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6829" class="blob-num js-line-number" data-line-number="6829"></td>
+ <td id="LC6829" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L6830" class="blob-num js-line-number" data-line-number="6830"></td>
+ <td id="LC6830" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6831" class="blob-num js-line-number" data-line-number="6831"></td>
+ <td id="LC6831" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6832" class="blob-num js-line-number" data-line-number="6832"></td>
+ <td id="LC6832" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of elements from the specified indexes, or keys, of the</span></td>
+ </tr>
+ <tr>
+ <td id="L6833" class="blob-num js-line-number" data-line-number="6833"></td>
+ <td id="LC6833" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `collection`. Indexes may be specified as individual arguments or as arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L6834" class="blob-num js-line-number" data-line-number="6834"></td>
+ <td id="LC6834" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of indexes.</span></td>
+ </tr>
+ <tr>
+ <td id="L6835" class="blob-num js-line-number" data-line-number="6835"></td>
+ <td id="LC6835" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6836" class="blob-num js-line-number" data-line-number="6836"></td>
+ <td id="LC6836" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6837" class="blob-num js-line-number" data-line-number="6837"></td>
+ <td id="LC6837" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6838" class="blob-num js-line-number" data-line-number="6838"></td>
+ <td id="LC6838" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L6839" class="blob-num js-line-number" data-line-number="6839"></td>
+ <td id="LC6839" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6840" class="blob-num js-line-number" data-line-number="6840"></td>
+ <td id="LC6840" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...(number|number[]|string|string[])} [index] The indexes of `collection`</span></td>
+ </tr>
+ <tr>
+ <td id="L6841" class="blob-num js-line-number" data-line-number="6841"></td>
+ <td id="LC6841" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to retrieve, specified as individual indexes or arrays of indexes.</span></td>
+ </tr>
+ <tr>
+ <td id="L6842" class="blob-num js-line-number" data-line-number="6842"></td>
+ <td id="LC6842" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of elements corresponding to the</span></td>
+ </tr>
+ <tr>
+ <td id="L6843" class="blob-num js-line-number" data-line-number="6843"></td>
+ <td id="LC6843" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided indexes.</span></td>
+ </tr>
+ <tr>
+ <td id="L6844" class="blob-num js-line-number" data-line-number="6844"></td>
+ <td id="LC6844" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6845" class="blob-num js-line-number" data-line-number="6845"></td>
+ <td id="LC6845" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6846" class="blob-num js-line-number" data-line-number="6846"></td>
+ <td id="LC6846" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);</span></td>
+ </tr>
+ <tr>
+ <td id="L6847" class="blob-num js-line-number" data-line-number="6847"></td>
+ <td id="LC6847" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['a', 'c', 'e']</span></td>
+ </tr>
+ <tr>
+ <td id="L6848" class="blob-num js-line-number" data-line-number="6848"></td>
+ <td id="LC6848" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6849" class="blob-num js-line-number" data-line-number="6849"></td>
+ <td id="LC6849" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.at(['fred', 'barney', 'pebbles'], 0, 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L6850" class="blob-num js-line-number" data-line-number="6850"></td>
+ <td id="LC6850" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['fred', 'pebbles']</span></td>
+ </tr>
+ <tr>
+ <td id="L6851" class="blob-num js-line-number" data-line-number="6851"></td>
+ <td id="LC6851" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6852" class="blob-num js-line-number" data-line-number="6852"></td>
+ <td id="LC6852" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">at</span>(<span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6853" class="blob-num js-line-number" data-line-number="6853"></td>
+ <td id="LC6853" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6854" class="blob-num js-line-number" data-line-number="6854"></td>
+ <td id="LC6854" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6855" class="blob-num js-line-number" data-line-number="6855"></td>
+ <td id="LC6855" class="blob-code blob-code-inner js-file-line"> props <span class="pl-k">=</span> <span class="pl-en">baseFlatten</span>(args, <span class="pl-c1">true</span>, <span class="pl-c1">false</span>, <span class="pl-c1">1</span>),</td>
+ </tr>
+ <tr>
+ <td id="L6856" class="blob-num js-line-number" data-line-number="6856"></td>
+ <td id="LC6856" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> (args[<span class="pl-c1">2</span>] <span class="pl-k">&&</span> args[<span class="pl-c1">2</span>][args[<span class="pl-c1">1</span>]] <span class="pl-k">===</span> collection) <span class="pl-k">?</span> <span class="pl-c1">1</span> <span class="pl-k">:</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6857" class="blob-num js-line-number" data-line-number="6857"></td>
+ <td id="LC6857" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length);</td>
+ </tr>
+ <tr>
+ <td id="L6858" class="blob-num js-line-number" data-line-number="6858"></td>
+ <td id="LC6858" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6859" class="blob-num js-line-number" data-line-number="6859"></td>
+ <td id="LC6859" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span>(<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L6860" class="blob-num js-line-number" data-line-number="6860"></td>
+ <td id="LC6860" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> collection[props[index]];</td>
+ </tr>
+ <tr>
+ <td id="L6861" class="blob-num js-line-number" data-line-number="6861"></td>
+ <td id="LC6861" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6862" class="blob-num js-line-number" data-line-number="6862"></td>
+ <td id="LC6862" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6863" class="blob-num js-line-number" data-line-number="6863"></td>
+ <td id="LC6863" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6864" class="blob-num js-line-number" data-line-number="6864"></td>
+ <td id="LC6864" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6865" class="blob-num js-line-number" data-line-number="6865"></td>
+ <td id="LC6865" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6866" class="blob-num js-line-number" data-line-number="6866"></td>
+ <td id="LC6866" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if a given value is present in a collection using strict equality</span></td>
+ </tr>
+ <tr>
+ <td id="L6867" class="blob-num js-line-number" data-line-number="6867"></td>
+ <td id="LC6867" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the</span></td>
+ </tr>
+ <tr>
+ <td id="L6868" class="blob-num js-line-number" data-line-number="6868"></td>
+ <td id="LC6868" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * offset from the end of the collection.</span></td>
+ </tr>
+ <tr>
+ <td id="L6869" class="blob-num js-line-number" data-line-number="6869"></td>
+ <td id="LC6869" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6870" class="blob-num js-line-number" data-line-number="6870"></td>
+ <td id="LC6870" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6871" class="blob-num js-line-number" data-line-number="6871"></td>
+ <td id="LC6871" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6872" class="blob-num js-line-number" data-line-number="6872"></td>
+ <td id="LC6872" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> include</span></td>
+ </tr>
+ <tr>
+ <td id="L6873" class="blob-num js-line-number" data-line-number="6873"></td>
+ <td id="LC6873" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L6874" class="blob-num js-line-number" data-line-number="6874"></td>
+ <td id="LC6874" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6875" class="blob-num js-line-number" data-line-number="6875"></td>
+ <td id="LC6875" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} target The value to check for.</span></td>
+ </tr>
+ <tr>
+ <td id="L6876" class="blob-num js-line-number" data-line-number="6876"></td>
+ <td id="LC6876" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [fromIndex=0] The index to search from.</span></td>
+ </tr>
+ <tr>
+ <td id="L6877" class="blob-num js-line-number" data-line-number="6877"></td>
+ <td id="LC6877" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if the `target` element is found, else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6878" class="blob-num js-line-number" data-line-number="6878"></td>
+ <td id="LC6878" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6879" class="blob-num js-line-number" data-line-number="6879"></td>
+ <td id="LC6879" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6880" class="blob-num js-line-number" data-line-number="6880"></td>
+ <td id="LC6880" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.contains([1, 2, 3], 1);</span></td>
+ </tr>
+ <tr>
+ <td id="L6881" class="blob-num js-line-number" data-line-number="6881"></td>
+ <td id="LC6881" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6882" class="blob-num js-line-number" data-line-number="6882"></td>
+ <td id="LC6882" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6883" class="blob-num js-line-number" data-line-number="6883"></td>
+ <td id="LC6883" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.contains([1, 2, 3], 1, 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L6884" class="blob-num js-line-number" data-line-number="6884"></td>
+ <td id="LC6884" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6885" class="blob-num js-line-number" data-line-number="6885"></td>
+ <td id="LC6885" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6886" class="blob-num js-line-number" data-line-number="6886"></td>
+ <td id="LC6886" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.contains({ 'name': 'fred', 'age': 40 }, 'fred');</span></td>
+ </tr>
+ <tr>
+ <td id="L6887" class="blob-num js-line-number" data-line-number="6887"></td>
+ <td id="LC6887" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6888" class="blob-num js-line-number" data-line-number="6888"></td>
+ <td id="LC6888" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6889" class="blob-num js-line-number" data-line-number="6889"></td>
+ <td id="LC6889" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.contains('pebbles', 'eb');</span></td>
+ </tr>
+ <tr>
+ <td id="L6890" class="blob-num js-line-number" data-line-number="6890"></td>
+ <td id="LC6890" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6891" class="blob-num js-line-number" data-line-number="6891"></td>
+ <td id="LC6891" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6892" class="blob-num js-line-number" data-line-number="6892"></td>
+ <td id="LC6892" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">contains</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">target</span>, <span class="pl-smi">fromIndex</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6893" class="blob-num js-line-number" data-line-number="6893"></td>
+ <td id="LC6893" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6894" class="blob-num js-line-number" data-line-number="6894"></td>
+ <td id="LC6894" class="blob-code blob-code-inner js-file-line"> indexOf <span class="pl-k">=</span> <span class="pl-en">getIndexOf</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L6895" class="blob-num js-line-number" data-line-number="6895"></td>
+ <td id="LC6895" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6896" class="blob-num js-line-number" data-line-number="6896"></td>
+ <td id="LC6896" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6897" class="blob-num js-line-number" data-line-number="6897"></td>
+ <td id="LC6897" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6898" class="blob-num js-line-number" data-line-number="6898"></td>
+ <td id="LC6898" class="blob-code blob-code-inner js-file-line"> fromIndex <span class="pl-k">=</span> (fromIndex <span class="pl-k"><</span> <span class="pl-c1">0</span> <span class="pl-k">?</span> <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, length <span class="pl-k">+</span> fromIndex) <span class="pl-k">:</span> fromIndex) <span class="pl-k">||</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6899" class="blob-num js-line-number" data-line-number="6899"></td>
+ <td id="LC6899" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">isArray</span>(collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L6900" class="blob-num js-line-number" data-line-number="6900"></td>
+ <td id="LC6900" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-en">indexOf</span>(collection, target, fromIndex) <span class="pl-k">></span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6901" class="blob-num js-line-number" data-line-number="6901"></td>
+ <td id="LC6901" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6902" class="blob-num js-line-number" data-line-number="6902"></td>
+ <td id="LC6902" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> (<span class="pl-en">isString</span>(collection) <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">indexOf</span>(target, fromIndex) <span class="pl-k">:</span> <span class="pl-en">indexOf</span>(collection, target, fromIndex)) <span class="pl-k">></span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6903" class="blob-num js-line-number" data-line-number="6903"></td>
+ <td id="LC6903" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L6904" class="blob-num js-line-number" data-line-number="6904"></td>
+ <td id="LC6904" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6905" class="blob-num js-line-number" data-line-number="6905"></td>
+ <td id="LC6905" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">++</span>index <span class="pl-k">>=</span> fromIndex) {</td>
+ </tr>
+ <tr>
+ <td id="L6906" class="blob-num js-line-number" data-line-number="6906"></td>
+ <td id="LC6906" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!</span>(result <span class="pl-k">=</span> value <span class="pl-k">===</span> target);</td>
+ </tr>
+ <tr>
+ <td id="L6907" class="blob-num js-line-number" data-line-number="6907"></td>
+ <td id="LC6907" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6908" class="blob-num js-line-number" data-line-number="6908"></td>
+ <td id="LC6908" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6909" class="blob-num js-line-number" data-line-number="6909"></td>
+ <td id="LC6909" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6910" class="blob-num js-line-number" data-line-number="6910"></td>
+ <td id="LC6910" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L6911" class="blob-num js-line-number" data-line-number="6911"></td>
+ <td id="LC6911" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L6912" class="blob-num js-line-number" data-line-number="6912"></td>
+ <td id="LC6912" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6913" class="blob-num js-line-number" data-line-number="6913"></td>
+ <td id="LC6913" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6914" class="blob-num js-line-number" data-line-number="6914"></td>
+ <td id="LC6914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object composed of keys generated from the results of running</span></td>
+ </tr>
+ <tr>
+ <td id="L6915" class="blob-num js-line-number" data-line-number="6915"></td>
+ <td id="LC6915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * each element of `collection` through the callback. The corresponding value</span></td>
+ </tr>
+ <tr>
+ <td id="L6916" class="blob-num js-line-number" data-line-number="6916"></td>
+ <td id="LC6916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of each key is the number of times the key was returned by the callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L6917" class="blob-num js-line-number" data-line-number="6917"></td>
+ <td id="LC6917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L6918" class="blob-num js-line-number" data-line-number="6918"></td>
+ <td id="LC6918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L6919" class="blob-num js-line-number" data-line-number="6919"></td>
+ <td id="LC6919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6920" class="blob-num js-line-number" data-line-number="6920"></td>
+ <td id="LC6920" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L6921" class="blob-num js-line-number" data-line-number="6921"></td>
+ <td id="LC6921" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L6922" class="blob-num js-line-number" data-line-number="6922"></td>
+ <td id="LC6922" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6923" class="blob-num js-line-number" data-line-number="6923"></td>
+ <td id="LC6923" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L6924" class="blob-num js-line-number" data-line-number="6924"></td>
+ <td id="LC6924" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L6925" class="blob-num js-line-number" data-line-number="6925"></td>
+ <td id="LC6925" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6926" class="blob-num js-line-number" data-line-number="6926"></td>
+ <td id="LC6926" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6927" class="blob-num js-line-number" data-line-number="6927"></td>
+ <td id="LC6927" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6928" class="blob-num js-line-number" data-line-number="6928"></td>
+ <td id="LC6928" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6929" class="blob-num js-line-number" data-line-number="6929"></td>
+ <td id="LC6929" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L6930" class="blob-num js-line-number" data-line-number="6930"></td>
+ <td id="LC6930" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6931" class="blob-num js-line-number" data-line-number="6931"></td>
+ <td id="LC6931" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L6932" class="blob-num js-line-number" data-line-number="6932"></td>
+ <td id="LC6932" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L6933" class="blob-num js-line-number" data-line-number="6933"></td>
+ <td id="LC6933" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L6934" class="blob-num js-line-number" data-line-number="6934"></td>
+ <td id="LC6934" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6935" class="blob-num js-line-number" data-line-number="6935"></td>
+ <td id="LC6935" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the composed aggregate object.</span></td>
+ </tr>
+ <tr>
+ <td id="L6936" class="blob-num js-line-number" data-line-number="6936"></td>
+ <td id="LC6936" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6937" class="blob-num js-line-number" data-line-number="6937"></td>
+ <td id="LC6937" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6938" class="blob-num js-line-number" data-line-number="6938"></td>
+ <td id="LC6938" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });</span></td>
+ </tr>
+ <tr>
+ <td id="L6939" class="blob-num js-line-number" data-line-number="6939"></td>
+ <td id="LC6939" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '4': 1, '6': 2 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6940" class="blob-num js-line-number" data-line-number="6940"></td>
+ <td id="LC6940" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6941" class="blob-num js-line-number" data-line-number="6941"></td>
+ <td id="LC6941" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);</span></td>
+ </tr>
+ <tr>
+ <td id="L6942" class="blob-num js-line-number" data-line-number="6942"></td>
+ <td id="LC6942" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '4': 1, '6': 2 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6943" class="blob-num js-line-number" data-line-number="6943"></td>
+ <td id="LC6943" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6944" class="blob-num js-line-number" data-line-number="6944"></td>
+ <td id="LC6944" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.countBy(['one', 'two', 'three'], 'length');</span></td>
+ </tr>
+ <tr>
+ <td id="L6945" class="blob-num js-line-number" data-line-number="6945"></td>
+ <td id="LC6945" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '3': 2, '5': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6946" class="blob-num js-line-number" data-line-number="6946"></td>
+ <td id="LC6946" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6947" class="blob-num js-line-number" data-line-number="6947"></td>
+ <td id="LC6947" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> countBy <span class="pl-k">=</span> <span class="pl-en">createAggregator</span>(<span class="pl-k">function</span>(<span class="pl-smi">result</span>, <span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6948" class="blob-num js-line-number" data-line-number="6948"></td>
+ <td id="LC6948" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(result, key) <span class="pl-k">?</span> result[key]<span class="pl-k">++</span> <span class="pl-k">:</span> result[key] <span class="pl-k">=</span> <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6949" class="blob-num js-line-number" data-line-number="6949"></td>
+ <td id="LC6949" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L6950" class="blob-num js-line-number" data-line-number="6950"></td>
+ <td id="LC6950" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6951" class="blob-num js-line-number" data-line-number="6951"></td>
+ <td id="LC6951" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L6952" class="blob-num js-line-number" data-line-number="6952"></td>
+ <td id="LC6952" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if the given callback returns truey value for **all** elements of</span></td>
+ </tr>
+ <tr>
+ <td id="L6953" class="blob-num js-line-number" data-line-number="6953"></td>
+ <td id="LC6953" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * a collection. The callback is bound to `thisArg` and invoked with three</span></td>
+ </tr>
+ <tr>
+ <td id="L6954" class="blob-num js-line-number" data-line-number="6954"></td>
+ <td id="LC6954" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L6955" class="blob-num js-line-number" data-line-number="6955"></td>
+ <td id="LC6955" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6956" class="blob-num js-line-number" data-line-number="6956"></td>
+ <td id="LC6956" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L6957" class="blob-num js-line-number" data-line-number="6957"></td>
+ <td id="LC6957" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L6958" class="blob-num js-line-number" data-line-number="6958"></td>
+ <td id="LC6958" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6959" class="blob-num js-line-number" data-line-number="6959"></td>
+ <td id="LC6959" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L6960" class="blob-num js-line-number" data-line-number="6960"></td>
+ <td id="LC6960" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L6961" class="blob-num js-line-number" data-line-number="6961"></td>
+ <td id="LC6961" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6962" class="blob-num js-line-number" data-line-number="6962"></td>
+ <td id="LC6962" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6963" class="blob-num js-line-number" data-line-number="6963"></td>
+ <td id="LC6963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6964" class="blob-num js-line-number" data-line-number="6964"></td>
+ <td id="LC6964" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L6965" class="blob-num js-line-number" data-line-number="6965"></td>
+ <td id="LC6965" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> all</span></td>
+ </tr>
+ <tr>
+ <td id="L6966" class="blob-num js-line-number" data-line-number="6966"></td>
+ <td id="LC6966" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L6967" class="blob-num js-line-number" data-line-number="6967"></td>
+ <td id="LC6967" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L6968" class="blob-num js-line-number" data-line-number="6968"></td>
+ <td id="LC6968" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L6969" class="blob-num js-line-number" data-line-number="6969"></td>
+ <td id="LC6969" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L6970" class="blob-num js-line-number" data-line-number="6970"></td>
+ <td id="LC6970" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L6971" class="blob-num js-line-number" data-line-number="6971"></td>
+ <td id="LC6971" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6972" class="blob-num js-line-number" data-line-number="6972"></td>
+ <td id="LC6972" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if all elements passed the callback check,</span></td>
+ </tr>
+ <tr>
+ <td id="L6973" class="blob-num js-line-number" data-line-number="6973"></td>
+ <td id="LC6973" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L6974" class="blob-num js-line-number" data-line-number="6974"></td>
+ <td id="LC6974" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L6975" class="blob-num js-line-number" data-line-number="6975"></td>
+ <td id="LC6975" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6976" class="blob-num js-line-number" data-line-number="6976"></td>
+ <td id="LC6976" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.every([true, 1, null, 'yes']);</span></td>
+ </tr>
+ <tr>
+ <td id="L6977" class="blob-num js-line-number" data-line-number="6977"></td>
+ <td id="LC6977" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6978" class="blob-num js-line-number" data-line-number="6978"></td>
+ <td id="LC6978" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6979" class="blob-num js-line-number" data-line-number="6979"></td>
+ <td id="LC6979" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L6980" class="blob-num js-line-number" data-line-number="6980"></td>
+ <td id="LC6980" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L6981" class="blob-num js-line-number" data-line-number="6981"></td>
+ <td id="LC6981" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L6982" class="blob-num js-line-number" data-line-number="6982"></td>
+ <td id="LC6982" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L6983" class="blob-num js-line-number" data-line-number="6983"></td>
+ <td id="LC6983" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6984" class="blob-num js-line-number" data-line-number="6984"></td>
+ <td id="LC6984" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L6985" class="blob-num js-line-number" data-line-number="6985"></td>
+ <td id="LC6985" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.every(characters, 'age');</span></td>
+ </tr>
+ <tr>
+ <td id="L6986" class="blob-num js-line-number" data-line-number="6986"></td>
+ <td id="LC6986" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L6987" class="blob-num js-line-number" data-line-number="6987"></td>
+ <td id="LC6987" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L6988" class="blob-num js-line-number" data-line-number="6988"></td>
+ <td id="LC6988" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L6989" class="blob-num js-line-number" data-line-number="6989"></td>
+ <td id="LC6989" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.every(characters, { 'age': 36 });</span></td>
+ </tr>
+ <tr>
+ <td id="L6990" class="blob-num js-line-number" data-line-number="6990"></td>
+ <td id="LC6990" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L6991" class="blob-num js-line-number" data-line-number="6991"></td>
+ <td id="LC6991" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L6992" class="blob-num js-line-number" data-line-number="6992"></td>
+ <td id="LC6992" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">every</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L6993" class="blob-num js-line-number" data-line-number="6993"></td>
+ <td id="LC6993" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6994" class="blob-num js-line-number" data-line-number="6994"></td>
+ <td id="LC6994" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L6995" class="blob-num js-line-number" data-line-number="6995"></td>
+ <td id="LC6995" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6996" class="blob-num js-line-number" data-line-number="6996"></td>
+ <td id="LC6996" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L6997" class="blob-num js-line-number" data-line-number="6997"></td>
+ <td id="LC6997" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L6998" class="blob-num js-line-number" data-line-number="6998"></td>
+ <td id="LC6998" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L6999" class="blob-num js-line-number" data-line-number="6999"></td>
+ <td id="LC6999" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7000" class="blob-num js-line-number" data-line-number="7000"></td>
+ <td id="LC7000" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7001" class="blob-num js-line-number" data-line-number="7001"></td>
+ <td id="LC7001" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>(result <span class="pl-k">=</span> <span class="pl-k">!!</span><span class="pl-en">callback</span>(collection[index], index, collection))) {</td>
+ </tr>
+ <tr>
+ <td id="L7002" class="blob-num js-line-number" data-line-number="7002"></td>
+ <td id="LC7002" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7003" class="blob-num js-line-number" data-line-number="7003"></td>
+ <td id="LC7003" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7004" class="blob-num js-line-number" data-line-number="7004"></td>
+ <td id="LC7004" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7005" class="blob-num js-line-number" data-line-number="7005"></td>
+ <td id="LC7005" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7006" class="blob-num js-line-number" data-line-number="7006"></td>
+ <td id="LC7006" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7007" class="blob-num js-line-number" data-line-number="7007"></td>
+ <td id="LC7007" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> (result <span class="pl-k">=</span> <span class="pl-k">!!</span><span class="pl-en">callback</span>(value, index, collection));</td>
+ </tr>
+ <tr>
+ <td id="L7008" class="blob-num js-line-number" data-line-number="7008"></td>
+ <td id="LC7008" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7009" class="blob-num js-line-number" data-line-number="7009"></td>
+ <td id="LC7009" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7010" class="blob-num js-line-number" data-line-number="7010"></td>
+ <td id="LC7010" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7011" class="blob-num js-line-number" data-line-number="7011"></td>
+ <td id="LC7011" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7012" class="blob-num js-line-number" data-line-number="7012"></td>
+ <td id="LC7012" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7013" class="blob-num js-line-number" data-line-number="7013"></td>
+ <td id="LC7013" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7014" class="blob-num js-line-number" data-line-number="7014"></td>
+ <td id="LC7014" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Iterates over elements of a collection, returning an array of all elements</span></td>
+ </tr>
+ <tr>
+ <td id="L7015" class="blob-num js-line-number" data-line-number="7015"></td>
+ <td id="LC7015" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the callback returns truey for. The callback is bound to `thisArg` and</span></td>
+ </tr>
+ <tr>
+ <td id="L7016" class="blob-num js-line-number" data-line-number="7016"></td>
+ <td id="LC7016" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked with three arguments; (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7017" class="blob-num js-line-number" data-line-number="7017"></td>
+ <td id="LC7017" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7018" class="blob-num js-line-number" data-line-number="7018"></td>
+ <td id="LC7018" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7019" class="blob-num js-line-number" data-line-number="7019"></td>
+ <td id="LC7019" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7020" class="blob-num js-line-number" data-line-number="7020"></td>
+ <td id="LC7020" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7021" class="blob-num js-line-number" data-line-number="7021"></td>
+ <td id="LC7021" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7022" class="blob-num js-line-number" data-line-number="7022"></td>
+ <td id="LC7022" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7023" class="blob-num js-line-number" data-line-number="7023"></td>
+ <td id="LC7023" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7024" class="blob-num js-line-number" data-line-number="7024"></td>
+ <td id="LC7024" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7025" class="blob-num js-line-number" data-line-number="7025"></td>
+ <td id="LC7025" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7026" class="blob-num js-line-number" data-line-number="7026"></td>
+ <td id="LC7026" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7027" class="blob-num js-line-number" data-line-number="7027"></td>
+ <td id="LC7027" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> select</span></td>
+ </tr>
+ <tr>
+ <td id="L7028" class="blob-num js-line-number" data-line-number="7028"></td>
+ <td id="LC7028" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7029" class="blob-num js-line-number" data-line-number="7029"></td>
+ <td id="LC7029" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7030" class="blob-num js-line-number" data-line-number="7030"></td>
+ <td id="LC7030" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7031" class="blob-num js-line-number" data-line-number="7031"></td>
+ <td id="LC7031" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7032" class="blob-num js-line-number" data-line-number="7032"></td>
+ <td id="LC7032" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7033" class="blob-num js-line-number" data-line-number="7033"></td>
+ <td id="LC7033" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7034" class="blob-num js-line-number" data-line-number="7034"></td>
+ <td id="LC7034" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of elements that passed the callback check.</span></td>
+ </tr>
+ <tr>
+ <td id="L7035" class="blob-num js-line-number" data-line-number="7035"></td>
+ <td id="LC7035" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7036" class="blob-num js-line-number" data-line-number="7036"></td>
+ <td id="LC7036" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7037" class="blob-num js-line-number" data-line-number="7037"></td>
+ <td id="LC7037" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });</span></td>
+ </tr>
+ <tr>
+ <td id="L7038" class="blob-num js-line-number" data-line-number="7038"></td>
+ <td id="LC7038" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 4, 6]</span></td>
+ </tr>
+ <tr>
+ <td id="L7039" class="blob-num js-line-number" data-line-number="7039"></td>
+ <td id="LC7039" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7040" class="blob-num js-line-number" data-line-number="7040"></td>
+ <td id="LC7040" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7041" class="blob-num js-line-number" data-line-number="7041"></td>
+ <td id="LC7041" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L7042" class="blob-num js-line-number" data-line-number="7042"></td>
+ <td id="LC7042" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'blocked': true }</span></td>
+ </tr>
+ <tr>
+ <td id="L7043" class="blob-num js-line-number" data-line-number="7043"></td>
+ <td id="LC7043" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7044" class="blob-num js-line-number" data-line-number="7044"></td>
+ <td id="LC7044" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7045" class="blob-num js-line-number" data-line-number="7045"></td>
+ <td id="LC7045" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7046" class="blob-num js-line-number" data-line-number="7046"></td>
+ <td id="LC7046" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.filter(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L7047" class="blob-num js-line-number" data-line-number="7047"></td>
+ <td id="LC7047" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]</span></td>
+ </tr>
+ <tr>
+ <td id="L7048" class="blob-num js-line-number" data-line-number="7048"></td>
+ <td id="LC7048" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7049" class="blob-num js-line-number" data-line-number="7049"></td>
+ <td id="LC7049" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7050" class="blob-num js-line-number" data-line-number="7050"></td>
+ <td id="LC7050" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.filter(characters, { 'age': 36 });</span></td>
+ </tr>
+ <tr>
+ <td id="L7051" class="blob-num js-line-number" data-line-number="7051"></td>
+ <td id="LC7051" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]</span></td>
+ </tr>
+ <tr>
+ <td id="L7052" class="blob-num js-line-number" data-line-number="7052"></td>
+ <td id="LC7052" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7053" class="blob-num js-line-number" data-line-number="7053"></td>
+ <td id="LC7053" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">filter</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7054" class="blob-num js-line-number" data-line-number="7054"></td>
+ <td id="LC7054" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L7055" class="blob-num js-line-number" data-line-number="7055"></td>
+ <td id="LC7055" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7056" class="blob-num js-line-number" data-line-number="7056"></td>
+ <td id="LC7056" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7057" class="blob-num js-line-number" data-line-number="7057"></td>
+ <td id="LC7057" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7058" class="blob-num js-line-number" data-line-number="7058"></td>
+ <td id="LC7058" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7059" class="blob-num js-line-number" data-line-number="7059"></td>
+ <td id="LC7059" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7060" class="blob-num js-line-number" data-line-number="7060"></td>
+ <td id="LC7060" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7061" class="blob-num js-line-number" data-line-number="7061"></td>
+ <td id="LC7061" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7062" class="blob-num js-line-number" data-line-number="7062"></td>
+ <td id="LC7062" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> collection[index];</td>
+ </tr>
+ <tr>
+ <td id="L7063" class="blob-num js-line-number" data-line-number="7063"></td>
+ <td id="LC7063" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, index, collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7064" class="blob-num js-line-number" data-line-number="7064"></td>
+ <td id="LC7064" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L7065" class="blob-num js-line-number" data-line-number="7065"></td>
+ <td id="LC7065" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7066" class="blob-num js-line-number" data-line-number="7066"></td>
+ <td id="LC7066" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7067" class="blob-num js-line-number" data-line-number="7067"></td>
+ <td id="LC7067" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7068" class="blob-num js-line-number" data-line-number="7068"></td>
+ <td id="LC7068" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7069" class="blob-num js-line-number" data-line-number="7069"></td>
+ <td id="LC7069" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, index, collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7070" class="blob-num js-line-number" data-line-number="7070"></td>
+ <td id="LC7070" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L7071" class="blob-num js-line-number" data-line-number="7071"></td>
+ <td id="LC7071" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7072" class="blob-num js-line-number" data-line-number="7072"></td>
+ <td id="LC7072" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7073" class="blob-num js-line-number" data-line-number="7073"></td>
+ <td id="LC7073" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7074" class="blob-num js-line-number" data-line-number="7074"></td>
+ <td id="LC7074" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7075" class="blob-num js-line-number" data-line-number="7075"></td>
+ <td id="LC7075" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7076" class="blob-num js-line-number" data-line-number="7076"></td>
+ <td id="LC7076" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7077" class="blob-num js-line-number" data-line-number="7077"></td>
+ <td id="LC7077" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7078" class="blob-num js-line-number" data-line-number="7078"></td>
+ <td id="LC7078" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Iterates over elements of a collection, returning the first element that</span></td>
+ </tr>
+ <tr>
+ <td id="L7079" class="blob-num js-line-number" data-line-number="7079"></td>
+ <td id="LC7079" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the callback returns truey for. The callback is bound to `thisArg` and</span></td>
+ </tr>
+ <tr>
+ <td id="L7080" class="blob-num js-line-number" data-line-number="7080"></td>
+ <td id="LC7080" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked with three arguments; (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7081" class="blob-num js-line-number" data-line-number="7081"></td>
+ <td id="LC7081" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7082" class="blob-num js-line-number" data-line-number="7082"></td>
+ <td id="LC7082" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7083" class="blob-num js-line-number" data-line-number="7083"></td>
+ <td id="LC7083" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7084" class="blob-num js-line-number" data-line-number="7084"></td>
+ <td id="LC7084" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7085" class="blob-num js-line-number" data-line-number="7085"></td>
+ <td id="LC7085" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7086" class="blob-num js-line-number" data-line-number="7086"></td>
+ <td id="LC7086" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7087" class="blob-num js-line-number" data-line-number="7087"></td>
+ <td id="LC7087" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7088" class="blob-num js-line-number" data-line-number="7088"></td>
+ <td id="LC7088" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7089" class="blob-num js-line-number" data-line-number="7089"></td>
+ <td id="LC7089" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7090" class="blob-num js-line-number" data-line-number="7090"></td>
+ <td id="LC7090" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7091" class="blob-num js-line-number" data-line-number="7091"></td>
+ <td id="LC7091" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> detect, findWhere</span></td>
+ </tr>
+ <tr>
+ <td id="L7092" class="blob-num js-line-number" data-line-number="7092"></td>
+ <td id="LC7092" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7093" class="blob-num js-line-number" data-line-number="7093"></td>
+ <td id="LC7093" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7094" class="blob-num js-line-number" data-line-number="7094"></td>
+ <td id="LC7094" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7095" class="blob-num js-line-number" data-line-number="7095"></td>
+ <td id="LC7095" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7096" class="blob-num js-line-number" data-line-number="7096"></td>
+ <td id="LC7096" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7097" class="blob-num js-line-number" data-line-number="7097"></td>
+ <td id="LC7097" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7098" class="blob-num js-line-number" data-line-number="7098"></td>
+ <td id="LC7098" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the found element, else `undefined`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7099" class="blob-num js-line-number" data-line-number="7099"></td>
+ <td id="LC7099" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7100" class="blob-num js-line-number" data-line-number="7100"></td>
+ <td id="LC7100" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7101" class="blob-num js-line-number" data-line-number="7101"></td>
+ <td id="LC7101" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7102" class="blob-num js-line-number" data-line-number="7102"></td>
+ <td id="LC7102" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L7103" class="blob-num js-line-number" data-line-number="7103"></td>
+ <td id="LC7103" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'blocked': true },</span></td>
+ </tr>
+ <tr>
+ <td id="L7104" class="blob-num js-line-number" data-line-number="7104"></td>
+ <td id="LC7104" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'age': 1, 'blocked': false }</span></td>
+ </tr>
+ <tr>
+ <td id="L7105" class="blob-num js-line-number" data-line-number="7105"></td>
+ <td id="LC7105" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7106" class="blob-num js-line-number" data-line-number="7106"></td>
+ <td id="LC7106" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7107" class="blob-num js-line-number" data-line-number="7107"></td>
+ <td id="LC7107" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.find(characters, function(chr) {</span></td>
+ </tr>
+ <tr>
+ <td id="L7108" class="blob-num js-line-number" data-line-number="7108"></td>
+ <td id="LC7108" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return chr.age < 40;</span></td>
+ </tr>
+ <tr>
+ <td id="L7109" class="blob-num js-line-number" data-line-number="7109"></td>
+ <td id="LC7109" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L7110" class="blob-num js-line-number" data-line-number="7110"></td>
+ <td id="LC7110" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'barney', 'age': 36, 'blocked': false }</span></td>
+ </tr>
+ <tr>
+ <td id="L7111" class="blob-num js-line-number" data-line-number="7111"></td>
+ <td id="LC7111" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7112" class="blob-num js-line-number" data-line-number="7112"></td>
+ <td id="LC7112" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7113" class="blob-num js-line-number" data-line-number="7113"></td>
+ <td id="LC7113" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.find(characters, { 'age': 1 });</span></td>
+ </tr>
+ <tr>
+ <td id="L7114" class="blob-num js-line-number" data-line-number="7114"></td>
+ <td id="LC7114" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'pebbles', 'age': 1, 'blocked': false }</span></td>
+ </tr>
+ <tr>
+ <td id="L7115" class="blob-num js-line-number" data-line-number="7115"></td>
+ <td id="LC7115" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7116" class="blob-num js-line-number" data-line-number="7116"></td>
+ <td id="LC7116" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7117" class="blob-num js-line-number" data-line-number="7117"></td>
+ <td id="LC7117" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.find(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L7118" class="blob-num js-line-number" data-line-number="7118"></td>
+ <td id="LC7118" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred', 'age': 40, 'blocked': true }</span></td>
+ </tr>
+ <tr>
+ <td id="L7119" class="blob-num js-line-number" data-line-number="7119"></td>
+ <td id="LC7119" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7120" class="blob-num js-line-number" data-line-number="7120"></td>
+ <td id="LC7120" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">find</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7121" class="blob-num js-line-number" data-line-number="7121"></td>
+ <td id="LC7121" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7122" class="blob-num js-line-number" data-line-number="7122"></td>
+ <td id="LC7122" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7123" class="blob-num js-line-number" data-line-number="7123"></td>
+ <td id="LC7123" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7124" class="blob-num js-line-number" data-line-number="7124"></td>
+ <td id="LC7124" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7125" class="blob-num js-line-number" data-line-number="7125"></td>
+ <td id="LC7125" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7126" class="blob-num js-line-number" data-line-number="7126"></td>
+ <td id="LC7126" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7127" class="blob-num js-line-number" data-line-number="7127"></td>
+ <td id="LC7127" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7128" class="blob-num js-line-number" data-line-number="7128"></td>
+ <td id="LC7128" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> collection[index];</td>
+ </tr>
+ <tr>
+ <td id="L7129" class="blob-num js-line-number" data-line-number="7129"></td>
+ <td id="LC7129" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, index, collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7130" class="blob-num js-line-number" data-line-number="7130"></td>
+ <td id="LC7130" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7131" class="blob-num js-line-number" data-line-number="7131"></td>
+ <td id="LC7131" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7132" class="blob-num js-line-number" data-line-number="7132"></td>
+ <td id="LC7132" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7133" class="blob-num js-line-number" data-line-number="7133"></td>
+ <td id="LC7133" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7134" class="blob-num js-line-number" data-line-number="7134"></td>
+ <td id="LC7134" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7135" class="blob-num js-line-number" data-line-number="7135"></td>
+ <td id="LC7135" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7136" class="blob-num js-line-number" data-line-number="7136"></td>
+ <td id="LC7136" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, index, collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7137" class="blob-num js-line-number" data-line-number="7137"></td>
+ <td id="LC7137" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7138" class="blob-num js-line-number" data-line-number="7138"></td>
+ <td id="LC7138" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7139" class="blob-num js-line-number" data-line-number="7139"></td>
+ <td id="LC7139" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7140" class="blob-num js-line-number" data-line-number="7140"></td>
+ <td id="LC7140" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7141" class="blob-num js-line-number" data-line-number="7141"></td>
+ <td id="LC7141" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7142" class="blob-num js-line-number" data-line-number="7142"></td>
+ <td id="LC7142" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7143" class="blob-num js-line-number" data-line-number="7143"></td>
+ <td id="LC7143" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7144" class="blob-num js-line-number" data-line-number="7144"></td>
+ <td id="LC7144" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7145" class="blob-num js-line-number" data-line-number="7145"></td>
+ <td id="LC7145" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7146" class="blob-num js-line-number" data-line-number="7146"></td>
+ <td id="LC7146" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.find` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L7147" class="blob-num js-line-number" data-line-number="7147"></td>
+ <td id="LC7147" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` from right to left.</span></td>
+ </tr>
+ <tr>
+ <td id="L7148" class="blob-num js-line-number" data-line-number="7148"></td>
+ <td id="LC7148" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7149" class="blob-num js-line-number" data-line-number="7149"></td>
+ <td id="LC7149" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7150" class="blob-num js-line-number" data-line-number="7150"></td>
+ <td id="LC7150" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7151" class="blob-num js-line-number" data-line-number="7151"></td>
+ <td id="LC7151" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7152" class="blob-num js-line-number" data-line-number="7152"></td>
+ <td id="LC7152" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7153" class="blob-num js-line-number" data-line-number="7153"></td>
+ <td id="LC7153" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7154" class="blob-num js-line-number" data-line-number="7154"></td>
+ <td id="LC7154" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7155" class="blob-num js-line-number" data-line-number="7155"></td>
+ <td id="LC7155" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7156" class="blob-num js-line-number" data-line-number="7156"></td>
+ <td id="LC7156" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7157" class="blob-num js-line-number" data-line-number="7157"></td>
+ <td id="LC7157" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the found element, else `undefined`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7158" class="blob-num js-line-number" data-line-number="7158"></td>
+ <td id="LC7158" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7159" class="blob-num js-line-number" data-line-number="7159"></td>
+ <td id="LC7159" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7160" class="blob-num js-line-number" data-line-number="7160"></td>
+ <td id="LC7160" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLast([1, 2, 3, 4], function(num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L7161" class="blob-num js-line-number" data-line-number="7161"></td>
+ <td id="LC7161" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return num % 2 == 1;</span></td>
+ </tr>
+ <tr>
+ <td id="L7162" class="blob-num js-line-number" data-line-number="7162"></td>
+ <td id="LC7162" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L7163" class="blob-num js-line-number" data-line-number="7163"></td>
+ <td id="LC7163" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 3</span></td>
+ </tr>
+ <tr>
+ <td id="L7164" class="blob-num js-line-number" data-line-number="7164"></td>
+ <td id="LC7164" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7165" class="blob-num js-line-number" data-line-number="7165"></td>
+ <td id="LC7165" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">findLast</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7166" class="blob-num js-line-number" data-line-number="7166"></td>
+ <td id="LC7166" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7167" class="blob-num js-line-number" data-line-number="7167"></td>
+ <td id="LC7167" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7168" class="blob-num js-line-number" data-line-number="7168"></td>
+ <td id="LC7168" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEachRight</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7169" class="blob-num js-line-number" data-line-number="7169"></td>
+ <td id="LC7169" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, index, collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7170" class="blob-num js-line-number" data-line-number="7170"></td>
+ <td id="LC7170" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7171" class="blob-num js-line-number" data-line-number="7171"></td>
+ <td id="LC7171" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7172" class="blob-num js-line-number" data-line-number="7172"></td>
+ <td id="LC7172" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7173" class="blob-num js-line-number" data-line-number="7173"></td>
+ <td id="LC7173" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7174" class="blob-num js-line-number" data-line-number="7174"></td>
+ <td id="LC7174" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7175" class="blob-num js-line-number" data-line-number="7175"></td>
+ <td id="LC7175" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7176" class="blob-num js-line-number" data-line-number="7176"></td>
+ <td id="LC7176" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7177" class="blob-num js-line-number" data-line-number="7177"></td>
+ <td id="LC7177" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7178" class="blob-num js-line-number" data-line-number="7178"></td>
+ <td id="LC7178" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Iterates over elements of a collection, executing the callback for each</span></td>
+ </tr>
+ <tr>
+ <td id="L7179" class="blob-num js-line-number" data-line-number="7179"></td>
+ <td id="LC7179" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * element. The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L7180" class="blob-num js-line-number" data-line-number="7180"></td>
+ <td id="LC7180" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, index|key, collection). Callbacks may exit iteration early by</span></td>
+ </tr>
+ <tr>
+ <td id="L7181" class="blob-num js-line-number" data-line-number="7181"></td>
+ <td id="LC7181" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * explicitly returning `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7182" class="blob-num js-line-number" data-line-number="7182"></td>
+ <td id="LC7182" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7183" class="blob-num js-line-number" data-line-number="7183"></td>
+ <td id="LC7183" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: As with other "Collections" methods, objects with a `length` property</span></td>
+ </tr>
+ <tr>
+ <td id="L7184" class="blob-num js-line-number" data-line-number="7184"></td>
+ <td id="LC7184" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`</span></td>
+ </tr>
+ <tr>
+ <td id="L7185" class="blob-num js-line-number" data-line-number="7185"></td>
+ <td id="LC7185" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * may be used for object iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L7186" class="blob-num js-line-number" data-line-number="7186"></td>
+ <td id="LC7186" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7187" class="blob-num js-line-number" data-line-number="7187"></td>
+ <td id="LC7187" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7188" class="blob-num js-line-number" data-line-number="7188"></td>
+ <td id="LC7188" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7189" class="blob-num js-line-number" data-line-number="7189"></td>
+ <td id="LC7189" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> each</span></td>
+ </tr>
+ <tr>
+ <td id="L7190" class="blob-num js-line-number" data-line-number="7190"></td>
+ <td id="LC7190" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7191" class="blob-num js-line-number" data-line-number="7191"></td>
+ <td id="LC7191" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7192" class="blob-num js-line-number" data-line-number="7192"></td>
+ <td id="LC7192" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L7193" class="blob-num js-line-number" data-line-number="7193"></td>
+ <td id="LC7193" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7194" class="blob-num js-line-number" data-line-number="7194"></td>
+ <td id="LC7194" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {Array|Object|string} Returns `collection`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7195" class="blob-num js-line-number" data-line-number="7195"></td>
+ <td id="LC7195" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7196" class="blob-num js-line-number" data-line-number="7196"></td>
+ <td id="LC7196" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7197" class="blob-num js-line-number" data-line-number="7197"></td>
+ <td id="LC7197" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');</span></td>
+ </tr>
+ <tr>
+ <td id="L7198" class="blob-num js-line-number" data-line-number="7198"></td>
+ <td id="LC7198" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs each number and returns '1,2,3'</span></td>
+ </tr>
+ <tr>
+ <td id="L7199" class="blob-num js-line-number" data-line-number="7199"></td>
+ <td id="LC7199" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7200" class="blob-num js-line-number" data-line-number="7200"></td>
+ <td id="LC7200" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });</span></td>
+ </tr>
+ <tr>
+ <td id="L7201" class="blob-num js-line-number" data-line-number="7201"></td>
+ <td id="LC7201" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs each number and returns the object (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L7202" class="blob-num js-line-number" data-line-number="7202"></td>
+ <td id="LC7202" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7203" class="blob-num js-line-number" data-line-number="7203"></td>
+ <td id="LC7203" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">forEach</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7204" class="blob-num js-line-number" data-line-number="7204"></td>
+ <td id="LC7204" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7205" class="blob-num js-line-number" data-line-number="7205"></td>
+ <td id="LC7205" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7206" class="blob-num js-line-number" data-line-number="7206"></td>
+ <td id="LC7206" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7207" class="blob-num js-line-number" data-line-number="7207"></td>
+ <td id="LC7207" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> callback <span class="pl-k">&&</span> <span class="pl-k">typeof</span> thisArg <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span> <span class="pl-k">?</span> callback <span class="pl-k">:</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7208" class="blob-num js-line-number" data-line-number="7208"></td>
+ <td id="LC7208" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7209" class="blob-num js-line-number" data-line-number="7209"></td>
+ <td id="LC7209" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7210" class="blob-num js-line-number" data-line-number="7210"></td>
+ <td id="LC7210" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(collection[index], index, collection) <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7211" class="blob-num js-line-number" data-line-number="7211"></td>
+ <td id="LC7211" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7212" class="blob-num js-line-number" data-line-number="7212"></td>
+ <td id="LC7212" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7213" class="blob-num js-line-number" data-line-number="7213"></td>
+ <td id="LC7213" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7214" class="blob-num js-line-number" data-line-number="7214"></td>
+ <td id="LC7214" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7215" class="blob-num js-line-number" data-line-number="7215"></td>
+ <td id="LC7215" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, callback);</td>
+ </tr>
+ <tr>
+ <td id="L7216" class="blob-num js-line-number" data-line-number="7216"></td>
+ <td id="LC7216" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7217" class="blob-num js-line-number" data-line-number="7217"></td>
+ <td id="LC7217" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> collection;</td>
+ </tr>
+ <tr>
+ <td id="L7218" class="blob-num js-line-number" data-line-number="7218"></td>
+ <td id="LC7218" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7219" class="blob-num js-line-number" data-line-number="7219"></td>
+ <td id="LC7219" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7220" class="blob-num js-line-number" data-line-number="7220"></td>
+ <td id="LC7220" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7221" class="blob-num js-line-number" data-line-number="7221"></td>
+ <td id="LC7221" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.forEach` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L7222" class="blob-num js-line-number" data-line-number="7222"></td>
+ <td id="LC7222" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` from right to left.</span></td>
+ </tr>
+ <tr>
+ <td id="L7223" class="blob-num js-line-number" data-line-number="7223"></td>
+ <td id="LC7223" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7224" class="blob-num js-line-number" data-line-number="7224"></td>
+ <td id="LC7224" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7225" class="blob-num js-line-number" data-line-number="7225"></td>
+ <td id="LC7225" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7226" class="blob-num js-line-number" data-line-number="7226"></td>
+ <td id="LC7226" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> eachRight</span></td>
+ </tr>
+ <tr>
+ <td id="L7227" class="blob-num js-line-number" data-line-number="7227"></td>
+ <td id="LC7227" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7228" class="blob-num js-line-number" data-line-number="7228"></td>
+ <td id="LC7228" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7229" class="blob-num js-line-number" data-line-number="7229"></td>
+ <td id="LC7229" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L7230" class="blob-num js-line-number" data-line-number="7230"></td>
+ <td id="LC7230" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7231" class="blob-num js-line-number" data-line-number="7231"></td>
+ <td id="LC7231" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {Array|Object|string} Returns `collection`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7232" class="blob-num js-line-number" data-line-number="7232"></td>
+ <td id="LC7232" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7233" class="blob-num js-line-number" data-line-number="7233"></td>
+ <td id="LC7233" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7234" class="blob-num js-line-number" data-line-number="7234"></td>
+ <td id="LC7234" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(',');</span></td>
+ </tr>
+ <tr>
+ <td id="L7235" class="blob-num js-line-number" data-line-number="7235"></td>
+ <td id="LC7235" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs each number from right to left and returns '3,2,1'</span></td>
+ </tr>
+ <tr>
+ <td id="L7236" class="blob-num js-line-number" data-line-number="7236"></td>
+ <td id="LC7236" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7237" class="blob-num js-line-number" data-line-number="7237"></td>
+ <td id="LC7237" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">forEachRight</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7238" class="blob-num js-line-number" data-line-number="7238"></td>
+ <td id="LC7238" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7239" class="blob-num js-line-number" data-line-number="7239"></td>
+ <td id="LC7239" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> callback <span class="pl-k">&&</span> <span class="pl-k">typeof</span> thisArg <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>undefined<span class="pl-pds">'</span></span> <span class="pl-k">?</span> callback <span class="pl-k">:</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7240" class="blob-num js-line-number" data-line-number="7240"></td>
+ <td id="LC7240" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7241" class="blob-num js-line-number" data-line-number="7241"></td>
+ <td id="LC7241" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7242" class="blob-num js-line-number" data-line-number="7242"></td>
+ <td id="LC7242" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(collection[length], length, collection) <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7243" class="blob-num js-line-number" data-line-number="7243"></td>
+ <td id="LC7243" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7244" class="blob-num js-line-number" data-line-number="7244"></td>
+ <td id="LC7244" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7245" class="blob-num js-line-number" data-line-number="7245"></td>
+ <td id="LC7245" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7246" class="blob-num js-line-number" data-line-number="7246"></td>
+ <td id="LC7246" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7247" class="blob-num js-line-number" data-line-number="7247"></td>
+ <td id="LC7247" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> props <span class="pl-k">=</span> <span class="pl-en">keys</span>(collection);</td>
+ </tr>
+ <tr>
+ <td id="L7248" class="blob-num js-line-number" data-line-number="7248"></td>
+ <td id="LC7248" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7249" class="blob-num js-line-number" data-line-number="7249"></td>
+ <td id="LC7249" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7250" class="blob-num js-line-number" data-line-number="7250"></td>
+ <td id="LC7250" class="blob-code blob-code-inner js-file-line"> key <span class="pl-k">=</span> props <span class="pl-k">?</span> props[<span class="pl-k">--</span>length] <span class="pl-k">:</span> <span class="pl-k">--</span>length;</td>
+ </tr>
+ <tr>
+ <td id="L7251" class="blob-num js-line-number" data-line-number="7251"></td>
+ <td id="LC7251" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">callback</span>(collection[key], key, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7252" class="blob-num js-line-number" data-line-number="7252"></td>
+ <td id="LC7252" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7253" class="blob-num js-line-number" data-line-number="7253"></td>
+ <td id="LC7253" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7254" class="blob-num js-line-number" data-line-number="7254"></td>
+ <td id="LC7254" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> collection;</td>
+ </tr>
+ <tr>
+ <td id="L7255" class="blob-num js-line-number" data-line-number="7255"></td>
+ <td id="LC7255" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7256" class="blob-num js-line-number" data-line-number="7256"></td>
+ <td id="LC7256" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7257" class="blob-num js-line-number" data-line-number="7257"></td>
+ <td id="LC7257" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7258" class="blob-num js-line-number" data-line-number="7258"></td>
+ <td id="LC7258" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object composed of keys generated from the results of running</span></td>
+ </tr>
+ <tr>
+ <td id="L7259" class="blob-num js-line-number" data-line-number="7259"></td>
+ <td id="LC7259" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * each element of a collection through the callback. The corresponding value</span></td>
+ </tr>
+ <tr>
+ <td id="L7260" class="blob-num js-line-number" data-line-number="7260"></td>
+ <td id="LC7260" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of each key is an array of the elements responsible for generating the key.</span></td>
+ </tr>
+ <tr>
+ <td id="L7261" class="blob-num js-line-number" data-line-number="7261"></td>
+ <td id="LC7261" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L7262" class="blob-num js-line-number" data-line-number="7262"></td>
+ <td id="LC7262" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7263" class="blob-num js-line-number" data-line-number="7263"></td>
+ <td id="LC7263" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7264" class="blob-num js-line-number" data-line-number="7264"></td>
+ <td id="LC7264" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7265" class="blob-num js-line-number" data-line-number="7265"></td>
+ <td id="LC7265" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7266" class="blob-num js-line-number" data-line-number="7266"></td>
+ <td id="LC7266" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7267" class="blob-num js-line-number" data-line-number="7267"></td>
+ <td id="LC7267" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7268" class="blob-num js-line-number" data-line-number="7268"></td>
+ <td id="LC7268" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7269" class="blob-num js-line-number" data-line-number="7269"></td>
+ <td id="LC7269" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`</span></td>
+ </tr>
+ <tr>
+ <td id="L7270" class="blob-num js-line-number" data-line-number="7270"></td>
+ <td id="LC7270" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7271" class="blob-num js-line-number" data-line-number="7271"></td>
+ <td id="LC7271" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7272" class="blob-num js-line-number" data-line-number="7272"></td>
+ <td id="LC7272" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7273" class="blob-num js-line-number" data-line-number="7273"></td>
+ <td id="LC7273" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7274" class="blob-num js-line-number" data-line-number="7274"></td>
+ <td id="LC7274" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7275" class="blob-num js-line-number" data-line-number="7275"></td>
+ <td id="LC7275" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7276" class="blob-num js-line-number" data-line-number="7276"></td>
+ <td id="LC7276" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7277" class="blob-num js-line-number" data-line-number="7277"></td>
+ <td id="LC7277" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7278" class="blob-num js-line-number" data-line-number="7278"></td>
+ <td id="LC7278" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7279" class="blob-num js-line-number" data-line-number="7279"></td>
+ <td id="LC7279" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the composed aggregate object.</span></td>
+ </tr>
+ <tr>
+ <td id="L7280" class="blob-num js-line-number" data-line-number="7280"></td>
+ <td id="LC7280" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7281" class="blob-num js-line-number" data-line-number="7281"></td>
+ <td id="LC7281" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7282" class="blob-num js-line-number" data-line-number="7282"></td>
+ <td id="LC7282" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });</span></td>
+ </tr>
+ <tr>
+ <td id="L7283" class="blob-num js-line-number" data-line-number="7283"></td>
+ <td id="LC7283" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '4': [4.2], '6': [6.1, 6.4] }</span></td>
+ </tr>
+ <tr>
+ <td id="L7284" class="blob-num js-line-number" data-line-number="7284"></td>
+ <td id="LC7284" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7285" class="blob-num js-line-number" data-line-number="7285"></td>
+ <td id="LC7285" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);</span></td>
+ </tr>
+ <tr>
+ <td id="L7286" class="blob-num js-line-number" data-line-number="7286"></td>
+ <td id="LC7286" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '4': [4.2], '6': [6.1, 6.4] }</span></td>
+ </tr>
+ <tr>
+ <td id="L7287" class="blob-num js-line-number" data-line-number="7287"></td>
+ <td id="LC7287" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7288" class="blob-num js-line-number" data-line-number="7288"></td>
+ <td id="LC7288" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7289" class="blob-num js-line-number" data-line-number="7289"></td>
+ <td id="LC7289" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.groupBy(['one', 'two', 'three'], 'length');</span></td>
+ </tr>
+ <tr>
+ <td id="L7290" class="blob-num js-line-number" data-line-number="7290"></td>
+ <td id="LC7290" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '3': ['one', 'two'], '5': ['three'] }</span></td>
+ </tr>
+ <tr>
+ <td id="L7291" class="blob-num js-line-number" data-line-number="7291"></td>
+ <td id="LC7291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7292" class="blob-num js-line-number" data-line-number="7292"></td>
+ <td id="LC7292" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> groupBy <span class="pl-k">=</span> <span class="pl-en">createAggregator</span>(<span class="pl-k">function</span>(<span class="pl-smi">result</span>, <span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7293" class="blob-num js-line-number" data-line-number="7293"></td>
+ <td id="LC7293" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(result, key) <span class="pl-k">?</span> result[key] <span class="pl-k">:</span> result[key] <span class="pl-k">=</span> []).<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L7294" class="blob-num js-line-number" data-line-number="7294"></td>
+ <td id="LC7294" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7295" class="blob-num js-line-number" data-line-number="7295"></td>
+ <td id="LC7295" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7296" class="blob-num js-line-number" data-line-number="7296"></td>
+ <td id="LC7296" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7297" class="blob-num js-line-number" data-line-number="7297"></td>
+ <td id="LC7297" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object composed of keys generated from the results of running</span></td>
+ </tr>
+ <tr>
+ <td id="L7298" class="blob-num js-line-number" data-line-number="7298"></td>
+ <td id="LC7298" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * each element of the collection through the given callback. The corresponding</span></td>
+ </tr>
+ <tr>
+ <td id="L7299" class="blob-num js-line-number" data-line-number="7299"></td>
+ <td id="LC7299" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * value of each key is the last element responsible for generating the key.</span></td>
+ </tr>
+ <tr>
+ <td id="L7300" class="blob-num js-line-number" data-line-number="7300"></td>
+ <td id="LC7300" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The callback is bound to `thisArg` and invoked with three arguments;</span></td>
+ </tr>
+ <tr>
+ <td id="L7301" class="blob-num js-line-number" data-line-number="7301"></td>
+ <td id="LC7301" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7302" class="blob-num js-line-number" data-line-number="7302"></td>
+ <td id="LC7302" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7303" class="blob-num js-line-number" data-line-number="7303"></td>
+ <td id="LC7303" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7304" class="blob-num js-line-number" data-line-number="7304"></td>
+ <td id="LC7304" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7305" class="blob-num js-line-number" data-line-number="7305"></td>
+ <td id="LC7305" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7306" class="blob-num js-line-number" data-line-number="7306"></td>
+ <td id="LC7306" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7307" class="blob-num js-line-number" data-line-number="7307"></td>
+ <td id="LC7307" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7308" class="blob-num js-line-number" data-line-number="7308"></td>
+ <td id="LC7308" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7309" class="blob-num js-line-number" data-line-number="7309"></td>
+ <td id="LC7309" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7310" class="blob-num js-line-number" data-line-number="7310"></td>
+ <td id="LC7310" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7311" class="blob-num js-line-number" data-line-number="7311"></td>
+ <td id="LC7311" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7312" class="blob-num js-line-number" data-line-number="7312"></td>
+ <td id="LC7312" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7313" class="blob-num js-line-number" data-line-number="7313"></td>
+ <td id="LC7313" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7314" class="blob-num js-line-number" data-line-number="7314"></td>
+ <td id="LC7314" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7315" class="blob-num js-line-number" data-line-number="7315"></td>
+ <td id="LC7315" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7316" class="blob-num js-line-number" data-line-number="7316"></td>
+ <td id="LC7316" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7317" class="blob-num js-line-number" data-line-number="7317"></td>
+ <td id="LC7317" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7318" class="blob-num js-line-number" data-line-number="7318"></td>
+ <td id="LC7318" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the composed aggregate object.</span></td>
+ </tr>
+ <tr>
+ <td id="L7319" class="blob-num js-line-number" data-line-number="7319"></td>
+ <td id="LC7319" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7320" class="blob-num js-line-number" data-line-number="7320"></td>
+ <td id="LC7320" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7321" class="blob-num js-line-number" data-line-number="7321"></td>
+ <td id="LC7321" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var keys = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7322" class="blob-num js-line-number" data-line-number="7322"></td>
+ <td id="LC7322" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'dir': 'left', 'code': 97 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7323" class="blob-num js-line-number" data-line-number="7323"></td>
+ <td id="LC7323" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'dir': 'right', 'code': 100 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7324" class="blob-num js-line-number" data-line-number="7324"></td>
+ <td id="LC7324" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7325" class="blob-num js-line-number" data-line-number="7325"></td>
+ <td id="LC7325" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7326" class="blob-num js-line-number" data-line-number="7326"></td>
+ <td id="LC7326" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.indexBy(keys, 'dir');</span></td>
+ </tr>
+ <tr>
+ <td id="L7327" class="blob-num js-line-number" data-line-number="7327"></td>
+ <td id="LC7327" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }</span></td>
+ </tr>
+ <tr>
+ <td id="L7328" class="blob-num js-line-number" data-line-number="7328"></td>
+ <td id="LC7328" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7329" class="blob-num js-line-number" data-line-number="7329"></td>
+ <td id="LC7329" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); });</span></td>
+ </tr>
+ <tr>
+ <td id="L7330" class="blob-num js-line-number" data-line-number="7330"></td>
+ <td id="LC7330" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }</span></td>
+ </tr>
+ <tr>
+ <td id="L7331" class="blob-num js-line-number" data-line-number="7331"></td>
+ <td id="LC7331" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7332" class="blob-num js-line-number" data-line-number="7332"></td>
+ <td id="LC7332" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String);</span></td>
+ </tr>
+ <tr>
+ <td id="L7333" class="blob-num js-line-number" data-line-number="7333"></td>
+ <td id="LC7333" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }</span></td>
+ </tr>
+ <tr>
+ <td id="L7334" class="blob-num js-line-number" data-line-number="7334"></td>
+ <td id="LC7334" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7335" class="blob-num js-line-number" data-line-number="7335"></td>
+ <td id="LC7335" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> indexBy <span class="pl-k">=</span> <span class="pl-en">createAggregator</span>(<span class="pl-k">function</span>(<span class="pl-smi">result</span>, <span class="pl-smi">value</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7336" class="blob-num js-line-number" data-line-number="7336"></td>
+ <td id="LC7336" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7337" class="blob-num js-line-number" data-line-number="7337"></td>
+ <td id="LC7337" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7338" class="blob-num js-line-number" data-line-number="7338"></td>
+ <td id="LC7338" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7339" class="blob-num js-line-number" data-line-number="7339"></td>
+ <td id="LC7339" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7340" class="blob-num js-line-number" data-line-number="7340"></td>
+ <td id="LC7340" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Invokes the method named by `methodName` on each element in the `collection`</span></td>
+ </tr>
+ <tr>
+ <td id="L7341" class="blob-num js-line-number" data-line-number="7341"></td>
+ <td id="LC7341" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * returning an array of the results of each invoked method. Additional arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L7342" class="blob-num js-line-number" data-line-number="7342"></td>
+ <td id="LC7342" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will be provided to each invoked method. If `methodName` is a function it</span></td>
+ </tr>
+ <tr>
+ <td id="L7343" class="blob-num js-line-number" data-line-number="7343"></td>
+ <td id="LC7343" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will be invoked for, and `this` bound to, each element in the `collection`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7344" class="blob-num js-line-number" data-line-number="7344"></td>
+ <td id="LC7344" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7345" class="blob-num js-line-number" data-line-number="7345"></td>
+ <td id="LC7345" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7346" class="blob-num js-line-number" data-line-number="7346"></td>
+ <td id="LC7346" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7347" class="blob-num js-line-number" data-line-number="7347"></td>
+ <td id="LC7347" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7348" class="blob-num js-line-number" data-line-number="7348"></td>
+ <td id="LC7348" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7349" class="blob-num js-line-number" data-line-number="7349"></td>
+ <td id="LC7349" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|string} methodName The name of the method to invoke or</span></td>
+ </tr>
+ <tr>
+ <td id="L7350" class="blob-num js-line-number" data-line-number="7350"></td>
+ <td id="LC7350" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the function invoked per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L7351" class="blob-num js-line-number" data-line-number="7351"></td>
+ <td id="LC7351" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to invoke the method with.</span></td>
+ </tr>
+ <tr>
+ <td id="L7352" class="blob-num js-line-number" data-line-number="7352"></td>
+ <td id="LC7352" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of the results of each invoked method.</span></td>
+ </tr>
+ <tr>
+ <td id="L7353" class="blob-num js-line-number" data-line-number="7353"></td>
+ <td id="LC7353" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7354" class="blob-num js-line-number" data-line-number="7354"></td>
+ <td id="LC7354" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7355" class="blob-num js-line-number" data-line-number="7355"></td>
+ <td id="LC7355" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');</span></td>
+ </tr>
+ <tr>
+ <td id="L7356" class="blob-num js-line-number" data-line-number="7356"></td>
+ <td id="LC7356" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [[1, 5, 7], [1, 2, 3]]</span></td>
+ </tr>
+ <tr>
+ <td id="L7357" class="blob-num js-line-number" data-line-number="7357"></td>
+ <td id="LC7357" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7358" class="blob-num js-line-number" data-line-number="7358"></td>
+ <td id="LC7358" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.invoke([123, 456], String.prototype.split, '');</span></td>
+ </tr>
+ <tr>
+ <td id="L7359" class="blob-num js-line-number" data-line-number="7359"></td>
+ <td id="LC7359" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [['1', '2', '3'], ['4', '5', '6']]</span></td>
+ </tr>
+ <tr>
+ <td id="L7360" class="blob-num js-line-number" data-line-number="7360"></td>
+ <td id="LC7360" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7361" class="blob-num js-line-number" data-line-number="7361"></td>
+ <td id="LC7361" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">invoke</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">methodName</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7362" class="blob-num js-line-number" data-line-number="7362"></td>
+ <td id="LC7362" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">2</span>),</td>
+ </tr>
+ <tr>
+ <td id="L7363" class="blob-num js-line-number" data-line-number="7363"></td>
+ <td id="LC7363" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7364" class="blob-num js-line-number" data-line-number="7364"></td>
+ <td id="LC7364" class="blob-code blob-code-inner js-file-line"> isFunc <span class="pl-k">=</span> <span class="pl-k">typeof</span> methodName <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>,</td>
+ </tr>
+ <tr>
+ <td id="L7365" class="blob-num js-line-number" data-line-number="7365"></td>
+ <td id="LC7365" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7366" class="blob-num js-line-number" data-line-number="7366"></td>
+ <td id="LC7366" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> length <span class="pl-k">:</span> <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7367" class="blob-num js-line-number" data-line-number="7367"></td>
+ <td id="LC7367" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7368" class="blob-num js-line-number" data-line-number="7368"></td>
+ <td id="LC7368" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7369" class="blob-num js-line-number" data-line-number="7369"></td>
+ <td id="LC7369" class="blob-code blob-code-inner js-file-line"> result[<span class="pl-k">++</span>index] <span class="pl-k">=</span> (isFunc <span class="pl-k">?</span> methodName <span class="pl-k">:</span> value[methodName]).<span class="pl-c1">apply</span>(value, args);</td>
+ </tr>
+ <tr>
+ <td id="L7370" class="blob-num js-line-number" data-line-number="7370"></td>
+ <td id="LC7370" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7371" class="blob-num js-line-number" data-line-number="7371"></td>
+ <td id="LC7371" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7372" class="blob-num js-line-number" data-line-number="7372"></td>
+ <td id="LC7372" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7373" class="blob-num js-line-number" data-line-number="7373"></td>
+ <td id="LC7373" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7374" class="blob-num js-line-number" data-line-number="7374"></td>
+ <td id="LC7374" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7375" class="blob-num js-line-number" data-line-number="7375"></td>
+ <td id="LC7375" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of values by running each element in the collection</span></td>
+ </tr>
+ <tr>
+ <td id="L7376" class="blob-num js-line-number" data-line-number="7376"></td>
+ <td id="LC7376" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * through the callback. The callback is bound to `thisArg` and invoked with</span></td>
+ </tr>
+ <tr>
+ <td id="L7377" class="blob-num js-line-number" data-line-number="7377"></td>
+ <td id="LC7377" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * three arguments; (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7378" class="blob-num js-line-number" data-line-number="7378"></td>
+ <td id="LC7378" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7379" class="blob-num js-line-number" data-line-number="7379"></td>
+ <td id="LC7379" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7380" class="blob-num js-line-number" data-line-number="7380"></td>
+ <td id="LC7380" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7381" class="blob-num js-line-number" data-line-number="7381"></td>
+ <td id="LC7381" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7382" class="blob-num js-line-number" data-line-number="7382"></td>
+ <td id="LC7382" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7383" class="blob-num js-line-number" data-line-number="7383"></td>
+ <td id="LC7383" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7384" class="blob-num js-line-number" data-line-number="7384"></td>
+ <td id="LC7384" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7385" class="blob-num js-line-number" data-line-number="7385"></td>
+ <td id="LC7385" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7386" class="blob-num js-line-number" data-line-number="7386"></td>
+ <td id="LC7386" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7387" class="blob-num js-line-number" data-line-number="7387"></td>
+ <td id="LC7387" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7388" class="blob-num js-line-number" data-line-number="7388"></td>
+ <td id="LC7388" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> collect</span></td>
+ </tr>
+ <tr>
+ <td id="L7389" class="blob-num js-line-number" data-line-number="7389"></td>
+ <td id="LC7389" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7390" class="blob-num js-line-number" data-line-number="7390"></td>
+ <td id="LC7390" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7391" class="blob-num js-line-number" data-line-number="7391"></td>
+ <td id="LC7391" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7392" class="blob-num js-line-number" data-line-number="7392"></td>
+ <td id="LC7392" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7393" class="blob-num js-line-number" data-line-number="7393"></td>
+ <td id="LC7393" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7394" class="blob-num js-line-number" data-line-number="7394"></td>
+ <td id="LC7394" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7395" class="blob-num js-line-number" data-line-number="7395"></td>
+ <td id="LC7395" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of the results of each `callback` execution.</span></td>
+ </tr>
+ <tr>
+ <td id="L7396" class="blob-num js-line-number" data-line-number="7396"></td>
+ <td id="LC7396" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7397" class="blob-num js-line-number" data-line-number="7397"></td>
+ <td id="LC7397" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7398" class="blob-num js-line-number" data-line-number="7398"></td>
+ <td id="LC7398" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.map([1, 2, 3], function(num) { return num * 3; });</span></td>
+ </tr>
+ <tr>
+ <td id="L7399" class="blob-num js-line-number" data-line-number="7399"></td>
+ <td id="LC7399" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 6, 9]</span></td>
+ </tr>
+ <tr>
+ <td id="L7400" class="blob-num js-line-number" data-line-number="7400"></td>
+ <td id="LC7400" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7401" class="blob-num js-line-number" data-line-number="7401"></td>
+ <td id="LC7401" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });</span></td>
+ </tr>
+ <tr>
+ <td id="L7402" class="blob-num js-line-number" data-line-number="7402"></td>
+ <td id="LC7402" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 6, 9] (property order is not guaranteed across environments)</span></td>
+ </tr>
+ <tr>
+ <td id="L7403" class="blob-num js-line-number" data-line-number="7403"></td>
+ <td id="LC7403" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7404" class="blob-num js-line-number" data-line-number="7404"></td>
+ <td id="LC7404" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7405" class="blob-num js-line-number" data-line-number="7405"></td>
+ <td id="LC7405" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7406" class="blob-num js-line-number" data-line-number="7406"></td>
+ <td id="LC7406" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7407" class="blob-num js-line-number" data-line-number="7407"></td>
+ <td id="LC7407" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7408" class="blob-num js-line-number" data-line-number="7408"></td>
+ <td id="LC7408" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7409" class="blob-num js-line-number" data-line-number="7409"></td>
+ <td id="LC7409" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7410" class="blob-num js-line-number" data-line-number="7410"></td>
+ <td id="LC7410" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.map(characters, 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L7411" class="blob-num js-line-number" data-line-number="7411"></td>
+ <td id="LC7411" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['barney', 'fred']</span></td>
+ </tr>
+ <tr>
+ <td id="L7412" class="blob-num js-line-number" data-line-number="7412"></td>
+ <td id="LC7412" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7413" class="blob-num js-line-number" data-line-number="7413"></td>
+ <td id="LC7413" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">map</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7414" class="blob-num js-line-number" data-line-number="7414"></td>
+ <td id="LC7414" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7415" class="blob-num js-line-number" data-line-number="7415"></td>
+ <td id="LC7415" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7416" class="blob-num js-line-number" data-line-number="7416"></td>
+ <td id="LC7416" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7417" class="blob-num js-line-number" data-line-number="7417"></td>
+ <td id="LC7417" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7418" class="blob-num js-line-number" data-line-number="7418"></td>
+ <td id="LC7418" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7419" class="blob-num js-line-number" data-line-number="7419"></td>
+ <td id="LC7419" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length);</td>
+ </tr>
+ <tr>
+ <td id="L7420" class="blob-num js-line-number" data-line-number="7420"></td>
+ <td id="LC7420" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7421" class="blob-num js-line-number" data-line-number="7421"></td>
+ <td id="LC7421" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> <span class="pl-en">callback</span>(collection[index], index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7422" class="blob-num js-line-number" data-line-number="7422"></td>
+ <td id="LC7422" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7423" class="blob-num js-line-number" data-line-number="7423"></td>
+ <td id="LC7423" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7424" class="blob-num js-line-number" data-line-number="7424"></td>
+ <td id="LC7424" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L7425" class="blob-num js-line-number" data-line-number="7425"></td>
+ <td id="LC7425" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7426" class="blob-num js-line-number" data-line-number="7426"></td>
+ <td id="LC7426" class="blob-code blob-code-inner js-file-line"> result[<span class="pl-k">++</span>index] <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, key, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7427" class="blob-num js-line-number" data-line-number="7427"></td>
+ <td id="LC7427" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7428" class="blob-num js-line-number" data-line-number="7428"></td>
+ <td id="LC7428" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7429" class="blob-num js-line-number" data-line-number="7429"></td>
+ <td id="LC7429" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7430" class="blob-num js-line-number" data-line-number="7430"></td>
+ <td id="LC7430" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7431" class="blob-num js-line-number" data-line-number="7431"></td>
+ <td id="LC7431" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7432" class="blob-num js-line-number" data-line-number="7432"></td>
+ <td id="LC7432" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7433" class="blob-num js-line-number" data-line-number="7433"></td>
+ <td id="LC7433" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Retrieves the maximum value of a collection. If the collection is empty or</span></td>
+ </tr>
+ <tr>
+ <td id="L7434" class="blob-num js-line-number" data-line-number="7434"></td>
+ <td id="LC7434" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * falsey `-Infinity` is returned. If a callback is provided it will be executed</span></td>
+ </tr>
+ <tr>
+ <td id="L7435" class="blob-num js-line-number" data-line-number="7435"></td>
+ <td id="LC7435" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for each value in the collection to generate the criterion by which the value</span></td>
+ </tr>
+ <tr>
+ <td id="L7436" class="blob-num js-line-number" data-line-number="7436"></td>
+ <td id="LC7436" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is ranked. The callback is bound to `thisArg` and invoked with three</span></td>
+ </tr>
+ <tr>
+ <td id="L7437" class="blob-num js-line-number" data-line-number="7437"></td>
+ <td id="LC7437" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (value, index, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7438" class="blob-num js-line-number" data-line-number="7438"></td>
+ <td id="LC7438" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7439" class="blob-num js-line-number" data-line-number="7439"></td>
+ <td id="LC7439" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7440" class="blob-num js-line-number" data-line-number="7440"></td>
+ <td id="LC7440" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7441" class="blob-num js-line-number" data-line-number="7441"></td>
+ <td id="LC7441" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7442" class="blob-num js-line-number" data-line-number="7442"></td>
+ <td id="LC7442" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7443" class="blob-num js-line-number" data-line-number="7443"></td>
+ <td id="LC7443" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7444" class="blob-num js-line-number" data-line-number="7444"></td>
+ <td id="LC7444" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7445" class="blob-num js-line-number" data-line-number="7445"></td>
+ <td id="LC7445" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7446" class="blob-num js-line-number" data-line-number="7446"></td>
+ <td id="LC7446" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7447" class="blob-num js-line-number" data-line-number="7447"></td>
+ <td id="LC7447" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7448" class="blob-num js-line-number" data-line-number="7448"></td>
+ <td id="LC7448" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7449" class="blob-num js-line-number" data-line-number="7449"></td>
+ <td id="LC7449" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7450" class="blob-num js-line-number" data-line-number="7450"></td>
+ <td id="LC7450" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7451" class="blob-num js-line-number" data-line-number="7451"></td>
+ <td id="LC7451" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7452" class="blob-num js-line-number" data-line-number="7452"></td>
+ <td id="LC7452" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7453" class="blob-num js-line-number" data-line-number="7453"></td>
+ <td id="LC7453" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7454" class="blob-num js-line-number" data-line-number="7454"></td>
+ <td id="LC7454" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the maximum value.</span></td>
+ </tr>
+ <tr>
+ <td id="L7455" class="blob-num js-line-number" data-line-number="7455"></td>
+ <td id="LC7455" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7456" class="blob-num js-line-number" data-line-number="7456"></td>
+ <td id="LC7456" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7457" class="blob-num js-line-number" data-line-number="7457"></td>
+ <td id="LC7457" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.max([4, 2, 8, 6]);</span></td>
+ </tr>
+ <tr>
+ <td id="L7458" class="blob-num js-line-number" data-line-number="7458"></td>
+ <td id="LC7458" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 8</span></td>
+ </tr>
+ <tr>
+ <td id="L7459" class="blob-num js-line-number" data-line-number="7459"></td>
+ <td id="LC7459" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7460" class="blob-num js-line-number" data-line-number="7460"></td>
+ <td id="LC7460" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7461" class="blob-num js-line-number" data-line-number="7461"></td>
+ <td id="LC7461" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7462" class="blob-num js-line-number" data-line-number="7462"></td>
+ <td id="LC7462" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7463" class="blob-num js-line-number" data-line-number="7463"></td>
+ <td id="LC7463" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7464" class="blob-num js-line-number" data-line-number="7464"></td>
+ <td id="LC7464" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7465" class="blob-num js-line-number" data-line-number="7465"></td>
+ <td id="LC7465" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.max(characters, function(chr) { return chr.age; });</span></td>
+ </tr>
+ <tr>
+ <td id="L7466" class="blob-num js-line-number" data-line-number="7466"></td>
+ <td id="LC7466" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred', 'age': 40 };</span></td>
+ </tr>
+ <tr>
+ <td id="L7467" class="blob-num js-line-number" data-line-number="7467"></td>
+ <td id="LC7467" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7468" class="blob-num js-line-number" data-line-number="7468"></td>
+ <td id="LC7468" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7469" class="blob-num js-line-number" data-line-number="7469"></td>
+ <td id="LC7469" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.max(characters, 'age');</span></td>
+ </tr>
+ <tr>
+ <td id="L7470" class="blob-num js-line-number" data-line-number="7470"></td>
+ <td id="LC7470" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'fred', 'age': 40 };</span></td>
+ </tr>
+ <tr>
+ <td id="L7471" class="blob-num js-line-number" data-line-number="7471"></td>
+ <td id="LC7471" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7472" class="blob-num js-line-number" data-line-number="7472"></td>
+ <td id="LC7472" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">max</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7473" class="blob-num js-line-number" data-line-number="7473"></td>
+ <td id="LC7473" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> computed <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">Infinity</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7474" class="blob-num js-line-number" data-line-number="7474"></td>
+ <td id="LC7474" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> computed;</td>
+ </tr>
+ <tr>
+ <td id="L7475" class="blob-num js-line-number" data-line-number="7475"></td>
+ <td id="LC7475" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7476" class="blob-num js-line-number" data-line-number="7476"></td>
+ <td id="LC7476" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// allows working with functions like `_.map` without using</span></td>
+ </tr>
+ <tr>
+ <td id="L7477" class="blob-num js-line-number" data-line-number="7477"></td>
+ <td id="LC7477" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// their `index` argument as a callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7478" class="blob-num js-line-number" data-line-number="7478"></td>
+ <td id="LC7478" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> thisArg <span class="pl-k">&&</span> thisArg[callback] <span class="pl-k">===</span> collection) {</td>
+ </tr>
+ <tr>
+ <td id="L7479" class="blob-num js-line-number" data-line-number="7479"></td>
+ <td id="LC7479" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7480" class="blob-num js-line-number" data-line-number="7480"></td>
+ <td id="LC7480" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7481" class="blob-num js-line-number" data-line-number="7481"></td>
+ <td id="LC7481" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">&&</span> <span class="pl-en">isArray</span>(collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7482" class="blob-num js-line-number" data-line-number="7482"></td>
+ <td id="LC7482" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7483" class="blob-num js-line-number" data-line-number="7483"></td>
+ <td id="LC7483" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7484" class="blob-num js-line-number" data-line-number="7484"></td>
+ <td id="LC7484" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7485" class="blob-num js-line-number" data-line-number="7485"></td>
+ <td id="LC7485" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7486" class="blob-num js-line-number" data-line-number="7486"></td>
+ <td id="LC7486" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> collection[index];</td>
+ </tr>
+ <tr>
+ <td id="L7487" class="blob-num js-line-number" data-line-number="7487"></td>
+ <td id="LC7487" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k">></span> result) {</td>
+ </tr>
+ <tr>
+ <td id="L7488" class="blob-num js-line-number" data-line-number="7488"></td>
+ <td id="LC7488" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7489" class="blob-num js-line-number" data-line-number="7489"></td>
+ <td id="LC7489" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7490" class="blob-num js-line-number" data-line-number="7490"></td>
+ <td id="LC7490" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7491" class="blob-num js-line-number" data-line-number="7491"></td>
+ <td id="LC7491" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7492" class="blob-num js-line-number" data-line-number="7492"></td>
+ <td id="LC7492" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> (callback <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">&&</span> <span class="pl-en">isString</span>(collection))</td>
+ </tr>
+ <tr>
+ <td id="L7493" class="blob-num js-line-number" data-line-number="7493"></td>
+ <td id="LC7493" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> charAtCallback</td>
+ </tr>
+ <tr>
+ <td id="L7494" class="blob-num js-line-number" data-line-number="7494"></td>
+ <td id="LC7494" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7495" class="blob-num js-line-number" data-line-number="7495"></td>
+ <td id="LC7495" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7496" class="blob-num js-line-number" data-line-number="7496"></td>
+ <td id="LC7496" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7497" class="blob-num js-line-number" data-line-number="7497"></td>
+ <td id="LC7497" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> current <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7498" class="blob-num js-line-number" data-line-number="7498"></td>
+ <td id="LC7498" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (current <span class="pl-k">></span> computed) {</td>
+ </tr>
+ <tr>
+ <td id="L7499" class="blob-num js-line-number" data-line-number="7499"></td>
+ <td id="LC7499" class="blob-code blob-code-inner js-file-line"> computed <span class="pl-k">=</span> current;</td>
+ </tr>
+ <tr>
+ <td id="L7500" class="blob-num js-line-number" data-line-number="7500"></td>
+ <td id="LC7500" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7501" class="blob-num js-line-number" data-line-number="7501"></td>
+ <td id="LC7501" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7502" class="blob-num js-line-number" data-line-number="7502"></td>
+ <td id="LC7502" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7503" class="blob-num js-line-number" data-line-number="7503"></td>
+ <td id="LC7503" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7504" class="blob-num js-line-number" data-line-number="7504"></td>
+ <td id="LC7504" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7505" class="blob-num js-line-number" data-line-number="7505"></td>
+ <td id="LC7505" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7506" class="blob-num js-line-number" data-line-number="7506"></td>
+ <td id="LC7506" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7507" class="blob-num js-line-number" data-line-number="7507"></td>
+ <td id="LC7507" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7508" class="blob-num js-line-number" data-line-number="7508"></td>
+ <td id="LC7508" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Retrieves the minimum value of a collection. If the collection is empty or</span></td>
+ </tr>
+ <tr>
+ <td id="L7509" class="blob-num js-line-number" data-line-number="7509"></td>
+ <td id="LC7509" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * falsey `Infinity` is returned. If a callback is provided it will be executed</span></td>
+ </tr>
+ <tr>
+ <td id="L7510" class="blob-num js-line-number" data-line-number="7510"></td>
+ <td id="LC7510" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for each value in the collection to generate the criterion by which the value</span></td>
+ </tr>
+ <tr>
+ <td id="L7511" class="blob-num js-line-number" data-line-number="7511"></td>
+ <td id="LC7511" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is ranked. The callback is bound to `thisArg` and invoked with three</span></td>
+ </tr>
+ <tr>
+ <td id="L7512" class="blob-num js-line-number" data-line-number="7512"></td>
+ <td id="LC7512" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (value, index, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7513" class="blob-num js-line-number" data-line-number="7513"></td>
+ <td id="LC7513" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7514" class="blob-num js-line-number" data-line-number="7514"></td>
+ <td id="LC7514" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7515" class="blob-num js-line-number" data-line-number="7515"></td>
+ <td id="LC7515" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7516" class="blob-num js-line-number" data-line-number="7516"></td>
+ <td id="LC7516" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7517" class="blob-num js-line-number" data-line-number="7517"></td>
+ <td id="LC7517" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7518" class="blob-num js-line-number" data-line-number="7518"></td>
+ <td id="LC7518" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7519" class="blob-num js-line-number" data-line-number="7519"></td>
+ <td id="LC7519" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7520" class="blob-num js-line-number" data-line-number="7520"></td>
+ <td id="LC7520" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7521" class="blob-num js-line-number" data-line-number="7521"></td>
+ <td id="LC7521" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7522" class="blob-num js-line-number" data-line-number="7522"></td>
+ <td id="LC7522" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7523" class="blob-num js-line-number" data-line-number="7523"></td>
+ <td id="LC7523" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7524" class="blob-num js-line-number" data-line-number="7524"></td>
+ <td id="LC7524" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7525" class="blob-num js-line-number" data-line-number="7525"></td>
+ <td id="LC7525" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7526" class="blob-num js-line-number" data-line-number="7526"></td>
+ <td id="LC7526" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7527" class="blob-num js-line-number" data-line-number="7527"></td>
+ <td id="LC7527" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7528" class="blob-num js-line-number" data-line-number="7528"></td>
+ <td id="LC7528" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7529" class="blob-num js-line-number" data-line-number="7529"></td>
+ <td id="LC7529" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the minimum value.</span></td>
+ </tr>
+ <tr>
+ <td id="L7530" class="blob-num js-line-number" data-line-number="7530"></td>
+ <td id="LC7530" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7531" class="blob-num js-line-number" data-line-number="7531"></td>
+ <td id="LC7531" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7532" class="blob-num js-line-number" data-line-number="7532"></td>
+ <td id="LC7532" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.min([4, 2, 8, 6]);</span></td>
+ </tr>
+ <tr>
+ <td id="L7533" class="blob-num js-line-number" data-line-number="7533"></td>
+ <td id="LC7533" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L7534" class="blob-num js-line-number" data-line-number="7534"></td>
+ <td id="LC7534" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7535" class="blob-num js-line-number" data-line-number="7535"></td>
+ <td id="LC7535" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7536" class="blob-num js-line-number" data-line-number="7536"></td>
+ <td id="LC7536" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7537" class="blob-num js-line-number" data-line-number="7537"></td>
+ <td id="LC7537" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7538" class="blob-num js-line-number" data-line-number="7538"></td>
+ <td id="LC7538" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7539" class="blob-num js-line-number" data-line-number="7539"></td>
+ <td id="LC7539" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7540" class="blob-num js-line-number" data-line-number="7540"></td>
+ <td id="LC7540" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.min(characters, function(chr) { return chr.age; });</span></td>
+ </tr>
+ <tr>
+ <td id="L7541" class="blob-num js-line-number" data-line-number="7541"></td>
+ <td id="LC7541" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'barney', 'age': 36 };</span></td>
+ </tr>
+ <tr>
+ <td id="L7542" class="blob-num js-line-number" data-line-number="7542"></td>
+ <td id="LC7542" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7543" class="blob-num js-line-number" data-line-number="7543"></td>
+ <td id="LC7543" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7544" class="blob-num js-line-number" data-line-number="7544"></td>
+ <td id="LC7544" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.min(characters, 'age');</span></td>
+ </tr>
+ <tr>
+ <td id="L7545" class="blob-num js-line-number" data-line-number="7545"></td>
+ <td id="LC7545" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'barney', 'age': 36 };</span></td>
+ </tr>
+ <tr>
+ <td id="L7546" class="blob-num js-line-number" data-line-number="7546"></td>
+ <td id="LC7546" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7547" class="blob-num js-line-number" data-line-number="7547"></td>
+ <td id="LC7547" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">min</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7548" class="blob-num js-line-number" data-line-number="7548"></td>
+ <td id="LC7548" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> computed <span class="pl-k">=</span> <span class="pl-c1">Infinity</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7549" class="blob-num js-line-number" data-line-number="7549"></td>
+ <td id="LC7549" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> computed;</td>
+ </tr>
+ <tr>
+ <td id="L7550" class="blob-num js-line-number" data-line-number="7550"></td>
+ <td id="LC7550" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7551" class="blob-num js-line-number" data-line-number="7551"></td>
+ <td id="LC7551" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// allows working with functions like `_.map` without using</span></td>
+ </tr>
+ <tr>
+ <td id="L7552" class="blob-num js-line-number" data-line-number="7552"></td>
+ <td id="LC7552" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// their `index` argument as a callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7553" class="blob-num js-line-number" data-line-number="7553"></td>
+ <td id="LC7553" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> thisArg <span class="pl-k">&&</span> thisArg[callback] <span class="pl-k">===</span> collection) {</td>
+ </tr>
+ <tr>
+ <td id="L7554" class="blob-num js-line-number" data-line-number="7554"></td>
+ <td id="LC7554" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7555" class="blob-num js-line-number" data-line-number="7555"></td>
+ <td id="LC7555" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7556" class="blob-num js-line-number" data-line-number="7556"></td>
+ <td id="LC7556" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">&&</span> <span class="pl-en">isArray</span>(collection)) {</td>
+ </tr>
+ <tr>
+ <td id="L7557" class="blob-num js-line-number" data-line-number="7557"></td>
+ <td id="LC7557" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7558" class="blob-num js-line-number" data-line-number="7558"></td>
+ <td id="LC7558" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7559" class="blob-num js-line-number" data-line-number="7559"></td>
+ <td id="LC7559" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7560" class="blob-num js-line-number" data-line-number="7560"></td>
+ <td id="LC7560" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7561" class="blob-num js-line-number" data-line-number="7561"></td>
+ <td id="LC7561" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> collection[index];</td>
+ </tr>
+ <tr>
+ <td id="L7562" class="blob-num js-line-number" data-line-number="7562"></td>
+ <td id="LC7562" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k"><</span> result) {</td>
+ </tr>
+ <tr>
+ <td id="L7563" class="blob-num js-line-number" data-line-number="7563"></td>
+ <td id="LC7563" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7564" class="blob-num js-line-number" data-line-number="7564"></td>
+ <td id="LC7564" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7565" class="blob-num js-line-number" data-line-number="7565"></td>
+ <td id="LC7565" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7566" class="blob-num js-line-number" data-line-number="7566"></td>
+ <td id="LC7566" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7567" class="blob-num js-line-number" data-line-number="7567"></td>
+ <td id="LC7567" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> (callback <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">&&</span> <span class="pl-en">isString</span>(collection))</td>
+ </tr>
+ <tr>
+ <td id="L7568" class="blob-num js-line-number" data-line-number="7568"></td>
+ <td id="LC7568" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> charAtCallback</td>
+ </tr>
+ <tr>
+ <td id="L7569" class="blob-num js-line-number" data-line-number="7569"></td>
+ <td id="LC7569" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7570" class="blob-num js-line-number" data-line-number="7570"></td>
+ <td id="LC7570" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7571" class="blob-num js-line-number" data-line-number="7571"></td>
+ <td id="LC7571" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7572" class="blob-num js-line-number" data-line-number="7572"></td>
+ <td id="LC7572" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> current <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7573" class="blob-num js-line-number" data-line-number="7573"></td>
+ <td id="LC7573" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (current <span class="pl-k"><</span> computed) {</td>
+ </tr>
+ <tr>
+ <td id="L7574" class="blob-num js-line-number" data-line-number="7574"></td>
+ <td id="LC7574" class="blob-code blob-code-inner js-file-line"> computed <span class="pl-k">=</span> current;</td>
+ </tr>
+ <tr>
+ <td id="L7575" class="blob-num js-line-number" data-line-number="7575"></td>
+ <td id="LC7575" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7576" class="blob-num js-line-number" data-line-number="7576"></td>
+ <td id="LC7576" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7577" class="blob-num js-line-number" data-line-number="7577"></td>
+ <td id="LC7577" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7578" class="blob-num js-line-number" data-line-number="7578"></td>
+ <td id="LC7578" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7579" class="blob-num js-line-number" data-line-number="7579"></td>
+ <td id="LC7579" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7580" class="blob-num js-line-number" data-line-number="7580"></td>
+ <td id="LC7580" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7581" class="blob-num js-line-number" data-line-number="7581"></td>
+ <td id="LC7581" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7582" class="blob-num js-line-number" data-line-number="7582"></td>
+ <td id="LC7582" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7583" class="blob-num js-line-number" data-line-number="7583"></td>
+ <td id="LC7583" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Retrieves the value of a specified property from all elements in the collection.</span></td>
+ </tr>
+ <tr>
+ <td id="L7584" class="blob-num js-line-number" data-line-number="7584"></td>
+ <td id="LC7584" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7585" class="blob-num js-line-number" data-line-number="7585"></td>
+ <td id="LC7585" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7586" class="blob-num js-line-number" data-line-number="7586"></td>
+ <td id="LC7586" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7587" class="blob-num js-line-number" data-line-number="7587"></td>
+ <td id="LC7587" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L7588" class="blob-num js-line-number" data-line-number="7588"></td>
+ <td id="LC7588" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7589" class="blob-num js-line-number" data-line-number="7589"></td>
+ <td id="LC7589" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7590" class="blob-num js-line-number" data-line-number="7590"></td>
+ <td id="LC7590" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">property</span> The name of the property to pluck.</span></td>
+ </tr>
+ <tr>
+ <td id="L7591" class="blob-num js-line-number" data-line-number="7591"></td>
+ <td id="LC7591" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of property values.</span></td>
+ </tr>
+ <tr>
+ <td id="L7592" class="blob-num js-line-number" data-line-number="7592"></td>
+ <td id="LC7592" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7593" class="blob-num js-line-number" data-line-number="7593"></td>
+ <td id="LC7593" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7594" class="blob-num js-line-number" data-line-number="7594"></td>
+ <td id="LC7594" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7595" class="blob-num js-line-number" data-line-number="7595"></td>
+ <td id="LC7595" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7596" class="blob-num js-line-number" data-line-number="7596"></td>
+ <td id="LC7596" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7597" class="blob-num js-line-number" data-line-number="7597"></td>
+ <td id="LC7597" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7598" class="blob-num js-line-number" data-line-number="7598"></td>
+ <td id="LC7598" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7599" class="blob-num js-line-number" data-line-number="7599"></td>
+ <td id="LC7599" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pluck(characters, 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L7600" class="blob-num js-line-number" data-line-number="7600"></td>
+ <td id="LC7600" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['barney', 'fred']</span></td>
+ </tr>
+ <tr>
+ <td id="L7601" class="blob-num js-line-number" data-line-number="7601"></td>
+ <td id="LC7601" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7602" class="blob-num js-line-number" data-line-number="7602"></td>
+ <td id="LC7602" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> pluck <span class="pl-k">=</span> map;</td>
+ </tr>
+ <tr>
+ <td id="L7603" class="blob-num js-line-number" data-line-number="7603"></td>
+ <td id="LC7603" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7604" class="blob-num js-line-number" data-line-number="7604"></td>
+ <td id="LC7604" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7605" class="blob-num js-line-number" data-line-number="7605"></td>
+ <td id="LC7605" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Reduces a collection to a value which is the accumulated result of running</span></td>
+ </tr>
+ <tr>
+ <td id="L7606" class="blob-num js-line-number" data-line-number="7606"></td>
+ <td id="LC7606" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * each element in the collection through the callback, where each successive</span></td>
+ </tr>
+ <tr>
+ <td id="L7607" class="blob-num js-line-number" data-line-number="7607"></td>
+ <td id="LC7607" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback execution consumes the return value of the previous execution. If</span></td>
+ </tr>
+ <tr>
+ <td id="L7608" class="blob-num js-line-number" data-line-number="7608"></td>
+ <td id="LC7608" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `accumulator` is not provided the first element of the collection will be</span></td>
+ </tr>
+ <tr>
+ <td id="L7609" class="blob-num js-line-number" data-line-number="7609"></td>
+ <td id="LC7609" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * used as the initial `accumulator` value. The callback is bound to `thisArg`</span></td>
+ </tr>
+ <tr>
+ <td id="L7610" class="blob-num js-line-number" data-line-number="7610"></td>
+ <td id="LC7610" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and invoked with four arguments; (accumulator, value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7611" class="blob-num js-line-number" data-line-number="7611"></td>
+ <td id="LC7611" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7612" class="blob-num js-line-number" data-line-number="7612"></td>
+ <td id="LC7612" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7613" class="blob-num js-line-number" data-line-number="7613"></td>
+ <td id="LC7613" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7614" class="blob-num js-line-number" data-line-number="7614"></td>
+ <td id="LC7614" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> foldl, inject</span></td>
+ </tr>
+ <tr>
+ <td id="L7615" class="blob-num js-line-number" data-line-number="7615"></td>
+ <td id="LC7615" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7616" class="blob-num js-line-number" data-line-number="7616"></td>
+ <td id="LC7616" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7617" class="blob-num js-line-number" data-line-number="7617"></td>
+ <td id="LC7617" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L7618" class="blob-num js-line-number" data-line-number="7618"></td>
+ <td id="LC7618" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [accumulator] Initial value of the accumulator.</span></td>
+ </tr>
+ <tr>
+ <td id="L7619" class="blob-num js-line-number" data-line-number="7619"></td>
+ <td id="LC7619" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7620" class="blob-num js-line-number" data-line-number="7620"></td>
+ <td id="LC7620" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the accumulated value.</span></td>
+ </tr>
+ <tr>
+ <td id="L7621" class="blob-num js-line-number" data-line-number="7621"></td>
+ <td id="LC7621" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7622" class="blob-num js-line-number" data-line-number="7622"></td>
+ <td id="LC7622" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7623" class="blob-num js-line-number" data-line-number="7623"></td>
+ <td id="LC7623" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var sum = _.reduce([1, 2, 3], function(sum, num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L7624" class="blob-num js-line-number" data-line-number="7624"></td>
+ <td id="LC7624" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return sum + num;</span></td>
+ </tr>
+ <tr>
+ <td id="L7625" class="blob-num js-line-number" data-line-number="7625"></td>
+ <td id="LC7625" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L7626" class="blob-num js-line-number" data-line-number="7626"></td>
+ <td id="LC7626" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 6</span></td>
+ </tr>
+ <tr>
+ <td id="L7627" class="blob-num js-line-number" data-line-number="7627"></td>
+ <td id="LC7627" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7628" class="blob-num js-line-number" data-line-number="7628"></td>
+ <td id="LC7628" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {</span></td>
+ </tr>
+ <tr>
+ <td id="L7629" class="blob-num js-line-number" data-line-number="7629"></td>
+ <td id="LC7629" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * result[key] = num * 3;</span></td>
+ </tr>
+ <tr>
+ <td id="L7630" class="blob-num js-line-number" data-line-number="7630"></td>
+ <td id="LC7630" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return result;</span></td>
+ </tr>
+ <tr>
+ <td id="L7631" class="blob-num js-line-number" data-line-number="7631"></td>
+ <td id="LC7631" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }, {});</span></td>
+ </tr>
+ <tr>
+ <td id="L7632" class="blob-num js-line-number" data-line-number="7632"></td>
+ <td id="LC7632" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'a': 3, 'b': 6, 'c': 9 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7633" class="blob-num js-line-number" data-line-number="7633"></td>
+ <td id="LC7633" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7634" class="blob-num js-line-number" data-line-number="7634"></td>
+ <td id="LC7634" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">reduce</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">accumulator</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7635" class="blob-num js-line-number" data-line-number="7635"></td>
+ <td id="LC7635" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>collection) <span class="pl-k">return</span> accumulator;</td>
+ </tr>
+ <tr>
+ <td id="L7636" class="blob-num js-line-number" data-line-number="7636"></td>
+ <td id="LC7636" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> noaccum <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k"><</span> <span class="pl-c1">3</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7637" class="blob-num js-line-number" data-line-number="7637"></td>
+ <td id="LC7637" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">4</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7638" class="blob-num js-line-number" data-line-number="7638"></td>
+ <td id="LC7638" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7639" class="blob-num js-line-number" data-line-number="7639"></td>
+ <td id="LC7639" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7640" class="blob-num js-line-number" data-line-number="7640"></td>
+ <td id="LC7640" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7641" class="blob-num js-line-number" data-line-number="7641"></td>
+ <td id="LC7641" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7642" class="blob-num js-line-number" data-line-number="7642"></td>
+ <td id="LC7642" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7643" class="blob-num js-line-number" data-line-number="7643"></td>
+ <td id="LC7643" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (noaccum) {</td>
+ </tr>
+ <tr>
+ <td id="L7644" class="blob-num js-line-number" data-line-number="7644"></td>
+ <td id="LC7644" class="blob-code blob-code-inner js-file-line"> accumulator <span class="pl-k">=</span> collection[<span class="pl-k">++</span>index];</td>
+ </tr>
+ <tr>
+ <td id="L7645" class="blob-num js-line-number" data-line-number="7645"></td>
+ <td id="LC7645" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7646" class="blob-num js-line-number" data-line-number="7646"></td>
+ <td id="LC7646" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7647" class="blob-num js-line-number" data-line-number="7647"></td>
+ <td id="LC7647" class="blob-code blob-code-inner js-file-line"> accumulator <span class="pl-k">=</span> <span class="pl-en">callback</span>(accumulator, collection[index], index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7648" class="blob-num js-line-number" data-line-number="7648"></td>
+ <td id="LC7648" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7649" class="blob-num js-line-number" data-line-number="7649"></td>
+ <td id="LC7649" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7650" class="blob-num js-line-number" data-line-number="7650"></td>
+ <td id="LC7650" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7651" class="blob-num js-line-number" data-line-number="7651"></td>
+ <td id="LC7651" class="blob-code blob-code-inner js-file-line"> accumulator <span class="pl-k">=</span> noaccum</td>
+ </tr>
+ <tr>
+ <td id="L7652" class="blob-num js-line-number" data-line-number="7652"></td>
+ <td id="LC7652" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> (noaccum <span class="pl-k">=</span> <span class="pl-c1">false</span>, value)</td>
+ </tr>
+ <tr>
+ <td id="L7653" class="blob-num js-line-number" data-line-number="7653"></td>
+ <td id="LC7653" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">callback</span>(accumulator, value, index, collection)</td>
+ </tr>
+ <tr>
+ <td id="L7654" class="blob-num js-line-number" data-line-number="7654"></td>
+ <td id="LC7654" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7655" class="blob-num js-line-number" data-line-number="7655"></td>
+ <td id="LC7655" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7656" class="blob-num js-line-number" data-line-number="7656"></td>
+ <td id="LC7656" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> accumulator;</td>
+ </tr>
+ <tr>
+ <td id="L7657" class="blob-num js-line-number" data-line-number="7657"></td>
+ <td id="LC7657" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7658" class="blob-num js-line-number" data-line-number="7658"></td>
+ <td id="LC7658" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7659" class="blob-num js-line-number" data-line-number="7659"></td>
+ <td id="LC7659" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7660" class="blob-num js-line-number" data-line-number="7660"></td>
+ <td id="LC7660" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.reduce` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L7661" class="blob-num js-line-number" data-line-number="7661"></td>
+ <td id="LC7661" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` from right to left.</span></td>
+ </tr>
+ <tr>
+ <td id="L7662" class="blob-num js-line-number" data-line-number="7662"></td>
+ <td id="LC7662" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7663" class="blob-num js-line-number" data-line-number="7663"></td>
+ <td id="LC7663" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7664" class="blob-num js-line-number" data-line-number="7664"></td>
+ <td id="LC7664" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7665" class="blob-num js-line-number" data-line-number="7665"></td>
+ <td id="LC7665" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> foldr</span></td>
+ </tr>
+ <tr>
+ <td id="L7666" class="blob-num js-line-number" data-line-number="7666"></td>
+ <td id="LC7666" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7667" class="blob-num js-line-number" data-line-number="7667"></td>
+ <td id="LC7667" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7668" class="blob-num js-line-number" data-line-number="7668"></td>
+ <td id="LC7668" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [callback=identity] The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L7669" class="blob-num js-line-number" data-line-number="7669"></td>
+ <td id="LC7669" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [accumulator] Initial value of the accumulator.</span></td>
+ </tr>
+ <tr>
+ <td id="L7670" class="blob-num js-line-number" data-line-number="7670"></td>
+ <td id="LC7670" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7671" class="blob-num js-line-number" data-line-number="7671"></td>
+ <td id="LC7671" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the accumulated value.</span></td>
+ </tr>
+ <tr>
+ <td id="L7672" class="blob-num js-line-number" data-line-number="7672"></td>
+ <td id="LC7672" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7673" class="blob-num js-line-number" data-line-number="7673"></td>
+ <td id="LC7673" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7674" class="blob-num js-line-number" data-line-number="7674"></td>
+ <td id="LC7674" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var list = [[0, 1], [2, 3], [4, 5]];</span></td>
+ </tr>
+ <tr>
+ <td id="L7675" class="blob-num js-line-number" data-line-number="7675"></td>
+ <td id="LC7675" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);</span></td>
+ </tr>
+ <tr>
+ <td id="L7676" class="blob-num js-line-number" data-line-number="7676"></td>
+ <td id="LC7676" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [4, 5, 2, 3, 0, 1]</span></td>
+ </tr>
+ <tr>
+ <td id="L7677" class="blob-num js-line-number" data-line-number="7677"></td>
+ <td id="LC7677" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7678" class="blob-num js-line-number" data-line-number="7678"></td>
+ <td id="LC7678" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">reduceRight</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">accumulator</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7679" class="blob-num js-line-number" data-line-number="7679"></td>
+ <td id="LC7679" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> noaccum <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k"><</span> <span class="pl-c1">3</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7680" class="blob-num js-line-number" data-line-number="7680"></td>
+ <td id="LC7680" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">4</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7681" class="blob-num js-line-number" data-line-number="7681"></td>
+ <td id="LC7681" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEachRight</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7682" class="blob-num js-line-number" data-line-number="7682"></td>
+ <td id="LC7682" class="blob-code blob-code-inner js-file-line"> accumulator <span class="pl-k">=</span> noaccum</td>
+ </tr>
+ <tr>
+ <td id="L7683" class="blob-num js-line-number" data-line-number="7683"></td>
+ <td id="LC7683" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> (noaccum <span class="pl-k">=</span> <span class="pl-c1">false</span>, value)</td>
+ </tr>
+ <tr>
+ <td id="L7684" class="blob-num js-line-number" data-line-number="7684"></td>
+ <td id="LC7684" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">callback</span>(accumulator, value, index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7685" class="blob-num js-line-number" data-line-number="7685"></td>
+ <td id="LC7685" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7686" class="blob-num js-line-number" data-line-number="7686"></td>
+ <td id="LC7686" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> accumulator;</td>
+ </tr>
+ <tr>
+ <td id="L7687" class="blob-num js-line-number" data-line-number="7687"></td>
+ <td id="LC7687" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7688" class="blob-num js-line-number" data-line-number="7688"></td>
+ <td id="LC7688" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7689" class="blob-num js-line-number" data-line-number="7689"></td>
+ <td id="LC7689" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7690" class="blob-num js-line-number" data-line-number="7690"></td>
+ <td id="LC7690" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The opposite of `_.filter` this method returns the elements of a</span></td>
+ </tr>
+ <tr>
+ <td id="L7691" class="blob-num js-line-number" data-line-number="7691"></td>
+ <td id="LC7691" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * collection that the callback does **not** return truey for.</span></td>
+ </tr>
+ <tr>
+ <td id="L7692" class="blob-num js-line-number" data-line-number="7692"></td>
+ <td id="LC7692" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7693" class="blob-num js-line-number" data-line-number="7693"></td>
+ <td id="LC7693" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7694" class="blob-num js-line-number" data-line-number="7694"></td>
+ <td id="LC7694" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7695" class="blob-num js-line-number" data-line-number="7695"></td>
+ <td id="LC7695" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7696" class="blob-num js-line-number" data-line-number="7696"></td>
+ <td id="LC7696" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7697" class="blob-num js-line-number" data-line-number="7697"></td>
+ <td id="LC7697" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7698" class="blob-num js-line-number" data-line-number="7698"></td>
+ <td id="LC7698" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7699" class="blob-num js-line-number" data-line-number="7699"></td>
+ <td id="LC7699" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7700" class="blob-num js-line-number" data-line-number="7700"></td>
+ <td id="LC7700" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7701" class="blob-num js-line-number" data-line-number="7701"></td>
+ <td id="LC7701" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7702" class="blob-num js-line-number" data-line-number="7702"></td>
+ <td id="LC7702" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7703" class="blob-num js-line-number" data-line-number="7703"></td>
+ <td id="LC7703" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7704" class="blob-num js-line-number" data-line-number="7704"></td>
+ <td id="LC7704" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7705" class="blob-num js-line-number" data-line-number="7705"></td>
+ <td id="LC7705" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7706" class="blob-num js-line-number" data-line-number="7706"></td>
+ <td id="LC7706" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7707" class="blob-num js-line-number" data-line-number="7707"></td>
+ <td id="LC7707" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7708" class="blob-num js-line-number" data-line-number="7708"></td>
+ <td id="LC7708" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of elements that failed the callback check.</span></td>
+ </tr>
+ <tr>
+ <td id="L7709" class="blob-num js-line-number" data-line-number="7709"></td>
+ <td id="LC7709" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7710" class="blob-num js-line-number" data-line-number="7710"></td>
+ <td id="LC7710" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7711" class="blob-num js-line-number" data-line-number="7711"></td>
+ <td id="LC7711" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });</span></td>
+ </tr>
+ <tr>
+ <td id="L7712" class="blob-num js-line-number" data-line-number="7712"></td>
+ <td id="LC7712" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 3, 5]</span></td>
+ </tr>
+ <tr>
+ <td id="L7713" class="blob-num js-line-number" data-line-number="7713"></td>
+ <td id="LC7713" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7714" class="blob-num js-line-number" data-line-number="7714"></td>
+ <td id="LC7714" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7715" class="blob-num js-line-number" data-line-number="7715"></td>
+ <td id="LC7715" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L7716" class="blob-num js-line-number" data-line-number="7716"></td>
+ <td id="LC7716" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'blocked': true }</span></td>
+ </tr>
+ <tr>
+ <td id="L7717" class="blob-num js-line-number" data-line-number="7717"></td>
+ <td id="LC7717" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7718" class="blob-num js-line-number" data-line-number="7718"></td>
+ <td id="LC7718" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7719" class="blob-num js-line-number" data-line-number="7719"></td>
+ <td id="LC7719" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7720" class="blob-num js-line-number" data-line-number="7720"></td>
+ <td id="LC7720" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.reject(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L7721" class="blob-num js-line-number" data-line-number="7721"></td>
+ <td id="LC7721" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]</span></td>
+ </tr>
+ <tr>
+ <td id="L7722" class="blob-num js-line-number" data-line-number="7722"></td>
+ <td id="LC7722" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7723" class="blob-num js-line-number" data-line-number="7723"></td>
+ <td id="LC7723" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7724" class="blob-num js-line-number" data-line-number="7724"></td>
+ <td id="LC7724" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.reject(characters, { 'age': 36 });</span></td>
+ </tr>
+ <tr>
+ <td id="L7725" class="blob-num js-line-number" data-line-number="7725"></td>
+ <td id="LC7725" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]</span></td>
+ </tr>
+ <tr>
+ <td id="L7726" class="blob-num js-line-number" data-line-number="7726"></td>
+ <td id="LC7726" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7727" class="blob-num js-line-number" data-line-number="7727"></td>
+ <td id="LC7727" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">reject</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7728" class="blob-num js-line-number" data-line-number="7728"></td>
+ <td id="LC7728" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7729" class="blob-num js-line-number" data-line-number="7729"></td>
+ <td id="LC7729" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">filter</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7730" class="blob-num js-line-number" data-line-number="7730"></td>
+ <td id="LC7730" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!</span><span class="pl-en">callback</span>(value, index, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7731" class="blob-num js-line-number" data-line-number="7731"></td>
+ <td id="LC7731" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7732" class="blob-num js-line-number" data-line-number="7732"></td>
+ <td id="LC7732" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7733" class="blob-num js-line-number" data-line-number="7733"></td>
+ <td id="LC7733" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7734" class="blob-num js-line-number" data-line-number="7734"></td>
+ <td id="LC7734" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7735" class="blob-num js-line-number" data-line-number="7735"></td>
+ <td id="LC7735" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Retrieves a random element or `n` random elements from a collection.</span></td>
+ </tr>
+ <tr>
+ <td id="L7736" class="blob-num js-line-number" data-line-number="7736"></td>
+ <td id="LC7736" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7737" class="blob-num js-line-number" data-line-number="7737"></td>
+ <td id="LC7737" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7738" class="blob-num js-line-number" data-line-number="7738"></td>
+ <td id="LC7738" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7739" class="blob-num js-line-number" data-line-number="7739"></td>
+ <td id="LC7739" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7740" class="blob-num js-line-number" data-line-number="7740"></td>
+ <td id="LC7740" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to sample.</span></td>
+ </tr>
+ <tr>
+ <td id="L7741" class="blob-num js-line-number" data-line-number="7741"></td>
+ <td id="LC7741" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [n] The number of elements to sample.</span></td>
+ </tr>
+ <tr>
+ <td id="L7742" class="blob-num js-line-number" data-line-number="7742"></td>
+ <td id="LC7742" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span>- {Object} [guard] Allows working with functions like `_.map`</span></td>
+ </tr>
+ <tr>
+ <td id="L7743" class="blob-num js-line-number" data-line-number="7743"></td>
+ <td id="LC7743" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * without using their `index` arguments as `n`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7744" class="blob-num js-line-number" data-line-number="7744"></td>
+ <td id="LC7744" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> the random sample(s) of `collection`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7745" class="blob-num js-line-number" data-line-number="7745"></td>
+ <td id="LC7745" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7746" class="blob-num js-line-number" data-line-number="7746"></td>
+ <td id="LC7746" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7747" class="blob-num js-line-number" data-line-number="7747"></td>
+ <td id="LC7747" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sample([1, 2, 3, 4]);</span></td>
+ </tr>
+ <tr>
+ <td id="L7748" class="blob-num js-line-number" data-line-number="7748"></td>
+ <td id="LC7748" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L7749" class="blob-num js-line-number" data-line-number="7749"></td>
+ <td id="LC7749" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7750" class="blob-num js-line-number" data-line-number="7750"></td>
+ <td id="LC7750" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sample([1, 2, 3, 4], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L7751" class="blob-num js-line-number" data-line-number="7751"></td>
+ <td id="LC7751" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 1]</span></td>
+ </tr>
+ <tr>
+ <td id="L7752" class="blob-num js-line-number" data-line-number="7752"></td>
+ <td id="LC7752" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7753" class="blob-num js-line-number" data-line-number="7753"></td>
+ <td id="LC7753" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">sample</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">n</span>, <span class="pl-smi">guard</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7754" class="blob-num js-line-number" data-line-number="7754"></td>
+ <td id="LC7754" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (collection <span class="pl-k">&&</span> <span class="pl-k">typeof</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7755" class="blob-num js-line-number" data-line-number="7755"></td>
+ <td id="LC7755" class="blob-code blob-code-inner js-file-line"> collection <span class="pl-k">=</span> <span class="pl-en">values</span>(collection);</td>
+ </tr>
+ <tr>
+ <td id="L7756" class="blob-num js-line-number" data-line-number="7756"></td>
+ <td id="LC7756" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7757" class="blob-num js-line-number" data-line-number="7757"></td>
+ <td id="LC7757" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (n <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> guard) {</td>
+ </tr>
+ <tr>
+ <td id="L7758" class="blob-num js-line-number" data-line-number="7758"></td>
+ <td id="LC7758" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> collection <span class="pl-k">?</span> collection[<span class="pl-en">baseRandom</span>(<span class="pl-c1">0</span>, <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">-</span> <span class="pl-c1">1</span>)] <span class="pl-k">:</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7759" class="blob-num js-line-number" data-line-number="7759"></td>
+ <td id="LC7759" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7760" class="blob-num js-line-number" data-line-number="7760"></td>
+ <td id="LC7760" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-en">shuffle</span>(collection);</td>
+ </tr>
+ <tr>
+ <td id="L7761" class="blob-num js-line-number" data-line-number="7761"></td>
+ <td id="LC7761" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">length</span> <span class="pl-k">=</span> <span class="pl-en">nativeMin</span>(<span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, n), <span class="pl-smi">result</span>.<span class="pl-c1">length</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7762" class="blob-num js-line-number" data-line-number="7762"></td>
+ <td id="LC7762" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7763" class="blob-num js-line-number" data-line-number="7763"></td>
+ <td id="LC7763" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7764" class="blob-num js-line-number" data-line-number="7764"></td>
+ <td id="LC7764" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7765" class="blob-num js-line-number" data-line-number="7765"></td>
+ <td id="LC7765" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7766" class="blob-num js-line-number" data-line-number="7766"></td>
+ <td id="LC7766" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of shuffled values, using a version of the Fisher-Yates</span></td>
+ </tr>
+ <tr>
+ <td id="L7767" class="blob-num js-line-number" data-line-number="7767"></td>
+ <td id="LC7767" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.</span></td>
+ </tr>
+ <tr>
+ <td id="L7768" class="blob-num js-line-number" data-line-number="7768"></td>
+ <td id="LC7768" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7769" class="blob-num js-line-number" data-line-number="7769"></td>
+ <td id="LC7769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7770" class="blob-num js-line-number" data-line-number="7770"></td>
+ <td id="LC7770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7771" class="blob-num js-line-number" data-line-number="7771"></td>
+ <td id="LC7771" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7772" class="blob-num js-line-number" data-line-number="7772"></td>
+ <td id="LC7772" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to shuffle.</span></td>
+ </tr>
+ <tr>
+ <td id="L7773" class="blob-num js-line-number" data-line-number="7773"></td>
+ <td id="LC7773" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new shuffled collection.</span></td>
+ </tr>
+ <tr>
+ <td id="L7774" class="blob-num js-line-number" data-line-number="7774"></td>
+ <td id="LC7774" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7775" class="blob-num js-line-number" data-line-number="7775"></td>
+ <td id="LC7775" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7776" class="blob-num js-line-number" data-line-number="7776"></td>
+ <td id="LC7776" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.shuffle([1, 2, 3, 4, 5, 6]);</span></td>
+ </tr>
+ <tr>
+ <td id="L7777" class="blob-num js-line-number" data-line-number="7777"></td>
+ <td id="LC7777" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [4, 1, 6, 3, 5, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L7778" class="blob-num js-line-number" data-line-number="7778"></td>
+ <td id="LC7778" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7779" class="blob-num js-line-number" data-line-number="7779"></td>
+ <td id="LC7779" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">shuffle</span>(<span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7780" class="blob-num js-line-number" data-line-number="7780"></td>
+ <td id="LC7780" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7781" class="blob-num js-line-number" data-line-number="7781"></td>
+ <td id="LC7781" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7782" class="blob-num js-line-number" data-line-number="7782"></td>
+ <td id="LC7782" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> length <span class="pl-k">:</span> <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7783" class="blob-num js-line-number" data-line-number="7783"></td>
+ <td id="LC7783" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7784" class="blob-num js-line-number" data-line-number="7784"></td>
+ <td id="LC7784" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7785" class="blob-num js-line-number" data-line-number="7785"></td>
+ <td id="LC7785" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> rand <span class="pl-k">=</span> <span class="pl-en">baseRandom</span>(<span class="pl-c1">0</span>, <span class="pl-k">++</span>index);</td>
+ </tr>
+ <tr>
+ <td id="L7786" class="blob-num js-line-number" data-line-number="7786"></td>
+ <td id="LC7786" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> result[rand];</td>
+ </tr>
+ <tr>
+ <td id="L7787" class="blob-num js-line-number" data-line-number="7787"></td>
+ <td id="LC7787" class="blob-code blob-code-inner js-file-line"> result[rand] <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7788" class="blob-num js-line-number" data-line-number="7788"></td>
+ <td id="LC7788" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7789" class="blob-num js-line-number" data-line-number="7789"></td>
+ <td id="LC7789" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7790" class="blob-num js-line-number" data-line-number="7790"></td>
+ <td id="LC7790" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7791" class="blob-num js-line-number" data-line-number="7791"></td>
+ <td id="LC7791" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7792" class="blob-num js-line-number" data-line-number="7792"></td>
+ <td id="LC7792" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7793" class="blob-num js-line-number" data-line-number="7793"></td>
+ <td id="LC7793" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the size of the `collection` by returning `collection.length` for arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L7794" class="blob-num js-line-number" data-line-number="7794"></td>
+ <td id="LC7794" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and array-like objects or the number of own enumerable properties for objects.</span></td>
+ </tr>
+ <tr>
+ <td id="L7795" class="blob-num js-line-number" data-line-number="7795"></td>
+ <td id="LC7795" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7796" class="blob-num js-line-number" data-line-number="7796"></td>
+ <td id="LC7796" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7797" class="blob-num js-line-number" data-line-number="7797"></td>
+ <td id="LC7797" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7798" class="blob-num js-line-number" data-line-number="7798"></td>
+ <td id="LC7798" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7799" class="blob-num js-line-number" data-line-number="7799"></td>
+ <td id="LC7799" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L7800" class="blob-num js-line-number" data-line-number="7800"></td>
+ <td id="LC7800" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> `collection.length` or number of own enumerable properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L7801" class="blob-num js-line-number" data-line-number="7801"></td>
+ <td id="LC7801" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7802" class="blob-num js-line-number" data-line-number="7802"></td>
+ <td id="LC7802" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7803" class="blob-num js-line-number" data-line-number="7803"></td>
+ <td id="LC7803" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.size([1, 2]);</span></td>
+ </tr>
+ <tr>
+ <td id="L7804" class="blob-num js-line-number" data-line-number="7804"></td>
+ <td id="LC7804" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L7805" class="blob-num js-line-number" data-line-number="7805"></td>
+ <td id="LC7805" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7806" class="blob-num js-line-number" data-line-number="7806"></td>
+ <td id="LC7806" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.size({ 'one': 1, 'two': 2, 'three': 3 });</span></td>
+ </tr>
+ <tr>
+ <td id="L7807" class="blob-num js-line-number" data-line-number="7807"></td>
+ <td id="LC7807" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 3</span></td>
+ </tr>
+ <tr>
+ <td id="L7808" class="blob-num js-line-number" data-line-number="7808"></td>
+ <td id="LC7808" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7809" class="blob-num js-line-number" data-line-number="7809"></td>
+ <td id="LC7809" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.size('pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L7810" class="blob-num js-line-number" data-line-number="7810"></td>
+ <td id="LC7810" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 7</span></td>
+ </tr>
+ <tr>
+ <td id="L7811" class="blob-num js-line-number" data-line-number="7811"></td>
+ <td id="LC7811" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7812" class="blob-num js-line-number" data-line-number="7812"></td>
+ <td id="LC7812" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">size</span>(<span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7813" class="blob-num js-line-number" data-line-number="7813"></td>
+ <td id="LC7813" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7814" class="blob-num js-line-number" data-line-number="7814"></td>
+ <td id="LC7814" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> length <span class="pl-k">:</span> <span class="pl-en">keys</span>(collection).<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7815" class="blob-num js-line-number" data-line-number="7815"></td>
+ <td id="LC7815" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7816" class="blob-num js-line-number" data-line-number="7816"></td>
+ <td id="LC7816" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7817" class="blob-num js-line-number" data-line-number="7817"></td>
+ <td id="LC7817" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7818" class="blob-num js-line-number" data-line-number="7818"></td>
+ <td id="LC7818" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Checks if the callback returns a truey value for **any** element of a</span></td>
+ </tr>
+ <tr>
+ <td id="L7819" class="blob-num js-line-number" data-line-number="7819"></td>
+ <td id="LC7819" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * collection. The function returns as soon as it finds a passing value and</span></td>
+ </tr>
+ <tr>
+ <td id="L7820" class="blob-num js-line-number" data-line-number="7820"></td>
+ <td id="LC7820" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * does not iterate over the entire collection. The callback is bound to</span></td>
+ </tr>
+ <tr>
+ <td id="L7821" class="blob-num js-line-number" data-line-number="7821"></td>
+ <td id="LC7821" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `thisArg` and invoked with three arguments; (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7822" class="blob-num js-line-number" data-line-number="7822"></td>
+ <td id="LC7822" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7823" class="blob-num js-line-number" data-line-number="7823"></td>
+ <td id="LC7823" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7824" class="blob-num js-line-number" data-line-number="7824"></td>
+ <td id="LC7824" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7825" class="blob-num js-line-number" data-line-number="7825"></td>
+ <td id="LC7825" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7826" class="blob-num js-line-number" data-line-number="7826"></td>
+ <td id="LC7826" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7827" class="blob-num js-line-number" data-line-number="7827"></td>
+ <td id="LC7827" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7828" class="blob-num js-line-number" data-line-number="7828"></td>
+ <td id="LC7828" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7829" class="blob-num js-line-number" data-line-number="7829"></td>
+ <td id="LC7829" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7830" class="blob-num js-line-number" data-line-number="7830"></td>
+ <td id="LC7830" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7831" class="blob-num js-line-number" data-line-number="7831"></td>
+ <td id="LC7831" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7832" class="blob-num js-line-number" data-line-number="7832"></td>
+ <td id="LC7832" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> any</span></td>
+ </tr>
+ <tr>
+ <td id="L7833" class="blob-num js-line-number" data-line-number="7833"></td>
+ <td id="LC7833" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7834" class="blob-num js-line-number" data-line-number="7834"></td>
+ <td id="LC7834" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7835" class="blob-num js-line-number" data-line-number="7835"></td>
+ <td id="LC7835" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7836" class="blob-num js-line-number" data-line-number="7836"></td>
+ <td id="LC7836" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7837" class="blob-num js-line-number" data-line-number="7837"></td>
+ <td id="LC7837" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7838" class="blob-num js-line-number" data-line-number="7838"></td>
+ <td id="LC7838" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7839" class="blob-num js-line-number" data-line-number="7839"></td>
+ <td id="LC7839" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{boolean}</span> <span class="pl-smi">Returns</span> `true` if any element passed the callback check,</span></td>
+ </tr>
+ <tr>
+ <td id="L7840" class="blob-num js-line-number" data-line-number="7840"></td>
+ <td id="LC7840" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7841" class="blob-num js-line-number" data-line-number="7841"></td>
+ <td id="LC7841" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7842" class="blob-num js-line-number" data-line-number="7842"></td>
+ <td id="LC7842" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7843" class="blob-num js-line-number" data-line-number="7843"></td>
+ <td id="LC7843" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.some([null, 0, 'yes', false], Boolean);</span></td>
+ </tr>
+ <tr>
+ <td id="L7844" class="blob-num js-line-number" data-line-number="7844"></td>
+ <td id="LC7844" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L7845" class="blob-num js-line-number" data-line-number="7845"></td>
+ <td id="LC7845" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7846" class="blob-num js-line-number" data-line-number="7846"></td>
+ <td id="LC7846" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7847" class="blob-num js-line-number" data-line-number="7847"></td>
+ <td id="LC7847" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L7848" class="blob-num js-line-number" data-line-number="7848"></td>
+ <td id="LC7848" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'blocked': true }</span></td>
+ </tr>
+ <tr>
+ <td id="L7849" class="blob-num js-line-number" data-line-number="7849"></td>
+ <td id="LC7849" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7850" class="blob-num js-line-number" data-line-number="7850"></td>
+ <td id="LC7850" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7851" class="blob-num js-line-number" data-line-number="7851"></td>
+ <td id="LC7851" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7852" class="blob-num js-line-number" data-line-number="7852"></td>
+ <td id="LC7852" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.some(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L7853" class="blob-num js-line-number" data-line-number="7853"></td>
+ <td id="LC7853" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L7854" class="blob-num js-line-number" data-line-number="7854"></td>
+ <td id="LC7854" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7855" class="blob-num js-line-number" data-line-number="7855"></td>
+ <td id="LC7855" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7856" class="blob-num js-line-number" data-line-number="7856"></td>
+ <td id="LC7856" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.some(characters, { 'age': 1 });</span></td>
+ </tr>
+ <tr>
+ <td id="L7857" class="blob-num js-line-number" data-line-number="7857"></td>
+ <td id="LC7857" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => false</span></td>
+ </tr>
+ <tr>
+ <td id="L7858" class="blob-num js-line-number" data-line-number="7858"></td>
+ <td id="LC7858" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7859" class="blob-num js-line-number" data-line-number="7859"></td>
+ <td id="LC7859" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">some</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7860" class="blob-num js-line-number" data-line-number="7860"></td>
+ <td id="LC7860" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7861" class="blob-num js-line-number" data-line-number="7861"></td>
+ <td id="LC7861" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7862" class="blob-num js-line-number" data-line-number="7862"></td>
+ <td id="LC7862" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7863" class="blob-num js-line-number" data-line-number="7863"></td>
+ <td id="LC7863" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7864" class="blob-num js-line-number" data-line-number="7864"></td>
+ <td id="LC7864" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7865" class="blob-num js-line-number" data-line-number="7865"></td>
+ <td id="LC7865" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7866" class="blob-num js-line-number" data-line-number="7866"></td>
+ <td id="LC7866" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7867" class="blob-num js-line-number" data-line-number="7867"></td>
+ <td id="LC7867" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L7868" class="blob-num js-line-number" data-line-number="7868"></td>
+ <td id="LC7868" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((result <span class="pl-k">=</span> <span class="pl-en">callback</span>(collection[index], index, collection))) {</td>
+ </tr>
+ <tr>
+ <td id="L7869" class="blob-num js-line-number" data-line-number="7869"></td>
+ <td id="LC7869" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7870" class="blob-num js-line-number" data-line-number="7870"></td>
+ <td id="LC7870" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7871" class="blob-num js-line-number" data-line-number="7871"></td>
+ <td id="LC7871" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7872" class="blob-num js-line-number" data-line-number="7872"></td>
+ <td id="LC7872" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7873" class="blob-num js-line-number" data-line-number="7873"></td>
+ <td id="LC7873" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">index</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7874" class="blob-num js-line-number" data-line-number="7874"></td>
+ <td id="LC7874" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!</span>(result <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, index, collection));</td>
+ </tr>
+ <tr>
+ <td id="L7875" class="blob-num js-line-number" data-line-number="7875"></td>
+ <td id="LC7875" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7876" class="blob-num js-line-number" data-line-number="7876"></td>
+ <td id="LC7876" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7877" class="blob-num js-line-number" data-line-number="7877"></td>
+ <td id="LC7877" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!!</span>result;</td>
+ </tr>
+ <tr>
+ <td id="L7878" class="blob-num js-line-number" data-line-number="7878"></td>
+ <td id="LC7878" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7879" class="blob-num js-line-number" data-line-number="7879"></td>
+ <td id="LC7879" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7880" class="blob-num js-line-number" data-line-number="7880"></td>
+ <td id="LC7880" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7881" class="blob-num js-line-number" data-line-number="7881"></td>
+ <td id="LC7881" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of elements, sorted in ascending order by the results of</span></td>
+ </tr>
+ <tr>
+ <td id="L7882" class="blob-num js-line-number" data-line-number="7882"></td>
+ <td id="LC7882" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * running each element in a collection through the callback. This method</span></td>
+ </tr>
+ <tr>
+ <td id="L7883" class="blob-num js-line-number" data-line-number="7883"></td>
+ <td id="LC7883" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * performs a stable sort, that is, it will preserve the original sort order</span></td>
+ </tr>
+ <tr>
+ <td id="L7884" class="blob-num js-line-number" data-line-number="7884"></td>
+ <td id="LC7884" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of equal elements. The callback is bound to `thisArg` and invoked with</span></td>
+ </tr>
+ <tr>
+ <td id="L7885" class="blob-num js-line-number" data-line-number="7885"></td>
+ <td id="LC7885" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * three arguments; (value, index|key, collection).</span></td>
+ </tr>
+ <tr>
+ <td id="L7886" class="blob-num js-line-number" data-line-number="7886"></td>
+ <td id="LC7886" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7887" class="blob-num js-line-number" data-line-number="7887"></td>
+ <td id="LC7887" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L7888" class="blob-num js-line-number" data-line-number="7888"></td>
+ <td id="LC7888" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L7889" class="blob-num js-line-number" data-line-number="7889"></td>
+ <td id="LC7889" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7890" class="blob-num js-line-number" data-line-number="7890"></td>
+ <td id="LC7890" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an array of property names is provided for `callback` the collection</span></td>
+ </tr>
+ <tr>
+ <td id="L7891" class="blob-num js-line-number" data-line-number="7891"></td>
+ <td id="LC7891" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will be sorted by each property value.</span></td>
+ </tr>
+ <tr>
+ <td id="L7892" class="blob-num js-line-number" data-line-number="7892"></td>
+ <td id="LC7892" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7893" class="blob-num js-line-number" data-line-number="7893"></td>
+ <td id="LC7893" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L7894" class="blob-num js-line-number" data-line-number="7894"></td>
+ <td id="LC7894" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L7895" class="blob-num js-line-number" data-line-number="7895"></td>
+ <td id="LC7895" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7896" class="blob-num js-line-number" data-line-number="7896"></td>
+ <td id="LC7896" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7897" class="blob-num js-line-number" data-line-number="7897"></td>
+ <td id="LC7897" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7898" class="blob-num js-line-number" data-line-number="7898"></td>
+ <td id="LC7898" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7899" class="blob-num js-line-number" data-line-number="7899"></td>
+ <td id="LC7899" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7900" class="blob-num js-line-number" data-line-number="7900"></td>
+ <td id="LC7900" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7901" class="blob-num js-line-number" data-line-number="7901"></td>
+ <td id="LC7901" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L7902" class="blob-num js-line-number" data-line-number="7902"></td>
+ <td id="LC7902" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L7903" class="blob-num js-line-number" data-line-number="7903"></td>
+ <td id="LC7903" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L7904" class="blob-num js-line-number" data-line-number="7904"></td>
+ <td id="LC7904" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L7905" class="blob-num js-line-number" data-line-number="7905"></td>
+ <td id="LC7905" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of sorted elements.</span></td>
+ </tr>
+ <tr>
+ <td id="L7906" class="blob-num js-line-number" data-line-number="7906"></td>
+ <td id="LC7906" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7907" class="blob-num js-line-number" data-line-number="7907"></td>
+ <td id="LC7907" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7908" class="blob-num js-line-number" data-line-number="7908"></td>
+ <td id="LC7908" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });</span></td>
+ </tr>
+ <tr>
+ <td id="L7909" class="blob-num js-line-number" data-line-number="7909"></td>
+ <td id="LC7909" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 1, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L7910" class="blob-num js-line-number" data-line-number="7910"></td>
+ <td id="LC7910" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7911" class="blob-num js-line-number" data-line-number="7911"></td>
+ <td id="LC7911" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);</span></td>
+ </tr>
+ <tr>
+ <td id="L7912" class="blob-num js-line-number" data-line-number="7912"></td>
+ <td id="LC7912" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 1, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L7913" class="blob-num js-line-number" data-line-number="7913"></td>
+ <td id="LC7913" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7914" class="blob-num js-line-number" data-line-number="7914"></td>
+ <td id="LC7914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7915" class="blob-num js-line-number" data-line-number="7915"></td>
+ <td id="LC7915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7916" class="blob-num js-line-number" data-line-number="7916"></td>
+ <td id="LC7916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7917" class="blob-num js-line-number" data-line-number="7917"></td>
+ <td id="LC7917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 26 },</span></td>
+ </tr>
+ <tr>
+ <td id="L7918" class="blob-num js-line-number" data-line-number="7918"></td>
+ <td id="LC7918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 30 }</span></td>
+ </tr>
+ <tr>
+ <td id="L7919" class="blob-num js-line-number" data-line-number="7919"></td>
+ <td id="LC7919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L7920" class="blob-num js-line-number" data-line-number="7920"></td>
+ <td id="LC7920" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7921" class="blob-num js-line-number" data-line-number="7921"></td>
+ <td id="LC7921" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L7922" class="blob-num js-line-number" data-line-number="7922"></td>
+ <td id="LC7922" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.map(_.sortBy(characters, 'age'), _.values);</span></td>
+ </tr>
+ <tr>
+ <td id="L7923" class="blob-num js-line-number" data-line-number="7923"></td>
+ <td id="LC7923" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]]</span></td>
+ </tr>
+ <tr>
+ <td id="L7924" class="blob-num js-line-number" data-line-number="7924"></td>
+ <td id="LC7924" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7925" class="blob-num js-line-number" data-line-number="7925"></td>
+ <td id="LC7925" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // sorting by multiple properties</span></td>
+ </tr>
+ <tr>
+ <td id="L7926" class="blob-num js-line-number" data-line-number="7926"></td>
+ <td id="LC7926" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.map(_.sortBy(characters, ['name', 'age']), _.values);</span></td>
+ </tr>
+ <tr>
+ <td id="L7927" class="blob-num js-line-number" data-line-number="7927"></td>
+ <td id="LC7927" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]]</span></td>
+ </tr>
+ <tr>
+ <td id="L7928" class="blob-num js-line-number" data-line-number="7928"></td>
+ <td id="LC7928" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7929" class="blob-num js-line-number" data-line-number="7929"></td>
+ <td id="LC7929" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">sortBy</span>(<span class="pl-smi">collection</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7930" class="blob-num js-line-number" data-line-number="7930"></td>
+ <td id="LC7930" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7931" class="blob-num js-line-number" data-line-number="7931"></td>
+ <td id="LC7931" class="blob-code blob-code-inner js-file-line"> isArr <span class="pl-k">=</span> <span class="pl-en">isArray</span>(callback),</td>
+ </tr>
+ <tr>
+ <td id="L7932" class="blob-num js-line-number" data-line-number="7932"></td>
+ <td id="LC7932" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> collection <span class="pl-k">?</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L7933" class="blob-num js-line-number" data-line-number="7933"></td>
+ <td id="LC7933" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(<span class="pl-k">typeof</span> length <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> length <span class="pl-k">:</span> <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7934" class="blob-num js-line-number" data-line-number="7934"></td>
+ <td id="LC7934" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7935" class="blob-num js-line-number" data-line-number="7935"></td>
+ <td id="LC7935" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L7936" class="blob-num js-line-number" data-line-number="7936"></td>
+ <td id="LC7936" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7937" class="blob-num js-line-number" data-line-number="7937"></td>
+ <td id="LC7937" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7938" class="blob-num js-line-number" data-line-number="7938"></td>
+ <td id="LC7938" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>(collection, <span class="pl-k">function</span>(<span class="pl-smi">value</span>, <span class="pl-smi">key</span>, <span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7939" class="blob-num js-line-number" data-line-number="7939"></td>
+ <td id="LC7939" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> object <span class="pl-k">=</span> result[<span class="pl-k">++</span>index] <span class="pl-k">=</span> <span class="pl-en">getObject</span>();</td>
+ </tr>
+ <tr>
+ <td id="L7940" class="blob-num js-line-number" data-line-number="7940"></td>
+ <td id="LC7940" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L7941" class="blob-num js-line-number" data-line-number="7941"></td>
+ <td id="LC7941" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">object</span>.<span class="pl-smi">criteria</span> <span class="pl-k">=</span> <span class="pl-en">map</span>(callback, <span class="pl-k">function</span>(<span class="pl-smi">key</span>) { <span class="pl-k">return</span> value[key]; });</td>
+ </tr>
+ <tr>
+ <td id="L7942" class="blob-num js-line-number" data-line-number="7942"></td>
+ <td id="LC7942" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L7943" class="blob-num js-line-number" data-line-number="7943"></td>
+ <td id="LC7943" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">object</span>.<span class="pl-smi">criteria</span> <span class="pl-k">=</span> <span class="pl-en">getArray</span>())[<span class="pl-c1">0</span>] <span class="pl-k">=</span> <span class="pl-en">callback</span>(value, key, collection);</td>
+ </tr>
+ <tr>
+ <td id="L7944" class="blob-num js-line-number" data-line-number="7944"></td>
+ <td id="LC7944" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7945" class="blob-num js-line-number" data-line-number="7945"></td>
+ <td id="LC7945" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">object</span>.<span class="pl-c1">index</span> <span class="pl-k">=</span> index;</td>
+ </tr>
+ <tr>
+ <td id="L7946" class="blob-num js-line-number" data-line-number="7946"></td>
+ <td id="LC7946" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">object</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L7947" class="blob-num js-line-number" data-line-number="7947"></td>
+ <td id="LC7947" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L7948" class="blob-num js-line-number" data-line-number="7948"></td>
+ <td id="LC7948" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7949" class="blob-num js-line-number" data-line-number="7949"></td>
+ <td id="LC7949" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">result</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7950" class="blob-num js-line-number" data-line-number="7950"></td>
+ <td id="LC7950" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">sort</span>(compareAscending);</td>
+ </tr>
+ <tr>
+ <td id="L7951" class="blob-num js-line-number" data-line-number="7951"></td>
+ <td id="LC7951" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7952" class="blob-num js-line-number" data-line-number="7952"></td>
+ <td id="LC7952" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> object <span class="pl-k">=</span> result[length];</td>
+ </tr>
+ <tr>
+ <td id="L7953" class="blob-num js-line-number" data-line-number="7953"></td>
+ <td id="LC7953" class="blob-code blob-code-inner js-file-line"> result[length] <span class="pl-k">=</span> <span class="pl-smi">object</span>.<span class="pl-c1">value</span>;</td>
+ </tr>
+ <tr>
+ <td id="L7954" class="blob-num js-line-number" data-line-number="7954"></td>
+ <td id="LC7954" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>isArr) {</td>
+ </tr>
+ <tr>
+ <td id="L7955" class="blob-num js-line-number" data-line-number="7955"></td>
+ <td id="LC7955" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(<span class="pl-smi">object</span>.<span class="pl-smi">criteria</span>);</td>
+ </tr>
+ <tr>
+ <td id="L7956" class="blob-num js-line-number" data-line-number="7956"></td>
+ <td id="LC7956" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7957" class="blob-num js-line-number" data-line-number="7957"></td>
+ <td id="LC7957" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseObject</span>(object);</td>
+ </tr>
+ <tr>
+ <td id="L7958" class="blob-num js-line-number" data-line-number="7958"></td>
+ <td id="LC7958" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7959" class="blob-num js-line-number" data-line-number="7959"></td>
+ <td id="LC7959" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L7960" class="blob-num js-line-number" data-line-number="7960"></td>
+ <td id="LC7960" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7961" class="blob-num js-line-number" data-line-number="7961"></td>
+ <td id="LC7961" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7962" class="blob-num js-line-number" data-line-number="7962"></td>
+ <td id="LC7962" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7963" class="blob-num js-line-number" data-line-number="7963"></td>
+ <td id="LC7963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Converts the `collection` to an array.</span></td>
+ </tr>
+ <tr>
+ <td id="L7964" class="blob-num js-line-number" data-line-number="7964"></td>
+ <td id="LC7964" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7965" class="blob-num js-line-number" data-line-number="7965"></td>
+ <td id="LC7965" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7966" class="blob-num js-line-number" data-line-number="7966"></td>
+ <td id="LC7966" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7967" class="blob-num js-line-number" data-line-number="7967"></td>
+ <td id="LC7967" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7968" class="blob-num js-line-number" data-line-number="7968"></td>
+ <td id="LC7968" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to convert.</span></td>
+ </tr>
+ <tr>
+ <td id="L7969" class="blob-num js-line-number" data-line-number="7969"></td>
+ <td id="LC7969" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> the new converted array.</span></td>
+ </tr>
+ <tr>
+ <td id="L7970" class="blob-num js-line-number" data-line-number="7970"></td>
+ <td id="LC7970" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7971" class="blob-num js-line-number" data-line-number="7971"></td>
+ <td id="LC7971" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7972" class="blob-num js-line-number" data-line-number="7972"></td>
+ <td id="LC7972" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);</span></td>
+ </tr>
+ <tr>
+ <td id="L7973" class="blob-num js-line-number" data-line-number="7973"></td>
+ <td id="LC7973" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 3, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L7974" class="blob-num js-line-number" data-line-number="7974"></td>
+ <td id="LC7974" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L7975" class="blob-num js-line-number" data-line-number="7975"></td>
+ <td id="LC7975" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">toArray</span>(<span class="pl-smi">collection</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7976" class="blob-num js-line-number" data-line-number="7976"></td>
+ <td id="LC7976" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (collection <span class="pl-k">&&</span> <span class="pl-k">typeof</span> <span class="pl-smi">collection</span>.<span class="pl-c1">length</span> <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L7977" class="blob-num js-line-number" data-line-number="7977"></td>
+ <td id="LC7977" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">slice</span>(collection);</td>
+ </tr>
+ <tr>
+ <td id="L7978" class="blob-num js-line-number" data-line-number="7978"></td>
+ <td id="LC7978" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7979" class="blob-num js-line-number" data-line-number="7979"></td>
+ <td id="LC7979" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">values</span>(collection);</td>
+ </tr>
+ <tr>
+ <td id="L7980" class="blob-num js-line-number" data-line-number="7980"></td>
+ <td id="LC7980" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L7981" class="blob-num js-line-number" data-line-number="7981"></td>
+ <td id="LC7981" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L7982" class="blob-num js-line-number" data-line-number="7982"></td>
+ <td id="LC7982" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L7983" class="blob-num js-line-number" data-line-number="7983"></td>
+ <td id="LC7983" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Performs a deep comparison of each element in a `collection` to the given</span></td>
+ </tr>
+ <tr>
+ <td id="L7984" class="blob-num js-line-number" data-line-number="7984"></td>
+ <td id="LC7984" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `properties` object, returning an array of all elements that have equivalent</span></td>
+ </tr>
+ <tr>
+ <td id="L7985" class="blob-num js-line-number" data-line-number="7985"></td>
+ <td id="LC7985" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * property values.</span></td>
+ </tr>
+ <tr>
+ <td id="L7986" class="blob-num js-line-number" data-line-number="7986"></td>
+ <td id="LC7986" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7987" class="blob-num js-line-number" data-line-number="7987"></td>
+ <td id="LC7987" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7988" class="blob-num js-line-number" data-line-number="7988"></td>
+ <td id="LC7988" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L7989" class="blob-num js-line-number" data-line-number="7989"></td>
+ <td id="LC7989" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> Function</span></td>
+ </tr>
+ <tr>
+ <td id="L7990" class="blob-num js-line-number" data-line-number="7990"></td>
+ <td id="LC7990" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Collections</span></td>
+ </tr>
+ <tr>
+ <td id="L7991" class="blob-num js-line-number" data-line-number="7991"></td>
+ <td id="LC7991" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array|Object|string} collection The collection to iterate over.</span></td>
+ </tr>
+ <tr>
+ <td id="L7992" class="blob-num js-line-number" data-line-number="7992"></td>
+ <td id="LC7992" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">props</span> The object of property values to filter by.</span></td>
+ </tr>
+ <tr>
+ <td id="L7993" class="blob-num js-line-number" data-line-number="7993"></td>
+ <td id="LC7993" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of elements that have the given properties.</span></td>
+ </tr>
+ <tr>
+ <td id="L7994" class="blob-num js-line-number" data-line-number="7994"></td>
+ <td id="LC7994" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L7995" class="blob-num js-line-number" data-line-number="7995"></td>
+ <td id="LC7995" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L7996" class="blob-num js-line-number" data-line-number="7996"></td>
+ <td id="LC7996" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L7997" class="blob-num js-line-number" data-line-number="7997"></td>
+ <td id="LC7997" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] },</span></td>
+ </tr>
+ <tr>
+ <td id="L7998" class="blob-num js-line-number" data-line-number="7998"></td>
+ <td id="LC7998" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }</span></td>
+ </tr>
+ <tr>
+ <td id="L7999" class="blob-num js-line-number" data-line-number="7999"></td>
+ <td id="LC7999" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8000" class="blob-num js-line-number" data-line-number="8000"></td>
+ <td id="LC8000" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8001" class="blob-num js-line-number" data-line-number="8001"></td>
+ <td id="LC8001" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.where(characters, { 'age': 36 });</span></td>
+ </tr>
+ <tr>
+ <td id="L8002" class="blob-num js-line-number" data-line-number="8002"></td>
+ <td id="LC8002" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8003" class="blob-num js-line-number" data-line-number="8003"></td>
+ <td id="LC8003" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8004" class="blob-num js-line-number" data-line-number="8004"></td>
+ <td id="LC8004" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.where(characters, { 'pets': ['dino'] });</span></td>
+ </tr>
+ <tr>
+ <td id="L8005" class="blob-num js-line-number" data-line-number="8005"></td>
+ <td id="LC8005" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8006" class="blob-num js-line-number" data-line-number="8006"></td>
+ <td id="LC8006" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8007" class="blob-num js-line-number" data-line-number="8007"></td>
+ <td id="LC8007" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> where <span class="pl-k">=</span> filter;</td>
+ </tr>
+ <tr>
+ <td id="L8008" class="blob-num js-line-number" data-line-number="8008"></td>
+ <td id="LC8008" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8009" class="blob-num js-line-number" data-line-number="8009"></td>
+ <td id="LC8009" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L8010" class="blob-num js-line-number" data-line-number="8010"></td>
+ <td id="LC8010" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8011" class="blob-num js-line-number" data-line-number="8011"></td>
+ <td id="LC8011" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8012" class="blob-num js-line-number" data-line-number="8012"></td>
+ <td id="LC8012" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array with all falsey values removed. The values `false`, `null`,</span></td>
+ </tr>
+ <tr>
+ <td id="L8013" class="blob-num js-line-number" data-line-number="8013"></td>
+ <td id="LC8013" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `0`, `""`, `undefined`, and `NaN` are all falsey.</span></td>
+ </tr>
+ <tr>
+ <td id="L8014" class="blob-num js-line-number" data-line-number="8014"></td>
+ <td id="LC8014" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8015" class="blob-num js-line-number" data-line-number="8015"></td>
+ <td id="LC8015" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8016" class="blob-num js-line-number" data-line-number="8016"></td>
+ <td id="LC8016" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8017" class="blob-num js-line-number" data-line-number="8017"></td>
+ <td id="LC8017" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8018" class="blob-num js-line-number" data-line-number="8018"></td>
+ <td id="LC8018" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to compact.</span></td>
+ </tr>
+ <tr>
+ <td id="L8019" class="blob-num js-line-number" data-line-number="8019"></td>
+ <td id="LC8019" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of filtered values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8020" class="blob-num js-line-number" data-line-number="8020"></td>
+ <td id="LC8020" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8021" class="blob-num js-line-number" data-line-number="8021"></td>
+ <td id="LC8021" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8022" class="blob-num js-line-number" data-line-number="8022"></td>
+ <td id="LC8022" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.compact([0, 1, false, 2, '', 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8023" class="blob-num js-line-number" data-line-number="8023"></td>
+ <td id="LC8023" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8024" class="blob-num js-line-number" data-line-number="8024"></td>
+ <td id="LC8024" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8025" class="blob-num js-line-number" data-line-number="8025"></td>
+ <td id="LC8025" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">compact</span>(<span class="pl-smi">array</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8026" class="blob-num js-line-number" data-line-number="8026"></td>
+ <td id="LC8026" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8027" class="blob-num js-line-number" data-line-number="8027"></td>
+ <td id="LC8027" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8028" class="blob-num js-line-number" data-line-number="8028"></td>
+ <td id="LC8028" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L8029" class="blob-num js-line-number" data-line-number="8029"></td>
+ <td id="LC8029" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8030" class="blob-num js-line-number" data-line-number="8030"></td>
+ <td id="LC8030" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8031" class="blob-num js-line-number" data-line-number="8031"></td>
+ <td id="LC8031" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> array[index];</td>
+ </tr>
+ <tr>
+ <td id="L8032" class="blob-num js-line-number" data-line-number="8032"></td>
+ <td id="LC8032" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value) {</td>
+ </tr>
+ <tr>
+ <td id="L8033" class="blob-num js-line-number" data-line-number="8033"></td>
+ <td id="LC8033" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L8034" class="blob-num js-line-number" data-line-number="8034"></td>
+ <td id="LC8034" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8035" class="blob-num js-line-number" data-line-number="8035"></td>
+ <td id="LC8035" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8036" class="blob-num js-line-number" data-line-number="8036"></td>
+ <td id="LC8036" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L8037" class="blob-num js-line-number" data-line-number="8037"></td>
+ <td id="LC8037" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8038" class="blob-num js-line-number" data-line-number="8038"></td>
+ <td id="LC8038" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8039" class="blob-num js-line-number" data-line-number="8039"></td>
+ <td id="LC8039" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8040" class="blob-num js-line-number" data-line-number="8040"></td>
+ <td id="LC8040" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array excluding all values of the provided arrays using strict</span></td>
+ </tr>
+ <tr>
+ <td id="L8041" class="blob-num js-line-number" data-line-number="8041"></td>
+ <td id="LC8041" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * equality for comparisons, i.e. `===`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8042" class="blob-num js-line-number" data-line-number="8042"></td>
+ <td id="LC8042" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8043" class="blob-num js-line-number" data-line-number="8043"></td>
+ <td id="LC8043" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8044" class="blob-num js-line-number" data-line-number="8044"></td>
+ <td id="LC8044" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8045" class="blob-num js-line-number" data-line-number="8045"></td>
+ <td id="LC8045" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8046" class="blob-num js-line-number" data-line-number="8046"></td>
+ <td id="LC8046" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to process.</span></td>
+ </tr>
+ <tr>
+ <td id="L8047" class="blob-num js-line-number" data-line-number="8047"></td>
+ <td id="LC8047" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Array} [values] The arrays of values to exclude.</span></td>
+ </tr>
+ <tr>
+ <td id="L8048" class="blob-num js-line-number" data-line-number="8048"></td>
+ <td id="LC8048" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of filtered values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8049" class="blob-num js-line-number" data-line-number="8049"></td>
+ <td id="LC8049" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8050" class="blob-num js-line-number" data-line-number="8050"></td>
+ <td id="LC8050" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8051" class="blob-num js-line-number" data-line-number="8051"></td>
+ <td id="LC8051" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8052" class="blob-num js-line-number" data-line-number="8052"></td>
+ <td id="LC8052" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 3, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L8053" class="blob-num js-line-number" data-line-number="8053"></td>
+ <td id="LC8053" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8054" class="blob-num js-line-number" data-line-number="8054"></td>
+ <td id="LC8054" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">difference</span>(<span class="pl-smi">array</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8055" class="blob-num js-line-number" data-line-number="8055"></td>
+ <td id="LC8055" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseDifference</span>(array, <span class="pl-en">baseFlatten</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">true</span>, <span class="pl-c1">true</span>, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L8056" class="blob-num js-line-number" data-line-number="8056"></td>
+ <td id="LC8056" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8057" class="blob-num js-line-number" data-line-number="8057"></td>
+ <td id="LC8057" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8058" class="blob-num js-line-number" data-line-number="8058"></td>
+ <td id="LC8058" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8059" class="blob-num js-line-number" data-line-number="8059"></td>
+ <td id="LC8059" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.find` except that it returns the index of the first</span></td>
+ </tr>
+ <tr>
+ <td id="L8060" class="blob-num js-line-number" data-line-number="8060"></td>
+ <td id="LC8060" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * element that passes the callback check, instead of the element itself.</span></td>
+ </tr>
+ <tr>
+ <td id="L8061" class="blob-num js-line-number" data-line-number="8061"></td>
+ <td id="LC8061" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8062" class="blob-num js-line-number" data-line-number="8062"></td>
+ <td id="LC8062" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8063" class="blob-num js-line-number" data-line-number="8063"></td>
+ <td id="LC8063" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8064" class="blob-num js-line-number" data-line-number="8064"></td>
+ <td id="LC8064" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8065" class="blob-num js-line-number" data-line-number="8065"></td>
+ <td id="LC8065" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8066" class="blob-num js-line-number" data-line-number="8066"></td>
+ <td id="LC8066" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8067" class="blob-num js-line-number" data-line-number="8067"></td>
+ <td id="LC8067" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8068" class="blob-num js-line-number" data-line-number="8068"></td>
+ <td id="LC8068" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8069" class="blob-num js-line-number" data-line-number="8069"></td>
+ <td id="LC8069" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8070" class="blob-num js-line-number" data-line-number="8070"></td>
+ <td id="LC8070" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8071" class="blob-num js-line-number" data-line-number="8071"></td>
+ <td id="LC8071" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8072" class="blob-num js-line-number" data-line-number="8072"></td>
+ <td id="LC8072" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L8073" class="blob-num js-line-number" data-line-number="8073"></td>
+ <td id="LC8073" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8074" class="blob-num js-line-number" data-line-number="8074"></td>
+ <td id="LC8074" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L8075" class="blob-num js-line-number" data-line-number="8075"></td>
+ <td id="LC8075" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8076" class="blob-num js-line-number" data-line-number="8076"></td>
+ <td id="LC8076" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8077" class="blob-num js-line-number" data-line-number="8077"></td>
+ <td id="LC8077" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the index of the found element, else `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8078" class="blob-num js-line-number" data-line-number="8078"></td>
+ <td id="LC8078" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8079" class="blob-num js-line-number" data-line-number="8079"></td>
+ <td id="LC8079" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8080" class="blob-num js-line-number" data-line-number="8080"></td>
+ <td id="LC8080" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8081" class="blob-num js-line-number" data-line-number="8081"></td>
+ <td id="LC8081" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L8082" class="blob-num js-line-number" data-line-number="8082"></td>
+ <td id="LC8082" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'blocked': true },</span></td>
+ </tr>
+ <tr>
+ <td id="L8083" class="blob-num js-line-number" data-line-number="8083"></td>
+ <td id="LC8083" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'age': 1, 'blocked': false }</span></td>
+ </tr>
+ <tr>
+ <td id="L8084" class="blob-num js-line-number" data-line-number="8084"></td>
+ <td id="LC8084" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8085" class="blob-num js-line-number" data-line-number="8085"></td>
+ <td id="LC8085" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8086" class="blob-num js-line-number" data-line-number="8086"></td>
+ <td id="LC8086" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findIndex(characters, function(chr) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8087" class="blob-num js-line-number" data-line-number="8087"></td>
+ <td id="LC8087" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return chr.age < 20;</span></td>
+ </tr>
+ <tr>
+ <td id="L8088" class="blob-num js-line-number" data-line-number="8088"></td>
+ <td id="LC8088" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8089" class="blob-num js-line-number" data-line-number="8089"></td>
+ <td id="LC8089" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8090" class="blob-num js-line-number" data-line-number="8090"></td>
+ <td id="LC8090" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8091" class="blob-num js-line-number" data-line-number="8091"></td>
+ <td id="LC8091" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8092" class="blob-num js-line-number" data-line-number="8092"></td>
+ <td id="LC8092" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findIndex(characters, { 'age': 36 });</span></td>
+ </tr>
+ <tr>
+ <td id="L8093" class="blob-num js-line-number" data-line-number="8093"></td>
+ <td id="LC8093" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 0</span></td>
+ </tr>
+ <tr>
+ <td id="L8094" class="blob-num js-line-number" data-line-number="8094"></td>
+ <td id="LC8094" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8095" class="blob-num js-line-number" data-line-number="8095"></td>
+ <td id="LC8095" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8096" class="blob-num js-line-number" data-line-number="8096"></td>
+ <td id="LC8096" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findIndex(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L8097" class="blob-num js-line-number" data-line-number="8097"></td>
+ <td id="LC8097" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 1</span></td>
+ </tr>
+ <tr>
+ <td id="L8098" class="blob-num js-line-number" data-line-number="8098"></td>
+ <td id="LC8098" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8099" class="blob-num js-line-number" data-line-number="8099"></td>
+ <td id="LC8099" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">findIndex</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8100" class="blob-num js-line-number" data-line-number="8100"></td>
+ <td id="LC8100" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8101" class="blob-num js-line-number" data-line-number="8101"></td>
+ <td id="LC8101" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8102" class="blob-num js-line-number" data-line-number="8102"></td>
+ <td id="LC8102" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8103" class="blob-num js-line-number" data-line-number="8103"></td>
+ <td id="LC8103" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8104" class="blob-num js-line-number" data-line-number="8104"></td>
+ <td id="LC8104" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8105" class="blob-num js-line-number" data-line-number="8105"></td>
+ <td id="LC8105" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(array[index], index, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8106" class="blob-num js-line-number" data-line-number="8106"></td>
+ <td id="LC8106" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> index;</td>
+ </tr>
+ <tr>
+ <td id="L8107" class="blob-num js-line-number" data-line-number="8107"></td>
+ <td id="LC8107" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8108" class="blob-num js-line-number" data-line-number="8108"></td>
+ <td id="LC8108" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8109" class="blob-num js-line-number" data-line-number="8109"></td>
+ <td id="LC8109" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8110" class="blob-num js-line-number" data-line-number="8110"></td>
+ <td id="LC8110" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8111" class="blob-num js-line-number" data-line-number="8111"></td>
+ <td id="LC8111" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8112" class="blob-num js-line-number" data-line-number="8112"></td>
+ <td id="LC8112" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8113" class="blob-num js-line-number" data-line-number="8113"></td>
+ <td id="LC8113" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.findIndex` except that it iterates over elements</span></td>
+ </tr>
+ <tr>
+ <td id="L8114" class="blob-num js-line-number" data-line-number="8114"></td>
+ <td id="LC8114" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of a `collection` from right to left.</span></td>
+ </tr>
+ <tr>
+ <td id="L8115" class="blob-num js-line-number" data-line-number="8115"></td>
+ <td id="LC8115" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8116" class="blob-num js-line-number" data-line-number="8116"></td>
+ <td id="LC8116" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8117" class="blob-num js-line-number" data-line-number="8117"></td>
+ <td id="LC8117" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8118" class="blob-num js-line-number" data-line-number="8118"></td>
+ <td id="LC8118" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8119" class="blob-num js-line-number" data-line-number="8119"></td>
+ <td id="LC8119" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8120" class="blob-num js-line-number" data-line-number="8120"></td>
+ <td id="LC8120" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8121" class="blob-num js-line-number" data-line-number="8121"></td>
+ <td id="LC8121" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8122" class="blob-num js-line-number" data-line-number="8122"></td>
+ <td id="LC8122" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8123" class="blob-num js-line-number" data-line-number="8123"></td>
+ <td id="LC8123" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8124" class="blob-num js-line-number" data-line-number="8124"></td>
+ <td id="LC8124" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8125" class="blob-num js-line-number" data-line-number="8125"></td>
+ <td id="LC8125" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8126" class="blob-num js-line-number" data-line-number="8126"></td>
+ <td id="LC8126" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L8127" class="blob-num js-line-number" data-line-number="8127"></td>
+ <td id="LC8127" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8128" class="blob-num js-line-number" data-line-number="8128"></td>
+ <td id="LC8128" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L8129" class="blob-num js-line-number" data-line-number="8129"></td>
+ <td id="LC8129" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8130" class="blob-num js-line-number" data-line-number="8130"></td>
+ <td id="LC8130" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8131" class="blob-num js-line-number" data-line-number="8131"></td>
+ <td id="LC8131" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the index of the found element, else `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8132" class="blob-num js-line-number" data-line-number="8132"></td>
+ <td id="LC8132" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8133" class="blob-num js-line-number" data-line-number="8133"></td>
+ <td id="LC8133" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8134" class="blob-num js-line-number" data-line-number="8134"></td>
+ <td id="LC8134" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8135" class="blob-num js-line-number" data-line-number="8135"></td>
+ <td id="LC8135" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36, 'blocked': true },</span></td>
+ </tr>
+ <tr>
+ <td id="L8136" class="blob-num js-line-number" data-line-number="8136"></td>
+ <td id="LC8136" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'blocked': false },</span></td>
+ </tr>
+ <tr>
+ <td id="L8137" class="blob-num js-line-number" data-line-number="8137"></td>
+ <td id="LC8137" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'age': 1, 'blocked': true }</span></td>
+ </tr>
+ <tr>
+ <td id="L8138" class="blob-num js-line-number" data-line-number="8138"></td>
+ <td id="LC8138" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8139" class="blob-num js-line-number" data-line-number="8139"></td>
+ <td id="LC8139" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8140" class="blob-num js-line-number" data-line-number="8140"></td>
+ <td id="LC8140" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLastIndex(characters, function(chr) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8141" class="blob-num js-line-number" data-line-number="8141"></td>
+ <td id="LC8141" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return chr.age > 30;</span></td>
+ </tr>
+ <tr>
+ <td id="L8142" class="blob-num js-line-number" data-line-number="8142"></td>
+ <td id="LC8142" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8143" class="blob-num js-line-number" data-line-number="8143"></td>
+ <td id="LC8143" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 1</span></td>
+ </tr>
+ <tr>
+ <td id="L8144" class="blob-num js-line-number" data-line-number="8144"></td>
+ <td id="LC8144" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8145" class="blob-num js-line-number" data-line-number="8145"></td>
+ <td id="LC8145" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8146" class="blob-num js-line-number" data-line-number="8146"></td>
+ <td id="LC8146" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLastIndex(characters, { 'age': 36 });</span></td>
+ </tr>
+ <tr>
+ <td id="L8147" class="blob-num js-line-number" data-line-number="8147"></td>
+ <td id="LC8147" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 0</span></td>
+ </tr>
+ <tr>
+ <td id="L8148" class="blob-num js-line-number" data-line-number="8148"></td>
+ <td id="LC8148" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8149" class="blob-num js-line-number" data-line-number="8149"></td>
+ <td id="LC8149" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8150" class="blob-num js-line-number" data-line-number="8150"></td>
+ <td id="LC8150" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.findLastIndex(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L8151" class="blob-num js-line-number" data-line-number="8151"></td>
+ <td id="LC8151" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8152" class="blob-num js-line-number" data-line-number="8152"></td>
+ <td id="LC8152" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8153" class="blob-num js-line-number" data-line-number="8153"></td>
+ <td id="LC8153" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">findLastIndex</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8154" class="blob-num js-line-number" data-line-number="8154"></td>
+ <td id="LC8154" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8155" class="blob-num js-line-number" data-line-number="8155"></td>
+ <td id="LC8155" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8156" class="blob-num js-line-number" data-line-number="8156"></td>
+ <td id="LC8156" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8157" class="blob-num js-line-number" data-line-number="8157"></td>
+ <td id="LC8157" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(array[length], length, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8158" class="blob-num js-line-number" data-line-number="8158"></td>
+ <td id="LC8158" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> length;</td>
+ </tr>
+ <tr>
+ <td id="L8159" class="blob-num js-line-number" data-line-number="8159"></td>
+ <td id="LC8159" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8160" class="blob-num js-line-number" data-line-number="8160"></td>
+ <td id="LC8160" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8161" class="blob-num js-line-number" data-line-number="8161"></td>
+ <td id="LC8161" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8162" class="blob-num js-line-number" data-line-number="8162"></td>
+ <td id="LC8162" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8163" class="blob-num js-line-number" data-line-number="8163"></td>
+ <td id="LC8163" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8164" class="blob-num js-line-number" data-line-number="8164"></td>
+ <td id="LC8164" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8165" class="blob-num js-line-number" data-line-number="8165"></td>
+ <td id="LC8165" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the first element or first `n` elements of an array. If a callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8166" class="blob-num js-line-number" data-line-number="8166"></td>
+ <td id="LC8166" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is provided elements at the beginning of the array are returned as long</span></td>
+ </tr>
+ <tr>
+ <td id="L8167" class="blob-num js-line-number" data-line-number="8167"></td>
+ <td id="LC8167" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * as the callback returns truey. The callback is bound to `thisArg` and</span></td>
+ </tr>
+ <tr>
+ <td id="L8168" class="blob-num js-line-number" data-line-number="8168"></td>
+ <td id="LC8168" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked with three arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8169" class="blob-num js-line-number" data-line-number="8169"></td>
+ <td id="LC8169" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8170" class="blob-num js-line-number" data-line-number="8170"></td>
+ <td id="LC8170" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8171" class="blob-num js-line-number" data-line-number="8171"></td>
+ <td id="LC8171" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8172" class="blob-num js-line-number" data-line-number="8172"></td>
+ <td id="LC8172" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8173" class="blob-num js-line-number" data-line-number="8173"></td>
+ <td id="LC8173" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8174" class="blob-num js-line-number" data-line-number="8174"></td>
+ <td id="LC8174" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8175" class="blob-num js-line-number" data-line-number="8175"></td>
+ <td id="LC8175" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8176" class="blob-num js-line-number" data-line-number="8176"></td>
+ <td id="LC8176" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8177" class="blob-num js-line-number" data-line-number="8177"></td>
+ <td id="LC8177" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8178" class="blob-num js-line-number" data-line-number="8178"></td>
+ <td id="LC8178" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8179" class="blob-num js-line-number" data-line-number="8179"></td>
+ <td id="LC8179" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> head, take</span></td>
+ </tr>
+ <tr>
+ <td id="L8180" class="blob-num js-line-number" data-line-number="8180"></td>
+ <td id="LC8180" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8181" class="blob-num js-line-number" data-line-number="8181"></td>
+ <td id="LC8181" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to query.</span></td>
+ </tr>
+ <tr>
+ <td id="L8182" class="blob-num js-line-number" data-line-number="8182"></td>
+ <td id="LC8182" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|number|string} [callback] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8183" class="blob-num js-line-number" data-line-number="8183"></td>
+ <td id="LC8183" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per element or the number of elements to return. If a property name or</span></td>
+ </tr>
+ <tr>
+ <td id="L8184" class="blob-num js-line-number" data-line-number="8184"></td>
+ <td id="LC8184" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object is provided it will be used to create a "_.pluck" or "_.where"</span></td>
+ </tr>
+ <tr>
+ <td id="L8185" class="blob-num js-line-number" data-line-number="8185"></td>
+ <td id="LC8185" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8186" class="blob-num js-line-number" data-line-number="8186"></td>
+ <td id="LC8186" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8187" class="blob-num js-line-number" data-line-number="8187"></td>
+ <td id="LC8187" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the first element(s) of `array`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8188" class="blob-num js-line-number" data-line-number="8188"></td>
+ <td id="LC8188" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8189" class="blob-num js-line-number" data-line-number="8189"></td>
+ <td id="LC8189" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8190" class="blob-num js-line-number" data-line-number="8190"></td>
+ <td id="LC8190" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.first([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8191" class="blob-num js-line-number" data-line-number="8191"></td>
+ <td id="LC8191" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 1</span></td>
+ </tr>
+ <tr>
+ <td id="L8192" class="blob-num js-line-number" data-line-number="8192"></td>
+ <td id="LC8192" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8193" class="blob-num js-line-number" data-line-number="8193"></td>
+ <td id="LC8193" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.first([1, 2, 3], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L8194" class="blob-num js-line-number" data-line-number="8194"></td>
+ <td id="LC8194" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L8195" class="blob-num js-line-number" data-line-number="8195"></td>
+ <td id="LC8195" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8196" class="blob-num js-line-number" data-line-number="8196"></td>
+ <td id="LC8196" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.first([1, 2, 3], function(num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8197" class="blob-num js-line-number" data-line-number="8197"></td>
+ <td id="LC8197" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return num < 3;</span></td>
+ </tr>
+ <tr>
+ <td id="L8198" class="blob-num js-line-number" data-line-number="8198"></td>
+ <td id="LC8198" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8199" class="blob-num js-line-number" data-line-number="8199"></td>
+ <td id="LC8199" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L8200" class="blob-num js-line-number" data-line-number="8200"></td>
+ <td id="LC8200" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8201" class="blob-num js-line-number" data-line-number="8201"></td>
+ <td id="LC8201" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8202" class="blob-num js-line-number" data-line-number="8202"></td>
+ <td id="LC8202" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8203" class="blob-num js-line-number" data-line-number="8203"></td>
+ <td id="LC8203" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8204" class="blob-num js-line-number" data-line-number="8204"></td>
+ <td id="LC8204" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }</span></td>
+ </tr>
+ <tr>
+ <td id="L8205" class="blob-num js-line-number" data-line-number="8205"></td>
+ <td id="LC8205" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8206" class="blob-num js-line-number" data-line-number="8206"></td>
+ <td id="LC8206" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8207" class="blob-num js-line-number" data-line-number="8207"></td>
+ <td id="LC8207" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8208" class="blob-num js-line-number" data-line-number="8208"></td>
+ <td id="LC8208" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.first(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L8209" class="blob-num js-line-number" data-line-number="8209"></td>
+ <td id="LC8209" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8210" class="blob-num js-line-number" data-line-number="8210"></td>
+ <td id="LC8210" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8211" class="blob-num js-line-number" data-line-number="8211"></td>
+ <td id="LC8211" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8212" class="blob-num js-line-number" data-line-number="8212"></td>
+ <td id="LC8212" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L8213" class="blob-num js-line-number" data-line-number="8213"></td>
+ <td id="LC8213" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['barney', 'fred']</span></td>
+ </tr>
+ <tr>
+ <td id="L8214" class="blob-num js-line-number" data-line-number="8214"></td>
+ <td id="LC8214" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8215" class="blob-num js-line-number" data-line-number="8215"></td>
+ <td id="LC8215" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">first</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8216" class="blob-num js-line-number" data-line-number="8216"></td>
+ <td id="LC8216" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> n <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8217" class="blob-num js-line-number" data-line-number="8217"></td>
+ <td id="LC8217" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8218" class="blob-num js-line-number" data-line-number="8218"></td>
+ <td id="LC8218" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8219" class="blob-num js-line-number" data-line-number="8219"></td>
+ <td id="LC8219" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> callback <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8220" class="blob-num js-line-number" data-line-number="8220"></td>
+ <td id="LC8220" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8221" class="blob-num js-line-number" data-line-number="8221"></td>
+ <td id="LC8221" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8222" class="blob-num js-line-number" data-line-number="8222"></td>
+ <td id="LC8222" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length <span class="pl-k">&&</span> <span class="pl-en">callback</span>(array[index], index, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8223" class="blob-num js-line-number" data-line-number="8223"></td>
+ <td id="LC8223" class="blob-code blob-code-inner js-file-line"> n<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8224" class="blob-num js-line-number" data-line-number="8224"></td>
+ <td id="LC8224" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8225" class="blob-num js-line-number" data-line-number="8225"></td>
+ <td id="LC8225" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L8226" class="blob-num js-line-number" data-line-number="8226"></td>
+ <td id="LC8226" class="blob-code blob-code-inner js-file-line"> n <span class="pl-k">=</span> callback;</td>
+ </tr>
+ <tr>
+ <td id="L8227" class="blob-num js-line-number" data-line-number="8227"></td>
+ <td id="LC8227" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (n <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> thisArg) {</td>
+ </tr>
+ <tr>
+ <td id="L8228" class="blob-num js-line-number" data-line-number="8228"></td>
+ <td id="LC8228" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> array <span class="pl-k">?</span> array[<span class="pl-c1">0</span>] <span class="pl-k">:</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8229" class="blob-num js-line-number" data-line-number="8229"></td>
+ <td id="LC8229" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8230" class="blob-num js-line-number" data-line-number="8230"></td>
+ <td id="LC8230" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8231" class="blob-num js-line-number" data-line-number="8231"></td>
+ <td id="LC8231" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">slice</span>(array, <span class="pl-c1">0</span>, <span class="pl-en">nativeMin</span>(<span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, n), length));</td>
+ </tr>
+ <tr>
+ <td id="L8232" class="blob-num js-line-number" data-line-number="8232"></td>
+ <td id="LC8232" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8233" class="blob-num js-line-number" data-line-number="8233"></td>
+ <td id="LC8233" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8234" class="blob-num js-line-number" data-line-number="8234"></td>
+ <td id="LC8234" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8235" class="blob-num js-line-number" data-line-number="8235"></td>
+ <td id="LC8235" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Flattens a nested array (the nesting can be to any depth). If `isShallow`</span></td>
+ </tr>
+ <tr>
+ <td id="L8236" class="blob-num js-line-number" data-line-number="8236"></td>
+ <td id="LC8236" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is truey, the array will only be flattened a single level. If a callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8237" class="blob-num js-line-number" data-line-number="8237"></td>
+ <td id="LC8237" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is provided each element of the array is passed through the callback before</span></td>
+ </tr>
+ <tr>
+ <td id="L8238" class="blob-num js-line-number" data-line-number="8238"></td>
+ <td id="LC8238" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * flattening. The callback is bound to `thisArg` and invoked with three</span></td>
+ </tr>
+ <tr>
+ <td id="L8239" class="blob-num js-line-number" data-line-number="8239"></td>
+ <td id="LC8239" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8240" class="blob-num js-line-number" data-line-number="8240"></td>
+ <td id="LC8240" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8241" class="blob-num js-line-number" data-line-number="8241"></td>
+ <td id="LC8241" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8242" class="blob-num js-line-number" data-line-number="8242"></td>
+ <td id="LC8242" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8243" class="blob-num js-line-number" data-line-number="8243"></td>
+ <td id="LC8243" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8244" class="blob-num js-line-number" data-line-number="8244"></td>
+ <td id="LC8244" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8245" class="blob-num js-line-number" data-line-number="8245"></td>
+ <td id="LC8245" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8246" class="blob-num js-line-number" data-line-number="8246"></td>
+ <td id="LC8246" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8247" class="blob-num js-line-number" data-line-number="8247"></td>
+ <td id="LC8247" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8248" class="blob-num js-line-number" data-line-number="8248"></td>
+ <td id="LC8248" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8249" class="blob-num js-line-number" data-line-number="8249"></td>
+ <td id="LC8249" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8250" class="blob-num js-line-number" data-line-number="8250"></td>
+ <td id="LC8250" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8251" class="blob-num js-line-number" data-line-number="8251"></td>
+ <td id="LC8251" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to flatten.</span></td>
+ </tr>
+ <tr>
+ <td id="L8252" class="blob-num js-line-number" data-line-number="8252"></td>
+ <td id="LC8252" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isShallow=false] A flag to restrict flattening to a single level.</span></td>
+ </tr>
+ <tr>
+ <td id="L8253" class="blob-num js-line-number" data-line-number="8253"></td>
+ <td id="LC8253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8254" class="blob-num js-line-number" data-line-number="8254"></td>
+ <td id="LC8254" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L8255" class="blob-num js-line-number" data-line-number="8255"></td>
+ <td id="LC8255" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8256" class="blob-num js-line-number" data-line-number="8256"></td>
+ <td id="LC8256" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8257" class="blob-num js-line-number" data-line-number="8257"></td>
+ <td id="LC8257" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new flattened array.</span></td>
+ </tr>
+ <tr>
+ <td id="L8258" class="blob-num js-line-number" data-line-number="8258"></td>
+ <td id="LC8258" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8259" class="blob-num js-line-number" data-line-number="8259"></td>
+ <td id="LC8259" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8260" class="blob-num js-line-number" data-line-number="8260"></td>
+ <td id="LC8260" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.flatten([1, [2], [3, [[4]]]]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8261" class="blob-num js-line-number" data-line-number="8261"></td>
+ <td id="LC8261" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3, 4];</span></td>
+ </tr>
+ <tr>
+ <td id="L8262" class="blob-num js-line-number" data-line-number="8262"></td>
+ <td id="LC8262" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8263" class="blob-num js-line-number" data-line-number="8263"></td>
+ <td id="LC8263" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.flatten([1, [2], [3, [[4]]]], true);</span></td>
+ </tr>
+ <tr>
+ <td id="L8264" class="blob-num js-line-number" data-line-number="8264"></td>
+ <td id="LC8264" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3, [[4]]];</span></td>
+ </tr>
+ <tr>
+ <td id="L8265" class="blob-num js-line-number" data-line-number="8265"></td>
+ <td id="LC8265" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8266" class="blob-num js-line-number" data-line-number="8266"></td>
+ <td id="LC8266" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8267" class="blob-num js-line-number" data-line-number="8267"></td>
+ <td id="LC8267" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] },</span></td>
+ </tr>
+ <tr>
+ <td id="L8268" class="blob-num js-line-number" data-line-number="8268"></td>
+ <td id="LC8268" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }</span></td>
+ </tr>
+ <tr>
+ <td id="L8269" class="blob-num js-line-number" data-line-number="8269"></td>
+ <td id="LC8269" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8270" class="blob-num js-line-number" data-line-number="8270"></td>
+ <td id="LC8270" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8271" class="blob-num js-line-number" data-line-number="8271"></td>
+ <td id="LC8271" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8272" class="blob-num js-line-number" data-line-number="8272"></td>
+ <td id="LC8272" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.flatten(characters, 'pets');</span></td>
+ </tr>
+ <tr>
+ <td id="L8273" class="blob-num js-line-number" data-line-number="8273"></td>
+ <td id="LC8273" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['hoppy', 'baby puss', 'dino']</span></td>
+ </tr>
+ <tr>
+ <td id="L8274" class="blob-num js-line-number" data-line-number="8274"></td>
+ <td id="LC8274" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8275" class="blob-num js-line-number" data-line-number="8275"></td>
+ <td id="LC8275" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">flatten</span>(<span class="pl-smi">array</span>, <span class="pl-smi">isShallow</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8276" class="blob-num js-line-number" data-line-number="8276"></td>
+ <td id="LC8276" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// juggle arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L8277" class="blob-num js-line-number" data-line-number="8277"></td>
+ <td id="LC8277" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> isShallow <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> isShallow <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8278" class="blob-num js-line-number" data-line-number="8278"></td>
+ <td id="LC8278" class="blob-code blob-code-inner js-file-line"> thisArg <span class="pl-k">=</span> callback;</td>
+ </tr>
+ <tr>
+ <td id="L8279" class="blob-num js-line-number" data-line-number="8279"></td>
+ <td id="LC8279" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> (<span class="pl-k">typeof</span> isShallow <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> thisArg <span class="pl-k">&&</span> thisArg[isShallow] <span class="pl-k">===</span> array) <span class="pl-k">?</span> <span class="pl-c1">null</span> <spa [...]
+ </tr>
+ <tr>
+ <td id="L8280" class="blob-num js-line-number" data-line-number="8280"></td>
+ <td id="LC8280" class="blob-code blob-code-inner js-file-line"> isShallow <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8281" class="blob-num js-line-number" data-line-number="8281"></td>
+ <td id="LC8281" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8282" class="blob-num js-line-number" data-line-number="8282"></td>
+ <td id="LC8282" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8283" class="blob-num js-line-number" data-line-number="8283"></td>
+ <td id="LC8283" class="blob-code blob-code-inner js-file-line"> array <span class="pl-k">=</span> <span class="pl-en">map</span>(array, callback, thisArg);</td>
+ </tr>
+ <tr>
+ <td id="L8284" class="blob-num js-line-number" data-line-number="8284"></td>
+ <td id="LC8284" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8285" class="blob-num js-line-number" data-line-number="8285"></td>
+ <td id="LC8285" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseFlatten</span>(array, isShallow);</td>
+ </tr>
+ <tr>
+ <td id="L8286" class="blob-num js-line-number" data-line-number="8286"></td>
+ <td id="LC8286" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8287" class="blob-num js-line-number" data-line-number="8287"></td>
+ <td id="LC8287" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8288" class="blob-num js-line-number" data-line-number="8288"></td>
+ <td id="LC8288" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8289" class="blob-num js-line-number" data-line-number="8289"></td>
+ <td id="LC8289" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the index at which the first occurrence of `value` is found using</span></td>
+ </tr>
+ <tr>
+ <td id="L8290" class="blob-num js-line-number" data-line-number="8290"></td>
+ <td id="LC8290" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * strict equality for comparisons, i.e. `===`. If the array is already sorted</span></td>
+ </tr>
+ <tr>
+ <td id="L8291" class="blob-num js-line-number" data-line-number="8291"></td>
+ <td id="LC8291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * providing `true` for `fromIndex` will run a faster binary search.</span></td>
+ </tr>
+ <tr>
+ <td id="L8292" class="blob-num js-line-number" data-line-number="8292"></td>
+ <td id="LC8292" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8293" class="blob-num js-line-number" data-line-number="8293"></td>
+ <td id="LC8293" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8294" class="blob-num js-line-number" data-line-number="8294"></td>
+ <td id="LC8294" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8295" class="blob-num js-line-number" data-line-number="8295"></td>
+ <td id="LC8295" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8296" class="blob-num js-line-number" data-line-number="8296"></td>
+ <td id="LC8296" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L8297" class="blob-num js-line-number" data-line-number="8297"></td>
+ <td id="LC8297" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to search for.</span></td>
+ </tr>
+ <tr>
+ <td id="L8298" class="blob-num js-line-number" data-line-number="8298"></td>
+ <td id="LC8298" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean|number} [fromIndex=0] The index to search from or `true`</span></td>
+ </tr>
+ <tr>
+ <td id="L8299" class="blob-num js-line-number" data-line-number="8299"></td>
+ <td id="LC8299" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to perform a binary search on a sorted array.</span></td>
+ </tr>
+ <tr>
+ <td id="L8300" class="blob-num js-line-number" data-line-number="8300"></td>
+ <td id="LC8300" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the index of the matched value or `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8301" class="blob-num js-line-number" data-line-number="8301"></td>
+ <td id="LC8301" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8302" class="blob-num js-line-number" data-line-number="8302"></td>
+ <td id="LC8302" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8303" class="blob-num js-line-number" data-line-number="8303"></td>
+ <td id="LC8303" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.indexOf([1, 2, 3, 1, 2, 3], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L8304" class="blob-num js-line-number" data-line-number="8304"></td>
+ <td id="LC8304" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 1</span></td>
+ </tr>
+ <tr>
+ <td id="L8305" class="blob-num js-line-number" data-line-number="8305"></td>
+ <td id="LC8305" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8306" class="blob-num js-line-number" data-line-number="8306"></td>
+ <td id="LC8306" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);</span></td>
+ </tr>
+ <tr>
+ <td id="L8307" class="blob-num js-line-number" data-line-number="8307"></td>
+ <td id="LC8307" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 4</span></td>
+ </tr>
+ <tr>
+ <td id="L8308" class="blob-num js-line-number" data-line-number="8308"></td>
+ <td id="LC8308" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8309" class="blob-num js-line-number" data-line-number="8309"></td>
+ <td id="LC8309" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);</span></td>
+ </tr>
+ <tr>
+ <td id="L8310" class="blob-num js-line-number" data-line-number="8310"></td>
+ <td id="LC8310" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8311" class="blob-num js-line-number" data-line-number="8311"></td>
+ <td id="LC8311" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8312" class="blob-num js-line-number" data-line-number="8312"></td>
+ <td id="LC8312" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">indexOf</span>(<span class="pl-smi">array</span>, <span class="pl-smi">value</span>, <span class="pl-smi">fromIndex</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8313" class="blob-num js-line-number" data-line-number="8313"></td>
+ <td id="LC8313" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> fromIndex <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8314" class="blob-num js-line-number" data-line-number="8314"></td>
+ <td id="LC8314" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8315" class="blob-num js-line-number" data-line-number="8315"></td>
+ <td id="LC8315" class="blob-code blob-code-inner js-file-line"> fromIndex <span class="pl-k">=</span> (fromIndex <span class="pl-k"><</span> <span class="pl-c1">0</span> <span class="pl-k">?</span> <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, length <span class="pl-k">+</span> fromIndex) <span class="pl-k">:</span> fromIndex <span class="pl-k">||</span> <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8316" class="blob-num js-line-number" data-line-number="8316"></td>
+ <td id="LC8316" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (fromIndex) {</td>
+ </tr>
+ <tr>
+ <td id="L8317" class="blob-num js-line-number" data-line-number="8317"></td>
+ <td id="LC8317" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-en">sortedIndex</span>(array, value);</td>
+ </tr>
+ <tr>
+ <td id="L8318" class="blob-num js-line-number" data-line-number="8318"></td>
+ <td id="LC8318" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> array[index] <span class="pl-k">===</span> value <span class="pl-k">?</span> index <span class="pl-k">:</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8319" class="blob-num js-line-number" data-line-number="8319"></td>
+ <td id="LC8319" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8320" class="blob-num js-line-number" data-line-number="8320"></td>
+ <td id="LC8320" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseIndexOf</span>(array, value, fromIndex);</td>
+ </tr>
+ <tr>
+ <td id="L8321" class="blob-num js-line-number" data-line-number="8321"></td>
+ <td id="LC8321" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8322" class="blob-num js-line-number" data-line-number="8322"></td>
+ <td id="LC8322" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8323" class="blob-num js-line-number" data-line-number="8323"></td>
+ <td id="LC8323" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8324" class="blob-num js-line-number" data-line-number="8324"></td>
+ <td id="LC8324" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets all but the last element or last `n` elements of an array. If a</span></td>
+ </tr>
+ <tr>
+ <td id="L8325" class="blob-num js-line-number" data-line-number="8325"></td>
+ <td id="LC8325" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback is provided elements at the end of the array are excluded from</span></td>
+ </tr>
+ <tr>
+ <td id="L8326" class="blob-num js-line-number" data-line-number="8326"></td>
+ <td id="LC8326" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the result as long as the callback returns truey. The callback is bound</span></td>
+ </tr>
+ <tr>
+ <td id="L8327" class="blob-num js-line-number" data-line-number="8327"></td>
+ <td id="LC8327" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to `thisArg` and invoked with three arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8328" class="blob-num js-line-number" data-line-number="8328"></td>
+ <td id="LC8328" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8329" class="blob-num js-line-number" data-line-number="8329"></td>
+ <td id="LC8329" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8330" class="blob-num js-line-number" data-line-number="8330"></td>
+ <td id="LC8330" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8331" class="blob-num js-line-number" data-line-number="8331"></td>
+ <td id="LC8331" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8332" class="blob-num js-line-number" data-line-number="8332"></td>
+ <td id="LC8332" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8333" class="blob-num js-line-number" data-line-number="8333"></td>
+ <td id="LC8333" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8334" class="blob-num js-line-number" data-line-number="8334"></td>
+ <td id="LC8334" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8335" class="blob-num js-line-number" data-line-number="8335"></td>
+ <td id="LC8335" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8336" class="blob-num js-line-number" data-line-number="8336"></td>
+ <td id="LC8336" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8337" class="blob-num js-line-number" data-line-number="8337"></td>
+ <td id="LC8337" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8338" class="blob-num js-line-number" data-line-number="8338"></td>
+ <td id="LC8338" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8339" class="blob-num js-line-number" data-line-number="8339"></td>
+ <td id="LC8339" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to query.</span></td>
+ </tr>
+ <tr>
+ <td id="L8340" class="blob-num js-line-number" data-line-number="8340"></td>
+ <td id="LC8340" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|number|string} [callback=1] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8341" class="blob-num js-line-number" data-line-number="8341"></td>
+ <td id="LC8341" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per element or the number of elements to exclude. If a property name or</span></td>
+ </tr>
+ <tr>
+ <td id="L8342" class="blob-num js-line-number" data-line-number="8342"></td>
+ <td id="LC8342" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object is provided it will be used to create a "_.pluck" or "_.where"</span></td>
+ </tr>
+ <tr>
+ <td id="L8343" class="blob-num js-line-number" data-line-number="8343"></td>
+ <td id="LC8343" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8344" class="blob-num js-line-number" data-line-number="8344"></td>
+ <td id="LC8344" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8345" class="blob-num js-line-number" data-line-number="8345"></td>
+ <td id="LC8345" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a slice of `array`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8346" class="blob-num js-line-number" data-line-number="8346"></td>
+ <td id="LC8346" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8347" class="blob-num js-line-number" data-line-number="8347"></td>
+ <td id="LC8347" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8348" class="blob-num js-line-number" data-line-number="8348"></td>
+ <td id="LC8348" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.initial([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8349" class="blob-num js-line-number" data-line-number="8349"></td>
+ <td id="LC8349" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L8350" class="blob-num js-line-number" data-line-number="8350"></td>
+ <td id="LC8350" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8351" class="blob-num js-line-number" data-line-number="8351"></td>
+ <td id="LC8351" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.initial([1, 2, 3], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L8352" class="blob-num js-line-number" data-line-number="8352"></td>
+ <td id="LC8352" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1]</span></td>
+ </tr>
+ <tr>
+ <td id="L8353" class="blob-num js-line-number" data-line-number="8353"></td>
+ <td id="LC8353" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8354" class="blob-num js-line-number" data-line-number="8354"></td>
+ <td id="LC8354" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.initial([1, 2, 3], function(num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8355" class="blob-num js-line-number" data-line-number="8355"></td>
+ <td id="LC8355" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return num > 1;</span></td>
+ </tr>
+ <tr>
+ <td id="L8356" class="blob-num js-line-number" data-line-number="8356"></td>
+ <td id="LC8356" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8357" class="blob-num js-line-number" data-line-number="8357"></td>
+ <td id="LC8357" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1]</span></td>
+ </tr>
+ <tr>
+ <td id="L8358" class="blob-num js-line-number" data-line-number="8358"></td>
+ <td id="LC8358" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8359" class="blob-num js-line-number" data-line-number="8359"></td>
+ <td id="LC8359" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8360" class="blob-num js-line-number" data-line-number="8360"></td>
+ <td id="LC8360" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8361" class="blob-num js-line-number" data-line-number="8361"></td>
+ <td id="LC8361" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8362" class="blob-num js-line-number" data-line-number="8362"></td>
+ <td id="LC8362" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }</span></td>
+ </tr>
+ <tr>
+ <td id="L8363" class="blob-num js-line-number" data-line-number="8363"></td>
+ <td id="LC8363" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8364" class="blob-num js-line-number" data-line-number="8364"></td>
+ <td id="LC8364" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8365" class="blob-num js-line-number" data-line-number="8365"></td>
+ <td id="LC8365" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8366" class="blob-num js-line-number" data-line-number="8366"></td>
+ <td id="LC8366" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.initial(characters, 'blocked');</span></td>
+ </tr>
+ <tr>
+ <td id="L8367" class="blob-num js-line-number" data-line-number="8367"></td>
+ <td id="LC8367" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8368" class="blob-num js-line-number" data-line-number="8368"></td>
+ <td id="LC8368" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8369" class="blob-num js-line-number" data-line-number="8369"></td>
+ <td id="LC8369" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8370" class="blob-num js-line-number" data-line-number="8370"></td>
+ <td id="LC8370" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L8371" class="blob-num js-line-number" data-line-number="8371"></td>
+ <td id="LC8371" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['barney', 'fred']</span></td>
+ </tr>
+ <tr>
+ <td id="L8372" class="blob-num js-line-number" data-line-number="8372"></td>
+ <td id="LC8372" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8373" class="blob-num js-line-number" data-line-number="8373"></td>
+ <td id="LC8373" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">initial</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8374" class="blob-num js-line-number" data-line-number="8374"></td>
+ <td id="LC8374" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> n <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8375" class="blob-num js-line-number" data-line-number="8375"></td>
+ <td id="LC8375" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8376" class="blob-num js-line-number" data-line-number="8376"></td>
+ <td id="LC8376" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8377" class="blob-num js-line-number" data-line-number="8377"></td>
+ <td id="LC8377" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> callback <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8378" class="blob-num js-line-number" data-line-number="8378"></td>
+ <td id="LC8378" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> length;</td>
+ </tr>
+ <tr>
+ <td id="L8379" class="blob-num js-line-number" data-line-number="8379"></td>
+ <td id="LC8379" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8380" class="blob-num js-line-number" data-line-number="8380"></td>
+ <td id="LC8380" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (index<span class="pl-k">--</span> <span class="pl-k">&&</span> <span class="pl-en">callback</span>(array[index], index, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8381" class="blob-num js-line-number" data-line-number="8381"></td>
+ <td id="LC8381" class="blob-code blob-code-inner js-file-line"> n<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8382" class="blob-num js-line-number" data-line-number="8382"></td>
+ <td id="LC8382" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8383" class="blob-num js-line-number" data-line-number="8383"></td>
+ <td id="LC8383" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L8384" class="blob-num js-line-number" data-line-number="8384"></td>
+ <td id="LC8384" class="blob-code blob-code-inner js-file-line"> n <span class="pl-k">=</span> (callback <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> thisArg) <span class="pl-k">?</span> <span class="pl-c1">1</span> <span class="pl-k">:</span> callback <span class="pl-k">||</span> n;</td>
+ </tr>
+ <tr>
+ <td id="L8385" class="blob-num js-line-number" data-line-number="8385"></td>
+ <td id="LC8385" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8386" class="blob-num js-line-number" data-line-number="8386"></td>
+ <td id="LC8386" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">slice</span>(array, <span class="pl-c1">0</span>, <span class="pl-en">nativeMin</span>(<span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, length <span class="pl-k">-</span> n), length));</td>
+ </tr>
+ <tr>
+ <td id="L8387" class="blob-num js-line-number" data-line-number="8387"></td>
+ <td id="LC8387" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8388" class="blob-num js-line-number" data-line-number="8388"></td>
+ <td id="LC8388" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8389" class="blob-num js-line-number" data-line-number="8389"></td>
+ <td id="LC8389" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8390" class="blob-num js-line-number" data-line-number="8390"></td>
+ <td id="LC8390" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of unique values present in all provided arrays using</span></td>
+ </tr>
+ <tr>
+ <td id="L8391" class="blob-num js-line-number" data-line-number="8391"></td>
+ <td id="LC8391" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * strict equality for comparisons, i.e. `===`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8392" class="blob-num js-line-number" data-line-number="8392"></td>
+ <td id="LC8392" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8393" class="blob-num js-line-number" data-line-number="8393"></td>
+ <td id="LC8393" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8394" class="blob-num js-line-number" data-line-number="8394"></td>
+ <td id="LC8394" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8395" class="blob-num js-line-number" data-line-number="8395"></td>
+ <td id="LC8395" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8396" class="blob-num js-line-number" data-line-number="8396"></td>
+ <td id="LC8396" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Array} [array] The arrays to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L8397" class="blob-num js-line-number" data-line-number="8397"></td>
+ <td id="LC8397" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of shared values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8398" class="blob-num js-line-number" data-line-number="8398"></td>
+ <td id="LC8398" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8399" class="blob-num js-line-number" data-line-number="8399"></td>
+ <td id="LC8399" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8400" class="blob-num js-line-number" data-line-number="8400"></td>
+ <td id="LC8400" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8401" class="blob-num js-line-number" data-line-number="8401"></td>
+ <td id="LC8401" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2]</span></td>
+ </tr>
+ <tr>
+ <td id="L8402" class="blob-num js-line-number" data-line-number="8402"></td>
+ <td id="LC8402" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8403" class="blob-num js-line-number" data-line-number="8403"></td>
+ <td id="LC8403" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">intersection</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L8404" class="blob-num js-line-number" data-line-number="8404"></td>
+ <td id="LC8404" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> [],</td>
+ </tr>
+ <tr>
+ <td id="L8405" class="blob-num js-line-number" data-line-number="8405"></td>
+ <td id="LC8405" class="blob-code blob-code-inner js-file-line"> argsIndex <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8406" class="blob-num js-line-number" data-line-number="8406"></td>
+ <td id="LC8406" class="blob-code blob-code-inner js-file-line"> argsLength <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8407" class="blob-num js-line-number" data-line-number="8407"></td>
+ <td id="LC8407" class="blob-code blob-code-inner js-file-line"> caches <span class="pl-k">=</span> <span class="pl-en">getArray</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L8408" class="blob-num js-line-number" data-line-number="8408"></td>
+ <td id="LC8408" class="blob-code blob-code-inner js-file-line"> indexOf <span class="pl-k">=</span> <span class="pl-en">getIndexOf</span>(),</td>
+ </tr>
+ <tr>
+ <td id="L8409" class="blob-num js-line-number" data-line-number="8409"></td>
+ <td id="LC8409" class="blob-code blob-code-inner js-file-line"> trustIndexOf <span class="pl-k">=</span> indexOf <span class="pl-k">===</span> baseIndexOf,</td>
+ </tr>
+ <tr>
+ <td id="L8410" class="blob-num js-line-number" data-line-number="8410"></td>
+ <td id="LC8410" class="blob-code blob-code-inner js-file-line"> seen <span class="pl-k">=</span> <span class="pl-en">getArray</span>();</td>
+ </tr>
+ <tr>
+ <td id="L8411" class="blob-num js-line-number" data-line-number="8411"></td>
+ <td id="LC8411" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8412" class="blob-num js-line-number" data-line-number="8412"></td>
+ <td id="LC8412" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>argsIndex <span class="pl-k"><</span> argsLength) {</td>
+ </tr>
+ <tr>
+ <td id="L8413" class="blob-num js-line-number" data-line-number="8413"></td>
+ <td id="LC8413" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> <span class="pl-v">arguments</span>[argsIndex];</td>
+ </tr>
+ <tr>
+ <td id="L8414" class="blob-num js-line-number" data-line-number="8414"></td>
+ <td id="LC8414" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">isArray</span>(value) <span class="pl-k">||</span> <span class="pl-en">isArguments</span>(value)) {</td>
+ </tr>
+ <tr>
+ <td id="L8415" class="blob-num js-line-number" data-line-number="8415"></td>
+ <td id="LC8415" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">args</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L8416" class="blob-num js-line-number" data-line-number="8416"></td>
+ <td id="LC8416" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">caches</span>.<span class="pl-c1">push</span>(trustIndexOf <span class="pl-k">&&</span> <span class="pl-smi">value</span>.<span class="pl-c1">length</span> <span class="pl-k">>=</span> largeArraySize <span class="pl-k">&&</span></td>
+ </tr>
+ <tr>
+ <td id="L8417" class="blob-num js-line-number" data-line-number="8417"></td>
+ <td id="LC8417" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">createCache</span>(argsIndex <span class="pl-k">?</span> args[argsIndex] <span class="pl-k">:</span> seen));</td>
+ </tr>
+ <tr>
+ <td id="L8418" class="blob-num js-line-number" data-line-number="8418"></td>
+ <td id="LC8418" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8419" class="blob-num js-line-number" data-line-number="8419"></td>
+ <td id="LC8419" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8420" class="blob-num js-line-number" data-line-number="8420"></td>
+ <td id="LC8420" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> array <span class="pl-k">=</span> args[<span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L8421" class="blob-num js-line-number" data-line-number="8421"></td>
+ <td id="LC8421" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8422" class="blob-num js-line-number" data-line-number="8422"></td>
+ <td id="LC8422" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8423" class="blob-num js-line-number" data-line-number="8423"></td>
+ <td id="LC8423" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L8424" class="blob-num js-line-number" data-line-number="8424"></td>
+ <td id="LC8424" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8425" class="blob-num js-line-number" data-line-number="8425"></td>
+ <td id="LC8425" class="blob-code blob-code-inner js-file-line"> outer<span class="pl-k">:</span></td>
+ </tr>
+ <tr>
+ <td id="L8426" class="blob-num js-line-number" data-line-number="8426"></td>
+ <td id="LC8426" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8427" class="blob-num js-line-number" data-line-number="8427"></td>
+ <td id="LC8427" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> caches[<span class="pl-c1">0</span>];</td>
+ </tr>
+ <tr>
+ <td id="L8428" class="blob-num js-line-number" data-line-number="8428"></td>
+ <td id="LC8428" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> array[index];</td>
+ </tr>
+ <tr>
+ <td id="L8429" class="blob-num js-line-number" data-line-number="8429"></td>
+ <td id="LC8429" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8430" class="blob-num js-line-number" data-line-number="8430"></td>
+ <td id="LC8430" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((cache <span class="pl-k">?</span> <span class="pl-en">cacheIndexOf</span>(cache, value) <span class="pl-k">:</span> <span class="pl-en">indexOf</span>(seen, value)) <span class="pl-k"><</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8431" class="blob-num js-line-number" data-line-number="8431"></td>
+ <td id="LC8431" class="blob-code blob-code-inner js-file-line"> argsIndex <span class="pl-k">=</span> argsLength;</td>
+ </tr>
+ <tr>
+ <td id="L8432" class="blob-num js-line-number" data-line-number="8432"></td>
+ <td id="LC8432" class="blob-code blob-code-inner js-file-line"> (cache <span class="pl-k">||</span> seen).<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L8433" class="blob-num js-line-number" data-line-number="8433"></td>
+ <td id="LC8433" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">--</span>argsIndex) {</td>
+ </tr>
+ <tr>
+ <td id="L8434" class="blob-num js-line-number" data-line-number="8434"></td>
+ <td id="LC8434" class="blob-code blob-code-inner js-file-line"> cache <span class="pl-k">=</span> caches[argsIndex];</td>
+ </tr>
+ <tr>
+ <td id="L8435" class="blob-num js-line-number" data-line-number="8435"></td>
+ <td id="LC8435" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> ((cache <span class="pl-k">?</span> <span class="pl-en">cacheIndexOf</span>(cache, value) <span class="pl-k">:</span> <span class="pl-en">indexOf</span>(args[argsIndex], value)) <span class="pl-k"><</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8436" class="blob-num js-line-number" data-line-number="8436"></td>
+ <td id="LC8436" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">continue</span> outer;</td>
+ </tr>
+ <tr>
+ <td id="L8437" class="blob-num js-line-number" data-line-number="8437"></td>
+ <td id="LC8437" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8438" class="blob-num js-line-number" data-line-number="8438"></td>
+ <td id="LC8438" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8439" class="blob-num js-line-number" data-line-number="8439"></td>
+ <td id="LC8439" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L8440" class="blob-num js-line-number" data-line-number="8440"></td>
+ <td id="LC8440" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8441" class="blob-num js-line-number" data-line-number="8441"></td>
+ <td id="LC8441" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8442" class="blob-num js-line-number" data-line-number="8442"></td>
+ <td id="LC8442" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (argsLength<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8443" class="blob-num js-line-number" data-line-number="8443"></td>
+ <td id="LC8443" class="blob-code blob-code-inner js-file-line"> cache <span class="pl-k">=</span> caches[argsLength];</td>
+ </tr>
+ <tr>
+ <td id="L8444" class="blob-num js-line-number" data-line-number="8444"></td>
+ <td id="LC8444" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (cache) {</td>
+ </tr>
+ <tr>
+ <td id="L8445" class="blob-num js-line-number" data-line-number="8445"></td>
+ <td id="LC8445" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseObject</span>(cache);</td>
+ </tr>
+ <tr>
+ <td id="L8446" class="blob-num js-line-number" data-line-number="8446"></td>
+ <td id="LC8446" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8447" class="blob-num js-line-number" data-line-number="8447"></td>
+ <td id="LC8447" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8448" class="blob-num js-line-number" data-line-number="8448"></td>
+ <td id="LC8448" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(caches);</td>
+ </tr>
+ <tr>
+ <td id="L8449" class="blob-num js-line-number" data-line-number="8449"></td>
+ <td id="LC8449" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">releaseArray</span>(seen);</td>
+ </tr>
+ <tr>
+ <td id="L8450" class="blob-num js-line-number" data-line-number="8450"></td>
+ <td id="LC8450" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L8451" class="blob-num js-line-number" data-line-number="8451"></td>
+ <td id="LC8451" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8452" class="blob-num js-line-number" data-line-number="8452"></td>
+ <td id="LC8452" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8453" class="blob-num js-line-number" data-line-number="8453"></td>
+ <td id="LC8453" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8454" class="blob-num js-line-number" data-line-number="8454"></td>
+ <td id="LC8454" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the last element or last `n` elements of an array. If a callback is</span></td>
+ </tr>
+ <tr>
+ <td id="L8455" class="blob-num js-line-number" data-line-number="8455"></td>
+ <td id="LC8455" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided elements at the end of the array are returned as long as the</span></td>
+ </tr>
+ <tr>
+ <td id="L8456" class="blob-num js-line-number" data-line-number="8456"></td>
+ <td id="LC8456" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback returns truey. The callback is bound to `thisArg` and invoked</span></td>
+ </tr>
+ <tr>
+ <td id="L8457" class="blob-num js-line-number" data-line-number="8457"></td>
+ <td id="LC8457" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * with three arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8458" class="blob-num js-line-number" data-line-number="8458"></td>
+ <td id="LC8458" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8459" class="blob-num js-line-number" data-line-number="8459"></td>
+ <td id="LC8459" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8460" class="blob-num js-line-number" data-line-number="8460"></td>
+ <td id="LC8460" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8461" class="blob-num js-line-number" data-line-number="8461"></td>
+ <td id="LC8461" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8462" class="blob-num js-line-number" data-line-number="8462"></td>
+ <td id="LC8462" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8463" class="blob-num js-line-number" data-line-number="8463"></td>
+ <td id="LC8463" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8464" class="blob-num js-line-number" data-line-number="8464"></td>
+ <td id="LC8464" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8465" class="blob-num js-line-number" data-line-number="8465"></td>
+ <td id="LC8465" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8466" class="blob-num js-line-number" data-line-number="8466"></td>
+ <td id="LC8466" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8467" class="blob-num js-line-number" data-line-number="8467"></td>
+ <td id="LC8467" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8468" class="blob-num js-line-number" data-line-number="8468"></td>
+ <td id="LC8468" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8469" class="blob-num js-line-number" data-line-number="8469"></td>
+ <td id="LC8469" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to query.</span></td>
+ </tr>
+ <tr>
+ <td id="L8470" class="blob-num js-line-number" data-line-number="8470"></td>
+ <td id="LC8470" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|number|string} [callback] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8471" class="blob-num js-line-number" data-line-number="8471"></td>
+ <td id="LC8471" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per element or the number of elements to return. If a property name or</span></td>
+ </tr>
+ <tr>
+ <td id="L8472" class="blob-num js-line-number" data-line-number="8472"></td>
+ <td id="LC8472" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object is provided it will be used to create a "_.pluck" or "_.where"</span></td>
+ </tr>
+ <tr>
+ <td id="L8473" class="blob-num js-line-number" data-line-number="8473"></td>
+ <td id="LC8473" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8474" class="blob-num js-line-number" data-line-number="8474"></td>
+ <td id="LC8474" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8475" class="blob-num js-line-number" data-line-number="8475"></td>
+ <td id="LC8475" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the last element(s) of `array`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8476" class="blob-num js-line-number" data-line-number="8476"></td>
+ <td id="LC8476" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8477" class="blob-num js-line-number" data-line-number="8477"></td>
+ <td id="LC8477" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8478" class="blob-num js-line-number" data-line-number="8478"></td>
+ <td id="LC8478" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.last([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8479" class="blob-num js-line-number" data-line-number="8479"></td>
+ <td id="LC8479" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 3</span></td>
+ </tr>
+ <tr>
+ <td id="L8480" class="blob-num js-line-number" data-line-number="8480"></td>
+ <td id="LC8480" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8481" class="blob-num js-line-number" data-line-number="8481"></td>
+ <td id="LC8481" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.last([1, 2, 3], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L8482" class="blob-num js-line-number" data-line-number="8482"></td>
+ <td id="LC8482" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8483" class="blob-num js-line-number" data-line-number="8483"></td>
+ <td id="LC8483" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8484" class="blob-num js-line-number" data-line-number="8484"></td>
+ <td id="LC8484" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.last([1, 2, 3], function(num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8485" class="blob-num js-line-number" data-line-number="8485"></td>
+ <td id="LC8485" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return num > 1;</span></td>
+ </tr>
+ <tr>
+ <td id="L8486" class="blob-num js-line-number" data-line-number="8486"></td>
+ <td id="LC8486" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8487" class="blob-num js-line-number" data-line-number="8487"></td>
+ <td id="LC8487" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8488" class="blob-num js-line-number" data-line-number="8488"></td>
+ <td id="LC8488" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8489" class="blob-num js-line-number" data-line-number="8489"></td>
+ <td id="LC8489" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8490" class="blob-num js-line-number" data-line-number="8490"></td>
+ <td id="LC8490" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'blocked': false, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8491" class="blob-num js-line-number" data-line-number="8491"></td>
+ <td id="LC8491" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'blocked': true, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8492" class="blob-num js-line-number" data-line-number="8492"></td>
+ <td id="LC8492" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }</span></td>
+ </tr>
+ <tr>
+ <td id="L8493" class="blob-num js-line-number" data-line-number="8493"></td>
+ <td id="LC8493" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8494" class="blob-num js-line-number" data-line-number="8494"></td>
+ <td id="LC8494" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8495" class="blob-num js-line-number" data-line-number="8495"></td>
+ <td id="LC8495" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8496" class="blob-num js-line-number" data-line-number="8496"></td>
+ <td id="LC8496" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pluck(_.last(characters, 'blocked'), 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L8497" class="blob-num js-line-number" data-line-number="8497"></td>
+ <td id="LC8497" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['fred', 'pebbles']</span></td>
+ </tr>
+ <tr>
+ <td id="L8498" class="blob-num js-line-number" data-line-number="8498"></td>
+ <td id="LC8498" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8499" class="blob-num js-line-number" data-line-number="8499"></td>
+ <td id="LC8499" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8500" class="blob-num js-line-number" data-line-number="8500"></td>
+ <td id="LC8500" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.last(characters, { 'employer': 'na' });</span></td>
+ </tr>
+ <tr>
+ <td id="L8501" class="blob-num js-line-number" data-line-number="8501"></td>
+ <td id="LC8501" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8502" class="blob-num js-line-number" data-line-number="8502"></td>
+ <td id="LC8502" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8503" class="blob-num js-line-number" data-line-number="8503"></td>
+ <td id="LC8503" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">last</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8504" class="blob-num js-line-number" data-line-number="8504"></td>
+ <td id="LC8504" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> n <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8505" class="blob-num js-line-number" data-line-number="8505"></td>
+ <td id="LC8505" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8506" class="blob-num js-line-number" data-line-number="8506"></td>
+ <td id="LC8506" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8507" class="blob-num js-line-number" data-line-number="8507"></td>
+ <td id="LC8507" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> callback <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8508" class="blob-num js-line-number" data-line-number="8508"></td>
+ <td id="LC8508" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> length;</td>
+ </tr>
+ <tr>
+ <td id="L8509" class="blob-num js-line-number" data-line-number="8509"></td>
+ <td id="LC8509" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8510" class="blob-num js-line-number" data-line-number="8510"></td>
+ <td id="LC8510" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (index<span class="pl-k">--</span> <span class="pl-k">&&</span> <span class="pl-en">callback</span>(array[index], index, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8511" class="blob-num js-line-number" data-line-number="8511"></td>
+ <td id="LC8511" class="blob-code blob-code-inner js-file-line"> n<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8512" class="blob-num js-line-number" data-line-number="8512"></td>
+ <td id="LC8512" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8513" class="blob-num js-line-number" data-line-number="8513"></td>
+ <td id="LC8513" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L8514" class="blob-num js-line-number" data-line-number="8514"></td>
+ <td id="LC8514" class="blob-code blob-code-inner js-file-line"> n <span class="pl-k">=</span> callback;</td>
+ </tr>
+ <tr>
+ <td id="L8515" class="blob-num js-line-number" data-line-number="8515"></td>
+ <td id="LC8515" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (n <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> thisArg) {</td>
+ </tr>
+ <tr>
+ <td id="L8516" class="blob-num js-line-number" data-line-number="8516"></td>
+ <td id="LC8516" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> array <span class="pl-k">?</span> array[length <span class="pl-k">-</span> <span class="pl-c1">1</span>] <span class="pl-k">:</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8517" class="blob-num js-line-number" data-line-number="8517"></td>
+ <td id="LC8517" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8518" class="blob-num js-line-number" data-line-number="8518"></td>
+ <td id="LC8518" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8519" class="blob-num js-line-number" data-line-number="8519"></td>
+ <td id="LC8519" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">slice</span>(array, <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, length <span class="pl-k">-</span> n));</td>
+ </tr>
+ <tr>
+ <td id="L8520" class="blob-num js-line-number" data-line-number="8520"></td>
+ <td id="LC8520" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8521" class="blob-num js-line-number" data-line-number="8521"></td>
+ <td id="LC8521" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8522" class="blob-num js-line-number" data-line-number="8522"></td>
+ <td id="LC8522" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8523" class="blob-num js-line-number" data-line-number="8523"></td>
+ <td id="LC8523" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the index at which the last occurrence of `value` is found using strict</span></td>
+ </tr>
+ <tr>
+ <td id="L8524" class="blob-num js-line-number" data-line-number="8524"></td>
+ <td id="LC8524" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used</span></td>
+ </tr>
+ <tr>
+ <td id="L8525" class="blob-num js-line-number" data-line-number="8525"></td>
+ <td id="LC8525" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * as the offset from the end of the collection.</span></td>
+ </tr>
+ <tr>
+ <td id="L8526" class="blob-num js-line-number" data-line-number="8526"></td>
+ <td id="LC8526" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8527" class="blob-num js-line-number" data-line-number="8527"></td>
+ <td id="LC8527" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8528" class="blob-num js-line-number" data-line-number="8528"></td>
+ <td id="LC8528" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8529" class="blob-num js-line-number" data-line-number="8529"></td>
+ <td id="LC8529" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8530" class="blob-num js-line-number" data-line-number="8530"></td>
+ <td id="LC8530" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8531" class="blob-num js-line-number" data-line-number="8531"></td>
+ <td id="LC8531" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8532" class="blob-num js-line-number" data-line-number="8532"></td>
+ <td id="LC8532" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8533" class="blob-num js-line-number" data-line-number="8533"></td>
+ <td id="LC8533" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8534" class="blob-num js-line-number" data-line-number="8534"></td>
+ <td id="LC8534" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8535" class="blob-num js-line-number" data-line-number="8535"></td>
+ <td id="LC8535" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8536" class="blob-num js-line-number" data-line-number="8536"></td>
+ <td id="LC8536" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8537" class="blob-num js-line-number" data-line-number="8537"></td>
+ <td id="LC8537" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to search.</span></td>
+ </tr>
+ <tr>
+ <td id="L8538" class="blob-num js-line-number" data-line-number="8538"></td>
+ <td id="LC8538" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to search for.</span></td>
+ </tr>
+ <tr>
+ <td id="L8539" class="blob-num js-line-number" data-line-number="8539"></td>
+ <td id="LC8539" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [fromIndex=array.length-1] The index to search from.</span></td>
+ </tr>
+ <tr>
+ <td id="L8540" class="blob-num js-line-number" data-line-number="8540"></td>
+ <td id="LC8540" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the index of the matched value or `-1`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8541" class="blob-num js-line-number" data-line-number="8541"></td>
+ <td id="LC8541" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8542" class="blob-num js-line-number" data-line-number="8542"></td>
+ <td id="LC8542" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8543" class="blob-num js-line-number" data-line-number="8543"></td>
+ <td id="LC8543" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L8544" class="blob-num js-line-number" data-line-number="8544"></td>
+ <td id="LC8544" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 4</span></td>
+ </tr>
+ <tr>
+ <td id="L8545" class="blob-num js-line-number" data-line-number="8545"></td>
+ <td id="LC8545" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8546" class="blob-num js-line-number" data-line-number="8546"></td>
+ <td id="LC8546" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);</span></td>
+ </tr>
+ <tr>
+ <td id="L8547" class="blob-num js-line-number" data-line-number="8547"></td>
+ <td id="LC8547" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 1</span></td>
+ </tr>
+ <tr>
+ <td id="L8548" class="blob-num js-line-number" data-line-number="8548"></td>
+ <td id="LC8548" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8549" class="blob-num js-line-number" data-line-number="8549"></td>
+ <td id="LC8549" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">lastIndexOf</span>(<span class="pl-smi">array</span>, <span class="pl-smi">value</span>, <span class="pl-smi">fromIndex</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8550" class="blob-num js-line-number" data-line-number="8550"></td>
+ <td id="LC8550" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8551" class="blob-num js-line-number" data-line-number="8551"></td>
+ <td id="LC8551" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> fromIndex <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8552" class="blob-num js-line-number" data-line-number="8552"></td>
+ <td id="LC8552" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> (fromIndex <span class="pl-k"><</span> <span class="pl-c1">0</span> <span class="pl-k">?</span> <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, index <span class="pl-k">+</span> fromIndex) <span class="pl-k">:</span> <span class="pl-en">nativeMin</span>(fromIndex, index <span class="pl-k">-</span> <span class="pl-c1">1</span>)) <span class="pl-k">+</span> [...]
+ </tr>
+ <tr>
+ <td id="L8553" class="blob-num js-line-number" data-line-number="8553"></td>
+ <td id="LC8553" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8554" class="blob-num js-line-number" data-line-number="8554"></td>
+ <td id="LC8554" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (index<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8555" class="blob-num js-line-number" data-line-number="8555"></td>
+ <td id="LC8555" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (array[index] <span class="pl-k">===</span> value) {</td>
+ </tr>
+ <tr>
+ <td id="L8556" class="blob-num js-line-number" data-line-number="8556"></td>
+ <td id="LC8556" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> index;</td>
+ </tr>
+ <tr>
+ <td id="L8557" class="blob-num js-line-number" data-line-number="8557"></td>
+ <td id="LC8557" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8558" class="blob-num js-line-number" data-line-number="8558"></td>
+ <td id="LC8558" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8559" class="blob-num js-line-number" data-line-number="8559"></td>
+ <td id="LC8559" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">-</span><span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8560" class="blob-num js-line-number" data-line-number="8560"></td>
+ <td id="LC8560" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8561" class="blob-num js-line-number" data-line-number="8561"></td>
+ <td id="LC8561" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8562" class="blob-num js-line-number" data-line-number="8562"></td>
+ <td id="LC8562" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8563" class="blob-num js-line-number" data-line-number="8563"></td>
+ <td id="LC8563" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Removes all provided values from the given array using strict equality for</span></td>
+ </tr>
+ <tr>
+ <td id="L8564" class="blob-num js-line-number" data-line-number="8564"></td>
+ <td id="LC8564" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * comparisons, i.e. `===`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8565" class="blob-num js-line-number" data-line-number="8565"></td>
+ <td id="LC8565" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8566" class="blob-num js-line-number" data-line-number="8566"></td>
+ <td id="LC8566" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8567" class="blob-num js-line-number" data-line-number="8567"></td>
+ <td id="LC8567" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8568" class="blob-num js-line-number" data-line-number="8568"></td>
+ <td id="LC8568" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8569" class="blob-num js-line-number" data-line-number="8569"></td>
+ <td id="LC8569" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to modify.</span></td>
+ </tr>
+ <tr>
+ <td id="L8570" class="blob-num js-line-number" data-line-number="8570"></td>
+ <td id="LC8570" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [value] The values to remove.</span></td>
+ </tr>
+ <tr>
+ <td id="L8571" class="blob-num js-line-number" data-line-number="8571"></td>
+ <td id="LC8571" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> `array`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8572" class="blob-num js-line-number" data-line-number="8572"></td>
+ <td id="LC8572" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8573" class="blob-num js-line-number" data-line-number="8573"></td>
+ <td id="LC8573" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8574" class="blob-num js-line-number" data-line-number="8574"></td>
+ <td id="LC8574" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var array = [1, 2, 3, 1, 2, 3];</span></td>
+ </tr>
+ <tr>
+ <td id="L8575" class="blob-num js-line-number" data-line-number="8575"></td>
+ <td id="LC8575" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pull(array, 2, 3);</span></td>
+ </tr>
+ <tr>
+ <td id="L8576" class="blob-num js-line-number" data-line-number="8576"></td>
+ <td id="LC8576" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(array);</span></td>
+ </tr>
+ <tr>
+ <td id="L8577" class="blob-num js-line-number" data-line-number="8577"></td>
+ <td id="LC8577" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 1]</span></td>
+ </tr>
+ <tr>
+ <td id="L8578" class="blob-num js-line-number" data-line-number="8578"></td>
+ <td id="LC8578" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8579" class="blob-num js-line-number" data-line-number="8579"></td>
+ <td id="LC8579" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">pull</span>(<span class="pl-smi">array</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8580" class="blob-num js-line-number" data-line-number="8580"></td>
+ <td id="LC8580" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8581" class="blob-num js-line-number" data-line-number="8581"></td>
+ <td id="LC8581" class="blob-code blob-code-inner js-file-line"> argsIndex <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8582" class="blob-num js-line-number" data-line-number="8582"></td>
+ <td id="LC8582" class="blob-code blob-code-inner js-file-line"> argsLength <span class="pl-k">=</span> <span class="pl-smi">args</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8583" class="blob-num js-line-number" data-line-number="8583"></td>
+ <td id="LC8583" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8584" class="blob-num js-line-number" data-line-number="8584"></td>
+ <td id="LC8584" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8585" class="blob-num js-line-number" data-line-number="8585"></td>
+ <td id="LC8585" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>argsIndex <span class="pl-k"><</span> argsLength) {</td>
+ </tr>
+ <tr>
+ <td id="L8586" class="blob-num js-line-number" data-line-number="8586"></td>
+ <td id="LC8586" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8587" class="blob-num js-line-number" data-line-number="8587"></td>
+ <td id="LC8587" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> args[argsIndex];</td>
+ </tr>
+ <tr>
+ <td id="L8588" class="blob-num js-line-number" data-line-number="8588"></td>
+ <td id="LC8588" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8589" class="blob-num js-line-number" data-line-number="8589"></td>
+ <td id="LC8589" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (array[index] <span class="pl-k">===</span> value) {</td>
+ </tr>
+ <tr>
+ <td id="L8590" class="blob-num js-line-number" data-line-number="8590"></td>
+ <td id="LC8590" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">splice</span>.<span class="pl-c1">call</span>(array, index<span class="pl-k">--</span>, <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8591" class="blob-num js-line-number" data-line-number="8591"></td>
+ <td id="LC8591" class="blob-code blob-code-inner js-file-line"> length<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8592" class="blob-num js-line-number" data-line-number="8592"></td>
+ <td id="LC8592" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8593" class="blob-num js-line-number" data-line-number="8593"></td>
+ <td id="LC8593" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8594" class="blob-num js-line-number" data-line-number="8594"></td>
+ <td id="LC8594" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8595" class="blob-num js-line-number" data-line-number="8595"></td>
+ <td id="LC8595" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> array;</td>
+ </tr>
+ <tr>
+ <td id="L8596" class="blob-num js-line-number" data-line-number="8596"></td>
+ <td id="LC8596" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8597" class="blob-num js-line-number" data-line-number="8597"></td>
+ <td id="LC8597" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8598" class="blob-num js-line-number" data-line-number="8598"></td>
+ <td id="LC8598" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8599" class="blob-num js-line-number" data-line-number="8599"></td>
+ <td id="LC8599" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of numbers (positive and/or negative) progressing from</span></td>
+ </tr>
+ <tr>
+ <td id="L8600" class="blob-num js-line-number" data-line-number="8600"></td>
+ <td id="LC8600" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `start` up to but not including `end`. If `start` is less than `stop` a</span></td>
+ </tr>
+ <tr>
+ <td id="L8601" class="blob-num js-line-number" data-line-number="8601"></td>
+ <td id="LC8601" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * zero-length range is created unless a negative `step` is specified.</span></td>
+ </tr>
+ <tr>
+ <td id="L8602" class="blob-num js-line-number" data-line-number="8602"></td>
+ <td id="LC8602" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8603" class="blob-num js-line-number" data-line-number="8603"></td>
+ <td id="LC8603" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8604" class="blob-num js-line-number" data-line-number="8604"></td>
+ <td id="LC8604" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8605" class="blob-num js-line-number" data-line-number="8605"></td>
+ <td id="LC8605" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8606" class="blob-num js-line-number" data-line-number="8606"></td>
+ <td id="LC8606" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [start=0] The start of the range.</span></td>
+ </tr>
+ <tr>
+ <td id="L8607" class="blob-num js-line-number" data-line-number="8607"></td>
+ <td id="LC8607" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">end</span> The end of the range.</span></td>
+ </tr>
+ <tr>
+ <td id="L8608" class="blob-num js-line-number" data-line-number="8608"></td>
+ <td id="LC8608" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [step=1] The value to increment or decrement by.</span></td>
+ </tr>
+ <tr>
+ <td id="L8609" class="blob-num js-line-number" data-line-number="8609"></td>
+ <td id="LC8609" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new range array.</span></td>
+ </tr>
+ <tr>
+ <td id="L8610" class="blob-num js-line-number" data-line-number="8610"></td>
+ <td id="LC8610" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8611" class="blob-num js-line-number" data-line-number="8611"></td>
+ <td id="LC8611" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8612" class="blob-num js-line-number" data-line-number="8612"></td>
+ <td id="LC8612" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.range(4);</span></td>
+ </tr>
+ <tr>
+ <td id="L8613" class="blob-num js-line-number" data-line-number="8613"></td>
+ <td id="LC8613" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [0, 1, 2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8614" class="blob-num js-line-number" data-line-number="8614"></td>
+ <td id="LC8614" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8615" class="blob-num js-line-number" data-line-number="8615"></td>
+ <td id="LC8615" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.range(1, 5);</span></td>
+ </tr>
+ <tr>
+ <td id="L8616" class="blob-num js-line-number" data-line-number="8616"></td>
+ <td id="LC8616" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L8617" class="blob-num js-line-number" data-line-number="8617"></td>
+ <td id="LC8617" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8618" class="blob-num js-line-number" data-line-number="8618"></td>
+ <td id="LC8618" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.range(0, 20, 5);</span></td>
+ </tr>
+ <tr>
+ <td id="L8619" class="blob-num js-line-number" data-line-number="8619"></td>
+ <td id="LC8619" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [0, 5, 10, 15]</span></td>
+ </tr>
+ <tr>
+ <td id="L8620" class="blob-num js-line-number" data-line-number="8620"></td>
+ <td id="LC8620" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8621" class="blob-num js-line-number" data-line-number="8621"></td>
+ <td id="LC8621" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.range(0, -4, -1);</span></td>
+ </tr>
+ <tr>
+ <td id="L8622" class="blob-num js-line-number" data-line-number="8622"></td>
+ <td id="LC8622" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [0, -1, -2, -3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8623" class="blob-num js-line-number" data-line-number="8623"></td>
+ <td id="LC8623" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8624" class="blob-num js-line-number" data-line-number="8624"></td>
+ <td id="LC8624" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.range(1, 4, 0);</span></td>
+ </tr>
+ <tr>
+ <td id="L8625" class="blob-num js-line-number" data-line-number="8625"></td>
+ <td id="LC8625" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 1, 1]</span></td>
+ </tr>
+ <tr>
+ <td id="L8626" class="blob-num js-line-number" data-line-number="8626"></td>
+ <td id="LC8626" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8627" class="blob-num js-line-number" data-line-number="8627"></td>
+ <td id="LC8627" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.range(0);</span></td>
+ </tr>
+ <tr>
+ <td id="L8628" class="blob-num js-line-number" data-line-number="8628"></td>
+ <td id="LC8628" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => []</span></td>
+ </tr>
+ <tr>
+ <td id="L8629" class="blob-num js-line-number" data-line-number="8629"></td>
+ <td id="LC8629" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8630" class="blob-num js-line-number" data-line-number="8630"></td>
+ <td id="LC8630" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">range</span>(<span class="pl-smi">start</span>, <span class="pl-smi">end</span>, <span class="pl-smi">step</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8631" class="blob-num js-line-number" data-line-number="8631"></td>
+ <td id="LC8631" class="blob-code blob-code-inner js-file-line"> start <span class="pl-k">=</span> <span class="pl-k">+</span>start <span class="pl-k">||</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8632" class="blob-num js-line-number" data-line-number="8632"></td>
+ <td id="LC8632" class="blob-code blob-code-inner js-file-line"> step <span class="pl-k">=</span> <span class="pl-k">typeof</span> step <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> step <span class="pl-k">:</span> (<span class="pl-k">+</span>step <span class="pl-k">||</span> <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8633" class="blob-num js-line-number" data-line-number="8633"></td>
+ <td id="LC8633" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8634" class="blob-num js-line-number" data-line-number="8634"></td>
+ <td id="LC8634" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (end <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8635" class="blob-num js-line-number" data-line-number="8635"></td>
+ <td id="LC8635" class="blob-code blob-code-inner js-file-line"> end <span class="pl-k">=</span> start;</td>
+ </tr>
+ <tr>
+ <td id="L8636" class="blob-num js-line-number" data-line-number="8636"></td>
+ <td id="LC8636" class="blob-code blob-code-inner js-file-line"> start <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8637" class="blob-num js-line-number" data-line-number="8637"></td>
+ <td id="LC8637" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8638" class="blob-num js-line-number" data-line-number="8638"></td>
+ <td id="LC8638" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// use `Array(length)` so engines like Chakra and V8 avoid slower modes</span></td>
+ </tr>
+ <tr>
+ <td id="L8639" class="blob-num js-line-number" data-line-number="8639"></td>
+ <td id="LC8639" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://youtu.be/XAqIpGU8ZZk#t=17m25s</span></td>
+ </tr>
+ <tr>
+ <td id="L8640" class="blob-num js-line-number" data-line-number="8640"></td>
+ <td id="LC8640" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8641" class="blob-num js-line-number" data-line-number="8641"></td>
+ <td id="LC8641" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, <span class="pl-en">ceil</span>((end <span class="pl-k">-</span> start) <span class="pl-k">/</span> (step <span class="pl-k">||</span> <span class="pl-c1">1</span>))),</td>
+ </tr>
+ <tr>
+ <td id="L8642" class="blob-num js-line-number" data-line-number="8642"></td>
+ <td id="LC8642" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length);</td>
+ </tr>
+ <tr>
+ <td id="L8643" class="blob-num js-line-number" data-line-number="8643"></td>
+ <td id="LC8643" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8644" class="blob-num js-line-number" data-line-number="8644"></td>
+ <td id="LC8644" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8645" class="blob-num js-line-number" data-line-number="8645"></td>
+ <td id="LC8645" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> start;</td>
+ </tr>
+ <tr>
+ <td id="L8646" class="blob-num js-line-number" data-line-number="8646"></td>
+ <td id="LC8646" class="blob-code blob-code-inner js-file-line"> start <span class="pl-k">+=</span> step;</td>
+ </tr>
+ <tr>
+ <td id="L8647" class="blob-num js-line-number" data-line-number="8647"></td>
+ <td id="LC8647" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8648" class="blob-num js-line-number" data-line-number="8648"></td>
+ <td id="LC8648" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L8649" class="blob-num js-line-number" data-line-number="8649"></td>
+ <td id="LC8649" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8650" class="blob-num js-line-number" data-line-number="8650"></td>
+ <td id="LC8650" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8651" class="blob-num js-line-number" data-line-number="8651"></td>
+ <td id="LC8651" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8652" class="blob-num js-line-number" data-line-number="8652"></td>
+ <td id="LC8652" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Removes all elements from an array that the callback returns truey for</span></td>
+ </tr>
+ <tr>
+ <td id="L8653" class="blob-num js-line-number" data-line-number="8653"></td>
+ <td id="LC8653" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and returns an array of removed elements. The callback is bound to `thisArg`</span></td>
+ </tr>
+ <tr>
+ <td id="L8654" class="blob-num js-line-number" data-line-number="8654"></td>
+ <td id="LC8654" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and invoked with three arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8655" class="blob-num js-line-number" data-line-number="8655"></td>
+ <td id="LC8655" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8656" class="blob-num js-line-number" data-line-number="8656"></td>
+ <td id="LC8656" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8657" class="blob-num js-line-number" data-line-number="8657"></td>
+ <td id="LC8657" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8658" class="blob-num js-line-number" data-line-number="8658"></td>
+ <td id="LC8658" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8659" class="blob-num js-line-number" data-line-number="8659"></td>
+ <td id="LC8659" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8660" class="blob-num js-line-number" data-line-number="8660"></td>
+ <td id="LC8660" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8661" class="blob-num js-line-number" data-line-number="8661"></td>
+ <td id="LC8661" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8662" class="blob-num js-line-number" data-line-number="8662"></td>
+ <td id="LC8662" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8663" class="blob-num js-line-number" data-line-number="8663"></td>
+ <td id="LC8663" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8664" class="blob-num js-line-number" data-line-number="8664"></td>
+ <td id="LC8664" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8665" class="blob-num js-line-number" data-line-number="8665"></td>
+ <td id="LC8665" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8666" class="blob-num js-line-number" data-line-number="8666"></td>
+ <td id="LC8666" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to modify.</span></td>
+ </tr>
+ <tr>
+ <td id="L8667" class="blob-num js-line-number" data-line-number="8667"></td>
+ <td id="LC8667" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8668" class="blob-num js-line-number" data-line-number="8668"></td>
+ <td id="LC8668" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L8669" class="blob-num js-line-number" data-line-number="8669"></td>
+ <td id="LC8669" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8670" class="blob-num js-line-number" data-line-number="8670"></td>
+ <td id="LC8670" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8671" class="blob-num js-line-number" data-line-number="8671"></td>
+ <td id="LC8671" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of removed elements.</span></td>
+ </tr>
+ <tr>
+ <td id="L8672" class="blob-num js-line-number" data-line-number="8672"></td>
+ <td id="LC8672" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8673" class="blob-num js-line-number" data-line-number="8673"></td>
+ <td id="LC8673" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8674" class="blob-num js-line-number" data-line-number="8674"></td>
+ <td id="LC8674" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var array = [1, 2, 3, 4, 5, 6];</span></td>
+ </tr>
+ <tr>
+ <td id="L8675" class="blob-num js-line-number" data-line-number="8675"></td>
+ <td id="LC8675" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var evens = _.remove(array, function(num) { return num % 2 == 0; });</span></td>
+ </tr>
+ <tr>
+ <td id="L8676" class="blob-num js-line-number" data-line-number="8676"></td>
+ <td id="LC8676" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8677" class="blob-num js-line-number" data-line-number="8677"></td>
+ <td id="LC8677" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(array);</span></td>
+ </tr>
+ <tr>
+ <td id="L8678" class="blob-num js-line-number" data-line-number="8678"></td>
+ <td id="LC8678" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 3, 5]</span></td>
+ </tr>
+ <tr>
+ <td id="L8679" class="blob-num js-line-number" data-line-number="8679"></td>
+ <td id="LC8679" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8680" class="blob-num js-line-number" data-line-number="8680"></td>
+ <td id="LC8680" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(evens);</span></td>
+ </tr>
+ <tr>
+ <td id="L8681" class="blob-num js-line-number" data-line-number="8681"></td>
+ <td id="LC8681" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 4, 6]</span></td>
+ </tr>
+ <tr>
+ <td id="L8682" class="blob-num js-line-number" data-line-number="8682"></td>
+ <td id="LC8682" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8683" class="blob-num js-line-number" data-line-number="8683"></td>
+ <td id="LC8683" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">remove</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8684" class="blob-num js-line-number" data-line-number="8684"></td>
+ <td id="LC8684" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8685" class="blob-num js-line-number" data-line-number="8685"></td>
+ <td id="LC8685" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8686" class="blob-num js-line-number" data-line-number="8686"></td>
+ <td id="LC8686" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L8687" class="blob-num js-line-number" data-line-number="8687"></td>
+ <td id="LC8687" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8688" class="blob-num js-line-number" data-line-number="8688"></td>
+ <td id="LC8688" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8689" class="blob-num js-line-number" data-line-number="8689"></td>
+ <td id="LC8689" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8690" class="blob-num js-line-number" data-line-number="8690"></td>
+ <td id="LC8690" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> array[index];</td>
+ </tr>
+ <tr>
+ <td id="L8691" class="blob-num js-line-number" data-line-number="8691"></td>
+ <td id="LC8691" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">callback</span>(value, index, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8692" class="blob-num js-line-number" data-line-number="8692"></td>
+ <td id="LC8692" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">push</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L8693" class="blob-num js-line-number" data-line-number="8693"></td>
+ <td id="LC8693" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">splice</span>.<span class="pl-c1">call</span>(array, index<span class="pl-k">--</span>, <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8694" class="blob-num js-line-number" data-line-number="8694"></td>
+ <td id="LC8694" class="blob-code blob-code-inner js-file-line"> length<span class="pl-k">--</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8695" class="blob-num js-line-number" data-line-number="8695"></td>
+ <td id="LC8695" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8696" class="blob-num js-line-number" data-line-number="8696"></td>
+ <td id="LC8696" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8697" class="blob-num js-line-number" data-line-number="8697"></td>
+ <td id="LC8697" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L8698" class="blob-num js-line-number" data-line-number="8698"></td>
+ <td id="LC8698" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8699" class="blob-num js-line-number" data-line-number="8699"></td>
+ <td id="LC8699" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8700" class="blob-num js-line-number" data-line-number="8700"></td>
+ <td id="LC8700" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8701" class="blob-num js-line-number" data-line-number="8701"></td>
+ <td id="LC8701" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The opposite of `_.initial` this method gets all but the first element or</span></td>
+ </tr>
+ <tr>
+ <td id="L8702" class="blob-num js-line-number" data-line-number="8702"></td>
+ <td id="LC8702" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * first `n` elements of an array. If a callback function is provided elements</span></td>
+ </tr>
+ <tr>
+ <td id="L8703" class="blob-num js-line-number" data-line-number="8703"></td>
+ <td id="LC8703" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * at the beginning of the array are excluded from the result as long as the</span></td>
+ </tr>
+ <tr>
+ <td id="L8704" class="blob-num js-line-number" data-line-number="8704"></td>
+ <td id="LC8704" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback returns truey. The callback is bound to `thisArg` and invoked</span></td>
+ </tr>
+ <tr>
+ <td id="L8705" class="blob-num js-line-number" data-line-number="8705"></td>
+ <td id="LC8705" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * with three arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8706" class="blob-num js-line-number" data-line-number="8706"></td>
+ <td id="LC8706" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8707" class="blob-num js-line-number" data-line-number="8707"></td>
+ <td id="LC8707" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8708" class="blob-num js-line-number" data-line-number="8708"></td>
+ <td id="LC8708" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8709" class="blob-num js-line-number" data-line-number="8709"></td>
+ <td id="LC8709" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8710" class="blob-num js-line-number" data-line-number="8710"></td>
+ <td id="LC8710" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8711" class="blob-num js-line-number" data-line-number="8711"></td>
+ <td id="LC8711" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8712" class="blob-num js-line-number" data-line-number="8712"></td>
+ <td id="LC8712" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8713" class="blob-num js-line-number" data-line-number="8713"></td>
+ <td id="LC8713" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8714" class="blob-num js-line-number" data-line-number="8714"></td>
+ <td id="LC8714" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8715" class="blob-num js-line-number" data-line-number="8715"></td>
+ <td id="LC8715" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8716" class="blob-num js-line-number" data-line-number="8716"></td>
+ <td id="LC8716" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> drop, tail</span></td>
+ </tr>
+ <tr>
+ <td id="L8717" class="blob-num js-line-number" data-line-number="8717"></td>
+ <td id="LC8717" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8718" class="blob-num js-line-number" data-line-number="8718"></td>
+ <td id="LC8718" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to query.</span></td>
+ </tr>
+ <tr>
+ <td id="L8719" class="blob-num js-line-number" data-line-number="8719"></td>
+ <td id="LC8719" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|number|string} [callback=1] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8720" class="blob-num js-line-number" data-line-number="8720"></td>
+ <td id="LC8720" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per element or the number of elements to exclude. If a property name or</span></td>
+ </tr>
+ <tr>
+ <td id="L8721" class="blob-num js-line-number" data-line-number="8721"></td>
+ <td id="LC8721" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object is provided it will be used to create a "_.pluck" or "_.where"</span></td>
+ </tr>
+ <tr>
+ <td id="L8722" class="blob-num js-line-number" data-line-number="8722"></td>
+ <td id="LC8722" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8723" class="blob-num js-line-number" data-line-number="8723"></td>
+ <td id="LC8723" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8724" class="blob-num js-line-number" data-line-number="8724"></td>
+ <td id="LC8724" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a slice of `array`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8725" class="blob-num js-line-number" data-line-number="8725"></td>
+ <td id="LC8725" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8726" class="blob-num js-line-number" data-line-number="8726"></td>
+ <td id="LC8726" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8727" class="blob-num js-line-number" data-line-number="8727"></td>
+ <td id="LC8727" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.rest([1, 2, 3]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8728" class="blob-num js-line-number" data-line-number="8728"></td>
+ <td id="LC8728" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8729" class="blob-num js-line-number" data-line-number="8729"></td>
+ <td id="LC8729" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8730" class="blob-num js-line-number" data-line-number="8730"></td>
+ <td id="LC8730" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.rest([1, 2, 3], 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L8731" class="blob-num js-line-number" data-line-number="8731"></td>
+ <td id="LC8731" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8732" class="blob-num js-line-number" data-line-number="8732"></td>
+ <td id="LC8732" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8733" class="blob-num js-line-number" data-line-number="8733"></td>
+ <td id="LC8733" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.rest([1, 2, 3], function(num) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8734" class="blob-num js-line-number" data-line-number="8734"></td>
+ <td id="LC8734" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return num < 3;</span></td>
+ </tr>
+ <tr>
+ <td id="L8735" class="blob-num js-line-number" data-line-number="8735"></td>
+ <td id="LC8735" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8736" class="blob-num js-line-number" data-line-number="8736"></td>
+ <td id="LC8736" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8737" class="blob-num js-line-number" data-line-number="8737"></td>
+ <td id="LC8737" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8738" class="blob-num js-line-number" data-line-number="8738"></td>
+ <td id="LC8738" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L8739" class="blob-num js-line-number" data-line-number="8739"></td>
+ <td id="LC8739" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'blocked': true, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8740" class="blob-num js-line-number" data-line-number="8740"></td>
+ <td id="LC8740" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'blocked': false, 'employer': 'slate' },</span></td>
+ </tr>
+ <tr>
+ <td id="L8741" class="blob-num js-line-number" data-line-number="8741"></td>
+ <td id="LC8741" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }</span></td>
+ </tr>
+ <tr>
+ <td id="L8742" class="blob-num js-line-number" data-line-number="8742"></td>
+ <td id="LC8742" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L8743" class="blob-num js-line-number" data-line-number="8743"></td>
+ <td id="LC8743" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8744" class="blob-num js-line-number" data-line-number="8744"></td>
+ <td id="LC8744" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8745" class="blob-num js-line-number" data-line-number="8745"></td>
+ <td id="LC8745" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.pluck(_.rest(characters, 'blocked'), 'name');</span></td>
+ </tr>
+ <tr>
+ <td id="L8746" class="blob-num js-line-number" data-line-number="8746"></td>
+ <td id="LC8746" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['fred', 'pebbles']</span></td>
+ </tr>
+ <tr>
+ <td id="L8747" class="blob-num js-line-number" data-line-number="8747"></td>
+ <td id="LC8747" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8748" class="blob-num js-line-number" data-line-number="8748"></td>
+ <td id="LC8748" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.where" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8749" class="blob-num js-line-number" data-line-number="8749"></td>
+ <td id="LC8749" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.rest(characters, { 'employer': 'slate' });</span></td>
+ </tr>
+ <tr>
+ <td id="L8750" class="blob-num js-line-number" data-line-number="8750"></td>
+ <td id="LC8750" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8751" class="blob-num js-line-number" data-line-number="8751"></td>
+ <td id="LC8751" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8752" class="blob-num js-line-number" data-line-number="8752"></td>
+ <td id="LC8752" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">rest</span>(<span class="pl-smi">array</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8753" class="blob-num js-line-number" data-line-number="8753"></td>
+ <td id="LC8753" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> callback <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> callback <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8754" class="blob-num js-line-number" data-line-number="8754"></td>
+ <td id="LC8754" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> n <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8755" class="blob-num js-line-number" data-line-number="8755"></td>
+ <td id="LC8755" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8756" class="blob-num js-line-number" data-line-number="8756"></td>
+ <td id="LC8756" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8757" class="blob-num js-line-number" data-line-number="8757"></td>
+ <td id="LC8757" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8758" class="blob-num js-line-number" data-line-number="8758"></td>
+ <td id="LC8758" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8759" class="blob-num js-line-number" data-line-number="8759"></td>
+ <td id="LC8759" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length <span class="pl-k">&&</span> <span class="pl-en">callback</span>(array[index], index, array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8760" class="blob-num js-line-number" data-line-number="8760"></td>
+ <td id="LC8760" class="blob-code blob-code-inner js-file-line"> n<span class="pl-k">++</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8761" class="blob-num js-line-number" data-line-number="8761"></td>
+ <td id="LC8761" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8762" class="blob-num js-line-number" data-line-number="8762"></td>
+ <td id="LC8762" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L8763" class="blob-num js-line-number" data-line-number="8763"></td>
+ <td id="LC8763" class="blob-code blob-code-inner js-file-line"> n <span class="pl-k">=</span> (callback <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> thisArg) <span class="pl-k">?</span> <span class="pl-c1">1</span> <span class="pl-k">:</span> <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, callback);</td>
+ </tr>
+ <tr>
+ <td id="L8764" class="blob-num js-line-number" data-line-number="8764"></td>
+ <td id="LC8764" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8765" class="blob-num js-line-number" data-line-number="8765"></td>
+ <td id="LC8765" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">slice</span>(array, n);</td>
+ </tr>
+ <tr>
+ <td id="L8766" class="blob-num js-line-number" data-line-number="8766"></td>
+ <td id="LC8766" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8767" class="blob-num js-line-number" data-line-number="8767"></td>
+ <td id="LC8767" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8768" class="blob-num js-line-number" data-line-number="8768"></td>
+ <td id="LC8768" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8769" class="blob-num js-line-number" data-line-number="8769"></td>
+ <td id="LC8769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Uses a binary search to determine the smallest index at which a value</span></td>
+ </tr>
+ <tr>
+ <td id="L8770" class="blob-num js-line-number" data-line-number="8770"></td>
+ <td id="LC8770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * should be inserted into a given sorted array in order to maintain the sort</span></td>
+ </tr>
+ <tr>
+ <td id="L8771" class="blob-num js-line-number" data-line-number="8771"></td>
+ <td id="LC8771" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * order of the array. If a callback is provided it will be executed for</span></td>
+ </tr>
+ <tr>
+ <td id="L8772" class="blob-num js-line-number" data-line-number="8772"></td>
+ <td id="LC8772" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `value` and each element of `array` to compute their sort ranking. The</span></td>
+ </tr>
+ <tr>
+ <td id="L8773" class="blob-num js-line-number" data-line-number="8773"></td>
+ <td id="LC8773" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback is bound to `thisArg` and invoked with one argument; (value).</span></td>
+ </tr>
+ <tr>
+ <td id="L8774" class="blob-num js-line-number" data-line-number="8774"></td>
+ <td id="LC8774" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8775" class="blob-num js-line-number" data-line-number="8775"></td>
+ <td id="LC8775" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8776" class="blob-num js-line-number" data-line-number="8776"></td>
+ <td id="LC8776" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8777" class="blob-num js-line-number" data-line-number="8777"></td>
+ <td id="LC8777" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8778" class="blob-num js-line-number" data-line-number="8778"></td>
+ <td id="LC8778" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8779" class="blob-num js-line-number" data-line-number="8779"></td>
+ <td id="LC8779" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8780" class="blob-num js-line-number" data-line-number="8780"></td>
+ <td id="LC8780" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8781" class="blob-num js-line-number" data-line-number="8781"></td>
+ <td id="LC8781" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8782" class="blob-num js-line-number" data-line-number="8782"></td>
+ <td id="LC8782" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8783" class="blob-num js-line-number" data-line-number="8783"></td>
+ <td id="LC8783" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8784" class="blob-num js-line-number" data-line-number="8784"></td>
+ <td id="LC8784" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8785" class="blob-num js-line-number" data-line-number="8785"></td>
+ <td id="LC8785" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L8786" class="blob-num js-line-number" data-line-number="8786"></td>
+ <td id="LC8786" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to evaluate.</span></td>
+ </tr>
+ <tr>
+ <td id="L8787" class="blob-num js-line-number" data-line-number="8787"></td>
+ <td id="LC8787" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8788" class="blob-num js-line-number" data-line-number="8788"></td>
+ <td id="LC8788" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L8789" class="blob-num js-line-number" data-line-number="8789"></td>
+ <td id="LC8789" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8790" class="blob-num js-line-number" data-line-number="8790"></td>
+ <td id="LC8790" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8791" class="blob-num js-line-number" data-line-number="8791"></td>
+ <td id="LC8791" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the index at which `value` should be inserted</span></td>
+ </tr>
+ <tr>
+ <td id="L8792" class="blob-num js-line-number" data-line-number="8792"></td>
+ <td id="LC8792" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * into `array`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8793" class="blob-num js-line-number" data-line-number="8793"></td>
+ <td id="LC8793" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8794" class="blob-num js-line-number" data-line-number="8794"></td>
+ <td id="LC8794" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8795" class="blob-num js-line-number" data-line-number="8795"></td>
+ <td id="LC8795" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortedIndex([20, 30, 50], 40);</span></td>
+ </tr>
+ <tr>
+ <td id="L8796" class="blob-num js-line-number" data-line-number="8796"></td>
+ <td id="LC8796" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8797" class="blob-num js-line-number" data-line-number="8797"></td>
+ <td id="LC8797" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8798" class="blob-num js-line-number" data-line-number="8798"></td>
+ <td id="LC8798" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8799" class="blob-num js-line-number" data-line-number="8799"></td>
+ <td id="LC8799" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');</span></td>
+ </tr>
+ <tr>
+ <td id="L8800" class="blob-num js-line-number" data-line-number="8800"></td>
+ <td id="LC8800" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8801" class="blob-num js-line-number" data-line-number="8801"></td>
+ <td id="LC8801" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8802" class="blob-num js-line-number" data-line-number="8802"></td>
+ <td id="LC8802" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var dict = {</span></td>
+ </tr>
+ <tr>
+ <td id="L8803" class="blob-num js-line-number" data-line-number="8803"></td>
+ <td id="LC8803" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }</span></td>
+ </tr>
+ <tr>
+ <td id="L8804" class="blob-num js-line-number" data-line-number="8804"></td>
+ <td id="LC8804" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L8805" class="blob-num js-line-number" data-line-number="8805"></td>
+ <td id="LC8805" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8806" class="blob-num js-line-number" data-line-number="8806"></td>
+ <td id="LC8806" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8807" class="blob-num js-line-number" data-line-number="8807"></td>
+ <td id="LC8807" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return dict.wordToNumber[word];</span></td>
+ </tr>
+ <tr>
+ <td id="L8808" class="blob-num js-line-number" data-line-number="8808"></td>
+ <td id="LC8808" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L8809" class="blob-num js-line-number" data-line-number="8809"></td>
+ <td id="LC8809" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8810" class="blob-num js-line-number" data-line-number="8810"></td>
+ <td id="LC8810" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8811" class="blob-num js-line-number" data-line-number="8811"></td>
+ <td id="LC8811" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {</span></td>
+ </tr>
+ <tr>
+ <td id="L8812" class="blob-num js-line-number" data-line-number="8812"></td>
+ <td id="LC8812" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return this.wordToNumber[word];</span></td>
+ </tr>
+ <tr>
+ <td id="L8813" class="blob-num js-line-number" data-line-number="8813"></td>
+ <td id="LC8813" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }, dict);</span></td>
+ </tr>
+ <tr>
+ <td id="L8814" class="blob-num js-line-number" data-line-number="8814"></td>
+ <td id="LC8814" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 2</span></td>
+ </tr>
+ <tr>
+ <td id="L8815" class="blob-num js-line-number" data-line-number="8815"></td>
+ <td id="LC8815" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8816" class="blob-num js-line-number" data-line-number="8816"></td>
+ <td id="LC8816" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">sortedIndex</span>(<span class="pl-smi">array</span>, <span class="pl-smi">value</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8817" class="blob-num js-line-number" data-line-number="8817"></td>
+ <td id="LC8817" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> low <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8818" class="blob-num js-line-number" data-line-number="8818"></td>
+ <td id="LC8818" class="blob-code blob-code-inner js-file-line"> high <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-smi">array</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> low;</td>
+ </tr>
+ <tr>
+ <td id="L8819" class="blob-num js-line-number" data-line-number="8819"></td>
+ <td id="LC8819" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8820" class="blob-num js-line-number" data-line-number="8820"></td>
+ <td id="LC8820" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// explicitly reference `identity` for better inlining in Firefox</span></td>
+ </tr>
+ <tr>
+ <td id="L8821" class="blob-num js-line-number" data-line-number="8821"></td>
+ <td id="LC8821" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> callback <span class="pl-k">?</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">1</span>) <span class="pl-k">:</span> identity;</td>
+ </tr>
+ <tr>
+ <td id="L8822" class="blob-num js-line-number" data-line-number="8822"></td>
+ <td id="LC8822" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> <span class="pl-en">callback</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L8823" class="blob-num js-line-number" data-line-number="8823"></td>
+ <td id="LC8823" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8824" class="blob-num js-line-number" data-line-number="8824"></td>
+ <td id="LC8824" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (low <span class="pl-k"><</span> high) {</td>
+ </tr>
+ <tr>
+ <td id="L8825" class="blob-num js-line-number" data-line-number="8825"></td>
+ <td id="LC8825" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> mid <span class="pl-k">=</span> (low <span class="pl-k">+</span> high) <span class="pl-k">>>></span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8826" class="blob-num js-line-number" data-line-number="8826"></td>
+ <td id="LC8826" class="blob-code blob-code-inner js-file-line"> (<span class="pl-en">callback</span>(array[mid]) <span class="pl-k"><</span> value)</td>
+ </tr>
+ <tr>
+ <td id="L8827" class="blob-num js-line-number" data-line-number="8827"></td>
+ <td id="LC8827" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> low <span class="pl-k">=</span> mid <span class="pl-k">+</span> <span class="pl-c1">1</span></td>
+ </tr>
+ <tr>
+ <td id="L8828" class="blob-num js-line-number" data-line-number="8828"></td>
+ <td id="LC8828" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> high <span class="pl-k">=</span> mid;</td>
+ </tr>
+ <tr>
+ <td id="L8829" class="blob-num js-line-number" data-line-number="8829"></td>
+ <td id="LC8829" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8830" class="blob-num js-line-number" data-line-number="8830"></td>
+ <td id="LC8830" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> low;</td>
+ </tr>
+ <tr>
+ <td id="L8831" class="blob-num js-line-number" data-line-number="8831"></td>
+ <td id="LC8831" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8832" class="blob-num js-line-number" data-line-number="8832"></td>
+ <td id="LC8832" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8833" class="blob-num js-line-number" data-line-number="8833"></td>
+ <td id="LC8833" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8834" class="blob-num js-line-number" data-line-number="8834"></td>
+ <td id="LC8834" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of unique values, in order, of the provided arrays using</span></td>
+ </tr>
+ <tr>
+ <td id="L8835" class="blob-num js-line-number" data-line-number="8835"></td>
+ <td id="LC8835" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * strict equality for comparisons, i.e. `===`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8836" class="blob-num js-line-number" data-line-number="8836"></td>
+ <td id="LC8836" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8837" class="blob-num js-line-number" data-line-number="8837"></td>
+ <td id="LC8837" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8838" class="blob-num js-line-number" data-line-number="8838"></td>
+ <td id="LC8838" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8839" class="blob-num js-line-number" data-line-number="8839"></td>
+ <td id="LC8839" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8840" class="blob-num js-line-number" data-line-number="8840"></td>
+ <td id="LC8840" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Array} [array] The arrays to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L8841" class="blob-num js-line-number" data-line-number="8841"></td>
+ <td id="LC8841" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of combined values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8842" class="blob-num js-line-number" data-line-number="8842"></td>
+ <td id="LC8842" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8843" class="blob-num js-line-number" data-line-number="8843"></td>
+ <td id="LC8843" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8844" class="blob-num js-line-number" data-line-number="8844"></td>
+ <td id="LC8844" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8845" class="blob-num js-line-number" data-line-number="8845"></td>
+ <td id="LC8845" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3, 5, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L8846" class="blob-num js-line-number" data-line-number="8846"></td>
+ <td id="LC8846" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8847" class="blob-num js-line-number" data-line-number="8847"></td>
+ <td id="LC8847" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">union</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L8848" class="blob-num js-line-number" data-line-number="8848"></td>
+ <td id="LC8848" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseUniq</span>(<span class="pl-en">baseFlatten</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">true</span>, <span class="pl-c1">true</span>));</td>
+ </tr>
+ <tr>
+ <td id="L8849" class="blob-num js-line-number" data-line-number="8849"></td>
+ <td id="LC8849" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8850" class="blob-num js-line-number" data-line-number="8850"></td>
+ <td id="LC8850" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8851" class="blob-num js-line-number" data-line-number="8851"></td>
+ <td id="LC8851" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8852" class="blob-num js-line-number" data-line-number="8852"></td>
+ <td id="LC8852" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a duplicate-value-free version of an array using strict equality</span></td>
+ </tr>
+ <tr>
+ <td id="L8853" class="blob-num js-line-number" data-line-number="8853"></td>
+ <td id="LC8853" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * for comparisons, i.e. `===`. If the array is sorted, providing</span></td>
+ </tr>
+ <tr>
+ <td id="L8854" class="blob-num js-line-number" data-line-number="8854"></td>
+ <td id="LC8854" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `true` for `isSorted` will use a faster algorithm. If a callback is provided</span></td>
+ </tr>
+ <tr>
+ <td id="L8855" class="blob-num js-line-number" data-line-number="8855"></td>
+ <td id="LC8855" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * each element of `array` is passed through the callback before uniqueness</span></td>
+ </tr>
+ <tr>
+ <td id="L8856" class="blob-num js-line-number" data-line-number="8856"></td>
+ <td id="LC8856" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is computed. The callback is bound to `thisArg` and invoked with three</span></td>
+ </tr>
+ <tr>
+ <td id="L8857" class="blob-num js-line-number" data-line-number="8857"></td>
+ <td id="LC8857" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments; (value, index, array).</span></td>
+ </tr>
+ <tr>
+ <td id="L8858" class="blob-num js-line-number" data-line-number="8858"></td>
+ <td id="LC8858" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8859" class="blob-num js-line-number" data-line-number="8859"></td>
+ <td id="LC8859" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If a property name is provided for `callback` the created "_.pluck" style</span></td>
+ </tr>
+ <tr>
+ <td id="L8860" class="blob-num js-line-number" data-line-number="8860"></td>
+ <td id="LC8860" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * callback will return the property value of the given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L8861" class="blob-num js-line-number" data-line-number="8861"></td>
+ <td id="LC8861" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8862" class="blob-num js-line-number" data-line-number="8862"></td>
+ <td id="LC8862" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If an object is provided for `callback` the created "_.where" style callback</span></td>
+ </tr>
+ <tr>
+ <td id="L8863" class="blob-num js-line-number" data-line-number="8863"></td>
+ <td id="LC8863" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will return `true` for elements that have the properties of the given object,</span></td>
+ </tr>
+ <tr>
+ <td id="L8864" class="blob-num js-line-number" data-line-number="8864"></td>
+ <td id="LC8864" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8865" class="blob-num js-line-number" data-line-number="8865"></td>
+ <td id="LC8865" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8866" class="blob-num js-line-number" data-line-number="8866"></td>
+ <td id="LC8866" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8867" class="blob-num js-line-number" data-line-number="8867"></td>
+ <td id="LC8867" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8868" class="blob-num js-line-number" data-line-number="8868"></td>
+ <td id="LC8868" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> unique</span></td>
+ </tr>
+ <tr>
+ <td id="L8869" class="blob-num js-line-number" data-line-number="8869"></td>
+ <td id="LC8869" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8870" class="blob-num js-line-number" data-line-number="8870"></td>
+ <td id="LC8870" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to process.</span></td>
+ </tr>
+ <tr>
+ <td id="L8871" class="blob-num js-line-number" data-line-number="8871"></td>
+ <td id="LC8871" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [isSorted=false] A flag to indicate that `array` is sorted.</span></td>
+ </tr>
+ <tr>
+ <td id="L8872" class="blob-num js-line-number" data-line-number="8872"></td>
+ <td id="LC8872" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object|string} [callback=identity] The function called</span></td>
+ </tr>
+ <tr>
+ <td id="L8873" class="blob-num js-line-number" data-line-number="8873"></td>
+ <td id="LC8873" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * per iteration. If a property name or object is provided it will be used</span></td>
+ </tr>
+ <tr>
+ <td id="L8874" class="blob-num js-line-number" data-line-number="8874"></td>
+ <td id="LC8874" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to create a "_.pluck" or "_.where" style callback, respectively.</span></td>
+ </tr>
+ <tr>
+ <td id="L8875" class="blob-num js-line-number" data-line-number="8875"></td>
+ <td id="LC8875" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8876" class="blob-num js-line-number" data-line-number="8876"></td>
+ <td id="LC8876" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a duplicate-value-free array.</span></td>
+ </tr>
+ <tr>
+ <td id="L8877" class="blob-num js-line-number" data-line-number="8877"></td>
+ <td id="LC8877" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8878" class="blob-num js-line-number" data-line-number="8878"></td>
+ <td id="LC8878" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8879" class="blob-num js-line-number" data-line-number="8879"></td>
+ <td id="LC8879" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniq([1, 2, 1, 3, 1]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8880" class="blob-num js-line-number" data-line-number="8880"></td>
+ <td id="LC8880" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8881" class="blob-num js-line-number" data-line-number="8881"></td>
+ <td id="LC8881" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8882" class="blob-num js-line-number" data-line-number="8882"></td>
+ <td id="LC8882" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniq([1, 1, 2, 2, 3], true);</span></td>
+ </tr>
+ <tr>
+ <td id="L8883" class="blob-num js-line-number" data-line-number="8883"></td>
+ <td id="LC8883" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8884" class="blob-num js-line-number" data-line-number="8884"></td>
+ <td id="LC8884" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8885" class="blob-num js-line-number" data-line-number="8885"></td>
+ <td id="LC8885" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); });</span></td>
+ </tr>
+ <tr>
+ <td id="L8886" class="blob-num js-line-number" data-line-number="8886"></td>
+ <td id="LC8886" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['A', 'b', 'C']</span></td>
+ </tr>
+ <tr>
+ <td id="L8887" class="blob-num js-line-number" data-line-number="8887"></td>
+ <td id="LC8887" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8888" class="blob-num js-line-number" data-line-number="8888"></td>
+ <td id="LC8888" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);</span></td>
+ </tr>
+ <tr>
+ <td id="L8889" class="blob-num js-line-number" data-line-number="8889"></td>
+ <td id="LC8889" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2.5, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L8890" class="blob-num js-line-number" data-line-number="8890"></td>
+ <td id="LC8890" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8891" class="blob-num js-line-number" data-line-number="8891"></td>
+ <td id="LC8891" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using "_.pluck" callback shorthand</span></td>
+ </tr>
+ <tr>
+ <td id="L8892" class="blob-num js-line-number" data-line-number="8892"></td>
+ <td id="LC8892" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');</span></td>
+ </tr>
+ <tr>
+ <td id="L8893" class="blob-num js-line-number" data-line-number="8893"></td>
+ <td id="LC8893" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'x': 1 }, { 'x': 2 }]</span></td>
+ </tr>
+ <tr>
+ <td id="L8894" class="blob-num js-line-number" data-line-number="8894"></td>
+ <td id="LC8894" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8895" class="blob-num js-line-number" data-line-number="8895"></td>
+ <td id="LC8895" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">uniq</span>(<span class="pl-smi">array</span>, <span class="pl-smi">isSorted</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8896" class="blob-num js-line-number" data-line-number="8896"></td>
+ <td id="LC8896" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// juggle arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L8897" class="blob-num js-line-number" data-line-number="8897"></td>
+ <td id="LC8897" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> isSorted <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> isSorted <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8898" class="blob-num js-line-number" data-line-number="8898"></td>
+ <td id="LC8898" class="blob-code blob-code-inner js-file-line"> thisArg <span class="pl-k">=</span> callback;</td>
+ </tr>
+ <tr>
+ <td id="L8899" class="blob-num js-line-number" data-line-number="8899"></td>
+ <td id="LC8899" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> (<span class="pl-k">typeof</span> isSorted <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> thisArg <span class="pl-k">&&</span> thisArg[isSorted] <span class="pl-k">===</span> array) <span class="pl-k">?</span> <span class="pl-c1">null</span> <span [...]
+ </tr>
+ <tr>
+ <td id="L8900" class="blob-num js-line-number" data-line-number="8900"></td>
+ <td id="LC8900" class="blob-code blob-code-inner js-file-line"> isSorted <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8901" class="blob-num js-line-number" data-line-number="8901"></td>
+ <td id="LC8901" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8902" class="blob-num js-line-number" data-line-number="8902"></td>
+ <td id="LC8902" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (callback <span class="pl-k">!=</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8903" class="blob-num js-line-number" data-line-number="8903"></td>
+ <td id="LC8903" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-en">createCallback</span>(callback, thisArg, <span class="pl-c1">3</span>);</td>
+ </tr>
+ <tr>
+ <td id="L8904" class="blob-num js-line-number" data-line-number="8904"></td>
+ <td id="LC8904" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8905" class="blob-num js-line-number" data-line-number="8905"></td>
+ <td id="LC8905" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseUniq</span>(array, isSorted, callback);</td>
+ </tr>
+ <tr>
+ <td id="L8906" class="blob-num js-line-number" data-line-number="8906"></td>
+ <td id="LC8906" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8907" class="blob-num js-line-number" data-line-number="8907"></td>
+ <td id="LC8907" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8908" class="blob-num js-line-number" data-line-number="8908"></td>
+ <td id="LC8908" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8909" class="blob-num js-line-number" data-line-number="8909"></td>
+ <td id="LC8909" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array excluding all provided values using strict equality for</span></td>
+ </tr>
+ <tr>
+ <td id="L8910" class="blob-num js-line-number" data-line-number="8910"></td>
+ <td id="LC8910" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * comparisons, i.e. `===`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8911" class="blob-num js-line-number" data-line-number="8911"></td>
+ <td id="LC8911" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8912" class="blob-num js-line-number" data-line-number="8912"></td>
+ <td id="LC8912" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8913" class="blob-num js-line-number" data-line-number="8913"></td>
+ <td id="LC8913" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8914" class="blob-num js-line-number" data-line-number="8914"></td>
+ <td id="LC8914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8915" class="blob-num js-line-number" data-line-number="8915"></td>
+ <td id="LC8915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">array</span> The array to filter.</span></td>
+ </tr>
+ <tr>
+ <td id="L8916" class="blob-num js-line-number" data-line-number="8916"></td>
+ <td id="LC8916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [value] The values to exclude.</span></td>
+ </tr>
+ <tr>
+ <td id="L8917" class="blob-num js-line-number" data-line-number="8917"></td>
+ <td id="LC8917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of filtered values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8918" class="blob-num js-line-number" data-line-number="8918"></td>
+ <td id="LC8918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8919" class="blob-num js-line-number" data-line-number="8919"></td>
+ <td id="LC8919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8920" class="blob-num js-line-number" data-line-number="8920"></td>
+ <td id="LC8920" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);</span></td>
+ </tr>
+ <tr>
+ <td id="L8921" class="blob-num js-line-number" data-line-number="8921"></td>
+ <td id="LC8921" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [2, 3, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L8922" class="blob-num js-line-number" data-line-number="8922"></td>
+ <td id="LC8922" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8923" class="blob-num js-line-number" data-line-number="8923"></td>
+ <td id="LC8923" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">without</span>(<span class="pl-smi">array</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L8924" class="blob-num js-line-number" data-line-number="8924"></td>
+ <td id="LC8924" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseDifference</span>(array, <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L8925" class="blob-num js-line-number" data-line-number="8925"></td>
+ <td id="LC8925" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8926" class="blob-num js-line-number" data-line-number="8926"></td>
+ <td id="LC8926" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8927" class="blob-num js-line-number" data-line-number="8927"></td>
+ <td id="LC8927" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8928" class="blob-num js-line-number" data-line-number="8928"></td>
+ <td id="LC8928" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array that is the symmetric difference of the provided arrays.</span></td>
+ </tr>
+ <tr>
+ <td id="L8929" class="blob-num js-line-number" data-line-number="8929"></td>
+ <td id="LC8929" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * See http://en.wikipedia.org/wiki/Symmetric_difference.</span></td>
+ </tr>
+ <tr>
+ <td id="L8930" class="blob-num js-line-number" data-line-number="8930"></td>
+ <td id="LC8930" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8931" class="blob-num js-line-number" data-line-number="8931"></td>
+ <td id="LC8931" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8932" class="blob-num js-line-number" data-line-number="8932"></td>
+ <td id="LC8932" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8933" class="blob-num js-line-number" data-line-number="8933"></td>
+ <td id="LC8933" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8934" class="blob-num js-line-number" data-line-number="8934"></td>
+ <td id="LC8934" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Array} [array] The arrays to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L8935" class="blob-num js-line-number" data-line-number="8935"></td>
+ <td id="LC8935" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8936" class="blob-num js-line-number" data-line-number="8936"></td>
+ <td id="LC8936" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8937" class="blob-num js-line-number" data-line-number="8937"></td>
+ <td id="LC8937" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8938" class="blob-num js-line-number" data-line-number="8938"></td>
+ <td id="LC8938" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.xor([1, 2, 3], [5, 2, 1, 4]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8939" class="blob-num js-line-number" data-line-number="8939"></td>
+ <td id="LC8939" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 5, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L8940" class="blob-num js-line-number" data-line-number="8940"></td>
+ <td id="LC8940" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8941" class="blob-num js-line-number" data-line-number="8941"></td>
+ <td id="LC8941" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8942" class="blob-num js-line-number" data-line-number="8942"></td>
+ <td id="LC8942" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 4, 5]</span></td>
+ </tr>
+ <tr>
+ <td id="L8943" class="blob-num js-line-number" data-line-number="8943"></td>
+ <td id="LC8943" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8944" class="blob-num js-line-number" data-line-number="8944"></td>
+ <td id="LC8944" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">xor</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L8945" class="blob-num js-line-number" data-line-number="8945"></td>
+ <td id="LC8945" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8946" class="blob-num js-line-number" data-line-number="8946"></td>
+ <td id="LC8946" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L8947" class="blob-num js-line-number" data-line-number="8947"></td>
+ <td id="LC8947" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8948" class="blob-num js-line-number" data-line-number="8948"></td>
+ <td id="LC8948" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8949" class="blob-num js-line-number" data-line-number="8949"></td>
+ <td id="LC8949" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> array <span class="pl-k">=</span> <span class="pl-v">arguments</span>[index];</td>
+ </tr>
+ <tr>
+ <td id="L8950" class="blob-num js-line-number" data-line-number="8950"></td>
+ <td id="LC8950" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-en">isArray</span>(array) <span class="pl-k">||</span> <span class="pl-en">isArguments</span>(array)) {</td>
+ </tr>
+ <tr>
+ <td id="L8951" class="blob-num js-line-number" data-line-number="8951"></td>
+ <td id="LC8951" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> result</td>
+ </tr>
+ <tr>
+ <td id="L8952" class="blob-num js-line-number" data-line-number="8952"></td>
+ <td id="LC8952" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-en">baseUniq</span>(<span class="pl-en">baseDifference</span>(result, array).<span class="pl-c1">concat</span>(<span class="pl-en">baseDifference</span>(array, result)))</td>
+ </tr>
+ <tr>
+ <td id="L8953" class="blob-num js-line-number" data-line-number="8953"></td>
+ <td id="LC8953" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> array;</td>
+ </tr>
+ <tr>
+ <td id="L8954" class="blob-num js-line-number" data-line-number="8954"></td>
+ <td id="LC8954" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8955" class="blob-num js-line-number" data-line-number="8955"></td>
+ <td id="LC8955" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8956" class="blob-num js-line-number" data-line-number="8956"></td>
+ <td id="LC8956" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result <span class="pl-k">||</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L8957" class="blob-num js-line-number" data-line-number="8957"></td>
+ <td id="LC8957" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8958" class="blob-num js-line-number" data-line-number="8958"></td>
+ <td id="LC8958" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8959" class="blob-num js-line-number" data-line-number="8959"></td>
+ <td id="LC8959" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8960" class="blob-num js-line-number" data-line-number="8960"></td>
+ <td id="LC8960" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an array of grouped elements, the first of which contains the first</span></td>
+ </tr>
+ <tr>
+ <td id="L8961" class="blob-num js-line-number" data-line-number="8961"></td>
+ <td id="LC8961" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * elements of the given arrays, the second of which contains the second</span></td>
+ </tr>
+ <tr>
+ <td id="L8962" class="blob-num js-line-number" data-line-number="8962"></td>
+ <td id="LC8962" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * elements of the given arrays, and so on.</span></td>
+ </tr>
+ <tr>
+ <td id="L8963" class="blob-num js-line-number" data-line-number="8963"></td>
+ <td id="LC8963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8964" class="blob-num js-line-number" data-line-number="8964"></td>
+ <td id="LC8964" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8965" class="blob-num js-line-number" data-line-number="8965"></td>
+ <td id="LC8965" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8966" class="blob-num js-line-number" data-line-number="8966"></td>
+ <td id="LC8966" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> unzip</span></td>
+ </tr>
+ <tr>
+ <td id="L8967" class="blob-num js-line-number" data-line-number="8967"></td>
+ <td id="LC8967" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8968" class="blob-num js-line-number" data-line-number="8968"></td>
+ <td id="LC8968" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Array} [array] Arrays to process.</span></td>
+ </tr>
+ <tr>
+ <td id="L8969" class="blob-num js-line-number" data-line-number="8969"></td>
+ <td id="LC8969" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> a new array of grouped elements.</span></td>
+ </tr>
+ <tr>
+ <td id="L8970" class="blob-num js-line-number" data-line-number="8970"></td>
+ <td id="LC8970" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8971" class="blob-num js-line-number" data-line-number="8971"></td>
+ <td id="LC8971" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8972" class="blob-num js-line-number" data-line-number="8972"></td>
+ <td id="LC8972" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.zip(['fred', 'barney'], [30, 40], [true, false]);</span></td>
+ </tr>
+ <tr>
+ <td id="L8973" class="blob-num js-line-number" data-line-number="8973"></td>
+ <td id="LC8973" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [['fred', 30, true], ['barney', 40, false]]</span></td>
+ </tr>
+ <tr>
+ <td id="L8974" class="blob-num js-line-number" data-line-number="8974"></td>
+ <td id="LC8974" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L8975" class="blob-num js-line-number" data-line-number="8975"></td>
+ <td id="LC8975" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">zip</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L8976" class="blob-num js-line-number" data-line-number="8976"></td>
+ <td id="LC8976" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> array <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span> <span class="pl-k">?</span> <span class="pl-v">arguments</span> <span class="pl-k">:</span> <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L8977" class="blob-num js-line-number" data-line-number="8977"></td>
+ <td id="LC8977" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8978" class="blob-num js-line-number" data-line-number="8978"></td>
+ <td id="LC8978" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> array <span class="pl-k">?</span> <span class="pl-en">max</span>(<span class="pl-en">pluck</span>(array, <span class="pl-s"><span class="pl-pds">'</span>length<span class="pl-pds">'</span></span>)) <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L8979" class="blob-num js-line-number" data-line-number="8979"></td>
+ <td id="LC8979" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(length <span class="pl-k"><</span> <span class="pl-c1">0</span> <span class="pl-k">?</span> <span class="pl-c1">0</span> <span class="pl-k">:</span> length);</td>
+ </tr>
+ <tr>
+ <td id="L8980" class="blob-num js-line-number" data-line-number="8980"></td>
+ <td id="LC8980" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8981" class="blob-num js-line-number" data-line-number="8981"></td>
+ <td id="LC8981" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L8982" class="blob-num js-line-number" data-line-number="8982"></td>
+ <td id="LC8982" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> <span class="pl-en">pluck</span>(array, index);</td>
+ </tr>
+ <tr>
+ <td id="L8983" class="blob-num js-line-number" data-line-number="8983"></td>
+ <td id="LC8983" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8984" class="blob-num js-line-number" data-line-number="8984"></td>
+ <td id="LC8984" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L8985" class="blob-num js-line-number" data-line-number="8985"></td>
+ <td id="LC8985" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L8986" class="blob-num js-line-number" data-line-number="8986"></td>
+ <td id="LC8986" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L8987" class="blob-num js-line-number" data-line-number="8987"></td>
+ <td id="LC8987" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L8988" class="blob-num js-line-number" data-line-number="8988"></td>
+ <td id="LC8988" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates an object composed from arrays of `keys` and `values`. Provide</span></td>
+ </tr>
+ <tr>
+ <td id="L8989" class="blob-num js-line-number" data-line-number="8989"></td>
+ <td id="LC8989" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`</span></td>
+ </tr>
+ <tr>
+ <td id="L8990" class="blob-num js-line-number" data-line-number="8990"></td>
+ <td id="LC8990" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * or two arrays, one of `keys` and one of corresponding `values`.</span></td>
+ </tr>
+ <tr>
+ <td id="L8991" class="blob-num js-line-number" data-line-number="8991"></td>
+ <td id="LC8991" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L8992" class="blob-num js-line-number" data-line-number="8992"></td>
+ <td id="LC8992" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L8993" class="blob-num js-line-number" data-line-number="8993"></td>
+ <td id="LC8993" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L8994" class="blob-num js-line-number" data-line-number="8994"></td>
+ <td id="LC8994" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> object</span></td>
+ </tr>
+ <tr>
+ <td id="L8995" class="blob-num js-line-number" data-line-number="8995"></td>
+ <td id="LC8995" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L8996" class="blob-num js-line-number" data-line-number="8996"></td>
+ <td id="LC8996" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Array}</span> <span class="pl-smi">keys</span> The array of keys.</span></td>
+ </tr>
+ <tr>
+ <td id="L8997" class="blob-num js-line-number" data-line-number="8997"></td>
+ <td id="LC8997" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Array} [values=[]] The array of values.</span></td>
+ </tr>
+ <tr>
+ <td id="L8998" class="blob-num js-line-number" data-line-number="8998"></td>
+ <td id="LC8998" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> an object composed of the given keys and</span></td>
+ </tr>
+ <tr>
+ <td id="L8999" class="blob-num js-line-number" data-line-number="8999"></td>
+ <td id="LC8999" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * corresponding values.</span></td>
+ </tr>
+ <tr>
+ <td id="L9000" class="blob-num js-line-number" data-line-number="9000"></td>
+ <td id="LC9000" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9001" class="blob-num js-line-number" data-line-number="9001"></td>
+ <td id="LC9001" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9002" class="blob-num js-line-number" data-line-number="9002"></td>
+ <td id="LC9002" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.zipObject(['fred', 'barney'], [30, 40]);</span></td>
+ </tr>
+ <tr>
+ <td id="L9003" class="blob-num js-line-number" data-line-number="9003"></td>
+ <td id="LC9003" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'fred': 30, 'barney': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L9004" class="blob-num js-line-number" data-line-number="9004"></td>
+ <td id="LC9004" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9005" class="blob-num js-line-number" data-line-number="9005"></td>
+ <td id="LC9005" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">zipObject</span>(<span class="pl-smi">keys</span>, <span class="pl-smi">values</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9006" class="blob-num js-line-number" data-line-number="9006"></td>
+ <td id="LC9006" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9007" class="blob-num js-line-number" data-line-number="9007"></td>
+ <td id="LC9007" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> keys <span class="pl-k">?</span> <span class="pl-smi">keys</span>.<span class="pl-c1">length</span> <span class="pl-k">:</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9008" class="blob-num js-line-number" data-line-number="9008"></td>
+ <td id="LC9008" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L9009" class="blob-num js-line-number" data-line-number="9009"></td>
+ <td id="LC9009" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9010" class="blob-num js-line-number" data-line-number="9010"></td>
+ <td id="LC9010" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>values <span class="pl-k">&&</span> length <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-en">isArray</span>(keys[<span class="pl-c1">0</span>])) {</td>
+ </tr>
+ <tr>
+ <td id="L9011" class="blob-num js-line-number" data-line-number="9011"></td>
+ <td id="LC9011" class="blob-code blob-code-inner js-file-line"> values <span class="pl-k">=</span> [];</td>
+ </tr>
+ <tr>
+ <td id="L9012" class="blob-num js-line-number" data-line-number="9012"></td>
+ <td id="LC9012" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9013" class="blob-num js-line-number" data-line-number="9013"></td>
+ <td id="LC9013" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L9014" class="blob-num js-line-number" data-line-number="9014"></td>
+ <td id="LC9014" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> keys[index];</td>
+ </tr>
+ <tr>
+ <td id="L9015" class="blob-num js-line-number" data-line-number="9015"></td>
+ <td id="LC9015" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (values) {</td>
+ </tr>
+ <tr>
+ <td id="L9016" class="blob-num js-line-number" data-line-number="9016"></td>
+ <td id="LC9016" class="blob-code blob-code-inner js-file-line"> result[key] <span class="pl-k">=</span> values[index];</td>
+ </tr>
+ <tr>
+ <td id="L9017" class="blob-num js-line-number" data-line-number="9017"></td>
+ <td id="LC9017" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (key) {</td>
+ </tr>
+ <tr>
+ <td id="L9018" class="blob-num js-line-number" data-line-number="9018"></td>
+ <td id="LC9018" class="blob-code blob-code-inner js-file-line"> result[key[<span class="pl-c1">0</span>]] <span class="pl-k">=</span> key[<span class="pl-c1">1</span>];</td>
+ </tr>
+ <tr>
+ <td id="L9019" class="blob-num js-line-number" data-line-number="9019"></td>
+ <td id="LC9019" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9020" class="blob-num js-line-number" data-line-number="9020"></td>
+ <td id="LC9020" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9021" class="blob-num js-line-number" data-line-number="9021"></td>
+ <td id="LC9021" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L9022" class="blob-num js-line-number" data-line-number="9022"></td>
+ <td id="LC9022" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9023" class="blob-num js-line-number" data-line-number="9023"></td>
+ <td id="LC9023" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9024" class="blob-num js-line-number" data-line-number="9024"></td>
+ <td id="LC9024" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L9025" class="blob-num js-line-number" data-line-number="9025"></td>
+ <td id="LC9025" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9026" class="blob-num js-line-number" data-line-number="9026"></td>
+ <td id="LC9026" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9027" class="blob-num js-line-number" data-line-number="9027"></td>
+ <td id="LC9027" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that executes `func`, with the `this` binding and</span></td>
+ </tr>
+ <tr>
+ <td id="L9028" class="blob-num js-line-number" data-line-number="9028"></td>
+ <td id="LC9028" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * arguments of the created function, only after being called `n` times.</span></td>
+ </tr>
+ <tr>
+ <td id="L9029" class="blob-num js-line-number" data-line-number="9029"></td>
+ <td id="LC9029" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9030" class="blob-num js-line-number" data-line-number="9030"></td>
+ <td id="LC9030" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9031" class="blob-num js-line-number" data-line-number="9031"></td>
+ <td id="LC9031" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9032" class="blob-num js-line-number" data-line-number="9032"></td>
+ <td id="LC9032" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9033" class="blob-num js-line-number" data-line-number="9033"></td>
+ <td id="LC9033" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">n</span> The number of times the function must be called before</span></td>
+ </tr>
+ <tr>
+ <td id="L9034" class="blob-num js-line-number" data-line-number="9034"></td>
+ <td id="LC9034" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `func` is executed.</span></td>
+ </tr>
+ <tr>
+ <td id="L9035" class="blob-num js-line-number" data-line-number="9035"></td>
+ <td id="LC9035" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to restrict.</span></td>
+ </tr>
+ <tr>
+ <td id="L9036" class="blob-num js-line-number" data-line-number="9036"></td>
+ <td id="LC9036" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new restricted function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9037" class="blob-num js-line-number" data-line-number="9037"></td>
+ <td id="LC9037" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9038" class="blob-num js-line-number" data-line-number="9038"></td>
+ <td id="LC9038" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9039" class="blob-num js-line-number" data-line-number="9039"></td>
+ <td id="LC9039" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var saves = ['profile', 'settings'];</span></td>
+ </tr>
+ <tr>
+ <td id="L9040" class="blob-num js-line-number" data-line-number="9040"></td>
+ <td id="LC9040" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9041" class="blob-num js-line-number" data-line-number="9041"></td>
+ <td id="LC9041" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var done = _.after(saves.length, function() {</span></td>
+ </tr>
+ <tr>
+ <td id="L9042" class="blob-num js-line-number" data-line-number="9042"></td>
+ <td id="LC9042" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log('Done saving!');</span></td>
+ </tr>
+ <tr>
+ <td id="L9043" class="blob-num js-line-number" data-line-number="9043"></td>
+ <td id="LC9043" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9044" class="blob-num js-line-number" data-line-number="9044"></td>
+ <td id="LC9044" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9045" class="blob-num js-line-number" data-line-number="9045"></td>
+ <td id="LC9045" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.forEach(saves, function(type) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9046" class="blob-num js-line-number" data-line-number="9046"></td>
+ <td id="LC9046" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * asyncSave({ 'type': type, 'complete': done });</span></td>
+ </tr>
+ <tr>
+ <td id="L9047" class="blob-num js-line-number" data-line-number="9047"></td>
+ <td id="LC9047" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9048" class="blob-num js-line-number" data-line-number="9048"></td>
+ <td id="LC9048" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs 'Done saving!', after all saves have completed</span></td>
+ </tr>
+ <tr>
+ <td id="L9049" class="blob-num js-line-number" data-line-number="9049"></td>
+ <td id="LC9049" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9050" class="blob-num js-line-number" data-line-number="9050"></td>
+ <td id="LC9050" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">after</span>(<span class="pl-smi">n</span>, <span class="pl-smi">func</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9051" class="blob-num js-line-number" data-line-number="9051"></td>
+ <td id="LC9051" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9052" class="blob-num js-line-number" data-line-number="9052"></td>
+ <td id="LC9052" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9053" class="blob-num js-line-number" data-line-number="9053"></td>
+ <td id="LC9053" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9054" class="blob-num js-line-number" data-line-number="9054"></td>
+ <td id="LC9054" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9055" class="blob-num js-line-number" data-line-number="9055"></td>
+ <td id="LC9055" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">--</span>n <span class="pl-k"><</span> <span class="pl-c1">1</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9056" class="blob-num js-line-number" data-line-number="9056"></td>
+ <td id="LC9056" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9057" class="blob-num js-line-number" data-line-number="9057"></td>
+ <td id="LC9057" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9058" class="blob-num js-line-number" data-line-number="9058"></td>
+ <td id="LC9058" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9059" class="blob-num js-line-number" data-line-number="9059"></td>
+ <td id="LC9059" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9060" class="blob-num js-line-number" data-line-number="9060"></td>
+ <td id="LC9060" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9061" class="blob-num js-line-number" data-line-number="9061"></td>
+ <td id="LC9061" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9062" class="blob-num js-line-number" data-line-number="9062"></td>
+ <td id="LC9062" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that, when called, invokes `func` with the `this`</span></td>
+ </tr>
+ <tr>
+ <td id="L9063" class="blob-num js-line-number" data-line-number="9063"></td>
+ <td id="LC9063" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * binding of `thisArg` and prepends any additional `bind` arguments to those</span></td>
+ </tr>
+ <tr>
+ <td id="L9064" class="blob-num js-line-number" data-line-number="9064"></td>
+ <td id="LC9064" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided to the bound function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9065" class="blob-num js-line-number" data-line-number="9065"></td>
+ <td id="LC9065" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9066" class="blob-num js-line-number" data-line-number="9066"></td>
+ <td id="LC9066" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9067" class="blob-num js-line-number" data-line-number="9067"></td>
+ <td id="LC9067" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9068" class="blob-num js-line-number" data-line-number="9068"></td>
+ <td id="LC9068" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9069" class="blob-num js-line-number" data-line-number="9069"></td>
+ <td id="LC9069" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to bind.</span></td>
+ </tr>
+ <tr>
+ <td id="L9070" class="blob-num js-line-number" data-line-number="9070"></td>
+ <td id="LC9070" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `func`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9071" class="blob-num js-line-number" data-line-number="9071"></td>
+ <td id="LC9071" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to be partially applied.</span></td>
+ </tr>
+ <tr>
+ <td id="L9072" class="blob-num js-line-number" data-line-number="9072"></td>
+ <td id="LC9072" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new bound function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9073" class="blob-num js-line-number" data-line-number="9073"></td>
+ <td id="LC9073" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9074" class="blob-num js-line-number" data-line-number="9074"></td>
+ <td id="LC9074" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9075" class="blob-num js-line-number" data-line-number="9075"></td>
+ <td id="LC9075" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var func = function(greeting) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9076" class="blob-num js-line-number" data-line-number="9076"></td>
+ <td id="LC9076" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return greeting + ' ' + this.name;</span></td>
+ </tr>
+ <tr>
+ <td id="L9077" class="blob-num js-line-number" data-line-number="9077"></td>
+ <td id="LC9077" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9078" class="blob-num js-line-number" data-line-number="9078"></td>
+ <td id="LC9078" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9079" class="blob-num js-line-number" data-line-number="9079"></td>
+ <td id="LC9079" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * func = _.bind(func, { 'name': 'fred' }, 'hi');</span></td>
+ </tr>
+ <tr>
+ <td id="L9080" class="blob-num js-line-number" data-line-number="9080"></td>
+ <td id="LC9080" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * func();</span></td>
+ </tr>
+ <tr>
+ <td id="L9081" class="blob-num js-line-number" data-line-number="9081"></td>
+ <td id="LC9081" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hi fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L9082" class="blob-num js-line-number" data-line-number="9082"></td>
+ <td id="LC9082" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9083" class="blob-num js-line-number" data-line-number="9083"></td>
+ <td id="LC9083" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">bind</span>(<span class="pl-smi">func</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9084" class="blob-num js-line-number" data-line-number="9084"></td>
+ <td id="LC9084" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">2</span></td>
+ </tr>
+ <tr>
+ <td id="L9085" class="blob-num js-line-number" data-line-number="9085"></td>
+ <td id="LC9085" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-en">createWrapper</span>(func, <span class="pl-c1">17</span>, <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">2</span>), <span class="pl-c1">null</span>, thisArg)</td>
+ </tr>
+ <tr>
+ <td id="L9086" class="blob-num js-line-number" data-line-number="9086"></td>
+ <td id="LC9086" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">createWrapper</span>(func, <span class="pl-c1">1</span>, <span class="pl-c1">null</span>, <span class="pl-c1">null</span>, thisArg);</td>
+ </tr>
+ <tr>
+ <td id="L9087" class="blob-num js-line-number" data-line-number="9087"></td>
+ <td id="LC9087" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9088" class="blob-num js-line-number" data-line-number="9088"></td>
+ <td id="LC9088" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9089" class="blob-num js-line-number" data-line-number="9089"></td>
+ <td id="LC9089" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9090" class="blob-num js-line-number" data-line-number="9090"></td>
+ <td id="LC9090" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Binds methods of an object to the object itself, overwriting the existing</span></td>
+ </tr>
+ <tr>
+ <td id="L9091" class="blob-num js-line-number" data-line-number="9091"></td>
+ <td id="LC9091" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * method. Method names may be specified as individual arguments or as arrays</span></td>
+ </tr>
+ <tr>
+ <td id="L9092" class="blob-num js-line-number" data-line-number="9092"></td>
+ <td id="LC9092" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of method names. If no method names are provided all the function properties</span></td>
+ </tr>
+ <tr>
+ <td id="L9093" class="blob-num js-line-number" data-line-number="9093"></td>
+ <td id="LC9093" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of `object` will be bound.</span></td>
+ </tr>
+ <tr>
+ <td id="L9094" class="blob-num js-line-number" data-line-number="9094"></td>
+ <td id="LC9094" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9095" class="blob-num js-line-number" data-line-number="9095"></td>
+ <td id="LC9095" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9096" class="blob-num js-line-number" data-line-number="9096"></td>
+ <td id="LC9096" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9097" class="blob-num js-line-number" data-line-number="9097"></td>
+ <td id="LC9097" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9098" class="blob-num js-line-number" data-line-number="9098"></td>
+ <td id="LC9098" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to bind and assign the bound methods to.</span></td>
+ </tr>
+ <tr>
+ <td id="L9099" class="blob-num js-line-number" data-line-number="9099"></td>
+ <td id="LC9099" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...string} [methodName] The object method names to</span></td>
+ </tr>
+ <tr>
+ <td id="L9100" class="blob-num js-line-number" data-line-number="9100"></td>
+ <td id="LC9100" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * bind, specified as individual method names or arrays of method names.</span></td>
+ </tr>
+ <tr>
+ <td id="L9101" class="blob-num js-line-number" data-line-number="9101"></td>
+ <td id="LC9101" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> `object`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9102" class="blob-num js-line-number" data-line-number="9102"></td>
+ <td id="LC9102" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9103" class="blob-num js-line-number" data-line-number="9103"></td>
+ <td id="LC9103" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9104" class="blob-num js-line-number" data-line-number="9104"></td>
+ <td id="LC9104" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var view = {</span></td>
+ </tr>
+ <tr>
+ <td id="L9105" class="blob-num js-line-number" data-line-number="9105"></td>
+ <td id="LC9105" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'label': 'docs',</span></td>
+ </tr>
+ <tr>
+ <td id="L9106" class="blob-num js-line-number" data-line-number="9106"></td>
+ <td id="LC9106" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'onClick': function() { console.log('clicked ' + this.label); }</span></td>
+ </tr>
+ <tr>
+ <td id="L9107" class="blob-num js-line-number" data-line-number="9107"></td>
+ <td id="LC9107" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9108" class="blob-num js-line-number" data-line-number="9108"></td>
+ <td id="LC9108" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9109" class="blob-num js-line-number" data-line-number="9109"></td>
+ <td id="LC9109" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.bindAll(view);</span></td>
+ </tr>
+ <tr>
+ <td id="L9110" class="blob-num js-line-number" data-line-number="9110"></td>
+ <td id="LC9110" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * jQuery('#docs').on('click', view.onClick);</span></td>
+ </tr>
+ <tr>
+ <td id="L9111" class="blob-num js-line-number" data-line-number="9111"></td>
+ <td id="LC9111" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs 'clicked docs', when the button is clicked</span></td>
+ </tr>
+ <tr>
+ <td id="L9112" class="blob-num js-line-number" data-line-number="9112"></td>
+ <td id="LC9112" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9113" class="blob-num js-line-number" data-line-number="9113"></td>
+ <td id="LC9113" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">bindAll</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9114" class="blob-num js-line-number" data-line-number="9114"></td>
+ <td id="LC9114" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> funcs <span class="pl-k">=</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">1</span> <span class="pl-k">?</span> <span class="pl-en">baseFlatten</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">true</span>, <span class="pl-c1">false</span>, <span class="pl-c1">1</span>) <span class="pl-k">: [...]
+ </tr>
+ <tr>
+ <td id="L9115" class="blob-num js-line-number" data-line-number="9115"></td>
+ <td id="LC9115" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9116" class="blob-num js-line-number" data-line-number="9116"></td>
+ <td id="LC9116" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">funcs</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9117" class="blob-num js-line-number" data-line-number="9117"></td>
+ <td id="LC9117" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9118" class="blob-num js-line-number" data-line-number="9118"></td>
+ <td id="LC9118" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> length) {</td>
+ </tr>
+ <tr>
+ <td id="L9119" class="blob-num js-line-number" data-line-number="9119"></td>
+ <td id="LC9119" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> key <span class="pl-k">=</span> funcs[index];</td>
+ </tr>
+ <tr>
+ <td id="L9120" class="blob-num js-line-number" data-line-number="9120"></td>
+ <td id="LC9120" class="blob-code blob-code-inner js-file-line"> object[key] <span class="pl-k">=</span> <span class="pl-en">createWrapper</span>(object[key], <span class="pl-c1">1</span>, <span class="pl-c1">null</span>, <span class="pl-c1">null</span>, object);</td>
+ </tr>
+ <tr>
+ <td id="L9121" class="blob-num js-line-number" data-line-number="9121"></td>
+ <td id="LC9121" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9122" class="blob-num js-line-number" data-line-number="9122"></td>
+ <td id="LC9122" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object;</td>
+ </tr>
+ <tr>
+ <td id="L9123" class="blob-num js-line-number" data-line-number="9123"></td>
+ <td id="LC9123" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9124" class="blob-num js-line-number" data-line-number="9124"></td>
+ <td id="LC9124" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9125" class="blob-num js-line-number" data-line-number="9125"></td>
+ <td id="LC9125" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9126" class="blob-num js-line-number" data-line-number="9126"></td>
+ <td id="LC9126" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that, when called, invokes the method at `object[key]`</span></td>
+ </tr>
+ <tr>
+ <td id="L9127" class="blob-num js-line-number" data-line-number="9127"></td>
+ <td id="LC9127" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * and prepends any additional `bindKey` arguments to those provided to the bound</span></td>
+ </tr>
+ <tr>
+ <td id="L9128" class="blob-num js-line-number" data-line-number="9128"></td>
+ <td id="LC9128" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function. This method differs from `_.bind` by allowing bound functions to</span></td>
+ </tr>
+ <tr>
+ <td id="L9129" class="blob-num js-line-number" data-line-number="9129"></td>
+ <td id="LC9129" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * reference methods that will be redefined or don't yet exist.</span></td>
+ </tr>
+ <tr>
+ <td id="L9130" class="blob-num js-line-number" data-line-number="9130"></td>
+ <td id="LC9130" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * See http://michaux.ca/articles/lazy-function-definition-pattern.</span></td>
+ </tr>
+ <tr>
+ <td id="L9131" class="blob-num js-line-number" data-line-number="9131"></td>
+ <td id="LC9131" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9132" class="blob-num js-line-number" data-line-number="9132"></td>
+ <td id="LC9132" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9133" class="blob-num js-line-number" data-line-number="9133"></td>
+ <td id="LC9133" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9134" class="blob-num js-line-number" data-line-number="9134"></td>
+ <td id="LC9134" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9135" class="blob-num js-line-number" data-line-number="9135"></td>
+ <td id="LC9135" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object the method belongs to.</span></td>
+ </tr>
+ <tr>
+ <td id="L9136" class="blob-num js-line-number" data-line-number="9136"></td>
+ <td id="LC9136" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">key</span> The key of the method.</span></td>
+ </tr>
+ <tr>
+ <td id="L9137" class="blob-num js-line-number" data-line-number="9137"></td>
+ <td id="LC9137" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to be partially applied.</span></td>
+ </tr>
+ <tr>
+ <td id="L9138" class="blob-num js-line-number" data-line-number="9138"></td>
+ <td id="LC9138" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new bound function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9139" class="blob-num js-line-number" data-line-number="9139"></td>
+ <td id="LC9139" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9140" class="blob-num js-line-number" data-line-number="9140"></td>
+ <td id="LC9140" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9141" class="blob-num js-line-number" data-line-number="9141"></td>
+ <td id="LC9141" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = {</span></td>
+ </tr>
+ <tr>
+ <td id="L9142" class="blob-num js-line-number" data-line-number="9142"></td>
+ <td id="LC9142" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'name': 'fred',</span></td>
+ </tr>
+ <tr>
+ <td id="L9143" class="blob-num js-line-number" data-line-number="9143"></td>
+ <td id="LC9143" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'greet': function(greeting) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9144" class="blob-num js-line-number" data-line-number="9144"></td>
+ <td id="LC9144" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return greeting + ' ' + this.name;</span></td>
+ </tr>
+ <tr>
+ <td id="L9145" class="blob-num js-line-number" data-line-number="9145"></td>
+ <td id="LC9145" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L9146" class="blob-num js-line-number" data-line-number="9146"></td>
+ <td id="LC9146" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9147" class="blob-num js-line-number" data-line-number="9147"></td>
+ <td id="LC9147" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9148" class="blob-num js-line-number" data-line-number="9148"></td>
+ <td id="LC9148" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var func = _.bindKey(object, 'greet', 'hi');</span></td>
+ </tr>
+ <tr>
+ <td id="L9149" class="blob-num js-line-number" data-line-number="9149"></td>
+ <td id="LC9149" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * func();</span></td>
+ </tr>
+ <tr>
+ <td id="L9150" class="blob-num js-line-number" data-line-number="9150"></td>
+ <td id="LC9150" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hi fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L9151" class="blob-num js-line-number" data-line-number="9151"></td>
+ <td id="LC9151" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9152" class="blob-num js-line-number" data-line-number="9152"></td>
+ <td id="LC9152" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * object.greet = function(greeting) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9153" class="blob-num js-line-number" data-line-number="9153"></td>
+ <td id="LC9153" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return greeting + 'ya ' + this.name + '!';</span></td>
+ </tr>
+ <tr>
+ <td id="L9154" class="blob-num js-line-number" data-line-number="9154"></td>
+ <td id="LC9154" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9155" class="blob-num js-line-number" data-line-number="9155"></td>
+ <td id="LC9155" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9156" class="blob-num js-line-number" data-line-number="9156"></td>
+ <td id="LC9156" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * func();</span></td>
+ </tr>
+ <tr>
+ <td id="L9157" class="blob-num js-line-number" data-line-number="9157"></td>
+ <td id="LC9157" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hiya fred!'</span></td>
+ </tr>
+ <tr>
+ <td id="L9158" class="blob-num js-line-number" data-line-number="9158"></td>
+ <td id="LC9158" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9159" class="blob-num js-line-number" data-line-number="9159"></td>
+ <td id="LC9159" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">bindKey</span>(<span class="pl-smi">object</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9160" class="blob-num js-line-number" data-line-number="9160"></td>
+ <td id="LC9160" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">arguments</span>.<span class="pl-c1">length</span> <span class="pl-k">></span> <span class="pl-c1">2</span></td>
+ </tr>
+ <tr>
+ <td id="L9161" class="blob-num js-line-number" data-line-number="9161"></td>
+ <td id="LC9161" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-en">createWrapper</span>(key, <span class="pl-c1">19</span>, <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">2</span>), <span class="pl-c1">null</span>, object)</td>
+ </tr>
+ <tr>
+ <td id="L9162" class="blob-num js-line-number" data-line-number="9162"></td>
+ <td id="LC9162" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-en">createWrapper</span>(key, <span class="pl-c1">3</span>, <span class="pl-c1">null</span>, <span class="pl-c1">null</span>, object);</td>
+ </tr>
+ <tr>
+ <td id="L9163" class="blob-num js-line-number" data-line-number="9163"></td>
+ <td id="LC9163" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9164" class="blob-num js-line-number" data-line-number="9164"></td>
+ <td id="LC9164" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9165" class="blob-num js-line-number" data-line-number="9165"></td>
+ <td id="LC9165" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9166" class="blob-num js-line-number" data-line-number="9166"></td>
+ <td id="LC9166" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that is the composition of the provided functions,</span></td>
+ </tr>
+ <tr>
+ <td id="L9167" class="blob-num js-line-number" data-line-number="9167"></td>
+ <td id="LC9167" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * where each function consumes the return value of the function that follows.</span></td>
+ </tr>
+ <tr>
+ <td id="L9168" class="blob-num js-line-number" data-line-number="9168"></td>
+ <td id="LC9168" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9169" class="blob-num js-line-number" data-line-number="9169"></td>
+ <td id="LC9169" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Each function is executed with the `this` binding of the composed function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9170" class="blob-num js-line-number" data-line-number="9170"></td>
+ <td id="LC9170" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9171" class="blob-num js-line-number" data-line-number="9171"></td>
+ <td id="LC9171" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9172" class="blob-num js-line-number" data-line-number="9172"></td>
+ <td id="LC9172" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9173" class="blob-num js-line-number" data-line-number="9173"></td>
+ <td id="LC9173" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9174" class="blob-num js-line-number" data-line-number="9174"></td>
+ <td id="LC9174" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...Function} [func] Functions to compose.</span></td>
+ </tr>
+ <tr>
+ <td id="L9175" class="blob-num js-line-number" data-line-number="9175"></td>
+ <td id="LC9175" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new composed function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9176" class="blob-num js-line-number" data-line-number="9176"></td>
+ <td id="LC9176" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9177" class="blob-num js-line-number" data-line-number="9177"></td>
+ <td id="LC9177" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9178" class="blob-num js-line-number" data-line-number="9178"></td>
+ <td id="LC9178" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var realNameMap = {</span></td>
+ </tr>
+ <tr>
+ <td id="L9179" class="blob-num js-line-number" data-line-number="9179"></td>
+ <td id="LC9179" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'pebbles': 'penelope'</span></td>
+ </tr>
+ <tr>
+ <td id="L9180" class="blob-num js-line-number" data-line-number="9180"></td>
+ <td id="LC9180" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9181" class="blob-num js-line-number" data-line-number="9181"></td>
+ <td id="LC9181" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9182" class="blob-num js-line-number" data-line-number="9182"></td>
+ <td id="LC9182" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var format = function(name) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9183" class="blob-num js-line-number" data-line-number="9183"></td>
+ <td id="LC9183" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * name = realNameMap[name.toLowerCase()] || name;</span></td>
+ </tr>
+ <tr>
+ <td id="L9184" class="blob-num js-line-number" data-line-number="9184"></td>
+ <td id="LC9184" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();</span></td>
+ </tr>
+ <tr>
+ <td id="L9185" class="blob-num js-line-number" data-line-number="9185"></td>
+ <td id="LC9185" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9186" class="blob-num js-line-number" data-line-number="9186"></td>
+ <td id="LC9186" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9187" class="blob-num js-line-number" data-line-number="9187"></td>
+ <td id="LC9187" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var greet = function(formatted) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9188" class="blob-num js-line-number" data-line-number="9188"></td>
+ <td id="LC9188" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return 'Hiya ' + formatted + '!';</span></td>
+ </tr>
+ <tr>
+ <td id="L9189" class="blob-num js-line-number" data-line-number="9189"></td>
+ <td id="LC9189" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9190" class="blob-num js-line-number" data-line-number="9190"></td>
+ <td id="LC9190" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9191" class="blob-num js-line-number" data-line-number="9191"></td>
+ <td id="LC9191" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var welcome = _.compose(greet, format);</span></td>
+ </tr>
+ <tr>
+ <td id="L9192" class="blob-num js-line-number" data-line-number="9192"></td>
+ <td id="LC9192" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * welcome('pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L9193" class="blob-num js-line-number" data-line-number="9193"></td>
+ <td id="LC9193" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'Hiya Penelope!'</span></td>
+ </tr>
+ <tr>
+ <td id="L9194" class="blob-num js-line-number" data-line-number="9194"></td>
+ <td id="LC9194" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9195" class="blob-num js-line-number" data-line-number="9195"></td>
+ <td id="LC9195" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">compose</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9196" class="blob-num js-line-number" data-line-number="9196"></td>
+ <td id="LC9196" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> funcs <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9197" class="blob-num js-line-number" data-line-number="9197"></td>
+ <td id="LC9197" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">funcs</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9198" class="blob-num js-line-number" data-line-number="9198"></td>
+ <td id="LC9198" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9199" class="blob-num js-line-number" data-line-number="9199"></td>
+ <td id="LC9199" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9200" class="blob-num js-line-number" data-line-number="9200"></td>
+ <td id="LC9200" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(funcs[length])) {</td>
+ </tr>
+ <tr>
+ <td id="L9201" class="blob-num js-line-number" data-line-number="9201"></td>
+ <td id="LC9201" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9202" class="blob-num js-line-number" data-line-number="9202"></td>
+ <td id="LC9202" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9203" class="blob-num js-line-number" data-line-number="9203"></td>
+ <td id="LC9203" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9204" class="blob-num js-line-number" data-line-number="9204"></td>
+ <td id="LC9204" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9205" class="blob-num js-line-number" data-line-number="9205"></td>
+ <td id="LC9205" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9206" class="blob-num js-line-number" data-line-number="9206"></td>
+ <td id="LC9206" class="blob-code blob-code-inner js-file-line"> length <span class="pl-k">=</span> <span class="pl-smi">funcs</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9207" class="blob-num js-line-number" data-line-number="9207"></td>
+ <td id="LC9207" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9208" class="blob-num js-line-number" data-line-number="9208"></td>
+ <td id="LC9208" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9209" class="blob-num js-line-number" data-line-number="9209"></td>
+ <td id="LC9209" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> [funcs[length].<span class="pl-c1">apply</span>(<span class="pl-v">this</span>, args)];</td>
+ </tr>
+ <tr>
+ <td id="L9210" class="blob-num js-line-number" data-line-number="9210"></td>
+ <td id="LC9210" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9211" class="blob-num js-line-number" data-line-number="9211"></td>
+ <td id="LC9211" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> args[<span class="pl-c1">0</span>];</td>
+ </tr>
+ <tr>
+ <td id="L9212" class="blob-num js-line-number" data-line-number="9212"></td>
+ <td id="LC9212" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9213" class="blob-num js-line-number" data-line-number="9213"></td>
+ <td id="LC9213" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9214" class="blob-num js-line-number" data-line-number="9214"></td>
+ <td id="LC9214" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9215" class="blob-num js-line-number" data-line-number="9215"></td>
+ <td id="LC9215" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9216" class="blob-num js-line-number" data-line-number="9216"></td>
+ <td id="LC9216" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function which accepts one or more arguments of `func` that when</span></td>
+ </tr>
+ <tr>
+ <td id="L9217" class="blob-num js-line-number" data-line-number="9217"></td>
+ <td id="LC9217" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked either executes `func` returning its result, if all `func` arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L9218" class="blob-num js-line-number" data-line-number="9218"></td>
+ <td id="LC9218" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * have been provided, or returns a function that accepts one or more of the</span></td>
+ </tr>
+ <tr>
+ <td id="L9219" class="blob-num js-line-number" data-line-number="9219"></td>
+ <td id="LC9219" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * remaining `func` arguments, and so on. The arity of `func` can be specified</span></td>
+ </tr>
+ <tr>
+ <td id="L9220" class="blob-num js-line-number" data-line-number="9220"></td>
+ <td id="LC9220" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * if `func.length` is not sufficient.</span></td>
+ </tr>
+ <tr>
+ <td id="L9221" class="blob-num js-line-number" data-line-number="9221"></td>
+ <td id="LC9221" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9222" class="blob-num js-line-number" data-line-number="9222"></td>
+ <td id="LC9222" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9223" class="blob-num js-line-number" data-line-number="9223"></td>
+ <td id="LC9223" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9224" class="blob-num js-line-number" data-line-number="9224"></td>
+ <td id="LC9224" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9225" class="blob-num js-line-number" data-line-number="9225"></td>
+ <td id="LC9225" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to curry.</span></td>
+ </tr>
+ <tr>
+ <td id="L9226" class="blob-num js-line-number" data-line-number="9226"></td>
+ <td id="LC9226" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [arity=func.length] The arity of `func`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9227" class="blob-num js-line-number" data-line-number="9227"></td>
+ <td id="LC9227" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new curried function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9228" class="blob-num js-line-number" data-line-number="9228"></td>
+ <td id="LC9228" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9229" class="blob-num js-line-number" data-line-number="9229"></td>
+ <td id="LC9229" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9230" class="blob-num js-line-number" data-line-number="9230"></td>
+ <td id="LC9230" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var curried = _.curry(function(a, b, c) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9231" class="blob-num js-line-number" data-line-number="9231"></td>
+ <td id="LC9231" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * console.log(a + b + c);</span></td>
+ </tr>
+ <tr>
+ <td id="L9232" class="blob-num js-line-number" data-line-number="9232"></td>
+ <td id="LC9232" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9233" class="blob-num js-line-number" data-line-number="9233"></td>
+ <td id="LC9233" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9234" class="blob-num js-line-number" data-line-number="9234"></td>
+ <td id="LC9234" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * curried(1)(2)(3);</span></td>
+ </tr>
+ <tr>
+ <td id="L9235" class="blob-num js-line-number" data-line-number="9235"></td>
+ <td id="LC9235" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 6</span></td>
+ </tr>
+ <tr>
+ <td id="L9236" class="blob-num js-line-number" data-line-number="9236"></td>
+ <td id="LC9236" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9237" class="blob-num js-line-number" data-line-number="9237"></td>
+ <td id="LC9237" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * curried(1, 2)(3);</span></td>
+ </tr>
+ <tr>
+ <td id="L9238" class="blob-num js-line-number" data-line-number="9238"></td>
+ <td id="LC9238" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 6</span></td>
+ </tr>
+ <tr>
+ <td id="L9239" class="blob-num js-line-number" data-line-number="9239"></td>
+ <td id="LC9239" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9240" class="blob-num js-line-number" data-line-number="9240"></td>
+ <td id="LC9240" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * curried(1, 2, 3);</span></td>
+ </tr>
+ <tr>
+ <td id="L9241" class="blob-num js-line-number" data-line-number="9241"></td>
+ <td id="LC9241" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 6</span></td>
+ </tr>
+ <tr>
+ <td id="L9242" class="blob-num js-line-number" data-line-number="9242"></td>
+ <td id="LC9242" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9243" class="blob-num js-line-number" data-line-number="9243"></td>
+ <td id="LC9243" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">curry</span>(<span class="pl-smi">func</span>, <span class="pl-smi">arity</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9244" class="blob-num js-line-number" data-line-number="9244"></td>
+ <td id="LC9244" class="blob-code blob-code-inner js-file-line"> arity <span class="pl-k">=</span> <span class="pl-k">typeof</span> arity <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>number<span class="pl-pds">'</span></span> <span class="pl-k">?</span> arity <span class="pl-k">:</span> (<span class="pl-k">+</span>arity <span class="pl-k">||</span> <span class="pl-smi">func</span>.<span class="pl-c1">length</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9245" class="blob-num js-line-number" data-line-number="9245"></td>
+ <td id="LC9245" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">createWrapper</span>(func, <span class="pl-c1">4</span>, <span class="pl-c1">null</span>, <span class="pl-c1">null</span>, <span class="pl-c1">null</span>, arity);</td>
+ </tr>
+ <tr>
+ <td id="L9246" class="blob-num js-line-number" data-line-number="9246"></td>
+ <td id="LC9246" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9247" class="blob-num js-line-number" data-line-number="9247"></td>
+ <td id="LC9247" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9248" class="blob-num js-line-number" data-line-number="9248"></td>
+ <td id="LC9248" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9249" class="blob-num js-line-number" data-line-number="9249"></td>
+ <td id="LC9249" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that will delay the execution of `func` until after</span></td>
+ </tr>
+ <tr>
+ <td id="L9250" class="blob-num js-line-number" data-line-number="9250"></td>
+ <td id="LC9250" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `wait` milliseconds have elapsed since the last time it was invoked.</span></td>
+ </tr>
+ <tr>
+ <td id="L9251" class="blob-num js-line-number" data-line-number="9251"></td>
+ <td id="LC9251" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Provide an options object to indicate that `func` should be invoked on</span></td>
+ </tr>
+ <tr>
+ <td id="L9252" class="blob-num js-line-number" data-line-number="9252"></td>
+ <td id="LC9252" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the leading and/or trailing edge of the `wait` timeout. Subsequent calls</span></td>
+ </tr>
+ <tr>
+ <td id="L9253" class="blob-num js-line-number" data-line-number="9253"></td>
+ <td id="LC9253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to the debounced function will return the result of the last `func` call.</span></td>
+ </tr>
+ <tr>
+ <td id="L9254" class="blob-num js-line-number" data-line-number="9254"></td>
+ <td id="LC9254" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9255" class="blob-num js-line-number" data-line-number="9255"></td>
+ <td id="LC9255" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: If `leading` and `trailing` options are `true` `func` will be called</span></td>
+ </tr>
+ <tr>
+ <td id="L9256" class="blob-num js-line-number" data-line-number="9256"></td>
+ <td id="LC9256" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * on the trailing edge of the timeout only if the the debounced function is</span></td>
+ </tr>
+ <tr>
+ <td id="L9257" class="blob-num js-line-number" data-line-number="9257"></td>
+ <td id="LC9257" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked more than once during the `wait` timeout.</span></td>
+ </tr>
+ <tr>
+ <td id="L9258" class="blob-num js-line-number" data-line-number="9258"></td>
+ <td id="LC9258" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9259" class="blob-num js-line-number" data-line-number="9259"></td>
+ <td id="LC9259" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9260" class="blob-num js-line-number" data-line-number="9260"></td>
+ <td id="LC9260" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9261" class="blob-num js-line-number" data-line-number="9261"></td>
+ <td id="LC9261" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9262" class="blob-num js-line-number" data-line-number="9262"></td>
+ <td id="LC9262" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to debounce.</span></td>
+ </tr>
+ <tr>
+ <td id="L9263" class="blob-num js-line-number" data-line-number="9263"></td>
+ <td id="LC9263" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">wait</span> The number of milliseconds to delay.</span></td>
+ </tr>
+ <tr>
+ <td id="L9264" class="blob-num js-line-number" data-line-number="9264"></td>
+ <td id="LC9264" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [options] The options object.</span></td>
+ </tr>
+ <tr>
+ <td id="L9265" class="blob-num js-line-number" data-line-number="9265"></td>
+ <td id="LC9265" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [options.leading=false] Specify execution on the leading edge of the timeout.</span></td>
+ </tr>
+ <tr>
+ <td id="L9266" class="blob-num js-line-number" data-line-number="9266"></td>
+ <td id="LC9266" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called.</span></td>
+ </tr>
+ <tr>
+ <td id="L9267" class="blob-num js-line-number" data-line-number="9267"></td>
+ <td id="LC9267" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.</span></td>
+ </tr>
+ <tr>
+ <td id="L9268" class="blob-num js-line-number" data-line-number="9268"></td>
+ <td id="LC9268" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new debounced function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9269" class="blob-num js-line-number" data-line-number="9269"></td>
+ <td id="LC9269" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9270" class="blob-num js-line-number" data-line-number="9270"></td>
+ <td id="LC9270" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9271" class="blob-num js-line-number" data-line-number="9271"></td>
+ <td id="LC9271" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // avoid costly calculations while the window size is in flux</span></td>
+ </tr>
+ <tr>
+ <td id="L9272" class="blob-num js-line-number" data-line-number="9272"></td>
+ <td id="LC9272" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var lazyLayout = _.debounce(calculateLayout, 150);</span></td>
+ </tr>
+ <tr>
+ <td id="L9273" class="blob-num js-line-number" data-line-number="9273"></td>
+ <td id="LC9273" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * jQuery(window).on('resize', lazyLayout);</span></td>
+ </tr>
+ <tr>
+ <td id="L9274" class="blob-num js-line-number" data-line-number="9274"></td>
+ <td id="LC9274" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9275" class="blob-num js-line-number" data-line-number="9275"></td>
+ <td id="LC9275" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // execute `sendMail` when the click event is fired, debouncing subsequent calls</span></td>
+ </tr>
+ <tr>
+ <td id="L9276" class="blob-num js-line-number" data-line-number="9276"></td>
+ <td id="LC9276" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {</span></td>
+ </tr>
+ <tr>
+ <td id="L9277" class="blob-num js-line-number" data-line-number="9277"></td>
+ <td id="LC9277" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'leading': true,</span></td>
+ </tr>
+ <tr>
+ <td id="L9278" class="blob-num js-line-number" data-line-number="9278"></td>
+ <td id="LC9278" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'trailing': false</span></td>
+ </tr>
+ <tr>
+ <td id="L9279" class="blob-num js-line-number" data-line-number="9279"></td>
+ <td id="LC9279" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9280" class="blob-num js-line-number" data-line-number="9280"></td>
+ <td id="LC9280" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9281" class="blob-num js-line-number" data-line-number="9281"></td>
+ <td id="LC9281" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // ensure `batchLog` is executed once after 1 second of debounced calls</span></td>
+ </tr>
+ <tr>
+ <td id="L9282" class="blob-num js-line-number" data-line-number="9282"></td>
+ <td id="LC9282" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var source = new EventSource('/stream');</span></td>
+ </tr>
+ <tr>
+ <td id="L9283" class="blob-num js-line-number" data-line-number="9283"></td>
+ <td id="LC9283" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * source.addEventListener('message', _.debounce(batchLog, 250, {</span></td>
+ </tr>
+ <tr>
+ <td id="L9284" class="blob-num js-line-number" data-line-number="9284"></td>
+ <td id="LC9284" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'maxWait': 1000</span></td>
+ </tr>
+ <tr>
+ <td id="L9285" class="blob-num js-line-number" data-line-number="9285"></td>
+ <td id="LC9285" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }, false);</span></td>
+ </tr>
+ <tr>
+ <td id="L9286" class="blob-num js-line-number" data-line-number="9286"></td>
+ <td id="LC9286" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9287" class="blob-num js-line-number" data-line-number="9287"></td>
+ <td id="LC9287" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">debounce</span>(<span class="pl-smi">func</span>, <span class="pl-smi">wait</span>, <span class="pl-smi">options</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9288" class="blob-num js-line-number" data-line-number="9288"></td>
+ <td id="LC9288" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args,</td>
+ </tr>
+ <tr>
+ <td id="L9289" class="blob-num js-line-number" data-line-number="9289"></td>
+ <td id="LC9289" class="blob-code blob-code-inner js-file-line"> maxTimeoutId,</td>
+ </tr>
+ <tr>
+ <td id="L9290" class="blob-num js-line-number" data-line-number="9290"></td>
+ <td id="LC9290" class="blob-code blob-code-inner js-file-line"> result,</td>
+ </tr>
+ <tr>
+ <td id="L9291" class="blob-num js-line-number" data-line-number="9291"></td>
+ <td id="LC9291" class="blob-code blob-code-inner js-file-line"> stamp,</td>
+ </tr>
+ <tr>
+ <td id="L9292" class="blob-num js-line-number" data-line-number="9292"></td>
+ <td id="LC9292" class="blob-code blob-code-inner js-file-line"> thisArg,</td>
+ </tr>
+ <tr>
+ <td id="L9293" class="blob-num js-line-number" data-line-number="9293"></td>
+ <td id="LC9293" class="blob-code blob-code-inner js-file-line"> timeoutId,</td>
+ </tr>
+ <tr>
+ <td id="L9294" class="blob-num js-line-number" data-line-number="9294"></td>
+ <td id="LC9294" class="blob-code blob-code-inner js-file-line"> trailingCall,</td>
+ </tr>
+ <tr>
+ <td id="L9295" class="blob-num js-line-number" data-line-number="9295"></td>
+ <td id="LC9295" class="blob-code blob-code-inner js-file-line"> lastCalled <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9296" class="blob-num js-line-number" data-line-number="9296"></td>
+ <td id="LC9296" class="blob-code blob-code-inner js-file-line"> maxWait <span class="pl-k">=</span> <span class="pl-c1">false</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9297" class="blob-num js-line-number" data-line-number="9297"></td>
+ <td id="LC9297" class="blob-code blob-code-inner js-file-line"> trailing <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9298" class="blob-num js-line-number" data-line-number="9298"></td>
+ <td id="LC9298" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9299" class="blob-num js-line-number" data-line-number="9299"></td>
+ <td id="LC9299" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9300" class="blob-num js-line-number" data-line-number="9300"></td>
+ <td id="LC9300" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9301" class="blob-num js-line-number" data-line-number="9301"></td>
+ <td id="LC9301" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9302" class="blob-num js-line-number" data-line-number="9302"></td>
+ <td id="LC9302" class="blob-code blob-code-inner js-file-line"> wait <span class="pl-k">=</span> <span class="pl-en">nativeMax</span>(<span class="pl-c1">0</span>, wait) <span class="pl-k">||</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9303" class="blob-num js-line-number" data-line-number="9303"></td>
+ <td id="LC9303" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (options <span class="pl-k">===</span> <span class="pl-c1">true</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9304" class="blob-num js-line-number" data-line-number="9304"></td>
+ <td id="LC9304" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> leading <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9305" class="blob-num js-line-number" data-line-number="9305"></td>
+ <td id="LC9305" class="blob-code blob-code-inner js-file-line"> trailing <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9306" class="blob-num js-line-number" data-line-number="9306"></td>
+ <td id="LC9306" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-en">isObject</span>(options)) {</td>
+ </tr>
+ <tr>
+ <td id="L9307" class="blob-num js-line-number" data-line-number="9307"></td>
+ <td id="LC9307" class="blob-code blob-code-inner js-file-line"> leading <span class="pl-k">=</span> <span class="pl-smi">options</span>.<span class="pl-smi">leading</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9308" class="blob-num js-line-number" data-line-number="9308"></td>
+ <td id="LC9308" class="blob-code blob-code-inner js-file-line"> maxWait <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>maxWait<span class="pl-pds">'</span></span> <span class="pl-k">in</span> options <span class="pl-k">&&</span> (<span class="pl-en">nativeMax</span>(wait, <span class="pl-smi">options</span>.<span class="pl-smi">maxWait</span>) <span class="pl-k">||</span> <span class="pl-c1">0</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9309" class="blob-num js-line-number" data-line-number="9309"></td>
+ <td id="LC9309" class="blob-code blob-code-inner js-file-line"> trailing <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>trailing<span class="pl-pds">'</span></span> <span class="pl-k">in</span> options <span class="pl-k">?</span> <span class="pl-smi">options</span>.<span class="pl-smi">trailing</span> <span class="pl-k">:</span> trailing;</td>
+ </tr>
+ <tr>
+ <td id="L9310" class="blob-num js-line-number" data-line-number="9310"></td>
+ <td id="LC9310" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9311" class="blob-num js-line-number" data-line-number="9311"></td>
+ <td id="LC9311" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">delayed</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9312" class="blob-num js-line-number" data-line-number="9312"></td>
+ <td id="LC9312" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> remaining <span class="pl-k">=</span> wait <span class="pl-k">-</span> (<span class="pl-en">now</span>() <span class="pl-k">-</span> stamp);</td>
+ </tr>
+ <tr>
+ <td id="L9313" class="blob-num js-line-number" data-line-number="9313"></td>
+ <td id="LC9313" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (remaining <span class="pl-k"><=</span> <span class="pl-c1">0</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9314" class="blob-num js-line-number" data-line-number="9314"></td>
+ <td id="LC9314" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (maxTimeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9315" class="blob-num js-line-number" data-line-number="9315"></td>
+ <td id="LC9315" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">clearTimeout</span>(maxTimeoutId);</td>
+ </tr>
+ <tr>
+ <td id="L9316" class="blob-num js-line-number" data-line-number="9316"></td>
+ <td id="LC9316" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9317" class="blob-num js-line-number" data-line-number="9317"></td>
+ <td id="LC9317" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isCalled <span class="pl-k">=</span> trailingCall;</td>
+ </tr>
+ <tr>
+ <td id="L9318" class="blob-num js-line-number" data-line-number="9318"></td>
+ <td id="LC9318" class="blob-code blob-code-inner js-file-line"> maxTimeoutId <span class="pl-k">=</span> timeoutId <span class="pl-k">=</span> trailingCall <span class="pl-k">=</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9319" class="blob-num js-line-number" data-line-number="9319"></td>
+ <td id="LC9319" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isCalled) {</td>
+ </tr>
+ <tr>
+ <td id="L9320" class="blob-num js-line-number" data-line-number="9320"></td>
+ <td id="LC9320" class="blob-code blob-code-inner js-file-line"> lastCalled <span class="pl-k">=</span> <span class="pl-en">now</span>();</td>
+ </tr>
+ <tr>
+ <td id="L9321" class="blob-num js-line-number" data-line-number="9321"></td>
+ <td id="LC9321" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisArg, args);</td>
+ </tr>
+ <tr>
+ <td id="L9322" class="blob-num js-line-number" data-line-number="9322"></td>
+ <td id="LC9322" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>timeoutId <span class="pl-k">&&</span> <span class="pl-k">!</span>maxTimeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9323" class="blob-num js-line-number" data-line-number="9323"></td>
+ <td id="LC9323" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> thisArg <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9324" class="blob-num js-line-number" data-line-number="9324"></td>
+ <td id="LC9324" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9325" class="blob-num js-line-number" data-line-number="9325"></td>
+ <td id="LC9325" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9326" class="blob-num js-line-number" data-line-number="9326"></td>
+ <td id="LC9326" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L9327" class="blob-num js-line-number" data-line-number="9327"></td>
+ <td id="LC9327" class="blob-code blob-code-inner js-file-line"> timeoutId <span class="pl-k">=</span> <span class="pl-c1">setTimeout</span>(delayed, remaining);</td>
+ </tr>
+ <tr>
+ <td id="L9328" class="blob-num js-line-number" data-line-number="9328"></td>
+ <td id="LC9328" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9329" class="blob-num js-line-number" data-line-number="9329"></td>
+ <td id="LC9329" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9330" class="blob-num js-line-number" data-line-number="9330"></td>
+ <td id="LC9330" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9331" class="blob-num js-line-number" data-line-number="9331"></td>
+ <td id="LC9331" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">maxDelayed</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9332" class="blob-num js-line-number" data-line-number="9332"></td>
+ <td id="LC9332" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (timeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9333" class="blob-num js-line-number" data-line-number="9333"></td>
+ <td id="LC9333" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">clearTimeout</span>(timeoutId);</td>
+ </tr>
+ <tr>
+ <td id="L9334" class="blob-num js-line-number" data-line-number="9334"></td>
+ <td id="LC9334" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9335" class="blob-num js-line-number" data-line-number="9335"></td>
+ <td id="LC9335" class="blob-code blob-code-inner js-file-line"> maxTimeoutId <span class="pl-k">=</span> timeoutId <span class="pl-k">=</span> trailingCall <span class="pl-k">=</span> <span class="pl-c1">undefined</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9336" class="blob-num js-line-number" data-line-number="9336"></td>
+ <td id="LC9336" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (trailing <span class="pl-k">||</span> (maxWait <span class="pl-k">!==</span> wait)) {</td>
+ </tr>
+ <tr>
+ <td id="L9337" class="blob-num js-line-number" data-line-number="9337"></td>
+ <td id="LC9337" class="blob-code blob-code-inner js-file-line"> lastCalled <span class="pl-k">=</span> <span class="pl-en">now</span>();</td>
+ </tr>
+ <tr>
+ <td id="L9338" class="blob-num js-line-number" data-line-number="9338"></td>
+ <td id="LC9338" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisArg, args);</td>
+ </tr>
+ <tr>
+ <td id="L9339" class="blob-num js-line-number" data-line-number="9339"></td>
+ <td id="LC9339" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>timeoutId <span class="pl-k">&&</span> <span class="pl-k">!</span>maxTimeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9340" class="blob-num js-line-number" data-line-number="9340"></td>
+ <td id="LC9340" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> thisArg <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9341" class="blob-num js-line-number" data-line-number="9341"></td>
+ <td id="LC9341" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9342" class="blob-num js-line-number" data-line-number="9342"></td>
+ <td id="LC9342" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9343" class="blob-num js-line-number" data-line-number="9343"></td>
+ <td id="LC9343" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9344" class="blob-num js-line-number" data-line-number="9344"></td>
+ <td id="LC9344" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9345" class="blob-num js-line-number" data-line-number="9345"></td>
+ <td id="LC9345" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9346" class="blob-num js-line-number" data-line-number="9346"></td>
+ <td id="LC9346" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> <span class="pl-v">arguments</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9347" class="blob-num js-line-number" data-line-number="9347"></td>
+ <td id="LC9347" class="blob-code blob-code-inner js-file-line"> stamp <span class="pl-k">=</span> <span class="pl-en">now</span>();</td>
+ </tr>
+ <tr>
+ <td id="L9348" class="blob-num js-line-number" data-line-number="9348"></td>
+ <td id="LC9348" class="blob-code blob-code-inner js-file-line"> thisArg <span class="pl-k">=</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9349" class="blob-num js-line-number" data-line-number="9349"></td>
+ <td id="LC9349" class="blob-code blob-code-inner js-file-line"> trailingCall <span class="pl-k">=</span> trailing <span class="pl-k">&&</span> (timeoutId <span class="pl-k">||</span> <span class="pl-k">!</span>leading);</td>
+ </tr>
+ <tr>
+ <td id="L9350" class="blob-num js-line-number" data-line-number="9350"></td>
+ <td id="LC9350" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9351" class="blob-num js-line-number" data-line-number="9351"></td>
+ <td id="LC9351" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (maxWait <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9352" class="blob-num js-line-number" data-line-number="9352"></td>
+ <td id="LC9352" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> leadingCall <span class="pl-k">=</span> leading <span class="pl-k">&&</span> <span class="pl-k">!</span>timeoutId;</td>
+ </tr>
+ <tr>
+ <td id="L9353" class="blob-num js-line-number" data-line-number="9353"></td>
+ <td id="LC9353" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L9354" class="blob-num js-line-number" data-line-number="9354"></td>
+ <td id="LC9354" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>maxTimeoutId <span class="pl-k">&&</span> <span class="pl-k">!</span>leading) {</td>
+ </tr>
+ <tr>
+ <td id="L9355" class="blob-num js-line-number" data-line-number="9355"></td>
+ <td id="LC9355" class="blob-code blob-code-inner js-file-line"> lastCalled <span class="pl-k">=</span> stamp;</td>
+ </tr>
+ <tr>
+ <td id="L9356" class="blob-num js-line-number" data-line-number="9356"></td>
+ <td id="LC9356" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9357" class="blob-num js-line-number" data-line-number="9357"></td>
+ <td id="LC9357" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> remaining <span class="pl-k">=</span> maxWait <span class="pl-k">-</span> (stamp <span class="pl-k">-</span> lastCalled),</td>
+ </tr>
+ <tr>
+ <td id="L9358" class="blob-num js-line-number" data-line-number="9358"></td>
+ <td id="LC9358" class="blob-code blob-code-inner js-file-line"> isCalled <span class="pl-k">=</span> remaining <span class="pl-k"><=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9359" class="blob-num js-line-number" data-line-number="9359"></td>
+ <td id="LC9359" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9360" class="blob-num js-line-number" data-line-number="9360"></td>
+ <td id="LC9360" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isCalled) {</td>
+ </tr>
+ <tr>
+ <td id="L9361" class="blob-num js-line-number" data-line-number="9361"></td>
+ <td id="LC9361" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (maxTimeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9362" class="blob-num js-line-number" data-line-number="9362"></td>
+ <td id="LC9362" class="blob-code blob-code-inner js-file-line"> maxTimeoutId <span class="pl-k">=</span> <span class="pl-c1">clearTimeout</span>(maxTimeoutId);</td>
+ </tr>
+ <tr>
+ <td id="L9363" class="blob-num js-line-number" data-line-number="9363"></td>
+ <td id="LC9363" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9364" class="blob-num js-line-number" data-line-number="9364"></td>
+ <td id="LC9364" class="blob-code blob-code-inner js-file-line"> lastCalled <span class="pl-k">=</span> stamp;</td>
+ </tr>
+ <tr>
+ <td id="L9365" class="blob-num js-line-number" data-line-number="9365"></td>
+ <td id="LC9365" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisArg, args);</td>
+ </tr>
+ <tr>
+ <td id="L9366" class="blob-num js-line-number" data-line-number="9366"></td>
+ <td id="LC9366" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9367" class="blob-num js-line-number" data-line-number="9367"></td>
+ <td id="LC9367" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-k">!</span>maxTimeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9368" class="blob-num js-line-number" data-line-number="9368"></td>
+ <td id="LC9368" class="blob-code blob-code-inner js-file-line"> maxTimeoutId <span class="pl-k">=</span> <span class="pl-c1">setTimeout</span>(maxDelayed, remaining);</td>
+ </tr>
+ <tr>
+ <td id="L9369" class="blob-num js-line-number" data-line-number="9369"></td>
+ <td id="LC9369" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9370" class="blob-num js-line-number" data-line-number="9370"></td>
+ <td id="LC9370" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9371" class="blob-num js-line-number" data-line-number="9371"></td>
+ <td id="LC9371" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isCalled <span class="pl-k">&&</span> timeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9372" class="blob-num js-line-number" data-line-number="9372"></td>
+ <td id="LC9372" class="blob-code blob-code-inner js-file-line"> timeoutId <span class="pl-k">=</span> <span class="pl-c1">clearTimeout</span>(timeoutId);</td>
+ </tr>
+ <tr>
+ <td id="L9373" class="blob-num js-line-number" data-line-number="9373"></td>
+ <td id="LC9373" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9374" class="blob-num js-line-number" data-line-number="9374"></td>
+ <td id="LC9374" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-k">!</span>timeoutId <span class="pl-k">&&</span> wait <span class="pl-k">!==</span> maxWait) {</td>
+ </tr>
+ <tr>
+ <td id="L9375" class="blob-num js-line-number" data-line-number="9375"></td>
+ <td id="LC9375" class="blob-code blob-code-inner js-file-line"> timeoutId <span class="pl-k">=</span> <span class="pl-c1">setTimeout</span>(delayed, wait);</td>
+ </tr>
+ <tr>
+ <td id="L9376" class="blob-num js-line-number" data-line-number="9376"></td>
+ <td id="LC9376" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9377" class="blob-num js-line-number" data-line-number="9377"></td>
+ <td id="LC9377" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (leadingCall) {</td>
+ </tr>
+ <tr>
+ <td id="L9378" class="blob-num js-line-number" data-line-number="9378"></td>
+ <td id="LC9378" class="blob-code blob-code-inner js-file-line"> isCalled <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9379" class="blob-num js-line-number" data-line-number="9379"></td>
+ <td id="LC9379" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(thisArg, args);</td>
+ </tr>
+ <tr>
+ <td id="L9380" class="blob-num js-line-number" data-line-number="9380"></td>
+ <td id="LC9380" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9381" class="blob-num js-line-number" data-line-number="9381"></td>
+ <td id="LC9381" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isCalled <span class="pl-k">&&</span> <span class="pl-k">!</span>timeoutId <span class="pl-k">&&</span> <span class="pl-k">!</span>maxTimeoutId) {</td>
+ </tr>
+ <tr>
+ <td id="L9382" class="blob-num js-line-number" data-line-number="9382"></td>
+ <td id="LC9382" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> thisArg <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9383" class="blob-num js-line-number" data-line-number="9383"></td>
+ <td id="LC9383" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9384" class="blob-num js-line-number" data-line-number="9384"></td>
+ <td id="LC9384" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L9385" class="blob-num js-line-number" data-line-number="9385"></td>
+ <td id="LC9385" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9386" class="blob-num js-line-number" data-line-number="9386"></td>
+ <td id="LC9386" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9387" class="blob-num js-line-number" data-line-number="9387"></td>
+ <td id="LC9387" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9388" class="blob-num js-line-number" data-line-number="9388"></td>
+ <td id="LC9388" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9389" class="blob-num js-line-number" data-line-number="9389"></td>
+ <td id="LC9389" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Defers executing the `func` function until the current call stack has cleared.</span></td>
+ </tr>
+ <tr>
+ <td id="L9390" class="blob-num js-line-number" data-line-number="9390"></td>
+ <td id="LC9390" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Additional arguments will be provided to `func` when it is invoked.</span></td>
+ </tr>
+ <tr>
+ <td id="L9391" class="blob-num js-line-number" data-line-number="9391"></td>
+ <td id="LC9391" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9392" class="blob-num js-line-number" data-line-number="9392"></td>
+ <td id="LC9392" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9393" class="blob-num js-line-number" data-line-number="9393"></td>
+ <td id="LC9393" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9394" class="blob-num js-line-number" data-line-number="9394"></td>
+ <td id="LC9394" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9395" class="blob-num js-line-number" data-line-number="9395"></td>
+ <td id="LC9395" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to defer.</span></td>
+ </tr>
+ <tr>
+ <td id="L9396" class="blob-num js-line-number" data-line-number="9396"></td>
+ <td id="LC9396" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to invoke the function with.</span></td>
+ </tr>
+ <tr>
+ <td id="L9397" class="blob-num js-line-number" data-line-number="9397"></td>
+ <td id="LC9397" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the timer id.</span></td>
+ </tr>
+ <tr>
+ <td id="L9398" class="blob-num js-line-number" data-line-number="9398"></td>
+ <td id="LC9398" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9399" class="blob-num js-line-number" data-line-number="9399"></td>
+ <td id="LC9399" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9400" class="blob-num js-line-number" data-line-number="9400"></td>
+ <td id="LC9400" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.defer(function(text) { console.log(text); }, 'deferred');</span></td>
+ </tr>
+ <tr>
+ <td id="L9401" class="blob-num js-line-number" data-line-number="9401"></td>
+ <td id="LC9401" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // logs 'deferred' after one or more milliseconds</span></td>
+ </tr>
+ <tr>
+ <td id="L9402" class="blob-num js-line-number" data-line-number="9402"></td>
+ <td id="LC9402" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9403" class="blob-num js-line-number" data-line-number="9403"></td>
+ <td id="LC9403" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">defer</span>(<span class="pl-smi">func</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9404" class="blob-num js-line-number" data-line-number="9404"></td>
+ <td id="LC9404" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9405" class="blob-num js-line-number" data-line-number="9405"></td>
+ <td id="LC9405" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9406" class="blob-num js-line-number" data-line-number="9406"></td>
+ <td id="LC9406" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9407" class="blob-num js-line-number" data-line-number="9407"></td>
+ <td id="LC9407" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9408" class="blob-num js-line-number" data-line-number="9408"></td>
+ <td id="LC9408" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">setTimeout</span>(<span class="pl-k">function</span>() { <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-c1">undefined</span>, args); }, <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9409" class="blob-num js-line-number" data-line-number="9409"></td>
+ <td id="LC9409" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9410" class="blob-num js-line-number" data-line-number="9410"></td>
+ <td id="LC9410" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9411" class="blob-num js-line-number" data-line-number="9411"></td>
+ <td id="LC9411" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9412" class="blob-num js-line-number" data-line-number="9412"></td>
+ <td id="LC9412" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Executes the `func` function after `wait` milliseconds. Additional arguments</span></td>
+ </tr>
+ <tr>
+ <td id="L9413" class="blob-num js-line-number" data-line-number="9413"></td>
+ <td id="LC9413" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * will be provided to `func` when it is invoked.</span></td>
+ </tr>
+ <tr>
+ <td id="L9414" class="blob-num js-line-number" data-line-number="9414"></td>
+ <td id="LC9414" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9415" class="blob-num js-line-number" data-line-number="9415"></td>
+ <td id="LC9415" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9416" class="blob-num js-line-number" data-line-number="9416"></td>
+ <td id="LC9416" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9417" class="blob-num js-line-number" data-line-number="9417"></td>
+ <td id="LC9417" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9418" class="blob-num js-line-number" data-line-number="9418"></td>
+ <td id="LC9418" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to delay.</span></td>
+ </tr>
+ <tr>
+ <td id="L9419" class="blob-num js-line-number" data-line-number="9419"></td>
+ <td id="LC9419" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">wait</span> The number of milliseconds to delay execution.</span></td>
+ </tr>
+ <tr>
+ <td id="L9420" class="blob-num js-line-number" data-line-number="9420"></td>
+ <td id="LC9420" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to invoke the function with.</span></td>
+ </tr>
+ <tr>
+ <td id="L9421" class="blob-num js-line-number" data-line-number="9421"></td>
+ <td id="LC9421" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the timer id.</span></td>
+ </tr>
+ <tr>
+ <td id="L9422" class="blob-num js-line-number" data-line-number="9422"></td>
+ <td id="LC9422" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9423" class="blob-num js-line-number" data-line-number="9423"></td>
+ <td id="LC9423" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9424" class="blob-num js-line-number" data-line-number="9424"></td>
+ <td id="LC9424" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.delay(function(text) { console.log(text); }, 1000, 'later');</span></td>
+ </tr>
+ <tr>
+ <td id="L9425" class="blob-num js-line-number" data-line-number="9425"></td>
+ <td id="LC9425" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs 'later' after one second</span></td>
+ </tr>
+ <tr>
+ <td id="L9426" class="blob-num js-line-number" data-line-number="9426"></td>
+ <td id="LC9426" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9427" class="blob-num js-line-number" data-line-number="9427"></td>
+ <td id="LC9427" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">delay</span>(<span class="pl-smi">func</span>, <span class="pl-smi">wait</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9428" class="blob-num js-line-number" data-line-number="9428"></td>
+ <td id="LC9428" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9429" class="blob-num js-line-number" data-line-number="9429"></td>
+ <td id="LC9429" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9430" class="blob-num js-line-number" data-line-number="9430"></td>
+ <td id="LC9430" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9431" class="blob-num js-line-number" data-line-number="9431"></td>
+ <td id="LC9431" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> args <span class="pl-k">=</span> <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">2</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9432" class="blob-num js-line-number" data-line-number="9432"></td>
+ <td id="LC9432" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">setTimeout</span>(<span class="pl-k">function</span>() { <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-c1">undefined</span>, args); }, wait);</td>
+ </tr>
+ <tr>
+ <td id="L9433" class="blob-num js-line-number" data-line-number="9433"></td>
+ <td id="LC9433" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9434" class="blob-num js-line-number" data-line-number="9434"></td>
+ <td id="LC9434" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9435" class="blob-num js-line-number" data-line-number="9435"></td>
+ <td id="LC9435" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9436" class="blob-num js-line-number" data-line-number="9436"></td>
+ <td id="LC9436" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that memoizes the result of `func`. If `resolver` is</span></td>
+ </tr>
+ <tr>
+ <td id="L9437" class="blob-num js-line-number" data-line-number="9437"></td>
+ <td id="LC9437" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * provided it will be used to determine the cache key for storing the result</span></td>
+ </tr>
+ <tr>
+ <td id="L9438" class="blob-num js-line-number" data-line-number="9438"></td>
+ <td id="LC9438" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * based on the arguments provided to the memoized function. By default, the</span></td>
+ </tr>
+ <tr>
+ <td id="L9439" class="blob-num js-line-number" data-line-number="9439"></td>
+ <td id="LC9439" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * first argument provided to the memoized function is used as the cache key.</span></td>
+ </tr>
+ <tr>
+ <td id="L9440" class="blob-num js-line-number" data-line-number="9440"></td>
+ <td id="LC9440" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The `func` is executed with the `this` binding of the memoized function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9441" class="blob-num js-line-number" data-line-number="9441"></td>
+ <td id="LC9441" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The result cache is exposed as the `cache` property on the memoized function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9442" class="blob-num js-line-number" data-line-number="9442"></td>
+ <td id="LC9442" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9443" class="blob-num js-line-number" data-line-number="9443"></td>
+ <td id="LC9443" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9444" class="blob-num js-line-number" data-line-number="9444"></td>
+ <td id="LC9444" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9445" class="blob-num js-line-number" data-line-number="9445"></td>
+ <td id="LC9445" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9446" class="blob-num js-line-number" data-line-number="9446"></td>
+ <td id="LC9446" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to have its output memoized.</span></td>
+ </tr>
+ <tr>
+ <td id="L9447" class="blob-num js-line-number" data-line-number="9447"></td>
+ <td id="LC9447" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function} [resolver] A function used to resolve the cache key.</span></td>
+ </tr>
+ <tr>
+ <td id="L9448" class="blob-num js-line-number" data-line-number="9448"></td>
+ <td id="LC9448" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new memoizing function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9449" class="blob-num js-line-number" data-line-number="9449"></td>
+ <td id="LC9449" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9450" class="blob-num js-line-number" data-line-number="9450"></td>
+ <td id="LC9450" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9451" class="blob-num js-line-number" data-line-number="9451"></td>
+ <td id="LC9451" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var fibonacci = _.memoize(function(n) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9452" class="blob-num js-line-number" data-line-number="9452"></td>
+ <td id="LC9452" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);</span></td>
+ </tr>
+ <tr>
+ <td id="L9453" class="blob-num js-line-number" data-line-number="9453"></td>
+ <td id="LC9453" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9454" class="blob-num js-line-number" data-line-number="9454"></td>
+ <td id="LC9454" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9455" class="blob-num js-line-number" data-line-number="9455"></td>
+ <td id="LC9455" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * fibonacci(9)</span></td>
+ </tr>
+ <tr>
+ <td id="L9456" class="blob-num js-line-number" data-line-number="9456"></td>
+ <td id="LC9456" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 34</span></td>
+ </tr>
+ <tr>
+ <td id="L9457" class="blob-num js-line-number" data-line-number="9457"></td>
+ <td id="LC9457" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9458" class="blob-num js-line-number" data-line-number="9458"></td>
+ <td id="LC9458" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var data = {</span></td>
+ </tr>
+ <tr>
+ <td id="L9459" class="blob-num js-line-number" data-line-number="9459"></td>
+ <td id="LC9459" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'fred': { 'name': 'fred', 'age': 40 },</span></td>
+ </tr>
+ <tr>
+ <td id="L9460" class="blob-num js-line-number" data-line-number="9460"></td>
+ <td id="LC9460" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'pebbles': { 'name': 'pebbles', 'age': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L9461" class="blob-num js-line-number" data-line-number="9461"></td>
+ <td id="LC9461" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9462" class="blob-num js-line-number" data-line-number="9462"></td>
+ <td id="LC9462" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9463" class="blob-num js-line-number" data-line-number="9463"></td>
+ <td id="LC9463" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // modifying the result cache</span></td>
+ </tr>
+ <tr>
+ <td id="L9464" class="blob-num js-line-number" data-line-number="9464"></td>
+ <td id="LC9464" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var get = _.memoize(function(name) { return data[name]; }, _.identity);</span></td>
+ </tr>
+ <tr>
+ <td id="L9465" class="blob-num js-line-number" data-line-number="9465"></td>
+ <td id="LC9465" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * get('pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L9466" class="blob-num js-line-number" data-line-number="9466"></td>
+ <td id="LC9466" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'pebbles', 'age': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L9467" class="blob-num js-line-number" data-line-number="9467"></td>
+ <td id="LC9467" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9468" class="blob-num js-line-number" data-line-number="9468"></td>
+ <td id="LC9468" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * get.cache.pebbles.name = 'penelope';</span></td>
+ </tr>
+ <tr>
+ <td id="L9469" class="blob-num js-line-number" data-line-number="9469"></td>
+ <td id="LC9469" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * get('pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L9470" class="blob-num js-line-number" data-line-number="9470"></td>
+ <td id="LC9470" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'penelope', 'age': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L9471" class="blob-num js-line-number" data-line-number="9471"></td>
+ <td id="LC9471" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9472" class="blob-num js-line-number" data-line-number="9472"></td>
+ <td id="LC9472" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">memoize</span>(<span class="pl-smi">func</span>, <span class="pl-smi">resolver</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9473" class="blob-num js-line-number" data-line-number="9473"></td>
+ <td id="LC9473" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9474" class="blob-num js-line-number" data-line-number="9474"></td>
+ <td id="LC9474" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9475" class="blob-num js-line-number" data-line-number="9475"></td>
+ <td id="LC9475" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9476" class="blob-num js-line-number" data-line-number="9476"></td>
+ <td id="LC9476" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> <span class="pl-en">memoized</span> <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9477" class="blob-num js-line-number" data-line-number="9477"></td>
+ <td id="LC9477" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> cache <span class="pl-k">=</span> <span class="pl-smi">memoized</span>.<span class="pl-smi">cache</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9478" class="blob-num js-line-number" data-line-number="9478"></td>
+ <td id="LC9478" class="blob-code blob-code-inner js-file-line"> key <span class="pl-k">=</span> resolver <span class="pl-k">?</span> <span class="pl-smi">resolver</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>, <span class="pl-v">arguments</span>) <span class="pl-k">:</span> keyPrefix <span class="pl-k">+</span> <span class="pl-v">arguments</span>[<span class="pl-c1">0</span>];</td>
+ </tr>
+ <tr>
+ <td id="L9479" class="blob-num js-line-number" data-line-number="9479"></td>
+ <td id="LC9479" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9480" class="blob-num js-line-number" data-line-number="9480"></td>
+ <td id="LC9480" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-smi">hasOwnProperty</span>.<span class="pl-c1">call</span>(cache, key)</td>
+ </tr>
+ <tr>
+ <td id="L9481" class="blob-num js-line-number" data-line-number="9481"></td>
+ <td id="LC9481" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> cache[key]</td>
+ </tr>
+ <tr>
+ <td id="L9482" class="blob-num js-line-number" data-line-number="9482"></td>
+ <td id="LC9482" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> (cache[key] <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>, <span class="pl-v">arguments</span>));</td>
+ </tr>
+ <tr>
+ <td id="L9483" class="blob-num js-line-number" data-line-number="9483"></td>
+ <td id="LC9483" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9484" class="blob-num js-line-number" data-line-number="9484"></td>
+ <td id="LC9484" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">memoized</span>.<span class="pl-smi">cache</span> <span class="pl-k">=</span> {};</td>
+ </tr>
+ <tr>
+ <td id="L9485" class="blob-num js-line-number" data-line-number="9485"></td>
+ <td id="LC9485" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> memoized;</td>
+ </tr>
+ <tr>
+ <td id="L9486" class="blob-num js-line-number" data-line-number="9486"></td>
+ <td id="LC9486" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9487" class="blob-num js-line-number" data-line-number="9487"></td>
+ <td id="LC9487" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9488" class="blob-num js-line-number" data-line-number="9488"></td>
+ <td id="LC9488" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9489" class="blob-num js-line-number" data-line-number="9489"></td>
+ <td id="LC9489" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that is restricted to execute `func` once. Repeat calls to</span></td>
+ </tr>
+ <tr>
+ <td id="L9490" class="blob-num js-line-number" data-line-number="9490"></td>
+ <td id="LC9490" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the function will return the value of the first call. The `func` is executed</span></td>
+ </tr>
+ <tr>
+ <td id="L9491" class="blob-num js-line-number" data-line-number="9491"></td>
+ <td id="LC9491" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * with the `this` binding of the created function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9492" class="blob-num js-line-number" data-line-number="9492"></td>
+ <td id="LC9492" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9493" class="blob-num js-line-number" data-line-number="9493"></td>
+ <td id="LC9493" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9494" class="blob-num js-line-number" data-line-number="9494"></td>
+ <td id="LC9494" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9495" class="blob-num js-line-number" data-line-number="9495"></td>
+ <td id="LC9495" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9496" class="blob-num js-line-number" data-line-number="9496"></td>
+ <td id="LC9496" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to restrict.</span></td>
+ </tr>
+ <tr>
+ <td id="L9497" class="blob-num js-line-number" data-line-number="9497"></td>
+ <td id="LC9497" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new restricted function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9498" class="blob-num js-line-number" data-line-number="9498"></td>
+ <td id="LC9498" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9499" class="blob-num js-line-number" data-line-number="9499"></td>
+ <td id="LC9499" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9500" class="blob-num js-line-number" data-line-number="9500"></td>
+ <td id="LC9500" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var initialize = _.once(createApplication);</span></td>
+ </tr>
+ <tr>
+ <td id="L9501" class="blob-num js-line-number" data-line-number="9501"></td>
+ <td id="LC9501" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * initialize();</span></td>
+ </tr>
+ <tr>
+ <td id="L9502" class="blob-num js-line-number" data-line-number="9502"></td>
+ <td id="LC9502" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * initialize();</span></td>
+ </tr>
+ <tr>
+ <td id="L9503" class="blob-num js-line-number" data-line-number="9503"></td>
+ <td id="LC9503" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // `initialize` executes `createApplication` once</span></td>
+ </tr>
+ <tr>
+ <td id="L9504" class="blob-num js-line-number" data-line-number="9504"></td>
+ <td id="LC9504" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9505" class="blob-num js-line-number" data-line-number="9505"></td>
+ <td id="LC9505" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">once</span>(<span class="pl-smi">func</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9506" class="blob-num js-line-number" data-line-number="9506"></td>
+ <td id="LC9506" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ran,</td>
+ </tr>
+ <tr>
+ <td id="L9507" class="blob-num js-line-number" data-line-number="9507"></td>
+ <td id="LC9507" class="blob-code blob-code-inner js-file-line"> result;</td>
+ </tr>
+ <tr>
+ <td id="L9508" class="blob-num js-line-number" data-line-number="9508"></td>
+ <td id="LC9508" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9509" class="blob-num js-line-number" data-line-number="9509"></td>
+ <td id="LC9509" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9510" class="blob-num js-line-number" data-line-number="9510"></td>
+ <td id="LC9510" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9511" class="blob-num js-line-number" data-line-number="9511"></td>
+ <td id="LC9511" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9512" class="blob-num js-line-number" data-line-number="9512"></td>
+ <td id="LC9512" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9513" class="blob-num js-line-number" data-line-number="9513"></td>
+ <td id="LC9513" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (ran) {</td>
+ </tr>
+ <tr>
+ <td id="L9514" class="blob-num js-line-number" data-line-number="9514"></td>
+ <td id="LC9514" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L9515" class="blob-num js-line-number" data-line-number="9515"></td>
+ <td id="LC9515" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9516" class="blob-num js-line-number" data-line-number="9516"></td>
+ <td id="LC9516" class="blob-code blob-code-inner js-file-line"> ran <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9517" class="blob-num js-line-number" data-line-number="9517"></td>
+ <td id="LC9517" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9518" class="blob-num js-line-number" data-line-number="9518"></td>
+ <td id="LC9518" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9519" class="blob-num js-line-number" data-line-number="9519"></td>
+ <td id="LC9519" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// clear the `func` variable so the function may be garbage collected</span></td>
+ </tr>
+ <tr>
+ <td id="L9520" class="blob-num js-line-number" data-line-number="9520"></td>
+ <td id="LC9520" class="blob-code blob-code-inner js-file-line"> func <span class="pl-k">=</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9521" class="blob-num js-line-number" data-line-number="9521"></td>
+ <td id="LC9521" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L9522" class="blob-num js-line-number" data-line-number="9522"></td>
+ <td id="LC9522" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9523" class="blob-num js-line-number" data-line-number="9523"></td>
+ <td id="LC9523" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9524" class="blob-num js-line-number" data-line-number="9524"></td>
+ <td id="LC9524" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9525" class="blob-num js-line-number" data-line-number="9525"></td>
+ <td id="LC9525" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9526" class="blob-num js-line-number" data-line-number="9526"></td>
+ <td id="LC9526" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that, when called, invokes `func` with any additional</span></td>
+ </tr>
+ <tr>
+ <td id="L9527" class="blob-num js-line-number" data-line-number="9527"></td>
+ <td id="LC9527" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `partial` arguments prepended to those provided to the new function. This</span></td>
+ </tr>
+ <tr>
+ <td id="L9528" class="blob-num js-line-number" data-line-number="9528"></td>
+ <td id="LC9528" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * method is similar to `_.bind` except it does **not** alter the `this` binding.</span></td>
+ </tr>
+ <tr>
+ <td id="L9529" class="blob-num js-line-number" data-line-number="9529"></td>
+ <td id="LC9529" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9530" class="blob-num js-line-number" data-line-number="9530"></td>
+ <td id="LC9530" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9531" class="blob-num js-line-number" data-line-number="9531"></td>
+ <td id="LC9531" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9532" class="blob-num js-line-number" data-line-number="9532"></td>
+ <td id="LC9532" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9533" class="blob-num js-line-number" data-line-number="9533"></td>
+ <td id="LC9533" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to partially apply arguments to.</span></td>
+ </tr>
+ <tr>
+ <td id="L9534" class="blob-num js-line-number" data-line-number="9534"></td>
+ <td id="LC9534" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to be partially applied.</span></td>
+ </tr>
+ <tr>
+ <td id="L9535" class="blob-num js-line-number" data-line-number="9535"></td>
+ <td id="LC9535" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new partially applied function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9536" class="blob-num js-line-number" data-line-number="9536"></td>
+ <td id="LC9536" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9537" class="blob-num js-line-number" data-line-number="9537"></td>
+ <td id="LC9537" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9538" class="blob-num js-line-number" data-line-number="9538"></td>
+ <td id="LC9538" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var greet = function(greeting, name) { return greeting + ' ' + name; };</span></td>
+ </tr>
+ <tr>
+ <td id="L9539" class="blob-num js-line-number" data-line-number="9539"></td>
+ <td id="LC9539" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var hi = _.partial(greet, 'hi');</span></td>
+ </tr>
+ <tr>
+ <td id="L9540" class="blob-num js-line-number" data-line-number="9540"></td>
+ <td id="LC9540" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * hi('fred');</span></td>
+ </tr>
+ <tr>
+ <td id="L9541" class="blob-num js-line-number" data-line-number="9541"></td>
+ <td id="LC9541" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hi fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L9542" class="blob-num js-line-number" data-line-number="9542"></td>
+ <td id="LC9542" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9543" class="blob-num js-line-number" data-line-number="9543"></td>
+ <td id="LC9543" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">partial</span>(<span class="pl-smi">func</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9544" class="blob-num js-line-number" data-line-number="9544"></td>
+ <td id="LC9544" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">createWrapper</span>(func, <span class="pl-c1">16</span>, <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L9545" class="blob-num js-line-number" data-line-number="9545"></td>
+ <td id="LC9545" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9546" class="blob-num js-line-number" data-line-number="9546"></td>
+ <td id="LC9546" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9547" class="blob-num js-line-number" data-line-number="9547"></td>
+ <td id="LC9547" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9548" class="blob-num js-line-number" data-line-number="9548"></td>
+ <td id="LC9548" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method is like `_.partial` except that `partial` arguments are</span></td>
+ </tr>
+ <tr>
+ <td id="L9549" class="blob-num js-line-number" data-line-number="9549"></td>
+ <td id="LC9549" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * appended to those provided to the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9550" class="blob-num js-line-number" data-line-number="9550"></td>
+ <td id="LC9550" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9551" class="blob-num js-line-number" data-line-number="9551"></td>
+ <td id="LC9551" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9552" class="blob-num js-line-number" data-line-number="9552"></td>
+ <td id="LC9552" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9553" class="blob-num js-line-number" data-line-number="9553"></td>
+ <td id="LC9553" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9554" class="blob-num js-line-number" data-line-number="9554"></td>
+ <td id="LC9554" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to partially apply arguments to.</span></td>
+ </tr>
+ <tr>
+ <td id="L9555" class="blob-num js-line-number" data-line-number="9555"></td>
+ <td id="LC9555" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {...*} [arg] Arguments to be partially applied.</span></td>
+ </tr>
+ <tr>
+ <td id="L9556" class="blob-num js-line-number" data-line-number="9556"></td>
+ <td id="LC9556" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new partially applied function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9557" class="blob-num js-line-number" data-line-number="9557"></td>
+ <td id="LC9557" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9558" class="blob-num js-line-number" data-line-number="9558"></td>
+ <td id="LC9558" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9559" class="blob-num js-line-number" data-line-number="9559"></td>
+ <td id="LC9559" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var defaultsDeep = _.partialRight(_.merge, _.defaults);</span></td>
+ </tr>
+ <tr>
+ <td id="L9560" class="blob-num js-line-number" data-line-number="9560"></td>
+ <td id="LC9560" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9561" class="blob-num js-line-number" data-line-number="9561"></td>
+ <td id="LC9561" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var options = {</span></td>
+ </tr>
+ <tr>
+ <td id="L9562" class="blob-num js-line-number" data-line-number="9562"></td>
+ <td id="LC9562" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'variable': 'data',</span></td>
+ </tr>
+ <tr>
+ <td id="L9563" class="blob-num js-line-number" data-line-number="9563"></td>
+ <td id="LC9563" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'imports': { 'jq': $ }</span></td>
+ </tr>
+ <tr>
+ <td id="L9564" class="blob-num js-line-number" data-line-number="9564"></td>
+ <td id="LC9564" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9565" class="blob-num js-line-number" data-line-number="9565"></td>
+ <td id="LC9565" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9566" class="blob-num js-line-number" data-line-number="9566"></td>
+ <td id="LC9566" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * defaultsDeep(options, _.templateSettings);</span></td>
+ </tr>
+ <tr>
+ <td id="L9567" class="blob-num js-line-number" data-line-number="9567"></td>
+ <td id="LC9567" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9568" class="blob-num js-line-number" data-line-number="9568"></td>
+ <td id="LC9568" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * options.variable</span></td>
+ </tr>
+ <tr>
+ <td id="L9569" class="blob-num js-line-number" data-line-number="9569"></td>
+ <td id="LC9569" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'data'</span></td>
+ </tr>
+ <tr>
+ <td id="L9570" class="blob-num js-line-number" data-line-number="9570"></td>
+ <td id="LC9570" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9571" class="blob-num js-line-number" data-line-number="9571"></td>
+ <td id="LC9571" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * options.imports</span></td>
+ </tr>
+ <tr>
+ <td id="L9572" class="blob-num js-line-number" data-line-number="9572"></td>
+ <td id="LC9572" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { '_': _, 'jq': $ }</span></td>
+ </tr>
+ <tr>
+ <td id="L9573" class="blob-num js-line-number" data-line-number="9573"></td>
+ <td id="LC9573" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9574" class="blob-num js-line-number" data-line-number="9574"></td>
+ <td id="LC9574" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">partialRight</span>(<span class="pl-smi">func</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9575" class="blob-num js-line-number" data-line-number="9575"></td>
+ <td id="LC9575" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">createWrapper</span>(func, <span class="pl-c1">32</span>, <span class="pl-c1">null</span>, <span class="pl-en">slice</span>(<span class="pl-v">arguments</span>, <span class="pl-c1">1</span>));</td>
+ </tr>
+ <tr>
+ <td id="L9576" class="blob-num js-line-number" data-line-number="9576"></td>
+ <td id="LC9576" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9577" class="blob-num js-line-number" data-line-number="9577"></td>
+ <td id="LC9577" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9578" class="blob-num js-line-number" data-line-number="9578"></td>
+ <td id="LC9578" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9579" class="blob-num js-line-number" data-line-number="9579"></td>
+ <td id="LC9579" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that, when executed, will only call the `func` function</span></td>
+ </tr>
+ <tr>
+ <td id="L9580" class="blob-num js-line-number" data-line-number="9580"></td>
+ <td id="LC9580" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * at most once per every `wait` milliseconds. Provide an options object to</span></td>
+ </tr>
+ <tr>
+ <td id="L9581" class="blob-num js-line-number" data-line-number="9581"></td>
+ <td id="LC9581" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * indicate that `func` should be invoked on the leading and/or trailing edge</span></td>
+ </tr>
+ <tr>
+ <td id="L9582" class="blob-num js-line-number" data-line-number="9582"></td>
+ <td id="LC9582" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of the `wait` timeout. Subsequent calls to the throttled function will</span></td>
+ </tr>
+ <tr>
+ <td id="L9583" class="blob-num js-line-number" data-line-number="9583"></td>
+ <td id="LC9583" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return the result of the last `func` call.</span></td>
+ </tr>
+ <tr>
+ <td id="L9584" class="blob-num js-line-number" data-line-number="9584"></td>
+ <td id="LC9584" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9585" class="blob-num js-line-number" data-line-number="9585"></td>
+ <td id="LC9585" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: If `leading` and `trailing` options are `true` `func` will be called</span></td>
+ </tr>
+ <tr>
+ <td id="L9586" class="blob-num js-line-number" data-line-number="9586"></td>
+ <td id="LC9586" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * on the trailing edge of the timeout only if the the throttled function is</span></td>
+ </tr>
+ <tr>
+ <td id="L9587" class="blob-num js-line-number" data-line-number="9587"></td>
+ <td id="LC9587" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * invoked more than once during the `wait` timeout.</span></td>
+ </tr>
+ <tr>
+ <td id="L9588" class="blob-num js-line-number" data-line-number="9588"></td>
+ <td id="LC9588" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9589" class="blob-num js-line-number" data-line-number="9589"></td>
+ <td id="LC9589" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9590" class="blob-num js-line-number" data-line-number="9590"></td>
+ <td id="LC9590" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9591" class="blob-num js-line-number" data-line-number="9591"></td>
+ <td id="LC9591" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9592" class="blob-num js-line-number" data-line-number="9592"></td>
+ <td id="LC9592" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">func</span> The function to throttle.</span></td>
+ </tr>
+ <tr>
+ <td id="L9593" class="blob-num js-line-number" data-line-number="9593"></td>
+ <td id="LC9593" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">wait</span> The number of milliseconds to throttle executions to.</span></td>
+ </tr>
+ <tr>
+ <td id="L9594" class="blob-num js-line-number" data-line-number="9594"></td>
+ <td id="LC9594" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [options] The options object.</span></td>
+ </tr>
+ <tr>
+ <td id="L9595" class="blob-num js-line-number" data-line-number="9595"></td>
+ <td id="LC9595" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [options.leading=true] Specify execution on the leading edge of the timeout.</span></td>
+ </tr>
+ <tr>
+ <td id="L9596" class="blob-num js-line-number" data-line-number="9596"></td>
+ <td id="LC9596" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.</span></td>
+ </tr>
+ <tr>
+ <td id="L9597" class="blob-num js-line-number" data-line-number="9597"></td>
+ <td id="LC9597" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new throttled function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9598" class="blob-num js-line-number" data-line-number="9598"></td>
+ <td id="LC9598" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9599" class="blob-num js-line-number" data-line-number="9599"></td>
+ <td id="LC9599" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9600" class="blob-num js-line-number" data-line-number="9600"></td>
+ <td id="LC9600" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // avoid excessively updating the position while scrolling</span></td>
+ </tr>
+ <tr>
+ <td id="L9601" class="blob-num js-line-number" data-line-number="9601"></td>
+ <td id="LC9601" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var throttled = _.throttle(updatePosition, 100);</span></td>
+ </tr>
+ <tr>
+ <td id="L9602" class="blob-num js-line-number" data-line-number="9602"></td>
+ <td id="LC9602" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * jQuery(window).on('scroll', throttled);</span></td>
+ </tr>
+ <tr>
+ <td id="L9603" class="blob-num js-line-number" data-line-number="9603"></td>
+ <td id="LC9603" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9604" class="blob-num js-line-number" data-line-number="9604"></td>
+ <td id="LC9604" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes</span></td>
+ </tr>
+ <tr>
+ <td id="L9605" class="blob-num js-line-number" data-line-number="9605"></td>
+ <td id="LC9605" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {</span></td>
+ </tr>
+ <tr>
+ <td id="L9606" class="blob-num js-line-number" data-line-number="9606"></td>
+ <td id="LC9606" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'trailing': false</span></td>
+ </tr>
+ <tr>
+ <td id="L9607" class="blob-num js-line-number" data-line-number="9607"></td>
+ <td id="LC9607" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }));</span></td>
+ </tr>
+ <tr>
+ <td id="L9608" class="blob-num js-line-number" data-line-number="9608"></td>
+ <td id="LC9608" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9609" class="blob-num js-line-number" data-line-number="9609"></td>
+ <td id="LC9609" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">throttle</span>(<span class="pl-smi">func</span>, <span class="pl-smi">wait</span>, <span class="pl-smi">options</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9610" class="blob-num js-line-number" data-line-number="9610"></td>
+ <td id="LC9610" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> leading <span class="pl-k">=</span> <span class="pl-c1">true</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9611" class="blob-num js-line-number" data-line-number="9611"></td>
+ <td id="LC9611" class="blob-code blob-code-inner js-file-line"> trailing <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9612" class="blob-num js-line-number" data-line-number="9612"></td>
+ <td id="LC9612" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9613" class="blob-num js-line-number" data-line-number="9613"></td>
+ <td id="LC9613" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-en">isFunction</span>(func)) {</td>
+ </tr>
+ <tr>
+ <td id="L9614" class="blob-num js-line-number" data-line-number="9614"></td>
+ <td id="LC9614" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> <span class="pl-k">new</span> <span class="pl-en">TypeError</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9615" class="blob-num js-line-number" data-line-number="9615"></td>
+ <td id="LC9615" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9616" class="blob-num js-line-number" data-line-number="9616"></td>
+ <td id="LC9616" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (options <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9617" class="blob-num js-line-number" data-line-number="9617"></td>
+ <td id="LC9617" class="blob-code blob-code-inner js-file-line"> leading <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9618" class="blob-num js-line-number" data-line-number="9618"></td>
+ <td id="LC9618" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-en">isObject</span>(options)) {</td>
+ </tr>
+ <tr>
+ <td id="L9619" class="blob-num js-line-number" data-line-number="9619"></td>
+ <td id="LC9619" class="blob-code blob-code-inner js-file-line"> leading <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>leading<span class="pl-pds">'</span></span> <span class="pl-k">in</span> options <span class="pl-k">?</span> <span class="pl-smi">options</span>.<span class="pl-smi">leading</span> <span class="pl-k">:</span> leading;</td>
+ </tr>
+ <tr>
+ <td id="L9620" class="blob-num js-line-number" data-line-number="9620"></td>
+ <td id="LC9620" class="blob-code blob-code-inner js-file-line"> trailing <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>trailing<span class="pl-pds">'</span></span> <span class="pl-k">in</span> options <span class="pl-k">?</span> <span class="pl-smi">options</span>.<span class="pl-smi">trailing</span> <span class="pl-k">:</span> trailing;</td>
+ </tr>
+ <tr>
+ <td id="L9621" class="blob-num js-line-number" data-line-number="9621"></td>
+ <td id="LC9621" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9622" class="blob-num js-line-number" data-line-number="9622"></td>
+ <td id="LC9622" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">debounceOptions</span>.<span class="pl-smi">leading</span> <span class="pl-k">=</span> leading;</td>
+ </tr>
+ <tr>
+ <td id="L9623" class="blob-num js-line-number" data-line-number="9623"></td>
+ <td id="LC9623" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">debounceOptions</span>.<span class="pl-smi">maxWait</span> <span class="pl-k">=</span> wait;</td>
+ </tr>
+ <tr>
+ <td id="L9624" class="blob-num js-line-number" data-line-number="9624"></td>
+ <td id="LC9624" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">debounceOptions</span>.<span class="pl-smi">trailing</span> <span class="pl-k">=</span> trailing;</td>
+ </tr>
+ <tr>
+ <td id="L9625" class="blob-num js-line-number" data-line-number="9625"></td>
+ <td id="LC9625" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9626" class="blob-num js-line-number" data-line-number="9626"></td>
+ <td id="LC9626" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">debounce</span>(func, wait, debounceOptions);</td>
+ </tr>
+ <tr>
+ <td id="L9627" class="blob-num js-line-number" data-line-number="9627"></td>
+ <td id="LC9627" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9628" class="blob-num js-line-number" data-line-number="9628"></td>
+ <td id="LC9628" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9629" class="blob-num js-line-number" data-line-number="9629"></td>
+ <td id="LC9629" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9630" class="blob-num js-line-number" data-line-number="9630"></td>
+ <td id="LC9630" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that provides `value` to the wrapper function as its</span></td>
+ </tr>
+ <tr>
+ <td id="L9631" class="blob-num js-line-number" data-line-number="9631"></td>
+ <td id="LC9631" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * first argument. Additional arguments provided to the function are appended</span></td>
+ </tr>
+ <tr>
+ <td id="L9632" class="blob-num js-line-number" data-line-number="9632"></td>
+ <td id="LC9632" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * to those provided to the wrapper function. The wrapper is executed with</span></td>
+ </tr>
+ <tr>
+ <td id="L9633" class="blob-num js-line-number" data-line-number="9633"></td>
+ <td id="LC9633" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the `this` binding of the created function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9634" class="blob-num js-line-number" data-line-number="9634"></td>
+ <td id="LC9634" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9635" class="blob-num js-line-number" data-line-number="9635"></td>
+ <td id="LC9635" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9636" class="blob-num js-line-number" data-line-number="9636"></td>
+ <td id="LC9636" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9637" class="blob-num js-line-number" data-line-number="9637"></td>
+ <td id="LC9637" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Functions</span></td>
+ </tr>
+ <tr>
+ <td id="L9638" class="blob-num js-line-number" data-line-number="9638"></td>
+ <td id="LC9638" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to wrap.</span></td>
+ </tr>
+ <tr>
+ <td id="L9639" class="blob-num js-line-number" data-line-number="9639"></td>
+ <td id="LC9639" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">wrapper</span> The wrapper function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9640" class="blob-num js-line-number" data-line-number="9640"></td>
+ <td id="LC9640" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9641" class="blob-num js-line-number" data-line-number="9641"></td>
+ <td id="LC9641" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9642" class="blob-num js-line-number" data-line-number="9642"></td>
+ <td id="LC9642" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9643" class="blob-num js-line-number" data-line-number="9643"></td>
+ <td id="LC9643" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var p = _.wrap(_.escape, function(func, text) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9644" class="blob-num js-line-number" data-line-number="9644"></td>
+ <td id="LC9644" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return '<p>' + func(text) + '</p>';</span></td>
+ </tr>
+ <tr>
+ <td id="L9645" class="blob-num js-line-number" data-line-number="9645"></td>
+ <td id="LC9645" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9646" class="blob-num js-line-number" data-line-number="9646"></td>
+ <td id="LC9646" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9647" class="blob-num js-line-number" data-line-number="9647"></td>
+ <td id="LC9647" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * p('Fred, Wilma, & Pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L9648" class="blob-num js-line-number" data-line-number="9648"></td>
+ <td id="LC9648" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => '<p>Fred, Wilma, & Pebbles</p>'</span></td>
+ </tr>
+ <tr>
+ <td id="L9649" class="blob-num js-line-number" data-line-number="9649"></td>
+ <td id="LC9649" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9650" class="blob-num js-line-number" data-line-number="9650"></td>
+ <td id="LC9650" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">wrap</span>(<span class="pl-smi">value</span>, <span class="pl-smi">wrapper</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9651" class="blob-num js-line-number" data-line-number="9651"></td>
+ <td id="LC9651" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">createWrapper</span>(wrapper, <span class="pl-c1">16</span>, [value]);</td>
+ </tr>
+ <tr>
+ <td id="L9652" class="blob-num js-line-number" data-line-number="9652"></td>
+ <td id="LC9652" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9653" class="blob-num js-line-number" data-line-number="9653"></td>
+ <td id="LC9653" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9654" class="blob-num js-line-number" data-line-number="9654"></td>
+ <td id="LC9654" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L9655" class="blob-num js-line-number" data-line-number="9655"></td>
+ <td id="LC9655" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9656" class="blob-num js-line-number" data-line-number="9656"></td>
+ <td id="LC9656" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9657" class="blob-num js-line-number" data-line-number="9657"></td>
+ <td id="LC9657" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a function that returns `value`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9658" class="blob-num js-line-number" data-line-number="9658"></td>
+ <td id="LC9658" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9659" class="blob-num js-line-number" data-line-number="9659"></td>
+ <td id="LC9659" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9660" class="blob-num js-line-number" data-line-number="9660"></td>
+ <td id="LC9660" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9661" class="blob-num js-line-number" data-line-number="9661"></td>
+ <td id="LC9661" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9662" class="blob-num js-line-number" data-line-number="9662"></td>
+ <td id="LC9662" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to return from the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9663" class="blob-num js-line-number" data-line-number="9663"></td>
+ <td id="LC9663" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9664" class="blob-num js-line-number" data-line-number="9664"></td>
+ <td id="LC9664" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9665" class="blob-num js-line-number" data-line-number="9665"></td>
+ <td id="LC9665" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9666" class="blob-num js-line-number" data-line-number="9666"></td>
+ <td id="LC9666" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = { 'name': 'fred' };</span></td>
+ </tr>
+ <tr>
+ <td id="L9667" class="blob-num js-line-number" data-line-number="9667"></td>
+ <td id="LC9667" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var getter = _.constant(object);</span></td>
+ </tr>
+ <tr>
+ <td id="L9668" class="blob-num js-line-number" data-line-number="9668"></td>
+ <td id="LC9668" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * getter() === object;</span></td>
+ </tr>
+ <tr>
+ <td id="L9669" class="blob-num js-line-number" data-line-number="9669"></td>
+ <td id="LC9669" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L9670" class="blob-num js-line-number" data-line-number="9670"></td>
+ <td id="LC9670" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9671" class="blob-num js-line-number" data-line-number="9671"></td>
+ <td id="LC9671" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">constant</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9672" class="blob-num js-line-number" data-line-number="9672"></td>
+ <td id="LC9672" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9673" class="blob-num js-line-number" data-line-number="9673"></td>
+ <td id="LC9673" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L9674" class="blob-num js-line-number" data-line-number="9674"></td>
+ <td id="LC9674" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9675" class="blob-num js-line-number" data-line-number="9675"></td>
+ <td id="LC9675" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9676" class="blob-num js-line-number" data-line-number="9676"></td>
+ <td id="LC9676" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9677" class="blob-num js-line-number" data-line-number="9677"></td>
+ <td id="LC9677" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9678" class="blob-num js-line-number" data-line-number="9678"></td>
+ <td id="LC9678" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Produces a callback bound to an optional `thisArg`. If `func` is a property</span></td>
+ </tr>
+ <tr>
+ <td id="L9679" class="blob-num js-line-number" data-line-number="9679"></td>
+ <td id="LC9679" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * name the created callback will return the property value for a given element.</span></td>
+ </tr>
+ <tr>
+ <td id="L9680" class="blob-num js-line-number" data-line-number="9680"></td>
+ <td id="LC9680" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If `func` is an object the created callback will return `true` for elements</span></td>
+ </tr>
+ <tr>
+ <td id="L9681" class="blob-num js-line-number" data-line-number="9681"></td>
+ <td id="LC9681" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * that contain the equivalent object properties, otherwise it will return `false`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9682" class="blob-num js-line-number" data-line-number="9682"></td>
+ <td id="LC9682" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9683" class="blob-num js-line-number" data-line-number="9683"></td>
+ <td id="LC9683" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9684" class="blob-num js-line-number" data-line-number="9684"></td>
+ <td id="LC9684" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9685" class="blob-num js-line-number" data-line-number="9685"></td>
+ <td id="LC9685" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9686" class="blob-num js-line-number" data-line-number="9686"></td>
+ <td id="LC9686" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [func=identity] The value to convert to a callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L9687" class="blob-num js-line-number" data-line-number="9687"></td>
+ <td id="LC9687" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of the created callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L9688" class="blob-num js-line-number" data-line-number="9688"></td>
+ <td id="LC9688" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [argCount] The number of arguments the callback accepts.</span></td>
+ </tr>
+ <tr>
+ <td id="L9689" class="blob-num js-line-number" data-line-number="9689"></td>
+ <td id="LC9689" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> a callback function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9690" class="blob-num js-line-number" data-line-number="9690"></td>
+ <td id="LC9690" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9691" class="blob-num js-line-number" data-line-number="9691"></td>
+ <td id="LC9691" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9692" class="blob-num js-line-number" data-line-number="9692"></td>
+ <td id="LC9692" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L9693" class="blob-num js-line-number" data-line-number="9693"></td>
+ <td id="LC9693" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L9694" class="blob-num js-line-number" data-line-number="9694"></td>
+ <td id="LC9694" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L9695" class="blob-num js-line-number" data-line-number="9695"></td>
+ <td id="LC9695" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L9696" class="blob-num js-line-number" data-line-number="9696"></td>
+ <td id="LC9696" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9697" class="blob-num js-line-number" data-line-number="9697"></td>
+ <td id="LC9697" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // wrap to create custom callback shorthands</span></td>
+ </tr>
+ <tr>
+ <td id="L9698" class="blob-num js-line-number" data-line-number="9698"></td>
+ <td id="LC9698" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9699" class="blob-num js-line-number" data-line-number="9699"></td>
+ <td id="LC9699" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);</span></td>
+ </tr>
+ <tr>
+ <td id="L9700" class="blob-num js-line-number" data-line-number="9700"></td>
+ <td id="LC9700" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return !match ? func(callback, thisArg) : function(object) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9701" class="blob-num js-line-number" data-line-number="9701"></td>
+ <td id="LC9701" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];</span></td>
+ </tr>
+ <tr>
+ <td id="L9702" class="blob-num js-line-number" data-line-number="9702"></td>
+ <td id="LC9702" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L9703" class="blob-num js-line-number" data-line-number="9703"></td>
+ <td id="LC9703" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * });</span></td>
+ </tr>
+ <tr>
+ <td id="L9704" class="blob-num js-line-number" data-line-number="9704"></td>
+ <td id="LC9704" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9705" class="blob-num js-line-number" data-line-number="9705"></td>
+ <td id="LC9705" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.filter(characters, 'age__gt38');</span></td>
+ </tr>
+ <tr>
+ <td id="L9706" class="blob-num js-line-number" data-line-number="9706"></td>
+ <td id="LC9706" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'fred', 'age': 40 }]</span></td>
+ </tr>
+ <tr>
+ <td id="L9707" class="blob-num js-line-number" data-line-number="9707"></td>
+ <td id="LC9707" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9708" class="blob-num js-line-number" data-line-number="9708"></td>
+ <td id="LC9708" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">createCallback</span>(<span class="pl-smi">func</span>, <span class="pl-smi">thisArg</span>, <span class="pl-smi">argCount</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9709" class="blob-num js-line-number" data-line-number="9709"></td>
+ <td id="LC9709" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> type <span class="pl-k">=</span> <span class="pl-k">typeof</span> func;</td>
+ </tr>
+ <tr>
+ <td id="L9710" class="blob-num js-line-number" data-line-number="9710"></td>
+ <td id="LC9710" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (func <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> type <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9711" class="blob-num js-line-number" data-line-number="9711"></td>
+ <td id="LC9711" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseCreateCallback</span>(func, thisArg, argCount);</td>
+ </tr>
+ <tr>
+ <td id="L9712" class="blob-num js-line-number" data-line-number="9712"></td>
+ <td id="LC9712" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9713" class="blob-num js-line-number" data-line-number="9713"></td>
+ <td id="LC9713" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// handle "_.pluck" style callback shorthands</span></td>
+ </tr>
+ <tr>
+ <td id="L9714" class="blob-num js-line-number" data-line-number="9714"></td>
+ <td id="LC9714" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (type <span class="pl-k">!=</span> <span class="pl-s"><span class="pl-pds">'</span>object<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9715" class="blob-num js-line-number" data-line-number="9715"></td>
+ <td id="LC9715" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">property</span>(func);</td>
+ </tr>
+ <tr>
+ <td id="L9716" class="blob-num js-line-number" data-line-number="9716"></td>
+ <td id="LC9716" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9717" class="blob-num js-line-number" data-line-number="9717"></td>
+ <td id="LC9717" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> props <span class="pl-k">=</span> <span class="pl-en">keys</span>(func),</td>
+ </tr>
+ <tr>
+ <td id="L9718" class="blob-num js-line-number" data-line-number="9718"></td>
+ <td id="LC9718" class="blob-code blob-code-inner js-file-line"> key <span class="pl-k">=</span> props[<span class="pl-c1">0</span>],</td>
+ </tr>
+ <tr>
+ <td id="L9719" class="blob-num js-line-number" data-line-number="9719"></td>
+ <td id="LC9719" class="blob-code blob-code-inner js-file-line"> a <span class="pl-k">=</span> func[key];</td>
+ </tr>
+ <tr>
+ <td id="L9720" class="blob-num js-line-number" data-line-number="9720"></td>
+ <td id="LC9720" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9721" class="blob-num js-line-number" data-line-number="9721"></td>
+ <td id="LC9721" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// handle "_.where" style callback shorthands</span></td>
+ </tr>
+ <tr>
+ <td id="L9722" class="blob-num js-line-number" data-line-number="9722"></td>
+ <td id="LC9722" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-smi">props</span>.<span class="pl-c1">length</span> <span class="pl-k">==</span> <span class="pl-c1">1</span> <span class="pl-k">&&</span> a <span class="pl-k">===</span> a <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-en">isObject</span>(a)) {</td>
+ </tr>
+ <tr>
+ <td id="L9723" class="blob-num js-line-number" data-line-number="9723"></td>
+ <td id="LC9723" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// fast path the common case of providing an object with a single</span></td>
+ </tr>
+ <tr>
+ <td id="L9724" class="blob-num js-line-number" data-line-number="9724"></td>
+ <td id="LC9724" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// property containing a primitive value</span></td>
+ </tr>
+ <tr>
+ <td id="L9725" class="blob-num js-line-number" data-line-number="9725"></td>
+ <td id="LC9725" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9726" class="blob-num js-line-number" data-line-number="9726"></td>
+ <td id="LC9726" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> b <span class="pl-k">=</span> object[key];</td>
+ </tr>
+ <tr>
+ <td id="L9727" class="blob-num js-line-number" data-line-number="9727"></td>
+ <td id="LC9727" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> a <span class="pl-k">===</span> b <span class="pl-k">&&</span> (a <span class="pl-k">!==</span> <span class="pl-c1">0</span> <span class="pl-k">||</span> (<span class="pl-c1">1</span> <span class="pl-k">/</span> a <span class="pl-k">==</span> <span class="pl-c1">1</span> <span class="pl-k">/</span> b));</td>
+ </tr>
+ <tr>
+ <td id="L9728" class="blob-num js-line-number" data-line-number="9728"></td>
+ <td id="LC9728" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9729" class="blob-num js-line-number" data-line-number="9729"></td>
+ <td id="LC9729" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9730" class="blob-num js-line-number" data-line-number="9730"></td>
+ <td id="LC9730" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9731" class="blob-num js-line-number" data-line-number="9731"></td>
+ <td id="LC9731" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> length <span class="pl-k">=</span> <span class="pl-smi">props</span>.<span class="pl-c1">length</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9732" class="blob-num js-line-number" data-line-number="9732"></td>
+ <td id="LC9732" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9733" class="blob-num js-line-number" data-line-number="9733"></td>
+ <td id="LC9733" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9734" class="blob-num js-line-number" data-line-number="9734"></td>
+ <td id="LC9734" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (length<span class="pl-k">--</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9735" class="blob-num js-line-number" data-line-number="9735"></td>
+ <td id="LC9735" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>(result <span class="pl-k">=</span> <span class="pl-en">baseIsEqual</span>(object[props[length]], func[props[length]], <span class="pl-c1">null</span>, <span class="pl-c1">true</span>))) {</td>
+ </tr>
+ <tr>
+ <td id="L9736" class="blob-num js-line-number" data-line-number="9736"></td>
+ <td id="LC9736" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9737" class="blob-num js-line-number" data-line-number="9737"></td>
+ <td id="LC9737" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9738" class="blob-num js-line-number" data-line-number="9738"></td>
+ <td id="LC9738" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9739" class="blob-num js-line-number" data-line-number="9739"></td>
+ <td id="LC9739" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L9740" class="blob-num js-line-number" data-line-number="9740"></td>
+ <td id="LC9740" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9741" class="blob-num js-line-number" data-line-number="9741"></td>
+ <td id="LC9741" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9742" class="blob-num js-line-number" data-line-number="9742"></td>
+ <td id="LC9742" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9743" class="blob-num js-line-number" data-line-number="9743"></td>
+ <td id="LC9743" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9744" class="blob-num js-line-number" data-line-number="9744"></td>
+ <td id="LC9744" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their</span></td>
+ </tr>
+ <tr>
+ <td id="L9745" class="blob-num js-line-number" data-line-number="9745"></td>
+ <td id="LC9745" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * corresponding HTML entities.</span></td>
+ </tr>
+ <tr>
+ <td id="L9746" class="blob-num js-line-number" data-line-number="9746"></td>
+ <td id="LC9746" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9747" class="blob-num js-line-number" data-line-number="9747"></td>
+ <td id="LC9747" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9748" class="blob-num js-line-number" data-line-number="9748"></td>
+ <td id="LC9748" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9749" class="blob-num js-line-number" data-line-number="9749"></td>
+ <td id="LC9749" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9750" class="blob-num js-line-number" data-line-number="9750"></td>
+ <td id="LC9750" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">string</span> The string to escape.</span></td>
+ </tr>
+ <tr>
+ <td id="L9751" class="blob-num js-line-number" data-line-number="9751"></td>
+ <td id="LC9751" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the escaped string.</span></td>
+ </tr>
+ <tr>
+ <td id="L9752" class="blob-num js-line-number" data-line-number="9752"></td>
+ <td id="LC9752" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9753" class="blob-num js-line-number" data-line-number="9753"></td>
+ <td id="LC9753" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9754" class="blob-num js-line-number" data-line-number="9754"></td>
+ <td id="LC9754" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.escape('Fred, Wilma, & Pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L9755" class="blob-num js-line-number" data-line-number="9755"></td>
+ <td id="LC9755" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'Fred, Wilma, & Pebbles'</span></td>
+ </tr>
+ <tr>
+ <td id="L9756" class="blob-num js-line-number" data-line-number="9756"></td>
+ <td id="LC9756" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9757" class="blob-num js-line-number" data-line-number="9757"></td>
+ <td id="LC9757" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">escape</span>(<span class="pl-smi">string</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9758" class="blob-num js-line-number" data-line-number="9758"></td>
+ <td id="LC9758" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> string <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span> <span class="pl-k">:</span> <span class="pl-c1">String</span>(string).<span class="pl-c1">replace</span>(reUnescapedHtml, escapeHtmlChar);</td>
+ </tr>
+ <tr>
+ <td id="L9759" class="blob-num js-line-number" data-line-number="9759"></td>
+ <td id="LC9759" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9760" class="blob-num js-line-number" data-line-number="9760"></td>
+ <td id="LC9760" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9761" class="blob-num js-line-number" data-line-number="9761"></td>
+ <td id="LC9761" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9762" class="blob-num js-line-number" data-line-number="9762"></td>
+ <td id="LC9762" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * This method returns the first argument provided to it.</span></td>
+ </tr>
+ <tr>
+ <td id="L9763" class="blob-num js-line-number" data-line-number="9763"></td>
+ <td id="LC9763" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9764" class="blob-num js-line-number" data-line-number="9764"></td>
+ <td id="LC9764" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9765" class="blob-num js-line-number" data-line-number="9765"></td>
+ <td id="LC9765" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9766" class="blob-num js-line-number" data-line-number="9766"></td>
+ <td id="LC9766" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9767" class="blob-num js-line-number" data-line-number="9767"></td>
+ <td id="LC9767" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value Any value.</span></td>
+ </tr>
+ <tr>
+ <td id="L9768" class="blob-num js-line-number" data-line-number="9768"></td>
+ <td id="LC9768" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns `value`.</span></td>
+ </tr>
+ <tr>
+ <td id="L9769" class="blob-num js-line-number" data-line-number="9769"></td>
+ <td id="LC9769" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9770" class="blob-num js-line-number" data-line-number="9770"></td>
+ <td id="LC9770" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9771" class="blob-num js-line-number" data-line-number="9771"></td>
+ <td id="LC9771" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = { 'name': 'fred' };</span></td>
+ </tr>
+ <tr>
+ <td id="L9772" class="blob-num js-line-number" data-line-number="9772"></td>
+ <td id="LC9772" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.identity(object) === object;</span></td>
+ </tr>
+ <tr>
+ <td id="L9773" class="blob-num js-line-number" data-line-number="9773"></td>
+ <td id="LC9773" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L9774" class="blob-num js-line-number" data-line-number="9774"></td>
+ <td id="LC9774" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9775" class="blob-num js-line-number" data-line-number="9775"></td>
+ <td id="LC9775" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">identity</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9776" class="blob-num js-line-number" data-line-number="9776"></td>
+ <td id="LC9776" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L9777" class="blob-num js-line-number" data-line-number="9777"></td>
+ <td id="LC9777" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9778" class="blob-num js-line-number" data-line-number="9778"></td>
+ <td id="LC9778" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9779" class="blob-num js-line-number" data-line-number="9779"></td>
+ <td id="LC9779" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9780" class="blob-num js-line-number" data-line-number="9780"></td>
+ <td id="LC9780" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Adds function properties of a source object to the destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L9781" class="blob-num js-line-number" data-line-number="9781"></td>
+ <td id="LC9781" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If `object` is a function methods will be added to its prototype as well.</span></td>
+ </tr>
+ <tr>
+ <td id="L9782" class="blob-num js-line-number" data-line-number="9782"></td>
+ <td id="LC9782" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9783" class="blob-num js-line-number" data-line-number="9783"></td>
+ <td id="LC9783" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9784" class="blob-num js-line-number" data-line-number="9784"></td>
+ <td id="LC9784" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9785" class="blob-num js-line-number" data-line-number="9785"></td>
+ <td id="LC9785" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9786" class="blob-num js-line-number" data-line-number="9786"></td>
+ <td id="LC9786" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Function|Object} [object=lodash] object The destination object.</span></td>
+ </tr>
+ <tr>
+ <td id="L9787" class="blob-num js-line-number" data-line-number="9787"></td>
+ <td id="LC9787" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">source</span> The object of functions to add.</span></td>
+ </tr>
+ <tr>
+ <td id="L9788" class="blob-num js-line-number" data-line-number="9788"></td>
+ <td id="LC9788" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [options] The options object.</span></td>
+ </tr>
+ <tr>
+ <td id="L9789" class="blob-num js-line-number" data-line-number="9789"></td>
+ <td id="LC9789" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [options.chain=true] Specify whether the functions added are chainable.</span></td>
+ </tr>
+ <tr>
+ <td id="L9790" class="blob-num js-line-number" data-line-number="9790"></td>
+ <td id="LC9790" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9791" class="blob-num js-line-number" data-line-number="9791"></td>
+ <td id="LC9791" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9792" class="blob-num js-line-number" data-line-number="9792"></td>
+ <td id="LC9792" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * function capitalize(string) {</span></td>
+ </tr>
+ <tr>
+ <td id="L9793" class="blob-num js-line-number" data-line-number="9793"></td>
+ <td id="LC9793" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();</span></td>
+ </tr>
+ <tr>
+ <td id="L9794" class="blob-num js-line-number" data-line-number="9794"></td>
+ <td id="LC9794" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L9795" class="blob-num js-line-number" data-line-number="9795"></td>
+ <td id="LC9795" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9796" class="blob-num js-line-number" data-line-number="9796"></td>
+ <td id="LC9796" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.mixin({ 'capitalize': capitalize });</span></td>
+ </tr>
+ <tr>
+ <td id="L9797" class="blob-num js-line-number" data-line-number="9797"></td>
+ <td id="LC9797" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.capitalize('fred');</span></td>
+ </tr>
+ <tr>
+ <td id="L9798" class="blob-num js-line-number" data-line-number="9798"></td>
+ <td id="LC9798" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'Fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L9799" class="blob-num js-line-number" data-line-number="9799"></td>
+ <td id="LC9799" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9800" class="blob-num js-line-number" data-line-number="9800"></td>
+ <td id="LC9800" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _('fred').capitalize().value();</span></td>
+ </tr>
+ <tr>
+ <td id="L9801" class="blob-num js-line-number" data-line-number="9801"></td>
+ <td id="LC9801" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'Fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L9802" class="blob-num js-line-number" data-line-number="9802"></td>
+ <td id="LC9802" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9803" class="blob-num js-line-number" data-line-number="9803"></td>
+ <td id="LC9803" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.mixin({ 'capitalize': capitalize }, { 'chain': false });</span></td>
+ </tr>
+ <tr>
+ <td id="L9804" class="blob-num js-line-number" data-line-number="9804"></td>
+ <td id="LC9804" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _('fred').capitalize();</span></td>
+ </tr>
+ <tr>
+ <td id="L9805" class="blob-num js-line-number" data-line-number="9805"></td>
+ <td id="LC9805" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'Fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L9806" class="blob-num js-line-number" data-line-number="9806"></td>
+ <td id="LC9806" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9807" class="blob-num js-line-number" data-line-number="9807"></td>
+ <td id="LC9807" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">mixin</span>(<span class="pl-smi">object</span>, <span class="pl-smi">source</span>, <span class="pl-smi">options</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9808" class="blob-num js-line-number" data-line-number="9808"></td>
+ <td id="LC9808" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> chain <span class="pl-k">=</span> <span class="pl-c1">true</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9809" class="blob-num js-line-number" data-line-number="9809"></td>
+ <td id="LC9809" class="blob-code blob-code-inner js-file-line"> methodNames <span class="pl-k">=</span> source <span class="pl-k">&&</span> <span class="pl-en">functions</span>(source);</td>
+ </tr>
+ <tr>
+ <td id="L9810" class="blob-num js-line-number" data-line-number="9810"></td>
+ <td id="LC9810" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9811" class="blob-num js-line-number" data-line-number="9811"></td>
+ <td id="LC9811" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>source <span class="pl-k">||</span> (<span class="pl-k">!</span>options <span class="pl-k">&&</span> <span class="pl-k">!</span><span class="pl-smi">methodNames</span>.<span class="pl-c1">length</span>)) {</td>
+ </tr>
+ <tr>
+ <td id="L9812" class="blob-num js-line-number" data-line-number="9812"></td>
+ <td id="LC9812" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (options <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9813" class="blob-num js-line-number" data-line-number="9813"></td>
+ <td id="LC9813" class="blob-code blob-code-inner js-file-line"> options <span class="pl-k">=</span> source;</td>
+ </tr>
+ <tr>
+ <td id="L9814" class="blob-num js-line-number" data-line-number="9814"></td>
+ <td id="LC9814" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9815" class="blob-num js-line-number" data-line-number="9815"></td>
+ <td id="LC9815" class="blob-code blob-code-inner js-file-line"> ctor <span class="pl-k">=</span> lodashWrapper;</td>
+ </tr>
+ <tr>
+ <td id="L9816" class="blob-num js-line-number" data-line-number="9816"></td>
+ <td id="LC9816" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">=</span> object;</td>
+ </tr>
+ <tr>
+ <td id="L9817" class="blob-num js-line-number" data-line-number="9817"></td>
+ <td id="LC9817" class="blob-code blob-code-inner js-file-line"> object <span class="pl-k">=</span> lodash;</td>
+ </tr>
+ <tr>
+ <td id="L9818" class="blob-num js-line-number" data-line-number="9818"></td>
+ <td id="LC9818" class="blob-code blob-code-inner js-file-line"> methodNames <span class="pl-k">=</span> <span class="pl-en">functions</span>(source);</td>
+ </tr>
+ <tr>
+ <td id="L9819" class="blob-num js-line-number" data-line-number="9819"></td>
+ <td id="LC9819" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9820" class="blob-num js-line-number" data-line-number="9820"></td>
+ <td id="LC9820" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (options <span class="pl-k">===</span> <span class="pl-c1">false</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9821" class="blob-num js-line-number" data-line-number="9821"></td>
+ <td id="LC9821" class="blob-code blob-code-inner js-file-line"> chain <span class="pl-k">=</span> <span class="pl-c1">false</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9822" class="blob-num js-line-number" data-line-number="9822"></td>
+ <td id="LC9822" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-en">isObject</span>(options) <span class="pl-k">&&</span> <span class="pl-s"><span class="pl-pds">'</span>chain<span class="pl-pds">'</span></span> <span class="pl-k">in</span> options) {</td>
+ </tr>
+ <tr>
+ <td id="L9823" class="blob-num js-line-number" data-line-number="9823"></td>
+ <td id="LC9823" class="blob-code blob-code-inner js-file-line"> chain <span class="pl-k">=</span> <span class="pl-smi">options</span>.<span class="pl-smi">chain</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9824" class="blob-num js-line-number" data-line-number="9824"></td>
+ <td id="LC9824" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9825" class="blob-num js-line-number" data-line-number="9825"></td>
+ <td id="LC9825" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> ctor <span class="pl-k">=</span> object,</td>
+ </tr>
+ <tr>
+ <td id="L9826" class="blob-num js-line-number" data-line-number="9826"></td>
+ <td id="LC9826" class="blob-code blob-code-inner js-file-line"> isFunc <span class="pl-k">=</span> <span class="pl-en">isFunction</span>(ctor);</td>
+ </tr>
+ <tr>
+ <td id="L9827" class="blob-num js-line-number" data-line-number="9827"></td>
+ <td id="LC9827" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9828" class="blob-num js-line-number" data-line-number="9828"></td>
+ <td id="LC9828" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>(methodNames, <span class="pl-k">function</span>(<span class="pl-smi">methodName</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9829" class="blob-num js-line-number" data-line-number="9829"></td>
+ <td id="LC9829" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> func <span class="pl-k">=</span> object[methodName] <span class="pl-k">=</span> source[methodName];</td>
+ </tr>
+ <tr>
+ <td id="L9830" class="blob-num js-line-number" data-line-number="9830"></td>
+ <td id="LC9830" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (isFunc) {</td>
+ </tr>
+ <tr>
+ <td id="L9831" class="blob-num js-line-number" data-line-number="9831"></td>
+ <td id="LC9831" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">ctor</span>.<span class="pl-c1">prototype</span>[methodName] <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9832" class="blob-num js-line-number" data-line-number="9832"></td>
+ <td id="LC9832" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> chainAll <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">__chain__</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9833" class="blob-num js-line-number" data-line-number="9833"></td>
+ <td id="LC9833" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9834" class="blob-num js-line-number" data-line-number="9834"></td>
+ <td id="LC9834" class="blob-code blob-code-inner js-file-line"> args <span class="pl-k">=</span> [value];</td>
+ </tr>
+ <tr>
+ <td id="L9835" class="blob-num js-line-number" data-line-number="9835"></td>
+ <td id="LC9835" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9836" class="blob-num js-line-number" data-line-number="9836"></td>
+ <td id="LC9836" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">push</span>.<span class="pl-c1">apply</span>(args, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L9837" class="blob-num js-line-number" data-line-number="9837"></td>
+ <td id="LC9837" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(object, args);</td>
+ </tr>
+ <tr>
+ <td id="L9838" class="blob-num js-line-number" data-line-number="9838"></td>
+ <td id="LC9838" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (chain <span class="pl-k">||</span> chainAll) {</td>
+ </tr>
+ <tr>
+ <td id="L9839" class="blob-num js-line-number" data-line-number="9839"></td>
+ <td id="LC9839" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (value <span class="pl-k">===</span> result <span class="pl-k">&&</span> <span class="pl-en">isObject</span>(result)) {</td>
+ </tr>
+ <tr>
+ <td id="L9840" class="blob-num js-line-number" data-line-number="9840"></td>
+ <td id="LC9840" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9841" class="blob-num js-line-number" data-line-number="9841"></td>
+ <td id="LC9841" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9842" class="blob-num js-line-number" data-line-number="9842"></td>
+ <td id="LC9842" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">ctor</span>(result);</td>
+ </tr>
+ <tr>
+ <td id="L9843" class="blob-num js-line-number" data-line-number="9843"></td>
+ <td id="LC9843" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-smi">__chain__</span> <span class="pl-k">=</span> chainAll;</td>
+ </tr>
+ <tr>
+ <td id="L9844" class="blob-num js-line-number" data-line-number="9844"></td>
+ <td id="LC9844" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9845" class="blob-num js-line-number" data-line-number="9845"></td>
+ <td id="LC9845" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L9846" class="blob-num js-line-number" data-line-number="9846"></td>
+ <td id="LC9846" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9847" class="blob-num js-line-number" data-line-number="9847"></td>
+ <td id="LC9847" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9848" class="blob-num js-line-number" data-line-number="9848"></td>
+ <td id="LC9848" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L9849" class="blob-num js-line-number" data-line-number="9849"></td>
+ <td id="LC9849" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9850" class="blob-num js-line-number" data-line-number="9850"></td>
+ <td id="LC9850" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9851" class="blob-num js-line-number" data-line-number="9851"></td>
+ <td id="LC9851" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9852" class="blob-num js-line-number" data-line-number="9852"></td>
+ <td id="LC9852" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Reverts the '_' variable to its previous value and returns a reference to</span></td>
+ </tr>
+ <tr>
+ <td id="L9853" class="blob-num js-line-number" data-line-number="9853"></td>
+ <td id="LC9853" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the `lodash` function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9854" class="blob-num js-line-number" data-line-number="9854"></td>
+ <td id="LC9854" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9855" class="blob-num js-line-number" data-line-number="9855"></td>
+ <td id="LC9855" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9856" class="blob-num js-line-number" data-line-number="9856"></td>
+ <td id="LC9856" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9857" class="blob-num js-line-number" data-line-number="9857"></td>
+ <td id="LC9857" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9858" class="blob-num js-line-number" data-line-number="9858"></td>
+ <td id="LC9858" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the `lodash` function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9859" class="blob-num js-line-number" data-line-number="9859"></td>
+ <td id="LC9859" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9860" class="blob-num js-line-number" data-line-number="9860"></td>
+ <td id="LC9860" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9861" class="blob-num js-line-number" data-line-number="9861"></td>
+ <td id="LC9861" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var lodash = _.noConflict();</span></td>
+ </tr>
+ <tr>
+ <td id="L9862" class="blob-num js-line-number" data-line-number="9862"></td>
+ <td id="LC9862" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9863" class="blob-num js-line-number" data-line-number="9863"></td>
+ <td id="LC9863" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">noConflict</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9864" class="blob-num js-line-number" data-line-number="9864"></td>
+ <td id="LC9864" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">context</span>.<span class="pl-smi">_</span> <span class="pl-k">=</span> oldDash;</td>
+ </tr>
+ <tr>
+ <td id="L9865" class="blob-num js-line-number" data-line-number="9865"></td>
+ <td id="LC9865" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9866" class="blob-num js-line-number" data-line-number="9866"></td>
+ <td id="LC9866" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9867" class="blob-num js-line-number" data-line-number="9867"></td>
+ <td id="LC9867" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9868" class="blob-num js-line-number" data-line-number="9868"></td>
+ <td id="LC9868" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9869" class="blob-num js-line-number" data-line-number="9869"></td>
+ <td id="LC9869" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A no-operation function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9870" class="blob-num js-line-number" data-line-number="9870"></td>
+ <td id="LC9870" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9871" class="blob-num js-line-number" data-line-number="9871"></td>
+ <td id="LC9871" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9872" class="blob-num js-line-number" data-line-number="9872"></td>
+ <td id="LC9872" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9873" class="blob-num js-line-number" data-line-number="9873"></td>
+ <td id="LC9873" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9874" class="blob-num js-line-number" data-line-number="9874"></td>
+ <td id="LC9874" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9875" class="blob-num js-line-number" data-line-number="9875"></td>
+ <td id="LC9875" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9876" class="blob-num js-line-number" data-line-number="9876"></td>
+ <td id="LC9876" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = { 'name': 'fred' };</span></td>
+ </tr>
+ <tr>
+ <td id="L9877" class="blob-num js-line-number" data-line-number="9877"></td>
+ <td id="LC9877" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.noop(object) === undefined;</span></td>
+ </tr>
+ <tr>
+ <td id="L9878" class="blob-num js-line-number" data-line-number="9878"></td>
+ <td id="LC9878" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => true</span></td>
+ </tr>
+ <tr>
+ <td id="L9879" class="blob-num js-line-number" data-line-number="9879"></td>
+ <td id="LC9879" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9880" class="blob-num js-line-number" data-line-number="9880"></td>
+ <td id="LC9880" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">noop</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9881" class="blob-num js-line-number" data-line-number="9881"></td>
+ <td id="LC9881" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// no operation performed</span></td>
+ </tr>
+ <tr>
+ <td id="L9882" class="blob-num js-line-number" data-line-number="9882"></td>
+ <td id="LC9882" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9883" class="blob-num js-line-number" data-line-number="9883"></td>
+ <td id="LC9883" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9884" class="blob-num js-line-number" data-line-number="9884"></td>
+ <td id="LC9884" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9885" class="blob-num js-line-number" data-line-number="9885"></td>
+ <td id="LC9885" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Gets the number of milliseconds that have elapsed since the Unix epoch</span></td>
+ </tr>
+ <tr>
+ <td id="L9886" class="blob-num js-line-number" data-line-number="9886"></td>
+ <td id="LC9886" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * (1 January 1970 00:00:00 UTC).</span></td>
+ </tr>
+ <tr>
+ <td id="L9887" class="blob-num js-line-number" data-line-number="9887"></td>
+ <td id="LC9887" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9888" class="blob-num js-line-number" data-line-number="9888"></td>
+ <td id="LC9888" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9889" class="blob-num js-line-number" data-line-number="9889"></td>
+ <td id="LC9889" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9890" class="blob-num js-line-number" data-line-number="9890"></td>
+ <td id="LC9890" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9891" class="blob-num js-line-number" data-line-number="9891"></td>
+ <td id="LC9891" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9892" class="blob-num js-line-number" data-line-number="9892"></td>
+ <td id="LC9892" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9893" class="blob-num js-line-number" data-line-number="9893"></td>
+ <td id="LC9893" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var stamp = _.now();</span></td>
+ </tr>
+ <tr>
+ <td id="L9894" class="blob-num js-line-number" data-line-number="9894"></td>
+ <td id="LC9894" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.defer(function() { console.log(_.now() - stamp); });</span></td>
+ </tr>
+ <tr>
+ <td id="L9895" class="blob-num js-line-number" data-line-number="9895"></td>
+ <td id="LC9895" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => logs the number of milliseconds it took for the deferred function to be called</span></td>
+ </tr>
+ <tr>
+ <td id="L9896" class="blob-num js-line-number" data-line-number="9896"></td>
+ <td id="LC9896" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9897" class="blob-num js-line-number" data-line-number="9897"></td>
+ <td id="LC9897" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> now <span class="pl-k">=</span> <span class="pl-en">isNative</span>(now <span class="pl-k">=</span> <span class="pl-c1">Date</span>.<span class="pl-smi">now</span>) <span class="pl-k">&&</span> now <span class="pl-k">||</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L9898" class="blob-num js-line-number" data-line-number="9898"></td>
+ <td id="LC9898" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">new</span> <span class="pl-en">Date</span>().<span class="pl-c1">getTime</span>();</td>
+ </tr>
+ <tr>
+ <td id="L9899" class="blob-num js-line-number" data-line-number="9899"></td>
+ <td id="LC9899" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9900" class="blob-num js-line-number" data-line-number="9900"></td>
+ <td id="LC9900" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9901" class="blob-num js-line-number" data-line-number="9901"></td>
+ <td id="LC9901" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9902" class="blob-num js-line-number" data-line-number="9902"></td>
+ <td id="LC9902" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Converts the given value into an integer of the specified radix.</span></td>
+ </tr>
+ <tr>
+ <td id="L9903" class="blob-num js-line-number" data-line-number="9903"></td>
+ <td id="LC9903" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the</span></td>
+ </tr>
+ <tr>
+ <td id="L9904" class="blob-num js-line-number" data-line-number="9904"></td>
+ <td id="LC9904" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `value` is a hexadecimal, in which case a `radix` of `16` is used.</span></td>
+ </tr>
+ <tr>
+ <td id="L9905" class="blob-num js-line-number" data-line-number="9905"></td>
+ <td id="LC9905" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9906" class="blob-num js-line-number" data-line-number="9906"></td>
+ <td id="LC9906" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: This method avoids differences in native ES3 and ES5 `parseInt`</span></td>
+ </tr>
+ <tr>
+ <td id="L9907" class="blob-num js-line-number" data-line-number="9907"></td>
+ <td id="LC9907" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * implementations. See http://es5.github.io/#E.</span></td>
+ </tr>
+ <tr>
+ <td id="L9908" class="blob-num js-line-number" data-line-number="9908"></td>
+ <td id="LC9908" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9909" class="blob-num js-line-number" data-line-number="9909"></td>
+ <td id="LC9909" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9910" class="blob-num js-line-number" data-line-number="9910"></td>
+ <td id="LC9910" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9911" class="blob-num js-line-number" data-line-number="9911"></td>
+ <td id="LC9911" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9912" class="blob-num js-line-number" data-line-number="9912"></td>
+ <td id="LC9912" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">value</span> The value to parse.</span></td>
+ </tr>
+ <tr>
+ <td id="L9913" class="blob-num js-line-number" data-line-number="9913"></td>
+ <td id="LC9913" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [radix] The radix used to interpret the value to parse.</span></td>
+ </tr>
+ <tr>
+ <td id="L9914" class="blob-num js-line-number" data-line-number="9914"></td>
+ <td id="LC9914" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> the new integer value.</span></td>
+ </tr>
+ <tr>
+ <td id="L9915" class="blob-num js-line-number" data-line-number="9915"></td>
+ <td id="LC9915" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9916" class="blob-num js-line-number" data-line-number="9916"></td>
+ <td id="LC9916" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9917" class="blob-num js-line-number" data-line-number="9917"></td>
+ <td id="LC9917" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.parseInt('08');</span></td>
+ </tr>
+ <tr>
+ <td id="L9918" class="blob-num js-line-number" data-line-number="9918"></td>
+ <td id="LC9918" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 8</span></td>
+ </tr>
+ <tr>
+ <td id="L9919" class="blob-num js-line-number" data-line-number="9919"></td>
+ <td id="LC9919" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9920" class="blob-num js-line-number" data-line-number="9920"></td>
+ <td id="LC9920" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> parseInt <span class="pl-k">=</span> <span class="pl-en">nativeParseInt</span>(whitespace <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>08<span class="pl-pds">'</span></span>) <span class="pl-k">==</span> <span class="pl-c1">8</span> <span class="pl-k">?</span> <span class="pl-en">nativeParseInt</span> <span class="pl-k">:</span> <span class="pl-k [...]
+ </tr>
+ <tr>
+ <td id="L9921" class="blob-num js-line-number" data-line-number="9921"></td>
+ <td id="LC9921" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt`</span></td>
+ </tr>
+ <tr>
+ <td id="L9922" class="blob-num js-line-number" data-line-number="9922"></td>
+ <td id="LC9922" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">nativeParseInt</span>(<span class="pl-en">isString</span>(value) <span class="pl-k">?</span> <span class="pl-smi">value</span>.<span class="pl-c1">replace</span>(reLeadingSpacesAndZeros, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>) <span class="pl-k">:</span> value, radix <span class="pl-k">||</span> <span class [...]
+ </tr>
+ <tr>
+ <td id="L9923" class="blob-num js-line-number" data-line-number="9923"></td>
+ <td id="LC9923" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9924" class="blob-num js-line-number" data-line-number="9924"></td>
+ <td id="LC9924" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9925" class="blob-num js-line-number" data-line-number="9925"></td>
+ <td id="LC9925" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9926" class="blob-num js-line-number" data-line-number="9926"></td>
+ <td id="LC9926" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a "_.pluck" style function, which returns the `key` value of a</span></td>
+ </tr>
+ <tr>
+ <td id="L9927" class="blob-num js-line-number" data-line-number="9927"></td>
+ <td id="LC9927" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * given object.</span></td>
+ </tr>
+ <tr>
+ <td id="L9928" class="blob-num js-line-number" data-line-number="9928"></td>
+ <td id="LC9928" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9929" class="blob-num js-line-number" data-line-number="9929"></td>
+ <td id="LC9929" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9930" class="blob-num js-line-number" data-line-number="9930"></td>
+ <td id="LC9930" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9931" class="blob-num js-line-number" data-line-number="9931"></td>
+ <td id="LC9931" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9932" class="blob-num js-line-number" data-line-number="9932"></td>
+ <td id="LC9932" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">key</span> The name of the property to retrieve.</span></td>
+ </tr>
+ <tr>
+ <td id="L9933" class="blob-num js-line-number" data-line-number="9933"></td>
+ <td id="LC9933" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Function}</span> <span class="pl-smi">Returns</span> the new function.</span></td>
+ </tr>
+ <tr>
+ <td id="L9934" class="blob-num js-line-number" data-line-number="9934"></td>
+ <td id="LC9934" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9935" class="blob-num js-line-number" data-line-number="9935"></td>
+ <td id="LC9935" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9936" class="blob-num js-line-number" data-line-number="9936"></td>
+ <td id="LC9936" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L9937" class="blob-num js-line-number" data-line-number="9937"></td>
+ <td id="LC9937" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 },</span></td>
+ </tr>
+ <tr>
+ <td id="L9938" class="blob-num js-line-number" data-line-number="9938"></td>
+ <td id="LC9938" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 }</span></td>
+ </tr>
+ <tr>
+ <td id="L9939" class="blob-num js-line-number" data-line-number="9939"></td>
+ <td id="LC9939" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L9940" class="blob-num js-line-number" data-line-number="9940"></td>
+ <td id="LC9940" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9941" class="blob-num js-line-number" data-line-number="9941"></td>
+ <td id="LC9941" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var getName = _.property('name');</span></td>
+ </tr>
+ <tr>
+ <td id="L9942" class="blob-num js-line-number" data-line-number="9942"></td>
+ <td id="LC9942" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9943" class="blob-num js-line-number" data-line-number="9943"></td>
+ <td id="LC9943" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.map(characters, getName);</span></td>
+ </tr>
+ <tr>
+ <td id="L9944" class="blob-num js-line-number" data-line-number="9944"></td>
+ <td id="LC9944" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => ['barney', 'fred']</span></td>
+ </tr>
+ <tr>
+ <td id="L9945" class="blob-num js-line-number" data-line-number="9945"></td>
+ <td id="LC9945" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9946" class="blob-num js-line-number" data-line-number="9946"></td>
+ <td id="LC9946" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.sortBy(characters, getName);</span></td>
+ </tr>
+ <tr>
+ <td id="L9947" class="blob-num js-line-number" data-line-number="9947"></td>
+ <td id="LC9947" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }]</span></td>
+ </tr>
+ <tr>
+ <td id="L9948" class="blob-num js-line-number" data-line-number="9948"></td>
+ <td id="LC9948" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9949" class="blob-num js-line-number" data-line-number="9949"></td>
+ <td id="LC9949" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">property</span>(<span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9950" class="blob-num js-line-number" data-line-number="9950"></td>
+ <td id="LC9950" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">function</span>(<span class="pl-smi">object</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9951" class="blob-num js-line-number" data-line-number="9951"></td>
+ <td id="LC9951" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> object[key];</td>
+ </tr>
+ <tr>
+ <td id="L9952" class="blob-num js-line-number" data-line-number="9952"></td>
+ <td id="LC9952" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L9953" class="blob-num js-line-number" data-line-number="9953"></td>
+ <td id="LC9953" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9954" class="blob-num js-line-number" data-line-number="9954"></td>
+ <td id="LC9954" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9955" class="blob-num js-line-number" data-line-number="9955"></td>
+ <td id="LC9955" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L9956" class="blob-num js-line-number" data-line-number="9956"></td>
+ <td id="LC9956" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Produces a random number between `min` and `max` (inclusive). If only one</span></td>
+ </tr>
+ <tr>
+ <td id="L9957" class="blob-num js-line-number" data-line-number="9957"></td>
+ <td id="LC9957" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * argument is provided a number between `0` and the given number will be</span></td>
+ </tr>
+ <tr>
+ <td id="L9958" class="blob-num js-line-number" data-line-number="9958"></td>
+ <td id="LC9958" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * returned. If `floating` is truey or either `min` or `max` are floats a</span></td>
+ </tr>
+ <tr>
+ <td id="L9959" class="blob-num js-line-number" data-line-number="9959"></td>
+ <td id="LC9959" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * floating-point number will be returned instead of an integer.</span></td>
+ </tr>
+ <tr>
+ <td id="L9960" class="blob-num js-line-number" data-line-number="9960"></td>
+ <td id="LC9960" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9961" class="blob-num js-line-number" data-line-number="9961"></td>
+ <td id="LC9961" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9962" class="blob-num js-line-number" data-line-number="9962"></td>
+ <td id="LC9962" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L9963" class="blob-num js-line-number" data-line-number="9963"></td>
+ <td id="LC9963" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L9964" class="blob-num js-line-number" data-line-number="9964"></td>
+ <td id="LC9964" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [min=0] The minimum possible value.</span></td>
+ </tr>
+ <tr>
+ <td id="L9965" class="blob-num js-line-number" data-line-number="9965"></td>
+ <td id="LC9965" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {number} [max=1] The maximum possible value.</span></td>
+ </tr>
+ <tr>
+ <td id="L9966" class="blob-num js-line-number" data-line-number="9966"></td>
+ <td id="LC9966" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {boolean} [floating=false] Specify returning a floating-point number.</span></td>
+ </tr>
+ <tr>
+ <td id="L9967" class="blob-num js-line-number" data-line-number="9967"></td>
+ <td id="LC9967" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{number}</span> <span class="pl-smi">Returns</span> a random number.</span></td>
+ </tr>
+ <tr>
+ <td id="L9968" class="blob-num js-line-number" data-line-number="9968"></td>
+ <td id="LC9968" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L9969" class="blob-num js-line-number" data-line-number="9969"></td>
+ <td id="LC9969" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9970" class="blob-num js-line-number" data-line-number="9970"></td>
+ <td id="LC9970" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.random(0, 5);</span></td>
+ </tr>
+ <tr>
+ <td id="L9971" class="blob-num js-line-number" data-line-number="9971"></td>
+ <td id="LC9971" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => an integer between 0 and 5</span></td>
+ </tr>
+ <tr>
+ <td id="L9972" class="blob-num js-line-number" data-line-number="9972"></td>
+ <td id="LC9972" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9973" class="blob-num js-line-number" data-line-number="9973"></td>
+ <td id="LC9973" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.random(5);</span></td>
+ </tr>
+ <tr>
+ <td id="L9974" class="blob-num js-line-number" data-line-number="9974"></td>
+ <td id="LC9974" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => also an integer between 0 and 5</span></td>
+ </tr>
+ <tr>
+ <td id="L9975" class="blob-num js-line-number" data-line-number="9975"></td>
+ <td id="LC9975" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9976" class="blob-num js-line-number" data-line-number="9976"></td>
+ <td id="LC9976" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.random(5, true);</span></td>
+ </tr>
+ <tr>
+ <td id="L9977" class="blob-num js-line-number" data-line-number="9977"></td>
+ <td id="LC9977" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => a floating-point number between 0 and 5</span></td>
+ </tr>
+ <tr>
+ <td id="L9978" class="blob-num js-line-number" data-line-number="9978"></td>
+ <td id="LC9978" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L9979" class="blob-num js-line-number" data-line-number="9979"></td>
+ <td id="LC9979" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.random(1.2, 5.2);</span></td>
+ </tr>
+ <tr>
+ <td id="L9980" class="blob-num js-line-number" data-line-number="9980"></td>
+ <td id="LC9980" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => a floating-point number between 1.2 and 5.2</span></td>
+ </tr>
+ <tr>
+ <td id="L9981" class="blob-num js-line-number" data-line-number="9981"></td>
+ <td id="LC9981" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L9982" class="blob-num js-line-number" data-line-number="9982"></td>
+ <td id="LC9982" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">random</span>(<span class="pl-smi">min</span>, <span class="pl-smi">max</span>, <span class="pl-smi">floating</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9983" class="blob-num js-line-number" data-line-number="9983"></td>
+ <td id="LC9983" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> noMin <span class="pl-k">=</span> min <span class="pl-k">==</span> <span class="pl-c1">null</span>,</td>
+ </tr>
+ <tr>
+ <td id="L9984" class="blob-num js-line-number" data-line-number="9984"></td>
+ <td id="LC9984" class="blob-code blob-code-inner js-file-line"> noMax <span class="pl-k">=</span> max <span class="pl-k">==</span> <span class="pl-c1">null</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9985" class="blob-num js-line-number" data-line-number="9985"></td>
+ <td id="LC9985" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L9986" class="blob-num js-line-number" data-line-number="9986"></td>
+ <td id="LC9986" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (floating <span class="pl-k">==</span> <span class="pl-c1">null</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9987" class="blob-num js-line-number" data-line-number="9987"></td>
+ <td id="LC9987" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> min <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> noMax) {</td>
+ </tr>
+ <tr>
+ <td id="L9988" class="blob-num js-line-number" data-line-number="9988"></td>
+ <td id="LC9988" class="blob-code blob-code-inner js-file-line"> floating <span class="pl-k">=</span> min;</td>
+ </tr>
+ <tr>
+ <td id="L9989" class="blob-num js-line-number" data-line-number="9989"></td>
+ <td id="LC9989" class="blob-code blob-code-inner js-file-line"> min <span class="pl-k">=</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9990" class="blob-num js-line-number" data-line-number="9990"></td>
+ <td id="LC9990" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9991" class="blob-num js-line-number" data-line-number="9991"></td>
+ <td id="LC9991" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> <span class="pl-k">if</span> (<span class="pl-k">!</span>noMax <span class="pl-k">&&</span> <span class="pl-k">typeof</span> max <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>boolean<span class="pl-pds">'</span></span>) {</td>
+ </tr>
+ <tr>
+ <td id="L9992" class="blob-num js-line-number" data-line-number="9992"></td>
+ <td id="LC9992" class="blob-code blob-code-inner js-file-line"> floating <span class="pl-k">=</span> max;</td>
+ </tr>
+ <tr>
+ <td id="L9993" class="blob-num js-line-number" data-line-number="9993"></td>
+ <td id="LC9993" class="blob-code blob-code-inner js-file-line"> noMax <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9994" class="blob-num js-line-number" data-line-number="9994"></td>
+ <td id="LC9994" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9995" class="blob-num js-line-number" data-line-number="9995"></td>
+ <td id="LC9995" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9996" class="blob-num js-line-number" data-line-number="9996"></td>
+ <td id="LC9996" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (noMin <span class="pl-k">&&</span> noMax) {</td>
+ </tr>
+ <tr>
+ <td id="L9997" class="blob-num js-line-number" data-line-number="9997"></td>
+ <td id="LC9997" class="blob-code blob-code-inner js-file-line"> max <span class="pl-k">=</span> <span class="pl-c1">1</span>;</td>
+ </tr>
+ <tr>
+ <td id="L9998" class="blob-num js-line-number" data-line-number="9998"></td>
+ <td id="LC9998" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L9999" class="blob-num js-line-number" data-line-number="9999"></td>
+ <td id="LC9999" class="blob-code blob-code-inner js-file-line"> min <span class="pl-k">=</span> <span class="pl-k">+</span>min <span class="pl-k">||</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10000" class="blob-num js-line-number" data-line-number="10000"></td>
+ <td id="LC10000" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (noMax) {</td>
+ </tr>
+ <tr>
+ <td id="L10001" class="blob-num js-line-number" data-line-number="10001"></td>
+ <td id="LC10001" class="blob-code blob-code-inner js-file-line"> max <span class="pl-k">=</span> min;</td>
+ </tr>
+ <tr>
+ <td id="L10002" class="blob-num js-line-number" data-line-number="10002"></td>
+ <td id="LC10002" class="blob-code blob-code-inner js-file-line"> min <span class="pl-k">=</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10003" class="blob-num js-line-number" data-line-number="10003"></td>
+ <td id="LC10003" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L10004" class="blob-num js-line-number" data-line-number="10004"></td>
+ <td id="LC10004" class="blob-code blob-code-inner js-file-line"> max <span class="pl-k">=</span> <span class="pl-k">+</span>max <span class="pl-k">||</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10005" class="blob-num js-line-number" data-line-number="10005"></td>
+ <td id="LC10005" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10006" class="blob-num js-line-number" data-line-number="10006"></td>
+ <td id="LC10006" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (floating <span class="pl-k">||</span> min <span class="pl-k">%</span> <span class="pl-c1">1</span> <span class="pl-k">||</span> max <span class="pl-k">%</span> <span class="pl-c1">1</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10007" class="blob-num js-line-number" data-line-number="10007"></td>
+ <td id="LC10007" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> rand <span class="pl-k">=</span> <span class="pl-en">nativeRandom</span>();</td>
+ </tr>
+ <tr>
+ <td id="L10008" class="blob-num js-line-number" data-line-number="10008"></td>
+ <td id="LC10008" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">nativeMin</span>(min <span class="pl-k">+</span> (rand <span class="pl-k">*</span> (max <span class="pl-k">-</span> min <span class="pl-k">+</span> <span class="pl-c1">parseFloat</span>(<span class="pl-s"><span class="pl-pds">'</span>1e-<span class="pl-pds">'</span></span> <span class="pl-k">+</span> ((rand <span class="pl-k">+</span><span class="pl [...]
+ </tr>
+ <tr>
+ <td id="L10009" class="blob-num js-line-number" data-line-number="10009"></td>
+ <td id="LC10009" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10010" class="blob-num js-line-number" data-line-number="10010"></td>
+ <td id="LC10010" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">baseRandom</span>(min, max);</td>
+ </tr>
+ <tr>
+ <td id="L10011" class="blob-num js-line-number" data-line-number="10011"></td>
+ <td id="LC10011" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10012" class="blob-num js-line-number" data-line-number="10012"></td>
+ <td id="LC10012" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10013" class="blob-num js-line-number" data-line-number="10013"></td>
+ <td id="LC10013" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10014" class="blob-num js-line-number" data-line-number="10014"></td>
+ <td id="LC10014" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Resolves the value of property `key` on `object`. If `key` is a function</span></td>
+ </tr>
+ <tr>
+ <td id="L10015" class="blob-num js-line-number" data-line-number="10015"></td>
+ <td id="LC10015" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * it will be invoked with the `this` binding of `object` and its result returned,</span></td>
+ </tr>
+ <tr>
+ <td id="L10016" class="blob-num js-line-number" data-line-number="10016"></td>
+ <td id="LC10016" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * else the property value is returned. If `object` is falsey then `undefined`</span></td>
+ </tr>
+ <tr>
+ <td id="L10017" class="blob-num js-line-number" data-line-number="10017"></td>
+ <td id="LC10017" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is returned.</span></td>
+ </tr>
+ <tr>
+ <td id="L10018" class="blob-num js-line-number" data-line-number="10018"></td>
+ <td id="LC10018" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10019" class="blob-num js-line-number" data-line-number="10019"></td>
+ <td id="LC10019" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10020" class="blob-num js-line-number" data-line-number="10020"></td>
+ <td id="LC10020" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10021" class="blob-num js-line-number" data-line-number="10021"></td>
+ <td id="LC10021" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L10022" class="blob-num js-line-number" data-line-number="10022"></td>
+ <td id="LC10022" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">object</span> The object to inspect.</span></td>
+ </tr>
+ <tr>
+ <td id="L10023" class="blob-num js-line-number" data-line-number="10023"></td>
+ <td id="LC10023" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">key</span> The name of the property to resolve.</span></td>
+ </tr>
+ <tr>
+ <td id="L10024" class="blob-num js-line-number" data-line-number="10024"></td>
+ <td id="LC10024" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the resolved value.</span></td>
+ </tr>
+ <tr>
+ <td id="L10025" class="blob-num js-line-number" data-line-number="10025"></td>
+ <td id="LC10025" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10026" class="blob-num js-line-number" data-line-number="10026"></td>
+ <td id="LC10026" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10027" class="blob-num js-line-number" data-line-number="10027"></td>
+ <td id="LC10027" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var object = {</span></td>
+ </tr>
+ <tr>
+ <td id="L10028" class="blob-num js-line-number" data-line-number="10028"></td>
+ <td id="LC10028" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'cheese': 'crumpets',</span></td>
+ </tr>
+ <tr>
+ <td id="L10029" class="blob-num js-line-number" data-line-number="10029"></td>
+ <td id="LC10029" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'stuff': function() {</span></td>
+ </tr>
+ <tr>
+ <td id="L10030" class="blob-num js-line-number" data-line-number="10030"></td>
+ <td id="LC10030" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return 'nonsense';</span></td>
+ </tr>
+ <tr>
+ <td id="L10031" class="blob-num js-line-number" data-line-number="10031"></td>
+ <td id="LC10031" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L10032" class="blob-num js-line-number" data-line-number="10032"></td>
+ <td id="LC10032" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L10033" class="blob-num js-line-number" data-line-number="10033"></td>
+ <td id="LC10033" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10034" class="blob-num js-line-number" data-line-number="10034"></td>
+ <td id="LC10034" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.result(object, 'cheese');</span></td>
+ </tr>
+ <tr>
+ <td id="L10035" class="blob-num js-line-number" data-line-number="10035"></td>
+ <td id="LC10035" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'crumpets'</span></td>
+ </tr>
+ <tr>
+ <td id="L10036" class="blob-num js-line-number" data-line-number="10036"></td>
+ <td id="LC10036" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10037" class="blob-num js-line-number" data-line-number="10037"></td>
+ <td id="LC10037" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.result(object, 'stuff');</span></td>
+ </tr>
+ <tr>
+ <td id="L10038" class="blob-num js-line-number" data-line-number="10038"></td>
+ <td id="LC10038" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'nonsense'</span></td>
+ </tr>
+ <tr>
+ <td id="L10039" class="blob-num js-line-number" data-line-number="10039"></td>
+ <td id="LC10039" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10040" class="blob-num js-line-number" data-line-number="10040"></td>
+ <td id="LC10040" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">result</span>(<span class="pl-smi">object</span>, <span class="pl-smi">key</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10041" class="blob-num js-line-number" data-line-number="10041"></td>
+ <td id="LC10041" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (object) {</td>
+ </tr>
+ <tr>
+ <td id="L10042" class="blob-num js-line-number" data-line-number="10042"></td>
+ <td id="LC10042" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> value <span class="pl-k">=</span> object[key];</td>
+ </tr>
+ <tr>
+ <td id="L10043" class="blob-num js-line-number" data-line-number="10043"></td>
+ <td id="LC10043" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">isFunction</span>(value) <span class="pl-k">?</span> object[key]() <span class="pl-k">:</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L10044" class="blob-num js-line-number" data-line-number="10044"></td>
+ <td id="LC10044" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10045" class="blob-num js-line-number" data-line-number="10045"></td>
+ <td id="LC10045" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10046" class="blob-num js-line-number" data-line-number="10046"></td>
+ <td id="LC10046" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10047" class="blob-num js-line-number" data-line-number="10047"></td>
+ <td id="LC10047" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10048" class="blob-num js-line-number" data-line-number="10048"></td>
+ <td id="LC10048" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * A micro-templating method that handles arbitrary delimiters, preserves</span></td>
+ </tr>
+ <tr>
+ <td id="L10049" class="blob-num js-line-number" data-line-number="10049"></td>
+ <td id="LC10049" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * whitespace, and correctly escapes quotes within interpolated code.</span></td>
+ </tr>
+ <tr>
+ <td id="L10050" class="blob-num js-line-number" data-line-number="10050"></td>
+ <td id="LC10050" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10051" class="blob-num js-line-number" data-line-number="10051"></td>
+ <td id="LC10051" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Note: In the development build, `_.template` utilizes sourceURLs for easier</span></td>
+ </tr>
+ <tr>
+ <td id="L10052" class="blob-num js-line-number" data-line-number="10052"></td>
+ <td id="LC10052" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl</span></td>
+ </tr>
+ <tr>
+ <td id="L10053" class="blob-num js-line-number" data-line-number="10053"></td>
+ <td id="LC10053" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10054" class="blob-num js-line-number" data-line-number="10054"></td>
+ <td id="LC10054" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * For more information on precompiling templates see:</span></td>
+ </tr>
+ <tr>
+ <td id="L10055" class="blob-num js-line-number" data-line-number="10055"></td>
+ <td id="LC10055" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * https://lodash.com/custom-builds</span></td>
+ </tr>
+ <tr>
+ <td id="L10056" class="blob-num js-line-number" data-line-number="10056"></td>
+ <td id="LC10056" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10057" class="blob-num js-line-number" data-line-number="10057"></td>
+ <td id="LC10057" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * For more information on Chrome extension sandboxes see:</span></td>
+ </tr>
+ <tr>
+ <td id="L10058" class="blob-num js-line-number" data-line-number="10058"></td>
+ <td id="LC10058" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * http://developer.chrome.com/stable/extensions/sandboxingEval.html</span></td>
+ </tr>
+ <tr>
+ <td id="L10059" class="blob-num js-line-number" data-line-number="10059"></td>
+ <td id="LC10059" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10060" class="blob-num js-line-number" data-line-number="10060"></td>
+ <td id="LC10060" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10061" class="blob-num js-line-number" data-line-number="10061"></td>
+ <td id="LC10061" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10062" class="blob-num js-line-number" data-line-number="10062"></td>
+ <td id="LC10062" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L10063" class="blob-num js-line-number" data-line-number="10063"></td>
+ <td id="LC10063" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">text</span> The template text.</span></td>
+ </tr>
+ <tr>
+ <td id="L10064" class="blob-num js-line-number" data-line-number="10064"></td>
+ <td id="LC10064" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Object}</span> <span class="pl-smi">data</span> The data object used to populate the text.</span></td>
+ </tr>
+ <tr>
+ <td id="L10065" class="blob-num js-line-number" data-line-number="10065"></td>
+ <td id="LC10065" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [options] The options object.</span></td>
+ </tr>
+ <tr>
+ <td id="L10066" class="blob-num js-line-number" data-line-number="10066"></td>
+ <td id="LC10066" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {RegExp} [options.escape] The "escape" delimiter.</span></td>
+ </tr>
+ <tr>
+ <td id="L10067" class="blob-num js-line-number" data-line-number="10067"></td>
+ <td id="LC10067" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {RegExp} [options.evaluate] The "evaluate" delimiter.</span></td>
+ </tr>
+ <tr>
+ <td id="L10068" class="blob-num js-line-number" data-line-number="10068"></td>
+ <td id="LC10068" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {Object} [options.imports] An object to import into the template as local variables.</span></td>
+ </tr>
+ <tr>
+ <td id="L10069" class="blob-num js-line-number" data-line-number="10069"></td>
+ <td id="LC10069" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {RegExp} [options.interpolate] The "interpolate" delimiter.</span></td>
+ </tr>
+ <tr>
+ <td id="L10070" class="blob-num js-line-number" data-line-number="10070"></td>
+ <td id="LC10070" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {string} [sourceURL] The sourceURL of the template's compiled source.</span></td>
+ </tr>
+ <tr>
+ <td id="L10071" class="blob-num js-line-number" data-line-number="10071"></td>
+ <td id="LC10071" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {string} [variable] The data object variable name.</span></td>
+ </tr>
+ <tr>
+ <td id="L10072" class="blob-num js-line-number" data-line-number="10072"></td>
+ <td id="LC10072" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {Function|string} Returns a compiled function when no `data` object</span></td>
+ </tr>
+ <tr>
+ <td id="L10073" class="blob-num js-line-number" data-line-number="10073"></td>
+ <td id="LC10073" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * is given, else it returns the interpolated text.</span></td>
+ </tr>
+ <tr>
+ <td id="L10074" class="blob-num js-line-number" data-line-number="10074"></td>
+ <td id="LC10074" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10075" class="blob-num js-line-number" data-line-number="10075"></td>
+ <td id="LC10075" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10076" class="blob-num js-line-number" data-line-number="10076"></td>
+ <td id="LC10076" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the "interpolate" delimiter to create a compiled template</span></td>
+ </tr>
+ <tr>
+ <td id="L10077" class="blob-num js-line-number" data-line-number="10077"></td>
+ <td id="LC10077" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var compiled = _.template('hello <%= name %>');</span></td>
+ </tr>
+ <tr>
+ <td id="L10078" class="blob-num js-line-number" data-line-number="10078"></td>
+ <td id="LC10078" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * compiled({ 'name': 'fred' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10079" class="blob-num js-line-number" data-line-number="10079"></td>
+ <td id="LC10079" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hello fred'</span></td>
+ </tr>
+ <tr>
+ <td id="L10080" class="blob-num js-line-number" data-line-number="10080"></td>
+ <td id="LC10080" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10081" class="blob-num js-line-number" data-line-number="10081"></td>
+ <td id="LC10081" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the "escape" delimiter to escape HTML in data property values</span></td>
+ </tr>
+ <tr>
+ <td id="L10082" class="blob-num js-line-number" data-line-number="10082"></td>
+ <td id="LC10082" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.template('<b><%- value %></b>', { 'value': '<script>' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10083" class="blob-num js-line-number" data-line-number="10083"></td>
+ <td id="LC10083" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => '<b><script></b>'</span></td>
+ </tr>
+ <tr>
+ <td id="L10084" class="blob-num js-line-number" data-line-number="10084"></td>
+ <td id="LC10084" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10085" class="blob-num js-line-number" data-line-number="10085"></td>
+ <td id="LC10085" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the "evaluate" delimiter to generate HTML</span></td>
+ </tr>
+ <tr>
+ <td id="L10086" class="blob-num js-line-number" data-line-number="10086"></td>
+ <td id="LC10086" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';</span></td>
+ </tr>
+ <tr>
+ <td id="L10087" class="blob-num js-line-number" data-line-number="10087"></td>
+ <td id="LC10087" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.template(list, { 'people': ['fred', 'barney'] });</span></td>
+ </tr>
+ <tr>
+ <td id="L10088" class="blob-num js-line-number" data-line-number="10088"></td>
+ <td id="LC10088" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => '<li>fred</li><li>barney</li>'</span></td>
+ </tr>
+ <tr>
+ <td id="L10089" class="blob-num js-line-number" data-line-number="10089"></td>
+ <td id="LC10089" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10090" class="blob-num js-line-number" data-line-number="10090"></td>
+ <td id="LC10090" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter</span></td>
+ </tr>
+ <tr>
+ <td id="L10091" class="blob-num js-line-number" data-line-number="10091"></td>
+ <td id="LC10091" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.template('hello ${ name }', { 'name': 'pebbles' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10092" class="blob-num js-line-number" data-line-number="10092"></td>
+ <td id="LC10092" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hello pebbles'</span></td>
+ </tr>
+ <tr>
+ <td id="L10093" class="blob-num js-line-number" data-line-number="10093"></td>
+ <td id="LC10093" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10094" class="blob-num js-line-number" data-line-number="10094"></td>
+ <td id="LC10094" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the internal `print` function in "evaluate" delimiters</span></td>
+ </tr>
+ <tr>
+ <td id="L10095" class="blob-num js-line-number" data-line-number="10095"></td>
+ <td id="LC10095" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.template('<% print("hello " + name); %>!', { 'name': 'barney' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10096" class="blob-num js-line-number" data-line-number="10096"></td>
+ <td id="LC10096" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hello barney!'</span></td>
+ </tr>
+ <tr>
+ <td id="L10097" class="blob-num js-line-number" data-line-number="10097"></td>
+ <td id="LC10097" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10098" class="blob-num js-line-number" data-line-number="10098"></td>
+ <td id="LC10098" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using a custom template delimiters</span></td>
+ </tr>
+ <tr>
+ <td id="L10099" class="blob-num js-line-number" data-line-number="10099"></td>
+ <td id="LC10099" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.templateSettings = {</span></td>
+ </tr>
+ <tr>
+ <td id="L10100" class="blob-num js-line-number" data-line-number="10100"></td>
+ <td id="LC10100" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * 'interpolate': /{{([\s\S]+?)}}/g</span></td>
+ </tr>
+ <tr>
+ <td id="L10101" class="blob-num js-line-number" data-line-number="10101"></td>
+ <td id="LC10101" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };</span></td>
+ </tr>
+ <tr>
+ <td id="L10102" class="blob-num js-line-number" data-line-number="10102"></td>
+ <td id="LC10102" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10103" class="blob-num js-line-number" data-line-number="10103"></td>
+ <td id="LC10103" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.template('hello {{ name }}!', { 'name': 'mustache' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10104" class="blob-num js-line-number" data-line-number="10104"></td>
+ <td id="LC10104" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'hello mustache!'</span></td>
+ </tr>
+ <tr>
+ <td id="L10105" class="blob-num js-line-number" data-line-number="10105"></td>
+ <td id="LC10105" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10106" class="blob-num js-line-number" data-line-number="10106"></td>
+ <td id="LC10106" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the `imports` option to import jQuery</span></td>
+ </tr>
+ <tr>
+ <td id="L10107" class="blob-num js-line-number" data-line-number="10107"></td>
+ <td id="LC10107" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var list = '<% jq.each(people, function(name) { %><li><%- name %></li><% }); %>';</span></td>
+ </tr>
+ <tr>
+ <td id="L10108" class="blob-num js-line-number" data-line-number="10108"></td>
+ <td id="LC10108" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { 'jq': jQuery } });</span></td>
+ </tr>
+ <tr>
+ <td id="L10109" class="blob-num js-line-number" data-line-number="10109"></td>
+ <td id="LC10109" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => '<li>fred</li><li>barney</li>'</span></td>
+ </tr>
+ <tr>
+ <td id="L10110" class="blob-num js-line-number" data-line-number="10110"></td>
+ <td id="LC10110" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10111" class="blob-num js-line-number" data-line-number="10111"></td>
+ <td id="LC10111" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the `sourceURL` option to specify a custom sourceURL for the template</span></td>
+ </tr>
+ <tr>
+ <td id="L10112" class="blob-num js-line-number" data-line-number="10112"></td>
+ <td id="LC10112" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10113" class="blob-num js-line-number" data-line-number="10113"></td>
+ <td id="LC10113" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * compiled(data);</span></td>
+ </tr>
+ <tr>
+ <td id="L10114" class="blob-num js-line-number" data-line-number="10114"></td>
+ <td id="LC10114" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector</span></td>
+ </tr>
+ <tr>
+ <td id="L10115" class="blob-num js-line-number" data-line-number="10115"></td>
+ <td id="LC10115" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10116" class="blob-num js-line-number" data-line-number="10116"></td>
+ <td id="LC10116" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the `variable` option to ensure a with-statement isn't used in the compiled template</span></td>
+ </tr>
+ <tr>
+ <td id="L10117" class="blob-num js-line-number" data-line-number="10117"></td>
+ <td id="LC10117" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });</span></td>
+ </tr>
+ <tr>
+ <td id="L10118" class="blob-num js-line-number" data-line-number="10118"></td>
+ <td id="LC10118" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * compiled.source;</span></td>
+ </tr>
+ <tr>
+ <td id="L10119" class="blob-num js-line-number" data-line-number="10119"></td>
+ <td id="LC10119" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => function(data) {</span></td>
+ </tr>
+ <tr>
+ <td id="L10120" class="blob-num js-line-number" data-line-number="10120"></td>
+ <td id="LC10120" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var __t, __p = '', __e = _.escape;</span></td>
+ </tr>
+ <tr>
+ <td id="L10121" class="blob-num js-line-number" data-line-number="10121"></td>
+ <td id="LC10121" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';</span></td>
+ </tr>
+ <tr>
+ <td id="L10122" class="blob-num js-line-number" data-line-number="10122"></td>
+ <td id="LC10122" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * return __p;</span></td>
+ </tr>
+ <tr>
+ <td id="L10123" class="blob-num js-line-number" data-line-number="10123"></td>
+ <td id="LC10123" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * }</span></td>
+ </tr>
+ <tr>
+ <td id="L10124" class="blob-num js-line-number" data-line-number="10124"></td>
+ <td id="LC10124" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10125" class="blob-num js-line-number" data-line-number="10125"></td>
+ <td id="LC10125" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // using the `source` property to inline compiled templates for meaningful</span></td>
+ </tr>
+ <tr>
+ <td id="L10126" class="blob-num js-line-number" data-line-number="10126"></td>
+ <td id="LC10126" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // line numbers in error messages and a stack trace</span></td>
+ </tr>
+ <tr>
+ <td id="L10127" class="blob-num js-line-number" data-line-number="10127"></td>
+ <td id="LC10127" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * fs.writeFileSync(path.join(cwd, 'jst.js'), '\</span></td>
+ </tr>
+ <tr>
+ <td id="L10128" class="blob-num js-line-number" data-line-number="10128"></td>
+ <td id="LC10128" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var JST = {\</span></td>
+ </tr>
+ <tr>
+ <td id="L10129" class="blob-num js-line-number" data-line-number="10129"></td>
+ <td id="LC10129" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * "main": ' + _.template(mainText).source + '\</span></td>
+ </tr>
+ <tr>
+ <td id="L10130" class="blob-num js-line-number" data-line-number="10130"></td>
+ <td id="LC10130" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * };\</span></td>
+ </tr>
+ <tr>
+ <td id="L10131" class="blob-num js-line-number" data-line-number="10131"></td>
+ <td id="LC10131" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ');</span></td>
+ </tr>
+ <tr>
+ <td id="L10132" class="blob-num js-line-number" data-line-number="10132"></td>
+ <td id="LC10132" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10133" class="blob-num js-line-number" data-line-number="10133"></td>
+ <td id="LC10133" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">template</span>(<span class="pl-smi">text</span>, <span class="pl-smi">data</span>, <span class="pl-smi">options</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10134" class="blob-num js-line-number" data-line-number="10134"></td>
+ <td id="LC10134" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// based on John Resig's `tmpl` implementation</span></td>
+ </tr>
+ <tr>
+ <td id="L10135" class="blob-num js-line-number" data-line-number="10135"></td>
+ <td id="LC10135" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://ejohn.org/blog/javascript-micro-templating/</span></td>
+ </tr>
+ <tr>
+ <td id="L10136" class="blob-num js-line-number" data-line-number="10136"></td>
+ <td id="LC10136" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// and Laura Doktorova's doT.js</span></td>
+ </tr>
+ <tr>
+ <td id="L10137" class="blob-num js-line-number" data-line-number="10137"></td>
+ <td id="LC10137" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// https://github.com/olado/doT</span></td>
+ </tr>
+ <tr>
+ <td id="L10138" class="blob-num js-line-number" data-line-number="10138"></td>
+ <td id="LC10138" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> settings <span class="pl-k">=</span> <span class="pl-smi">lodash</span>.<span class="pl-smi">templateSettings</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10139" class="blob-num js-line-number" data-line-number="10139"></td>
+ <td id="LC10139" class="blob-code blob-code-inner js-file-line"> text <span class="pl-k">=</span> <span class="pl-c1">String</span>(text <span class="pl-k">||</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L10140" class="blob-num js-line-number" data-line-number="10140"></td>
+ <td id="LC10140" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10141" class="blob-num js-line-number" data-line-number="10141"></td>
+ <td id="LC10141" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// avoid missing dependencies when `iteratorTemplate` is not defined</span></td>
+ </tr>
+ <tr>
+ <td id="L10142" class="blob-num js-line-number" data-line-number="10142"></td>
+ <td id="LC10142" class="blob-code blob-code-inner js-file-line"> options <span class="pl-k">=</span> <span class="pl-en">defaults</span>({}, options, settings);</td>
+ </tr>
+ <tr>
+ <td id="L10143" class="blob-num js-line-number" data-line-number="10143"></td>
+ <td id="LC10143" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10144" class="blob-num js-line-number" data-line-number="10144"></td>
+ <td id="LC10144" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> imports <span class="pl-k">=</span> <span class="pl-en">defaults</span>({}, <span class="pl-smi">options</span>.<span class="pl-smi">imports</span>, <span class="pl-smi">settings</span>.<span class="pl-smi">imports</span>),</td>
+ </tr>
+ <tr>
+ <td id="L10145" class="blob-num js-line-number" data-line-number="10145"></td>
+ <td id="LC10145" class="blob-code blob-code-inner js-file-line"> importsKeys <span class="pl-k">=</span> <span class="pl-en">keys</span>(imports),</td>
+ </tr>
+ <tr>
+ <td id="L10146" class="blob-num js-line-number" data-line-number="10146"></td>
+ <td id="LC10146" class="blob-code blob-code-inner js-file-line"> importsValues <span class="pl-k">=</span> <span class="pl-en">values</span>(imports);</td>
+ </tr>
+ <tr>
+ <td id="L10147" class="blob-num js-line-number" data-line-number="10147"></td>
+ <td id="LC10147" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10148" class="blob-num js-line-number" data-line-number="10148"></td>
+ <td id="LC10148" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> isEvaluating,</td>
+ </tr>
+ <tr>
+ <td id="L10149" class="blob-num js-line-number" data-line-number="10149"></td>
+ <td id="LC10149" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> <span class="pl-c1">0</span>,</td>
+ </tr>
+ <tr>
+ <td id="L10150" class="blob-num js-line-number" data-line-number="10150"></td>
+ <td id="LC10150" class="blob-code blob-code-inner js-file-line"> interpolate <span class="pl-k">=</span> <span class="pl-smi">options</span>.<span class="pl-smi">interpolate</span> <span class="pl-k">||</span> reNoMatch,</td>
+ </tr>
+ <tr>
+ <td id="L10151" class="blob-num js-line-number" data-line-number="10151"></td>
+ <td id="LC10151" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">"</span>__p += '<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10152" class="blob-num js-line-number" data-line-number="10152"></td>
+ <td id="LC10152" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10153" class="blob-num js-line-number" data-line-number="10153"></td>
+ <td id="LC10153" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// compile the regexp to match each delimiter</span></td>
+ </tr>
+ <tr>
+ <td id="L10154" class="blob-num js-line-number" data-line-number="10154"></td>
+ <td id="LC10154" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> reDelimiters <span class="pl-k">=</span> <span class="pl-c1">RegExp</span>(</td>
+ </tr>
+ <tr>
+ <td id="L10155" class="blob-num js-line-number" data-line-number="10155"></td>
+ <td id="LC10155" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">options</span>.<span class="pl-smi">escape</span> <span class="pl-k">||</span> reNoMatch).<span class="pl-c1">source</span> <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>|<span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10156" class="blob-num js-line-number" data-line-number="10156"></td>
+ <td id="LC10156" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">interpolate</span>.<span class="pl-c1">source</span> <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>|<span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10157" class="blob-num js-line-number" data-line-number="10157"></td>
+ <td id="LC10157" class="blob-code blob-code-inner js-file-line"> (interpolate <span class="pl-k">===</span> reInterpolate <span class="pl-k">?</span> reEsTemplate <span class="pl-k">:</span> reNoMatch).<span class="pl-c1">source</span> <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>|<span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10158" class="blob-num js-line-number" data-line-number="10158"></td>
+ <td id="LC10158" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">options</span>.<span class="pl-smi">evaluate</span> <span class="pl-k">||</span> reNoMatch).<span class="pl-c1">source</span> <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>|$<span class="pl-pds">'</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10159" class="blob-num js-line-number" data-line-number="10159"></td>
+ <td id="LC10159" class="blob-code blob-code-inner js-file-line"> , <span class="pl-s"><span class="pl-pds">'</span>g<span class="pl-pds">'</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L10160" class="blob-num js-line-number" data-line-number="10160"></td>
+ <td id="LC10160" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10161" class="blob-num js-line-number" data-line-number="10161"></td>
+ <td id="LC10161" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">text</span>.<span class="pl-c1">replace</span>(reDelimiters, <span class="pl-k">function</span>(<span class="pl-smi">match</span>, <span class="pl-smi">escapeValue</span>, <span class="pl-smi">interpolateValue</span>, <span class="pl-smi">esTemplateValue</span>, <span class="pl-smi">evaluateValue</span>, <span class="pl-smi">offset</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10162" class="blob-num js-line-number" data-line-number="10162"></td>
+ <td id="LC10162" class="blob-code blob-code-inner js-file-line"> interpolateValue <span class="pl-k">||</span> (interpolateValue <span class="pl-k">=</span> esTemplateValue);</td>
+ </tr>
+ <tr>
+ <td id="L10163" class="blob-num js-line-number" data-line-number="10163"></td>
+ <td id="LC10163" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10164" class="blob-num js-line-number" data-line-number="10164"></td>
+ <td id="LC10164" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// escape characters that cannot be included in string literals</span></td>
+ </tr>
+ <tr>
+ <td id="L10165" class="blob-num js-line-number" data-line-number="10165"></td>
+ <td id="LC10165" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">+=</span> <span class="pl-smi">text</span>.<span class="pl-c1">slice</span>(index, offset).<span class="pl-c1">replace</span>(reUnescapedString, escapeStringChar);</td>
+ </tr>
+ <tr>
+ <td id="L10166" class="blob-num js-line-number" data-line-number="10166"></td>
+ <td id="LC10166" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10167" class="blob-num js-line-number" data-line-number="10167"></td>
+ <td id="LC10167" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// replace delimiters with snippets</span></td>
+ </tr>
+ <tr>
+ <td id="L10168" class="blob-num js-line-number" data-line-number="10168"></td>
+ <td id="LC10168" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (escapeValue) {</td>
+ </tr>
+ <tr>
+ <td id="L10169" class="blob-num js-line-number" data-line-number="10169"></td>
+ <td id="LC10169" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">+=</span> <span class="pl-s"><span class="pl-pds">"</span>' +<span class="pl-cce">\n</span>__e(<span class="pl-pds">"</span></span> <span class="pl-k">+</span> escapeValue <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>) +<span class="pl-cce">\n</span>'<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10170" class="blob-num js-line-number" data-line-number="10170"></td>
+ <td id="LC10170" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10171" class="blob-num js-line-number" data-line-number="10171"></td>
+ <td id="LC10171" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (evaluateValue) {</td>
+ </tr>
+ <tr>
+ <td id="L10172" class="blob-num js-line-number" data-line-number="10172"></td>
+ <td id="LC10172" class="blob-code blob-code-inner js-file-line"> isEvaluating <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10173" class="blob-num js-line-number" data-line-number="10173"></td>
+ <td id="LC10173" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">+=</span> <span class="pl-s"><span class="pl-pds">"</span>';<span class="pl-cce">\n</span><span class="pl-pds">"</span></span> <span class="pl-k">+</span> evaluateValue <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>;<span class="pl-cce">\n</span>__p += '<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10174" class="blob-num js-line-number" data-line-number="10174"></td>
+ <td id="LC10174" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10175" class="blob-num js-line-number" data-line-number="10175"></td>
+ <td id="LC10175" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (interpolateValue) {</td>
+ </tr>
+ <tr>
+ <td id="L10176" class="blob-num js-line-number" data-line-number="10176"></td>
+ <td id="LC10176" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">+=</span> <span class="pl-s"><span class="pl-pds">"</span>' +<span class="pl-cce">\n</span>((__t = (<span class="pl-pds">"</span></span> <span class="pl-k">+</span> interpolateValue <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">"</span>)) == null ? '' : __t) +<span class="pl-cce">\n</span>'<span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10177" class="blob-num js-line-number" data-line-number="10177"></td>
+ <td id="LC10177" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10178" class="blob-num js-line-number" data-line-number="10178"></td>
+ <td id="LC10178" class="blob-code blob-code-inner js-file-line"> index <span class="pl-k">=</span> offset <span class="pl-k">+</span> <span class="pl-smi">match</span>.<span class="pl-c1">length</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10179" class="blob-num js-line-number" data-line-number="10179"></td>
+ <td id="LC10179" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10180" class="blob-num js-line-number" data-line-number="10180"></td>
+ <td id="LC10180" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// the JS engine embedded in Adobe products requires returning the `match`</span></td>
+ </tr>
+ <tr>
+ <td id="L10181" class="blob-num js-line-number" data-line-number="10181"></td>
+ <td id="LC10181" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// string in order to produce the correct `offset` value</span></td>
+ </tr>
+ <tr>
+ <td id="L10182" class="blob-num js-line-number" data-line-number="10182"></td>
+ <td id="LC10182" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> match;</td>
+ </tr>
+ <tr>
+ <td id="L10183" class="blob-num js-line-number" data-line-number="10183"></td>
+ <td id="LC10183" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10184" class="blob-num js-line-number" data-line-number="10184"></td>
+ <td id="LC10184" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10185" class="blob-num js-line-number" data-line-number="10185"></td>
+ <td id="LC10185" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">+=</span> <span class="pl-s"><span class="pl-pds">"</span>';<span class="pl-cce">\n</span><span class="pl-pds">"</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10186" class="blob-num js-line-number" data-line-number="10186"></td>
+ <td id="LC10186" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10187" class="blob-num js-line-number" data-line-number="10187"></td>
+ <td id="LC10187" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// if `variable` is not specified, wrap a with-statement around the generated</span></td>
+ </tr>
+ <tr>
+ <td id="L10188" class="blob-num js-line-number" data-line-number="10188"></td>
+ <td id="LC10188" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// code to add the data object to the top of the scope chain</span></td>
+ </tr>
+ <tr>
+ <td id="L10189" class="blob-num js-line-number" data-line-number="10189"></td>
+ <td id="LC10189" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> variable <span class="pl-k">=</span> <span class="pl-smi">options</span>.<span class="pl-smi">variable</span>,</td>
+ </tr>
+ <tr>
+ <td id="L10190" class="blob-num js-line-number" data-line-number="10190"></td>
+ <td id="LC10190" class="blob-code blob-code-inner js-file-line"> hasVariable <span class="pl-k">=</span> variable;</td>
+ </tr>
+ <tr>
+ <td id="L10191" class="blob-num js-line-number" data-line-number="10191"></td>
+ <td id="LC10191" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10192" class="blob-num js-line-number" data-line-number="10192"></td>
+ <td id="LC10192" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span>hasVariable) {</td>
+ </tr>
+ <tr>
+ <td id="L10193" class="blob-num js-line-number" data-line-number="10193"></td>
+ <td id="LC10193" class="blob-code blob-code-inner js-file-line"> variable <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>obj<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10194" class="blob-num js-line-number" data-line-number="10194"></td>
+ <td id="LC10194" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>with (<span class="pl-pds">'</span></span> <span class="pl-k">+</span> variable <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>) {<span class="pl-cce">\n</span><span class="pl-pds">'</span></span> <span class="pl-k">+</span> source <span class="pl-k">+</span> <span class="pl-s"><span [...]
+ </tr>
+ <tr>
+ <td id="L10195" class="blob-num js-line-number" data-line-number="10195"></td>
+ <td id="LC10195" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10196" class="blob-num js-line-number" data-line-number="10196"></td>
+ <td id="LC10196" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// cleanup code by stripping empty strings</span></td>
+ </tr>
+ <tr>
+ <td id="L10197" class="blob-num js-line-number" data-line-number="10197"></td>
+ <td id="LC10197" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">=</span> (isEvaluating <span class="pl-k">?</span> <span class="pl-smi">source</span>.<span class="pl-c1">replace</span>(reEmptyStringLeading, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>) <span class="pl-k">:</span> source)</td>
+ </tr>
+ <tr>
+ <td id="L10198" class="blob-num js-line-number" data-line-number="10198"></td>
+ <td id="LC10198" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(reEmptyStringMiddle, <span class="pl-s"><span class="pl-pds">'</span>$1<span class="pl-pds">'</span></span>)</td>
+ </tr>
+ <tr>
+ <td id="L10199" class="blob-num js-line-number" data-line-number="10199"></td>
+ <td id="LC10199" class="blob-code blob-code-inner js-file-line"> .<span class="pl-c1">replace</span>(reEmptyStringTrailing, <span class="pl-s"><span class="pl-pds">'</span>$1;<span class="pl-pds">'</span></span>);</td>
+ </tr>
+ <tr>
+ <td id="L10200" class="blob-num js-line-number" data-line-number="10200"></td>
+ <td id="LC10200" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10201" class="blob-num js-line-number" data-line-number="10201"></td>
+ <td id="LC10201" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// frame code as the function body</span></td>
+ </tr>
+ <tr>
+ <td id="L10202" class="blob-num js-line-number" data-line-number="10202"></td>
+ <td id="LC10202" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>function(<span class="pl-pds">'</span></span> <span class="pl-k">+</span> variable <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span>) {<span class="pl-cce">\n</span><span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10203" class="blob-num js-line-number" data-line-number="10203"></td>
+ <td id="LC10203" class="blob-code blob-code-inner js-file-line"> (hasVariable <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span> <span class="pl-k">:</span> variable <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</span> || (<span class="pl-pds">'</span></span> <span class="pl-k">+</span> variable <span class="pl-k">+</span> <span class="pl-s"><span class="pl-pds">'</spa [...]
+ </tr>
+ <tr>
+ <td id="L10204" class="blob-num js-line-number" data-line-number="10204"></td>
+ <td id="LC10204" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span>var __t, __p = '', __e = _.escape<span class="pl-pds">"</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10205" class="blob-num js-line-number" data-line-number="10205"></td>
+ <td id="LC10205" class="blob-code blob-code-inner js-file-line"> (isEvaluating</td>
+ </tr>
+ <tr>
+ <td id="L10206" class="blob-num js-line-number" data-line-number="10206"></td>
+ <td id="LC10206" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">'</span>, __j = Array.prototype.join;<span class="pl-cce">\n</span><span class="pl-pds">'</span></span> <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10207" class="blob-num js-line-number" data-line-number="10207"></td>
+ <td id="LC10207" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">"</span>function print() { __p += __j.call(arguments, '') }<span class="pl-cce">\n</span><span class="pl-pds">"</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10208" class="blob-num js-line-number" data-line-number="10208"></td>
+ <td id="LC10208" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-s"><span class="pl-pds">'</span>;<span class="pl-cce">\n</span><span class="pl-pds">'</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10209" class="blob-num js-line-number" data-line-number="10209"></td>
+ <td id="LC10209" class="blob-code blob-code-inner js-file-line"> ) <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10210" class="blob-num js-line-number" data-line-number="10210"></td>
+ <td id="LC10210" class="blob-code blob-code-inner js-file-line"> source <span class="pl-k">+</span></td>
+ </tr>
+ <tr>
+ <td id="L10211" class="blob-num js-line-number" data-line-number="10211"></td>
+ <td id="LC10211" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>return __p<span class="pl-cce">\n</span>}<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10212" class="blob-num js-line-number" data-line-number="10212"></td>
+ <td id="LC10212" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10213" class="blob-num js-line-number" data-line-number="10213"></td>
+ <td id="LC10213" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Use a sourceURL for easier debugging.</span></td>
+ </tr>
+ <tr>
+ <td id="L10214" class="blob-num js-line-number" data-line-number="10214"></td>
+ <td id="LC10214" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl</span></td>
+ </tr>
+ <tr>
+ <td id="L10215" class="blob-num js-line-number" data-line-number="10215"></td>
+ <td id="LC10215" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> sourceURL <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\n</span>/*<span class="pl-cce">\n</span>//# sourceURL=<span class="pl-pds">'</span></span> <span class="pl-k">+</span> (<span class="pl-smi">options</span>.<span class="pl-smi">sourceURL</span> <span class="pl-k">||</span> <span class="pl-s"><span class="pl-pds">' [...]
+ </tr>
+ <tr>
+ <td id="L10216" class="blob-num js-line-number" data-line-number="10216"></td>
+ <td id="LC10216" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10217" class="blob-num js-line-number" data-line-number="10217"></td>
+ <td id="LC10217" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span> {</td>
+ </tr>
+ <tr>
+ <td id="L10218" class="blob-num js-line-number" data-line-number="10218"></td>
+ <td id="LC10218" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> result <span class="pl-k">=</span> <span class="pl-c1">Function</span>(importsKeys, <span class="pl-s"><span class="pl-pds">'</span>return <span class="pl-pds">'</span></span> <span class="pl-k">+</span> source <span class="pl-k">+</span> sourceURL).<span class="pl-c1">apply</span>(<span class="pl-c1">undefined</span>, importsValues);</td>
+ </tr>
+ <tr>
+ <td id="L10219" class="blob-num js-line-number" data-line-number="10219"></td>
+ <td id="LC10219" class="blob-code blob-code-inner js-file-line"> } <span class="pl-k">catch</span>(e) {</td>
+ </tr>
+ <tr>
+ <td id="L10220" class="blob-num js-line-number" data-line-number="10220"></td>
+ <td id="LC10220" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">e</span>.<span class="pl-c1">source</span> <span class="pl-k">=</span> source;</td>
+ </tr>
+ <tr>
+ <td id="L10221" class="blob-num js-line-number" data-line-number="10221"></td>
+ <td id="LC10221" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">throw</span> e;</td>
+ </tr>
+ <tr>
+ <td id="L10222" class="blob-num js-line-number" data-line-number="10222"></td>
+ <td id="LC10222" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10223" class="blob-num js-line-number" data-line-number="10223"></td>
+ <td id="LC10223" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (data) {</td>
+ </tr>
+ <tr>
+ <td id="L10224" class="blob-num js-line-number" data-line-number="10224"></td>
+ <td id="LC10224" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-en">result</span>(data);</td>
+ </tr>
+ <tr>
+ <td id="L10225" class="blob-num js-line-number" data-line-number="10225"></td>
+ <td id="LC10225" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10226" class="blob-num js-line-number" data-line-number="10226"></td>
+ <td id="LC10226" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// provide the compiled function's source by its `toString` method, in</span></td>
+ </tr>
+ <tr>
+ <td id="L10227" class="blob-num js-line-number" data-line-number="10227"></td>
+ <td id="LC10227" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// supported environments, or the `source` property as a convenience for</span></td>
+ </tr>
+ <tr>
+ <td id="L10228" class="blob-num js-line-number" data-line-number="10228"></td>
+ <td id="LC10228" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// inlining compiled templates during the build process</span></td>
+ </tr>
+ <tr>
+ <td id="L10229" class="blob-num js-line-number" data-line-number="10229"></td>
+ <td id="LC10229" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">result</span>.<span class="pl-c1">source</span> <span class="pl-k">=</span> source;</td>
+ </tr>
+ <tr>
+ <td id="L10230" class="blob-num js-line-number" data-line-number="10230"></td>
+ <td id="LC10230" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L10231" class="blob-num js-line-number" data-line-number="10231"></td>
+ <td id="LC10231" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10232" class="blob-num js-line-number" data-line-number="10232"></td>
+ <td id="LC10232" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10233" class="blob-num js-line-number" data-line-number="10233"></td>
+ <td id="LC10233" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10234" class="blob-num js-line-number" data-line-number="10234"></td>
+ <td id="LC10234" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Executes the callback `n` times, returning an array of the results</span></td>
+ </tr>
+ <tr>
+ <td id="L10235" class="blob-num js-line-number" data-line-number="10235"></td>
+ <td id="LC10235" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * of each callback execution. The callback is bound to `thisArg` and invoked</span></td>
+ </tr>
+ <tr>
+ <td id="L10236" class="blob-num js-line-number" data-line-number="10236"></td>
+ <td id="LC10236" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * with one argument; (index).</span></td>
+ </tr>
+ <tr>
+ <td id="L10237" class="blob-num js-line-number" data-line-number="10237"></td>
+ <td id="LC10237" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10238" class="blob-num js-line-number" data-line-number="10238"></td>
+ <td id="LC10238" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10239" class="blob-num js-line-number" data-line-number="10239"></td>
+ <td id="LC10239" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10240" class="blob-num js-line-number" data-line-number="10240"></td>
+ <td id="LC10240" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L10241" class="blob-num js-line-number" data-line-number="10241"></td>
+ <td id="LC10241" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{number}</span> <span class="pl-smi">n</span> The number of times to execute the callback.</span></td>
+ </tr>
+ <tr>
+ <td id="L10242" class="blob-num js-line-number" data-line-number="10242"></td>
+ <td id="LC10242" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">callback</span> The function called per iteration.</span></td>
+ </tr>
+ <tr>
+ <td id="L10243" class="blob-num js-line-number" data-line-number="10243"></td>
+ <td id="LC10243" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} [thisArg] The `this` binding of `callback`.</span></td>
+ </tr>
+ <tr>
+ <td id="L10244" class="blob-num js-line-number" data-line-number="10244"></td>
+ <td id="LC10244" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Array}</span> <span class="pl-smi">Returns</span> an array of the results of each `callback` execution.</span></td>
+ </tr>
+ <tr>
+ <td id="L10245" class="blob-num js-line-number" data-line-number="10245"></td>
+ <td id="LC10245" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10246" class="blob-num js-line-number" data-line-number="10246"></td>
+ <td id="LC10246" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10247" class="blob-num js-line-number" data-line-number="10247"></td>
+ <td id="LC10247" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var diceRolls = _.times(3, _.partial(_.random, 1, 6));</span></td>
+ </tr>
+ <tr>
+ <td id="L10248" class="blob-num js-line-number" data-line-number="10248"></td>
+ <td id="LC10248" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 6, 4]</span></td>
+ </tr>
+ <tr>
+ <td id="L10249" class="blob-num js-line-number" data-line-number="10249"></td>
+ <td id="LC10249" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10250" class="blob-num js-line-number" data-line-number="10250"></td>
+ <td id="LC10250" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.times(3, function(n) { mage.castSpell(n); });</span></td>
+ </tr>
+ <tr>
+ <td id="L10251" class="blob-num js-line-number" data-line-number="10251"></td>
+ <td id="LC10251" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively</span></td>
+ </tr>
+ <tr>
+ <td id="L10252" class="blob-num js-line-number" data-line-number="10252"></td>
+ <td id="LC10252" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10253" class="blob-num js-line-number" data-line-number="10253"></td>
+ <td id="LC10253" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.times(3, function(n) { this.cast(n); }, mage);</span></td>
+ </tr>
+ <tr>
+ <td id="L10254" class="blob-num js-line-number" data-line-number="10254"></td>
+ <td id="LC10254" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => also calls `mage.castSpell(n)` three times</span></td>
+ </tr>
+ <tr>
+ <td id="L10255" class="blob-num js-line-number" data-line-number="10255"></td>
+ <td id="LC10255" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10256" class="blob-num js-line-number" data-line-number="10256"></td>
+ <td id="LC10256" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">times</span>(<span class="pl-smi">n</span>, <span class="pl-smi">callback</span>, <span class="pl-smi">thisArg</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10257" class="blob-num js-line-number" data-line-number="10257"></td>
+ <td id="LC10257" class="blob-code blob-code-inner js-file-line"> n <span class="pl-k">=</span> (n <span class="pl-k">=</span> <span class="pl-k">+</span>n) <span class="pl-k">></span> <span class="pl-k">-</span><span class="pl-c1">1</span> <span class="pl-k">?</span> n <span class="pl-k">:</span> <span class="pl-c1">0</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10258" class="blob-num js-line-number" data-line-number="10258"></td>
+ <td id="LC10258" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> index <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span>,</td>
+ </tr>
+ <tr>
+ <td id="L10259" class="blob-num js-line-number" data-line-number="10259"></td>
+ <td id="LC10259" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-c1">Array</span>(n);</td>
+ </tr>
+ <tr>
+ <td id="L10260" class="blob-num js-line-number" data-line-number="10260"></td>
+ <td id="LC10260" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10261" class="blob-num js-line-number" data-line-number="10261"></td>
+ <td id="LC10261" class="blob-code blob-code-inner js-file-line"> callback <span class="pl-k">=</span> <span class="pl-en">baseCreateCallback</span>(callback, thisArg, <span class="pl-c1">1</span>);</td>
+ </tr>
+ <tr>
+ <td id="L10262" class="blob-num js-line-number" data-line-number="10262"></td>
+ <td id="LC10262" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (<span class="pl-k">++</span>index <span class="pl-k"><</span> n) {</td>
+ </tr>
+ <tr>
+ <td id="L10263" class="blob-num js-line-number" data-line-number="10263"></td>
+ <td id="LC10263" class="blob-code blob-code-inner js-file-line"> result[index] <span class="pl-k">=</span> <span class="pl-en">callback</span>(index);</td>
+ </tr>
+ <tr>
+ <td id="L10264" class="blob-num js-line-number" data-line-number="10264"></td>
+ <td id="LC10264" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10265" class="blob-num js-line-number" data-line-number="10265"></td>
+ <td id="LC10265" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L10266" class="blob-num js-line-number" data-line-number="10266"></td>
+ <td id="LC10266" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10267" class="blob-num js-line-number" data-line-number="10267"></td>
+ <td id="LC10267" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10268" class="blob-num js-line-number" data-line-number="10268"></td>
+ <td id="LC10268" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10269" class="blob-num js-line-number" data-line-number="10269"></td>
+ <td id="LC10269" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The inverse of `_.escape` this method converts the HTML entities</span></td>
+ </tr>
+ <tr>
+ <td id="L10270" class="blob-num js-line-number" data-line-number="10270"></td>
+ <td id="LC10270" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * `&`, `<`, `>`, `"`, and `'` in `string` to their</span></td>
+ </tr>
+ <tr>
+ <td id="L10271" class="blob-num js-line-number" data-line-number="10271"></td>
+ <td id="LC10271" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * corresponding characters.</span></td>
+ </tr>
+ <tr>
+ <td id="L10272" class="blob-num js-line-number" data-line-number="10272"></td>
+ <td id="LC10272" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10273" class="blob-num js-line-number" data-line-number="10273"></td>
+ <td id="LC10273" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10274" class="blob-num js-line-number" data-line-number="10274"></td>
+ <td id="LC10274" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10275" class="blob-num js-line-number" data-line-number="10275"></td>
+ <td id="LC10275" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L10276" class="blob-num js-line-number" data-line-number="10276"></td>
+ <td id="LC10276" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{string}</span> <span class="pl-smi">string</span> The string to unescape.</span></td>
+ </tr>
+ <tr>
+ <td id="L10277" class="blob-num js-line-number" data-line-number="10277"></td>
+ <td id="LC10277" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the unescaped string.</span></td>
+ </tr>
+ <tr>
+ <td id="L10278" class="blob-num js-line-number" data-line-number="10278"></td>
+ <td id="LC10278" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10279" class="blob-num js-line-number" data-line-number="10279"></td>
+ <td id="LC10279" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10280" class="blob-num js-line-number" data-line-number="10280"></td>
+ <td id="LC10280" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.unescape('Fred, Barney & Pebbles');</span></td>
+ </tr>
+ <tr>
+ <td id="L10281" class="blob-num js-line-number" data-line-number="10281"></td>
+ <td id="LC10281" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'Fred, Barney & Pebbles'</span></td>
+ </tr>
+ <tr>
+ <td id="L10282" class="blob-num js-line-number" data-line-number="10282"></td>
+ <td id="LC10282" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10283" class="blob-num js-line-number" data-line-number="10283"></td>
+ <td id="LC10283" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">unescape</span>(<span class="pl-smi">string</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10284" class="blob-num js-line-number" data-line-number="10284"></td>
+ <td id="LC10284" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> string <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span> <span class="pl-k">:</span> <span class="pl-c1">String</span>(string).<span class="pl-c1">replace</span>(reEscapedHtml, unescapeHtmlChar);</td>
+ </tr>
+ <tr>
+ <td id="L10285" class="blob-num js-line-number" data-line-number="10285"></td>
+ <td id="LC10285" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10286" class="blob-num js-line-number" data-line-number="10286"></td>
+ <td id="LC10286" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10287" class="blob-num js-line-number" data-line-number="10287"></td>
+ <td id="LC10287" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10288" class="blob-num js-line-number" data-line-number="10288"></td>
+ <td id="LC10288" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Generates a unique ID. If `prefix` is provided the ID will be appended to it.</span></td>
+ </tr>
+ <tr>
+ <td id="L10289" class="blob-num js-line-number" data-line-number="10289"></td>
+ <td id="LC10289" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10290" class="blob-num js-line-number" data-line-number="10290"></td>
+ <td id="LC10290" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10291" class="blob-num js-line-number" data-line-number="10291"></td>
+ <td id="LC10291" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10292" class="blob-num js-line-number" data-line-number="10292"></td>
+ <td id="LC10292" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Utilities</span></td>
+ </tr>
+ <tr>
+ <td id="L10293" class="blob-num js-line-number" data-line-number="10293"></td>
+ <td id="LC10293" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {string} [prefix] The value to prefix the ID with.</span></td>
+ </tr>
+ <tr>
+ <td id="L10294" class="blob-num js-line-number" data-line-number="10294"></td>
+ <td id="LC10294" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the unique ID.</span></td>
+ </tr>
+ <tr>
+ <td id="L10295" class="blob-num js-line-number" data-line-number="10295"></td>
+ <td id="LC10295" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10296" class="blob-num js-line-number" data-line-number="10296"></td>
+ <td id="LC10296" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10297" class="blob-num js-line-number" data-line-number="10297"></td>
+ <td id="LC10297" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniqueId('contact_');</span></td>
+ </tr>
+ <tr>
+ <td id="L10298" class="blob-num js-line-number" data-line-number="10298"></td>
+ <td id="LC10298" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'contact_104'</span></td>
+ </tr>
+ <tr>
+ <td id="L10299" class="blob-num js-line-number" data-line-number="10299"></td>
+ <td id="LC10299" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10300" class="blob-num js-line-number" data-line-number="10300"></td>
+ <td id="LC10300" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _.uniqueId();</span></td>
+ </tr>
+ <tr>
+ <td id="L10301" class="blob-num js-line-number" data-line-number="10301"></td>
+ <td id="LC10301" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => '105'</span></td>
+ </tr>
+ <tr>
+ <td id="L10302" class="blob-num js-line-number" data-line-number="10302"></td>
+ <td id="LC10302" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10303" class="blob-num js-line-number" data-line-number="10303"></td>
+ <td id="LC10303" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">uniqueId</span>(<span class="pl-smi">prefix</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10304" class="blob-num js-line-number" data-line-number="10304"></td>
+ <td id="LC10304" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> id <span class="pl-k">=</span> <span class="pl-k">++</span>idCounter;</td>
+ </tr>
+ <tr>
+ <td id="L10305" class="blob-num js-line-number" data-line-number="10305"></td>
+ <td id="LC10305" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">String</span>(prefix <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">?</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span> <span class="pl-k">:</span> prefix) <span class="pl-k">+</span> id;</td>
+ </tr>
+ <tr>
+ <td id="L10306" class="blob-num js-line-number" data-line-number="10306"></td>
+ <td id="LC10306" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10307" class="blob-num js-line-number" data-line-number="10307"></td>
+ <td id="LC10307" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10308" class="blob-num js-line-number" data-line-number="10308"></td>
+ <td id="LC10308" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L10309" class="blob-num js-line-number" data-line-number="10309"></td>
+ <td id="LC10309" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10310" class="blob-num js-line-number" data-line-number="10310"></td>
+ <td id="LC10310" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10311" class="blob-num js-line-number" data-line-number="10311"></td>
+ <td id="LC10311" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Creates a `lodash` object that wraps the given value with explicit</span></td>
+ </tr>
+ <tr>
+ <td id="L10312" class="blob-num js-line-number" data-line-number="10312"></td>
+ <td id="LC10312" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * method chaining enabled.</span></td>
+ </tr>
+ <tr>
+ <td id="L10313" class="blob-num js-line-number" data-line-number="10313"></td>
+ <td id="LC10313" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10314" class="blob-num js-line-number" data-line-number="10314"></td>
+ <td id="LC10314" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10315" class="blob-num js-line-number" data-line-number="10315"></td>
+ <td id="LC10315" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10316" class="blob-num js-line-number" data-line-number="10316"></td>
+ <td id="LC10316" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10317" class="blob-num js-line-number" data-line-number="10317"></td>
+ <td id="LC10317" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to wrap.</span></td>
+ </tr>
+ <tr>
+ <td id="L10318" class="blob-num js-line-number" data-line-number="10318"></td>
+ <td id="LC10318" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{Object}</span> <span class="pl-smi">Returns</span> the wrapper object.</span></td>
+ </tr>
+ <tr>
+ <td id="L10319" class="blob-num js-line-number" data-line-number="10319"></td>
+ <td id="LC10319" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10320" class="blob-num js-line-number" data-line-number="10320"></td>
+ <td id="LC10320" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10321" class="blob-num js-line-number" data-line-number="10321"></td>
+ <td id="LC10321" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L10322" class="blob-num js-line-number" data-line-number="10322"></td>
+ <td id="LC10322" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L10323" class="blob-num js-line-number" data-line-number="10323"></td>
+ <td id="LC10323" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 },</span></td>
+ </tr>
+ <tr>
+ <td id="L10324" class="blob-num js-line-number" data-line-number="10324"></td>
+ <td id="LC10324" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'pebbles', 'age': 1 }</span></td>
+ </tr>
+ <tr>
+ <td id="L10325" class="blob-num js-line-number" data-line-number="10325"></td>
+ <td id="LC10325" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L10326" class="blob-num js-line-number" data-line-number="10326"></td>
+ <td id="LC10326" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10327" class="blob-num js-line-number" data-line-number="10327"></td>
+ <td id="LC10327" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var youngest = _.chain(characters)</span></td>
+ </tr>
+ <tr>
+ <td id="L10328" class="blob-num js-line-number" data-line-number="10328"></td>
+ <td id="LC10328" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .sortBy('age')</span></td>
+ </tr>
+ <tr>
+ <td id="L10329" class="blob-num js-line-number" data-line-number="10329"></td>
+ <td id="LC10329" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .map(function(chr) { return chr.name + ' is ' + chr.age; })</span></td>
+ </tr>
+ <tr>
+ <td id="L10330" class="blob-num js-line-number" data-line-number="10330"></td>
+ <td id="LC10330" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .first()</span></td>
+ </tr>
+ <tr>
+ <td id="L10331" class="blob-num js-line-number" data-line-number="10331"></td>
+ <td id="LC10331" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .value();</span></td>
+ </tr>
+ <tr>
+ <td id="L10332" class="blob-num js-line-number" data-line-number="10332"></td>
+ <td id="LC10332" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => 'pebbles is 1'</span></td>
+ </tr>
+ <tr>
+ <td id="L10333" class="blob-num js-line-number" data-line-number="10333"></td>
+ <td id="LC10333" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10334" class="blob-num js-line-number" data-line-number="10334"></td>
+ <td id="LC10334" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">chain</span>(<span class="pl-smi">value</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10335" class="blob-num js-line-number" data-line-number="10335"></td>
+ <td id="LC10335" class="blob-code blob-code-inner js-file-line"> value <span class="pl-k">=</span> <span class="pl-k">new</span> <span class="pl-en">lodashWrapper</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L10336" class="blob-num js-line-number" data-line-number="10336"></td>
+ <td id="LC10336" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">value</span>.<span class="pl-smi">__chain__</span> <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10337" class="blob-num js-line-number" data-line-number="10337"></td>
+ <td id="LC10337" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L10338" class="blob-num js-line-number" data-line-number="10338"></td>
+ <td id="LC10338" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10339" class="blob-num js-line-number" data-line-number="10339"></td>
+ <td id="LC10339" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10340" class="blob-num js-line-number" data-line-number="10340"></td>
+ <td id="LC10340" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10341" class="blob-num js-line-number" data-line-number="10341"></td>
+ <td id="LC10341" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Invokes `interceptor` with the `value` as the first argument and then</span></td>
+ </tr>
+ <tr>
+ <td id="L10342" class="blob-num js-line-number" data-line-number="10342"></td>
+ <td id="LC10342" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * returns `value`. The purpose of this method is to "tap into" a method</span></td>
+ </tr>
+ <tr>
+ <td id="L10343" class="blob-num js-line-number" data-line-number="10343"></td>
+ <td id="LC10343" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * chain in order to perform operations on intermediate results within</span></td>
+ </tr>
+ <tr>
+ <td id="L10344" class="blob-num js-line-number" data-line-number="10344"></td>
+ <td id="LC10344" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * the chain.</span></td>
+ </tr>
+ <tr>
+ <td id="L10345" class="blob-num js-line-number" data-line-number="10345"></td>
+ <td id="LC10345" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10346" class="blob-num js-line-number" data-line-number="10346"></td>
+ <td id="LC10346" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10347" class="blob-num js-line-number" data-line-number="10347"></td>
+ <td id="LC10347" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10348" class="blob-num js-line-number" data-line-number="10348"></td>
+ <td id="LC10348" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10349" class="blob-num js-line-number" data-line-number="10349"></td>
+ <td id="LC10349" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> {*} value The value to provide to `interceptor`.</span></td>
+ </tr>
+ <tr>
+ <td id="L10350" class="blob-num js-line-number" data-line-number="10350"></td>
+ <td id="LC10350" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@param</span> <span class="pl-en">{Function}</span> <span class="pl-smi">interceptor</span> The function to invoke.</span></td>
+ </tr>
+ <tr>
+ <td id="L10351" class="blob-num js-line-number" data-line-number="10351"></td>
+ <td id="LC10351" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns `value`.</span></td>
+ </tr>
+ <tr>
+ <td id="L10352" class="blob-num js-line-number" data-line-number="10352"></td>
+ <td id="LC10352" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10353" class="blob-num js-line-number" data-line-number="10353"></td>
+ <td id="LC10353" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10354" class="blob-num js-line-number" data-line-number="10354"></td>
+ <td id="LC10354" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _([1, 2, 3, 4])</span></td>
+ </tr>
+ <tr>
+ <td id="L10355" class="blob-num js-line-number" data-line-number="10355"></td>
+ <td id="LC10355" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .tap(function(array) { array.pop(); })</span></td>
+ </tr>
+ <tr>
+ <td id="L10356" class="blob-num js-line-number" data-line-number="10356"></td>
+ <td id="LC10356" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .reverse()</span></td>
+ </tr>
+ <tr>
+ <td id="L10357" class="blob-num js-line-number" data-line-number="10357"></td>
+ <td id="LC10357" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .value();</span></td>
+ </tr>
+ <tr>
+ <td id="L10358" class="blob-num js-line-number" data-line-number="10358"></td>
+ <td id="LC10358" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [3, 2, 1]</span></td>
+ </tr>
+ <tr>
+ <td id="L10359" class="blob-num js-line-number" data-line-number="10359"></td>
+ <td id="LC10359" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10360" class="blob-num js-line-number" data-line-number="10360"></td>
+ <td id="LC10360" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">tap</span>(<span class="pl-smi">value</span>, <span class="pl-smi">interceptor</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10361" class="blob-num js-line-number" data-line-number="10361"></td>
+ <td id="LC10361" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">interceptor</span>(value);</td>
+ </tr>
+ <tr>
+ <td id="L10362" class="blob-num js-line-number" data-line-number="10362"></td>
+ <td id="LC10362" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> value;</td>
+ </tr>
+ <tr>
+ <td id="L10363" class="blob-num js-line-number" data-line-number="10363"></td>
+ <td id="LC10363" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10364" class="blob-num js-line-number" data-line-number="10364"></td>
+ <td id="LC10364" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10365" class="blob-num js-line-number" data-line-number="10365"></td>
+ <td id="LC10365" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10366" class="blob-num js-line-number" data-line-number="10366"></td>
+ <td id="LC10366" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Enables explicit method chaining on the wrapper object.</span></td>
+ </tr>
+ <tr>
+ <td id="L10367" class="blob-num js-line-number" data-line-number="10367"></td>
+ <td id="LC10367" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10368" class="blob-num js-line-number" data-line-number="10368"></td>
+ <td id="LC10368" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@name</span> chain</span></td>
+ </tr>
+ <tr>
+ <td id="L10369" class="blob-num js-line-number" data-line-number="10369"></td>
+ <td id="LC10369" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10370" class="blob-num js-line-number" data-line-number="10370"></td>
+ <td id="LC10370" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10371" class="blob-num js-line-number" data-line-number="10371"></td>
+ <td id="LC10371" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the wrapper object.</span></td>
+ </tr>
+ <tr>
+ <td id="L10372" class="blob-num js-line-number" data-line-number="10372"></td>
+ <td id="LC10372" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10373" class="blob-num js-line-number" data-line-number="10373"></td>
+ <td id="LC10373" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10374" class="blob-num js-line-number" data-line-number="10374"></td>
+ <td id="LC10374" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * var characters = [</span></td>
+ </tr>
+ <tr>
+ <td id="L10375" class="blob-num js-line-number" data-line-number="10375"></td>
+ <td id="LC10375" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'barney', 'age': 36 },</span></td>
+ </tr>
+ <tr>
+ <td id="L10376" class="blob-num js-line-number" data-line-number="10376"></td>
+ <td id="LC10376" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * { 'name': 'fred', 'age': 40 }</span></td>
+ </tr>
+ <tr>
+ <td id="L10377" class="blob-num js-line-number" data-line-number="10377"></td>
+ <td id="LC10377" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * ];</span></td>
+ </tr>
+ <tr>
+ <td id="L10378" class="blob-num js-line-number" data-line-number="10378"></td>
+ <td id="LC10378" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10379" class="blob-num js-line-number" data-line-number="10379"></td>
+ <td id="LC10379" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // without explicit chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10380" class="blob-num js-line-number" data-line-number="10380"></td>
+ <td id="LC10380" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _(characters).first();</span></td>
+ </tr>
+ <tr>
+ <td id="L10381" class="blob-num js-line-number" data-line-number="10381"></td>
+ <td id="LC10381" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'name': 'barney', 'age': 36 }</span></td>
+ </tr>
+ <tr>
+ <td id="L10382" class="blob-num js-line-number" data-line-number="10382"></td>
+ <td id="LC10382" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10383" class="blob-num js-line-number" data-line-number="10383"></td>
+ <td id="LC10383" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // with explicit chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10384" class="blob-num js-line-number" data-line-number="10384"></td>
+ <td id="LC10384" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _(characters).chain()</span></td>
+ </tr>
+ <tr>
+ <td id="L10385" class="blob-num js-line-number" data-line-number="10385"></td>
+ <td id="LC10385" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .first()</span></td>
+ </tr>
+ <tr>
+ <td id="L10386" class="blob-num js-line-number" data-line-number="10386"></td>
+ <td id="LC10386" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .pick('age')</span></td>
+ </tr>
+ <tr>
+ <td id="L10387" class="blob-num js-line-number" data-line-number="10387"></td>
+ <td id="LC10387" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * .value();</span></td>
+ </tr>
+ <tr>
+ <td id="L10388" class="blob-num js-line-number" data-line-number="10388"></td>
+ <td id="LC10388" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => { 'age': 36 }</span></td>
+ </tr>
+ <tr>
+ <td id="L10389" class="blob-num js-line-number" data-line-number="10389"></td>
+ <td id="LC10389" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10390" class="blob-num js-line-number" data-line-number="10390"></td>
+ <td id="LC10390" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">wrapperChain</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10391" class="blob-num js-line-number" data-line-number="10391"></td>
+ <td id="LC10391" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">this</span>.<span class="pl-smi">__chain__</span> <span class="pl-k">=</span> <span class="pl-c1">true</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10392" class="blob-num js-line-number" data-line-number="10392"></td>
+ <td id="LC10392" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10393" class="blob-num js-line-number" data-line-number="10393"></td>
+ <td id="LC10393" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10394" class="blob-num js-line-number" data-line-number="10394"></td>
+ <td id="LC10394" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10395" class="blob-num js-line-number" data-line-number="10395"></td>
+ <td id="LC10395" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10396" class="blob-num js-line-number" data-line-number="10396"></td>
+ <td id="LC10396" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Produces the `toString` result of the wrapped value.</span></td>
+ </tr>
+ <tr>
+ <td id="L10397" class="blob-num js-line-number" data-line-number="10397"></td>
+ <td id="LC10397" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10398" class="blob-num js-line-number" data-line-number="10398"></td>
+ <td id="LC10398" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@name</span> toString</span></td>
+ </tr>
+ <tr>
+ <td id="L10399" class="blob-num js-line-number" data-line-number="10399"></td>
+ <td id="LC10399" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10400" class="blob-num js-line-number" data-line-number="10400"></td>
+ <td id="LC10400" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10401" class="blob-num js-line-number" data-line-number="10401"></td>
+ <td id="LC10401" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> <span class="pl-en">{string}</span> <span class="pl-smi">Returns</span> the string result.</span></td>
+ </tr>
+ <tr>
+ <td id="L10402" class="blob-num js-line-number" data-line-number="10402"></td>
+ <td id="LC10402" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10403" class="blob-num js-line-number" data-line-number="10403"></td>
+ <td id="LC10403" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10404" class="blob-num js-line-number" data-line-number="10404"></td>
+ <td id="LC10404" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _([1, 2, 3]).toString();</span></td>
+ </tr>
+ <tr>
+ <td id="L10405" class="blob-num js-line-number" data-line-number="10405"></td>
+ <td id="LC10405" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => '1,2,3'</span></td>
+ </tr>
+ <tr>
+ <td id="L10406" class="blob-num js-line-number" data-line-number="10406"></td>
+ <td id="LC10406" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10407" class="blob-num js-line-number" data-line-number="10407"></td>
+ <td id="LC10407" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">wrapperToString</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10408" class="blob-num js-line-number" data-line-number="10408"></td>
+ <td id="LC10408" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">String</span>(<span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>);</td>
+ </tr>
+ <tr>
+ <td id="L10409" class="blob-num js-line-number" data-line-number="10409"></td>
+ <td id="LC10409" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10410" class="blob-num js-line-number" data-line-number="10410"></td>
+ <td id="LC10410" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10411" class="blob-num js-line-number" data-line-number="10411"></td>
+ <td id="LC10411" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10412" class="blob-num js-line-number" data-line-number="10412"></td>
+ <td id="LC10412" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * Extracts the wrapped value.</span></td>
+ </tr>
+ <tr>
+ <td id="L10413" class="blob-num js-line-number" data-line-number="10413"></td>
+ <td id="LC10413" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10414" class="blob-num js-line-number" data-line-number="10414"></td>
+ <td id="LC10414" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@name</span> valueOf</span></td>
+ </tr>
+ <tr>
+ <td id="L10415" class="blob-num js-line-number" data-line-number="10415"></td>
+ <td id="LC10415" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10416" class="blob-num js-line-number" data-line-number="10416"></td>
+ <td id="LC10416" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@alias</span> value</span></td>
+ </tr>
+ <tr>
+ <td id="L10417" class="blob-num js-line-number" data-line-number="10417"></td>
+ <td id="LC10417" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @category Chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10418" class="blob-num js-line-number" data-line-number="10418"></td>
+ <td id="LC10418" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@returns</span> {*} Returns the wrapped value.</span></td>
+ </tr>
+ <tr>
+ <td id="L10419" class="blob-num js-line-number" data-line-number="10419"></td>
+ <td id="LC10419" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@example</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10420" class="blob-num js-line-number" data-line-number="10420"></td>
+ <td id="LC10420" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10421" class="blob-num js-line-number" data-line-number="10421"></td>
+ <td id="LC10421" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * _([1, 2, 3]).valueOf();</span></td>
+ </tr>
+ <tr>
+ <td id="L10422" class="blob-num js-line-number" data-line-number="10422"></td>
+ <td id="LC10422" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * // => [1, 2, 3]</span></td>
+ </tr>
+ <tr>
+ <td id="L10423" class="blob-num js-line-number" data-line-number="10423"></td>
+ <td id="LC10423" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10424" class="blob-num js-line-number" data-line-number="10424"></td>
+ <td id="LC10424" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">function</span> <span class="pl-en">wrapperValueOf</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10425" class="blob-num js-line-number" data-line-number="10425"></td>
+ <td id="LC10425" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10426" class="blob-num js-line-number" data-line-number="10426"></td>
+ <td id="LC10426" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10427" class="blob-num js-line-number" data-line-number="10427"></td>
+ <td id="LC10427" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10428" class="blob-num js-line-number" data-line-number="10428"></td>
+ <td id="LC10428" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L10429" class="blob-num js-line-number" data-line-number="10429"></td>
+ <td id="LC10429" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10430" class="blob-num js-line-number" data-line-number="10430"></td>
+ <td id="LC10430" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add functions that return wrapped values when chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10431" class="blob-num js-line-number" data-line-number="10431"></td>
+ <td id="LC10431" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">after</span> <span class="pl-k">=</span> after;</td>
+ </tr>
+ <tr>
+ <td id="L10432" class="blob-num js-line-number" data-line-number="10432"></td>
+ <td id="LC10432" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">assign</span> <span class="pl-k">=</span> assign;</td>
+ </tr>
+ <tr>
+ <td id="L10433" class="blob-num js-line-number" data-line-number="10433"></td>
+ <td id="LC10433" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">at</span> <span class="pl-k">=</span> at;</td>
+ </tr>
+ <tr>
+ <td id="L10434" class="blob-num js-line-number" data-line-number="10434"></td>
+ <td id="LC10434" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">bind</span> <span class="pl-k">=</span> bind;</td>
+ </tr>
+ <tr>
+ <td id="L10435" class="blob-num js-line-number" data-line-number="10435"></td>
+ <td id="LC10435" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">bindAll</span> <span class="pl-k">=</span> bindAll;</td>
+ </tr>
+ <tr>
+ <td id="L10436" class="blob-num js-line-number" data-line-number="10436"></td>
+ <td id="LC10436" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">bindKey</span> <span class="pl-k">=</span> bindKey;</td>
+ </tr>
+ <tr>
+ <td id="L10437" class="blob-num js-line-number" data-line-number="10437"></td>
+ <td id="LC10437" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">chain</span> <span class="pl-k">=</span> chain;</td>
+ </tr>
+ <tr>
+ <td id="L10438" class="blob-num js-line-number" data-line-number="10438"></td>
+ <td id="LC10438" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">compact</span> <span class="pl-k">=</span> compact;</td>
+ </tr>
+ <tr>
+ <td id="L10439" class="blob-num js-line-number" data-line-number="10439"></td>
+ <td id="LC10439" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">compose</span> <span class="pl-k">=</span> compose;</td>
+ </tr>
+ <tr>
+ <td id="L10440" class="blob-num js-line-number" data-line-number="10440"></td>
+ <td id="LC10440" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">constant</span> <span class="pl-k">=</span> constant;</td>
+ </tr>
+ <tr>
+ <td id="L10441" class="blob-num js-line-number" data-line-number="10441"></td>
+ <td id="LC10441" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">countBy</span> <span class="pl-k">=</span> countBy;</td>
+ </tr>
+ <tr>
+ <td id="L10442" class="blob-num js-line-number" data-line-number="10442"></td>
+ <td id="LC10442" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">create</span> <span class="pl-k">=</span> create;</td>
+ </tr>
+ <tr>
+ <td id="L10443" class="blob-num js-line-number" data-line-number="10443"></td>
+ <td id="LC10443" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">createCallback</span> <span class="pl-k">=</span> createCallback;</td>
+ </tr>
+ <tr>
+ <td id="L10444" class="blob-num js-line-number" data-line-number="10444"></td>
+ <td id="LC10444" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">curry</span> <span class="pl-k">=</span> curry;</td>
+ </tr>
+ <tr>
+ <td id="L10445" class="blob-num js-line-number" data-line-number="10445"></td>
+ <td id="LC10445" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">debounce</span> <span class="pl-k">=</span> debounce;</td>
+ </tr>
+ <tr>
+ <td id="L10446" class="blob-num js-line-number" data-line-number="10446"></td>
+ <td id="LC10446" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">defaults</span> <span class="pl-k">=</span> defaults;</td>
+ </tr>
+ <tr>
+ <td id="L10447" class="blob-num js-line-number" data-line-number="10447"></td>
+ <td id="LC10447" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">defer</span> <span class="pl-k">=</span> defer;</td>
+ </tr>
+ <tr>
+ <td id="L10448" class="blob-num js-line-number" data-line-number="10448"></td>
+ <td id="LC10448" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">delay</span> <span class="pl-k">=</span> delay;</td>
+ </tr>
+ <tr>
+ <td id="L10449" class="blob-num js-line-number" data-line-number="10449"></td>
+ <td id="LC10449" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">difference</span> <span class="pl-k">=</span> difference;</td>
+ </tr>
+ <tr>
+ <td id="L10450" class="blob-num js-line-number" data-line-number="10450"></td>
+ <td id="LC10450" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">filter</span> <span class="pl-k">=</span> filter;</td>
+ </tr>
+ <tr>
+ <td id="L10451" class="blob-num js-line-number" data-line-number="10451"></td>
+ <td id="LC10451" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">flatten</span> <span class="pl-k">=</span> flatten;</td>
+ </tr>
+ <tr>
+ <td id="L10452" class="blob-num js-line-number" data-line-number="10452"></td>
+ <td id="LC10452" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">forEach</span> <span class="pl-k">=</span> forEach;</td>
+ </tr>
+ <tr>
+ <td id="L10453" class="blob-num js-line-number" data-line-number="10453"></td>
+ <td id="LC10453" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">forEachRight</span> <span class="pl-k">=</span> forEachRight;</td>
+ </tr>
+ <tr>
+ <td id="L10454" class="blob-num js-line-number" data-line-number="10454"></td>
+ <td id="LC10454" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">forIn</span> <span class="pl-k">=</span> forIn;</td>
+ </tr>
+ <tr>
+ <td id="L10455" class="blob-num js-line-number" data-line-number="10455"></td>
+ <td id="LC10455" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">forInRight</span> <span class="pl-k">=</span> forInRight;</td>
+ </tr>
+ <tr>
+ <td id="L10456" class="blob-num js-line-number" data-line-number="10456"></td>
+ <td id="LC10456" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">forOwn</span> <span class="pl-k">=</span> forOwn;</td>
+ </tr>
+ <tr>
+ <td id="L10457" class="blob-num js-line-number" data-line-number="10457"></td>
+ <td id="LC10457" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">forOwnRight</span> <span class="pl-k">=</span> forOwnRight;</td>
+ </tr>
+ <tr>
+ <td id="L10458" class="blob-num js-line-number" data-line-number="10458"></td>
+ <td id="LC10458" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">functions</span> <span class="pl-k">=</span> functions;</td>
+ </tr>
+ <tr>
+ <td id="L10459" class="blob-num js-line-number" data-line-number="10459"></td>
+ <td id="LC10459" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">groupBy</span> <span class="pl-k">=</span> groupBy;</td>
+ </tr>
+ <tr>
+ <td id="L10460" class="blob-num js-line-number" data-line-number="10460"></td>
+ <td id="LC10460" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">indexBy</span> <span class="pl-k">=</span> indexBy;</td>
+ </tr>
+ <tr>
+ <td id="L10461" class="blob-num js-line-number" data-line-number="10461"></td>
+ <td id="LC10461" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">initial</span> <span class="pl-k">=</span> initial;</td>
+ </tr>
+ <tr>
+ <td id="L10462" class="blob-num js-line-number" data-line-number="10462"></td>
+ <td id="LC10462" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">intersection</span> <span class="pl-k">=</span> intersection;</td>
+ </tr>
+ <tr>
+ <td id="L10463" class="blob-num js-line-number" data-line-number="10463"></td>
+ <td id="LC10463" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">invert</span> <span class="pl-k">=</span> invert;</td>
+ </tr>
+ <tr>
+ <td id="L10464" class="blob-num js-line-number" data-line-number="10464"></td>
+ <td id="LC10464" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">invoke</span> <span class="pl-k">=</span> invoke;</td>
+ </tr>
+ <tr>
+ <td id="L10465" class="blob-num js-line-number" data-line-number="10465"></td>
+ <td id="LC10465" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">keys</span> <span class="pl-k">=</span> keys;</td>
+ </tr>
+ <tr>
+ <td id="L10466" class="blob-num js-line-number" data-line-number="10466"></td>
+ <td id="LC10466" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">map</span> <span class="pl-k">=</span> map;</td>
+ </tr>
+ <tr>
+ <td id="L10467" class="blob-num js-line-number" data-line-number="10467"></td>
+ <td id="LC10467" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">mapValues</span> <span class="pl-k">=</span> mapValues;</td>
+ </tr>
+ <tr>
+ <td id="L10468" class="blob-num js-line-number" data-line-number="10468"></td>
+ <td id="LC10468" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">max</span> <span class="pl-k">=</span> max;</td>
+ </tr>
+ <tr>
+ <td id="L10469" class="blob-num js-line-number" data-line-number="10469"></td>
+ <td id="LC10469" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">memoize</span> <span class="pl-k">=</span> memoize;</td>
+ </tr>
+ <tr>
+ <td id="L10470" class="blob-num js-line-number" data-line-number="10470"></td>
+ <td id="LC10470" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">merge</span> <span class="pl-k">=</span> merge;</td>
+ </tr>
+ <tr>
+ <td id="L10471" class="blob-num js-line-number" data-line-number="10471"></td>
+ <td id="LC10471" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">min</span> <span class="pl-k">=</span> min;</td>
+ </tr>
+ <tr>
+ <td id="L10472" class="blob-num js-line-number" data-line-number="10472"></td>
+ <td id="LC10472" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">omit</span> <span class="pl-k">=</span> omit;</td>
+ </tr>
+ <tr>
+ <td id="L10473" class="blob-num js-line-number" data-line-number="10473"></td>
+ <td id="LC10473" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">once</span> <span class="pl-k">=</span> once;</td>
+ </tr>
+ <tr>
+ <td id="L10474" class="blob-num js-line-number" data-line-number="10474"></td>
+ <td id="LC10474" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">pairs</span> <span class="pl-k">=</span> pairs;</td>
+ </tr>
+ <tr>
+ <td id="L10475" class="blob-num js-line-number" data-line-number="10475"></td>
+ <td id="LC10475" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">partial</span> <span class="pl-k">=</span> partial;</td>
+ </tr>
+ <tr>
+ <td id="L10476" class="blob-num js-line-number" data-line-number="10476"></td>
+ <td id="LC10476" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">partialRight</span> <span class="pl-k">=</span> partialRight;</td>
+ </tr>
+ <tr>
+ <td id="L10477" class="blob-num js-line-number" data-line-number="10477"></td>
+ <td id="LC10477" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">pick</span> <span class="pl-k">=</span> pick;</td>
+ </tr>
+ <tr>
+ <td id="L10478" class="blob-num js-line-number" data-line-number="10478"></td>
+ <td id="LC10478" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">pluck</span> <span class="pl-k">=</span> pluck;</td>
+ </tr>
+ <tr>
+ <td id="L10479" class="blob-num js-line-number" data-line-number="10479"></td>
+ <td id="LC10479" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">property</span> <span class="pl-k">=</span> property;</td>
+ </tr>
+ <tr>
+ <td id="L10480" class="blob-num js-line-number" data-line-number="10480"></td>
+ <td id="LC10480" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">pull</span> <span class="pl-k">=</span> pull;</td>
+ </tr>
+ <tr>
+ <td id="L10481" class="blob-num js-line-number" data-line-number="10481"></td>
+ <td id="LC10481" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">range</span> <span class="pl-k">=</span> range;</td>
+ </tr>
+ <tr>
+ <td id="L10482" class="blob-num js-line-number" data-line-number="10482"></td>
+ <td id="LC10482" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">reject</span> <span class="pl-k">=</span> reject;</td>
+ </tr>
+ <tr>
+ <td id="L10483" class="blob-num js-line-number" data-line-number="10483"></td>
+ <td id="LC10483" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">remove</span> <span class="pl-k">=</span> remove;</td>
+ </tr>
+ <tr>
+ <td id="L10484" class="blob-num js-line-number" data-line-number="10484"></td>
+ <td id="LC10484" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">rest</span> <span class="pl-k">=</span> rest;</td>
+ </tr>
+ <tr>
+ <td id="L10485" class="blob-num js-line-number" data-line-number="10485"></td>
+ <td id="LC10485" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">shuffle</span> <span class="pl-k">=</span> shuffle;</td>
+ </tr>
+ <tr>
+ <td id="L10486" class="blob-num js-line-number" data-line-number="10486"></td>
+ <td id="LC10486" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">sortBy</span> <span class="pl-k">=</span> sortBy;</td>
+ </tr>
+ <tr>
+ <td id="L10487" class="blob-num js-line-number" data-line-number="10487"></td>
+ <td id="LC10487" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">tap</span> <span class="pl-k">=</span> tap;</td>
+ </tr>
+ <tr>
+ <td id="L10488" class="blob-num js-line-number" data-line-number="10488"></td>
+ <td id="LC10488" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">throttle</span> <span class="pl-k">=</span> throttle;</td>
+ </tr>
+ <tr>
+ <td id="L10489" class="blob-num js-line-number" data-line-number="10489"></td>
+ <td id="LC10489" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">times</span> <span class="pl-k">=</span> times;</td>
+ </tr>
+ <tr>
+ <td id="L10490" class="blob-num js-line-number" data-line-number="10490"></td>
+ <td id="LC10490" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">toArray</span> <span class="pl-k">=</span> toArray;</td>
+ </tr>
+ <tr>
+ <td id="L10491" class="blob-num js-line-number" data-line-number="10491"></td>
+ <td id="LC10491" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">transform</span> <span class="pl-k">=</span> transform;</td>
+ </tr>
+ <tr>
+ <td id="L10492" class="blob-num js-line-number" data-line-number="10492"></td>
+ <td id="LC10492" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">union</span> <span class="pl-k">=</span> union;</td>
+ </tr>
+ <tr>
+ <td id="L10493" class="blob-num js-line-number" data-line-number="10493"></td>
+ <td id="LC10493" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">uniq</span> <span class="pl-k">=</span> uniq;</td>
+ </tr>
+ <tr>
+ <td id="L10494" class="blob-num js-line-number" data-line-number="10494"></td>
+ <td id="LC10494" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">values</span> <span class="pl-k">=</span> values;</td>
+ </tr>
+ <tr>
+ <td id="L10495" class="blob-num js-line-number" data-line-number="10495"></td>
+ <td id="LC10495" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">where</span> <span class="pl-k">=</span> where;</td>
+ </tr>
+ <tr>
+ <td id="L10496" class="blob-num js-line-number" data-line-number="10496"></td>
+ <td id="LC10496" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">without</span> <span class="pl-k">=</span> without;</td>
+ </tr>
+ <tr>
+ <td id="L10497" class="blob-num js-line-number" data-line-number="10497"></td>
+ <td id="LC10497" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">wrap</span> <span class="pl-k">=</span> wrap;</td>
+ </tr>
+ <tr>
+ <td id="L10498" class="blob-num js-line-number" data-line-number="10498"></td>
+ <td id="LC10498" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">xor</span> <span class="pl-k">=</span> xor;</td>
+ </tr>
+ <tr>
+ <td id="L10499" class="blob-num js-line-number" data-line-number="10499"></td>
+ <td id="LC10499" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">zip</span> <span class="pl-k">=</span> zip;</td>
+ </tr>
+ <tr>
+ <td id="L10500" class="blob-num js-line-number" data-line-number="10500"></td>
+ <td id="LC10500" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">zipObject</span> <span class="pl-k">=</span> zipObject;</td>
+ </tr>
+ <tr>
+ <td id="L10501" class="blob-num js-line-number" data-line-number="10501"></td>
+ <td id="LC10501" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10502" class="blob-num js-line-number" data-line-number="10502"></td>
+ <td id="LC10502" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add aliases</span></td>
+ </tr>
+ <tr>
+ <td id="L10503" class="blob-num js-line-number" data-line-number="10503"></td>
+ <td id="LC10503" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">collect</span> <span class="pl-k">=</span> map;</td>
+ </tr>
+ <tr>
+ <td id="L10504" class="blob-num js-line-number" data-line-number="10504"></td>
+ <td id="LC10504" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">drop</span> <span class="pl-k">=</span> rest;</td>
+ </tr>
+ <tr>
+ <td id="L10505" class="blob-num js-line-number" data-line-number="10505"></td>
+ <td id="LC10505" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">each</span> <span class="pl-k">=</span> forEach;</td>
+ </tr>
+ <tr>
+ <td id="L10506" class="blob-num js-line-number" data-line-number="10506"></td>
+ <td id="LC10506" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">eachRight</span> <span class="pl-k">=</span> forEachRight;</td>
+ </tr>
+ <tr>
+ <td id="L10507" class="blob-num js-line-number" data-line-number="10507"></td>
+ <td id="LC10507" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">extend</span> <span class="pl-k">=</span> assign;</td>
+ </tr>
+ <tr>
+ <td id="L10508" class="blob-num js-line-number" data-line-number="10508"></td>
+ <td id="LC10508" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">methods</span> <span class="pl-k">=</span> functions;</td>
+ </tr>
+ <tr>
+ <td id="L10509" class="blob-num js-line-number" data-line-number="10509"></td>
+ <td id="LC10509" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">object</span> <span class="pl-k">=</span> zipObject;</td>
+ </tr>
+ <tr>
+ <td id="L10510" class="blob-num js-line-number" data-line-number="10510"></td>
+ <td id="LC10510" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">select</span> <span class="pl-k">=</span> filter;</td>
+ </tr>
+ <tr>
+ <td id="L10511" class="blob-num js-line-number" data-line-number="10511"></td>
+ <td id="LC10511" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">tail</span> <span class="pl-k">=</span> rest;</td>
+ </tr>
+ <tr>
+ <td id="L10512" class="blob-num js-line-number" data-line-number="10512"></td>
+ <td id="LC10512" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">unique</span> <span class="pl-k">=</span> uniq;</td>
+ </tr>
+ <tr>
+ <td id="L10513" class="blob-num js-line-number" data-line-number="10513"></td>
+ <td id="LC10513" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">unzip</span> <span class="pl-k">=</span> zip;</td>
+ </tr>
+ <tr>
+ <td id="L10514" class="blob-num js-line-number" data-line-number="10514"></td>
+ <td id="LC10514" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10515" class="blob-num js-line-number" data-line-number="10515"></td>
+ <td id="LC10515" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add functions to `lodash.prototype`</span></td>
+ </tr>
+ <tr>
+ <td id="L10516" class="blob-num js-line-number" data-line-number="10516"></td>
+ <td id="LC10516" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">mixin</span>(lodash);</td>
+ </tr>
+ <tr>
+ <td id="L10517" class="blob-num js-line-number" data-line-number="10517"></td>
+ <td id="LC10517" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10518" class="blob-num js-line-number" data-line-number="10518"></td>
+ <td id="LC10518" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L10519" class="blob-num js-line-number" data-line-number="10519"></td>
+ <td id="LC10519" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10520" class="blob-num js-line-number" data-line-number="10520"></td>
+ <td id="LC10520" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add functions that return unwrapped values when chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10521" class="blob-num js-line-number" data-line-number="10521"></td>
+ <td id="LC10521" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">clone</span> <span class="pl-k">=</span> clone;</td>
+ </tr>
+ <tr>
+ <td id="L10522" class="blob-num js-line-number" data-line-number="10522"></td>
+ <td id="LC10522" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">cloneDeep</span> <span class="pl-k">=</span> cloneDeep;</td>
+ </tr>
+ <tr>
+ <td id="L10523" class="blob-num js-line-number" data-line-number="10523"></td>
+ <td id="LC10523" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">contains</span> <span class="pl-k">=</span> contains;</td>
+ </tr>
+ <tr>
+ <td id="L10524" class="blob-num js-line-number" data-line-number="10524"></td>
+ <td id="LC10524" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">escape</span> <span class="pl-k">=</span> escape;</td>
+ </tr>
+ <tr>
+ <td id="L10525" class="blob-num js-line-number" data-line-number="10525"></td>
+ <td id="LC10525" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">every</span> <span class="pl-k">=</span> every;</td>
+ </tr>
+ <tr>
+ <td id="L10526" class="blob-num js-line-number" data-line-number="10526"></td>
+ <td id="LC10526" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">find</span> <span class="pl-k">=</span> find;</td>
+ </tr>
+ <tr>
+ <td id="L10527" class="blob-num js-line-number" data-line-number="10527"></td>
+ <td id="LC10527" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">findIndex</span> <span class="pl-k">=</span> findIndex;</td>
+ </tr>
+ <tr>
+ <td id="L10528" class="blob-num js-line-number" data-line-number="10528"></td>
+ <td id="LC10528" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">findKey</span> <span class="pl-k">=</span> findKey;</td>
+ </tr>
+ <tr>
+ <td id="L10529" class="blob-num js-line-number" data-line-number="10529"></td>
+ <td id="LC10529" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">findLast</span> <span class="pl-k">=</span> findLast;</td>
+ </tr>
+ <tr>
+ <td id="L10530" class="blob-num js-line-number" data-line-number="10530"></td>
+ <td id="LC10530" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">findLastIndex</span> <span class="pl-k">=</span> findLastIndex;</td>
+ </tr>
+ <tr>
+ <td id="L10531" class="blob-num js-line-number" data-line-number="10531"></td>
+ <td id="LC10531" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">findLastKey</span> <span class="pl-k">=</span> findLastKey;</td>
+ </tr>
+ <tr>
+ <td id="L10532" class="blob-num js-line-number" data-line-number="10532"></td>
+ <td id="LC10532" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">has</span> <span class="pl-k">=</span> has;</td>
+ </tr>
+ <tr>
+ <td id="L10533" class="blob-num js-line-number" data-line-number="10533"></td>
+ <td id="LC10533" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">identity</span> <span class="pl-k">=</span> identity;</td>
+ </tr>
+ <tr>
+ <td id="L10534" class="blob-num js-line-number" data-line-number="10534"></td>
+ <td id="LC10534" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">indexOf</span> <span class="pl-k">=</span> indexOf;</td>
+ </tr>
+ <tr>
+ <td id="L10535" class="blob-num js-line-number" data-line-number="10535"></td>
+ <td id="LC10535" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isArguments</span> <span class="pl-k">=</span> isArguments;</td>
+ </tr>
+ <tr>
+ <td id="L10536" class="blob-num js-line-number" data-line-number="10536"></td>
+ <td id="LC10536" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isArray</span> <span class="pl-k">=</span> isArray;</td>
+ </tr>
+ <tr>
+ <td id="L10537" class="blob-num js-line-number" data-line-number="10537"></td>
+ <td id="LC10537" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isBoolean</span> <span class="pl-k">=</span> isBoolean;</td>
+ </tr>
+ <tr>
+ <td id="L10538" class="blob-num js-line-number" data-line-number="10538"></td>
+ <td id="LC10538" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isDate</span> <span class="pl-k">=</span> isDate;</td>
+ </tr>
+ <tr>
+ <td id="L10539" class="blob-num js-line-number" data-line-number="10539"></td>
+ <td id="LC10539" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isElement</span> <span class="pl-k">=</span> isElement;</td>
+ </tr>
+ <tr>
+ <td id="L10540" class="blob-num js-line-number" data-line-number="10540"></td>
+ <td id="LC10540" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isEmpty</span> <span class="pl-k">=</span> isEmpty;</td>
+ </tr>
+ <tr>
+ <td id="L10541" class="blob-num js-line-number" data-line-number="10541"></td>
+ <td id="LC10541" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isEqual</span> <span class="pl-k">=</span> isEqual;</td>
+ </tr>
+ <tr>
+ <td id="L10542" class="blob-num js-line-number" data-line-number="10542"></td>
+ <td id="LC10542" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isFinite</span> <span class="pl-k">=</span> isFinite;</td>
+ </tr>
+ <tr>
+ <td id="L10543" class="blob-num js-line-number" data-line-number="10543"></td>
+ <td id="LC10543" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isFunction</span> <span class="pl-k">=</span> isFunction;</td>
+ </tr>
+ <tr>
+ <td id="L10544" class="blob-num js-line-number" data-line-number="10544"></td>
+ <td id="LC10544" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isNaN</span> <span class="pl-k">=</span> isNaN;</td>
+ </tr>
+ <tr>
+ <td id="L10545" class="blob-num js-line-number" data-line-number="10545"></td>
+ <td id="LC10545" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isNull</span> <span class="pl-k">=</span> isNull;</td>
+ </tr>
+ <tr>
+ <td id="L10546" class="blob-num js-line-number" data-line-number="10546"></td>
+ <td id="LC10546" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isNumber</span> <span class="pl-k">=</span> isNumber;</td>
+ </tr>
+ <tr>
+ <td id="L10547" class="blob-num js-line-number" data-line-number="10547"></td>
+ <td id="LC10547" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isObject</span> <span class="pl-k">=</span> isObject;</td>
+ </tr>
+ <tr>
+ <td id="L10548" class="blob-num js-line-number" data-line-number="10548"></td>
+ <td id="LC10548" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isPlainObject</span> <span class="pl-k">=</span> isPlainObject;</td>
+ </tr>
+ <tr>
+ <td id="L10549" class="blob-num js-line-number" data-line-number="10549"></td>
+ <td id="LC10549" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isRegExp</span> <span class="pl-k">=</span> isRegExp;</td>
+ </tr>
+ <tr>
+ <td id="L10550" class="blob-num js-line-number" data-line-number="10550"></td>
+ <td id="LC10550" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isString</span> <span class="pl-k">=</span> isString;</td>
+ </tr>
+ <tr>
+ <td id="L10551" class="blob-num js-line-number" data-line-number="10551"></td>
+ <td id="LC10551" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">isUndefined</span> <span class="pl-k">=</span> isUndefined;</td>
+ </tr>
+ <tr>
+ <td id="L10552" class="blob-num js-line-number" data-line-number="10552"></td>
+ <td id="LC10552" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">lastIndexOf</span> <span class="pl-k">=</span> lastIndexOf;</td>
+ </tr>
+ <tr>
+ <td id="L10553" class="blob-num js-line-number" data-line-number="10553"></td>
+ <td id="LC10553" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">mixin</span> <span class="pl-k">=</span> mixin;</td>
+ </tr>
+ <tr>
+ <td id="L10554" class="blob-num js-line-number" data-line-number="10554"></td>
+ <td id="LC10554" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">noConflict</span> <span class="pl-k">=</span> noConflict;</td>
+ </tr>
+ <tr>
+ <td id="L10555" class="blob-num js-line-number" data-line-number="10555"></td>
+ <td id="LC10555" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">noop</span> <span class="pl-k">=</span> noop;</td>
+ </tr>
+ <tr>
+ <td id="L10556" class="blob-num js-line-number" data-line-number="10556"></td>
+ <td id="LC10556" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">now</span> <span class="pl-k">=</span> now;</td>
+ </tr>
+ <tr>
+ <td id="L10557" class="blob-num js-line-number" data-line-number="10557"></td>
+ <td id="LC10557" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">parseInt</span> <span class="pl-k">=</span> parseInt;</td>
+ </tr>
+ <tr>
+ <td id="L10558" class="blob-num js-line-number" data-line-number="10558"></td>
+ <td id="LC10558" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">random</span> <span class="pl-k">=</span> random;</td>
+ </tr>
+ <tr>
+ <td id="L10559" class="blob-num js-line-number" data-line-number="10559"></td>
+ <td id="LC10559" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">reduce</span> <span class="pl-k">=</span> reduce;</td>
+ </tr>
+ <tr>
+ <td id="L10560" class="blob-num js-line-number" data-line-number="10560"></td>
+ <td id="LC10560" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">reduceRight</span> <span class="pl-k">=</span> reduceRight;</td>
+ </tr>
+ <tr>
+ <td id="L10561" class="blob-num js-line-number" data-line-number="10561"></td>
+ <td id="LC10561" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">result</span> <span class="pl-k">=</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L10562" class="blob-num js-line-number" data-line-number="10562"></td>
+ <td id="LC10562" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">runInContext</span> <span class="pl-k">=</span> runInContext;</td>
+ </tr>
+ <tr>
+ <td id="L10563" class="blob-num js-line-number" data-line-number="10563"></td>
+ <td id="LC10563" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">size</span> <span class="pl-k">=</span> size;</td>
+ </tr>
+ <tr>
+ <td id="L10564" class="blob-num js-line-number" data-line-number="10564"></td>
+ <td id="LC10564" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">some</span> <span class="pl-k">=</span> some;</td>
+ </tr>
+ <tr>
+ <td id="L10565" class="blob-num js-line-number" data-line-number="10565"></td>
+ <td id="LC10565" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">sortedIndex</span> <span class="pl-k">=</span> sortedIndex;</td>
+ </tr>
+ <tr>
+ <td id="L10566" class="blob-num js-line-number" data-line-number="10566"></td>
+ <td id="LC10566" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">template</span> <span class="pl-k">=</span> template;</td>
+ </tr>
+ <tr>
+ <td id="L10567" class="blob-num js-line-number" data-line-number="10567"></td>
+ <td id="LC10567" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">unescape</span> <span class="pl-k">=</span> unescape;</td>
+ </tr>
+ <tr>
+ <td id="L10568" class="blob-num js-line-number" data-line-number="10568"></td>
+ <td id="LC10568" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">uniqueId</span> <span class="pl-k">=</span> uniqueId;</td>
+ </tr>
+ <tr>
+ <td id="L10569" class="blob-num js-line-number" data-line-number="10569"></td>
+ <td id="LC10569" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10570" class="blob-num js-line-number" data-line-number="10570"></td>
+ <td id="LC10570" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add aliases</span></td>
+ </tr>
+ <tr>
+ <td id="L10571" class="blob-num js-line-number" data-line-number="10571"></td>
+ <td id="LC10571" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">all</span> <span class="pl-k">=</span> every;</td>
+ </tr>
+ <tr>
+ <td id="L10572" class="blob-num js-line-number" data-line-number="10572"></td>
+ <td id="LC10572" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">any</span> <span class="pl-k">=</span> some;</td>
+ </tr>
+ <tr>
+ <td id="L10573" class="blob-num js-line-number" data-line-number="10573"></td>
+ <td id="LC10573" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">detect</span> <span class="pl-k">=</span> find;</td>
+ </tr>
+ <tr>
+ <td id="L10574" class="blob-num js-line-number" data-line-number="10574"></td>
+ <td id="LC10574" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">findWhere</span> <span class="pl-k">=</span> find;</td>
+ </tr>
+ <tr>
+ <td id="L10575" class="blob-num js-line-number" data-line-number="10575"></td>
+ <td id="LC10575" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">foldl</span> <span class="pl-k">=</span> reduce;</td>
+ </tr>
+ <tr>
+ <td id="L10576" class="blob-num js-line-number" data-line-number="10576"></td>
+ <td id="LC10576" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">foldr</span> <span class="pl-k">=</span> reduceRight;</td>
+ </tr>
+ <tr>
+ <td id="L10577" class="blob-num js-line-number" data-line-number="10577"></td>
+ <td id="LC10577" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">include</span> <span class="pl-k">=</span> contains;</td>
+ </tr>
+ <tr>
+ <td id="L10578" class="blob-num js-line-number" data-line-number="10578"></td>
+ <td id="LC10578" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">inject</span> <span class="pl-k">=</span> reduce;</td>
+ </tr>
+ <tr>
+ <td id="L10579" class="blob-num js-line-number" data-line-number="10579"></td>
+ <td id="LC10579" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10580" class="blob-num js-line-number" data-line-number="10580"></td>
+ <td id="LC10580" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">mixin</span>(<span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10581" class="blob-num js-line-number" data-line-number="10581"></td>
+ <td id="LC10581" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> source <span class="pl-k">=</span> {}</td>
+ </tr>
+ <tr>
+ <td id="L10582" class="blob-num js-line-number" data-line-number="10582"></td>
+ <td id="LC10582" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(lodash, <span class="pl-k">function</span>(<span class="pl-smi">func</span>, <span class="pl-smi">methodName</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10583" class="blob-num js-line-number" data-line-number="10583"></td>
+ <td id="LC10583" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>[methodName]) {</td>
+ </tr>
+ <tr>
+ <td id="L10584" class="blob-num js-line-number" data-line-number="10584"></td>
+ <td id="LC10584" class="blob-code blob-code-inner js-file-line"> source[methodName] <span class="pl-k">=</span> func;</td>
+ </tr>
+ <tr>
+ <td id="L10585" class="blob-num js-line-number" data-line-number="10585"></td>
+ <td id="LC10585" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10586" class="blob-num js-line-number" data-line-number="10586"></td>
+ <td id="LC10586" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10587" class="blob-num js-line-number" data-line-number="10587"></td>
+ <td id="LC10587" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> source;</td>
+ </tr>
+ <tr>
+ <td id="L10588" class="blob-num js-line-number" data-line-number="10588"></td>
+ <td id="LC10588" class="blob-code blob-code-inner js-file-line"> }(), <span class="pl-c1">false</span>);</td>
+ </tr>
+ <tr>
+ <td id="L10589" class="blob-num js-line-number" data-line-number="10589"></td>
+ <td id="LC10589" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10590" class="blob-num js-line-number" data-line-number="10590"></td>
+ <td id="LC10590" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L10591" class="blob-num js-line-number" data-line-number="10591"></td>
+ <td id="LC10591" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10592" class="blob-num js-line-number" data-line-number="10592"></td>
+ <td id="LC10592" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add functions capable of returning wrapped and unwrapped values when chaining</span></td>
+ </tr>
+ <tr>
+ <td id="L10593" class="blob-num js-line-number" data-line-number="10593"></td>
+ <td id="LC10593" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">first</span> <span class="pl-k">=</span> first;</td>
+ </tr>
+ <tr>
+ <td id="L10594" class="blob-num js-line-number" data-line-number="10594"></td>
+ <td id="LC10594" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">last</span> <span class="pl-k">=</span> last;</td>
+ </tr>
+ <tr>
+ <td id="L10595" class="blob-num js-line-number" data-line-number="10595"></td>
+ <td id="LC10595" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">sample</span> <span class="pl-k">=</span> sample;</td>
+ </tr>
+ <tr>
+ <td id="L10596" class="blob-num js-line-number" data-line-number="10596"></td>
+ <td id="LC10596" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10597" class="blob-num js-line-number" data-line-number="10597"></td>
+ <td id="LC10597" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add aliases</span></td>
+ </tr>
+ <tr>
+ <td id="L10598" class="blob-num js-line-number" data-line-number="10598"></td>
+ <td id="LC10598" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">take</span> <span class="pl-k">=</span> first;</td>
+ </tr>
+ <tr>
+ <td id="L10599" class="blob-num js-line-number" data-line-number="10599"></td>
+ <td id="LC10599" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-smi">head</span> <span class="pl-k">=</span> first;</td>
+ </tr>
+ <tr>
+ <td id="L10600" class="blob-num js-line-number" data-line-number="10600"></td>
+ <td id="LC10600" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10601" class="blob-num js-line-number" data-line-number="10601"></td>
+ <td id="LC10601" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forOwn</span>(lodash, <span class="pl-k">function</span>(<span class="pl-smi">func</span>, <span class="pl-smi">methodName</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10602" class="blob-num js-line-number" data-line-number="10602"></td>
+ <td id="LC10602" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> callbackable <span class="pl-k">=</span> methodName <span class="pl-k">!==</span> <span class="pl-s"><span class="pl-pds">'</span>sample<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10603" class="blob-num js-line-number" data-line-number="10603"></td>
+ <td id="LC10603" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">!</span><span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>[methodName]) {</td>
+ </tr>
+ <tr>
+ <td id="L10604" class="blob-num js-line-number" data-line-number="10604"></td>
+ <td id="LC10604" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>[methodName]<span class="pl-k">=</span> <span class="pl-k">function</span>(<span class="pl-smi">n</span>, <span class="pl-smi">guard</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10605" class="blob-num js-line-number" data-line-number="10605"></td>
+ <td id="LC10605" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> chainAll <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">__chain__</span>,</td>
+ </tr>
+ <tr>
+ <td id="L10606" class="blob-num js-line-number" data-line-number="10606"></td>
+ <td id="LC10606" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-en">func</span>(<span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>, n, guard);</td>
+ </tr>
+ <tr>
+ <td id="L10607" class="blob-num js-line-number" data-line-number="10607"></td>
+ <td id="LC10607" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10608" class="blob-num js-line-number" data-line-number="10608"></td>
+ <td id="LC10608" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">!</span>chainAll <span class="pl-k">&&</span> (n <span class="pl-k">==</span> <span class="pl-c1">null</span> <span class="pl-k">||</span> (guard <span class="pl-k">&&</span> <span class="pl-k">!</span>(callbackable <span class="pl-k">&&</span> <span class="pl-k">typeof</span> n <span class="pl-k">==</span> <span class="pl-s"><span [...]
+ </tr>
+ <tr>
+ <td id="L10609" class="blob-num js-line-number" data-line-number="10609"></td>
+ <td id="LC10609" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> result</td>
+ </tr>
+ <tr>
+ <td id="L10610" class="blob-num js-line-number" data-line-number="10610"></td>
+ <td id="LC10610" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> <span class="pl-k">new</span> <span class="pl-en">lodashWrapper</span>(result, chainAll);</td>
+ </tr>
+ <tr>
+ <td id="L10611" class="blob-num js-line-number" data-line-number="10611"></td>
+ <td id="LC10611" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L10612" class="blob-num js-line-number" data-line-number="10612"></td>
+ <td id="LC10612" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10613" class="blob-num js-line-number" data-line-number="10613"></td>
+ <td id="LC10613" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10614" class="blob-num js-line-number" data-line-number="10614"></td>
+ <td id="LC10614" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10615" class="blob-num js-line-number" data-line-number="10615"></td>
+ <td id="LC10615" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L10616" class="blob-num js-line-number" data-line-number="10616"></td>
+ <td id="LC10616" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10617" class="blob-num js-line-number" data-line-number="10617"></td>
+ <td id="LC10617" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/**</span></td>
+ </tr>
+ <tr>
+ <td id="L10618" class="blob-num js-line-number" data-line-number="10618"></td>
+ <td id="LC10618" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * The semantic version number.</span></td>
+ </tr>
+ <tr>
+ <td id="L10619" class="blob-num js-line-number" data-line-number="10619"></td>
+ <td id="LC10619" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> *</span></td>
+ </tr>
+ <tr>
+ <td id="L10620" class="blob-num js-line-number" data-line-number="10620"></td>
+ <td id="LC10620" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@static</span></span></td>
+ </tr>
+ <tr>
+ <td id="L10621" class="blob-num js-line-number" data-line-number="10621"></td>
+ <td id="LC10621" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * @memberOf _</span></td>
+ </tr>
+ <tr>
+ <td id="L10622" class="blob-num js-line-number" data-line-number="10622"></td>
+ <td id="LC10622" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> * <span class="pl-k">@type</span> string</span></td>
+ </tr>
+ <tr>
+ <td id="L10623" class="blob-num js-line-number" data-line-number="10623"></td>
+ <td id="LC10623" class="blob-code blob-code-inner js-file-line"><span class="pl-c"> */</span></td>
+ </tr>
+ <tr>
+ <td id="L10624" class="blob-num js-line-number" data-line-number="10624"></td>
+ <td id="LC10624" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">VERSION</span> <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>2.4.2<span class="pl-pds">'</span></span>;</td>
+ </tr>
+ <tr>
+ <td id="L10625" class="blob-num js-line-number" data-line-number="10625"></td>
+ <td id="LC10625" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10626" class="blob-num js-line-number" data-line-number="10626"></td>
+ <td id="LC10626" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add "Chaining" functions to the wrapper</span></td>
+ </tr>
+ <tr>
+ <td id="L10627" class="blob-num js-line-number" data-line-number="10627"></td>
+ <td id="LC10627" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>.<span class="pl-smi">chain</span> <span class="pl-k">=</span> wrapperChain;</td>
+ </tr>
+ <tr>
+ <td id="L10628" class="blob-num js-line-number" data-line-number="10628"></td>
+ <td id="LC10628" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>.<span class="pl-smi">toString</span> <span class="pl-k">=</span> wrapperToString;</td>
+ </tr>
+ <tr>
+ <td id="L10629" class="blob-num js-line-number" data-line-number="10629"></td>
+ <td id="LC10629" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>.<span class="pl-c1">value</span> <span class="pl-k">=</span> wrapperValueOf;</td>
+ </tr>
+ <tr>
+ <td id="L10630" class="blob-num js-line-number" data-line-number="10630"></td>
+ <td id="LC10630" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>.<span class="pl-smi">valueOf</span> <span class="pl-k">=</span> wrapperValueOf;</td>
+ </tr>
+ <tr>
+ <td id="L10631" class="blob-num js-line-number" data-line-number="10631"></td>
+ <td id="LC10631" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10632" class="blob-num js-line-number" data-line-number="10632"></td>
+ <td id="LC10632" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add `Array` functions that return unwrapped values</span></td>
+ </tr>
+ <tr>
+ <td id="L10633" class="blob-num js-line-number" data-line-number="10633"></td>
+ <td id="LC10633" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>([<span class="pl-s"><span class="pl-pds">'</span>join<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>pop<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>shift<span class="pl-pds">'</span></span>], <span class="pl-k">function</span>(<span class="pl-smi">methodName</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10634" class="blob-num js-line-number" data-line-number="10634"></td>
+ <td id="LC10634" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> func <span class="pl-k">=</span> arrayRef[methodName];</td>
+ </tr>
+ <tr>
+ <td id="L10635" class="blob-num js-line-number" data-line-number="10635"></td>
+ <td id="LC10635" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>[methodName] <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10636" class="blob-num js-line-number" data-line-number="10636"></td>
+ <td id="LC10636" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> chainAll <span class="pl-k">=</span> <span class="pl-v">this</span>.<span class="pl-smi">__chain__</span>,</td>
+ </tr>
+ <tr>
+ <td id="L10637" class="blob-num js-line-number" data-line-number="10637"></td>
+ <td id="LC10637" class="blob-code blob-code-inner js-file-line"> result <span class="pl-k">=</span> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L10638" class="blob-num js-line-number" data-line-number="10638"></td>
+ <td id="LC10638" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10639" class="blob-num js-line-number" data-line-number="10639"></td>
+ <td id="LC10639" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> chainAll</td>
+ </tr>
+ <tr>
+ <td id="L10640" class="blob-num js-line-number" data-line-number="10640"></td>
+ <td id="LC10640" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">?</span> <span class="pl-k">new</span> <span class="pl-en">lodashWrapper</span>(result, chainAll)</td>
+ </tr>
+ <tr>
+ <td id="L10641" class="blob-num js-line-number" data-line-number="10641"></td>
+ <td id="LC10641" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">:</span> result;</td>
+ </tr>
+ <tr>
+ <td id="L10642" class="blob-num js-line-number" data-line-number="10642"></td>
+ <td id="LC10642" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L10643" class="blob-num js-line-number" data-line-number="10643"></td>
+ <td id="LC10643" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10644" class="blob-num js-line-number" data-line-number="10644"></td>
+ <td id="LC10644" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10645" class="blob-num js-line-number" data-line-number="10645"></td>
+ <td id="LC10645" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add `Array` functions that return the existing wrapped value</span></td>
+ </tr>
+ <tr>
+ <td id="L10646" class="blob-num js-line-number" data-line-number="10646"></td>
+ <td id="LC10646" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>([<span class="pl-s"><span class="pl-pds">'</span>push<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>reverse<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>sort<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>unshift<span class="pl-pds"> [...]
+ </tr>
+ <tr>
+ <td id="L10647" class="blob-num js-line-number" data-line-number="10647"></td>
+ <td id="LC10647" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> func <span class="pl-k">=</span> arrayRef[methodName];</td>
+ </tr>
+ <tr>
+ <td id="L10648" class="blob-num js-line-number" data-line-number="10648"></td>
+ <td id="LC10648" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>[methodName] <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10649" class="blob-num js-line-number" data-line-number="10649"></td>
+ <td id="LC10649" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>, <span class="pl-v">arguments</span>);</td>
+ </tr>
+ <tr>
+ <td id="L10650" class="blob-num js-line-number" data-line-number="10650"></td>
+ <td id="LC10650" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-v">this</span>;</td>
+ </tr>
+ <tr>
+ <td id="L10651" class="blob-num js-line-number" data-line-number="10651"></td>
+ <td id="LC10651" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L10652" class="blob-num js-line-number" data-line-number="10652"></td>
+ <td id="LC10652" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10653" class="blob-num js-line-number" data-line-number="10653"></td>
+ <td id="LC10653" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10654" class="blob-num js-line-number" data-line-number="10654"></td>
+ <td id="LC10654" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// add `Array` functions that return new wrapped values</span></td>
+ </tr>
+ <tr>
+ <td id="L10655" class="blob-num js-line-number" data-line-number="10655"></td>
+ <td id="LC10655" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">forEach</span>([<span class="pl-s"><span class="pl-pds">'</span>concat<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>slice<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>splice<span class="pl-pds">'</span></span>], <span class="pl-k">function</span>(<span class="pl-smi">methodName</span>) {</td>
+ </tr>
+ <tr>
+ <td id="L10656" class="blob-num js-line-number" data-line-number="10656"></td>
+ <td id="LC10656" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> func <span class="pl-k">=</span> arrayRef[methodName];</td>
+ </tr>
+ <tr>
+ <td id="L10657" class="blob-num js-line-number" data-line-number="10657"></td>
+ <td id="LC10657" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">lodash</span>.<span class="pl-c1">prototype</span>[methodName] <span class="pl-k">=</span> <span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10658" class="blob-num js-line-number" data-line-number="10658"></td>
+ <td id="LC10658" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-k">new</span> <span class="pl-en">lodashWrapper</span>(<span class="pl-smi">func</span>.<span class="pl-c1">apply</span>(<span class="pl-v">this</span>.<span class="pl-smi">__wrapped__</span>, <span class="pl-v">arguments</span>), <span class="pl-v">this</span>.<span class="pl-smi">__chain__</span>);</td>
+ </tr>
+ <tr>
+ <td id="L10659" class="blob-num js-line-number" data-line-number="10659"></td>
+ <td id="LC10659" class="blob-code blob-code-inner js-file-line"> };</td>
+ </tr>
+ <tr>
+ <td id="L10660" class="blob-num js-line-number" data-line-number="10660"></td>
+ <td id="LC10660" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10661" class="blob-num js-line-number" data-line-number="10661"></td>
+ <td id="LC10661" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10662" class="blob-num js-line-number" data-line-number="10662"></td>
+ <td id="LC10662" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> lodash;</td>
+ </tr>
+ <tr>
+ <td id="L10663" class="blob-num js-line-number" data-line-number="10663"></td>
+ <td id="LC10663" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10664" class="blob-num js-line-number" data-line-number="10664"></td>
+ <td id="LC10664" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10665" class="blob-num js-line-number" data-line-number="10665"></td>
+ <td id="LC10665" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">/*--------------------------------------------------------------------------*/</span></td>
+ </tr>
+ <tr>
+ <td id="L10666" class="blob-num js-line-number" data-line-number="10666"></td>
+ <td id="LC10666" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10667" class="blob-num js-line-number" data-line-number="10667"></td>
+ <td id="LC10667" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// expose Lo-Dash</span></td>
+ </tr>
+ <tr>
+ <td id="L10668" class="blob-num js-line-number" data-line-number="10668"></td>
+ <td id="LC10668" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">var</span> _ <span class="pl-k">=</span> <span class="pl-en">runInContext</span>();</td>
+ </tr>
+ <tr>
+ <td id="L10669" class="blob-num js-line-number" data-line-number="10669"></td>
+ <td id="LC10669" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10670" class="blob-num js-line-number" data-line-number="10670"></td>
+ <td id="LC10670" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// some AMD build optimizers like r.js check for condition patterns like the following:</span></td>
+ </tr>
+ <tr>
+ <td id="L10671" class="blob-num js-line-number" data-line-number="10671"></td>
+ <td id="LC10671" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (<span class="pl-k">typeof</span> define <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>function<span class="pl-pds">'</span></span> <span class="pl-k">&&</span> <span class="pl-k">typeof</span> <span class="pl-smi">define</span>.<span class="pl-smi">amd</span> <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span> [...]
+ </tr>
+ <tr>
+ <td id="L10672" class="blob-num js-line-number" data-line-number="10672"></td>
+ <td id="LC10672" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// Expose Lo-Dash to the global object even when an AMD loader is present in</span></td>
+ </tr>
+ <tr>
+ <td id="L10673" class="blob-num js-line-number" data-line-number="10673"></td>
+ <td id="LC10673" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// case Lo-Dash is loaded with a RequireJS shim config.</span></td>
+ </tr>
+ <tr>
+ <td id="L10674" class="blob-num js-line-number" data-line-number="10674"></td>
+ <td id="LC10674" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// See http://requirejs.org/docs/api.html#config-shim</span></td>
+ </tr>
+ <tr>
+ <td id="L10675" class="blob-num js-line-number" data-line-number="10675"></td>
+ <td id="LC10675" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">root</span>.<span class="pl-smi">_</span> <span class="pl-k">=</span> _;</td>
+ </tr>
+ <tr>
+ <td id="L10676" class="blob-num js-line-number" data-line-number="10676"></td>
+ <td id="LC10676" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10677" class="blob-num js-line-number" data-line-number="10677"></td>
+ <td id="LC10677" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// define as an anonymous module so, through path mapping, it can be</span></td>
+ </tr>
+ <tr>
+ <td id="L10678" class="blob-num js-line-number" data-line-number="10678"></td>
+ <td id="LC10678" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// referenced as the "underscore" module</span></td>
+ </tr>
+ <tr>
+ <td id="L10679" class="blob-num js-line-number" data-line-number="10679"></td>
+ <td id="LC10679" class="blob-code blob-code-inner js-file-line"> <span class="pl-en">define</span>(<span class="pl-k">function</span>() {</td>
+ </tr>
+ <tr>
+ <td id="L10680" class="blob-num js-line-number" data-line-number="10680"></td>
+ <td id="LC10680" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> _;</td>
+ </tr>
+ <tr>
+ <td id="L10681" class="blob-num js-line-number" data-line-number="10681"></td>
+ <td id="LC10681" class="blob-code blob-code-inner js-file-line"> });</td>
+ </tr>
+ <tr>
+ <td id="L10682" class="blob-num js-line-number" data-line-number="10682"></td>
+ <td id="LC10682" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10683" class="blob-num js-line-number" data-line-number="10683"></td>
+ <td id="LC10683" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// check for `exports` after `define` in case a build optimizer adds an `exports` object</span></td>
+ </tr>
+ <tr>
+ <td id="L10684" class="blob-num js-line-number" data-line-number="10684"></td>
+ <td id="LC10684" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> <span class="pl-k">if</span> (freeExports <span class="pl-k">&&</span> freeModule) {</td>
+ </tr>
+ <tr>
+ <td id="L10685" class="blob-num js-line-number" data-line-number="10685"></td>
+ <td id="LC10685" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// in Node.js or RingoJS</span></td>
+ </tr>
+ <tr>
+ <td id="L10686" class="blob-num js-line-number" data-line-number="10686"></td>
+ <td id="LC10686" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (moduleExports) {</td>
+ </tr>
+ <tr>
+ <td id="L10687" class="blob-num js-line-number" data-line-number="10687"></td>
+ <td id="LC10687" class="blob-code blob-code-inner js-file-line"> (<span class="pl-smi">freeModule</span>.<span class="pl-smi">exports</span> <span class="pl-k">=</span> _).<span class="pl-smi">_</span> <span class="pl-k">=</span> _;</td>
+ </tr>
+ <tr>
+ <td id="L10688" class="blob-num js-line-number" data-line-number="10688"></td>
+ <td id="LC10688" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10689" class="blob-num js-line-number" data-line-number="10689"></td>
+ <td id="LC10689" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// in Narwhal or Rhino -require</span></td>
+ </tr>
+ <tr>
+ <td id="L10690" class="blob-num js-line-number" data-line-number="10690"></td>
+ <td id="LC10690" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L10691" class="blob-num js-line-number" data-line-number="10691"></td>
+ <td id="LC10691" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">freeExports</span>.<span class="pl-smi">_</span> <span class="pl-k">=</span> _;</td>
+ </tr>
+ <tr>
+ <td id="L10692" class="blob-num js-line-number" data-line-number="10692"></td>
+ <td id="LC10692" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10693" class="blob-num js-line-number" data-line-number="10693"></td>
+ <td id="LC10693" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10694" class="blob-num js-line-number" data-line-number="10694"></td>
+ <td id="LC10694" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span> {</td>
+ </tr>
+ <tr>
+ <td id="L10695" class="blob-num js-line-number" data-line-number="10695"></td>
+ <td id="LC10695" class="blob-code blob-code-inner js-file-line"> <span class="pl-c">// in a browser or Rhino</span></td>
+ </tr>
+ <tr>
+ <td id="L10696" class="blob-num js-line-number" data-line-number="10696"></td>
+ <td id="LC10696" class="blob-code blob-code-inner js-file-line"> <span class="pl-smi">root</span>.<span class="pl-smi">_</span> <span class="pl-k">=</span> _;</td>
+ </tr>
+ <tr>
+ <td id="L10697" class="blob-num js-line-number" data-line-number="10697"></td>
+ <td id="LC10697" class="blob-code blob-code-inner js-file-line"> }</td>
+ </tr>
+ <tr>
+ <td id="L10698" class="blob-num js-line-number" data-line-number="10698"></td>
+ <td id="LC10698" class="blob-code blob-code-inner js-file-line">}.<span class="pl-c1">call</span>(<span class="pl-v">this</span>));</td>
+ </tr>
+ <tr>
+ <td id="L10699" class="blob-num js-line-number" data-line-number="10699"></td>
+ <td id="LC10699" class="blob-code blob-code-inner js-file-line">
+</td>
+ </tr>
+ <tr>
+ <td id="L10700" class="blob-num js-line-number" data-line-number="10700"></td>
+ <td id="LC10700" class="blob-code blob-code-inner js-file-line">}).<span class="pl-c1">call</span>(<span class="pl-v">this</span>,<span class="pl-k">typeof</span> <span class="pl-c1">global</span> <span class="pl-k">!==</span> <span class="pl-s"><span class="pl-pds">"</span>undefined<span class="pl-pds">"</span></span> <span class="pl-k">?</span> <span class="pl-c1">global</span> <span class="pl-k">:</span> <span class="pl-k">typeof</span> self <span class="pl-k">!==</s [...]
+ </tr>
+ <tr>
+ <td id="L10701" class="blob-num js-line-number" data-line-number="10701"></td>
+ <td id="LC10701" class="blob-code blob-code-inner js-file-line">},{}]},{},[<span class="pl-c1">1</span>]);</td>
+ </tr>
+</table>
+
+ </div>
+
+</div>
+
+<button type="button" data-facebox="#jump-to-line" data-facebox-class="linejump" data-hotkey="l" class="hidden">Jump to Line</button>
+<div id="jump-to-line" style="display:none">
+ <!-- </textarea> --><!-- '"` --><form accept-charset="UTF-8" action="" class="js-jump-to-line-form" method="get"><div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="✓" /></div>
+ <input class="form-control linejump-input js-jump-to-line-field" type="text" placeholder="Jump to line…" aria-label="Jump to line" autofocus>
+ <button type="submit" class="btn">Go</button>
+</form></div>
+
+ </div>
+ <div class="modal-backdrop js-touch-events"></div>
+</div>
+
+
+ </div>
+ </div>
+
+ </div>
+
+ <div class="container site-footer-container">
+ <div class="site-footer" role="contentinfo">
+ <ul class="site-footer-links right">
+ <li><a href="https://github.com/contact" data-ga-click="Footer, go to contact, text:contact">Contact GitHub</a></li>
+ <li><a href="https://developer.github.com" data-ga-click="Footer, go to api, text:api">API</a></li>
+ <li><a href="https://training.github.com" data-ga-click="Footer, go to training, text:training">Training</a></li>
+ <li><a href="https://shop.github.com" data-ga-click="Footer, go to shop, text:shop">Shop</a></li>
+ <li><a href="https://github.com/blog" data-ga-click="Footer, go to blog, text:blog">Blog</a></li>
+ <li><a href="https://github.com/about" data-ga-click="Footer, go to about, text:about">About</a></li>
+
+ </ul>
+
+ <a href="https://github.com" aria-label="Homepage" class="site-footer-mark" title="GitHub">
+ <svg aria-hidden="true" class="octicon octicon-mark-github" height="24" version="1.1" viewBox="0 0 16 16" width="24"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36. [...]
+</a>
+ <ul class="site-footer-links">
+ <li>© 2016 <span title="0.23831s from github-fe152-cp1-prd.iad.github.net">GitHub</span>, Inc.</li>
+ <li><a href="https://github.com/site/terms" data-ga-click="Footer, go to terms, text:terms">Terms</a></li>
+ <li><a href="https://github.com/site/privacy" data-ga-click="Footer, go to privacy, text:privacy">Privacy</a></li>
+ <li><a href="https://github.com/security" data-ga-click="Footer, go to security, text:security">Security</a></li>
+ <li><a href="https://status.github.com/" data-ga-click="Footer, go to status, text:status">Status</a></li>
+ <li><a href="https://help.github.com" data-ga-click="Footer, go to help, text:help">Help</a></li>
+ </ul>
+ </div>
+</div>
+
+
+
+
+
+ <div id="ajax-error-message" class="ajax-error-message flash flash-error">
+ <svg aria-hidden="true" class="octicon octicon-alert" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path d="M8.865 1.52c-.18-.31-.51-.5-.87-.5s-.69.19-.87.5L.275 13.5c-.18.31-.18.69 0 1 .19.31.52.5.87.5h13.7c.36 0 .69-.19.86-.5.17-.31.18-.69.01-1L8.865 1.52zM8.995 13h-2v-2h2v2zm0-3h-2V6h2v4z"></path></svg>
+ <button type="button" class="flash-close js-flash-close js-ajax-error-dismiss" aria-label="Dismiss error">
+ <svg aria-hidden="true" class="octicon octicon-x" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M7.48 8l3.75 3.75-1.48 1.48L6 9.48l-3.75 3.75-1.48-1.48L4.52 8 .77 4.25l1.48-1.48L6 6.52l3.75-3.75 1.48 1.48z"></path></svg>
+ </button>
+ Something went wrong with that request. Please try again.
+ </div>
+
+
+
+ <script crossorigin="anonymous" integrity="sha256-FJ2TOMJmUXKHCCXHj6SP3MpNQx0GfL9f2nEg2eOcxzg=" src="https://assets-cdn.github.com/assets/frameworks-149d9338c2665172870825c78fa48fdcca4d431d067cbf5fda7120d9e39cc738.js"></script>
+ <script async="async" crossorigin="anonymous" integrity="sha256-ps8NSbwnqQE0nRxQVkqMGFZZawtAXjs1s3R3GfEDiqU=" src="https://assets-cdn.github.com/assets/github-a6cf0d49bc27a901349d1c50564a8c1856596b0b405e3b35b3747719f1038aa5.js"></script>
+
+
+
+
+
+
+ <div class="js-stale-session-flash stale-session-flash flash flash-warn flash-banner hidden">
+ <svg aria-hidden="true" class="octicon octicon-alert" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path d="M8.865 1.52c-.18-.31-.51-.5-.87-.5s-.69.19-.87.5L.275 13.5c-.18.31-.18.69 0 1 .19.31.52.5.87.5h13.7c.36 0 .69-.19.86-.5.17-.31.18-.69.01-1L8.865 1.52zM8.995 13h-2v-2h2v2zm0-3h-2V6h2v4z"></path></svg>
+ <span class="signed-in-tab-flash">You signed in with another tab or window. <a href="">Reload</a> to refresh your session.</span>
+ <span class="signed-out-tab-flash">You signed out in another tab or window. <a href="">Reload</a> to refresh your session.</span>
+ </div>
+ <div class="facebox" id="facebox" style="display:none;">
+ <div class="facebox-popup">
+ <div class="facebox-content" role="dialog" aria-labelledby="facebox-header" aria-describedby="facebox-description">
+ </div>
+ <button type="button" class="facebox-close js-facebox-close" aria-label="Close modal">
+ <svg aria-hidden="true" class="octicon octicon-x" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path d="M7.48 8l3.75 3.75-1.48 1.48L6 9.48l-3.75 3.75-1.48-1.48L4.52 8 .77 4.25l1.48-1.48L6 6.52l3.75-3.75 1.48 1.48z"></path></svg>
+ </button>
+ </div>
+</div>
+
+ </body>
+</html>
+
diff --git a/debian/source.lintian-overrides b/debian/source.lintian-overrides
new file mode 100644
index 0000000..a67b4c0
--- /dev/null
+++ b/debian/source.lintian-overrides
@@ -0,0 +1,23 @@
+# minified versions of Javascript libraries shipped by purpose
+theano source: source-contains-prebuilt-javascript-object theano/d3viz/js/d3.v3.min.js
+theano source: source-contains-prebuilt-javascript-object theano/d3viz/js/dagre-d3.min.js
+theano source: source-contains-prebuilt-javascript-object theano/d3viz/js/graphlib-dot.min.js
+theano source: source-contains-prebuilt-javascript-object doc/library/d3viz/examples/d3viz/js/d3.v3.min.js
+theano source: source-contains-prebuilt-javascript-object doc/library/d3viz/examples/d3viz/js/dagre-d3.min.js
+theano source: source-contains-prebuilt-javascript-object doc/library/d3viz/examples/d3viz/js/graphlib-dot.min.js
+
+# added sources in debian/missing-source (see README.txt for details)
+theano source: source-is-missing theano/d3viz/js/d3.v3.min.js
+theano source: source-is-missing theano/d3viz/js/dagre-d3.min.js
+theano source: source-is-missing theano/d3viz/js/graphlib-dot.min.js
+theano source: source-is-missing doc/library/d3viz/examples/d3viz/js/d3.v3.min.js
+theano source: source-is-missing doc/library/d3viz/examples/d3viz/js/dagre-d3.min.js
+theano source: source-is-missing doc/library/d3viz/examples/d3viz/js/graphlib-dot.min.js
+
+# prevent complaints on added sources in deb/missing-source
+theano source: insane-line-length-in-source-file debian/missing-source/dagre-d3.js line length is 805 characters (>512)
+theano source: source-contains-prebuilt-javascript-object debian/missing-source/dagre-d3.js line length is 805 characters (>512)
+theano source: source-is-missing debian/missing-source/dagre-d3.js line length is 805 characters (>512)
+theano source: insane-line-length-in-source-file debian/missing-source/graphlib-dot.js line length is 598 characters (>512)
+theano source: source-contains-prebuilt-javascript-object debian/missing-source/graphlib-dot.js line length is 596 characters (>512)
+theano source: source-is-missing debian/missing-source/graphlib-dot.js line length is 596 characters (>512)
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/theano.git
More information about the debian-science-commits
mailing list