gravityview / GravityView

vendor/illuminate/support/Traits/Macroable.php

Indentation +65 added lines, -65 removed lines

@@ -7,77 +7,77 @@
 
 trait Macroable
 {
-    /**
-     * The registered string macros.
-     *
-     * @var array
-     */
-    protected static $macros = [];
+	/**
+	 * The registered string macros.
+	 *
+	 * @var array
+	 */
+	protected static $macros = [];
 
-    /**
-     * Register a custom macro.
-     *
-     * @param  string    $name
-     * @param  callable  $macro
-     * @return void
-     */
-    public static function macro($name, callable $macro)
-    {
-        static::$macros[$name] = $macro;
-    }
+	/**
+	 * Register a custom macro.
+	 *
+	 * @param  string    $name
+	 * @param  callable  $macro
+	 * @return void
+	 */
+	public static function macro($name, callable $macro)
+	{
+		static::$macros[$name] = $macro;
+	}
 
-    /**
-     * Checks if macro is registered.
-     *
-     * @param  string  $name
-     * @return bool
-     */
-    public static function hasMacro($name)
-    {
-        return isset(static::$macros[$name]);
-    }
+	/**
+	 * Checks if macro is registered.
+	 *
+	 * @param  string  $name
+	 * @return bool
+	 */
+	public static function hasMacro($name)
+	{
+		return isset(static::$macros[$name]);
+	}
 
-    /**
-     * Dynamically handle calls to the class.
-     *
-     * @param  string  $method
-     * @param  array   $parameters
-     * @return mixed
-     *
-     * @throws \BadMethodCallException
-     */
-    public static function __callStatic($method, $parameters)
-    {
-        if (! static::hasMacro($method)) {
-            throw new BadMethodCallException("Method {$method} does not exist.");
-        }
+	/**
+	 * Dynamically handle calls to the class.
+	 *
+	 * @param  string  $method
+	 * @param  array   $parameters
+	 * @return mixed
+	 *
+	 * @throws \BadMethodCallException
+	 */
+	public static function __callStatic($method, $parameters)
+	{
+		if (! static::hasMacro($method)) {
+			throw new BadMethodCallException("Method {$method} does not exist.");
+		}
 
-        if (static::$macros[$method] instanceof Closure) {
-            return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
-        }
+		if (static::$macros[$method] instanceof Closure) {
+			return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
+		}
 
-        return call_user_func_array(static::$macros[$method], $parameters);
-    }
+		return call_user_func_array(static::$macros[$method], $parameters);
+	}
 
-    /**
-     * Dynamically handle calls to the class.
-     *
-     * @param  string  $method
-     * @param  array   $parameters
-     * @return mixed
-     *
-     * @throws \BadMethodCallException
-     */
-    public function __call($method, $parameters)
-    {
-        if (! static::hasMacro($method)) {
-            throw new BadMethodCallException("Method {$method} does not exist.");
-        }
+	/**
+	 * Dynamically handle calls to the class.
+	 *
+	 * @param  string  $method
+	 * @param  array   $parameters
+	 * @return mixed
+	 *
+	 * @throws \BadMethodCallException
+	 */
+	public function __call($method, $parameters)
+	{
+		if (! static::hasMacro($method)) {
+			throw new BadMethodCallException("Method {$method} does not exist.");
+		}
 
-        if (static::$macros[$method] instanceof Closure) {
-            return call_user_func_array(static::$macros[$method]->bindTo($this, static::class), $parameters);
-        }
+		if (static::$macros[$method] instanceof Closure) {
+			return call_user_func_array(static::$macros[$method]->bindTo($this, static::class), $parameters);
+		}
 
-        return call_user_func_array(static::$macros[$method], $parameters);
-    }
+		return call_user_func_array(static::$macros[$method], $parameters);
+	}
 }

Braces +5 added lines, -10 removed lines

@@ -5,8 +5,7 @@ 
 use Closure;
 use BadMethodCallException;
 
-trait Macroable
-{
+trait Macroable {
     /**
      * The registered string macros.
      *
@@ -21,8 +20,7 @@ 
      * @param  callable  $macro
      * @return void
      */
-    public static function macro($name, callable $macro)
-    {
+    public static function macro($name, callable $macro) {
         static::$macros[$name] = $macro;
     }
 
@@ -32,8 +30,7 @@ 
      * @param  string  $name
      * @return bool
      */
-    public static function hasMacro($name)
-    {
+    public static function hasMacro($name) {
         return isset(static::$macros[$name]);
     }
 
@@ -46,8 +43,7 @@ 
      *
      * @throws \BadMethodCallException
      */
-    public static function __callStatic($method, $parameters)
-    {
+    public static function __callStatic($method, $parameters) {
         if (! static::hasMacro($method)) {
             throw new BadMethodCallException("Method {$method} does not exist.");
         }
@@ -68,8 +64,7 @@ 
      *
      * @throws \BadMethodCallException
      */
-    public function __call($method, $parameters)
-    {
+    public function __call($method, $parameters) {
         if (! static::hasMacro($method)) {
             throw new BadMethodCallException("Method {$method} does not exist.");
         }

vendor/illuminate/support/HigherOrderCollectionProxy.php

Indentation +49 added lines, -49 removed lines

@@ -7,57 +7,57 @@
  */
 class HigherOrderCollectionProxy
 {
-    /**
-     * The collection being operated on.
-     *
-     * @var \Illuminate\Support\Collection
-     */
-    protected $collection;
+	/**
+	 * The collection being operated on.
+	 *
+	 * @var \Illuminate\Support\Collection
+	 */
+	protected $collection;
 
-    /**
-     * The method being proxied.
-     *
-     * @var string
-     */
-    protected $method;
+	/**
+	 * The method being proxied.
+	 *
+	 * @var string
+	 */
+	protected $method;
 
-    /**
-     * Create a new proxy instance.
-     *
-     * @param  \Illuminate\Support\Collection  $collection
-     * @param  string  $method
-     * @return void
-     */
-    public function __construct(Collection $collection, $method)
-    {
-        $this->method = $method;
-        $this->collection = $collection;
-    }
+	/**
+	 * Create a new proxy instance.
+	 *
+	 * @param  \Illuminate\Support\Collection  $collection
+	 * @param  string  $method
+	 * @return void
+	 */
+	public function __construct(Collection $collection, $method)
+	{
+		$this->method = $method;
+		$this->collection = $collection;
+	}
 
-    /**
-     * Proxy accessing an attribute onto the collection items.
-     *
-     * @param  string  $key
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        return $this->collection->{$this->method}(function ($value) use ($key) {
-            return is_array($value) ? $value[$key] : $value->{$key};
-        });
-    }
+	/**
+	 * Proxy accessing an attribute onto the collection items.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		return $this->collection->{$this->method}(function ($value) use ($key) {
+			return is_array($value) ? $value[$key] : $value->{$key};
+		});
+	}
 
-    /**
-     * Proxy a method call onto the collection items.
-     *
-     * @param  string  $method
-     * @param  array  $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
-            return $value->{$method}(...$parameters);
-        });
-    }
+	/**
+	 * Proxy a method call onto the collection items.
+	 *
+	 * @param  string  $method
+	 * @param  array  $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
+			return $value->{$method}(...$parameters);
+		});
+	}
 }

Braces +4 added lines, -8 removed lines

@@ -5,8 +5,7 @@ 
 /**
  * @mixin \Illuminate\Support\Collection
  */
-class HigherOrderCollectionProxy
-{
+class HigherOrderCollectionProxy {
     /**
      * The collection being operated on.
      *
@@ -28,8 +27,7 @@ 
      * @param  string  $method
      * @return void
      */
-    public function __construct(Collection $collection, $method)
-    {
+    public function __construct(Collection $collection, $method) {
         $this->method = $method;
         $this->collection = $collection;
     }
@@ -40,8 +38,7 @@ 
      * @param  string  $key
      * @return mixed
      */
-    public function __get($key)
-    {
+    public function __get($key) {
         return $this->collection->{$this->method}(function ($value) use ($key) {
             return is_array($value) ? $value[$key] : $value->{$key};
         });
@@ -54,8 +51,7 @@ 
      * @param  array  $parameters
      * @return mixed
      */
-    public function __call($method, $parameters)
-    {
+    public function __call($method, $parameters) {
         return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
             return $value->{$method}(...$parameters);
         });

vendor/illuminate/support/Collection.php

Indentation +1636 added lines, -1636 removed lines

@@ -16,1640 +16,1640 @@
 
 class Collection implements ArrayAccess, Arrayable, Countable, IteratorAggregate, Jsonable, JsonSerializable
 {
-    use Macroable;
-
-    /**
-     * The items contained in the collection.
-     *
-     * @var array
-     */
-    protected $items = [];
-
-    /**
-     * The methods that can be proxied.
-     *
-     * @var array
-     */
-    protected static $proxies = [
-        'average', 'avg', 'contains', 'each', 'every', 'filter', 'first', 'flatMap',
-        'map', 'partition', 'reject', 'sortBy', 'sortByDesc', 'sum',
-    ];
-
-    /**
-     * Create a new collection.
-     *
-     * @param  mixed  $items
-     * @return void
-     */
-    public function __construct($items = [])
-    {
-        $this->items = $this->getArrayableItems($items);
-    }
-
-    /**
-     * Create a new collection instance if the value isn't one already.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public static function make($items = [])
-    {
-        return new static($items);
-    }
-
-    /**
-     * Create a new collection by invoking the callback a given number of times.
-     *
-     * @param  int  $number
-     * @param  callable  $callback
-     * @return static
-     */
-    public static function times($number, callable $callback = null)
-    {
-        if ($number < 1) {
-            return new static;
-        }
-
-        if (is_null($callback)) {
-            return new static(range(1, $number));
-        }
-
-        return (new static(range(1, $number)))->map($callback);
-    }
-
-    /**
-     * Get all of the items in the collection.
-     *
-     * @return array
-     */
-    public function all()
-    {
-        return $this->items;
-    }
-
-    /**
-     * Get the average value of a given key.
-     *
-     * @param  callable|string|null  $callback
-     * @return mixed
-     */
-    public function avg($callback = null)
-    {
-        if ($count = $this->count()) {
-            return $this->sum($callback) / $count;
-        }
-    }
-
-    /**
-     * Alias for the "avg" method.
-     *
-     * @param  callable|string|null  $callback
-     * @return mixed
-     */
-    public function average($callback = null)
-    {
-        return $this->avg($callback);
-    }
-
-    /**
-     * Get the median of a given key.
-     *
-     * @param  null $key
-     * @return mixed
-     */
-    public function median($key = null)
-    {
-        $count = $this->count();
-
-        if ($count == 0) {
-            return;
-        }
-
-        $values = with(isset($key) ? $this->pluck($key) : $this)
-                    ->sort()->values();
-
-        $middle = (int) ($count / 2);
-
-        if ($count % 2) {
-            return $values->get($middle);
-        }
-
-        return (new static([
-            $values->get($middle - 1), $values->get($middle),
-        ]))->average();
-    }
-
-    /**
-     * Get the mode of a given key.
-     *
-     * @param  mixed  $key
-     * @return array|null
-     */
-    public function mode($key = null)
-    {
-        $count = $this->count();
-
-        if ($count == 0) {
-            return;
-        }
-
-        $collection = isset($key) ? $this->pluck($key) : $this;
-
-        $counts = new self;
-
-        $collection->each(function ($value) use ($counts) {
-            $counts[$value] = isset($counts[$value]) ? $counts[$value] + 1 : 1;
-        });
-
-        $sorted = $counts->sort();
-
-        $highestValue = $sorted->last();
-
-        return $sorted->filter(function ($value) use ($highestValue) {
-            return $value == $highestValue;
-        })->sort()->keys()->all();
-    }
-
-    /**
-     * Collapse the collection of items into a single array.
-     *
-     * @return static
-     */
-    public function collapse()
-    {
-        return new static(Arr::collapse($this->items));
-    }
-
-    /**
-     * Determine if an item exists in the collection.
-     *
-     * @param  mixed  $key
-     * @param  mixed  $operator
-     * @param  mixed  $value
-     * @return bool
-     */
-    public function contains($key, $operator = null, $value = null)
-    {
-        if (func_num_args() == 1) {
-            if ($this->useAsCallable($key)) {
-                return ! is_null($this->first($key));
-            }
-
-            return in_array($key, $this->items);
-        }
-
-        if (func_num_args() == 2) {
-            $value = $operator;
-
-            $operator = '=';
-        }
-
-        return $this->contains($this->operatorForWhere($key, $operator, $value));
-    }
-
-    /**
-     * Determine if an item exists in the collection using strict comparison.
-     *
-     * @param  mixed  $key
-     * @param  mixed  $value
-     * @return bool
-     */
-    public function containsStrict($key, $value = null)
-    {
-        if (func_num_args() == 2) {
-            return $this->contains(function ($item) use ($key, $value) {
-                return data_get($item, $key) === $value;
-            });
-        }
-
-        if ($this->useAsCallable($key)) {
-            return ! is_null($this->first($key));
-        }
-
-        return in_array($key, $this->items, true);
-    }
-
-    /**
-     * Cross join with the given lists, returning all possible permutations.
-     *
-     * @param  mixed  ...$lists
-     * @return static
-     */
-    public function crossJoin(...$lists)
-    {
-        return new static(Arr::crossJoin(
-            $this->items, ...array_map([$this, 'getArrayableItems'], $lists)
-        ));
-    }
-
-    /**
-     * Get the items in the collection that are not present in the given items.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function diff($items)
-    {
-        return new static(array_diff($this->items, $this->getArrayableItems($items)));
-    }
-
-    /**
-     * Get the items in the collection whose keys and values are not present in the given items.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function diffAssoc($items)
-    {
-        return new static(array_diff_assoc($this->items, $this->getArrayableItems($items)));
-    }
-
-    /**
-     * Get the items in the collection whose keys are not present in the given items.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function diffKeys($items)
-    {
-        return new static(array_diff_key($this->items, $this->getArrayableItems($items)));
-    }
-
-    /**
-     * Execute a callback over each item.
-     *
-     * @param  callable  $callback
-     * @return $this
-     */
-    public function each(callable $callback)
-    {
-        foreach ($this->items as $key => $item) {
-            if ($callback($item, $key) === false) {
-                break;
-            }
-        }
-
-        return $this;
-    }
-
-    /**
-     * Execute a callback over each nested chunk of items.
-     *
-     * @param  callable  $callback
-     * @return static
-     */
-    public function eachSpread(callable $callback)
-    {
-        return $this->each(function ($chunk) use ($callback) {
-            return $callback(...$chunk);
-        });
-    }
-
-    /**
-     * Determine if all items in the collection pass the given test.
-     *
-     * @param  string|callable  $key
-     * @param  mixed  $operator
-     * @param  mixed  $value
-     * @return bool
-     */
-    public function every($key, $operator = null, $value = null)
-    {
-        if (func_num_args() == 1) {
-            $callback = $this->valueRetriever($key);
-
-            foreach ($this->items as $k => $v) {
-                if (! $callback($v, $k)) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        if (func_num_args() == 2) {
-            $value = $operator;
-
-            $operator = '=';
-        }
-
-        return $this->every($this->operatorForWhere($key, $operator, $value));
-    }
-
-    /**
-     * Get all items except for those with the specified keys.
-     *
-     * @param  mixed  $keys
-     * @return static
-     */
-    public function except($keys)
-    {
-        $keys = is_array($keys) ? $keys : func_get_args();
-
-        return new static(Arr::except($this->items, $keys));
-    }
-
-    /**
-     * Run a filter over each of the items.
-     *
-     * @param  callable|null  $callback
-     * @return static
-     */
-    public function filter(callable $callback = null)
-    {
-        if ($callback) {
-            return new static(Arr::where($this->items, $callback));
-        }
-
-        return new static(array_filter($this->items));
-    }
-
-    /**
-     * Apply the callback if the value is truthy.
-     *
-     * @param  bool  $value
-     * @param  callable  $callback
-     * @param  callable  $default
-     * @return mixed
-     */
-    public function when($value, callable $callback, callable $default = null)
-    {
-        if ($value) {
-            return $callback($this);
-        } elseif ($default) {
-            return $default($this);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Apply the callback if the value is falsy.
-     *
-     * @param  bool  $value
-     * @param  callable  $callback
-     * @param  callable  $default
-     * @return mixed
-     */
-    public function unless($value, callable $callback, callable $default = null)
-    {
-        return $this->when(! $value, $callback, $default);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param  string  $key
-     * @param  mixed  $operator
-     * @param  mixed  $value
-     * @return static
-     */
-    public function where($key, $operator, $value = null)
-    {
-        if (func_num_args() == 2) {
-            $value = $operator;
-
-            $operator = '=';
-        }
-
-        return $this->filter($this->operatorForWhere($key, $operator, $value));
-    }
-
-    /**
-     * Get an operator checker callback.
-     *
-     * @param  string  $key
-     * @param  string  $operator
-     * @param  mixed  $value
-     * @return \Closure
-     */
-    protected function operatorForWhere($key, $operator, $value)
-    {
-        return function ($item) use ($key, $operator, $value) {
-            $retrieved = data_get($item, $key);
-
-            switch ($operator) {
-                default:
-                case '=':
-                case '==':  return $retrieved == $value;
-                case '!=':
-                case '<>':  return $retrieved != $value;
-                case '<':   return $retrieved < $value;
-                case '>':   return $retrieved > $value;
-                case '<=':  return $retrieved <= $value;
-                case '>=':  return $retrieved >= $value;
-                case '===': return $retrieved === $value;
-                case '!==': return $retrieved !== $value;
-            }
-        };
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param  string  $key
-     * @param  mixed  $value
-     * @return static
-     */
-    public function whereStrict($key, $value)
-    {
-        return $this->where($key, '===', $value);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param  string  $key
-     * @param  mixed  $values
-     * @param  bool  $strict
-     * @return static
-     */
-    public function whereIn($key, $values, $strict = false)
-    {
-        $values = $this->getArrayableItems($values);
-
-        return $this->filter(function ($item) use ($key, $values, $strict) {
-            return in_array(data_get($item, $key), $values, $strict);
-        });
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param  string  $key
-     * @param  mixed  $values
-     * @return static
-     */
-    public function whereInStrict($key, $values)
-    {
-        return $this->whereIn($key, $values, true);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param  string  $key
-     * @param  mixed  $values
-     * @param  bool  $strict
-     * @return static
-     */
-    public function whereNotIn($key, $values, $strict = false)
-    {
-        $values = $this->getArrayableItems($values);
-
-        return $this->reject(function ($item) use ($key, $values, $strict) {
-            return in_array(data_get($item, $key), $values, $strict);
-        });
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param  string  $key
-     * @param  mixed  $values
-     * @return static
-     */
-    public function whereNotInStrict($key, $values)
-    {
-        return $this->whereNotIn($key, $values, true);
-    }
-
-    /**
-     * Get the first item from the collection.
-     *
-     * @param  callable|null  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public function first(callable $callback = null, $default = null)
-    {
-        return Arr::first($this->items, $callback, $default);
-    }
-
-    /**
-     * Get a flattened array of the items in the collection.
-     *
-     * @param  int  $depth
-     * @return static
-     */
-    public function flatten($depth = INF)
-    {
-        return new static(Arr::flatten($this->items, $depth));
-    }
-
-    /**
-     * Flip the items in the collection.
-     *
-     * @return static
-     */
-    public function flip()
-    {
-        return new static(array_flip($this->items));
-    }
-
-    /**
-     * Remove an item from the collection by key.
-     *
-     * @param  string|array  $keys
-     * @return $this
-     */
-    public function forget($keys)
-    {
-        foreach ((array) $keys as $key) {
-            $this->offsetUnset($key);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Get an item from the collection by key.
-     *
-     * @param  mixed  $key
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public function get($key, $default = null)
-    {
-        if ($this->offsetExists($key)) {
-            return $this->items[$key];
-        }
-
-        return value($default);
-    }
-
-    /**
-     * Group an associative array by a field or using a callback.
-     *
-     * @param  callable|string  $groupBy
-     * @param  bool  $preserveKeys
-     * @return static
-     */
-    public function groupBy($groupBy, $preserveKeys = false)
-    {
-        $groupBy = $this->valueRetriever($groupBy);
-
-        $results = [];
-
-        foreach ($this->items as $key => $value) {
-            $groupKeys = $groupBy($value, $key);
-
-            if (! is_array($groupKeys)) {
-                $groupKeys = [$groupKeys];
-            }
-
-            foreach ($groupKeys as $groupKey) {
-                $groupKey = is_bool($groupKey) ? (int) $groupKey : $groupKey;
-
-                if (! array_key_exists($groupKey, $results)) {
-                    $results[$groupKey] = new static;
-                }
-
-                $results[$groupKey]->offsetSet($preserveKeys ? $key : null, $value);
-            }
-        }
-
-        return new static($results);
-    }
-
-    /**
-     * Key an associative array by a field or using a callback.
-     *
-     * @param  callable|string  $keyBy
-     * @return static
-     */
-    public function keyBy($keyBy)
-    {
-        $keyBy = $this->valueRetriever($keyBy);
-
-        $results = [];
-
-        foreach ($this->items as $key => $item) {
-            $resolvedKey = $keyBy($item, $key);
-
-            if (is_object($resolvedKey)) {
-                $resolvedKey = (string) $resolvedKey;
-            }
-
-            $results[$resolvedKey] = $item;
-        }
-
-        return new static($results);
-    }
-
-    /**
-     * Determine if an item exists in the collection by key.
-     *
-     * @param  mixed  $key
-     * @return bool
-     */
-    public function has($key)
-    {
-        return $this->offsetExists($key);
-    }
-
-    /**
-     * Concatenate values of a given key as a string.
-     *
-     * @param  string  $value
-     * @param  string  $glue
-     * @return string
-     */
-    public function implode($value, $glue = null)
-    {
-        $first = $this->first();
-
-        if (is_array($first) || is_object($first)) {
-            return implode($glue, $this->pluck($value)->all());
-        }
-
-        return implode($value, $this->items);
-    }
-
-    /**
-     * Intersect the collection with the given items.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function intersect($items)
-    {
-        return new static(array_intersect($this->items, $this->getArrayableItems($items)));
-    }
-
-    /**
-     * Intersect the collection with the given items by key.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function intersectKey($items)
-    {
-        return new static(array_intersect_key($this->items, $this->getArrayableItems($items)));
-    }
-
-    /**
-     * Determine if the collection is empty or not.
-     *
-     * @return bool
-     */
-    public function isEmpty()
-    {
-        return empty($this->items);
-    }
-
-    /**
-     * Determine if the collection is not empty.
-     *
-     * @return bool
-     */
-    public function isNotEmpty()
-    {
-        return ! $this->isEmpty();
-    }
-
-    /**
-     * Determine if the given value is callable, but not a string.
-     *
-     * @param  mixed  $value
-     * @return bool
-     */
-    protected function useAsCallable($value)
-    {
-        return ! is_string($value) && is_callable($value);
-    }
-
-    /**
-     * Get the keys of the collection items.
-     *
-     * @return static
-     */
-    public function keys()
-    {
-        return new static(array_keys($this->items));
-    }
-
-    /**
-     * Get the last item from the collection.
-     *
-     * @param  callable|null  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public function last(callable $callback = null, $default = null)
-    {
-        return Arr::last($this->items, $callback, $default);
-    }
-
-    /**
-     * Get the values of a given key.
-     *
-     * @param  string|array  $value
-     * @param  string|null  $key
-     * @return static
-     */
-    public function pluck($value, $key = null)
-    {
-        return new static(Arr::pluck($this->items, $value, $key));
-    }
-
-    /**
-     * Run a map over each of the items.
-     *
-     * @param  callable  $callback
-     * @return static
-     */
-    public function map(callable $callback)
-    {
-        $keys = array_keys($this->items);
-
-        $items = array_map($callback, $this->items, $keys);
-
-        return new static(array_combine($keys, $items));
-    }
-
-    /**
-     * Run a map over each nested chunk of items.
-     *
-     * @param  callable  $callback
-     * @return static
-     */
-    public function mapSpread(callable $callback)
-    {
-        return $this->map(function ($chunk) use ($callback) {
-            return $callback(...$chunk);
-        });
-    }
-
-    /**
-     * Run a grouping map over the items.
-     *
-     * The callback should return an associative array with a single key/value pair.
-     *
-     * @param  callable  $callback
-     * @return static
-     */
-    public function mapToGroups(callable $callback)
-    {
-        $groups = $this->map($callback)->reduce(function ($groups, $pair) {
-            $groups[key($pair)][] = reset($pair);
-
-            return $groups;
-        }, []);
-
-        return (new static($groups))->map([$this, 'make']);
-    }
-
-    /**
-     * Run an associative map over each of the items.
-     *
-     * The callback should return an associative array with a single key/value pair.
-     *
-     * @param  callable  $callback
-     * @return static
-     */
-    public function mapWithKeys(callable $callback)
-    {
-        $result = [];
-
-        foreach ($this->items as $key => $value) {
-            $assoc = $callback($value, $key);
-
-            foreach ($assoc as $mapKey => $mapValue) {
-                $result[$mapKey] = $mapValue;
-            }
-        }
-
-        return new static($result);
-    }
-
-    /**
-     * Map a collection and flatten the result by a single level.
-     *
-     * @param  callable  $callback
-     * @return static
-     */
-    public function flatMap(callable $callback)
-    {
-        return $this->map($callback)->collapse();
-    }
-
-    /**
-     * Get the max value of a given key.
-     *
-     * @param  callable|string|null  $callback
-     * @return mixed
-     */
-    public function max($callback = null)
-    {
-        $callback = $this->valueRetriever($callback);
-
-        return $this->filter(function ($value) {
-            return ! is_null($value);
-        })->reduce(function ($result, $item) use ($callback) {
-            $value = $callback($item);
-
-            return is_null($result) || $value > $result ? $value : $result;
-        });
-    }
-
-    /**
-     * Merge the collection with the given items.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function merge($items)
-    {
-        return new static(array_merge($this->items, $this->getArrayableItems($items)));
-    }
-
-    /**
-     * Create a collection by using this collection for keys and another for its values.
-     *
-     * @param  mixed  $values
-     * @return static
-     */
-    public function combine($values)
-    {
-        return new static(array_combine($this->all(), $this->getArrayableItems($values)));
-    }
-
-    /**
-     * Union the collection with the given items.
-     *
-     * @param  mixed  $items
-     * @return static
-     */
-    public function union($items)
-    {
-        return new static($this->items + $this->getArrayableItems($items));
-    }
-
-    /**
-     * Get the min value of a given key.
-     *
-     * @param  callable|string|null  $callback
-     * @return mixed
-     */
-    public function min($callback = null)
-    {
-        $callback = $this->valueRetriever($callback);
-
-        return $this->filter(function ($value) {
-            return ! is_null($value);
-        })->reduce(function ($result, $item) use ($callback) {
-            $value = $callback($item);
-
-            return is_null($result) || $value < $result ? $value : $result;
-        });
-    }
-
-    /**
-     * Create a new collection consisting of every n-th element.
-     *
-     * @param  int  $step
-     * @param  int  $offset
-     * @return static
-     */
-    public function nth($step, $offset = 0)
-    {
-        $new = [];
-
-        $position = 0;
-
-        foreach ($this->items as $item) {
-            if ($position % $step === $offset) {
-                $new[] = $item;
-            }
-
-            $position++;
-        }
-
-        return new static($new);
-    }
-
-    /**
-     * Get the items with the specified keys.
-     *
-     * @param  mixed  $keys
-     * @return static
-     */
-    public function only($keys)
-    {
-        if (is_null($keys)) {
-            return new static($this->items);
-        }
-
-        $keys = is_array($keys) ? $keys : func_get_args();
-
-        return new static(Arr::only($this->items, $keys));
-    }
-
-    /**
-     * "Paginate" the collection by slicing it into a smaller collection.
-     *
-     * @param  int  $page
-     * @param  int  $perPage
-     * @return static
-     */
-    public function forPage($page, $perPage)
-    {
-        return $this->slice(($page - 1) * $perPage, $perPage);
-    }
-
-    /**
-     * Partition the collection into two arrays using the given callback or key.
-     *
-     * @param  callable|string  $callback
-     * @return static
-     */
-    public function partition($callback)
-    {
-        $partitions = [new static, new static];
-
-        $callback = $this->valueRetriever($callback);
-
-        foreach ($this->items as $key => $item) {
-            $partitions[(int) ! $callback($item)][$key] = $item;
-        }
-
-        return new static($partitions);
-    }
-
-    /**
-     * Pass the collection to the given callback and return the result.
-     *
-     * @param  callable $callback
-     * @return mixed
-     */
-    public function pipe(callable $callback)
-    {
-        return $callback($this);
-    }
-
-    /**
-     * Get and remove the last item from the collection.
-     *
-     * @return mixed
-     */
-    public function pop()
-    {
-        return array_pop($this->items);
-    }
-
-    /**
-     * Push an item onto the beginning of the collection.
-     *
-     * @param  mixed  $value
-     * @param  mixed  $key
-     * @return $this
-     */
-    public function prepend($value, $key = null)
-    {
-        $this->items = Arr::prepend($this->items, $value, $key);
-
-        return $this;
-    }
-
-    /**
-     * Push an item onto the end of the collection.
-     *
-     * @param  mixed  $value
-     * @return $this
-     */
-    public function push($value)
-    {
-        $this->offsetSet(null, $value);
-
-        return $this;
-    }
-
-    /**
-     * Push all of the given items onto the collection.
-     *
-     * @param  \Traversable  $source
-     * @return self
-     */
-    public function concat($source)
-    {
-        $result = new static($this);
-
-        foreach ($source as $item) {
-            $result->push($item);
-        }
-
-        return $result;
-    }
-
-    /**
-     * Get and remove an item from the collection.
-     *
-     * @param  mixed  $key
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public function pull($key, $default = null)
-    {
-        return Arr::pull($this->items, $key, $default);
-    }
-
-    /**
-     * Put an item in the collection by key.
-     *
-     * @param  mixed  $key
-     * @param  mixed  $value
-     * @return $this
-     */
-    public function put($key, $value)
-    {
-        $this->offsetSet($key, $value);
-
-        return $this;
-    }
-
-    /**
-     * Get one or a specified number of items randomly from the collection.
-     *
-     * @param  int|null  $number
-     * @return mixed
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function random($number = null)
-    {
-        if (is_null($number)) {
-            return Arr::random($this->items);
-        }
-
-        return new static(Arr::random($this->items, $number));
-    }
-
-    /**
-     * Reduce the collection to a single value.
-     *
-     * @param  callable  $callback
-     * @param  mixed  $initial
-     * @return mixed
-     */
-    public function reduce(callable $callback, $initial = null)
-    {
-        return array_reduce($this->items, $callback, $initial);
-    }
-
-    /**
-     * Create a collection of all elements that do not pass a given truth test.
-     *
-     * @param  callable|mixed  $callback
-     * @return static
-     */
-    public function reject($callback)
-    {
-        if ($this->useAsCallable($callback)) {
-            return $this->filter(function ($value, $key) use ($callback) {
-                return ! $callback($value, $key);
-            });
-        }
-
-        return $this->filter(function ($item) use ($callback) {
-            return $item != $callback;
-        });
-    }
-
-    /**
-     * Reverse items order.
-     *
-     * @return static
-     */
-    public function reverse()
-    {
-        return new static(array_reverse($this->items, true));
-    }
-
-    /**
-     * Search the collection for a given value and return the corresponding key if successful.
-     *
-     * @param  mixed  $value
-     * @param  bool  $strict
-     * @return mixed
-     */
-    public function search($value, $strict = false)
-    {
-        if (! $this->useAsCallable($value)) {
-            return array_search($value, $this->items, $strict);
-        }
-
-        foreach ($this->items as $key => $item) {
-            if (call_user_func($value, $item, $key)) {
-                return $key;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Get and remove the first item from the collection.
-     *
-     * @return mixed
-     */
-    public function shift()
-    {
-        return array_shift($this->items);
-    }
-
-    /**
-     * Shuffle the items in the collection.
-     *
-     * @param  int  $seed
-     * @return static
-     */
-    public function shuffle($seed = null)
-    {
-        $items = $this->items;
-
-        if (is_null($seed)) {
-            shuffle($items);
-        } else {
-            srand($seed);
-
-            usort($items, function () {
-                return rand(-1, 1);
-            });
-        }
-
-        return new static($items);
-    }
-
-    /**
-     * Slice the underlying collection array.
-     *
-     * @param  int  $offset
-     * @param  int  $length
-     * @return static
-     */
-    public function slice($offset, $length = null)
-    {
-        return new static(array_slice($this->items, $offset, $length, true));
-    }
-
-    /**
-     * Split a collection into a certain number of groups.
-     *
-     * @param  int  $numberOfGroups
-     * @return static
-     */
-    public function split($numberOfGroups)
-    {
-        if ($this->isEmpty()) {
-            return new static;
-        }
-
-        $groupSize = ceil($this->count() / $numberOfGroups);
-
-        return $this->chunk($groupSize);
-    }
-
-    /**
-     * Chunk the underlying collection array.
-     *
-     * @param  int  $size
-     * @return static
-     */
-    public function chunk($size)
-    {
-        if ($size <= 0) {
-            return new static;
-        }
-
-        $chunks = [];
-
-        foreach (array_chunk($this->items, $size, true) as $chunk) {
-            $chunks[] = new static($chunk);
-        }
-
-        return new static($chunks);
-    }
-
-    /**
-     * Sort through each item with a callback.
-     *
-     * @param  callable|null  $callback
-     * @return static
-     */
-    public function sort(callable $callback = null)
-    {
-        $items = $this->items;
-
-        $callback
-            ? uasort($items, $callback)
-            : asort($items);
-
-        return new static($items);
-    }
-
-    /**
-     * Sort the collection using the given callback.
-     *
-     * @param  callable|string  $callback
-     * @param  int  $options
-     * @param  bool  $descending
-     * @return static
-     */
-    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
-    {
-        $results = [];
-
-        $callback = $this->valueRetriever($callback);
-
-        // First we will loop through the items and get the comparator from a callback
-        // function which we were given. Then, we will sort the returned values and
-        // and grab the corresponding values for the sorted keys from this array.
-        foreach ($this->items as $key => $value) {
-            $results[$key] = $callback($value, $key);
-        }
-
-        $descending ? arsort($results, $options)
-                    : asort($results, $options);
-
-        // Once we have sorted all of the keys in the array, we will loop through them
-        // and grab the corresponding model so we can set the underlying items list
-        // to the sorted version. Then we'll just return the collection instance.
-        foreach (array_keys($results) as $key) {
-            $results[$key] = $this->items[$key];
-        }
-
-        return new static($results);
-    }
-
-    /**
-     * Sort the collection in descending order using the given callback.
-     *
-     * @param  callable|string  $callback
-     * @param  int  $options
-     * @return static
-     */
-    public function sortByDesc($callback, $options = SORT_REGULAR)
-    {
-        return $this->sortBy($callback, $options, true);
-    }
-
-    /**
-     * Splice a portion of the underlying collection array.
-     *
-     * @param  int  $offset
-     * @param  int|null  $length
-     * @param  mixed  $replacement
-     * @return static
-     */
-    public function splice($offset, $length = null, $replacement = [])
-    {
-        if (func_num_args() == 1) {
-            return new static(array_splice($this->items, $offset));
-        }
-
-        return new static(array_splice($this->items, $offset, $length, $replacement));
-    }
-
-    /**
-     * Get the sum of the given values.
-     *
-     * @param  callable|string|null  $callback
-     * @return mixed
-     */
-    public function sum($callback = null)
-    {
-        if (is_null($callback)) {
-            return array_sum($this->items);
-        }
-
-        $callback = $this->valueRetriever($callback);
-
-        return $this->reduce(function ($result, $item) use ($callback) {
-            return $result + $callback($item);
-        }, 0);
-    }
-
-    /**
-     * Take the first or last {$limit} items.
-     *
-     * @param  int  $limit
-     * @return static
-     */
-    public function take($limit)
-    {
-        if ($limit < 0) {
-            return $this->slice($limit, abs($limit));
-        }
-
-        return $this->slice(0, $limit);
-    }
-
-    /**
-     * Pass the collection to the given callback and then return it.
-     *
-     * @param  callable  $callback
-     * @return $this
-     */
-    public function tap(callable $callback)
-    {
-        $callback(new static($this->items));
-
-        return $this;
-    }
-
-    /**
-     * Transform each item in the collection using a callback.
-     *
-     * @param  callable  $callback
-     * @return $this
-     */
-    public function transform(callable $callback)
-    {
-        $this->items = $this->map($callback)->all();
-
-        return $this;
-    }
-
-    /**
-     * Return only unique items from the collection array.
-     *
-     * @param  string|callable|null  $key
-     * @param  bool  $strict
-     * @return static
-     */
-    public function unique($key = null, $strict = false)
-    {
-        if (is_null($key)) {
-            return new static(array_unique($this->items, SORT_REGULAR));
-        }
-
-        $callback = $this->valueRetriever($key);
-
-        $exists = [];
-
-        return $this->reject(function ($item, $key) use ($callback, $strict, &$exists) {
-            if (in_array($id = $callback($item, $key), $exists, $strict)) {
-                return true;
-            }
-
-            $exists[] = $id;
-        });
-    }
-
-    /**
-     * Return only unique items from the collection array using strict comparison.
-     *
-     * @param  string|callable|null  $key
-     * @return static
-     */
-    public function uniqueStrict($key = null)
-    {
-        return $this->unique($key, true);
-    }
-
-    /**
-     * Reset the keys on the underlying array.
-     *
-     * @return static
-     */
-    public function values()
-    {
-        return new static(array_values($this->items));
-    }
-
-    /**
-     * Get a value retrieving callback.
-     *
-     * @param  string  $value
-     * @return callable
-     */
-    protected function valueRetriever($value)
-    {
-        if ($this->useAsCallable($value)) {
-            return $value;
-        }
-
-        return function ($item) use ($value) {
-            return data_get($item, $value);
-        };
-    }
-
-    /**
-     * Zip the collection together with one or more arrays.
-     *
-     * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]);
-     *      => [[1, 4], [2, 5], [3, 6]]
-     *
-     * @param  mixed ...$items
-     * @return static
-     */
-    public function zip($items)
-    {
-        $arrayableItems = array_map(function ($items) {
-            return $this->getArrayableItems($items);
-        }, func_get_args());
-
-        $params = array_merge([function () {
-            return new static(func_get_args());
-        }, $this->items], $arrayableItems);
-
-        return new static(call_user_func_array('array_map', $params));
-    }
-
-    /**
-     * Get the collection of items as a plain array.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        return array_map(function ($value) {
-            return $value instanceof Arrayable ? $value->toArray() : $value;
-        }, $this->items);
-    }
-
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        return array_map(function ($value) {
-            if ($value instanceof JsonSerializable) {
-                return $value->jsonSerialize();
-            } elseif ($value instanceof Jsonable) {
-                return json_decode($value->toJson(), true);
-            } elseif ($value instanceof Arrayable) {
-                return $value->toArray();
-            } else {
-                return $value;
-            }
-        }, $this->items);
-    }
-
-    /**
-     * Get the collection of items as JSON.
-     *
-     * @param  int  $options
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        return json_encode($this->jsonSerialize(), $options);
-    }
-
-    /**
-     * Get an iterator for the items.
-     *
-     * @return \ArrayIterator
-     */
-    public function getIterator()
-    {
-        return new ArrayIterator($this->items);
-    }
-
-    /**
-     * Get a CachingIterator instance.
-     *
-     * @param  int  $flags
-     * @return \CachingIterator
-     */
-    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
-    {
-        return new CachingIterator($this->getIterator(), $flags);
-    }
-
-    /**
-     * Count the number of items in the collection.
-     *
-     * @return int
-     */
-    public function count()
-    {
-        return count($this->items);
-    }
-
-    /**
-     * Get a base Support collection instance from this collection.
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function toBase()
-    {
-        return new self($this);
-    }
-
-    /**
-     * Determine if an item exists at an offset.
-     *
-     * @param  mixed  $key
-     * @return bool
-     */
-    public function offsetExists($key)
-    {
-        return array_key_exists($key, $this->items);
-    }
-
-    /**
-     * Get an item at a given offset.
-     *
-     * @param  mixed  $key
-     * @return mixed
-     */
-    public function offsetGet($key)
-    {
-        return $this->items[$key];
-    }
-
-    /**
-     * Set the item at a given offset.
-     *
-     * @param  mixed  $key
-     * @param  mixed  $value
-     * @return void
-     */
-    public function offsetSet($key, $value)
-    {
-        if (is_null($key)) {
-            $this->items[] = $value;
-        } else {
-            $this->items[$key] = $value;
-        }
-    }
-
-    /**
-     * Unset the item at a given offset.
-     *
-     * @param  string  $key
-     * @return void
-     */
-    public function offsetUnset($key)
-    {
-        unset($this->items[$key]);
-    }
-
-    /**
-     * Convert the collection to its string representation.
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->toJson();
-    }
-
-    /**
-     * Results array of items from Collection or Arrayable.
-     *
-     * @param  mixed  $items
-     * @return array
-     */
-    protected function getArrayableItems($items)
-    {
-        if (is_array($items)) {
-            return $items;
-        } elseif ($items instanceof self) {
-            return $items->all();
-        } elseif ($items instanceof Arrayable) {
-            return $items->toArray();
-        } elseif ($items instanceof Jsonable) {
-            return json_decode($items->toJson(), true);
-        } elseif ($items instanceof JsonSerializable) {
-            return $items->jsonSerialize();
-        } elseif ($items instanceof Traversable) {
-            return iterator_to_array($items);
-        }
-
-        return (array) $items;
-    }
-
-    /**
-     * Add a method to the list of proxied methods.
-     *
-     * @param  string  $method
-     * @return void
-     */
-    public static function proxy($method)
-    {
-        static::$proxies[] = $method;
-    }
-
-    /**
-     * Dynamically access collection proxies.
-     *
-     * @param  string  $key
-     * @return mixed
-     *
-     * @throws \Exception
-     */
-    public function __get($key)
-    {
-        if (! in_array($key, static::$proxies)) {
-            throw new Exception("Property [{$key}] does not exist on this collection instance.");
-        }
-
-        return new HigherOrderCollectionProxy($this, $key);
-    }
+	use Macroable;
+
+	/**
+	 * The items contained in the collection.
+	 *
+	 * @var array
+	 */
+	protected $items = [];
+
+	/**
+	 * The methods that can be proxied.
+	 *
+	 * @var array
+	 */
+	protected static $proxies = [
+		'average', 'avg', 'contains', 'each', 'every', 'filter', 'first', 'flatMap',
+		'map', 'partition', 'reject', 'sortBy', 'sortByDesc', 'sum',
+	];
+
+	/**
+	 * Create a new collection.
+	 *
+	 * @param  mixed  $items
+	 * @return void
+	 */
+	public function __construct($items = [])
+	{
+		$this->items = $this->getArrayableItems($items);
+	}
+
+	/**
+	 * Create a new collection instance if the value isn't one already.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public static function make($items = [])
+	{
+		return new static($items);
+	}
+
+	/**
+	 * Create a new collection by invoking the callback a given number of times.
+	 *
+	 * @param  int  $number
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public static function times($number, callable $callback = null)
+	{
+		if ($number < 1) {
+			return new static;
+		}
+
+		if (is_null($callback)) {
+			return new static(range(1, $number));
+		}
+
+		return (new static(range(1, $number)))->map($callback);
+	}
+
+	/**
+	 * Get all of the items in the collection.
+	 *
+	 * @return array
+	 */
+	public function all()
+	{
+		return $this->items;
+	}
+
+	/**
+	 * Get the average value of a given key.
+	 *
+	 * @param  callable|string|null  $callback
+	 * @return mixed
+	 */
+	public function avg($callback = null)
+	{
+		if ($count = $this->count()) {
+			return $this->sum($callback) / $count;
+		}
+	}
+
+	/**
+	 * Alias for the "avg" method.
+	 *
+	 * @param  callable|string|null  $callback
+	 * @return mixed
+	 */
+	public function average($callback = null)
+	{
+		return $this->avg($callback);
+	}
+
+	/**
+	 * Get the median of a given key.
+	 *
+	 * @param  null $key
+	 * @return mixed
+	 */
+	public function median($key = null)
+	{
+		$count = $this->count();
+
+		if ($count == 0) {
+			return;
+		}
+
+		$values = with(isset($key) ? $this->pluck($key) : $this)
+					->sort()->values();
+
+		$middle = (int) ($count / 2);
+
+		if ($count % 2) {
+			return $values->get($middle);
+		}
+
+		return (new static([
+			$values->get($middle - 1), $values->get($middle),
+		]))->average();
+	}
+
+	/**
+	 * Get the mode of a given key.
+	 *
+	 * @param  mixed  $key
+	 * @return array|null
+	 */
+	public function mode($key = null)
+	{
+		$count = $this->count();
+
+		if ($count == 0) {
+			return;
+		}
+
+		$collection = isset($key) ? $this->pluck($key) : $this;
+
+		$counts = new self;
+
+		$collection->each(function ($value) use ($counts) {
+			$counts[$value] = isset($counts[$value]) ? $counts[$value] + 1 : 1;
+		});
+
+		$sorted = $counts->sort();
+
+		$highestValue = $sorted->last();
+
+		return $sorted->filter(function ($value) use ($highestValue) {
+			return $value == $highestValue;
+		})->sort()->keys()->all();
+	}
+
+	/**
+	 * Collapse the collection of items into a single array.
+	 *
+	 * @return static
+	 */
+	public function collapse()
+	{
+		return new static(Arr::collapse($this->items));
+	}
+
+	/**
+	 * Determine if an item exists in the collection.
+	 *
+	 * @param  mixed  $key
+	 * @param  mixed  $operator
+	 * @param  mixed  $value
+	 * @return bool
+	 */
+	public function contains($key, $operator = null, $value = null)
+	{
+		if (func_num_args() == 1) {
+			if ($this->useAsCallable($key)) {
+				return ! is_null($this->first($key));
+			}
+
+			return in_array($key, $this->items);
+		}
+
+		if (func_num_args() == 2) {
+			$value = $operator;
+
+			$operator = '=';
+		}
+
+		return $this->contains($this->operatorForWhere($key, $operator, $value));
+	}
+
+	/**
+	 * Determine if an item exists in the collection using strict comparison.
+	 *
+	 * @param  mixed  $key
+	 * @param  mixed  $value
+	 * @return bool
+	 */
+	public function containsStrict($key, $value = null)
+	{
+		if (func_num_args() == 2) {
+			return $this->contains(function ($item) use ($key, $value) {
+				return data_get($item, $key) === $value;
+			});
+		}
+
+		if ($this->useAsCallable($key)) {
+			return ! is_null($this->first($key));
+		}
+
+		return in_array($key, $this->items, true);
+	}
+
+	/**
+	 * Cross join with the given lists, returning all possible permutations.
+	 *
+	 * @param  mixed  ...$lists
+	 * @return static
+	 */
+	public function crossJoin(...$lists)
+	{
+		return new static(Arr::crossJoin(
+			$this->items, ...array_map([$this, 'getArrayableItems'], $lists)
+		));
+	}
+
+	/**
+	 * Get the items in the collection that are not present in the given items.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function diff($items)
+	{
+		return new static(array_diff($this->items, $this->getArrayableItems($items)));
+	}
+
+	/**
+	 * Get the items in the collection whose keys and values are not present in the given items.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function diffAssoc($items)
+	{
+		return new static(array_diff_assoc($this->items, $this->getArrayableItems($items)));
+	}
+
+	/**
+	 * Get the items in the collection whose keys are not present in the given items.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function diffKeys($items)
+	{
+		return new static(array_diff_key($this->items, $this->getArrayableItems($items)));
+	}
+
+	/**
+	 * Execute a callback over each item.
+	 *
+	 * @param  callable  $callback
+	 * @return $this
+	 */
+	public function each(callable $callback)
+	{
+		foreach ($this->items as $key => $item) {
+			if ($callback($item, $key) === false) {
+				break;
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Execute a callback over each nested chunk of items.
+	 *
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public function eachSpread(callable $callback)
+	{
+		return $this->each(function ($chunk) use ($callback) {
+			return $callback(...$chunk);
+		});
+	}
+
+	/**
+	 * Determine if all items in the collection pass the given test.
+	 *
+	 * @param  string|callable  $key
+	 * @param  mixed  $operator
+	 * @param  mixed  $value
+	 * @return bool
+	 */
+	public function every($key, $operator = null, $value = null)
+	{
+		if (func_num_args() == 1) {
+			$callback = $this->valueRetriever($key);
+
+			foreach ($this->items as $k => $v) {
+				if (! $callback($v, $k)) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		if (func_num_args() == 2) {
+			$value = $operator;
+
+			$operator = '=';
+		}
+
+		return $this->every($this->operatorForWhere($key, $operator, $value));
+	}
+
+	/**
+	 * Get all items except for those with the specified keys.
+	 *
+	 * @param  mixed  $keys
+	 * @return static
+	 */
+	public function except($keys)
+	{
+		$keys = is_array($keys) ? $keys : func_get_args();
+
+		return new static(Arr::except($this->items, $keys));
+	}
+
+	/**
+	 * Run a filter over each of the items.
+	 *
+	 * @param  callable|null  $callback
+	 * @return static
+	 */
+	public function filter(callable $callback = null)
+	{
+		if ($callback) {
+			return new static(Arr::where($this->items, $callback));
+		}
+
+		return new static(array_filter($this->items));
+	}
+
+	/**
+	 * Apply the callback if the value is truthy.
+	 *
+	 * @param  bool  $value
+	 * @param  callable  $callback
+	 * @param  callable  $default
+	 * @return mixed
+	 */
+	public function when($value, callable $callback, callable $default = null)
+	{
+		if ($value) {
+			return $callback($this);
+		} elseif ($default) {
+			return $default($this);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Apply the callback if the value is falsy.
+	 *
+	 * @param  bool  $value
+	 * @param  callable  $callback
+	 * @param  callable  $default
+	 * @return mixed
+	 */
+	public function unless($value, callable $callback, callable $default = null)
+	{
+		return $this->when(! $value, $callback, $default);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $operator
+	 * @param  mixed  $value
+	 * @return static
+	 */
+	public function where($key, $operator, $value = null)
+	{
+		if (func_num_args() == 2) {
+			$value = $operator;
+
+			$operator = '=';
+		}
+
+		return $this->filter($this->operatorForWhere($key, $operator, $value));
+	}
+
+	/**
+	 * Get an operator checker callback.
+	 *
+	 * @param  string  $key
+	 * @param  string  $operator
+	 * @param  mixed  $value
+	 * @return \Closure
+	 */
+	protected function operatorForWhere($key, $operator, $value)
+	{
+		return function ($item) use ($key, $operator, $value) {
+			$retrieved = data_get($item, $key);
+
+			switch ($operator) {
+				default:
+				case '=':
+				case '==':  return $retrieved == $value;
+				case '!=':
+				case '<>':  return $retrieved != $value;
+				case '<':   return $retrieved < $value;
+				case '>':   return $retrieved > $value;
+				case '<=':  return $retrieved <= $value;
+				case '>=':  return $retrieved >= $value;
+				case '===': return $retrieved === $value;
+				case '!==': return $retrieved !== $value;
+			}
+		};
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return static
+	 */
+	public function whereStrict($key, $value)
+	{
+		return $this->where($key, '===', $value);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $values
+	 * @param  bool  $strict
+	 * @return static
+	 */
+	public function whereIn($key, $values, $strict = false)
+	{
+		$values = $this->getArrayableItems($values);
+
+		return $this->filter(function ($item) use ($key, $values, $strict) {
+			return in_array(data_get($item, $key), $values, $strict);
+		});
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $values
+	 * @return static
+	 */
+	public function whereInStrict($key, $values)
+	{
+		return $this->whereIn($key, $values, true);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $values
+	 * @param  bool  $strict
+	 * @return static
+	 */
+	public function whereNotIn($key, $values, $strict = false)
+	{
+		$values = $this->getArrayableItems($values);
+
+		return $this->reject(function ($item) use ($key, $values, $strict) {
+			return in_array(data_get($item, $key), $values, $strict);
+		});
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $values
+	 * @return static
+	 */
+	public function whereNotInStrict($key, $values)
+	{
+		return $this->whereNotIn($key, $values, true);
+	}
+
+	/**
+	 * Get the first item from the collection.
+	 *
+	 * @param  callable|null  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public function first(callable $callback = null, $default = null)
+	{
+		return Arr::first($this->items, $callback, $default);
+	}
+
+	/**
+	 * Get a flattened array of the items in the collection.
+	 *
+	 * @param  int  $depth
+	 * @return static
+	 */
+	public function flatten($depth = INF)
+	{
+		return new static(Arr::flatten($this->items, $depth));
+	}
+
+	/**
+	 * Flip the items in the collection.
+	 *
+	 * @return static
+	 */
+	public function flip()
+	{
+		return new static(array_flip($this->items));
+	}
+
+	/**
+	 * Remove an item from the collection by key.
+	 *
+	 * @param  string|array  $keys
+	 * @return $this
+	 */
+	public function forget($keys)
+	{
+		foreach ((array) $keys as $key) {
+			$this->offsetUnset($key);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Get an item from the collection by key.
+	 *
+	 * @param  mixed  $key
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null)
+	{
+		if ($this->offsetExists($key)) {
+			return $this->items[$key];
+		}
+
+		return value($default);
+	}
+
+	/**
+	 * Group an associative array by a field or using a callback.
+	 *
+	 * @param  callable|string  $groupBy
+	 * @param  bool  $preserveKeys
+	 * @return static
+	 */
+	public function groupBy($groupBy, $preserveKeys = false)
+	{
+		$groupBy = $this->valueRetriever($groupBy);
+
+		$results = [];
+
+		foreach ($this->items as $key => $value) {
+			$groupKeys = $groupBy($value, $key);
+
+			if (! is_array($groupKeys)) {
+				$groupKeys = [$groupKeys];
+			}
+
+			foreach ($groupKeys as $groupKey) {
+				$groupKey = is_bool($groupKey) ? (int) $groupKey : $groupKey;
+
+				if (! array_key_exists($groupKey, $results)) {
+					$results[$groupKey] = new static;
+				}
+
+				$results[$groupKey]->offsetSet($preserveKeys ? $key : null, $value);
+			}
+		}
+
+		return new static($results);
+	}
+
+	/**
+	 * Key an associative array by a field or using a callback.
+	 *
+	 * @param  callable|string  $keyBy
+	 * @return static
+	 */
+	public function keyBy($keyBy)
+	{
+		$keyBy = $this->valueRetriever($keyBy);
+
+		$results = [];
+
+		foreach ($this->items as $key => $item) {
+			$resolvedKey = $keyBy($item, $key);
+
+			if (is_object($resolvedKey)) {
+				$resolvedKey = (string) $resolvedKey;
+			}
+
+			$results[$resolvedKey] = $item;
+		}
+
+		return new static($results);
+	}
+
+	/**
+	 * Determine if an item exists in the collection by key.
+	 *
+	 * @param  mixed  $key
+	 * @return bool
+	 */
+	public function has($key)
+	{
+		return $this->offsetExists($key);
+	}
+
+	/**
+	 * Concatenate values of a given key as a string.
+	 *
+	 * @param  string  $value
+	 * @param  string  $glue
+	 * @return string
+	 */
+	public function implode($value, $glue = null)
+	{
+		$first = $this->first();
+
+		if (is_array($first) || is_object($first)) {
+			return implode($glue, $this->pluck($value)->all());
+		}
+
+		return implode($value, $this->items);
+	}
+
+	/**
+	 * Intersect the collection with the given items.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function intersect($items)
+	{
+		return new static(array_intersect($this->items, $this->getArrayableItems($items)));
+	}
+
+	/**
+	 * Intersect the collection with the given items by key.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function intersectKey($items)
+	{
+		return new static(array_intersect_key($this->items, $this->getArrayableItems($items)));
+	}
+
+	/**
+	 * Determine if the collection is empty or not.
+	 *
+	 * @return bool
+	 */
+	public function isEmpty()
+	{
+		return empty($this->items);
+	}
+
+	/**
+	 * Determine if the collection is not empty.
+	 *
+	 * @return bool
+	 */
+	public function isNotEmpty()
+	{
+		return ! $this->isEmpty();
+	}
+
+	/**
+	 * Determine if the given value is callable, but not a string.
+	 *
+	 * @param  mixed  $value
+	 * @return bool
+	 */
+	protected function useAsCallable($value)
+	{
+		return ! is_string($value) && is_callable($value);
+	}
+
+	/**
+	 * Get the keys of the collection items.
+	 *
+	 * @return static
+	 */
+	public function keys()
+	{
+		return new static(array_keys($this->items));
+	}
+
+	/**
+	 * Get the last item from the collection.
+	 *
+	 * @param  callable|null  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public function last(callable $callback = null, $default = null)
+	{
+		return Arr::last($this->items, $callback, $default);
+	}
+
+	/**
+	 * Get the values of a given key.
+	 *
+	 * @param  string|array  $value
+	 * @param  string|null  $key
+	 * @return static
+	 */
+	public function pluck($value, $key = null)
+	{
+		return new static(Arr::pluck($this->items, $value, $key));
+	}
+
+	/**
+	 * Run a map over each of the items.
+	 *
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public function map(callable $callback)
+	{
+		$keys = array_keys($this->items);
+
+		$items = array_map($callback, $this->items, $keys);
+
+		return new static(array_combine($keys, $items));
+	}
+
+	/**
+	 * Run a map over each nested chunk of items.
+	 *
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public function mapSpread(callable $callback)
+	{
+		return $this->map(function ($chunk) use ($callback) {
+			return $callback(...$chunk);
+		});
+	}
+
+	/**
+	 * Run a grouping map over the items.
+	 *
+	 * The callback should return an associative array with a single key/value pair.
+	 *
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public function mapToGroups(callable $callback)
+	{
+		$groups = $this->map($callback)->reduce(function ($groups, $pair) {
+			$groups[key($pair)][] = reset($pair);
+
+			return $groups;
+		}, []);
+
+		return (new static($groups))->map([$this, 'make']);
+	}
+
+	/**
+	 * Run an associative map over each of the items.
+	 *
+	 * The callback should return an associative array with a single key/value pair.
+	 *
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public function mapWithKeys(callable $callback)
+	{
+		$result = [];
+
+		foreach ($this->items as $key => $value) {
+			$assoc = $callback($value, $key);
+
+			foreach ($assoc as $mapKey => $mapValue) {
+				$result[$mapKey] = $mapValue;
+			}
+		}
+
+		return new static($result);
+	}
+
+	/**
+	 * Map a collection and flatten the result by a single level.
+	 *
+	 * @param  callable  $callback
+	 * @return static
+	 */
+	public function flatMap(callable $callback)
+	{
+		return $this->map($callback)->collapse();
+	}
+
+	/**
+	 * Get the max value of a given key.
+	 *
+	 * @param  callable|string|null  $callback
+	 * @return mixed
+	 */
+	public function max($callback = null)
+	{
+		$callback = $this->valueRetriever($callback);
+
+		return $this->filter(function ($value) {
+			return ! is_null($value);
+		})->reduce(function ($result, $item) use ($callback) {
+			$value = $callback($item);
+
+			return is_null($result) || $value > $result ? $value : $result;
+		});
+	}
+
+	/**
+	 * Merge the collection with the given items.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function merge($items)
+	{
+		return new static(array_merge($this->items, $this->getArrayableItems($items)));
+	}
+
+	/**
+	 * Create a collection by using this collection for keys and another for its values.
+	 *
+	 * @param  mixed  $values
+	 * @return static
+	 */
+	public function combine($values)
+	{
+		return new static(array_combine($this->all(), $this->getArrayableItems($values)));
+	}
+
+	/**
+	 * Union the collection with the given items.
+	 *
+	 * @param  mixed  $items
+	 * @return static
+	 */
+	public function union($items)
+	{
+		return new static($this->items + $this->getArrayableItems($items));
+	}
+
+	/**
+	 * Get the min value of a given key.
+	 *
+	 * @param  callable|string|null  $callback
+	 * @return mixed
+	 */
+	public function min($callback = null)
+	{
+		$callback = $this->valueRetriever($callback);
+
+		return $this->filter(function ($value) {
+			return ! is_null($value);
+		})->reduce(function ($result, $item) use ($callback) {
+			$value = $callback($item);
+
+			return is_null($result) || $value < $result ? $value : $result;
+		});
+	}
+
+	/**
+	 * Create a new collection consisting of every n-th element.
+	 *
+	 * @param  int  $step
+	 * @param  int  $offset
+	 * @return static
+	 */
+	public function nth($step, $offset = 0)
+	{
+		$new = [];
+
+		$position = 0;
+
+		foreach ($this->items as $item) {
+			if ($position % $step === $offset) {
+				$new[] = $item;
+			}
+
+			$position++;
+		}
+
+		return new static($new);
+	}
+
+	/**
+	 * Get the items with the specified keys.
+	 *
+	 * @param  mixed  $keys
+	 * @return static
+	 */
+	public function only($keys)
+	{
+		if (is_null($keys)) {
+			return new static($this->items);
+		}
+
+		$keys = is_array($keys) ? $keys : func_get_args();
+
+		return new static(Arr::only($this->items, $keys));
+	}
+
+	/**
+	 * "Paginate" the collection by slicing it into a smaller collection.
+	 *
+	 * @param  int  $page
+	 * @param  int  $perPage
+	 * @return static
+	 */
+	public function forPage($page, $perPage)
+	{
+		return $this->slice(($page - 1) * $perPage, $perPage);
+	}
+
+	/**
+	 * Partition the collection into two arrays using the given callback or key.
+	 *
+	 * @param  callable|string  $callback
+	 * @return static
+	 */
+	public function partition($callback)
+	{
+		$partitions = [new static, new static];
+
+		$callback = $this->valueRetriever($callback);
+
+		foreach ($this->items as $key => $item) {
+			$partitions[(int) ! $callback($item)][$key] = $item;
+		}
+
+		return new static($partitions);
+	}
+
+	/**
+	 * Pass the collection to the given callback and return the result.
+	 *
+	 * @param  callable $callback
+	 * @return mixed
+	 */
+	public function pipe(callable $callback)
+	{
+		return $callback($this);
+	}
+
+	/**
+	 * Get and remove the last item from the collection.
+	 *
+	 * @return mixed
+	 */
+	public function pop()
+	{
+		return array_pop($this->items);
+	}
+
+	/**
+	 * Push an item onto the beginning of the collection.
+	 *
+	 * @param  mixed  $value
+	 * @param  mixed  $key
+	 * @return $this
+	 */
+	public function prepend($value, $key = null)
+	{
+		$this->items = Arr::prepend($this->items, $value, $key);
+
+		return $this;
+	}
+
+	/**
+	 * Push an item onto the end of the collection.
+	 *
+	 * @param  mixed  $value
+	 * @return $this
+	 */
+	public function push($value)
+	{
+		$this->offsetSet(null, $value);
+
+		return $this;
+	}
+
+	/**
+	 * Push all of the given items onto the collection.
+	 *
+	 * @param  \Traversable  $source
+	 * @return self
+	 */
+	public function concat($source)
+	{
+		$result = new static($this);
+
+		foreach ($source as $item) {
+			$result->push($item);
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Get and remove an item from the collection.
+	 *
+	 * @param  mixed  $key
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public function pull($key, $default = null)
+	{
+		return Arr::pull($this->items, $key, $default);
+	}
+
+	/**
+	 * Put an item in the collection by key.
+	 *
+	 * @param  mixed  $key
+	 * @param  mixed  $value
+	 * @return $this
+	 */
+	public function put($key, $value)
+	{
+		$this->offsetSet($key, $value);
+
+		return $this;
+	}
+
+	/**
+	 * Get one or a specified number of items randomly from the collection.
+	 *
+	 * @param  int|null  $number
+	 * @return mixed
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function random($number = null)
+	{
+		if (is_null($number)) {
+			return Arr::random($this->items);
+		}
+
+		return new static(Arr::random($this->items, $number));
+	}
+
+	/**
+	 * Reduce the collection to a single value.
+	 *
+	 * @param  callable  $callback
+	 * @param  mixed  $initial
+	 * @return mixed
+	 */
+	public function reduce(callable $callback, $initial = null)
+	{
+		return array_reduce($this->items, $callback, $initial);
+	}
+
+	/**
+	 * Create a collection of all elements that do not pass a given truth test.
+	 *
+	 * @param  callable|mixed  $callback
+	 * @return static
+	 */
+	public function reject($callback)
+	{
+		if ($this->useAsCallable($callback)) {
+			return $this->filter(function ($value, $key) use ($callback) {
+				return ! $callback($value, $key);
+			});
+		}
+
+		return $this->filter(function ($item) use ($callback) {
+			return $item != $callback;
+		});
+	}
+
+	/**
+	 * Reverse items order.
+	 *
+	 * @return static
+	 */
+	public function reverse()
+	{
+		return new static(array_reverse($this->items, true));
+	}
+
+	/**
+	 * Search the collection for a given value and return the corresponding key if successful.
+	 *
+	 * @param  mixed  $value
+	 * @param  bool  $strict
+	 * @return mixed
+	 */
+	public function search($value, $strict = false)
+	{
+		if (! $this->useAsCallable($value)) {
+			return array_search($value, $this->items, $strict);
+		}
+
+		foreach ($this->items as $key => $item) {
+			if (call_user_func($value, $item, $key)) {
+				return $key;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Get and remove the first item from the collection.
+	 *
+	 * @return mixed
+	 */
+	public function shift()
+	{
+		return array_shift($this->items);
+	}
+
+	/**
+	 * Shuffle the items in the collection.
+	 *
+	 * @param  int  $seed
+	 * @return static
+	 */
+	public function shuffle($seed = null)
+	{
+		$items = $this->items;
+
+		if (is_null($seed)) {
+			shuffle($items);
+		} else {
+			srand($seed);
+
+			usort($items, function () {
+				return rand(-1, 1);
+			});
+		}
+
+		return new static($items);
+	}
+
+	/**
+	 * Slice the underlying collection array.
+	 *
+	 * @param  int  $offset
+	 * @param  int  $length
+	 * @return static
+	 */
+	public function slice($offset, $length = null)
+	{
+		return new static(array_slice($this->items, $offset, $length, true));
+	}
+
+	/**
+	 * Split a collection into a certain number of groups.
+	 *
+	 * @param  int  $numberOfGroups
+	 * @return static
+	 */
+	public function split($numberOfGroups)
+	{
+		if ($this->isEmpty()) {
+			return new static;
+		}
+
+		$groupSize = ceil($this->count() / $numberOfGroups);
+
+		return $this->chunk($groupSize);
+	}
+
+	/**
+	 * Chunk the underlying collection array.
+	 *
+	 * @param  int  $size
+	 * @return static
+	 */
+	public function chunk($size)
+	{
+		if ($size <= 0) {
+			return new static;
+		}
+
+		$chunks = [];
+
+		foreach (array_chunk($this->items, $size, true) as $chunk) {
+			$chunks[] = new static($chunk);
+		}
+
+		return new static($chunks);
+	}
+
+	/**
+	 * Sort through each item with a callback.
+	 *
+	 * @param  callable|null  $callback
+	 * @return static
+	 */
+	public function sort(callable $callback = null)
+	{
+		$items = $this->items;
+
+		$callback
+			? uasort($items, $callback)
+			: asort($items);
+
+		return new static($items);
+	}
+
+	/**
+	 * Sort the collection using the given callback.
+	 *
+	 * @param  callable|string  $callback
+	 * @param  int  $options
+	 * @param  bool  $descending
+	 * @return static
+	 */
+	public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
+	{
+		$results = [];
+
+		$callback = $this->valueRetriever($callback);
+
+		// First we will loop through the items and get the comparator from a callback
+		// function which we were given. Then, we will sort the returned values and
+		// and grab the corresponding values for the sorted keys from this array.
+		foreach ($this->items as $key => $value) {
+			$results[$key] = $callback($value, $key);
+		}
+
+		$descending ? arsort($results, $options)
+					: asort($results, $options);
+
+		// Once we have sorted all of the keys in the array, we will loop through them
+		// and grab the corresponding model so we can set the underlying items list
+		// to the sorted version. Then we'll just return the collection instance.
+		foreach (array_keys($results) as $key) {
+			$results[$key] = $this->items[$key];
+		}
+
+		return new static($results);
+	}
+
+	/**
+	 * Sort the collection in descending order using the given callback.
+	 *
+	 * @param  callable|string  $callback
+	 * @param  int  $options
+	 * @return static
+	 */
+	public function sortByDesc($callback, $options = SORT_REGULAR)
+	{
+		return $this->sortBy($callback, $options, true);
+	}
+
+	/**
+	 * Splice a portion of the underlying collection array.
+	 *
+	 * @param  int  $offset
+	 * @param  int|null  $length
+	 * @param  mixed  $replacement
+	 * @return static
+	 */
+	public function splice($offset, $length = null, $replacement = [])
+	{
+		if (func_num_args() == 1) {
+			return new static(array_splice($this->items, $offset));
+		}
+
+		return new static(array_splice($this->items, $offset, $length, $replacement));
+	}
+
+	/**
+	 * Get the sum of the given values.
+	 *
+	 * @param  callable|string|null  $callback
+	 * @return mixed
+	 */
+	public function sum($callback = null)
+	{
+		if (is_null($callback)) {
+			return array_sum($this->items);
+		}
+
+		$callback = $this->valueRetriever($callback);
+
+		return $this->reduce(function ($result, $item) use ($callback) {
+			return $result + $callback($item);
+		}, 0);
+	}
+
+	/**
+	 * Take the first or last {$limit} items.
+	 *
+	 * @param  int  $limit
+	 * @return static
+	 */
+	public function take($limit)
+	{
+		if ($limit < 0) {
+			return $this->slice($limit, abs($limit));
+		}
+
+		return $this->slice(0, $limit);
+	}
+
+	/**
+	 * Pass the collection to the given callback and then return it.
+	 *
+	 * @param  callable  $callback
+	 * @return $this
+	 */
+	public function tap(callable $callback)
+	{
+		$callback(new static($this->items));
+
+		return $this;
+	}
+
+	/**
+	 * Transform each item in the collection using a callback.
+	 *
+	 * @param  callable  $callback
+	 * @return $this
+	 */
+	public function transform(callable $callback)
+	{
+		$this->items = $this->map($callback)->all();
+
+		return $this;
+	}
+
+	/**
+	 * Return only unique items from the collection array.
+	 *
+	 * @param  string|callable|null  $key
+	 * @param  bool  $strict
+	 * @return static
+	 */
+	public function unique($key = null, $strict = false)
+	{
+		if (is_null($key)) {
+			return new static(array_unique($this->items, SORT_REGULAR));
+		}
+
+		$callback = $this->valueRetriever($key);
+
+		$exists = [];
+
+		return $this->reject(function ($item, $key) use ($callback, $strict, &$exists) {
+			if (in_array($id = $callback($item, $key), $exists, $strict)) {
+				return true;
+			}
+
+			$exists[] = $id;
+		});
+	}
+
+	/**
+	 * Return only unique items from the collection array using strict comparison.
+	 *
+	 * @param  string|callable|null  $key
+	 * @return static
+	 */
+	public function uniqueStrict($key = null)
+	{
+		return $this->unique($key, true);
+	}
+
+	/**
+	 * Reset the keys on the underlying array.
+	 *
+	 * @return static
+	 */
+	public function values()
+	{
+		return new static(array_values($this->items));
+	}
+
+	/**
+	 * Get a value retrieving callback.
+	 *
+	 * @param  string  $value
+	 * @return callable
+	 */
+	protected function valueRetriever($value)
+	{
+		if ($this->useAsCallable($value)) {
+			return $value;
+		}
+
+		return function ($item) use ($value) {
+			return data_get($item, $value);
+		};
+	}
+
+	/**
+	 * Zip the collection together with one or more arrays.
+	 *
+	 * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]);
+	 *      => [[1, 4], [2, 5], [3, 6]]
+	 *
+	 * @param  mixed ...$items
+	 * @return static
+	 */
+	public function zip($items)
+	{
+		$arrayableItems = array_map(function ($items) {
+			return $this->getArrayableItems($items);
+		}, func_get_args());
+
+		$params = array_merge([function () {
+			return new static(func_get_args());
+		}, $this->items], $arrayableItems);
+
+		return new static(call_user_func_array('array_map', $params));
+	}
+
+	/**
+	 * Get the collection of items as a plain array.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return array_map(function ($value) {
+			return $value instanceof Arrayable ? $value->toArray() : $value;
+		}, $this->items);
+	}
+
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		return array_map(function ($value) {
+			if ($value instanceof JsonSerializable) {
+				return $value->jsonSerialize();
+			} elseif ($value instanceof Jsonable) {
+				return json_decode($value->toJson(), true);
+			} elseif ($value instanceof Arrayable) {
+				return $value->toArray();
+			} else {
+				return $value;
+			}
+		}, $this->items);
+	}
+
+	/**
+	 * Get the collection of items as JSON.
+	 *
+	 * @param  int  $options
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		return json_encode($this->jsonSerialize(), $options);
+	}
+
+	/**
+	 * Get an iterator for the items.
+	 *
+	 * @return \ArrayIterator
+	 */
+	public function getIterator()
+	{
+		return new ArrayIterator($this->items);
+	}
+
+	/**
+	 * Get a CachingIterator instance.
+	 *
+	 * @param  int  $flags
+	 * @return \CachingIterator
+	 */
+	public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
+	{
+		return new CachingIterator($this->getIterator(), $flags);
+	}
+
+	/**
+	 * Count the number of items in the collection.
+	 *
+	 * @return int
+	 */
+	public function count()
+	{
+		return count($this->items);
+	}
+
+	/**
+	 * Get a base Support collection instance from this collection.
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function toBase()
+	{
+		return new self($this);
+	}
+
+	/**
+	 * Determine if an item exists at an offset.
+	 *
+	 * @param  mixed  $key
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		return array_key_exists($key, $this->items);
+	}
+
+	/**
+	 * Get an item at a given offset.
+	 *
+	 * @param  mixed  $key
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		return $this->items[$key];
+	}
+
+	/**
+	 * Set the item at a given offset.
+	 *
+	 * @param  mixed  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		if (is_null($key)) {
+			$this->items[] = $value;
+		} else {
+			$this->items[$key] = $value;
+		}
+	}
+
+	/**
+	 * Unset the item at a given offset.
+	 *
+	 * @param  string  $key
+	 * @return void
+	 */
+	public function offsetUnset($key)
+	{
+		unset($this->items[$key]);
+	}
+
+	/**
+	 * Convert the collection to its string representation.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->toJson();
+	}
+
+	/**
+	 * Results array of items from Collection or Arrayable.
+	 *
+	 * @param  mixed  $items
+	 * @return array
+	 */
+	protected function getArrayableItems($items)
+	{
+		if (is_array($items)) {
+			return $items;
+		} elseif ($items instanceof self) {
+			return $items->all();
+		} elseif ($items instanceof Arrayable) {
+			return $items->toArray();
+		} elseif ($items instanceof Jsonable) {
+			return json_decode($items->toJson(), true);
+		} elseif ($items instanceof JsonSerializable) {
+			return $items->jsonSerialize();
+		} elseif ($items instanceof Traversable) {
+			return iterator_to_array($items);
+		}
+
+		return (array) $items;
+	}
+
+	/**
+	 * Add a method to the list of proxied methods.
+	 *
+	 * @param  string  $method
+	 * @return void
+	 */
+	public static function proxy($method)
+	{
+		static::$proxies[] = $method;
+	}
+
+	/**
+	 * Dynamically access collection proxies.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 *
+	 * @throws \Exception
+	 */
+	public function __get($key)
+	{
+		if (! in_array($key, static::$proxies)) {
+			throw new Exception("Property [{$key}] does not exist on this collection instance.");
+		}
+
+		return new HigherOrderCollectionProxy($this, $key);
+	}
 }

Braces +105 added lines, -210 removed lines

@@ -41,8 +41,7 @@ 
      * @param  mixed  $items
      * @return void
      */
-    public function __construct($items = [])
-    {
+    public function __construct($items = []) {
         $this->items = $this->getArrayableItems($items);
     }
 
@@ -52,8 +51,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public static function make($items = [])
-    {
+    public static function make($items = []) {
         return new static($items);
     }
 
@@ -64,8 +62,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public static function times($number, callable $callback = null)
-    {
+    public static function times($number, callable $callback = null) {
         if ($number < 1) {
             return new static;
         }
@@ -82,8 +79,7 @@ 
      *
      * @return array
      */
-    public function all()
-    {
+    public function all() {
         return $this->items;
     }
 
@@ -93,8 +89,7 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function avg($callback = null)
-    {
+    public function avg($callback = null) {
         if ($count = $this->count()) {
             return $this->sum($callback) / $count;
         }
@@ -106,8 +101,7 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function average($callback = null)
-    {
+    public function average($callback = null) {
         return $this->avg($callback);
     }
 
@@ -117,8 +111,7 @@ 
      * @param  null $key
      * @return mixed
      */
-    public function median($key = null)
-    {
+    public function median($key = null) {
         $count = $this->count();
 
         if ($count == 0) {
@@ -145,8 +138,7 @@ 
      * @param  mixed  $key
      * @return array|null
      */
-    public function mode($key = null)
-    {
+    public function mode($key = null) {
         $count = $this->count();
 
         if ($count == 0) {
@@ -175,8 +167,7 @@ 
      *
      * @return static
      */
-    public function collapse()
-    {
+    public function collapse() {
         return new static(Arr::collapse($this->items));
     }
 
@@ -188,8 +179,7 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function contains($key, $operator = null, $value = null)
-    {
+    public function contains($key, $operator = null, $value = null) {
         if (func_num_args() == 1) {
             if ($this->useAsCallable($key)) {
                 return ! is_null($this->first($key));
@@ -214,8 +204,7 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function containsStrict($key, $value = null)
-    {
+    public function containsStrict($key, $value = null) {
         if (func_num_args() == 2) {
             return $this->contains(function ($item) use ($key, $value) {
                 return data_get($item, $key) === $value;
@@ -235,8 +224,7 @@ 
      * @param  mixed  ...$lists
      * @return static
      */
-    public function crossJoin(...$lists)
-    {
+    public function crossJoin(...$lists) {
         return new static(Arr::crossJoin(
             $this->items, ...array_map([$this, 'getArrayableItems'], $lists)
         ));
@@ -248,8 +236,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diff($items)
-    {
+    public function diff($items) {
         return new static(array_diff($this->items, $this->getArrayableItems($items)));
     }
 
@@ -259,8 +246,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diffAssoc($items)
-    {
+    public function diffAssoc($items) {
         return new static(array_diff_assoc($this->items, $this->getArrayableItems($items)));
     }
 
@@ -270,8 +256,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diffKeys($items)
-    {
+    public function diffKeys($items) {
         return new static(array_diff_key($this->items, $this->getArrayableItems($items)));
     }
 
@@ -281,8 +266,7 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function each(callable $callback)
-    {
+    public function each(callable $callback) {
         foreach ($this->items as $key => $item) {
             if ($callback($item, $key) === false) {
                 break;
@@ -298,8 +282,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function eachSpread(callable $callback)
-    {
+    public function eachSpread(callable $callback) {
         return $this->each(function ($chunk) use ($callback) {
             return $callback(...$chunk);
         });
@@ -313,8 +296,7 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function every($key, $operator = null, $value = null)
-    {
+    public function every($key, $operator = null, $value = null) {
         if (func_num_args() == 1) {
             $callback = $this->valueRetriever($key);
 
@@ -342,8 +324,7 @@ 
      * @param  mixed  $keys
      * @return static
      */
-    public function except($keys)
-    {
+    public function except($keys) {
         $keys = is_array($keys) ? $keys : func_get_args();
 
         return new static(Arr::except($this->items, $keys));
@@ -355,8 +336,7 @@ 
      * @param  callable|null  $callback
      * @return static
      */
-    public function filter(callable $callback = null)
-    {
+    public function filter(callable $callback = null) {
         if ($callback) {
             return new static(Arr::where($this->items, $callback));
         }
@@ -372,8 +352,7 @@ 
      * @param  callable  $default
      * @return mixed
      */
-    public function when($value, callable $callback, callable $default = null)
-    {
+    public function when($value, callable $callback, callable $default = null) {
         if ($value) {
             return $callback($this);
         } elseif ($default) {
@@ -391,8 +370,7 @@ 
      * @param  callable  $default
      * @return mixed
      */
-    public function unless($value, callable $callback, callable $default = null)
-    {
+    public function unless($value, callable $callback, callable $default = null) {
         return $this->when(! $value, $callback, $default);
     }
 
@@ -404,8 +382,7 @@ 
      * @param  mixed  $value
      * @return static
      */
-    public function where($key, $operator, $value = null)
-    {
+    public function where($key, $operator, $value = null) {
         if (func_num_args() == 2) {
             $value = $operator;
 
@@ -423,8 +400,7 @@ 
      * @param  mixed  $value
      * @return \Closure
      */
-    protected function operatorForWhere($key, $operator, $value)
-    {
+    protected function operatorForWhere($key, $operator, $value) {
         return function ($item) use ($key, $operator, $value) {
             $retrieved = data_get($item, $key);
 
@@ -451,8 +427,7 @@ 
      * @param  mixed  $value
      * @return static
      */
-    public function whereStrict($key, $value)
-    {
+    public function whereStrict($key, $value) {
         return $this->where($key, '===', $value);
     }
 
@@ -464,8 +439,7 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function whereIn($key, $values, $strict = false)
-    {
+    public function whereIn($key, $values, $strict = false) {
         $values = $this->getArrayableItems($values);
 
         return $this->filter(function ($item) use ($key, $values, $strict) {
@@ -480,8 +454,7 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function whereInStrict($key, $values)
-    {
+    public function whereInStrict($key, $values) {
         return $this->whereIn($key, $values, true);
     }
 
@@ -493,8 +466,7 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function whereNotIn($key, $values, $strict = false)
-    {
+    public function whereNotIn($key, $values, $strict = false) {
         $values = $this->getArrayableItems($values);
 
         return $this->reject(function ($item) use ($key, $values, $strict) {
@@ -509,8 +481,7 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function whereNotInStrict($key, $values)
-    {
+    public function whereNotInStrict($key, $values) {
         return $this->whereNotIn($key, $values, true);
     }
 
@@ -521,8 +492,7 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function first(callable $callback = null, $default = null)
-    {
+    public function first(callable $callback = null, $default = null) {
         return Arr::first($this->items, $callback, $default);
     }
 
@@ -532,8 +502,7 @@ 
      * @param  int  $depth
      * @return static
      */
-    public function flatten($depth = INF)
-    {
+    public function flatten($depth = INF) {
         return new static(Arr::flatten($this->items, $depth));
     }
 
@@ -542,8 +511,7 @@ 
      *
      * @return static
      */
-    public function flip()
-    {
+    public function flip() {
         return new static(array_flip($this->items));
     }
 
@@ -553,8 +521,7 @@ 
      * @param  string|array  $keys
      * @return $this
      */
-    public function forget($keys)
-    {
+    public function forget($keys) {
         foreach ((array) $keys as $key) {
             $this->offsetUnset($key);
         }
@@ -569,8 +536,7 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function get($key, $default = null)
-    {
+    public function get($key, $default = null) {
         if ($this->offsetExists($key)) {
             return $this->items[$key];
         }
@@ -585,8 +551,7 @@ 
      * @param  bool  $preserveKeys
      * @return static
      */
-    public function groupBy($groupBy, $preserveKeys = false)
-    {
+    public function groupBy($groupBy, $preserveKeys = false) {
         $groupBy = $this->valueRetriever($groupBy);
 
         $results = [];
@@ -618,8 +583,7 @@ 
      * @param  callable|string  $keyBy
      * @return static
      */
-    public function keyBy($keyBy)
-    {
+    public function keyBy($keyBy) {
         $keyBy = $this->valueRetriever($keyBy);
 
         $results = [];
@@ -643,8 +607,7 @@ 
      * @param  mixed  $key
      * @return bool
      */
-    public function has($key)
-    {
+    public function has($key) {
         return $this->offsetExists($key);
     }
 
@@ -655,8 +618,7 @@ 
      * @param  string  $glue
      * @return string
      */
-    public function implode($value, $glue = null)
-    {
+    public function implode($value, $glue = null) {
         $first = $this->first();
 
         if (is_array($first) || is_object($first)) {
@@ -672,8 +634,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function intersect($items)
-    {
+    public function intersect($items) {
         return new static(array_intersect($this->items, $this->getArrayableItems($items)));
     }
 
@@ -683,8 +644,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function intersectKey($items)
-    {
+    public function intersectKey($items) {
         return new static(array_intersect_key($this->items, $this->getArrayableItems($items)));
     }
 
@@ -693,8 +653,7 @@ 
      *
      * @return bool
      */
-    public function isEmpty()
-    {
+    public function isEmpty() {
         return empty($this->items);
     }
 
@@ -703,8 +662,7 @@ 
      *
      * @return bool
      */
-    public function isNotEmpty()
-    {
+    public function isNotEmpty() {
         return ! $this->isEmpty();
     }
 
@@ -714,8 +672,7 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    protected function useAsCallable($value)
-    {
+    protected function useAsCallable($value) {
         return ! is_string($value) && is_callable($value);
     }
 
@@ -724,8 +681,7 @@ 
      *
      * @return static
      */
-    public function keys()
-    {
+    public function keys() {
         return new static(array_keys($this->items));
     }
 
@@ -736,8 +692,7 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function last(callable $callback = null, $default = null)
-    {
+    public function last(callable $callback = null, $default = null) {
         return Arr::last($this->items, $callback, $default);
     }
 
@@ -748,8 +703,7 @@ 
      * @param  string|null  $key
      * @return static
      */
-    public function pluck($value, $key = null)
-    {
+    public function pluck($value, $key = null) {
         return new static(Arr::pluck($this->items, $value, $key));
     }
 
@@ -759,8 +713,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function map(callable $callback)
-    {
+    public function map(callable $callback) {
         $keys = array_keys($this->items);
 
         $items = array_map($callback, $this->items, $keys);
@@ -774,8 +727,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapSpread(callable $callback)
-    {
+    public function mapSpread(callable $callback) {
         return $this->map(function ($chunk) use ($callback) {
             return $callback(...$chunk);
         });
@@ -789,8 +741,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapToGroups(callable $callback)
-    {
+    public function mapToGroups(callable $callback) {
         $groups = $this->map($callback)->reduce(function ($groups, $pair) {
             $groups[key($pair)][] = reset($pair);
 
@@ -808,8 +759,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapWithKeys(callable $callback)
-    {
+    public function mapWithKeys(callable $callback) {
         $result = [];
 
         foreach ($this->items as $key => $value) {
@@ -829,8 +779,7 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function flatMap(callable $callback)
-    {
+    public function flatMap(callable $callback) {
         return $this->map($callback)->collapse();
     }
 
@@ -840,8 +789,7 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function max($callback = null)
-    {
+    public function max($callback = null) {
         $callback = $this->valueRetriever($callback);
 
         return $this->filter(function ($value) {
@@ -859,8 +807,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function merge($items)
-    {
+    public function merge($items) {
         return new static(array_merge($this->items, $this->getArrayableItems($items)));
     }
 
@@ -870,8 +817,7 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function combine($values)
-    {
+    public function combine($values) {
         return new static(array_combine($this->all(), $this->getArrayableItems($values)));
     }
 
@@ -881,8 +827,7 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function union($items)
-    {
+    public function union($items) {
         return new static($this->items + $this->getArrayableItems($items));
     }
 
@@ -892,8 +837,7 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function min($callback = null)
-    {
+    public function min($callback = null) {
         $callback = $this->valueRetriever($callback);
 
         return $this->filter(function ($value) {
@@ -912,8 +856,7 @@ 
      * @param  int  $offset
      * @return static
      */
-    public function nth($step, $offset = 0)
-    {
+    public function nth($step, $offset = 0) {
         $new = [];
 
         $position = 0;
@@ -935,8 +878,7 @@ 
      * @param  mixed  $keys
      * @return static
      */
-    public function only($keys)
-    {
+    public function only($keys) {
         if (is_null($keys)) {
             return new static($this->items);
         }
@@ -953,8 +895,7 @@ 
      * @param  int  $perPage
      * @return static
      */
-    public function forPage($page, $perPage)
-    {
+    public function forPage($page, $perPage) {
         return $this->slice(($page - 1) * $perPage, $perPage);
     }
 
@@ -964,8 +905,7 @@ 
      * @param  callable|string  $callback
      * @return static
      */
-    public function partition($callback)
-    {
+    public function partition($callback) {
         $partitions = [new static, new static];
 
         $callback = $this->valueRetriever($callback);
@@ -983,8 +923,7 @@ 
      * @param  callable $callback
      * @return mixed
      */
-    public function pipe(callable $callback)
-    {
+    public function pipe(callable $callback) {
         return $callback($this);
     }
 
@@ -993,8 +932,7 @@ 
      *
      * @return mixed
      */
-    public function pop()
-    {
+    public function pop() {
         return array_pop($this->items);
     }
 
@@ -1005,8 +943,7 @@ 
      * @param  mixed  $key
      * @return $this
      */
-    public function prepend($value, $key = null)
-    {
+    public function prepend($value, $key = null) {
         $this->items = Arr::prepend($this->items, $value, $key);
 
         return $this;
@@ -1018,8 +955,7 @@ 
      * @param  mixed  $value
      * @return $this
      */
-    public function push($value)
-    {
+    public function push($value) {
         $this->offsetSet(null, $value);
 
         return $this;
@@ -1031,8 +967,7 @@ 
      * @param  \Traversable  $source
      * @return self
      */
-    public function concat($source)
-    {
+    public function concat($source) {
         $result = new static($this);
 
         foreach ($source as $item) {
@@ -1049,8 +984,7 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function pull($key, $default = null)
-    {
+    public function pull($key, $default = null) {
         return Arr::pull($this->items, $key, $default);
     }
 
@@ -1061,8 +995,7 @@ 
      * @param  mixed  $value
      * @return $this
      */
-    public function put($key, $value)
-    {
+    public function put($key, $value) {
         $this->offsetSet($key, $value);
 
         return $this;
@@ -1076,8 +1009,7 @@ 
      *
      * @throws \InvalidArgumentException
      */
-    public function random($number = null)
-    {
+    public function random($number = null) {
         if (is_null($number)) {
             return Arr::random($this->items);
         }
@@ -1092,8 +1024,7 @@ 
      * @param  mixed  $initial
      * @return mixed
      */
-    public function reduce(callable $callback, $initial = null)
-    {
+    public function reduce(callable $callback, $initial = null) {
         return array_reduce($this->items, $callback, $initial);
     }
 
@@ -1103,8 +1034,7 @@ 
      * @param  callable|mixed  $callback
      * @return static
      */
-    public function reject($callback)
-    {
+    public function reject($callback) {
         if ($this->useAsCallable($callback)) {
             return $this->filter(function ($value, $key) use ($callback) {
                 return ! $callback($value, $key);
@@ -1121,8 +1051,7 @@ 
      *
      * @return static
      */
-    public function reverse()
-    {
+    public function reverse() {
         return new static(array_reverse($this->items, true));
     }
 
@@ -1133,8 +1062,7 @@ 
      * @param  bool  $strict
      * @return mixed
      */
-    public function search($value, $strict = false)
-    {
+    public function search($value, $strict = false) {
         if (! $this->useAsCallable($value)) {
             return array_search($value, $this->items, $strict);
         }
@@ -1153,8 +1081,7 @@ 
      *
      * @return mixed
      */
-    public function shift()
-    {
+    public function shift() {
         return array_shift($this->items);
     }
 
@@ -1164,8 +1091,7 @@ 
      * @param  int  $seed
      * @return static
      */
-    public function shuffle($seed = null)
-    {
+    public function shuffle($seed = null) {
         $items = $this->items;
 
         if (is_null($seed)) {
@@ -1188,8 +1114,7 @@ 
      * @param  int  $length
      * @return static
      */
-    public function slice($offset, $length = null)
-    {
+    public function slice($offset, $length = null) {
         return new static(array_slice($this->items, $offset, $length, true));
     }
 
@@ -1199,8 +1124,7 @@ 
      * @param  int  $numberOfGroups
      * @return static
      */
-    public function split($numberOfGroups)
-    {
+    public function split($numberOfGroups) {
         if ($this->isEmpty()) {
             return new static;
         }
@@ -1216,8 +1140,7 @@ 
      * @param  int  $size
      * @return static
      */
-    public function chunk($size)
-    {
+    public function chunk($size) {
         if ($size <= 0) {
             return new static;
         }
@@ -1237,8 +1160,7 @@ 
      * @param  callable|null  $callback
      * @return static
      */
-    public function sort(callable $callback = null)
-    {
+    public function sort(callable $callback = null) {
         $items = $this->items;
 
         $callback
@@ -1256,8 +1178,7 @@ 
      * @param  bool  $descending
      * @return static
      */
-    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
-    {
+    public function sortBy($callback, $options = SORT_REGULAR, $descending = false) {
         $results = [];
 
         $callback = $this->valueRetriever($callback);
@@ -1289,8 +1210,7 @@ 
      * @param  int  $options
      * @return static
      */
-    public function sortByDesc($callback, $options = SORT_REGULAR)
-    {
+    public function sortByDesc($callback, $options = SORT_REGULAR) {
         return $this->sortBy($callback, $options, true);
     }
 
@@ -1302,8 +1222,7 @@ 
      * @param  mixed  $replacement
      * @return static
      */
-    public function splice($offset, $length = null, $replacement = [])
-    {
+    public function splice($offset, $length = null, $replacement = []) {
         if (func_num_args() == 1) {
             return new static(array_splice($this->items, $offset));
         }
@@ -1317,8 +1236,7 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function sum($callback = null)
-    {
+    public function sum($callback = null) {
         if (is_null($callback)) {
             return array_sum($this->items);
         }
@@ -1336,8 +1254,7 @@ 
      * @param  int  $limit
      * @return static
      */
-    public function take($limit)
-    {
+    public function take($limit) {
         if ($limit < 0) {
             return $this->slice($limit, abs($limit));
         }
@@ -1351,8 +1268,7 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function tap(callable $callback)
-    {
+    public function tap(callable $callback) {
         $callback(new static($this->items));
 
         return $this;
@@ -1364,8 +1280,7 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function transform(callable $callback)
-    {
+    public function transform(callable $callback) {
         $this->items = $this->map($callback)->all();
 
         return $this;
@@ -1378,8 +1293,7 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function unique($key = null, $strict = false)
-    {
+    public function unique($key = null, $strict = false) {
         if (is_null($key)) {
             return new static(array_unique($this->items, SORT_REGULAR));
         }
@@ -1403,8 +1317,7 @@ 
      * @param  string|callable|null  $key
      * @return static
      */
-    public function uniqueStrict($key = null)
-    {
+    public function uniqueStrict($key = null) {
         return $this->unique($key, true);
     }
 
@@ -1413,8 +1326,7 @@ 
      *
      * @return static
      */
-    public function values()
-    {
+    public function values() {
         return new static(array_values($this->items));
     }
 
@@ -1424,8 +1336,7 @@ 
      * @param  string  $value
      * @return callable
      */
-    protected function valueRetriever($value)
-    {
+    protected function valueRetriever($value) {
         if ($this->useAsCallable($value)) {
             return $value;
         }
@@ -1444,8 +1355,7 @@ 
      * @param  mixed ...$items
      * @return static
      */
-    public function zip($items)
-    {
+    public function zip($items) {
         $arrayableItems = array_map(function ($items) {
             return $this->getArrayableItems($items);
         }, func_get_args());
@@ -1462,8 +1372,7 @@ 
      *
      * @return array
      */
-    public function toArray()
-    {
+    public function toArray() {
         return array_map(function ($value) {
             return $value instanceof Arrayable ? $value->toArray() : $value;
         }, $this->items);
@@ -1474,8 +1383,7 @@ 
      *
      * @return array
      */
-    public function jsonSerialize()
-    {
+    public function jsonSerialize() {
         return array_map(function ($value) {
             if ($value instanceof JsonSerializable) {
                 return $value->jsonSerialize();
@@ -1495,8 +1403,7 @@ 
      * @param  int  $options
      * @return string
      */
-    public function toJson($options = 0)
-    {
+    public function toJson($options = 0) {
         return json_encode($this->jsonSerialize(), $options);
     }
 
@@ -1505,8 +1412,7 @@ 
      *
      * @return \ArrayIterator
      */
-    public function getIterator()
-    {
+    public function getIterator() {
         return new ArrayIterator($this->items);
     }
 
@@ -1516,8 +1422,7 @@ 
      * @param  int  $flags
      * @return \CachingIterator
      */
-    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
-    {
+    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING) {
         return new CachingIterator($this->getIterator(), $flags);
     }
 
@@ -1526,8 +1431,7 @@ 
      *
      * @return int
      */
-    public function count()
-    {
+    public function count() {
         return count($this->items);
     }
 
@@ -1536,8 +1440,7 @@ 
      *
      * @return \Illuminate\Support\Collection
      */
-    public function toBase()
-    {
+    public function toBase() {
         return new self($this);
     }
 
@@ -1547,8 +1450,7 @@ 
      * @param  mixed  $key
      * @return bool
      */
-    public function offsetExists($key)
-    {
+    public function offsetExists($key) {
         return array_key_exists($key, $this->items);
     }
 
@@ -1558,8 +1460,7 @@ 
      * @param  mixed  $key
      * @return mixed
      */
-    public function offsetGet($key)
-    {
+    public function offsetGet($key) {
         return $this->items[$key];
     }
 
@@ -1570,8 +1471,7 @@ 
      * @param  mixed  $value
      * @return void
      */
-    public function offsetSet($key, $value)
-    {
+    public function offsetSet($key, $value) {
         if (is_null($key)) {
             $this->items[] = $value;
         } else {
@@ -1585,8 +1485,7 @@ 
      * @param  string  $key
      * @return void
      */
-    public function offsetUnset($key)
-    {
+    public function offsetUnset($key) {
         unset($this->items[$key]);
     }
 
@@ -1595,8 +1494,7 @@ 
      *
      * @return string
      */
-    public function __toString()
-    {
+    public function __toString() {
         return $this->toJson();
     }
 
@@ -1606,8 +1504,7 @@ 
      * @param  mixed  $items
      * @return array
      */
-    protected function getArrayableItems($items)
-    {
+    protected function getArrayableItems($items) {
         if (is_array($items)) {
             return $items;
         } elseif ($items instanceof self) {
@@ -1631,8 +1528,7 @@ 
      * @param  string  $method
      * @return void
      */
-    public static function proxy($method)
-    {
+    public static function proxy($method) {
         static::$proxies[] = $method;
     }
 
@@ -1644,8 +1540,7 @@ 
      *
      * @throws \Exception
      */
-    public function __get($key)
-    {
+    public function __get($key) {
         if (! in_array($key, static::$proxies)) {
             throw new Exception("Property [{$key}] does not exist on this collection instance.");
         }

vendor/illuminate/support/Facades/Input.php

Indentation +22 added lines, -22 removed lines

@@ -7,27 +7,27 @@
  */
 class Input extends Facade
 {
-    /**
-     * Get an item from the input data.
-     *
-     * This method is used for all request verbs (GET, POST, PUT, and DELETE)
-     *
-     * @param  string  $key
-     * @param  mixed   $default
-     * @return mixed
-     */
-    public static function get($key = null, $default = null)
-    {
-        return static::$app['request']->input($key, $default);
-    }
+	/**
+	 * Get an item from the input data.
+	 *
+	 * This method is used for all request verbs (GET, POST, PUT, and DELETE)
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public static function get($key = null, $default = null)
+	{
+		return static::$app['request']->input($key, $default);
+	}
 
-    /**
-     * Get the registered name of the component.
-     *
-     * @return string
-     */
-    protected static function getFacadeAccessor()
-    {
-        return 'request';
-    }
+	/**
+	 * Get the registered name of the component.
+	 *
+	 * @return string
+	 */
+	protected static function getFacadeAccessor()
+	{
+		return 'request';
+	}
 }

Braces +3 added lines, -6 removed lines

@@ -5,8 +5,7 @@ 
 /**
  * @see \Illuminate\Http\Request
  */
-class Input extends Facade
-{
+class Input extends Facade {
     /**
      * Get an item from the input data.
      *
@@ -16,8 +15,7 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function get($key = null, $default = null)
-    {
+    public static function get($key = null, $default = null) {
         return static::$app['request']->input($key, $default);
     }
 
@@ -26,8 +24,7 @@ 
      *
      * @return string
      */
-    protected static function getFacadeAccessor()
-    {
+    protected static function getFacadeAccessor() {
         return 'request';
     }
 }

vendor/illuminate/support/Arr.php

Indentation +591 added lines, -591 removed lines

@@ -8,595 +8,595 @@
 
 class Arr
 {
-    use Macroable;
-
-    /**
-     * Determine whether the given value is array accessible.
-     *
-     * @param  mixed  $value
-     * @return bool
-     */
-    public static function accessible($value)
-    {
-        return is_array($value) || $value instanceof ArrayAccess;
-    }
-
-    /**
-     * Add an element to an array using "dot" notation if it doesn't exist.
-     *
-     * @param  array   $array
-     * @param  string  $key
-     * @param  mixed   $value
-     * @return array
-     */
-    public static function add($array, $key, $value)
-    {
-        if (is_null(static::get($array, $key))) {
-            static::set($array, $key, $value);
-        }
-
-        return $array;
-    }
-
-    /**
-     * Collapse an array of arrays into a single array.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function collapse($array)
-    {
-        $results = [];
-
-        foreach ($array as $values) {
-            if ($values instanceof Collection) {
-                $values = $values->all();
-            } elseif (! is_array($values)) {
-                continue;
-            }
-
-            $results = array_merge($results, $values);
-        }
-
-        return $results;
-    }
-
-    /**
-     * Cross join the given arrays, returning all possible permutations.
-     *
-     * @param  array  ...$arrays
-     * @return array
-     */
-    public static function crossJoin(...$arrays)
-    {
-        $results = [[]];
-
-        foreach ($arrays as $index => $array) {
-            $append = [];
-
-            foreach ($results as $product) {
-                foreach ($array as $item) {
-                    $product[$index] = $item;
-
-                    $append[] = $product;
-                }
-            }
-
-            $results = $append;
-        }
-
-        return $results;
-    }
-
-    /**
-     * Divide an array into two arrays. One with keys and the other with values.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function divide($array)
-    {
-        return [array_keys($array), array_values($array)];
-    }
-
-    /**
-     * Flatten a multi-dimensional associative array with dots.
-     *
-     * @param  array   $array
-     * @param  string  $prepend
-     * @return array
-     */
-    public static function dot($array, $prepend = '')
-    {
-        $results = [];
-
-        foreach ($array as $key => $value) {
-            if (is_array($value) && ! empty($value)) {
-                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
-            } else {
-                $results[$prepend.$key] = $value;
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Get all of the given array except for a specified array of items.
-     *
-     * @param  array  $array
-     * @param  array|string  $keys
-     * @return array
-     */
-    public static function except($array, $keys)
-    {
-        static::forget($array, $keys);
-
-        return $array;
-    }
-
-    /**
-     * Determine if the given key exists in the provided array.
-     *
-     * @param  \ArrayAccess|array  $array
-     * @param  string|int  $key
-     * @return bool
-     */
-    public static function exists($array, $key)
-    {
-        if ($array instanceof ArrayAccess) {
-            return $array->offsetExists($key);
-        }
-
-        return array_key_exists($key, $array);
-    }
-
-    /**
-     * Return the first element in an array passing a given truth test.
-     *
-     * @param  array  $array
-     * @param  callable|null  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public static function first($array, callable $callback = null, $default = null)
-    {
-        if (is_null($callback)) {
-            if (empty($array)) {
-                return value($default);
-            }
-
-            foreach ($array as $item) {
-                return $item;
-            }
-        }
-
-        foreach ($array as $key => $value) {
-            if (call_user_func($callback, $value, $key)) {
-                return $value;
-            }
-        }
-
-        return value($default);
-    }
-
-    /**
-     * Return the last element in an array passing a given truth test.
-     *
-     * @param  array  $array
-     * @param  callable|null  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public static function last($array, callable $callback = null, $default = null)
-    {
-        if (is_null($callback)) {
-            return empty($array) ? value($default) : end($array);
-        }
-
-        return static::first(array_reverse($array, true), $callback, $default);
-    }
-
-    /**
-     * Flatten a multi-dimensional array into a single level.
-     *
-     * @param  array  $array
-     * @param  int  $depth
-     * @return array
-     */
-    public static function flatten($array, $depth = INF)
-    {
-        return array_reduce($array, function ($result, $item) use ($depth) {
-            $item = $item instanceof Collection ? $item->all() : $item;
-
-            if (! is_array($item)) {
-                return array_merge($result, [$item]);
-            } elseif ($depth === 1) {
-                return array_merge($result, array_values($item));
-            } else {
-                return array_merge($result, static::flatten($item, $depth - 1));
-            }
-        }, []);
-    }
-
-    /**
-     * Remove one or many array items from a given array using "dot" notation.
-     *
-     * @param  array  $array
-     * @param  array|string  $keys
-     * @return void
-     */
-    public static function forget(&$array, $keys)
-    {
-        $original = &$array;
-
-        $keys = (array) $keys;
-
-        if (count($keys) === 0) {
-            return;
-        }
-
-        foreach ($keys as $key) {
-            // if the exact key exists in the top-level, remove it
-            if (static::exists($array, $key)) {
-                unset($array[$key]);
-
-                continue;
-            }
-
-            $parts = explode('.', $key);
-
-            // clean up before each pass
-            $array = &$original;
-
-            while (count($parts) > 1) {
-                $part = array_shift($parts);
-
-                if (isset($array[$part]) && is_array($array[$part])) {
-                    $array = &$array[$part];
-                } else {
-                    continue 2;
-                }
-            }
-
-            unset($array[array_shift($parts)]);
-        }
-    }
-
-    /**
-     * Get an item from an array using "dot" notation.
-     *
-     * @param  \ArrayAccess|array  $array
-     * @param  string  $key
-     * @param  mixed   $default
-     * @return mixed
-     */
-    public static function get($array, $key, $default = null)
-    {
-        if (! static::accessible($array)) {
-            return value($default);
-        }
-
-        if (is_null($key)) {
-            return $array;
-        }
-
-        if (static::exists($array, $key)) {
-            return $array[$key];
-        }
-
-        foreach (explode('.', $key) as $segment) {
-            if (static::accessible($array) && static::exists($array, $segment)) {
-                $array = $array[$segment];
-            } else {
-                return value($default);
-            }
-        }
-
-        return $array;
-    }
-
-    /**
-     * Check if an item or items exist in an array using "dot" notation.
-     *
-     * @param  \ArrayAccess|array  $array
-     * @param  string|array  $keys
-     * @return bool
-     */
-    public static function has($array, $keys)
-    {
-        if (is_null($keys)) {
-            return false;
-        }
-
-        $keys = (array) $keys;
-
-        if (! $array) {
-            return false;
-        }
-
-        if ($keys === []) {
-            return false;
-        }
-
-        foreach ($keys as $key) {
-            $subKeyArray = $array;
-
-            if (static::exists($array, $key)) {
-                continue;
-            }
-
-            foreach (explode('.', $key) as $segment) {
-                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
-                    $subKeyArray = $subKeyArray[$segment];
-                } else {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Determines if an array is associative.
-     *
-     * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
-     *
-     * @param  array  $array
-     * @return bool
-     */
-    public static function isAssoc(array $array)
-    {
-        $keys = array_keys($array);
-
-        return array_keys($keys) !== $keys;
-    }
-
-    /**
-     * Get a subset of the items from the given array.
-     *
-     * @param  array  $array
-     * @param  array|string  $keys
-     * @return array
-     */
-    public static function only($array, $keys)
-    {
-        return array_intersect_key($array, array_flip((array) $keys));
-    }
-
-    /**
-     * Pluck an array of values from an array.
-     *
-     * @param  array  $array
-     * @param  string|array  $value
-     * @param  string|array|null  $key
-     * @return array
-     */
-    public static function pluck($array, $value, $key = null)
-    {
-        $results = [];
-
-        list($value, $key) = static::explodePluckParameters($value, $key);
-
-        foreach ($array as $item) {
-            $itemValue = data_get($item, $value);
-
-            // If the key is "null", we will just append the value to the array and keep
-            // looping. Otherwise we will key the array using the value of the key we
-            // received from the developer. Then we'll return the final array form.
-            if (is_null($key)) {
-                $results[] = $itemValue;
-            } else {
-                $itemKey = data_get($item, $key);
-
-                if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
-                    $itemKey = (string) $itemKey;
-                }
-
-                $results[$itemKey] = $itemValue;
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Explode the "value" and "key" arguments passed to "pluck".
-     *
-     * @param  string|array  $value
-     * @param  string|array|null  $key
-     * @return array
-     */
-    protected static function explodePluckParameters($value, $key)
-    {
-        $value = is_string($value) ? explode('.', $value) : $value;
-
-        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
-
-        return [$value, $key];
-    }
-
-    /**
-     * Push an item onto the beginning of an array.
-     *
-     * @param  array  $array
-     * @param  mixed  $value
-     * @param  mixed  $key
-     * @return array
-     */
-    public static function prepend($array, $value, $key = null)
-    {
-        if (is_null($key)) {
-            array_unshift($array, $value);
-        } else {
-            $array = [$key => $value] + $array;
-        }
-
-        return $array;
-    }
-
-    /**
-     * Get a value from the array, and remove it.
-     *
-     * @param  array   $array
-     * @param  string  $key
-     * @param  mixed   $default
-     * @return mixed
-     */
-    public static function pull(&$array, $key, $default = null)
-    {
-        $value = static::get($array, $key, $default);
-
-        static::forget($array, $key);
-
-        return $value;
-    }
-
-    /**
-     * Get one or a specified number of random values from an array.
-     *
-     * @param  array  $array
-     * @param  int|null  $number
-     * @return mixed
-     *
-     * @throws \InvalidArgumentException
-     */
-    public static function random($array, $number = null)
-    {
-        $requested = is_null($number) ? 1 : $number;
-
-        $count = count($array);
-
-        if ($requested > $count) {
-            throw new InvalidArgumentException(
-                "You requested {$requested} items, but there are only {$count} items available."
-            );
-        }
-
-        if (is_null($number)) {
-            return $array[array_rand($array)];
-        }
-
-        if ((int) $number === 0) {
-            return [];
-        }
-
-        $keys = array_rand($array, $number);
-
-        $results = [];
-
-        foreach ((array) $keys as $key) {
-            $results[] = $array[$key];
-        }
-
-        return $results;
-    }
-
-    /**
-     * Set an array item to a given value using "dot" notation.
-     *
-     * If no key is given to the method, the entire array will be replaced.
-     *
-     * @param  array   $array
-     * @param  string  $key
-     * @param  mixed   $value
-     * @return array
-     */
-    public static function set(&$array, $key, $value)
-    {
-        if (is_null($key)) {
-            return $array = $value;
-        }
-
-        $keys = explode('.', $key);
-
-        while (count($keys) > 1) {
-            $key = array_shift($keys);
-
-            // If the key doesn't exist at this depth, we will just create an empty array
-            // to hold the next value, allowing us to create the arrays to hold final
-            // values at the correct depth. Then we'll keep digging into the array.
-            if (! isset($array[$key]) || ! is_array($array[$key])) {
-                $array[$key] = [];
-            }
-
-            $array = &$array[$key];
-        }
-
-        $array[array_shift($keys)] = $value;
-
-        return $array;
-    }
-
-    /**
-     * Shuffle the given array and return the result.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function shuffle($array)
-    {
-        shuffle($array);
-
-        return $array;
-    }
-
-    /**
-     * Sort the array using the given callback or "dot" notation.
-     *
-     * @param  array  $array
-     * @param  callable|string  $callback
-     * @return array
-     */
-    public static function sort($array, $callback)
-    {
-        return Collection::make($array)->sortBy($callback)->all();
-    }
-
-    /**
-     * Recursively sort an array by keys and values.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function sortRecursive($array)
-    {
-        foreach ($array as &$value) {
-            if (is_array($value)) {
-                $value = static::sortRecursive($value);
-            }
-        }
-
-        if (static::isAssoc($array)) {
-            ksort($array);
-        } else {
-            sort($array);
-        }
-
-        return $array;
-    }
-
-    /**
-     * Filter the array using the given callback.
-     *
-     * @param  array  $array
-     * @param  callable  $callback
-     * @return array
-     */
-    public static function where($array, callable $callback)
-    {
-        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
-    }
-
-    /**
-     * If the given value is not an array, wrap it in one.
-     *
-     * @param  mixed  $value
-     * @return array
-     */
-    public static function wrap($value)
-    {
-        return ! is_array($value) ? [$value] : $value;
-    }
+	use Macroable;
+
+	/**
+	 * Determine whether the given value is array accessible.
+	 *
+	 * @param  mixed  $value
+	 * @return bool
+	 */
+	public static function accessible($value)
+	{
+		return is_array($value) || $value instanceof ArrayAccess;
+	}
+
+	/**
+	 * Add an element to an array using "dot" notation if it doesn't exist.
+	 *
+	 * @param  array   $array
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return array
+	 */
+	public static function add($array, $key, $value)
+	{
+		if (is_null(static::get($array, $key))) {
+			static::set($array, $key, $value);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Collapse an array of arrays into a single array.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function collapse($array)
+	{
+		$results = [];
+
+		foreach ($array as $values) {
+			if ($values instanceof Collection) {
+				$values = $values->all();
+			} elseif (! is_array($values)) {
+				continue;
+			}
+
+			$results = array_merge($results, $values);
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Cross join the given arrays, returning all possible permutations.
+	 *
+	 * @param  array  ...$arrays
+	 * @return array
+	 */
+	public static function crossJoin(...$arrays)
+	{
+		$results = [[]];
+
+		foreach ($arrays as $index => $array) {
+			$append = [];
+
+			foreach ($results as $product) {
+				foreach ($array as $item) {
+					$product[$index] = $item;
+
+					$append[] = $product;
+				}
+			}
+
+			$results = $append;
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Divide an array into two arrays. One with keys and the other with values.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function divide($array)
+	{
+		return [array_keys($array), array_values($array)];
+	}
+
+	/**
+	 * Flatten a multi-dimensional associative array with dots.
+	 *
+	 * @param  array   $array
+	 * @param  string  $prepend
+	 * @return array
+	 */
+	public static function dot($array, $prepend = '')
+	{
+		$results = [];
+
+		foreach ($array as $key => $value) {
+			if (is_array($value) && ! empty($value)) {
+				$results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+			} else {
+				$results[$prepend.$key] = $value;
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Get all of the given array except for a specified array of items.
+	 *
+	 * @param  array  $array
+	 * @param  array|string  $keys
+	 * @return array
+	 */
+	public static function except($array, $keys)
+	{
+		static::forget($array, $keys);
+
+		return $array;
+	}
+
+	/**
+	 * Determine if the given key exists in the provided array.
+	 *
+	 * @param  \ArrayAccess|array  $array
+	 * @param  string|int  $key
+	 * @return bool
+	 */
+	public static function exists($array, $key)
+	{
+		if ($array instanceof ArrayAccess) {
+			return $array->offsetExists($key);
+		}
+
+		return array_key_exists($key, $array);
+	}
+
+	/**
+	 * Return the first element in an array passing a given truth test.
+	 *
+	 * @param  array  $array
+	 * @param  callable|null  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public static function first($array, callable $callback = null, $default = null)
+	{
+		if (is_null($callback)) {
+			if (empty($array)) {
+				return value($default);
+			}
+
+			foreach ($array as $item) {
+				return $item;
+			}
+		}
+
+		foreach ($array as $key => $value) {
+			if (call_user_func($callback, $value, $key)) {
+				return $value;
+			}
+		}
+
+		return value($default);
+	}
+
+	/**
+	 * Return the last element in an array passing a given truth test.
+	 *
+	 * @param  array  $array
+	 * @param  callable|null  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public static function last($array, callable $callback = null, $default = null)
+	{
+		if (is_null($callback)) {
+			return empty($array) ? value($default) : end($array);
+		}
+
+		return static::first(array_reverse($array, true), $callback, $default);
+	}
+
+	/**
+	 * Flatten a multi-dimensional array into a single level.
+	 *
+	 * @param  array  $array
+	 * @param  int  $depth
+	 * @return array
+	 */
+	public static function flatten($array, $depth = INF)
+	{
+		return array_reduce($array, function ($result, $item) use ($depth) {
+			$item = $item instanceof Collection ? $item->all() : $item;
+
+			if (! is_array($item)) {
+				return array_merge($result, [$item]);
+			} elseif ($depth === 1) {
+				return array_merge($result, array_values($item));
+			} else {
+				return array_merge($result, static::flatten($item, $depth - 1));
+			}
+		}, []);
+	}
+
+	/**
+	 * Remove one or many array items from a given array using "dot" notation.
+	 *
+	 * @param  array  $array
+	 * @param  array|string  $keys
+	 * @return void
+	 */
+	public static function forget(&$array, $keys)
+	{
+		$original = &$array;
+
+		$keys = (array) $keys;
+
+		if (count($keys) === 0) {
+			return;
+		}
+
+		foreach ($keys as $key) {
+			// if the exact key exists in the top-level, remove it
+			if (static::exists($array, $key)) {
+				unset($array[$key]);
+
+				continue;
+			}
+
+			$parts = explode('.', $key);
+
+			// clean up before each pass
+			$array = &$original;
+
+			while (count($parts) > 1) {
+				$part = array_shift($parts);
+
+				if (isset($array[$part]) && is_array($array[$part])) {
+					$array = &$array[$part];
+				} else {
+					continue 2;
+				}
+			}
+
+			unset($array[array_shift($parts)]);
+		}
+	}
+
+	/**
+	 * Get an item from an array using "dot" notation.
+	 *
+	 * @param  \ArrayAccess|array  $array
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public static function get($array, $key, $default = null)
+	{
+		if (! static::accessible($array)) {
+			return value($default);
+		}
+
+		if (is_null($key)) {
+			return $array;
+		}
+
+		if (static::exists($array, $key)) {
+			return $array[$key];
+		}
+
+		foreach (explode('.', $key) as $segment) {
+			if (static::accessible($array) && static::exists($array, $segment)) {
+				$array = $array[$segment];
+			} else {
+				return value($default);
+			}
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Check if an item or items exist in an array using "dot" notation.
+	 *
+	 * @param  \ArrayAccess|array  $array
+	 * @param  string|array  $keys
+	 * @return bool
+	 */
+	public static function has($array, $keys)
+	{
+		if (is_null($keys)) {
+			return false;
+		}
+
+		$keys = (array) $keys;
+
+		if (! $array) {
+			return false;
+		}
+
+		if ($keys === []) {
+			return false;
+		}
+
+		foreach ($keys as $key) {
+			$subKeyArray = $array;
+
+			if (static::exists($array, $key)) {
+				continue;
+			}
+
+			foreach (explode('.', $key) as $segment) {
+				if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
+					$subKeyArray = $subKeyArray[$segment];
+				} else {
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Determines if an array is associative.
+	 *
+	 * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
+	 *
+	 * @param  array  $array
+	 * @return bool
+	 */
+	public static function isAssoc(array $array)
+	{
+		$keys = array_keys($array);
+
+		return array_keys($keys) !== $keys;
+	}
+
+	/**
+	 * Get a subset of the items from the given array.
+	 *
+	 * @param  array  $array
+	 * @param  array|string  $keys
+	 * @return array
+	 */
+	public static function only($array, $keys)
+	{
+		return array_intersect_key($array, array_flip((array) $keys));
+	}
+
+	/**
+	 * Pluck an array of values from an array.
+	 *
+	 * @param  array  $array
+	 * @param  string|array  $value
+	 * @param  string|array|null  $key
+	 * @return array
+	 */
+	public static function pluck($array, $value, $key = null)
+	{
+		$results = [];
+
+		list($value, $key) = static::explodePluckParameters($value, $key);
+
+		foreach ($array as $item) {
+			$itemValue = data_get($item, $value);
+
+			// If the key is "null", we will just append the value to the array and keep
+			// looping. Otherwise we will key the array using the value of the key we
+			// received from the developer. Then we'll return the final array form.
+			if (is_null($key)) {
+				$results[] = $itemValue;
+			} else {
+				$itemKey = data_get($item, $key);
+
+				if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
+					$itemKey = (string) $itemKey;
+				}
+
+				$results[$itemKey] = $itemValue;
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Explode the "value" and "key" arguments passed to "pluck".
+	 *
+	 * @param  string|array  $value
+	 * @param  string|array|null  $key
+	 * @return array
+	 */
+	protected static function explodePluckParameters($value, $key)
+	{
+		$value = is_string($value) ? explode('.', $value) : $value;
+
+		$key = is_null($key) || is_array($key) ? $key : explode('.', $key);
+
+		return [$value, $key];
+	}
+
+	/**
+	 * Push an item onto the beginning of an array.
+	 *
+	 * @param  array  $array
+	 * @param  mixed  $value
+	 * @param  mixed  $key
+	 * @return array
+	 */
+	public static function prepend($array, $value, $key = null)
+	{
+		if (is_null($key)) {
+			array_unshift($array, $value);
+		} else {
+			$array = [$key => $value] + $array;
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Get a value from the array, and remove it.
+	 *
+	 * @param  array   $array
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public static function pull(&$array, $key, $default = null)
+	{
+		$value = static::get($array, $key, $default);
+
+		static::forget($array, $key);
+
+		return $value;
+	}
+
+	/**
+	 * Get one or a specified number of random values from an array.
+	 *
+	 * @param  array  $array
+	 * @param  int|null  $number
+	 * @return mixed
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public static function random($array, $number = null)
+	{
+		$requested = is_null($number) ? 1 : $number;
+
+		$count = count($array);
+
+		if ($requested > $count) {
+			throw new InvalidArgumentException(
+				"You requested {$requested} items, but there are only {$count} items available."
+			);
+		}
+
+		if (is_null($number)) {
+			return $array[array_rand($array)];
+		}
+
+		if ((int) $number === 0) {
+			return [];
+		}
+
+		$keys = array_rand($array, $number);
+
+		$results = [];
+
+		foreach ((array) $keys as $key) {
+			$results[] = $array[$key];
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Set an array item to a given value using "dot" notation.
+	 *
+	 * If no key is given to the method, the entire array will be replaced.
+	 *
+	 * @param  array   $array
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return array
+	 */
+	public static function set(&$array, $key, $value)
+	{
+		if (is_null($key)) {
+			return $array = $value;
+		}
+
+		$keys = explode('.', $key);
+
+		while (count($keys) > 1) {
+			$key = array_shift($keys);
+
+			// If the key doesn't exist at this depth, we will just create an empty array
+			// to hold the next value, allowing us to create the arrays to hold final
+			// values at the correct depth. Then we'll keep digging into the array.
+			if (! isset($array[$key]) || ! is_array($array[$key])) {
+				$array[$key] = [];
+			}
+
+			$array = &$array[$key];
+		}
+
+		$array[array_shift($keys)] = $value;
+
+		return $array;
+	}
+
+	/**
+	 * Shuffle the given array and return the result.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function shuffle($array)
+	{
+		shuffle($array);
+
+		return $array;
+	}
+
+	/**
+	 * Sort the array using the given callback or "dot" notation.
+	 *
+	 * @param  array  $array
+	 * @param  callable|string  $callback
+	 * @return array
+	 */
+	public static function sort($array, $callback)
+	{
+		return Collection::make($array)->sortBy($callback)->all();
+	}
+
+	/**
+	 * Recursively sort an array by keys and values.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function sortRecursive($array)
+	{
+		foreach ($array as &$value) {
+			if (is_array($value)) {
+				$value = static::sortRecursive($value);
+			}
+		}
+
+		if (static::isAssoc($array)) {
+			ksort($array);
+		} else {
+			sort($array);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Filter the array using the given callback.
+	 *
+	 * @param  array  $array
+	 * @param  callable  $callback
+	 * @return array
+	 */
+	public static function where($array, callable $callback)
+	{
+		return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
+	}
+
+	/**
+	 * If the given value is not an array, wrap it in one.
+	 *
+	 * @param  mixed  $value
+	 * @return array
+	 */
+	public static function wrap($value)
+	{
+		return ! is_array($value) ? [$value] : $value;
+	}
 }

Braces +28 added lines, -56 removed lines

@@ -6,8 +6,7 @@ 
 use InvalidArgumentException;
 use Illuminate\Support\Traits\Macroable;
 
-class Arr
-{
+class Arr {
     use Macroable;
 
     /**
@@ -16,8 +15,7 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public static function accessible($value)
-    {
+    public static function accessible($value) {
         return is_array($value) || $value instanceof ArrayAccess;
     }
 
@@ -29,8 +27,7 @@ 
      * @param  mixed   $value
      * @return array
      */
-    public static function add($array, $key, $value)
-    {
+    public static function add($array, $key, $value) {
         if (is_null(static::get($array, $key))) {
             static::set($array, $key, $value);
         }
@@ -44,8 +41,7 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function collapse($array)
-    {
+    public static function collapse($array) {
         $results = [];
 
         foreach ($array as $values) {
@@ -67,8 +63,7 @@ 
      * @param  array  ...$arrays
      * @return array
      */
-    public static function crossJoin(...$arrays)
-    {
+    public static function crossJoin(...$arrays) {
         $results = [[]];
 
         foreach ($arrays as $index => $array) {
@@ -94,8 +89,7 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function divide($array)
-    {
+    public static function divide($array) {
         return [array_keys($array), array_values($array)];
     }
 
@@ -106,8 +100,7 @@ 
      * @param  string  $prepend
      * @return array
      */
-    public static function dot($array, $prepend = '')
-    {
+    public static function dot($array, $prepend = '') {
         $results = [];
 
         foreach ($array as $key => $value) {
@@ -128,8 +121,7 @@ 
      * @param  array|string  $keys
      * @return array
      */
-    public static function except($array, $keys)
-    {
+    public static function except($array, $keys) {
         static::forget($array, $keys);
 
         return $array;
@@ -142,8 +134,7 @@ 
      * @param  string|int  $key
      * @return bool
      */
-    public static function exists($array, $key)
-    {
+    public static function exists($array, $key) {
         if ($array instanceof ArrayAccess) {
             return $array->offsetExists($key);
         }
@@ -159,8 +150,7 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public static function first($array, callable $callback = null, $default = null)
-    {
+    public static function first($array, callable $callback = null, $default = null) {
         if (is_null($callback)) {
             if (empty($array)) {
                 return value($default);
@@ -188,8 +178,7 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public static function last($array, callable $callback = null, $default = null)
-    {
+    public static function last($array, callable $callback = null, $default = null) {
         if (is_null($callback)) {
             return empty($array) ? value($default) : end($array);
         }
@@ -204,8 +193,7 @@ 
      * @param  int  $depth
      * @return array
      */
-    public static function flatten($array, $depth = INF)
-    {
+    public static function flatten($array, $depth = INF) {
         return array_reduce($array, function ($result, $item) use ($depth) {
             $item = $item instanceof Collection ? $item->all() : $item;
 
@@ -226,8 +214,7 @@ 
      * @param  array|string  $keys
      * @return void
      */
-    public static function forget(&$array, $keys)
-    {
+    public static function forget(&$array, $keys) {
         $original = &$array;
 
         $keys = (array) $keys;
@@ -271,8 +258,7 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function get($array, $key, $default = null)
-    {
+    public static function get($array, $key, $default = null) {
         if (! static::accessible($array)) {
             return value($default);
         }
@@ -303,8 +289,7 @@ 
      * @param  string|array  $keys
      * @return bool
      */
-    public static function has($array, $keys)
-    {
+    public static function has($array, $keys) {
         if (is_null($keys)) {
             return false;
         }
@@ -346,8 +331,7 @@ 
      * @param  array  $array
      * @return bool
      */
-    public static function isAssoc(array $array)
-    {
+    public static function isAssoc(array $array) {
         $keys = array_keys($array);
 
         return array_keys($keys) !== $keys;
@@ -360,8 +344,7 @@ 
      * @param  array|string  $keys
      * @return array
      */
-    public static function only($array, $keys)
-    {
+    public static function only($array, $keys) {
         return array_intersect_key($array, array_flip((array) $keys));
     }
 
@@ -373,8 +356,7 @@ 
      * @param  string|array|null  $key
      * @return array
      */
-    public static function pluck($array, $value, $key = null)
-    {
+    public static function pluck($array, $value, $key = null) {
         $results = [];
 
         list($value, $key) = static::explodePluckParameters($value, $key);
@@ -408,8 +390,7 @@ 
      * @param  string|array|null  $key
      * @return array
      */
-    protected static function explodePluckParameters($value, $key)
-    {
+    protected static function explodePluckParameters($value, $key) {
         $value = is_string($value) ? explode('.', $value) : $value;
 
         $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
@@ -425,8 +406,7 @@ 
      * @param  mixed  $key
      * @return array
      */
-    public static function prepend($array, $value, $key = null)
-    {
+    public static function prepend($array, $value, $key = null) {
         if (is_null($key)) {
             array_unshift($array, $value);
         } else {
@@ -444,8 +424,7 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function pull(&$array, $key, $default = null)
-    {
+    public static function pull(&$array, $key, $default = null) {
         $value = static::get($array, $key, $default);
 
         static::forget($array, $key);
@@ -462,8 +441,7 @@ 
      *
      * @throws \InvalidArgumentException
      */
-    public static function random($array, $number = null)
-    {
+    public static function random($array, $number = null) {
         $requested = is_null($number) ? 1 : $number;
 
         $count = count($array);
@@ -503,8 +481,7 @@ 
      * @param  mixed   $value
      * @return array
      */
-    public static function set(&$array, $key, $value)
-    {
+    public static function set(&$array, $key, $value) {
         if (is_null($key)) {
             return $array = $value;
         }
@@ -535,8 +512,7 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function shuffle($array)
-    {
+    public static function shuffle($array) {
         shuffle($array);
 
         return $array;
@@ -549,8 +525,7 @@ 
      * @param  callable|string  $callback
      * @return array
      */
-    public static function sort($array, $callback)
-    {
+    public static function sort($array, $callback) {
         return Collection::make($array)->sortBy($callback)->all();
     }
 
@@ -560,8 +535,7 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function sortRecursive($array)
-    {
+    public static function sortRecursive($array) {
         foreach ($array as &$value) {
             if (is_array($value)) {
                 $value = static::sortRecursive($value);
@@ -584,8 +558,7 @@ 
      * @param  callable  $callback
      * @return array
      */
-    public static function where($array, callable $callback)
-    {
+    public static function where($array, callable $callback) {
         return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
     }
 
@@ -595,8 +568,7 @@ 
      * @param  mixed  $value
      * @return array
      */
-    public static function wrap($value)
-    {
+    public static function wrap($value) {
         return ! is_array($value) ? [$value] : $value;
     }
 }

vendor/illuminate/support/Debug/HtmlDumper.php

Indentation +20 added lines, -20 removed lines

@@ -6,24 +6,24 @@
 
 class HtmlDumper extends SymfonyHtmlDumper
 {
-    /**
-     * Colour definitions for output.
-     *
-     * @var array
-     */
-    protected $styles = [
-        'default' => 'background-color:#fff; color:#222; line-height:1.2em; font-weight:normal; font:12px Monaco, Consolas, monospace; word-wrap: break-word; white-space: pre-wrap; position:relative; z-index:100000',
-        'num' => 'color:#a71d5d',
-        'const' => 'color:#795da3',
-        'str' => 'color:#df5000',
-        'cchr' => 'color:#222',
-        'note' => 'color:#a71d5d',
-        'ref' => 'color:#a0a0a0',
-        'public' => 'color:#795da3',
-        'protected' => 'color:#795da3',
-        'private' => 'color:#795da3',
-        'meta' => 'color:#b729d9',
-        'key' => 'color:#df5000',
-        'index' => 'color:#a71d5d',
-    ];
+	/**
+	 * Colour definitions for output.
+	 *
+	 * @var array
+	 */
+	protected $styles = [
+		'default' => 'background-color:#fff; color:#222; line-height:1.2em; font-weight:normal; font:12px Monaco, Consolas, monospace; word-wrap: break-word; white-space: pre-wrap; position:relative; z-index:100000',
+		'num' => 'color:#a71d5d',
+		'const' => 'color:#795da3',
+		'str' => 'color:#df5000',
+		'cchr' => 'color:#222',
+		'note' => 'color:#a71d5d',
+		'ref' => 'color:#a0a0a0',
+		'public' => 'color:#795da3',
+		'protected' => 'color:#795da3',
+		'private' => 'color:#795da3',
+		'meta' => 'color:#b729d9',
+		'key' => 'color:#df5000',
+		'index' => 'color:#a71d5d',
+	];
 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 use Symfony\Component\VarDumper\Dumper\HtmlDumper as SymfonyHtmlDumper;
 
-class HtmlDumper extends SymfonyHtmlDumper
-{
+class HtmlDumper extends SymfonyHtmlDumper {
     /**
      * Colour definitions for output.
      *

vendor/illuminate/support/Debug/Dumper.php

Indentation +15 added lines, -15 removed lines

@@ -7,20 +7,20 @@
 
 class Dumper
 {
-    /**
-     * Dump a value with elegance.
-     *
-     * @param  mixed  $value
-     * @return void
-     */
-    public function dump($value)
-    {
-        if (class_exists(CliDumper::class)) {
-            $dumper = 'cli' === PHP_SAPI ? new CliDumper : new HtmlDumper;
+	/**
+	 * Dump a value with elegance.
+	 *
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function dump($value)
+	{
+		if (class_exists(CliDumper::class)) {
+			$dumper = 'cli' === PHP_SAPI ? new CliDumper : new HtmlDumper;
 
-            $dumper->dump((new VarCloner)->cloneVar($value));
-        } else {
-            var_dump($value);
-        }
-    }
+			$dumper->dump((new VarCloner)->cloneVar($value));
+		} else {
+			var_dump($value);
+		}
+	}
 }

Braces +2 added lines, -4 removed lines

@@ -5,16 +5,14 @@
 use Symfony\Component\VarDumper\Cloner\VarCloner;
 use Symfony\Component\VarDumper\Dumper\CliDumper;
 
-class Dumper
-{
+class Dumper {
     /**
      * Dump a value with elegance.
      *
      * @param  mixed  $value
      * @return void
      */
-    public function dump($value)
-    {
+    public function dump($value) {
         if (class_exists(CliDumper::class)) {
             $dumper = 'cli' === PHP_SAPI ? new CliDumper : new HtmlDumper;
 

vendor/illuminate/contracts/Logging/Log.php

Indentation +82 added lines, -82 removed lines

@@ -4,95 +4,95 @@
 
 interface Log
 {
-    /**
-     * Log an alert message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function alert($message, array $context = []);
+	/**
+	 * Log an alert message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function alert($message, array $context = []);
 
-    /**
-     * Log a critical message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function critical($message, array $context = []);
+	/**
+	 * Log a critical message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function critical($message, array $context = []);
 
-    /**
-     * Log an error message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function error($message, array $context = []);
+	/**
+	 * Log an error message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function error($message, array $context = []);
 
-    /**
-     * Log a warning message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function warning($message, array $context = []);
+	/**
+	 * Log a warning message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function warning($message, array $context = []);
 
-    /**
-     * Log a notice to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function notice($message, array $context = []);
+	/**
+	 * Log a notice to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function notice($message, array $context = []);
 
-    /**
-     * Log an informational message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function info($message, array $context = []);
+	/**
+	 * Log an informational message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function info($message, array $context = []);
 
-    /**
-     * Log a debug message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function debug($message, array $context = []);
+	/**
+	 * Log a debug message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function debug($message, array $context = []);
 
-    /**
-     * Log a message to the logs.
-     *
-     * @param  string  $level
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function log($level, $message, array $context = []);
+	/**
+	 * Log a message to the logs.
+	 *
+	 * @param  string  $level
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function log($level, $message, array $context = []);
 
-    /**
-     * Register a file log handler.
-     *
-     * @param  string  $path
-     * @param  string  $level
-     * @return void
-     */
-    public function useFiles($path, $level = 'debug');
+	/**
+	 * Register a file log handler.
+	 *
+	 * @param  string  $path
+	 * @param  string  $level
+	 * @return void
+	 */
+	public function useFiles($path, $level = 'debug');
 
-    /**
-     * Register a daily file log handler.
-     *
-     * @param  string  $path
-     * @param  int     $days
-     * @param  string  $level
-     * @return void
-     */
-    public function useDailyFiles($path, $days = 0, $level = 'debug');
+	/**
+	 * Register a daily file log handler.
+	 *
+	 * @param  string  $path
+	 * @param  int     $days
+	 * @param  string  $level
+	 * @return void
+	 */
+	public function useDailyFiles($path, $days = 0, $level = 'debug');
 }

Braces +1 added lines, -2 removed lines

@@ -2,8 +2,7 @@
 
 namespace Illuminate\Contracts\Logging;
 
-interface Log
-{
+interface Log {
     /**
      * Log an alert message to the logs.
      *

vendor/phpdocumentor/type-resolver/src/PseudoTypes/NegativeInteger.php

Indentation +11 added lines, -11 removed lines

@@ -24,16 +24,16 @@
  */
 final class NegativeInteger extends Integer implements PseudoType
 {
-    public function underlyingType(): Type
-    {
-        return new Integer();
-    }
+	public function underlyingType(): Type
+	{
+		return new Integer();
+	}
 
-    /**
-     * Returns a rendered output of the Type as it would be used in a DocBlock.
-     */
-    public function __toString(): string
-    {
-        return 'negative-int';
-    }
+	/**
+	 * Returns a rendered output of the Type as it would be used in a DocBlock.
+	 */
+	public function __toString(): string
+	{
+		return 'negative-int';
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -22,8 +22,7 @@
  *
  * @psalm-immutable
  */
-final class NegativeInteger extends Integer implements PseudoType
-{
+final class NegativeInteger extends Integer implements PseudoType {
     public function underlyingType(): Type
     {
         return new Integer();