VimUnDo ^Lo !~?>t
h` ( * PZ @ _ Pg 5_ v P
function take(source, n) { /** H Returns sequence of first `n` items of the given `source`. If `source` J contains less items than `n` then that's how much items return sequence will contain. 8 print(take([ 1, 2, 3, 4, 5 ], 2)) // => 4 print(take([ 1, 2, 3 ], 5)) // => **/ / return transformer(source, function(source) { % var count = n >= 0 ? n : Infinity < return transform(source, function(next, value, result) { count = count - 1 E return count === 0 ? next(accumulated(), next(value, result)) : . count > 0 ? next(value, result) : 4 next(accumulated(), result) }) }) }5_ v P module.exports = take5_ v P * 5_ v P * 5_ v P * 5_
v P A Returns sequence of all `source`'s items except first `n` one. 5_
A v P A Returns sequence of all `source`'s items except first `n` one. 5_
< v P < Returns sequence of all `source`'s items after `n`-th one.5_
= v P H Returns sequence of all `source`'s items after `n`-th one. if sequence5_
H v P H Returns sequence of all `source`'s items after `n`-th one. If sequence5_
v P, 5_
v P, B Drops first n characters from s. Returns an empty string if n is5_
v P- greater than the length of s.5_ v P- < Returns sequence of first `n` items of the given `source`.5_ v P. / Reduces given `reducible` to first `n` items.5_ v P6 5_ v P9 8 print(take([ 1, 2, 3, 4, 5 ], 2)) // => 5_ v P> 8 print(drop([ 1, 2, 3, 4, 5 ], 2)) // => 5_ / v PC 5 print(drop([ 1, 2, 3, 4 ], 2)) // => 5_ 1 v PD 5 print(drop([ 1, 2, 3, 4 ], 2)) // => 5_ 1 v PJ 4 print(take([ 1, 2, 3 ], 5)) // => 5_ v PL . print(take([ 1, 2, 3 ], 5)) // => 5_ v PN
5_ v PQ 5_ . v Pt . print(drop([ 1, 2, 3 ], 5)) // => 5_ ! . v Pv 5 print(drop([ 1, 2, 3, 4 ], 2)) // => 5_ . v P
*var accumulated = require("./accumulated")5_
v P
5_ PJ& M/*jshint asi: true undef: true es5: true node: true browser: true devel: true5_ PJ' 9 forin: true latedef: false globalstrict: true */5_ ! PJ' 5_ " ! PJ(
'use strict';5_ ! # " PJ)
"use strict';5_ " $ # v P4 *var transformer = require("./transformer") &var transform = require("./transform") 5_ # % $ v P4 5_ $ & % v P4 5_ % ' & v P4 return reducible()5_ & ( ' v P4 return reducible(function())5_ ' ) ( v P4 ! return reducible(function() {})5_ ( * ) v P4# return reducible(function() {5_ ) + * ( v P43 5_ * , + v P4: return reduce()5_ + - , $ v P4= % return reduce(source, function())5_ , . - & v P4= ( return reduce(source, function() {})5_ - / . v P4> })5_ . 0 / v P4E }, n)5_ / 1 0 # v P4T & return reduce(source, function() {5_ 0 2 1 * v P4b 5_ 1 3 2
v P4h if ()5_ 2 4 3 v P4o if (count --> 0)5_ 3 5 4 v P4} if (count -- > 0)5_ 4 6 5 v P4 if (n > 0)5_ 5 8 6
v P4 if (n > 0) next()5_ 6 9 7 8 v P4 if (n === 0) next()5_ 8 : 9 v P4 5_ 9 ; : v P4 }, n >= 0 ? n : 1)5_ : < ; v P4 if (n === 0) next(value)5_ ; = < v P4 5_ < > = v P4 count5_ = ? > v P4 5_ > @ ? v P4 " if (count === 0) next(value)5_ ? A @ v P4 ! 5_ @ B A
v P4 !
return count >= 0) next(value) ! ! if (count >= 0) next(value)5_ A C B v P4 $ return count >= 0) next(value)5_ B D C % v P4 % return count >= 0 ? next(value)5_ C E D $ v P4 . return reduce(source, function(n, value) {5_ D F E % v P4 % return count >= 0 ? next(result5_ E G F 0 v P5 6 return count >= 0 ? next(result, value) : result5_ F H G v P5 / return transformer(source, function(source) {5_ G I H v P5
var count = n >= 0 ? n : 15_ H J I v P5
< return transform(source, function(next, value, result) {5_ I K J v P5 $ return count -- > 0 ? result :5_ J L K v P5 / next(value, result)5_ K M L v P5 })5_ L N M v P5 })5_ M O N v P59 / return count >= 0 ? next(result, value) :5_ N P O v P5E / return count <= 0 ? next(result, value) :5_ O Q P v P5J result5_ P R Q v P function drop(source, n) { &var reducible = require("./reducible") var reduce = require("./reduce") function drop(source, n) {5_ Q S R v P 5_ R T S v P
5_ S U T v P C// If take `0` then optimize by returning an empty if less then `0`5_ T V U v P
5_ U W V v P E // If take `0` then optimize by returning an empty if less then `0`5_ V X W 4 v P E // If drop `0` then optimize by returning an empty if less then `0`5_ W Y X : v P H // If drop `0` then optimize by returning source it if less then `0`5_ X Z Y 6 v P D // If drop `0` then optimize by returning source its less then `0`5_ Y [ Z v P& G // If drop `0` then optimize by returning source itself less then `0`5_ Z \ [
v P+ if (n === 0) return void(0)5_ [ ] \ J v P3 J // If drop `<= 0` then optimize by returning source itself less then `0`5_ \ ^ ] v P8 if (n <= 0) return void(0)5_ ] _ ^ v P= $ // then just return `source` back.5_ ^ ` _ = v P> = // If drop `<= 0` then optimize by returning source itself.5_ _ a ` v PN if (n < 0) return source5_ ` b a
v PP if (n === 0) return source5_ a c b # v PS # if (n === Infinity) return source5_ b d c " v PW # if (n === Infinity) return void()5_ c e d v P_ var count = n >= 0 ? n : 15_ d g e v Pl 3 return reduce(source, function(result, value) {5_ e h f g v P , return reducible(function(next, initial) {5_ g i h v P - return reducible(function (next, initial) {5_ h j i % v P 7 return reducible(function reduceDrop(next, initial) {5_ i k j * % v P ; return reducible(function accumulateTake(next, initial) {5_ j l k ) v P 0 accumulate(source, function(result, value) {5_ k m l . ) v P ? accumulate(source, function accumulateDrop(result, value) {5_ l n m / ) v P @ accumulate(source, function accumulateWhile(result, value) {5_ m o n = ) v P E accumulate(source, function accumulateDropSource(result, value) {5_ n p o : ) v P = accumulate(source, function accumulateDropSource(value) {5_ o q p ) v P ! 5_ p r q ) v P result = 5_ q s r & ) v P . return count < 0 ? next(result, value) :5_ r v s # ) v P " & return count < 0 ? next(value) :5_ s w t v ) v P ! 5_ v x w
) v P ! if ()5_ w y x ) v P ! if (count >)5_ x z y ) v P ! if (count === 0)5_ y { z ) v P count = count - 15_ z | { ) v P 5_ { } | ) v P ! $ if (count === 0) return result5_ | ~ } , ) v P ! , if (count === 0) return reduced(result5_ } ~ - ) v P ! - if (count === 0) return reduced(result)5_ ~ & ) v P ! , if (count === 0) return reduced(result5_ ) v P " ! 5_ ) v P # " 5_ ) v P # result = next()5_ ) v P $ # 5_ ) v P 5_ ) v P . return count < 0 ? next(value, result) :5_ ) v P # result5_ ) v P $ ! $ if (count === 0) return result5_ ) v P % ! " if (count > 0) return result5_ ) v P/ " ! 5_
) v P0 " if ()5_ ) v P2 " if (isError())5_ ) v P6 # " 5_ ) v P; # var isError = require()5_ ) v P< # var isError = require("")5_ ) v P? & var end = require("./end")5_ ) v PB " if (isError(value))5_ ) v PD " if (isError(value)) next()5_ ) v PI " - if (isError(value)) next(error, result)5_ + ) v PQ ' " 4 if (isError(value)) return next(error, result)5_ ) v Pk " " result = next(value, result)5_ ) v Pm - return result5_ ) v P ! # if (count >= 0) return result5_ $ ) v P ! $ if (count === 0) return result5_ ) v P ! if (count === 0) next()5_ ) ) v P ! * if (count === 0) next(value, return)5_ ) v P 0 ! return next(value, result)5_ ) v P 2 ! * if (count === 0) next(value, result)5_ ) v P " ! 5_ J ) v P # J // If value is an error (which also includes end of collection) than5_ ) v P 3 # //5_ A ) v P* 4 # A // pass it through `reducible` will take care of everything5_ 3 ) v P- 5 $ # 5_ % ) v PO 8 % $ 5_ " v P & % 5_ # v P if ()5_ " v P & % 5_
# v P & if ()5_ # v P & if (value === end)5_ " # v P & " if (value === end) reducible5_ % # v P! & & if (value === end) return next()5_ # v P& ' & 5_ $ v P) ' var end = require()5_ $ v P) 9 ' var end = require("")5_ $ v P. ( ' 5_ % v P3 ( // If value is end 5_ B v P> ( J // If value is an error (which also includes end of collection) just B // pass it through `reducible` will take care of everything. 4 if (isError(value)) return next(value, result)5_ H v P? & : if (isError(value)) return next(value, result)5_ ' H v PB & ' // If value is end just pass it t5_ H v PF ( ` // If value is end or // If value is an error (which also includes end of collection) just5_ 5 H v PL ( n // If value is end of collection or // If value is an error (which also includes end of collection) just5_ K H v PS ( b // If value is end of collection or is an error (which also includes end of collection) just5_ H v PU ) // end of collection) just 9pass it through `reducible` will take care of everything. ) B // pass it through `reducible` will take care of everything.5_ 0 H v P] ( Z // end of collection) just pass it through `reducible` will take care of everything.5_ L H v P_ ( [ // end of collection) just pass it through, `reducible` will take care of everything.5_ H v P` ; 5_ PC] ( &var reducible = require("./reducible")5_ PC` ( (var accumulate = require("./accumulate")5_ PCc ( 0var accumulate = require("reducible/accumulate")5_
PCe ( ,var reduec = require("reducible/accumulate")5_
PCg ( ,var reduec = require("reducible/accumulate")5_
PCi ( ,var reduec = require("reducible/accumulate")5_ PCl ( #var isError = require("./is-error")5_ PCo < ( var end = require("./end")5_ PCu ( E accumulate(source, function accumulateDropSource(value, result) {5_
PCw ( A reduec(source, function accumulateDropSource(value, result) {5_ & PC| = ( ; return reducible(function accumulateDrop(next, initial) {5_ & PC ? ( A reduce(source, function accumulateDropSource(value, result) {5_ * PL @ ( ,var reduce = require("reducible/accumulate")5_ PY (
"use strict"; .var reducible = require("reducible/reducible") (var reduce = require("reducible/reduce") +var isError = require("reducible/is-error") "var end = require("reducible/end") function drop(source, n) { /** O Returns sequence of all `source`'s items after `n`-th one. If source contains 1 less then `n` items empty sequence is returned. ## Example 6 print(drop([ 1, 2, 3, 4 ], 2)) // => 2 print(drop([ 1, 2, 3 ], 5)) // => **/ K // If drop `<= 0` then optimize by returning source itself. If `Infinity` // return empty. if (n <= 0) return source $ if (n === Infinity) return void(0) 7 return reducible(function reduceDrop(next, initial) { var count = n = reduce(source, function reduceDropSource(value, result) { J // If value is end of collection or is an error (which also includes L // end of collection) just pass it through, `reducible` will take care // of everything. 3 if (value === end) return next(value, result) 4 if (isError(value)) return next(value, result) G // If count of items has reached `0` just keep on passing values. 1 if (count === 0) return next(value, result) < // Otherwise just decrement count and return `result`. count = count - 1 return result }, initial) }) } module.exports = drop5_ PZ (
"use strict"; &var reducible = require("./reducible") (var accumulate = require("./accumulate") #var isError = require("./is-error") var end = require("./end") function drop(source, n) { /** O Returns sequence of all `source`'s items after `n`-th one. If source contains 1 less then `n` items empty sequence is returned. ## Example 6 print(drop([ 1, 2, 3, 4 ], 2)) // => 2 print(drop([ 1, 2, 3 ], 5)) // => **/ K // If drop `<= 0` then optimize by returning source itself. If `Infinity` // return empty. if (n <= 0) return source $ if (n === Infinity) return void(0) ; return reducible(function accumulateDrop(next, initial) { var count = n E accumulate(source, function accumulateDropSource(value, result) { J // If value is end of collection or is an error (which also includes L // end of collection) just pass it through, `reducible` will take care // of everything. 3 if (value === end) return next(value, result) 4 if (isError(value)) return next(value, result) G // If count of items has reached `0` just keep on passing values. 1 if (count === 0) return next(value, result) < // Otherwise just decrement count and return `result`. count = count - 1 return result }, initial) }) } module.exports = drop5_ ) v P / ! * if (count === 1) next(value, result)5_ ) v P ! ( if (count > 0) next(value, result)5_ ) v P + ! $ if (count === 0) return result5_ ) v P , 5_ ) v P| ) ! " if (count > 0) return result5_ s u v t ) v P_ ! result = next()5_ t u ) v Pd ! " result = next(value, result)5_ e g f & v Px * accumulate(source, function(, value) {5_ 6 8 7 v P4 })va5