You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

685 lines
15 KiB

  1. // Generated by LiveScript 1.4.0
  2. var each, map, compact, filter, reject, partition, find, head, first, tail, last, initial, empty, reverse, unique, uniqueBy, fold, foldl, fold1, foldl1, foldr, foldr1, unfoldr, concat, concatMap, flatten, difference, intersection, union, countBy, groupBy, andList, orList, any, all, sort, sortWith, sortBy, sum, product, mean, average, maximum, minimum, maximumBy, minimumBy, scan, scanl, scan1, scanl1, scanr, scanr1, slice, take, drop, splitAt, takeWhile, dropWhile, span, breakList, zip, zipWith, zipAll, zipAllWith, at, elemIndex, elemIndices, findIndex, findIndices, toString$ = {}.toString, slice$ = [].slice;
  3. each = curry$(function(f, xs){
  4. var i$, len$, x;
  5. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  6. x = xs[i$];
  7. f(x);
  8. }
  9. return xs;
  10. });
  11. map = curry$(function(f, xs){
  12. var i$, len$, x, results$ = [];
  13. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  14. x = xs[i$];
  15. results$.push(f(x));
  16. }
  17. return results$;
  18. });
  19. compact = function(xs){
  20. var i$, len$, x, results$ = [];
  21. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  22. x = xs[i$];
  23. if (x) {
  24. results$.push(x);
  25. }
  26. }
  27. return results$;
  28. };
  29. filter = curry$(function(f, xs){
  30. var i$, len$, x, results$ = [];
  31. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  32. x = xs[i$];
  33. if (f(x)) {
  34. results$.push(x);
  35. }
  36. }
  37. return results$;
  38. });
  39. reject = curry$(function(f, xs){
  40. var i$, len$, x, results$ = [];
  41. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  42. x = xs[i$];
  43. if (!f(x)) {
  44. results$.push(x);
  45. }
  46. }
  47. return results$;
  48. });
  49. partition = curry$(function(f, xs){
  50. var passed, failed, i$, len$, x;
  51. passed = [];
  52. failed = [];
  53. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  54. x = xs[i$];
  55. (f(x) ? passed : failed).push(x);
  56. }
  57. return [passed, failed];
  58. });
  59. find = curry$(function(f, xs){
  60. var i$, len$, x;
  61. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  62. x = xs[i$];
  63. if (f(x)) {
  64. return x;
  65. }
  66. }
  67. });
  68. head = first = function(xs){
  69. return xs[0];
  70. };
  71. tail = function(xs){
  72. if (!xs.length) {
  73. return;
  74. }
  75. return xs.slice(1);
  76. };
  77. last = function(xs){
  78. return xs[xs.length - 1];
  79. };
  80. initial = function(xs){
  81. if (!xs.length) {
  82. return;
  83. }
  84. return xs.slice(0, -1);
  85. };
  86. empty = function(xs){
  87. return !xs.length;
  88. };
  89. reverse = function(xs){
  90. return xs.concat().reverse();
  91. };
  92. unique = function(xs){
  93. var result, i$, len$, x;
  94. result = [];
  95. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  96. x = xs[i$];
  97. if (!in$(x, result)) {
  98. result.push(x);
  99. }
  100. }
  101. return result;
  102. };
  103. uniqueBy = curry$(function(f, xs){
  104. var seen, i$, len$, x, val, results$ = [];
  105. seen = [];
  106. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  107. x = xs[i$];
  108. val = f(x);
  109. if (in$(val, seen)) {
  110. continue;
  111. }
  112. seen.push(val);
  113. results$.push(x);
  114. }
  115. return results$;
  116. });
  117. fold = foldl = curry$(function(f, memo, xs){
  118. var i$, len$, x;
  119. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  120. x = xs[i$];
  121. memo = f(memo, x);
  122. }
  123. return memo;
  124. });
  125. fold1 = foldl1 = curry$(function(f, xs){
  126. return fold(f, xs[0], xs.slice(1));
  127. });
  128. foldr = curry$(function(f, memo, xs){
  129. var i$, x;
  130. for (i$ = xs.length - 1; i$ >= 0; --i$) {
  131. x = xs[i$];
  132. memo = f(x, memo);
  133. }
  134. return memo;
  135. });
  136. foldr1 = curry$(function(f, xs){
  137. return foldr(f, xs[xs.length - 1], xs.slice(0, -1));
  138. });
  139. unfoldr = curry$(function(f, b){
  140. var result, x, that;
  141. result = [];
  142. x = b;
  143. while ((that = f(x)) != null) {
  144. result.push(that[0]);
  145. x = that[1];
  146. }
  147. return result;
  148. });
  149. concat = function(xss){
  150. return [].concat.apply([], xss);
  151. };
  152. concatMap = curry$(function(f, xs){
  153. var x;
  154. return [].concat.apply([], (function(){
  155. var i$, ref$, len$, results$ = [];
  156. for (i$ = 0, len$ = (ref$ = xs).length; i$ < len$; ++i$) {
  157. x = ref$[i$];
  158. results$.push(f(x));
  159. }
  160. return results$;
  161. }()));
  162. });
  163. flatten = function(xs){
  164. var x;
  165. return [].concat.apply([], (function(){
  166. var i$, ref$, len$, results$ = [];
  167. for (i$ = 0, len$ = (ref$ = xs).length; i$ < len$; ++i$) {
  168. x = ref$[i$];
  169. if (toString$.call(x).slice(8, -1) === 'Array') {
  170. results$.push(flatten(x));
  171. } else {
  172. results$.push(x);
  173. }
  174. }
  175. return results$;
  176. }()));
  177. };
  178. difference = function(xs){
  179. var yss, results, i$, len$, x, j$, len1$, ys;
  180. yss = slice$.call(arguments, 1);
  181. results = [];
  182. outer: for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  183. x = xs[i$];
  184. for (j$ = 0, len1$ = yss.length; j$ < len1$; ++j$) {
  185. ys = yss[j$];
  186. if (in$(x, ys)) {
  187. continue outer;
  188. }
  189. }
  190. results.push(x);
  191. }
  192. return results;
  193. };
  194. intersection = function(xs){
  195. var yss, results, i$, len$, x, j$, len1$, ys;
  196. yss = slice$.call(arguments, 1);
  197. results = [];
  198. outer: for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  199. x = xs[i$];
  200. for (j$ = 0, len1$ = yss.length; j$ < len1$; ++j$) {
  201. ys = yss[j$];
  202. if (!in$(x, ys)) {
  203. continue outer;
  204. }
  205. }
  206. results.push(x);
  207. }
  208. return results;
  209. };
  210. union = function(){
  211. var xss, results, i$, len$, xs, j$, len1$, x;
  212. xss = slice$.call(arguments);
  213. results = [];
  214. for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {
  215. xs = xss[i$];
  216. for (j$ = 0, len1$ = xs.length; j$ < len1$; ++j$) {
  217. x = xs[j$];
  218. if (!in$(x, results)) {
  219. results.push(x);
  220. }
  221. }
  222. }
  223. return results;
  224. };
  225. countBy = curry$(function(f, xs){
  226. var results, i$, len$, x, key;
  227. results = {};
  228. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  229. x = xs[i$];
  230. key = f(x);
  231. if (key in results) {
  232. results[key] += 1;
  233. } else {
  234. results[key] = 1;
  235. }
  236. }
  237. return results;
  238. });
  239. groupBy = curry$(function(f, xs){
  240. var results, i$, len$, x, key;
  241. results = {};
  242. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  243. x = xs[i$];
  244. key = f(x);
  245. if (key in results) {
  246. results[key].push(x);
  247. } else {
  248. results[key] = [x];
  249. }
  250. }
  251. return results;
  252. });
  253. andList = function(xs){
  254. var i$, len$, x;
  255. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  256. x = xs[i$];
  257. if (!x) {
  258. return false;
  259. }
  260. }
  261. return true;
  262. };
  263. orList = function(xs){
  264. var i$, len$, x;
  265. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  266. x = xs[i$];
  267. if (x) {
  268. return true;
  269. }
  270. }
  271. return false;
  272. };
  273. any = curry$(function(f, xs){
  274. var i$, len$, x;
  275. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  276. x = xs[i$];
  277. if (f(x)) {
  278. return true;
  279. }
  280. }
  281. return false;
  282. });
  283. all = curry$(function(f, xs){
  284. var i$, len$, x;
  285. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  286. x = xs[i$];
  287. if (!f(x)) {
  288. return false;
  289. }
  290. }
  291. return true;
  292. });
  293. sort = function(xs){
  294. return xs.concat().sort(function(x, y){
  295. if (x > y) {
  296. return 1;
  297. } else if (x < y) {
  298. return -1;
  299. } else {
  300. return 0;
  301. }
  302. });
  303. };
  304. sortWith = curry$(function(f, xs){
  305. return xs.concat().sort(f);
  306. });
  307. sortBy = curry$(function(f, xs){
  308. return xs.concat().sort(function(x, y){
  309. if (f(x) > f(y)) {
  310. return 1;
  311. } else if (f(x) < f(y)) {
  312. return -1;
  313. } else {
  314. return 0;
  315. }
  316. });
  317. });
  318. sum = function(xs){
  319. var result, i$, len$, x;
  320. result = 0;
  321. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  322. x = xs[i$];
  323. result += x;
  324. }
  325. return result;
  326. };
  327. product = function(xs){
  328. var result, i$, len$, x;
  329. result = 1;
  330. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  331. x = xs[i$];
  332. result *= x;
  333. }
  334. return result;
  335. };
  336. mean = average = function(xs){
  337. var sum, i$, len$, x;
  338. sum = 0;
  339. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  340. x = xs[i$];
  341. sum += x;
  342. }
  343. return sum / xs.length;
  344. };
  345. maximum = function(xs){
  346. var max, i$, ref$, len$, x;
  347. max = xs[0];
  348. for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {
  349. x = ref$[i$];
  350. if (x > max) {
  351. max = x;
  352. }
  353. }
  354. return max;
  355. };
  356. minimum = function(xs){
  357. var min, i$, ref$, len$, x;
  358. min = xs[0];
  359. for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {
  360. x = ref$[i$];
  361. if (x < min) {
  362. min = x;
  363. }
  364. }
  365. return min;
  366. };
  367. maximumBy = curry$(function(f, xs){
  368. var max, i$, ref$, len$, x;
  369. max = xs[0];
  370. for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {
  371. x = ref$[i$];
  372. if (f(x) > f(max)) {
  373. max = x;
  374. }
  375. }
  376. return max;
  377. });
  378. minimumBy = curry$(function(f, xs){
  379. var min, i$, ref$, len$, x;
  380. min = xs[0];
  381. for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {
  382. x = ref$[i$];
  383. if (f(x) < f(min)) {
  384. min = x;
  385. }
  386. }
  387. return min;
  388. });
  389. scan = scanl = curry$(function(f, memo, xs){
  390. var last, x;
  391. last = memo;
  392. return [memo].concat((function(){
  393. var i$, ref$, len$, results$ = [];
  394. for (i$ = 0, len$ = (ref$ = xs).length; i$ < len$; ++i$) {
  395. x = ref$[i$];
  396. results$.push(last = f(last, x));
  397. }
  398. return results$;
  399. }()));
  400. });
  401. scan1 = scanl1 = curry$(function(f, xs){
  402. if (!xs.length) {
  403. return;
  404. }
  405. return scan(f, xs[0], xs.slice(1));
  406. });
  407. scanr = curry$(function(f, memo, xs){
  408. xs = xs.concat().reverse();
  409. return scan(f, memo, xs).reverse();
  410. });
  411. scanr1 = curry$(function(f, xs){
  412. if (!xs.length) {
  413. return;
  414. }
  415. xs = xs.concat().reverse();
  416. return scan(f, xs[0], xs.slice(1)).reverse();
  417. });
  418. slice = curry$(function(x, y, xs){
  419. return xs.slice(x, y);
  420. });
  421. take = curry$(function(n, xs){
  422. if (n <= 0) {
  423. return xs.slice(0, 0);
  424. } else {
  425. return xs.slice(0, n);
  426. }
  427. });
  428. drop = curry$(function(n, xs){
  429. if (n <= 0) {
  430. return xs;
  431. } else {
  432. return xs.slice(n);
  433. }
  434. });
  435. splitAt = curry$(function(n, xs){
  436. return [take(n, xs), drop(n, xs)];
  437. });
  438. takeWhile = curry$(function(p, xs){
  439. var len, i;
  440. len = xs.length;
  441. if (!len) {
  442. return xs;
  443. }
  444. i = 0;
  445. while (i < len && p(xs[i])) {
  446. i += 1;
  447. }
  448. return xs.slice(0, i);
  449. });
  450. dropWhile = curry$(function(p, xs){
  451. var len, i;
  452. len = xs.length;
  453. if (!len) {
  454. return xs;
  455. }
  456. i = 0;
  457. while (i < len && p(xs[i])) {
  458. i += 1;
  459. }
  460. return xs.slice(i);
  461. });
  462. span = curry$(function(p, xs){
  463. return [takeWhile(p, xs), dropWhile(p, xs)];
  464. });
  465. breakList = curry$(function(p, xs){
  466. return span(compose$(p, not$), xs);
  467. });
  468. zip = curry$(function(xs, ys){
  469. var result, len, i$, len$, i, x;
  470. result = [];
  471. len = ys.length;
  472. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  473. i = i$;
  474. x = xs[i$];
  475. if (i === len) {
  476. break;
  477. }
  478. result.push([x, ys[i]]);
  479. }
  480. return result;
  481. });
  482. zipWith = curry$(function(f, xs, ys){
  483. var result, len, i$, len$, i, x;
  484. result = [];
  485. len = ys.length;
  486. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  487. i = i$;
  488. x = xs[i$];
  489. if (i === len) {
  490. break;
  491. }
  492. result.push(f(x, ys[i]));
  493. }
  494. return result;
  495. });
  496. zipAll = function(){
  497. var xss, minLength, i$, len$, xs, ref$, i, lresult$, j$, results$ = [];
  498. xss = slice$.call(arguments);
  499. minLength = undefined;
  500. for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {
  501. xs = xss[i$];
  502. minLength <= (ref$ = xs.length) || (minLength = ref$);
  503. }
  504. for (i$ = 0; i$ < minLength; ++i$) {
  505. i = i$;
  506. lresult$ = [];
  507. for (j$ = 0, len$ = xss.length; j$ < len$; ++j$) {
  508. xs = xss[j$];
  509. lresult$.push(xs[i]);
  510. }
  511. results$.push(lresult$);
  512. }
  513. return results$;
  514. };
  515. zipAllWith = function(f){
  516. var xss, minLength, i$, len$, xs, ref$, i, results$ = [];
  517. xss = slice$.call(arguments, 1);
  518. minLength = undefined;
  519. for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {
  520. xs = xss[i$];
  521. minLength <= (ref$ = xs.length) || (minLength = ref$);
  522. }
  523. for (i$ = 0; i$ < minLength; ++i$) {
  524. i = i$;
  525. results$.push(f.apply(null, (fn$())));
  526. }
  527. return results$;
  528. function fn$(){
  529. var i$, ref$, len$, results$ = [];
  530. for (i$ = 0, len$ = (ref$ = xss).length; i$ < len$; ++i$) {
  531. xs = ref$[i$];
  532. results$.push(xs[i]);
  533. }
  534. return results$;
  535. }
  536. };
  537. at = curry$(function(n, xs){
  538. if (n < 0) {
  539. return xs[xs.length + n];
  540. } else {
  541. return xs[n];
  542. }
  543. });
  544. elemIndex = curry$(function(el, xs){
  545. var i$, len$, i, x;
  546. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  547. i = i$;
  548. x = xs[i$];
  549. if (x === el) {
  550. return i;
  551. }
  552. }
  553. });
  554. elemIndices = curry$(function(el, xs){
  555. var i$, len$, i, x, results$ = [];
  556. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  557. i = i$;
  558. x = xs[i$];
  559. if (x === el) {
  560. results$.push(i);
  561. }
  562. }
  563. return results$;
  564. });
  565. findIndex = curry$(function(f, xs){
  566. var i$, len$, i, x;
  567. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  568. i = i$;
  569. x = xs[i$];
  570. if (f(x)) {
  571. return i;
  572. }
  573. }
  574. });
  575. findIndices = curry$(function(f, xs){
  576. var i$, len$, i, x, results$ = [];
  577. for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
  578. i = i$;
  579. x = xs[i$];
  580. if (f(x)) {
  581. results$.push(i);
  582. }
  583. }
  584. return results$;
  585. });
  586. module.exports = {
  587. each: each,
  588. map: map,
  589. filter: filter,
  590. compact: compact,
  591. reject: reject,
  592. partition: partition,
  593. find: find,
  594. head: head,
  595. first: first,
  596. tail: tail,
  597. last: last,
  598. initial: initial,
  599. empty: empty,
  600. reverse: reverse,
  601. difference: difference,
  602. intersection: intersection,
  603. union: union,
  604. countBy: countBy,
  605. groupBy: groupBy,
  606. fold: fold,
  607. fold1: fold1,
  608. foldl: foldl,
  609. foldl1: foldl1,
  610. foldr: foldr,
  611. foldr1: foldr1,
  612. unfoldr: unfoldr,
  613. andList: andList,
  614. orList: orList,
  615. any: any,
  616. all: all,
  617. unique: unique,
  618. uniqueBy: uniqueBy,
  619. sort: sort,
  620. sortWith: sortWith,
  621. sortBy: sortBy,
  622. sum: sum,
  623. product: product,
  624. mean: mean,
  625. average: average,
  626. concat: concat,
  627. concatMap: concatMap,
  628. flatten: flatten,
  629. maximum: maximum,
  630. minimum: minimum,
  631. maximumBy: maximumBy,
  632. minimumBy: minimumBy,
  633. scan: scan,
  634. scan1: scan1,
  635. scanl: scanl,
  636. scanl1: scanl1,
  637. scanr: scanr,
  638. scanr1: scanr1,
  639. slice: slice,
  640. take: take,
  641. drop: drop,
  642. splitAt: splitAt,
  643. takeWhile: takeWhile,
  644. dropWhile: dropWhile,
  645. span: span,
  646. breakList: breakList,
  647. zip: zip,
  648. zipWith: zipWith,
  649. zipAll: zipAll,
  650. zipAllWith: zipAllWith,
  651. at: at,
  652. elemIndex: elemIndex,
  653. elemIndices: elemIndices,
  654. findIndex: findIndex,
  655. findIndices: findIndices
  656. };
  657. function curry$(f, bound){
  658. var context,
  659. _curry = function(args) {
  660. return f.length > 1 ? function(){
  661. var params = args ? args.concat() : [];
  662. context = bound ? context || this : this;
  663. return params.push.apply(params, arguments) <
  664. f.length && arguments.length ?
  665. _curry.call(context, params) : f.apply(context, params);
  666. } : f;
  667. };
  668. return _curry();
  669. }
  670. function in$(x, xs){
  671. var i = -1, l = xs.length >>> 0;
  672. while (++i < l) if (x === xs[i]) return true;
  673. return false;
  674. }
  675. function compose$() {
  676. var functions = arguments;
  677. return function() {
  678. var i, result;
  679. result = functions[0].apply(this, arguments);
  680. for (i = 1; i < functions.length; ++i) {
  681. result = functions[i](result);
  682. }
  683. return result;
  684. };
  685. }
  686. function not$(x){ return !x; }