Push all elements in `arr` to the end of an array. Mark all Computed Properties as dirty on their way in.
198384
function push(arr){
  var i, len = arr.length;
  this.added || (this.added = {});
  for(i=0;i<len;i++){
    arr[i].markDirty();
    if(this.added[arr[i].cid]) continue;
    this.added[arr[i].cid] = 1;
    this.push(arr[i]);
  }
}
909066
function( arr, results ) {
		var ret = results || [];

		if ( arr != null ) {
			if ( isArraylike( Object(arr) ) ) {
				jQuery.merge( ret,
					typeof arr === "string" ?
					[ arr ] : arr
				);
			} else {
				core_push.call( ret, arr );
			}
		}

		return ret;
	}
279401
function(arr, i) {
			var ret = arr.slice(0);
			for (var j = 0; j < i; j++) {
				ret = [ret[ret.length - 1]].concat(ret.slice(0, ret.length - 1));
			}
			return ret;
		}
906344
function concatAllArray(array) {
  var ret = [];
  for (var ii = 0; ii < array.length; ii++) {
    var value = array[ii];
    if (Array.isArray(value)) {
      push.apply(ret, value);
    } else if (value != null) {
      throw new TypeError(
        'concatAllArray: All items in the array must be an array or null, ' +
        'got "' + value + '" at index "' + ii + '" instead'
      );
    }
  }
  return ret;
}
642890
function(input, shallow, strict, output) {
    if (shallow && _.every(input, _.isArray)) {
      return concat.apply(output, input);
    }
    for (var i = 0, length = input.length; i < length; i++) {
      var value = input[i];
      if (!_.isArray(value) && !_.isArguments(value)) {
        if (!strict) output.push(value);
      } else if (shallow) {
        push.apply(output, value);
      } else {
        flatten(value, shallow, strict, output);
      }
    }
    return output;
  }
632007
function (arr, handler) {
        var tmp = when.defer();
        var index = -1;
        var results = [];

        var doNext = function () {
            try {
                index++;

                if (index > arr.length) {
                    tmp.resolve(results);
                }

                var file = arr[index];
                var promise = handler(file);
                if (promise) {
                    when(promise).then(function (result) {
                        results.push(result);
                        process.nextTick(doNext);
                    }, function () {
                        process.nextTick(doNext);
                    });
//                    when(promise).ensure(function () {
//                        process.nextTick(doNext);
//                    });
                }
                else {
                    //logger.log('skipping bad promise');
                    process.nextTick(doNext);
                }
            }
            catch (ex) {
                logger.error("pdas error: " + ex);
            }
        };

        process.nextTick(doNext);

        return tmp.promise;
    }
193406
function concatStreams(array) {
  var concat = new stream.PassThrough();

  function pipe(i) {
    if (i < array.length - 1) {
      array[i].pipe(concat, {end: false});
      array[i].on('end', function () { pipe(i + 1) });
    } else {
      array[i].pipe(concat);
    }
  }
  if (array.length > 0) {
    pipe(0);
  }

  return concat;
}
394975
function replaceInArray(array, indexToReplace, indexToInsert) {
        var _removedArray = array.splice(indexToReplace, 1);
        array.splice(indexToInsert, 0, _removedArray[0]);
        return array;
    }
1072772
function(arr) {
      var n = [], l=arr.length,i;
      for(i = 0 ; i < l ; i++) {
         if( !lang.isNull(arr[i]) && !lang.isUndefined(arr[i]) ) {
            n.push(arr[i]);
         }
      }
      return n;
   }
851711
function(array) {
    this.destination = this.parse(array)

    // normalize length of arrays
    if (this.value.length != this.destination.length) {
      var lastValue       = this.value[this.value.length - 1]
        , lastDestination = this.destination[this.destination.length - 1]

      while(this.value.length > this.destination.length)
        this.destination.push(lastDestination)
      while(this.value.length < this.destination.length)
        this.value.push(lastValue)
    }

    return this
  }
191305
public static function cleanArray(array &$arr)
    {
        foreach ($arr as $k => $v) {
            if (is_array($v)) {
                self::cleanArray($arr[$k]);
            } else {
                $arr[$k] = stripslashes($v);
            }
        }
    }
1107860
function(arr, func) {
	
	if (arr.map) { return arr.map(func); }
	
	var i, l,
		r = [];
	
	for (i=0, l=arr.length; i<l; i++) {
		r.push(func(arr[i]));
	}
	return r;
}
437814
function concat(res, done) {
  const chunks = []
  res
    .on('data', chunk => {
      chunks.push(chunk)
    })
    .on('end', () => {
      done(Buffer.concat(chunks))
    })
}
910324
function pushTo(array) {
	return map(function (file, cb) {
		array.push(file);
		cb(null, file);
	});
}
950316
function arrayFlatten(arr, level) {
        var self = this;
        var result = [];
        var current = 0;
        level = level || Infinity;

        self._forEach(arr, function (el) {
            if (validateHelpers.isArray(el) && current < level) {
                result = result.concat(self.arrayFlatten(el, level, current + 1));
            } else {
                result.push(el);
            }
        });
        return result;
    }
692736
@SuppressWarnings("unchecked")
   private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
      int i = r.length;
      while (it.hasNext()) {
         int cap = r.length;
         if (i == cap) {
            int newCap = cap + (cap >> 1) + 1;
            // overflow-conscious code
            if (newCap - MAX_ARRAY_SIZE > 0)
               newCap = hugeCapacity(cap + 1);
            r = Arrays.copyOf(r, newCap);
         }
         r[i++] = (T)it.next();
      }
      // trim if overallocated
      return (i == r.length) ? r : Arrays.copyOf(r, i);
   }
537243
function append(baseArr, value) {
    if (Array.isArray(value)) {
        baseArr.push.apply(baseArr, value);
    } else {
        baseArr.push(value);
    }
    return baseArr.length;
}