review.tizen.org Git - platform/framework/web/crosswalk-tizen.git/blob

   1 // Generated by LiveScript 1.2.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(function(){
 467     return not$(p.apply(this, arguments));
 468   }, xs);
 469 });
 470 zip = curry$(function(xs, ys){
 471   var result, len, i$, len$, i, x;
 472   result = [];
 473   len = ys.length;
 474   for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
 475     i = i$;
 476     x = xs[i$];
 477     if (i === len) {
 478       break;
 479     }
 480     result.push([x, ys[i]]);
 481   }
 482   return result;
 483 });
 484 zipWith = curry$(function(f, xs, ys){
 485   var result, len, i$, len$, i, x;
 486   result = [];
 487   len = ys.length;
 488   for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
 489     i = i$;
 490     x = xs[i$];
 491     if (i === len) {
 492       break;
 493     }
 494     result.push(f(x, ys[i]));
 495   }
 496   return result;
 497 });
 498 zipAll = function(){
 499   var xss, minLength, i$, len$, xs, ref$, i, lresult$, j$, results$ = [];
 500   xss = slice$.call(arguments);
 501   minLength = 9e9;
 502   for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {
 503     xs = xss[i$];
 504     minLength <= (ref$ = xs.length) || (minLength = ref$);
 505   }
 506   for (i$ = 0; i$ < minLength; ++i$) {
 507     i = i$;
 508     lresult$ = [];
 509     for (j$ = 0, len$ = xss.length; j$ < len$; ++j$) {
 510       xs = xss[j$];
 511       lresult$.push(xs[i]);
 512     }
 513     results$.push(lresult$);
 514   }
 515   return results$;
 516 };
 517 zipAllWith = function(f){
 518   var xss, minLength, i$, len$, xs, ref$, i, results$ = [];
 519   xss = slice$.call(arguments, 1);
 520   minLength = 9e9;
 521   for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {
 522     xs = xss[i$];
 523     minLength <= (ref$ = xs.length) || (minLength = ref$);
 524   }
 525   for (i$ = 0; i$ < minLength; ++i$) {
 526     i = i$;
 527     results$.push(f.apply(null, (fn$())));
 528   }
 529   return results$;
 530   function fn$(){
 531     var i$, ref$, len$, results$ = [];
 532     for (i$ = 0, len$ = (ref$ = xss).length; i$ < len$; ++i$) {
 533       xs = ref$[i$];
 534       results$.push(xs[i]);
 535     }
 536     return results$;
 537   }
 538 };
 539 at = curry$(function(n, xs){
 540   if (n < 0) {
 541     return xs[xs.length + n];
 542   } else {
 543     return xs[n];
 544   }
 545 });
 546 elemIndex = curry$(function(el, xs){
 547   var i$, len$, i, x;
 548   for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
 549     i = i$;
 550     x = xs[i$];
 551     if (x === el) {
 552       return i;
 553     }
 554   }
 555 });
 556 elemIndices = curry$(function(el, xs){
 557   var i$, len$, i, x, results$ = [];
 558   for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
 559     i = i$;
 560     x = xs[i$];
 561     if (x === el) {
 562       results$.push(i);
 563     }
 564   }
 565   return results$;
 566 });
 567 findIndex = curry$(function(f, xs){
 568   var i$, len$, i, x;
 569   for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
 570     i = i$;
 571     x = xs[i$];
 572     if (f(x)) {
 573       return i;
 574     }
 575   }
 576 });
 577 findIndices = curry$(function(f, xs){
 578   var i$, len$, i, x, results$ = [];
 579   for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {
 580     i = i$;
 581     x = xs[i$];
 582     if (f(x)) {
 583       results$.push(i);
 584     }
 585   }
 586   return results$;
 587 });
 588 module.exports = {
 589   each: each,
 590   map: map,
 591   filter: filter,
 592   compact: compact,
 593   reject: reject,
 594   partition: partition,
 595   find: find,
 596   head: head,
 597   first: first,
 598   tail: tail,
 599   last: last,
 600   initial: initial,
 601   empty: empty,
 602   reverse: reverse,
 603   difference: difference,
 604   intersection: intersection,
 605   union: union,
 606   countBy: countBy,
 607   groupBy: groupBy,
 608   fold: fold,
 609   fold1: fold1,
 610   foldl: foldl,
 611   foldl1: foldl1,
 612   foldr: foldr,
 613   foldr1: foldr1,
 614   unfoldr: unfoldr,
 615   andList: andList,
 616   orList: orList,
 617   any: any,
 618   all: all,
 619   unique: unique,
 620   uniqueBy: uniqueBy,
 621   sort: sort,
 622   sortWith: sortWith,
 623   sortBy: sortBy,
 624   sum: sum,
 625   product: product,
 626   mean: mean,
 627   average: average,
 628   concat: concat,
 629   concatMap: concatMap,
 630   flatten: flatten,
 631   maximum: maximum,
 632   minimum: minimum,
 633   maximumBy: maximumBy,
 634   minimumBy: minimumBy,
 635   scan: scan,
 636   scan1: scan1,
 637   scanl: scanl,
 638   scanl1: scanl1,
 639   scanr: scanr,
 640   scanr1: scanr1,
 641   slice: slice,
 642   take: take,
 643   drop: drop,
 644   splitAt: splitAt,
 645   takeWhile: takeWhile,
 646   dropWhile: dropWhile,
 647   span: span,
 648   breakList: breakList,
 649   zip: zip,
 650   zipWith: zipWith,
 651   zipAll: zipAll,
 652   zipAllWith: zipAllWith,
 653   at: at,
 654   elemIndex: elemIndex,
 655   elemIndices: elemIndices,
 656   findIndex: findIndex,
 657   findIndices: findIndices
 658 };
 659 function curry$(f, bound){
 660   var context,
 661   _curry = function(args) {
 662     return f.length > 1 ? function(){
 663       var params = args ? args.concat() : [];
 664       context = bound ? context || this : this;
 665       return params.push.apply(params, arguments) <
 666           f.length && arguments.length ?
 667         _curry.call(context, params) : f.apply(context, params);
 668     } : f;
 669   };
 670   return _curry();
 671 }
 672 function in$(x, xs){
 673   var i = -1, l = xs.length >>> 0;
 674   while (++i < l) if (x === xs[i]) return true;
 675   return false;
 676 }
 677 function not$(x){ return !x; }