1 | (function (global, factory) {
|
2 | typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
3 | typeof define === 'function' && define.amd ? define('underscore', factory) :
|
4 | (function() {
|
5 | var current = global._;
|
6 | var exports = factory();
|
7 | global._ = exports;
|
8 | exports.noConflict = function() { global._ = current; return exports; };
|
9 | })();
|
10 | }(this, (function () {
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 | var root = typeof self == 'object' && self.self === self && self ||
|
24 | typeof global == 'object' && global.global === global && global ||
|
25 | Function('return this')() ||
|
26 | {};
|
27 |
|
28 |
|
29 | var ArrayProto = Array.prototype, ObjProto = Object.prototype;
|
30 | var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;
|
31 |
|
32 |
|
33 | var push = ArrayProto.push,
|
34 | slice = ArrayProto.slice,
|
35 | toString = ObjProto.toString,
|
36 | hasOwnProperty = ObjProto.hasOwnProperty;
|
37 |
|
38 |
|
39 |
|
40 | var nativeIsArray = Array.isArray,
|
41 | nativeKeys = Object.keys,
|
42 | nativeCreate = Object.create;
|
43 |
|
44 |
|
45 | var _isNaN = root.isNaN,
|
46 | _isFinite = root.isFinite;
|
47 |
|
48 |
|
49 | var Ctor = function(){};
|
50 |
|
51 |
|
52 |
|
53 | function _(obj) {
|
54 | if (obj instanceof _) return obj;
|
55 | if (!(this instanceof _)) return new _(obj);
|
56 | this._wrapped = obj;
|
57 | }
|
58 |
|
59 |
|
60 | var VERSION = _.VERSION = '1.10.2';
|
61 |
|
62 |
|
63 |
|
64 |
|
65 | function optimizeCb(func, context, argCount) {
|
66 | if (context === void 0) return func;
|
67 | switch (argCount == null ? 3 : argCount) {
|
68 | case 1: return function(value) {
|
69 | return func.call(context, value);
|
70 | };
|
71 |
|
72 | case 3: return function(value, index, collection) {
|
73 | return func.call(context, value, index, collection);
|
74 | };
|
75 | case 4: return function(accumulator, value, index, collection) {
|
76 | return func.call(context, accumulator, value, index, collection);
|
77 | };
|
78 | }
|
79 | return function() {
|
80 | return func.apply(context, arguments);
|
81 | };
|
82 | }
|
83 |
|
84 |
|
85 |
|
86 |
|
87 | function baseIteratee(value, context, argCount) {
|
88 | if (value == null) return identity;
|
89 | if (isFunction(value)) return optimizeCb(value, context, argCount);
|
90 | if (isObject(value) && !isArray(value)) return matcher(value);
|
91 | return property(value);
|
92 | }
|
93 |
|
94 |
|
95 |
|
96 |
|
97 | _.iteratee = iteratee;
|
98 | function iteratee(value, context) {
|
99 | return baseIteratee(value, context, Infinity);
|
100 | }
|
101 |
|
102 |
|
103 |
|
104 | function cb(value, context, argCount) {
|
105 | if (_.iteratee !== iteratee) return _.iteratee(value, context);
|
106 | return baseIteratee(value, context, argCount);
|
107 | }
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
|
113 |
|
114 | function restArguments(func, startIndex) {
|
115 | startIndex = startIndex == null ? func.length - 1 : +startIndex;
|
116 | return function() {
|
117 | var length = Math.max(arguments.length - startIndex, 0),
|
118 | rest = Array(length),
|
119 | index = 0;
|
120 | for (; index < length; index++) {
|
121 | rest[index] = arguments[index + startIndex];
|
122 | }
|
123 | switch (startIndex) {
|
124 | case 0: return func.call(this, rest);
|
125 | case 1: return func.call(this, arguments[0], rest);
|
126 | case 2: return func.call(this, arguments[0], arguments[1], rest);
|
127 | }
|
128 | var args = Array(startIndex + 1);
|
129 | for (index = 0; index < startIndex; index++) {
|
130 | args[index] = arguments[index];
|
131 | }
|
132 | args[startIndex] = rest;
|
133 | return func.apply(this, args);
|
134 | };
|
135 | }
|
136 |
|
137 |
|
138 | function baseCreate(prototype) {
|
139 | if (!isObject(prototype)) return {};
|
140 | if (nativeCreate) return nativeCreate(prototype);
|
141 | Ctor.prototype = prototype;
|
142 | var result = new Ctor;
|
143 | Ctor.prototype = null;
|
144 | return result;
|
145 | }
|
146 |
|
147 | function shallowProperty(key) {
|
148 | return function(obj) {
|
149 | return obj == null ? void 0 : obj[key];
|
150 | };
|
151 | }
|
152 |
|
153 | function _has(obj, path) {
|
154 | return obj != null && hasOwnProperty.call(obj, path);
|
155 | }
|
156 |
|
157 | function deepGet(obj, path) {
|
158 | var length = path.length;
|
159 | for (var i = 0; i < length; i++) {
|
160 | if (obj == null) return void 0;
|
161 | obj = obj[path[i]];
|
162 | }
|
163 | return length ? obj : void 0;
|
164 | }
|
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 | var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
|
171 | var getLength = shallowProperty('length');
|
172 | function isArrayLike(collection) {
|
173 | var length = getLength(collection);
|
174 | return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
|
175 | }
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 | function each(obj, iteratee, context) {
|
184 | iteratee = optimizeCb(iteratee, context);
|
185 | var i, length;
|
186 | if (isArrayLike(obj)) {
|
187 | for (i = 0, length = obj.length; i < length; i++) {
|
188 | iteratee(obj[i], i, obj);
|
189 | }
|
190 | } else {
|
191 | var _keys = keys(obj);
|
192 | for (i = 0, length = _keys.length; i < length; i++) {
|
193 | iteratee(obj[_keys[i]], _keys[i], obj);
|
194 | }
|
195 | }
|
196 | return obj;
|
197 | }
|
198 |
|
199 |
|
200 | function map(obj, iteratee, context) {
|
201 | iteratee = cb(iteratee, context);
|
202 | var _keys = !isArrayLike(obj) && keys(obj),
|
203 | length = (_keys || obj).length,
|
204 | results = Array(length);
|
205 | for (var index = 0; index < length; index++) {
|
206 | var currentKey = _keys ? _keys[index] : index;
|
207 | results[index] = iteratee(obj[currentKey], currentKey, obj);
|
208 | }
|
209 | return results;
|
210 | }
|
211 |
|
212 |
|
213 | function createReduce(dir) {
|
214 |
|
215 |
|
216 | var reducer = function(obj, iteratee, memo, initial) {
|
217 | var _keys = !isArrayLike(obj) && keys(obj),
|
218 | length = (_keys || obj).length,
|
219 | index = dir > 0 ? 0 : length - 1;
|
220 | if (!initial) {
|
221 | memo = obj[_keys ? _keys[index] : index];
|
222 | index += dir;
|
223 | }
|
224 | for (; index >= 0 && index < length; index += dir) {
|
225 | var currentKey = _keys ? _keys[index] : index;
|
226 | memo = iteratee(memo, obj[currentKey], currentKey, obj);
|
227 | }
|
228 | return memo;
|
229 | };
|
230 |
|
231 | return function(obj, iteratee, memo, context) {
|
232 | var initial = arguments.length >= 3;
|
233 | return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);
|
234 | };
|
235 | }
|
236 |
|
237 |
|
238 |
|
239 | var reduce = createReduce(1);
|
240 |
|
241 |
|
242 | var reduceRight = createReduce(-1);
|
243 |
|
244 |
|
245 | function find(obj, predicate, context) {
|
246 | var keyFinder = isArrayLike(obj) ? findIndex : findKey;
|
247 | var key = keyFinder(obj, predicate, context);
|
248 | if (key !== void 0 && key !== -1) return obj[key];
|
249 | }
|
250 |
|
251 |
|
252 | function filter(obj, predicate, context) {
|
253 | var results = [];
|
254 | predicate = cb(predicate, context);
|
255 | each(obj, function(value, index, list) {
|
256 | if (predicate(value, index, list)) results.push(value);
|
257 | });
|
258 | return results;
|
259 | }
|
260 |
|
261 |
|
262 | function reject(obj, predicate, context) {
|
263 | return filter(obj, negate(cb(predicate)), context);
|
264 | }
|
265 |
|
266 |
|
267 | function every(obj, predicate, context) {
|
268 | predicate = cb(predicate, context);
|
269 | var _keys = !isArrayLike(obj) && keys(obj),
|
270 | length = (_keys || obj).length;
|
271 | for (var index = 0; index < length; index++) {
|
272 | var currentKey = _keys ? _keys[index] : index;
|
273 | if (!predicate(obj[currentKey], currentKey, obj)) return false;
|
274 | }
|
275 | return true;
|
276 | }
|
277 |
|
278 |
|
279 | function some(obj, predicate, context) {
|
280 | predicate = cb(predicate, context);
|
281 | var _keys = !isArrayLike(obj) && keys(obj),
|
282 | length = (_keys || obj).length;
|
283 | for (var index = 0; index < length; index++) {
|
284 | var currentKey = _keys ? _keys[index] : index;
|
285 | if (predicate(obj[currentKey], currentKey, obj)) return true;
|
286 | }
|
287 | return false;
|
288 | }
|
289 |
|
290 |
|
291 | function contains(obj, item, fromIndex, guard) {
|
292 | if (!isArrayLike(obj)) obj = values(obj);
|
293 | if (typeof fromIndex != 'number' || guard) fromIndex = 0;
|
294 | return indexOf(obj, item, fromIndex) >= 0;
|
295 | }
|
296 |
|
297 |
|
298 | var invoke = restArguments(function(obj, path, args) {
|
299 | var contextPath, func;
|
300 | if (isFunction(path)) {
|
301 | func = path;
|
302 | } else if (isArray(path)) {
|
303 | contextPath = path.slice(0, -1);
|
304 | path = path[path.length - 1];
|
305 | }
|
306 | return map(obj, function(context) {
|
307 | var method = func;
|
308 | if (!method) {
|
309 | if (contextPath && contextPath.length) {
|
310 | context = deepGet(context, contextPath);
|
311 | }
|
312 | if (context == null) return void 0;
|
313 | method = context[path];
|
314 | }
|
315 | return method == null ? method : method.apply(context, args);
|
316 | });
|
317 | });
|
318 |
|
319 |
|
320 | function pluck(obj, key) {
|
321 | return map(obj, property(key));
|
322 | }
|
323 |
|
324 |
|
325 |
|
326 | function where(obj, attrs) {
|
327 | return filter(obj, matcher(attrs));
|
328 | }
|
329 |
|
330 |
|
331 |
|
332 | function findWhere(obj, attrs) {
|
333 | return find(obj, matcher(attrs));
|
334 | }
|
335 |
|
336 |
|
337 | function max(obj, iteratee, context) {
|
338 | var result = -Infinity, lastComputed = -Infinity,
|
339 | value, computed;
|
340 | if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {
|
341 | obj = isArrayLike(obj) ? obj : values(obj);
|
342 | for (var i = 0, length = obj.length; i < length; i++) {
|
343 | value = obj[i];
|
344 | if (value != null && value > result) {
|
345 | result = value;
|
346 | }
|
347 | }
|
348 | } else {
|
349 | iteratee = cb(iteratee, context);
|
350 | each(obj, function(v, index, list) {
|
351 | computed = iteratee(v, index, list);
|
352 | if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
|
353 | result = v;
|
354 | lastComputed = computed;
|
355 | }
|
356 | });
|
357 | }
|
358 | return result;
|
359 | }
|
360 |
|
361 |
|
362 | function min(obj, iteratee, context) {
|
363 | var result = Infinity, lastComputed = Infinity,
|
364 | value, computed;
|
365 | if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {
|
366 | obj = isArrayLike(obj) ? obj : values(obj);
|
367 | for (var i = 0, length = obj.length; i < length; i++) {
|
368 | value = obj[i];
|
369 | if (value != null && value < result) {
|
370 | result = value;
|
371 | }
|
372 | }
|
373 | } else {
|
374 | iteratee = cb(iteratee, context);
|
375 | each(obj, function(v, index, list) {
|
376 | computed = iteratee(v, index, list);
|
377 | if (computed < lastComputed || computed === Infinity && result === Infinity) {
|
378 | result = v;
|
379 | lastComputed = computed;
|
380 | }
|
381 | });
|
382 | }
|
383 | return result;
|
384 | }
|
385 |
|
386 |
|
387 | function shuffle(obj) {
|
388 | return sample(obj, Infinity);
|
389 | }
|
390 |
|
391 |
|
392 |
|
393 |
|
394 |
|
395 | function sample(obj, n, guard) {
|
396 | if (n == null || guard) {
|
397 | if (!isArrayLike(obj)) obj = values(obj);
|
398 | return obj[random(obj.length - 1)];
|
399 | }
|
400 | var sample = isArrayLike(obj) ? clone(obj) : values(obj);
|
401 | var length = getLength(sample);
|
402 | n = Math.max(Math.min(n, length), 0);
|
403 | var last = length - 1;
|
404 | for (var index = 0; index < n; index++) {
|
405 | var rand = random(index, last);
|
406 | var temp = sample[index];
|
407 | sample[index] = sample[rand];
|
408 | sample[rand] = temp;
|
409 | }
|
410 | return sample.slice(0, n);
|
411 | }
|
412 |
|
413 |
|
414 | function sortBy(obj, iteratee, context) {
|
415 | var index = 0;
|
416 | iteratee = cb(iteratee, context);
|
417 | return pluck(map(obj, function(value, key, list) {
|
418 | return {
|
419 | value: value,
|
420 | index: index++,
|
421 | criteria: iteratee(value, key, list)
|
422 | };
|
423 | }).sort(function(left, right) {
|
424 | var a = left.criteria;
|
425 | var b = right.criteria;
|
426 | if (a !== b) {
|
427 | if (a > b || a === void 0) return 1;
|
428 | if (a < b || b === void 0) return -1;
|
429 | }
|
430 | return left.index - right.index;
|
431 | }), 'value');
|
432 | }
|
433 |
|
434 |
|
435 | function group(behavior, partition) {
|
436 | return function(obj, iteratee, context) {
|
437 | var result = partition ? [[], []] : {};
|
438 | iteratee = cb(iteratee, context);
|
439 | each(obj, function(value, index) {
|
440 | var key = iteratee(value, index, obj);
|
441 | behavior(result, value, key);
|
442 | });
|
443 | return result;
|
444 | };
|
445 | }
|
446 |
|
447 |
|
448 |
|
449 | var groupBy = group(function(result, value, key) {
|
450 | if (_has(result, key)) result[key].push(value); else result[key] = [value];
|
451 | });
|
452 |
|
453 |
|
454 |
|
455 | var indexBy = group(function(result, value, key) {
|
456 | result[key] = value;
|
457 | });
|
458 |
|
459 |
|
460 |
|
461 |
|
462 | var countBy = group(function(result, value, key) {
|
463 | if (_has(result, key)) result[key]++; else result[key] = 1;
|
464 | });
|
465 |
|
466 | var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
|
467 |
|
468 | function toArray(obj) {
|
469 | if (!obj) return [];
|
470 | if (isArray(obj)) return slice.call(obj);
|
471 | if (isString(obj)) {
|
472 |
|
473 | return obj.match(reStrSymbol);
|
474 | }
|
475 | if (isArrayLike(obj)) return map(obj, identity);
|
476 | return values(obj);
|
477 | }
|
478 |
|
479 |
|
480 | function size(obj) {
|
481 | if (obj == null) return 0;
|
482 | return isArrayLike(obj) ? obj.length : keys(obj).length;
|
483 | }
|
484 |
|
485 |
|
486 |
|
487 | var partition = group(function(result, value, pass) {
|
488 | result[pass ? 0 : 1].push(value);
|
489 | }, true);
|
490 |
|
491 |
|
492 |
|
493 |
|
494 |
|
495 |
|
496 | function first(array, n, guard) {
|
497 | if (array == null || array.length < 1) return n == null ? void 0 : [];
|
498 | if (n == null || guard) return array[0];
|
499 | return initial(array, array.length - n);
|
500 | }
|
501 |
|
502 |
|
503 |
|
504 |
|
505 | function initial(array, n, guard) {
|
506 | return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
|
507 | }
|
508 |
|
509 |
|
510 |
|
511 | function last(array, n, guard) {
|
512 | if (array == null || array.length < 1) return n == null ? void 0 : [];
|
513 | if (n == null || guard) return array[array.length - 1];
|
514 | return rest(array, Math.max(0, array.length - n));
|
515 | }
|
516 |
|
517 |
|
518 |
|
519 |
|
520 | function rest(array, n, guard) {
|
521 | return slice.call(array, n == null || guard ? 1 : n);
|
522 | }
|
523 |
|
524 |
|
525 | function compact(array) {
|
526 | return filter(array, Boolean);
|
527 | }
|
528 |
|
529 |
|
530 | function _flatten(input, shallow, strict, output) {
|
531 | output = output || [];
|
532 | var idx = output.length;
|
533 | for (var i = 0, length = getLength(input); i < length; i++) {
|
534 | var value = input[i];
|
535 | if (isArrayLike(value) && (isArray(value) || isArguments(value))) {
|
536 |
|
537 | if (shallow) {
|
538 | var j = 0, len = value.length;
|
539 | while (j < len) output[idx++] = value[j++];
|
540 | } else {
|
541 | _flatten(value, shallow, strict, output);
|
542 | idx = output.length;
|
543 | }
|
544 | } else if (!strict) {
|
545 | output[idx++] = value;
|
546 | }
|
547 | }
|
548 | return output;
|
549 | }
|
550 |
|
551 |
|
552 | function flatten(array, shallow) {
|
553 | return _flatten(array, shallow, false);
|
554 | }
|
555 |
|
556 |
|
557 | var without = restArguments(function(array, otherArrays) {
|
558 | return difference(array, otherArrays);
|
559 | });
|
560 |
|
561 |
|
562 |
|
563 |
|
564 |
|
565 |
|
566 | function uniq(array, isSorted, iteratee, context) {
|
567 | if (!isBoolean(isSorted)) {
|
568 | context = iteratee;
|
569 | iteratee = isSorted;
|
570 | isSorted = false;
|
571 | }
|
572 | if (iteratee != null) iteratee = cb(iteratee, context);
|
573 | var result = [];
|
574 | var seen = [];
|
575 | for (var i = 0, length = getLength(array); i < length; i++) {
|
576 | var value = array[i],
|
577 | computed = iteratee ? iteratee(value, i, array) : value;
|
578 | if (isSorted && !iteratee) {
|
579 | if (!i || seen !== computed) result.push(value);
|
580 | seen = computed;
|
581 | } else if (iteratee) {
|
582 | if (!contains(seen, computed)) {
|
583 | seen.push(computed);
|
584 | result.push(value);
|
585 | }
|
586 | } else if (!contains(result, value)) {
|
587 | result.push(value);
|
588 | }
|
589 | }
|
590 | return result;
|
591 | }
|
592 |
|
593 |
|
594 |
|
595 | var union = restArguments(function(arrays) {
|
596 | return uniq(_flatten(arrays, true, true));
|
597 | });
|
598 |
|
599 |
|
600 |
|
601 | function intersection(array) {
|
602 | var result = [];
|
603 | var argsLength = arguments.length;
|
604 | for (var i = 0, length = getLength(array); i < length; i++) {
|
605 | var item = array[i];
|
606 | if (contains(result, item)) continue;
|
607 | var j;
|
608 | for (j = 1; j < argsLength; j++) {
|
609 | if (!contains(arguments[j], item)) break;
|
610 | }
|
611 | if (j === argsLength) result.push(item);
|
612 | }
|
613 | return result;
|
614 | }
|
615 |
|
616 |
|
617 |
|
618 | var difference = restArguments(function(array, rest) {
|
619 | rest = _flatten(rest, true, true);
|
620 | return filter(array, function(value){
|
621 | return !contains(rest, value);
|
622 | });
|
623 | });
|
624 |
|
625 |
|
626 |
|
627 | function unzip(array) {
|
628 | var length = array && max(array, getLength).length || 0;
|
629 | var result = Array(length);
|
630 |
|
631 | for (var index = 0; index < length; index++) {
|
632 | result[index] = pluck(array, index);
|
633 | }
|
634 | return result;
|
635 | }
|
636 |
|
637 |
|
638 |
|
639 | var zip = restArguments(unzip);
|
640 |
|
641 |
|
642 |
|
643 |
|
644 | function object(list, values) {
|
645 | var result = {};
|
646 | for (var i = 0, length = getLength(list); i < length; i++) {
|
647 | if (values) {
|
648 | result[list[i]] = values[i];
|
649 | } else {
|
650 | result[list[i][0]] = list[i][1];
|
651 | }
|
652 | }
|
653 | return result;
|
654 | }
|
655 |
|
656 |
|
657 | function createPredicateIndexFinder(dir) {
|
658 | return function(array, predicate, context) {
|
659 | predicate = cb(predicate, context);
|
660 | var length = getLength(array);
|
661 | var index = dir > 0 ? 0 : length - 1;
|
662 | for (; index >= 0 && index < length; index += dir) {
|
663 | if (predicate(array[index], index, array)) return index;
|
664 | }
|
665 | return -1;
|
666 | };
|
667 | }
|
668 |
|
669 |
|
670 | var findIndex = createPredicateIndexFinder(1);
|
671 | var findLastIndex = createPredicateIndexFinder(-1);
|
672 |
|
673 |
|
674 |
|
675 | function sortedIndex(array, obj, iteratee, context) {
|
676 | iteratee = cb(iteratee, context, 1);
|
677 | var value = iteratee(obj);
|
678 | var low = 0, high = getLength(array);
|
679 | while (low < high) {
|
680 | var mid = Math.floor((low + high) / 2);
|
681 | if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
|
682 | }
|
683 | return low;
|
684 | }
|
685 |
|
686 |
|
687 | function createIndexFinder(dir, predicateFind, sortedIndex) {
|
688 | return function(array, item, idx) {
|
689 | var i = 0, length = getLength(array);
|
690 | if (typeof idx == 'number') {
|
691 | if (dir > 0) {
|
692 | i = idx >= 0 ? idx : Math.max(idx + length, i);
|
693 | } else {
|
694 | length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
|
695 | }
|
696 | } else if (sortedIndex && idx && length) {
|
697 | idx = sortedIndex(array, item);
|
698 | return array[idx] === item ? idx : -1;
|
699 | }
|
700 | if (item !== item) {
|
701 | idx = predicateFind(slice.call(array, i, length), isNaN);
|
702 | return idx >= 0 ? idx + i : -1;
|
703 | }
|
704 | for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
|
705 | if (array[idx] === item) return idx;
|
706 | }
|
707 | return -1;
|
708 | };
|
709 | }
|
710 |
|
711 |
|
712 |
|
713 |
|
714 |
|
715 | var indexOf = createIndexFinder(1, findIndex, sortedIndex);
|
716 | var lastIndexOf = createIndexFinder(-1, findLastIndex);
|
717 |
|
718 |
|
719 |
|
720 |
|
721 | function range(start, stop, step) {
|
722 | if (stop == null) {
|
723 | stop = start || 0;
|
724 | start = 0;
|
725 | }
|
726 | if (!step) {
|
727 | step = stop < start ? -1 : 1;
|
728 | }
|
729 |
|
730 | var length = Math.max(Math.ceil((stop - start) / step), 0);
|
731 | var range = Array(length);
|
732 |
|
733 | for (var idx = 0; idx < length; idx++, start += step) {
|
734 | range[idx] = start;
|
735 | }
|
736 |
|
737 | return range;
|
738 | }
|
739 |
|
740 |
|
741 |
|
742 | function chunk(array, count) {
|
743 | if (count == null || count < 1) return [];
|
744 | var result = [];
|
745 | var i = 0, length = array.length;
|
746 | while (i < length) {
|
747 | result.push(slice.call(array, i, i += count));
|
748 | }
|
749 | return result;
|
750 | }
|
751 |
|
752 |
|
753 |
|
754 |
|
755 |
|
756 |
|
757 | function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
|
758 | if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
|
759 | var self = baseCreate(sourceFunc.prototype);
|
760 | var result = sourceFunc.apply(self, args);
|
761 | if (isObject(result)) return result;
|
762 | return self;
|
763 | }
|
764 |
|
765 |
|
766 |
|
767 |
|
768 | var bind = restArguments(function(func, context, args) {
|
769 | if (!isFunction(func)) throw new TypeError('Bind must be called on a function');
|
770 | var bound = restArguments(function(callArgs) {
|
771 | return executeBound(func, bound, context, this, args.concat(callArgs));
|
772 | });
|
773 | return bound;
|
774 | });
|
775 |
|
776 |
|
777 |
|
778 |
|
779 |
|
780 | var partial = restArguments(function(func, boundArgs) {
|
781 | var placeholder = partial.placeholder;
|
782 | var bound = function() {
|
783 | var position = 0, length = boundArgs.length;
|
784 | var args = Array(length);
|
785 | for (var i = 0; i < length; i++) {
|
786 | args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
|
787 | }
|
788 | while (position < arguments.length) args.push(arguments[position++]);
|
789 | return executeBound(func, bound, this, this, args);
|
790 | };
|
791 | return bound;
|
792 | });
|
793 |
|
794 | partial.placeholder = _;
|
795 |
|
796 |
|
797 |
|
798 |
|
799 | var bindAll = restArguments(function(obj, _keys) {
|
800 | _keys = _flatten(_keys, false, false);
|
801 | var index = _keys.length;
|
802 | if (index < 1) throw new Error('bindAll must be passed function names');
|
803 | while (index--) {
|
804 | var key = _keys[index];
|
805 | obj[key] = bind(obj[key], obj);
|
806 | }
|
807 | });
|
808 |
|
809 |
|
810 | function memoize(func, hasher) {
|
811 | var memoize = function(key) {
|
812 | var cache = memoize.cache;
|
813 | var address = '' + (hasher ? hasher.apply(this, arguments) : key);
|
814 | if (!_has(cache, address)) cache[address] = func.apply(this, arguments);
|
815 | return cache[address];
|
816 | };
|
817 | memoize.cache = {};
|
818 | return memoize;
|
819 | }
|
820 |
|
821 |
|
822 |
|
823 | var delay = restArguments(function(func, wait, args) {
|
824 | return setTimeout(function() {
|
825 | return func.apply(null, args);
|
826 | }, wait);
|
827 | });
|
828 |
|
829 |
|
830 |
|
831 | var defer = partial(delay, _, 1);
|
832 |
|
833 |
|
834 |
|
835 |
|
836 |
|
837 |
|
838 | function throttle(func, wait, options) {
|
839 | var timeout, context, args, result;
|
840 | var previous = 0;
|
841 | if (!options) options = {};
|
842 |
|
843 | var later = function() {
|
844 | previous = options.leading === false ? 0 : now();
|
845 | timeout = null;
|
846 | result = func.apply(context, args);
|
847 | if (!timeout) context = args = null;
|
848 | };
|
849 |
|
850 | var throttled = function() {
|
851 | var _now = now();
|
852 | if (!previous && options.leading === false) previous = _now;
|
853 | var remaining = wait - (_now - previous);
|
854 | context = this;
|
855 | args = arguments;
|
856 | if (remaining <= 0 || remaining > wait) {
|
857 | if (timeout) {
|
858 | clearTimeout(timeout);
|
859 | timeout = null;
|
860 | }
|
861 | previous = _now;
|
862 | result = func.apply(context, args);
|
863 | if (!timeout) context = args = null;
|
864 | } else if (!timeout && options.trailing !== false) {
|
865 | timeout = setTimeout(later, remaining);
|
866 | }
|
867 | return result;
|
868 | };
|
869 |
|
870 | throttled.cancel = function() {
|
871 | clearTimeout(timeout);
|
872 | previous = 0;
|
873 | timeout = context = args = null;
|
874 | };
|
875 |
|
876 | return throttled;
|
877 | }
|
878 |
|
879 |
|
880 |
|
881 |
|
882 |
|
883 | function debounce(func, wait, immediate) {
|
884 | var timeout, result;
|
885 |
|
886 | var later = function(context, args) {
|
887 | timeout = null;
|
888 | if (args) result = func.apply(context, args);
|
889 | };
|
890 |
|
891 | var debounced = restArguments(function(args) {
|
892 | if (timeout) clearTimeout(timeout);
|
893 | if (immediate) {
|
894 | var callNow = !timeout;
|
895 | timeout = setTimeout(later, wait);
|
896 | if (callNow) result = func.apply(this, args);
|
897 | } else {
|
898 | timeout = delay(later, wait, this, args);
|
899 | }
|
900 |
|
901 | return result;
|
902 | });
|
903 |
|
904 | debounced.cancel = function() {
|
905 | clearTimeout(timeout);
|
906 | timeout = null;
|
907 | };
|
908 |
|
909 | return debounced;
|
910 | }
|
911 |
|
912 |
|
913 |
|
914 |
|
915 | function wrap(func, wrapper) {
|
916 | return partial(wrapper, func);
|
917 | }
|
918 |
|
919 |
|
920 | function negate(predicate) {
|
921 | return function() {
|
922 | return !predicate.apply(this, arguments);
|
923 | };
|
924 | }
|
925 |
|
926 |
|
927 |
|
928 | function compose() {
|
929 | var args = arguments;
|
930 | var start = args.length - 1;
|
931 | return function() {
|
932 | var i = start;
|
933 | var result = args[start].apply(this, arguments);
|
934 | while (i--) result = args[i].call(this, result);
|
935 | return result;
|
936 | };
|
937 | }
|
938 |
|
939 |
|
940 | function after(times, func) {
|
941 | return function() {
|
942 | if (--times < 1) {
|
943 | return func.apply(this, arguments);
|
944 | }
|
945 | };
|
946 | }
|
947 |
|
948 |
|
949 | function before(times, func) {
|
950 | var memo;
|
951 | return function() {
|
952 | if (--times > 0) {
|
953 | memo = func.apply(this, arguments);
|
954 | }
|
955 | if (times <= 1) func = null;
|
956 | return memo;
|
957 | };
|
958 | }
|
959 |
|
960 |
|
961 |
|
962 | var once = partial(before, 2);
|
963 |
|
964 |
|
965 |
|
966 |
|
967 |
|
968 | var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
|
969 | var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
|
970 | 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
|
971 |
|
972 | function collectNonEnumProps(obj, _keys) {
|
973 | var nonEnumIdx = nonEnumerableProps.length;
|
974 | var constructor = obj.constructor;
|
975 | var proto = isFunction(constructor) && constructor.prototype || ObjProto;
|
976 |
|
977 | // Constructor is a special case.
|
978 | var prop = 'constructor';
|
979 | if (_has(obj, prop) && !contains(_keys, prop)) _keys.push(prop);
|
980 |
|
981 | while (nonEnumIdx--) {
|
982 | prop = nonEnumerableProps[nonEnumIdx];
|
983 | if (prop in obj && obj[prop] !== proto[prop] && !contains(_keys, prop)) {
|
984 | _keys.push(prop);
|
985 | }
|
986 | }
|
987 | }
|
988 |
|
989 |
|
990 |
|
991 | function keys(obj) {
|
992 | if (!isObject(obj)) return [];
|
993 | if (nativeKeys) return nativeKeys(obj);
|
994 | var _keys = [];
|
995 | for (var key in obj) if (_has(obj, key)) _keys.push(key);
|
996 |
|
997 | if (hasEnumBug) collectNonEnumProps(obj, _keys);
|
998 | return _keys;
|
999 | }
|
1000 |
|
1001 |
|
1002 | function allKeys(obj) {
|
1003 | if (!isObject(obj)) return [];
|
1004 | var _keys = [];
|
1005 | for (var key in obj) _keys.push(key);
|
1006 |
|
1007 | if (hasEnumBug) collectNonEnumProps(obj, _keys);
|
1008 | return _keys;
|
1009 | }
|
1010 |
|
1011 |
|
1012 | function values(obj) {
|
1013 | var _keys = keys(obj);
|
1014 | var length = _keys.length;
|
1015 | var values = Array(length);
|
1016 | for (var i = 0; i < length; i++) {
|
1017 | values[i] = obj[_keys[i]];
|
1018 | }
|
1019 | return values;
|
1020 | }
|
1021 |
|
1022 |
|
1023 |
|
1024 | function mapObject(obj, iteratee, context) {
|
1025 | iteratee = cb(iteratee, context);
|
1026 | var _keys = keys(obj),
|
1027 | length = _keys.length,
|
1028 | results = {};
|
1029 | for (var index = 0; index < length; index++) {
|
1030 | var currentKey = _keys[index];
|
1031 | results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
|
1032 | }
|
1033 | return results;
|
1034 | }
|
1035 |
|
1036 |
|
1037 |
|
1038 | function pairs(obj) {
|
1039 | var _keys = keys(obj);
|
1040 | var length = _keys.length;
|
1041 | var pairs = Array(length);
|
1042 | for (var i = 0; i < length; i++) {
|
1043 | pairs[i] = [_keys[i], obj[_keys[i]]];
|
1044 | }
|
1045 | return pairs;
|
1046 | }
|
1047 |
|
1048 |
|
1049 | function invert(obj) {
|
1050 | var result = {};
|
1051 | var _keys = keys(obj);
|
1052 | for (var i = 0, length = _keys.length; i < length; i++) {
|
1053 | result[obj[_keys[i]]] = _keys[i];
|
1054 | }
|
1055 | return result;
|
1056 | }
|
1057 |
|
1058 |
|
1059 | function functions(obj) {
|
1060 | var names = [];
|
1061 | for (var key in obj) {
|
1062 | if (isFunction(obj[key])) names.push(key);
|
1063 | }
|
1064 | return names.sort();
|
1065 | }
|
1066 |
|
1067 |
|
1068 | function createAssigner(keysFunc, defaults) {
|
1069 | return function(obj) {
|
1070 | var length = arguments.length;
|
1071 | if (defaults) obj = Object(obj);
|
1072 | if (length < 2 || obj == null) return obj;
|
1073 | for (var index = 1; index < length; index++) {
|
1074 | var source = arguments[index],
|
1075 | _keys = keysFunc(source),
|
1076 | l = _keys.length;
|
1077 | for (var i = 0; i < l; i++) {
|
1078 | var key = _keys[i];
|
1079 | if (!defaults || obj[key] === void 0) obj[key] = source[key];
|
1080 | }
|
1081 | }
|
1082 | return obj;
|
1083 | };
|
1084 | }
|
1085 |
|
1086 |
|
1087 | var extend = createAssigner(allKeys);
|
1088 |
|
1089 |
|
1090 |
|
1091 | var extendOwn = createAssigner(keys);
|
1092 |
|
1093 |
|
1094 | function findKey(obj, predicate, context) {
|
1095 | predicate = cb(predicate, context);
|
1096 | var _keys = keys(obj), key;
|
1097 | for (var i = 0, length = _keys.length; i < length; i++) {
|
1098 | key = _keys[i];
|
1099 | if (predicate(obj[key], key, obj)) return key;
|
1100 | }
|
1101 | }
|
1102 |
|
1103 |
|
1104 | function keyInObj(value, key, obj) {
|
1105 | return key in obj;
|
1106 | }
|
1107 |
|
1108 |
|
1109 | var pick = restArguments(function(obj, _keys) {
|
1110 | var result = {}, iteratee = _keys[0];
|
1111 | if (obj == null) return result;
|
1112 | if (isFunction(iteratee)) {
|
1113 | if (_keys.length > 1) iteratee = optimizeCb(iteratee, _keys[1]);
|
1114 | _keys = allKeys(obj);
|
1115 | } else {
|
1116 | iteratee = keyInObj;
|
1117 | _keys = _flatten(_keys, false, false);
|
1118 | obj = Object(obj);
|
1119 | }
|
1120 | for (var i = 0, length = _keys.length; i < length; i++) {
|
1121 | var key = _keys[i];
|
1122 | var value = obj[key];
|
1123 | if (iteratee(value, key, obj)) result[key] = value;
|
1124 | }
|
1125 | return result;
|
1126 | });
|
1127 |
|
1128 |
|
1129 | var omit = restArguments(function(obj, _keys) {
|
1130 | var iteratee = _keys[0], context;
|
1131 | if (isFunction(iteratee)) {
|
1132 | iteratee = negate(iteratee);
|
1133 | if (_keys.length > 1) context = _keys[1];
|
1134 | } else {
|
1135 | _keys = map(_flatten(_keys, false, false), String);
|
1136 | iteratee = function(value, key) {
|
1137 | return !contains(_keys, key);
|
1138 | };
|
1139 | }
|
1140 | return pick(obj, iteratee, context);
|
1141 | });
|
1142 |
|
1143 |
|
1144 | var defaults = createAssigner(allKeys, true);
|
1145 |
|
1146 |
|
1147 |
|
1148 |
|
1149 | function create(prototype, props) {
|
1150 | var result = baseCreate(prototype);
|
1151 | if (props) extendOwn(result, props);
|
1152 | return result;
|
1153 | }
|
1154 |
|
1155 |
|
1156 | function clone(obj) {
|
1157 | if (!isObject(obj)) return obj;
|
1158 | return isArray(obj) ? obj.slice() : extend({}, obj);
|
1159 | }
|
1160 |
|
1161 |
|
1162 |
|
1163 |
|
1164 | function tap(obj, interceptor) {
|
1165 | interceptor(obj);
|
1166 | return obj;
|
1167 | }
|
1168 |
|
1169 |
|
1170 | function isMatch(object, attrs) {
|
1171 | var _keys = keys(attrs), length = _keys.length;
|
1172 | if (object == null) return !length;
|
1173 | var obj = Object(object);
|
1174 | for (var i = 0; i < length; i++) {
|
1175 | var key = _keys[i];
|
1176 | if (attrs[key] !== obj[key] || !(key in obj)) return false;
|
1177 | }
|
1178 | return true;
|
1179 | }
|
1180 |
|
1181 |
|
1182 |
|
1183 | function eq(a, b, aStack, bStack) {
|
1184 |
|
1185 |
|
1186 | if (a === b) return a !== 0 || 1 / a === 1 / b;
|
1187 |
|
1188 | if (a == null || b == null) return false;
|
1189 |
|
1190 | if (a !== a) return b !== b;
|
1191 |
|
1192 | var type = typeof a;
|
1193 | if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
|
1194 | return deepEq(a, b, aStack, bStack);
|
1195 | }
|
1196 |
|
1197 |
|
1198 | function deepEq(a, b, aStack, bStack) {
|
1199 |
|
1200 | if (a instanceof _) a = a._wrapped;
|
1201 | if (b instanceof _) b = b._wrapped;
|
1202 |
|
1203 | var className = toString.call(a);
|
1204 | if (className !== toString.call(b)) return false;
|
1205 | switch (className) {
|
1206 |
|
1207 | case '[object RegExp]':
|
1208 |
|
1209 | case '[object String]':
|
1210 |
|
1211 |
|
1212 | return '' + a === '' + b;
|
1213 | case '[object Number]':
|
1214 |
|
1215 |
|
1216 | if (+a !== +a) return +b !== +b;
|
1217 |
|
1218 | return +a === 0 ? 1 / +a === 1 / b : +a === +b;
|
1219 | case '[object Date]':
|
1220 | case '[object Boolean]':
|
1221 |
|
1222 |
|
1223 |
|
1224 | return +a === +b;
|
1225 | case '[object Symbol]':
|
1226 | return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
|
1227 | }
|
1228 |
|
1229 | var areArrays = className === '[object Array]';
|
1230 | if (!areArrays) {
|
1231 | if (typeof a != 'object' || typeof b != 'object') return false;
|
1232 |
|
1233 |
|
1234 |
|
1235 | var aCtor = a.constructor, bCtor = b.constructor;
|
1236 | if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&
|
1237 | isFunction(bCtor) && bCtor instanceof bCtor)
|
1238 | && ('constructor' in a && 'constructor' in b)) {
|
1239 | return false;
|
1240 | }
|
1241 | }
|
1242 |
|
1243 |
|
1244 |
|
1245 |
|
1246 |
|
1247 | aStack = aStack || [];
|
1248 | bStack = bStack || [];
|
1249 | var length = aStack.length;
|
1250 | while (length--) {
|
1251 |
|
1252 |
|
1253 | if (aStack[length] === a) return bStack[length] === b;
|
1254 | }
|
1255 |
|
1256 |
|
1257 | aStack.push(a);
|
1258 | bStack.push(b);
|
1259 |
|
1260 |
|
1261 | if (areArrays) {
|
1262 |
|
1263 | length = a.length;
|
1264 | if (length !== b.length) return false;
|
1265 |
|
1266 | while (length--) {
|
1267 | if (!eq(a[length], b[length], aStack, bStack)) return false;
|
1268 | }
|
1269 | } else {
|
1270 |
|
1271 | var _keys = keys(a), key;
|
1272 | length = _keys.length;
|
1273 |
|
1274 | if (keys(b).length !== length) return false;
|
1275 | while (length--) {
|
1276 |
|
1277 | key = _keys[length];
|
1278 | if (!(_has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
|
1279 | }
|
1280 | }
|
1281 |
|
1282 | aStack.pop();
|
1283 | bStack.pop();
|
1284 | return true;
|
1285 | }
|
1286 |
|
1287 |
|
1288 | function isEqual(a, b) {
|
1289 | return eq(a, b);
|
1290 | }
|
1291 |
|
1292 |
|
1293 |
|
1294 | function isEmpty(obj) {
|
1295 | if (obj == null) return true;
|
1296 | if (isArrayLike(obj) && (isArray(obj) || isString(obj) || isArguments(obj))) return obj.length === 0;
|
1297 | return keys(obj).length === 0;
|
1298 | }
|
1299 |
|
1300 |
|
1301 | function isElement(obj) {
|
1302 | return !!(obj && obj.nodeType === 1);
|
1303 | }
|
1304 |
|
1305 |
|
1306 | function tagTester(name) {
|
1307 | return function(obj) {
|
1308 | return toString.call(obj) === '[object ' + name + ']';
|
1309 | };
|
1310 | }
|
1311 |
|
1312 |
|
1313 |
|
1314 | var isArray = nativeIsArray || tagTester('Array');
|
1315 |
|
1316 |
|
1317 | function isObject(obj) {
|
1318 | var type = typeof obj;
|
1319 | return type === 'function' || type === 'object' && !!obj;
|
1320 | }
|
1321 |
|
1322 |
|
1323 | var isArguments = tagTester('Arguments');
|
1324 | var isFunction = tagTester('Function');
|
1325 | var isString = tagTester('String');
|
1326 | var isNumber = tagTester('Number');
|
1327 | var isDate = tagTester('Date');
|
1328 | var isRegExp = tagTester('RegExp');
|
1329 | var isError = tagTester('Error');
|
1330 | var isSymbol = tagTester('Symbol');
|
1331 | var isMap = tagTester('Map');
|
1332 | var isWeakMap = tagTester('WeakMap');
|
1333 | var isSet = tagTester('Set');
|
1334 | var isWeakSet = tagTester('WeakSet');
|
1335 |
|
1336 |
|
1337 |
|
1338 | (function() {
|
1339 | if (!isArguments(arguments)) {
|
1340 | isArguments = function(obj) {
|
1341 | return _has(obj, 'callee');
|
1342 | };
|
1343 | }
|
1344 | }());
|
1345 |
|
1346 |
|
1347 |
|
1348 | var nodelist = root.document && root.document.childNodes;
|
1349 | if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {
|
1350 | isFunction = function(obj) {
|
1351 | return typeof obj == 'function' || false;
|
1352 | };
|
1353 | }
|
1354 |
|
1355 |
|
1356 | function isFinite(obj) {
|
1357 | return !isSymbol(obj) && _isFinite(obj) && !_isNaN(parseFloat(obj));
|
1358 | }
|
1359 |
|
1360 |
|
1361 | function isNaN(obj) {
|
1362 | return isNumber(obj) && _isNaN(obj);
|
1363 | }
|
1364 |
|
1365 |
|
1366 | function isBoolean(obj) {
|
1367 | return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
|
1368 | }
|
1369 |
|
1370 |
|
1371 | function isNull(obj) {
|
1372 | return obj === null;
|
1373 | }
|
1374 |
|
1375 |
|
1376 | function isUndefined(obj) {
|
1377 | return obj === void 0;
|
1378 | }
|
1379 |
|
1380 |
|
1381 |
|
1382 | function has(obj, path) {
|
1383 | if (!isArray(path)) {
|
1384 | return _has(obj, path);
|
1385 | }
|
1386 | var length = path.length;
|
1387 | for (var i = 0; i < length; i++) {
|
1388 | var key = path[i];
|
1389 | if (obj == null || !hasOwnProperty.call(obj, key)) {
|
1390 | return false;
|
1391 | }
|
1392 | obj = obj[key];
|
1393 | }
|
1394 | return !!length;
|
1395 | }
|
1396 |
|
1397 |
|
1398 |
|
1399 |
|
1400 |
|
1401 | function identity(value) {
|
1402 | return value;
|
1403 | }
|
1404 |
|
1405 |
|
1406 | function constant(value) {
|
1407 | return function() {
|
1408 | return value;
|
1409 | };
|
1410 | }
|
1411 |
|
1412 | function noop(){}
|
1413 |
|
1414 |
|
1415 |
|
1416 | function property(path) {
|
1417 | if (!isArray(path)) {
|
1418 | return shallowProperty(path);
|
1419 | }
|
1420 | return function(obj) {
|
1421 | return deepGet(obj, path);
|
1422 | };
|
1423 | }
|
1424 |
|
1425 |
|
1426 | function propertyOf(obj) {
|
1427 | if (obj == null) {
|
1428 | return function(){};
|
1429 | }
|
1430 | return function(path) {
|
1431 | return !isArray(path) ? obj[path] : deepGet(obj, path);
|
1432 | };
|
1433 | }
|
1434 |
|
1435 |
|
1436 |
|
1437 | function matcher(attrs) {
|
1438 | attrs = extendOwn({}, attrs);
|
1439 | return function(obj) {
|
1440 | return isMatch(obj, attrs);
|
1441 | };
|
1442 | }
|
1443 |
|
1444 |
|
1445 | function times(n, iteratee, context) {
|
1446 | var accum = Array(Math.max(0, n));
|
1447 | iteratee = optimizeCb(iteratee, context, 1);
|
1448 | for (var i = 0; i < n; i++) accum[i] = iteratee(i);
|
1449 | return accum;
|
1450 | }
|
1451 |
|
1452 |
|
1453 | function random(min, max) {
|
1454 | if (max == null) {
|
1455 | max = min;
|
1456 | min = 0;
|
1457 | }
|
1458 | return min + Math.floor(Math.random() * (max - min + 1));
|
1459 | }
|
1460 |
|
1461 |
|
1462 | var now = Date.now || function() {
|
1463 | return new Date().getTime();
|
1464 | };
|
1465 |
|
1466 |
|
1467 | var escapeMap = {
|
1468 | '&': '&',
|
1469 | '<': '<',
|
1470 | '>': '>',
|
1471 | '"': '"',
|
1472 | "'": ''',
|
1473 | '`': '`'
|
1474 | };
|
1475 | var unescapeMap = invert(escapeMap);
|
1476 |
|
1477 |
|
1478 | function createEscaper(map) {
|
1479 | var escaper = function(match) {
|
1480 | return map[match];
|
1481 | };
|
1482 |
|
1483 | var source = '(?:' + keys(map).join('|') + ')';
|
1484 | var testRegexp = RegExp(source);
|
1485 | var replaceRegexp = RegExp(source, 'g');
|
1486 | return function(string) {
|
1487 | string = string == null ? '' : '' + string;
|
1488 | return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
|
1489 | };
|
1490 | }
|
1491 | var escape = createEscaper(escapeMap);
|
1492 | var unescape = createEscaper(unescapeMap);
|
1493 |
|
1494 |
|
1495 |
|
1496 |
|
1497 | function result(obj, path, fallback) {
|
1498 | if (!isArray(path)) path = [path];
|
1499 | var length = path.length;
|
1500 | if (!length) {
|
1501 | return isFunction(fallback) ? fallback.call(obj) : fallback;
|
1502 | }
|
1503 | for (var i = 0; i < length; i++) {
|
1504 | var prop = obj == null ? void 0 : obj[path[i]];
|
1505 | if (prop === void 0) {
|
1506 | prop = fallback;
|
1507 | i = length;
|
1508 | }
|
1509 | obj = isFunction(prop) ? prop.call(obj) : prop;
|
1510 | }
|
1511 | return obj;
|
1512 | }
|
1513 |
|
1514 |
|
1515 |
|
1516 | var idCounter = 0;
|
1517 | function uniqueId(prefix) {
|
1518 | var id = ++idCounter + '';
|
1519 | return prefix ? prefix + id : id;
|
1520 | }
|
1521 |
|
1522 |
|
1523 |
|
1524 | var templateSettings = _.templateSettings = {
|
1525 | evaluate: /<%([\s\S]+?)%>/g,
|
1526 | interpolate: /<%=([\s\S]+?)%>/g,
|
1527 | escape: /<%-([\s\S]+?)%>/g
|
1528 | };
|
1529 |
|
1530 |
|
1531 |
|
1532 |
|
1533 | var noMatch = /(.)^/;
|
1534 |
|
1535 |
|
1536 |
|
1537 | var escapes = {
|
1538 | "'": "'",
|
1539 | '\\': '\\',
|
1540 | '\r': 'r',
|
1541 | '\n': 'n',
|
1542 | '\u2028': 'u2028',
|
1543 | '\u2029': 'u2029'
|
1544 | };
|
1545 |
|
1546 | var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;
|
1547 |
|
1548 | var escapeChar = function(match) {
|
1549 | return '\\' + escapes[match];
|
1550 | };
|
1551 |
|
1552 |
|
1553 |
|
1554 |
|
1555 |
|
1556 | function template(text, settings, oldSettings) {
|
1557 | if (!settings && oldSettings) settings = oldSettings;
|
1558 | settings = defaults({}, settings, _.templateSettings);
|
1559 |
|
1560 |
|
1561 | var matcher = RegExp([
|
1562 | (settings.escape || noMatch).source,
|
1563 | (settings.interpolate || noMatch).source,
|
1564 | (settings.evaluate || noMatch).source
|
1565 | ].join('|') + '|$', 'g');
|
1566 |
|
1567 |
|
1568 | var index = 0;
|
1569 | var source = "__p+='";
|
1570 | text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
|
1571 | source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
|
1572 | index = offset + match.length;
|
1573 |
|
1574 | if (escape) {
|
1575 | source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
|
1576 | } else if (interpolate) {
|
1577 | source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
|
1578 | } else if (evaluate) {
|
1579 | source += "';\n" + evaluate + "\n__p+='";
|
1580 | }
|
1581 |
|
1582 |
|
1583 | return match;
|
1584 | });
|
1585 | source += "';\n";
|
1586 |
|
1587 |
|
1588 | if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
|
1589 |
|
1590 | source = "var __t,__p='',__j=Array.prototype.join," +
|
1591 | "print=function(){__p+=__j.call(arguments,'');};\n" +
|
1592 | source + 'return __p;\n';
|
1593 |
|
1594 | var render;
|
1595 | try {
|
1596 | render = new Function(settings.variable || 'obj', '_', source);
|
1597 | } catch (e) {
|
1598 | e.source = source;
|
1599 | throw e;
|
1600 | }
|
1601 |
|
1602 | var template = function(data) {
|
1603 | return render.call(this, data, _);
|
1604 | };
|
1605 |
|
1606 |
|
1607 | var argument = settings.variable || 'obj';
|
1608 | template.source = 'function(' + argument + '){\n' + source + '}';
|
1609 |
|
1610 | return template;
|
1611 | }
|
1612 |
|
1613 |
|
1614 | function chain(obj) {
|
1615 | var instance = _(obj);
|
1616 | instance._chain = true;
|
1617 | return instance;
|
1618 | }
|
1619 |
|
1620 |
|
1621 |
|
1622 |
|
1623 |
|
1624 |
|
1625 |
|
1626 |
|
1627 | function chainResult(instance, obj) {
|
1628 | return instance._chain ? _(obj).chain() : obj;
|
1629 | }
|
1630 |
|
1631 |
|
1632 | function mixin(obj) {
|
1633 | each(functions(obj), function(name) {
|
1634 | var func = _[name] = obj[name];
|
1635 | _.prototype[name] = function() {
|
1636 | var args = [this._wrapped];
|
1637 | push.apply(args, arguments);
|
1638 | return chainResult(this, func.apply(_, args));
|
1639 | };
|
1640 | });
|
1641 | return _;
|
1642 | }
|
1643 |
|
1644 |
|
1645 | each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
|
1646 | var method = ArrayProto[name];
|
1647 | _.prototype[name] = function() {
|
1648 | var obj = this._wrapped;
|
1649 | method.apply(obj, arguments);
|
1650 | if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
|
1651 | return chainResult(this, obj);
|
1652 | };
|
1653 | });
|
1654 |
|
1655 |
|
1656 | each(['concat', 'join', 'slice'], function(name) {
|
1657 | var method = ArrayProto[name];
|
1658 | _.prototype[name] = function() {
|
1659 | return chainResult(this, method.apply(this._wrapped, arguments));
|
1660 | };
|
1661 | });
|
1662 |
|
1663 |
|
1664 | _.prototype.value = function() {
|
1665 | return this._wrapped;
|
1666 | };
|
1667 |
|
1668 |
|
1669 |
|
1670 | _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
|
1671 |
|
1672 | _.prototype.toString = function() {
|
1673 | return String(this._wrapped);
|
1674 | };
|
1675 |
|
1676 | var allExports = ({
|
1677 | 'default': _,
|
1678 | VERSION: VERSION,
|
1679 | iteratee: iteratee,
|
1680 | restArguments: restArguments,
|
1681 | each: each,
|
1682 | forEach: each,
|
1683 | map: map,
|
1684 | collect: map,
|
1685 | reduce: reduce,
|
1686 | foldl: reduce,
|
1687 | inject: reduce,
|
1688 | reduceRight: reduceRight,
|
1689 | foldr: reduceRight,
|
1690 | find: find,
|
1691 | detect: find,
|
1692 | filter: filter,
|
1693 | select: filter,
|
1694 | reject: reject,
|
1695 | every: every,
|
1696 | all: every,
|
1697 | some: some,
|
1698 | any: some,
|
1699 | contains: contains,
|
1700 | includes: contains,
|
1701 | include: contains,
|
1702 | invoke: invoke,
|
1703 | pluck: pluck,
|
1704 | where: where,
|
1705 | findWhere: findWhere,
|
1706 | max: max,
|
1707 | min: min,
|
1708 | shuffle: shuffle,
|
1709 | sample: sample,
|
1710 | sortBy: sortBy,
|
1711 | groupBy: groupBy,
|
1712 | indexBy: indexBy,
|
1713 | countBy: countBy,
|
1714 | toArray: toArray,
|
1715 | size: size,
|
1716 | partition: partition,
|
1717 | first: first,
|
1718 | head: first,
|
1719 | take: first,
|
1720 | initial: initial,
|
1721 | last: last,
|
1722 | rest: rest,
|
1723 | tail: rest,
|
1724 | drop: rest,
|
1725 | compact: compact,
|
1726 | flatten: flatten,
|
1727 | without: without,
|
1728 | uniq: uniq,
|
1729 | unique: uniq,
|
1730 | union: union,
|
1731 | intersection: intersection,
|
1732 | difference: difference,
|
1733 | unzip: unzip,
|
1734 | zip: zip,
|
1735 | object: object,
|
1736 | findIndex: findIndex,
|
1737 | findLastIndex: findLastIndex,
|
1738 | sortedIndex: sortedIndex,
|
1739 | indexOf: indexOf,
|
1740 | lastIndexOf: lastIndexOf,
|
1741 | range: range,
|
1742 | chunk: chunk,
|
1743 | bind: bind,
|
1744 | partial: partial,
|
1745 | bindAll: bindAll,
|
1746 | memoize: memoize,
|
1747 | delay: delay,
|
1748 | defer: defer,
|
1749 | throttle: throttle,
|
1750 | debounce: debounce,
|
1751 | wrap: wrap,
|
1752 | negate: negate,
|
1753 | compose: compose,
|
1754 | after: after,
|
1755 | before: before,
|
1756 | once: once,
|
1757 | keys: keys,
|
1758 | allKeys: allKeys,
|
1759 | values: values,
|
1760 | mapObject: mapObject,
|
1761 | pairs: pairs,
|
1762 | invert: invert,
|
1763 | functions: functions,
|
1764 | methods: functions,
|
1765 | extend: extend,
|
1766 | extendOwn: extendOwn,
|
1767 | assign: extendOwn,
|
1768 | findKey: findKey,
|
1769 | pick: pick,
|
1770 | omit: omit,
|
1771 | defaults: defaults,
|
1772 | create: create,
|
1773 | clone: clone,
|
1774 | tap: tap,
|
1775 | isMatch: isMatch,
|
1776 | isEqual: isEqual,
|
1777 | isEmpty: isEmpty,
|
1778 | isElement: isElement,
|
1779 | isArray: isArray,
|
1780 | isObject: isObject,
|
1781 | isArguments: isArguments,
|
1782 | isFunction: isFunction,
|
1783 | isString: isString,
|
1784 | isNumber: isNumber,
|
1785 | isDate: isDate,
|
1786 | isRegExp: isRegExp,
|
1787 | isError: isError,
|
1788 | isSymbol: isSymbol,
|
1789 | isMap: isMap,
|
1790 | isWeakMap: isWeakMap,
|
1791 | isSet: isSet,
|
1792 | isWeakSet: isWeakSet,
|
1793 | isFinite: isFinite,
|
1794 | isNaN: isNaN,
|
1795 | isBoolean: isBoolean,
|
1796 | isNull: isNull,
|
1797 | isUndefined: isUndefined,
|
1798 | has: has,
|
1799 | identity: identity,
|
1800 | constant: constant,
|
1801 | noop: noop,
|
1802 | property: property,
|
1803 | propertyOf: propertyOf,
|
1804 | matcher: matcher,
|
1805 | matches: matcher,
|
1806 | times: times,
|
1807 | random: random,
|
1808 | now: now,
|
1809 | escape: escape,
|
1810 | unescape: unescape,
|
1811 | result: result,
|
1812 | uniqueId: uniqueId,
|
1813 | templateSettings: templateSettings,
|
1814 | template: template,
|
1815 | chain: chain,
|
1816 | mixin: mixin
|
1817 | });
|
1818 |
|
1819 |
|
1820 | var _$1 = mixin(allExports);
|
1821 |
|
1822 | _$1._ = _$1;
|
1823 |
|
1824 | return _$1;
|
1825 |
|
1826 | })));
|
1827 |
|