https://www.idc-otsuka.jp/item/html/template/default/customize/assets/js/item/web.assets_common.js

1/* /web/static/lib/es5-shim/es5-shim.min.js defined in bundle 'web.assets_common' */
2(function(definition) {
3if (typeof define == "function") {
4define(definition)
5} else if (typeof YUI == "function") {
6YUI.add("es5", definition)
7} else {
8definition()
9}
10}
11)(function() {
12function Empty() {}
13if (!Function.prototype.bind) {
14Function.prototype.bind = function bind(that) {
15var target = this;
16if (typeof target != "function") {
17throw new TypeError("Function.prototype.bind called on incompatible " + target)
18}
19var args = _Array_slice_.call(arguments, 1);
20var bound = function() {
21if (this instanceof bound) {
22var result = target.apply(this, args.concat(_Array_slice_.call(arguments)));
23if (Object(result) === result) {
24return result
25}
26return this
27} else {
28return target.apply(that, args.concat(_Array_slice_.call(arguments)))
29}
30};
31if (target.prototype) {
32Empty.prototype = target.prototype;
33bound.prototype = new Empty;
34Empty.prototype = null
35}
36return bound
37}
38}
39var call = Function.prototype.call;
40var prototypeOfArray = Array.prototype;
41var prototypeOfObject = Object.prototype;
42var _Array_slice_ = prototypeOfArray.slice;
43var _toString = call.bind(prototypeOfObject.toString);
44var owns = call.bind(prototypeOfObject.hasOwnProperty);
45var defineGetter;
46var defineSetter;
47var lookupGetter;
48var lookupSetter;
49var supportsAccessors;
50if (supportsAccessors = owns(prototypeOfObject, "__defineGetter__")) {
51defineGetter = call.bind(prototypeOfObject.__defineGetter__);
52defineSetter = call.bind(prototypeOfObject.__defineSetter__);
53lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
54lookupSetter = call.bind(prototypeOfObject.__lookupSetter__)
55}
56if ([1, 2].splice(0).length != 2) {
57var array_splice = Array.prototype.splice;
58if (function() {
59function makeArray(l) {
60var a = [];
61while (l--) {
62a.unshift(l)
63}
64return a
65}
66var array = [], lengthBefore;
67array.splice.bind(array, 0, 0).apply(null, makeArray(20));
68array.splice.bind(array, 0, 0).apply(null, makeArray(26));
69lengthBefore = array.length;
70array.splice(5, 0, "XXX");
71if (lengthBefore + 1 == array.length) {
72return true
73}
74}()) {
75Array.prototype.splice = function(start, deleteCount) {
76if (!arguments.length) {
77return []
78} else {
79return array_splice.apply(this, [start === void 0 ? 0 : start, deleteCount === void 0 ? this.length - start : deleteCount].concat(_Array_slice_.call(arguments, 2)))
80}
81}
82} else {
83Array.prototype.splice = function(start, deleteCount) {
84var result, args = _Array_slice_.call(arguments, 2), addElementsCount = args.length;
85if (!arguments.length) {
86return []
87}
88if (start === void 0) {
89start = 0
90}
91if (deleteCount === void 0) {
92deleteCount = this.length - start
93}
94if (addElementsCount > 0) {
95if (deleteCount <= 0) {
96if (start == this.length) {
97this.push.apply(this, args);
98return []
99}
100if (start == 0) {
101this.unshift.apply(this, args);
102return []
103}
104}
105result = _Array_slice_.call(this, start, start + deleteCount);
106args.push.apply(args, _Array_slice_.call(this, start + deleteCount, this.length));
107args.unshift.apply(args, _Array_slice_.call(this, 0, start));
108args.unshift(0, this.length);
109array_splice.apply(this, args);
110return result
111}
112return array_splice.call(this, start, deleteCount)
113}
114}
115}
116if ([].unshift(0) != 1) {
117var array_unshift = Array.prototype.unshift;
118Array.prototype.unshift = function() {
119array_unshift.apply(this, arguments);
120return this.length
121}
122}
123if (!Array.isArray) {
124Array.isArray = function isArray(obj) {
125return _toString(obj) == "[object Array]"
126}
127}
128var boxedString = Object("a")
129  , splitString = boxedString[0] != "a" || !(0 in boxedString);
130if (!Array.prototype.forEach) {
131Array.prototype.forEach = function forEach(fun) {
132var object = toObject(this)
133  , self = splitString && _toString(this) == "[object String]" ? this.split("") : object
134  , thisp = arguments[1]
135  , i = -1
136  , length = self.length >>> 0;
137if (_toString(fun) != "[object Function]") {
138throw new TypeError
139}
140while (++i < length) {
141if (i in self) {
142fun.call(thisp, self[i], i, object)
143}
144}
145}
146}
147if (!Array.prototype.map) {
148Array.prototype.map = function map(fun) {
149var object = toObject(this)
150  , self = splitString && _toString(this) == "[object String]" ? this.split("") : object
151  , length = self.length >>> 0
152  , result = Array(length)
153  , thisp = arguments[1];
154if (_toString(fun) != "[object Function]") {
155throw new TypeError(fun + " is not a function")
156}
157for (var i = 0; i < length; i++) {
158if (i in self)
159result[i] = fun.call(thisp, self[i], i, object)
160}
161return result
162}
163}
164if (!Array.prototype.filter) {
165Array.prototype.filter = function filter(fun) {
166var object = toObject(this), self = splitString && _toString(this) == "[object String]" ? this.split("") : object, length = self.length >>> 0, result = [], value, thisp = arguments[1];
167if (_toString(fun) != "[object Function]") {
168throw new TypeError(fun + " is not a function")
169}
170for (var i = 0; i < length; i++) {
171if (i in self) {
172value = self[i];
173if (fun.call(thisp, value, i, object)) {
174result.push(value)
175}
176}
177}
178return result
179}
180}
181if (!Array.prototype.every) {
182Array.prototype.every = function every(fun) {
183var object = toObject(this)
184  , self = splitString && _toString(this) == "[object String]" ? this.split("") : object
185  , length = self.length >>> 0
186  , thisp = arguments[1];
187if (_toString(fun) != "[object Function]") {
188throw new TypeError(fun + " is not a function")
189}
190for (var i = 0; i < length; i++) {
191if (i in self && !fun.call(thisp, self[i], i, object)) {
192return false
193}
194}
195return true
196}
197}
198if (!Array.prototype.some) {
199Array.prototype.some = function some(fun) {
200var object = toObject(this)
201  , self = splitString && _toString(this) == "[object String]" ? this.split("") : object
202  , length = self.length >>> 0
203  , thisp = arguments[1];
204if (_toString(fun) != "[object Function]") {
205throw new TypeError(fun + " is not a function")
206}
207for (var i = 0; i < length; i++) {
208if (i in self && fun.call(thisp, self[i], i, object)) {
209return true
210}
211}
212return false
213}
214}
215if (!Array.prototype.reduce) {
216Array.prototype.reduce = function reduce(fun) {
217var object = toObject(this)
218  , self = splitString && _toString(this) == "[object String]" ? this.split("") : object
219  , length = self.length >>> 0;
220if (_toString(fun) != "[object Function]") {
221throw new TypeError(fun + " is not a function")
222}
223if (!length && arguments.length == 1) {
224throw new TypeError("reduce of empty array with no initial value")
225}
226var i = 0;
227var result;
228if (arguments.length >= 2) {
229result = arguments[1]
230} else {
231do {
232if (i in self) {
233result = self[i++];
234break
235}
236if (++i >= length) {
237throw new TypeError("reduce of empty array with no initial value")
238}
239} while (true)
240}
241for (; i < length; i++) {
242if (i in self) {
243result = fun.call(void 0, result, self[i], i, object)
244}
245}
246return result
247}
248}
249if (!Array.prototype.reduceRight) {
250Array.prototype.reduceRight = function reduceRight(fun) {
251var object = toObject(this)
252  , self = splitString && _toString(this) == "[object String]" ? this.split("") : object
253  , length = self.length >>> 0;
254if (_toString(fun) != "[object Function]") {
255throw new TypeError(fun + " is not a function")
256}
257if (!length && arguments.length == 1) {
258throw new TypeError("reduceRight of empty array with no initial value")
259}
260var result, i = length - 1;
261if (arguments.length >= 2) {
262result = arguments[1]
263} else {
264do {
265if (i in self) {
266result = self[i--];
267break
268}
269if (--i < 0) {
270throw new TypeError("reduceRight of empty array with no initial value")
271}
272} while (true)
273}
274if (i < 0) {
275return result
276}
277do {
278if (i in this) {
279result = fun.call(void 0, result, self[i], i, object)
280}
281} while (i--);return result
282}
283}
284if (!Array.prototype.indexOf || [0, 1].indexOf(1, 2) != -1) {
285Array.prototype.indexOf = function indexOf(sought) {
286var self = splitString && _toString(this) == "[object String]" ? this.split("") : toObject(this)
287  , length = self.length >>> 0;
288if (!length) {
289return -1
290}
291var i = 0;
292if (arguments.length > 1) {
293i = toInteger(arguments[1])
294}
295i = i >= 0 ? i : Math.max(0, length + i);
296for (; i < length; i++) {
297if (i in self && self[i] === sought) {
298return i
299}
300}
301return -1
302}
303}
304if (!Array.prototype.lastIndexOf || [0, 1].lastIndexOf(0, -3) != -1) {
305Array.prototype.lastIndexOf = function lastIndexOf(sought) {
306var self = splitString && _toString(this) == "[object String]" ? this.split("") : toObject(this)
307  , length = self.length >>> 0;
308if (!length) {
309return -1
310}
311var i = length - 1;
312if (arguments.length > 1) {
313i = Math.min(i, toInteger(arguments[1]))
314}
315i = i >= 0 ? i : length - Math.abs(i);
316for (; i >= 0; i--) {
317if (i in self && sought === self[i]) {
318return i
319}
320}
321return -1
322}
323}
324if (!Object.keys) {
325var hasDontEnumBug = true
326  , dontEnums = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"]
327  , dontEnumsLength = dontEnums.length;
328for (var key in {
329toString: null
330}) {
331hasDontEnumBug = false
332}
333Object.keys = function keys(object) {
334if (typeof object != "object" && typeof object != "function" || object === null) {
335throw new TypeError("Object.keys called on a non-object")
336}
337var keys = [];
338for (var name in object) {
339if (owns(object, name)) {
340keys.push(name)
341}
342}
343if (hasDontEnumBug) {
344for (var i = 0, ii = dontEnumsLength; i < ii; i++) {
345var dontEnum = dontEnums[i];
346if (owns(object, dontEnum)) {
347keys.push(dontEnum)
348}
349}
350}
351return keys
352}
353}
354var negativeDate = -621987552e5
355  , negativeYearString = "-000001";
356if (!Date.prototype.toISOString || new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1) {
357Date.prototype.toISOString = function toISOString() {
358var result, length, value, year, month;
359if (!isFinite(this)) {
360throw new RangeError("Date.prototype.toISOString called on non-finite value.")
361}
362year = this.getUTCFullYear();
363month = this.getUTCMonth();
364year += Math.floor(month / 12);
365month = (month % 12 + 12) % 12;
366result = [month + 1, this.getUTCDate(), this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()];
367year = (year < 0 ? "-" : year > 9999 ? "+" : "") + ("00000" + Math.abs(year)).slice(0 <= year && year <= 9999 ? -4 : -6);
368length = result.length;
369while (length--) {
370value = result[length];
371if (value < 10) {
372result[length] = "0" + value
373}
374}
375return year + "-" + result.slice(0, 2).join("-") + "T" + result.slice(2).join(":") + "." + ("000" + this.getUTCMilliseconds()).slice(-3) + "Z"
376}
377}
378var dateToJSONIsSupported = false;
379try {
380dateToJSONIsSupported = Date.prototype.toJSON && new Date(NaN).toJSON() === null && new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 && Date.prototype.toJSON.call({
381toISOString: function() {
382return true
383}
384})
385} catch (e) {}
386if (!dateToJSONIsSupported) {
387Date.prototype.toJSON = function toJSON(key) {
388var o = Object(this), tv = toPrimitive(o), toISO;
389if (typeof tv === "number" && !isFinite(tv)) {
390return null
391}
392toISO = o.toISOString;
393if (typeof toISO != "function") {
394throw new TypeError("toISOString property is not callable")
395}
396return toISO.call(o)
397}
398}
399if (!Date.parse || "Date.parse is buggy") {
400Date = function(NativeDate) {
401function Date(Y, M, D, h, m, s, ms) {
402var length = arguments.length;
403if (this instanceof NativeDate) {
404var date = length == 1 && String(Y) === Y ? new NativeDate(Date.parse(Y)) : length >= 7 ? new NativeDate(Y,M,D,h,m,s,ms) : length >= 6 ? new NativeDate(Y,M,D,h,m,s) : length >= 5 ? new NativeDate(Y,M,D,h,m) : length >= 4 ? new NativeDate(Y,M,D,h) : length >= 3 ? new NativeDate(Y,M,D) : length >= 2 ? new NativeDate(Y,M) : length >= 1 ? new NativeDate(Y) : new NativeDate;
405date.constructor = Date;
406return date
407}
408return NativeDate.apply(this, arguments)
409}
410var isoDateExpression = new RegExp("^" + "(\\d{4}|[+-]\\d{6})" + "(?:-(\\d{2})" + "(?:-(\\d{2})" + "(?:" + "T(\\d{2})" + ":(\\d{2})" + "(?:" + ":(\\d{2})" + "(?:(\\.\\d{1,}))?" + ")?" + "(" + "Z|" + "(?:" + "([-+])" + "(\\d{2})" + ":(\\d{2})" + ")" + ")?)?)?)?" + "$");
411var months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365];
412function dayFromMonth(year, month) {
413var t = month > 1 ? 1 : 0;
414return months[month] + Math.floor((year - 1969 + t) / 4) - Math.floor((year - 1901 + t) / 100) + Math.floor((year - 1601 + t) / 400) + 365 * (year - 1970)
415}
416for (var key in NativeDate) {
417Date[key] = NativeDate[key]
418}
419Date.now = NativeDate.now;
420Date.UTC = NativeDate.UTC;
421Date.prototype = NativeDate.prototype;
422Date.prototype.constructor = Date;
423Date.parse = function parse(string) {
424var match = isoDateExpression.exec(string);
425if (match) {
426var year = Number(match[1]), month = Number(match[2] || 1) - 1, day = Number(match[3] || 1) - 1, hour = Number(match[4] || 0), minute = Number(match[5] || 0), second = Number(match[6] || 0), millisecond = Math.floor(Number(match[7] || 0) * 1e3), offset = !match[4] || match[8] ? 0 : Number(new NativeDate(1970,0)), signOffset = match[9] === "-" ? 1 : -1, hourOffset = Number(match[10] || 0), minuteOffset = Number(match[11] || 0), result;
427if (hour < (minute > 0 || second > 0 || millisecond > 0 ? 24 : 25) && minute < 60 && second < 60 && millisecond < 1e3 && month > -1 && month < 12 && hourOffset < 24 && minuteOffset < 60 && day >

770if (!undefinedOnly || obj[key] === void 0)
771obj[key] = source[key];
772}
773}
774return obj;
775}
776;
777};
778var baseCreate = function(prototype) {
779if (!_.isObject(prototype))
780return {};
781if (nativeCreate)
782return nativeCreate(prototype);
783Ctor.prototype = prototype;
784var result = new Ctor;
785Ctor.prototype = null;
786return result;
787};
788var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
789var isArrayLike = function(collection) {
790var length = collection && collection.length;
791return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
792};
793_.each = _.forEach = function(obj, iteratee, context) {
794iteratee = optimizeCb(iteratee, context);
795var i, length;
796if (isArrayLike(obj)) {
797for (i = 0,
798length = obj.length; i < length; i++) {
799iteratee(obj[i], i, obj);
800}
801} else {
802var keys = _.keys(obj);
803for (i = 0,
804length = keys.length; i < length; i++) {
805iteratee(obj[keys[i]], keys[i], obj);
806}
807}
808return obj;
809}
810;
811_.map = _.collect = function(obj, iteratee, context) {
812iteratee = cb(iteratee, context);
813var keys = !isArrayLike(obj) && _.keys(obj)
814  , length = (keys || obj).length
815  , results = Array(length);
816for (var index = 0; index < length; index++) {
817var currentKey = keys ? keys[index] : index;
818results[index] = iteratee(obj[currentKey], currentKey, obj);
819}
820return results;
821}
822;
823function createReduce(dir) {
824function iterator(obj, iteratee, memo, keys, index, length) {
825for (; index >= 0 && index < length; index += dir) {
826var currentKey = keys ? keys[index] : index;
827memo = iteratee(memo, obj[currentKey], currentKey, obj);
828}
829return memo;
830}
831return function(obj, iteratee, memo, context) {
832iteratee = optimizeCb(iteratee, context, 4);
833var keys = !isArrayLike(obj) && _.keys(obj)
834  , length = (keys || obj).length
835  , index = dir > 0 ? 0 : length - 1;
836if (arguments.length < 3) {
837memo = obj[keys ? keys[index] : index];
838index += dir;
839}
840return iterator(obj, iteratee, memo, keys, index, length);
841}
842;
843}
844_.reduce = _.foldl = _.inject = createReduce(1);
845_.reduceRight = _.foldr = createReduce(-1);
846_.find = _.detect = function(obj, predicate, context) {
847var key;
848if (isArrayLike(obj)) {
849key = _.findIndex(obj, predicate, context);
850} else {
851key = _.findKey(obj, predicate, context);
852}
853if (key !== void 0 && key !== -1)
854return obj[key];
855}
856;
857_.filter = _.select = function(obj, predicate, context) {
858var results = [];
859predicate = cb(predicate, context);
860_.each(obj, function(value, index, list) {
861if (predicate(value, index, list))
862results.push(value);
863});
864return results;
865}
866;
867_.reject = function(obj, predicate, context) {
868return _.filter(obj, _.negate(cb(predicate)), context);
869}
870;
871_.every = _.all = function(obj, predicate, context) {
872predicate = cb(predicate, context);
873var keys = !isArrayLike(obj) && _.keys(obj)
874  , length = (keys || obj).length;
875for (var index = 0; index < length; index++) {
876var currentKey = keys ? keys[index] : index;
877if (!predicate(obj[currentKey], currentKey, obj))
878return false;
879}
880return true;
881}
882;
883_.some = _.any = function(obj, predicate, context) {
884predicate = cb(predicate, context);
885var keys = !isArrayLike(obj) && _.keys(obj)
886  , length = (keys || obj).length;
887for (var index = 0; index < length; index++) {
888var currentKey = keys ? keys[index] : index;
889if (predicate(obj[currentKey], currentKey, obj))
890return true;
891}
892return false;
893}
894;
895_.contains = _.includes = _.include = function(obj, target, fromIndex) {
896if (!isArrayLike(obj))
897obj = _.values(obj);
898return _.indexOf(obj, target, typeof fromIndex == 'number' && fromIndex) >= 0;
899}
900;
901_.invoke = function(obj, method) {
902var args = slice.call(arguments, 2);
903var isFunc = _.isFunction(method);
904return _.map(obj, function(value) {
905var func = isFunc ? method : value[method];
906return func == null ? func : func.apply(value, args);
907});
908}
909;
910_.pluck = function(obj, key) {
911return _.map(obj, _.property(key));
912}
913;
914_.where = function(obj, attrs) {
915return _.filter(obj, _.matcher(attrs));
916}
917;
918_.findWhere = function(obj, attrs) {
919return _.find(obj, _.matcher(attrs));
920}
921;
922_.max = function(obj, iteratee, context) {
923var result = -Infinity, lastComputed = -Infinity, value, computed;
924if (iteratee == null && obj != null) {
925obj = isArrayLike(obj) ? obj : _.values(obj);
926for (var i = 0, length = obj.length; i < length; i++) {
927value = obj[i];
928if (value > result) {
929result = value;
930}
931}
932} else {
933iteratee = cb(iteratee, context);
934_.each(obj, function(value, index, list) {
935computed = iteratee(value, index, list);
936if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
937result = value;
938lastComputed = computed;
939}
940});
941}
942return result;
943}
944;
945_.min = function(obj, iteratee, context) {
946var result = Infinity, lastComputed = Infinity, value, computed;
947if (iteratee == null && obj != null) {
948obj = isArrayLike(obj) ? obj : _.values(obj);
949for (var i = 0, length = obj.length; i < length; i++) {
950value = obj[i];
951if (value < result) {
952result = value;
953}
954}
955} else {
956iteratee = cb(iteratee, context);
957_.each(obj, function(value, index, list) {
958computed = iteratee(value, index, list);

959if (computed < lastComputed || computed === Infinity && result === Infinity) {
960result = value;
961lastComputed = computed;
962}
963});
964}
965return result;
966}
967;
968_.shuffle = function(obj) {
969var set = isArrayLike(obj) ? obj : _.values(obj);
970var length = set.length;
971var shuffled = Array(length);
972for (var index = 0, rand; index < length; index++) {
973rand = _.random(0, index);
974if (rand !== index)
975shuffled[index] = shuffled[rand];
976shuffled[rand] = set[index];
977}
978return shuffled;
979}
980;
981_.sample = function(obj, n, guard) {
982if (n == null || guard) {
983if (!isArrayLike(obj))
984obj = _.values(obj);
985return obj[_.random(obj.length - 1)];
986}
987return _.shuffle(obj).slice(0, Math.max(0, n));
988}
989;
990_.sortBy = function(obj, iteratee, context) {
991iteratee = cb(iteratee, context);
992return _.pluck(_.map(obj, function(value, index, list) {
993return {
994value: value,
995index: index,
996criteria: iteratee(value, index, list)
997};
998}).sort(function(left, right) {
999var a = left.criteria;
1000var b = right.criteria;
1001if (a !== b) {
1002if (a > b || a === void 0)
1003return 1;
1004if (a < b || b === void 0)
1005return -1;
1006}
1007return left.index - right.index;
1008}), 'value');
1009}
1010;
1011var group = function(behavior) {
1012return function(obj, iteratee, context) {
1013var result = {};
1014iteratee = cb(iteratee, context);
1015_.each(obj, function(value, index) {
1016var key = iteratee(value, index, obj);
1017behavior(result, value, key);
1018});
1019return result;
1020}
1021;
1022};
1023_.groupBy = group(function(result, value, key) {
1024if (_.has(result, key))
1025result[key].push(value);
1026else
1027result[key] = [value];
1028});
1029_.indexBy = group(function(result, value, key) {
1030result[key] = value;
1031});
1032_.countBy = group(function(result, value, key) {
1033if (_.has(result, key))
1034result[key]++;
1035else
1036result[key] = 1;
1037});
1038_.toArray = function(obj) {
1039if (!obj)
1040return [];
1041if (_.isArray(obj))
1042return slice.call(obj);
1043if (isArrayLike(obj))
1044return _.map(obj, _.identity);
1045return _.values(obj);
1046}
1047;
1048_.size = function(obj) {
1049if (obj == null)
1050return 0;
1051return isArrayLike(obj) ? obj.length : _.keys(obj).length;
1052}
1053;
1054_.partition = function(obj, predicate, context) {
1055predicate = cb(predicate, context);
1056var pass = []
1057  , fail = [];
1058_.each(obj, function(value, key, obj) {
1059(predicate(value, key, obj) ? pass : fail).push(value);
1060});
1061return [pass, fail];
1062}
1063;
1064_.first = _.head = _.take = function(array, n, guard) {
1065if (array == null)
1066return void 0;
1067if (n == null || guard)
1068return array[0];
1069return _.initial(array, array.length - n);
1070}
1071;
1072_.initial = function(array, n, guard) {
1073return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
1074}
1075;
1076_.last = function(array, n, guard) {
1077if (array == null)
1078return void 0;
1079if (n == null || guard)
1080return array[array.length - 1];
1081return _.rest(array, Math.max(0, array.length - n));
1082}
1083;
1084_.rest = _.tail = _.drop = function(array, n, guard) {
1085return slice.call(array, n == null || guard ? 1 : n);
1086}
1087;
1088_.compact = function(array) {
1089return _.filter(array, _.identity);
1090}
1091;
1092var flatten = function(input, shallow, strict, startIndex) {
1093var output = []
1094  , idx = 0;
1095for (var i = startIndex || 0, length = input && input.length; i < length; i++) {
1096var value = input[i];
1097if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
1098if (!shallow)
1099value = flatten(value, shallow, strict);
1100var j = 0
1101  , len = value.length;
1102output.length += len;
1103while (j < len) {
1104output[idx++] = value[j++];
1105}
1106} else if (!strict) {
1107output[idx++] = value;
1108}
1109}
1110return output;
1111};
1112_.flatten = function(array, shallow) {
1113return flatten(array, shallow, false);
1114}
1115;
1116_.without = function(array) {
1117return _.difference(array, slice.call(arguments, 1));
1118}
1119;
1120_.uniq = _.unique = function(array, isSorted, iteratee, context) {
1121if (array == null)
1122return [];
1123if (!_.isBoolean(isSorted)) {
1124context = iteratee;
1125iteratee = isSorted;
1126isSorted = false;
1127}
1128if (iteratee != null)
1129iteratee = cb(iteratee, context);
1130var result = [];
1131var seen = [];
1132for (var i = 0, length = array.length; i < length; i++) {
1133var value = array[i]
1134  , computed = iteratee ? iteratee(value, i, array) : value;
1135if (isSorted) {
1136if (!i || seen !== computed)
1137result.push(value);
1138seen = computed;
1139} else if (iteratee) {
1140if (!_.contains(seen, computed)) {
1141seen.push(computed);
1142result.push(value);
1143}
1144} else if (!_.contains(result, value)) {
1145result.push(value);
1146}
1147}
1148return result;
1149}
1150;
1151_.union = function() {
1152return _.uniq(flatten(arguments, true, true));
1153}
1154;
1155_.intersection = function(array) {
1156if (array == null)
1157return [];
1158var result = [];
1159var argsLength = arguments.length;
1160for (var i = 0, length = array.length; i < length; i++) {
1161var item = array[i];
1162if (_.contains(result, item))
1163continue;
1164for (var j = 1; j < argsLength; j++) {
1165if (!_.contains(arguments[j], item))
1166break;
1167}
1168if (j === argsLength)
1169result.push(item);
1170}
1171return result;
1172}
1173;
1174_.difference = function(array) {
1175var rest = flatten(arguments, true, true, 1);
1176return _.filter(array, function(value) {
1177return !_.contains(rest, value);
1178});
1179}
1180;
1181_.zip = function() {
1182return _.unzip(arguments);
1183}
1184;
1185_.unzip = function(array) {
1186var length = array && _.max(array, 'length').length || 0;
1187var result = Array(length);
1188for (var index = 0; index < length; index++) {
1189result[index] = _.pluck(array, index);
1190}
1191return result;
1192}
1193;
1194_.object = function(list, values) {
1195var result = {};
1196for (var i = 0, length = list && list.length; i < length; i++) {
1197if (values) {
1198result[list[i]] = values[i];
1199} else {
1200result[list[i][0]] = list[i][1];
1201}
1202}
1203return result;
1204}
1205;
1206_.indexOf = function(array, item, isSorted) {
1207var i = 0
1208  , length = array && array.length;
1209if (typeof isSorted == 'number') {
1210i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
1211} else if (isSorted && length) {
1212i = _.sortedIndex(array, item);
1213return array[i] === item ? i : -1;
1214}
1215if (item !== item) {
1216return _.findIndex(slice.call(array, i), _.isNaN);
1217}
1218for (; i < length; i++)
1219if (array[i] === item)
1220return i;
1221return -1;
1222}
1223;
1224_.lastIndexOf = function(array, item, from) {
1225var idx = array ? array.length : 0;
1226if (typeof from == 'number') {
1227idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);
1228}
1229if (item !== item) {
1230return _.findLastIndex(slice.call(array, 0, idx), _.isNaN);
1231}
1232while (--idx >= 0)
1233if (array[idx] === item)
1234return idx;
1235return -1;
1236}
1237;
1238function createIndexFinder(dir) {
1239return function(array, predicate, context) {
1240predicate = cb(predicate, context);
1241var length = array != null && array.length;
1242var index = dir > 0 ? 0 : length - 1;
1243for (; index >= 0 && index < length; index += dir) {
1244if (predicate(array[index], index, array))
1245return index;
1246}
1247return -1;
1248}
1249;
1250}
1251_.findIndex = createIndexFinder(1);
1252_.findLastIndex = createIndexFinder(-1);
1253_.sortedIndex = function(array, obj, iteratee, context) {
1254iteratee = cb(iteratee, context, 1);
1255var value = iteratee(obj);
1256var low = 0
1257  , high = array.length;
1258while (low < high) {
1259var mid = Math.floor((low + high) / 2);
1260if (iteratee(array[mid]) < value)
1261low = mid + 1;
1262else
1263high = mid;
1264}
1265return low;
1266}
1267;
1268_.range = function(start, stop, step) {
1269if (arguments.length <= 1) {
1270stop = start || 0;
1271start = 0;
1272}
1273step = step || 1;
1274var length = Math.max(Math.ceil((stop - start) / step), 0);
1275var range = Array(length);
1276for (var idx = 0; idx < length; idx++,
1277start += step) {
1278range[idx] = start;
1279}
1280return range;
1281}
1282;
1283var executeBound = function(sourceFunc, boundFunc, context, callingContext, args

1283) {
1284if (!(callingContext instanceof boundFunc))
1285return sourceFunc.apply(context, args);
1286var self = baseCreate(sourceFunc.prototype);
1287var result = sourceFunc.apply(self, args);
1288if (_.isObject(result))
1289return result;
1290return self;
1291};
1292_.bind = function(func, context) {
1293if (nativeBind && func.bind === nativeBind)
1294return nativeBind.apply(func, slice.call(arguments, 1));
1295if (!_.isFunction(func))
1296throw new TypeError('Bind must be called on a function');
1297var args = slice.call(arguments, 2);
1298var bound = function() {
1299return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));
1300};
1301return bound;
1302}
1303;
1304_.partial = function(func) {
1305var boundArgs = slice.call(arguments, 1);
1306var bound = function() {
1307var position = 0
1308  , length = boundArgs.length;
1309var args = Array(length);
1310for (var i = 0; i < length; i++) {
1311args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
1312}
1313while (position < arguments.length)
1314args.push(arguments[position++]);
1315return executeBound(func, bound, this, this, args);
1316};
1317return bound;
1318}
1319;
1320_.bindAll = function(obj) {
1321var i, length = arguments.length, key;
1322if (length <= 1)
1323throw new Error('bindAll must be passed function names');
1324for (i = 1; i < length; i++) {
1325key = arguments[i];
1326obj[key] = _.bind(obj[key], obj);
1327}
1328return obj;
1329}
1330;
1331_.memoize = function(func, hasher) {
1332var memoize = function(key) {
1333var cache = memoize.cache;
1334var address = '' + (hasher ? hasher.apply(this, arguments) : key);
1335if (!_.has(cache, address))
1336cache[address] = func.apply(this, arguments);
1337return cache[address];
1338};
1339memoize.cache = {};
1340return memoize;
1341}
1342;
1343_.delay = function(func, wait) {
1344var args = slice.call(arguments, 2);
1345return setTimeout(function() {
1346return func.apply(null, args);
1347}, wait);
1348}
1349;
1350_.defer = _.partial(_.delay, _, 1);
1351_.throttle = function(func, wait, options) {
1352var context, args, result;
1353var timeout = null;
1354var previous = 0;
1355if (!options)
1356options = {};
1357var later = function() {
1358previous = options.leading === false ? 0 : _.now();
1359timeout = null;
1360result = func.apply(context, args);
1361if (!timeout)
1362context = args = null;
1363};
1364return function() {
1365var now = _.now();
1366if (!previous && options.leading === false)
1367previous = now;
1368var remaining = wait - (now - previous);
1369context = this;
1370args = arguments;
1371if (remaining <= 0 || remaining > wait) {
1372if (timeout) {
1373clearTimeout(timeout);
1374timeout = null;
1375}
1376previous = now;
1377result = func.apply(context, args);
1378if (!timeout)
1379context = args = null;
1380} else if (!timeout && options.trailing !== false) {
1381timeout = setTimeout(later, remaining);
1382}
1383return result;
1384}
1385;
1386}
1387;
1388_.debounce = function(func, wait, immediate) {
1389var timeout, args, context, timestamp, result;
1390var later = function() {
1391var last = _.now() - timestamp;
1392if (last < wait && last >= 0) {
1393timeout = setTimeout(later, wait - last);
1394} else {
1395timeout = null;
1396if (!immediate) {
1397result = func.apply(context, args);
1398if (!timeout)
1399context = args = null;
1400}
1401}
1402};
1403return function() {
1404context = this;
1405args = arguments;
1406timestamp = _.now();
1407var callNow = immediate && !timeout;
1408if (!timeout)
1409timeout = setTimeout(later, wait);
1410if (callNow) {
1411result = func.apply(context, args);
1412context = args = null;
1413}
1414return result;
1415}
1416;
1417}
1418;
1419_.wrap = function(func, wrapper) {
1420return _.partial(wrapper, func);
1421}
1422;
1423_.negate = function(predicate) {
1424return function() {
1425return !predicate.apply(this, arguments);
1426}
1427;
1428}
1429;
1430_.compose = function() {
1431var args = arguments;
1432var start = args.length - 1;
1433return function() {
1434var i = start;
1435var result = args[start].apply(this, arguments);
1436while (i--)
1437result = args[i].call(this, result);
1438return result;
1439}
1440;
1441}
1442;
1443_.after = function(times, func) {
1444return function() {
1445if (--times < 1) {
1446return func.apply(this, arguments);
1447}
1448}
1449;
1450}
1451;
1452_.before = function(times, func) {
1453var memo;
1454return function() {
1455if (--times > 0) {
1456memo = func.apply(this, arguments);
1457}
1458if (times <= 1)
1459func = null;
1460return memo;
1461}
1462;
1463}
1464;
1465_.once = _.partial(_.before, 2);
1466var hasEnumBug = !{
1467toString: null
1468}.propertyIsEnumerable('toString');
1469var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
1470function collectNonEnumProps(obj, keys) {
1471var nonEnumIdx = nonEnumerableProps.length;
1472var constructor = obj.constructor;
1473var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;
1474var prop = 'constructor';
1475if (_.has(obj, prop) && !_.contains(keys, prop))
1476keys.push(prop);
1477while (nonEnumIdx--) {
1478prop = nonEnumerableProps[nonEnumIdx];
1479if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
1480keys.push(prop);
1481}
1482}
1483}
1484_.keys = function(obj) {
1485if (!_.isObject(obj))
1486return [];
1487if (nativeKeys)
1488return nativeKeys(obj);
1489var keys = [];
1490for (var key in obj)
1491if (_.has(obj, key))
1492keys.push(key);
1493if (hasEnumBug)
1494collectNonEnumProps(obj, keys);
1495return keys;
1496}
1497;
1498_.allKeys = function(obj) {
1499if (!_.isObject(obj))
1500return [];
1501var keys = [];
1502for (var key in obj)
1503keys.push(key);
1504if (hasEnumBug)
1505collectNonEnumProps(obj, keys);
1506return keys;
1507}
1508;
1509_.values = function(obj) {
1510var keys = _.keys(obj);
1511var length = keys.length;
1512var values = Array(length);
1513for (var i = 0; i < length; i++) {
1514values[i] = obj[keys[i]];
1515}
1516return values;
1517}
1518;
1519_.mapObject = function(obj, iteratee, context) {
1520iteratee = cb(iteratee, context);
1521var keys = _.keys(obj), length = keys.length, results = {}, currentKey;
1522for (var index = 0; index < length; index++) {
1523currentKey = keys[index];
1524results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
1525}
1526return results;
1527}
1528;
1529_.pairs = function(obj) {
1530var keys = _.keys(obj);
1531var length = keys.length;
1532var pairs = Array(length);
1533for (var i = 0; i < length; i++) {
1534pairs[i] = [keys[i], obj[keys[i]]];
1535}
1536return pairs;
1537}
1538;
1539_.invert = function(obj) {
1540var result = {};
1541var keys = _.keys(obj);
1542for (var i = 0, length = keys.length; i < length; i++) {
1543result[obj[keys[i]]] = keys[i];
1544}
1545return result;
1546}
1547;
1548_.functions = _.methods = function(obj) {
1549var names = [];
1550for (var key in obj) {
1551if (_.isFunction(obj[key]))
1552names.push(key);
1553}
1554return names.sort();
1555}
1556;
1557_.extend = createAssigner(_.allKeys);
1558_.extendOwn = _.assign = createAssigner(_.keys);
1559_.findKey = function(obj, predicate, context) {
1560predicate = cb(predicate, context);
1561var keys = _.keys(obj), key;
1562for (var i = 0, length = keys.length; i < length; i++) {
1563key = keys[i];
1564if (predicate(obj[key], key, obj))
1565return key;
1566}
1567}
1568;
1569_.pick = function(object, oiteratee, context) {
1570var result = {}, obj = object, iteratee, keys;
1571if (obj == null)
1572return result;
1573if (_.isFunction(oiteratee)) {
1574keys = _.allKeys(obj);
1575iteratee = optimizeCb(oiteratee, context);
1576} else {
1577keys = flatten(arguments, false, false, 1);
1578iteratee = function(value, key, obj) {
1579return key in obj;
1580}
1581;
1582obj = Object(obj);
1583}
1584for (var i = 0, length = keys.length; i < length; i++) {
1585var key = keys[i];
1586var value = obj[key];
1587if (iteratee(value, key, obj))
1588result[key] = value;
1589}
1590return result;
1591}
1592;
1593_.omit = function(obj, iteratee, context) {
1594if (_.isFunction(iteratee)) {
1595iteratee = _.negate(iteratee);
1596} else {
1597var keys = _.map(flatten(arguments, false, false, 1), String);
1598iteratee = function(value, key) {
1599return !_.contains(keys, key);
1600}
1601;
1602}
1603return _.pick(obj, iteratee, context);
1604}
1605;
1606_.defaults = createAssigner(_.allKeys, true);
1607_.clone = function(obj) {
1608if (!_.isObject(obj))
1609return obj;
1610return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
1611}
1612;
1613_.tap = function(obj, interceptor) {
1614interceptor(obj);
1615return obj;
1616}
1617;
1618_.isMatch = function(object, attrs) {
1619var keys = _.keys(attrs)
1620  , length = keys.length;
1621if (object == null)
1622return !length;
1623var obj = Object(object);
1624for (var i = 0; i < length; i++) {
1625var key = keys[i];
1626if (attrs[key] !== obj[key] || !(key in obj))
1627return false;
1628}
1629return true;
1630}
1631;
1632var eq = function(a, b, aStack, bStack) {
1633if (a === b)
1634return a !== 0 || 1 / a === 1 / b;
1635if (a == null || b == null)
1636return a === b;
1637if (a instanceof _)
1638a = a._wrapped;
1639if (b instanceof _)
1640b = b._wrapped;
1641var className = toString.call(a);
1642if (className !== toString.call(b))
1643return false;
1644switch (className) {
1645case '[object RegExp]':
1646case '[object String]':
1647return '' + a === '' + b;
1648case '[object Number]':
1649if (+a !== +a)
1650return +b !== +b;
1651return +a === 0 ? 1 / +a === 1 / b : +a === +b;
1652case '[object Date]':
1653case '[object Boolean]':
1654return +a === +b;
1655}
1656var areArrays = className === '[object Array]';
1657if (!areArrays) {
1658if (typeof a != 'object' || typeof b != 'object')
1659return false;
1660var aCtor = a.constructor
1661  , bCtor = b.constructor;
1662if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor && _.isFunction(bCtor) && bCtor instanceof bCtor) && ('constructor'in a && 'constructor'in b)) {
1663return false;
1664}
1665}
1666aStack = aStack || [];
1667bStack = bStack || [];
1668var length = aStack.length;
1669while (length--) {
1670if (aStack[length] === a)
1671return bStack[length] === b;
1672}
1673aStack.push(a);
1674bStack.push(b);
1675if (areArrays) {
1676length = a.length;
1677if (length !== b.length)
1678return false;
1679while (length--) {
1680if (!eq(a[length], b[length], aStack, bStack))
1681return false;
1682}
1683} else {
1684var keys = _.keys(a), key;
1685length = keys.length;
1686if (_.keys(b).length !== length)
1687return false;
1688while (length--) {
1689key = keys[length];
1690if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack)))
1691return false;
1692}
1693}
1694aStack.pop();
1695bStack.pop();
1696return true;
1697};
1698_.isEqual = function(a, b) {
1699return eq(a, b);
1700}
1701;
1702_.isEmpty = function(obj) {
1703if (obj == null)
1704return true;
1705if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)))
1706return obj.length === 0;
1707return _.keys(obj).length === 0;
1708}
1709;
1710_.isElement = function(obj) {
1711return !!(obj && obj.nodeType === 1);
1712}
1713;
1714_.isArray = nativeIsArray || function(obj) {
1715return toString.call(obj) === '[object Array]';
1716}
1717;
1718_.isObject = function(obj) {
1719var type = typeof obj;
1720return type === 'function' || type === 'object' && !!obj;
1721}
1722;
1723_.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {
1724_['is' + name] = function(obj) {
1725return toString.call(obj) === '[object ' + name + ']';
1726}
1727;
1728});
1729if (!_.isArguments(arguments)) {
1730_.isArguments = function(obj) {
1731return _.has(obj, 'callee');
1732}
1733;
1734}
1735if (typeof /./ != 'function' && typeof Int8Array != 'object') {
1736_.isFunction = function(obj) {
1737return typeof obj == 'function' || false;
1738}
1739;
1740}
1741_.isFinite = function(obj) {
1742return isFinite(obj) && !isNaN(parseFloat(obj));
1743}
1744;
1745_.isNaN = function(obj) {
1746return _.isNumber(obj) && obj !== +obj;
1747}
1748;
1749_.isBoolean = function(obj) {
1750return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
1751}
1752;
1753_.isNull = function(obj) {
1754return obj === null;
1755}
1756;
1757_.isUndefined = function(obj) {
1758return obj === void 0;
1759}
1760;
1761_.has = function(obj, key) {
1762return obj != null && hasOwnProperty.call(obj, key);
1763}
1764;
1765_.noConflict = function() {
1766root._ = previousUnderscore;
1767return this;
1768}
1769;
1770_.identity = function(value) {
1771return value;
1772}
1773;
1774_.constant = function(value) {
1775return function() {
1776return value;
1777}
1778;
1779}
1780;
1781_.noop = function() {}
1782;
1783_.property = function(key) {
1784return function(obj) {
1785return obj == null ? void 0 : obj[key];
1786}
1787;
1788}
1789;
1790_.propertyOf = function(obj) {
1791return obj == null ? function() {}
1792: function(key) {
1793return obj[key];
1794}
1795;
1796}
1797;
1798_.matcher = _.matches = function(attrs) {
1799attrs = _.extendOwn({}, attrs);
1800return function(obj) {
1801return _.isMatch(obj, attrs);
1802}
1803;
1804}
1805;
1806_.times = function(n, iteratee, context) {
1807var accum = Array(Math.max(0, n));
1808iteratee = optimizeCb(iteratee, context, 1);
1809for (var i = 0; i < n; i++)
1810accum[i] = iteratee(i);
1811return accum;
1812}
1813;
1814_.random = function(min, max) {
1815if (max == null) {
1816max = min;
1817min = 0;
1818}
1819return min + Math.floor(Math.random() * (max - min + 1));
1820}
1821;
1822_.now = Date.now || function() {
1823return new Date().getTime();
1824}
1825;
1826var escapeMap = {
1827'&': '&amp;',
1828'<': '&lt;',
1829'>': '&gt;',
1830'"': '&quot;',
1831"'": '&#x27;',
1832'`': '&#x60;'
1833};
1834var unescapeMap = _.invert(escapeMap);
1835var createEscaper = function(map) {
1836var escaper = function(match) {
1837return map[match];
1838};
1839var source = '(?:' + _.keys(map).join('|') + ')';
1840var testRegexp = RegExp(source);
1841var replaceRegexp = RegExp(source, 'g');
1842return function(string) {
1843string = string == null ? '' : '' + string;
1844return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
1845}
1846;
1847};
1848_.escape = createEscaper(escapeMap);
1849_.unescape = createEscaper(unescapeMap);
1850_.result = function(object, property, fallback) {
1851var value = object == null ? void 0 : object[property];
1852if (value === void 0) {
1853value = fallback;
1854}
1855return _.isFunction(value) ? value.call(object) : value;
1856}
1857;
1858var idCounter = 0;
1859_.uniqueId = function(prefix) {
1860var id = ++idCounter + '';
1861return prefix ? prefix + id : id;
1862}
1863;
1864_.templateSettings = {
1865evaluate: /<%([\s\S]+?)%>/g,
1866interpolate: /<%=([\s\S]+?)%>/g,
1867escape: /<%-([\s\S]+?)%>/g
1868};
1869var noMatch = /(.)^/;
1870var escapes = {
1871"'": "'",
1872'\\': '\\',
1873'\r': 'r',
1874'\n': 'n',
1875'\u2028': 'u2028',
1876'\u2029': 'u2029'
1877};
1878var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
1879var escapeChar = function(match) {
1880return '\\' + escapes[match];
1881};
1882_.template = function(text, settings, oldSettings) {
1883if (!settings && oldSettings)
1884settings = oldSettings;
1885settings = _.defaults({}, settings, _.templateSettings);
1886var matcher = RegExp([(settings.escape || noMatch).source, (settings.interpolate || noMatch).source, (settings.evaluate || noMatch).source].join('|') + '|$', 'g');
1887var index = 0;
1888var source = "__p+='";
1889text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
1890source += text.slice(index, offset).replace(escaper, escapeChar);
1891index = offset + match.length;
1892if (escape) {
1893source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
1894} else if (interpolate) {
1895source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";