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);
+	}
 }

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);
+		});
+	}
 }

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);
+	}
 }

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';
+	}
 }

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;
+	}
 }

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',
+	];
 }

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);
+		}
+	}
 }

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');
 }

vendor/composer/ClassLoader.php

Indentation +514 added lines, -514 removed lines

@@ -42,519 +42,519 @@ 
  */
 class ClassLoader
 {
-    /** @var ?string */
-    private $vendorDir;
-
-    // PSR-4
-    /**
-     * @var array[]
-     * @psalm-var array<string, array<string, int>>
-     */
-    private $prefixLengthsPsr4 = array();
-    /**
-     * @var array[]
-     * @psalm-var array<string, array<int, string>>
-     */
-    private $prefixDirsPsr4 = array();
-    /**
-     * @var array[]
-     * @psalm-var array<string, string>
-     */
-    private $fallbackDirsPsr4 = array();
-
-    // PSR-0
-    /**
-     * @var array[]
-     * @psalm-var array<string, array<string, string[]>>
-     */
-    private $prefixesPsr0 = array();
-    /**
-     * @var array[]
-     * @psalm-var array<string, string>
-     */
-    private $fallbackDirsPsr0 = array();
-
-    /** @var bool */
-    private $useIncludePath = false;
-
-    /**
-     * @var string[]
-     * @psalm-var array<string, string>
-     */
-    private $classMap = array();
-
-    /** @var bool */
-    private $classMapAuthoritative = false;
-
-    /**
-     * @var bool[]
-     * @psalm-var array<string, bool>
-     */
-    private $missingClasses = array();
-
-    /** @var ?string */
-    private $apcuPrefix;
-
-    /**
-     * @var self[]
-     */
-    private static $registeredLoaders = array();
-
-    /**
-     * @param ?string $vendorDir
-     */
-    public function __construct($vendorDir = null)
-    {
-        $this->vendorDir = $vendorDir;
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getPrefixes()
-    {
-        if (!empty($this->prefixesPsr0)) {
-            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
-        }
-
-        return array();
-    }
-
-    /**
-     * @return array[]
-     * @psalm-return array<string, array<int, string>>
-     */
-    public function getPrefixesPsr4()
-    {
-        return $this->prefixDirsPsr4;
-    }
-
-    /**
-     * @return array[]
-     * @psalm-return array<string, string>
-     */
-    public function getFallbackDirs()
-    {
-        return $this->fallbackDirsPsr0;
-    }
-
-    /**
-     * @return array[]
-     * @psalm-return array<string, string>
-     */
-    public function getFallbackDirsPsr4()
-    {
-        return $this->fallbackDirsPsr4;
-    }
-
-    /**
-     * @return string[] Array of classname => path
-     * @psalm-return array<string, string>
-     */
-    public function getClassMap()
-    {
-        return $this->classMap;
-    }
-
-    /**
-     * @param string[] $classMap Class to filename map
-     * @psalm-param array<string, string> $classMap
-     *
-     * @return void
-     */
-    public function addClassMap(array $classMap)
-    {
-        if ($this->classMap) {
-            $this->classMap = array_merge($this->classMap, $classMap);
-        } else {
-            $this->classMap = $classMap;
-        }
-    }
-
-    /**
-     * Registers a set of PSR-0 directories for a given prefix, either
-     * appending or prepending to the ones previously set for this prefix.
-     *
-     * @param string          $prefix  The prefix
-     * @param string[]|string $paths   The PSR-0 root directories
-     * @param bool            $prepend Whether to prepend the directories
-     *
-     * @return void
-     */
-    public function add($prefix, $paths, $prepend = false)
-    {
-        if (!$prefix) {
-            if ($prepend) {
-                $this->fallbackDirsPsr0 = array_merge(
-                    (array) $paths,
-                    $this->fallbackDirsPsr0
-                );
-            } else {
-                $this->fallbackDirsPsr0 = array_merge(
-                    $this->fallbackDirsPsr0,
-                    (array) $paths
-                );
-            }
-
-            return;
-        }
-
-        $first = $prefix[0];
-        if (!isset($this->prefixesPsr0[$first][$prefix])) {
-            $this->prefixesPsr0[$first][$prefix] = (array) $paths;
-
-            return;
-        }
-        if ($prepend) {
-            $this->prefixesPsr0[$first][$prefix] = array_merge(
-                (array) $paths,
-                $this->prefixesPsr0[$first][$prefix]
-            );
-        } else {
-            $this->prefixesPsr0[$first][$prefix] = array_merge(
-                $this->prefixesPsr0[$first][$prefix],
-                (array) $paths
-            );
-        }
-    }
-
-    /**
-     * Registers a set of PSR-4 directories for a given namespace, either
-     * appending or prepending to the ones previously set for this namespace.
-     *
-     * @param string          $prefix  The prefix/namespace, with trailing '\\'
-     * @param string[]|string $paths   The PSR-4 base directories
-     * @param bool            $prepend Whether to prepend the directories
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    public function addPsr4($prefix, $paths, $prepend = false)
-    {
-        if (!$prefix) {
-            // Register directories for the root namespace.
-            if ($prepend) {
-                $this->fallbackDirsPsr4 = array_merge(
-                    (array) $paths,
-                    $this->fallbackDirsPsr4
-                );
-            } else {
-                $this->fallbackDirsPsr4 = array_merge(
-                    $this->fallbackDirsPsr4,
-                    (array) $paths
-                );
-            }
-        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
-            // Register directories for a new namespace.
-            $length = strlen($prefix);
-            if ('\\' !== $prefix[$length - 1]) {
-                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
-            }
-            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
-            $this->prefixDirsPsr4[$prefix] = (array) $paths;
-        } elseif ($prepend) {
-            // Prepend directories for an already registered namespace.
-            $this->prefixDirsPsr4[$prefix] = array_merge(
-                (array) $paths,
-                $this->prefixDirsPsr4[$prefix]
-            );
-        } else {
-            // Append directories for an already registered namespace.
-            $this->prefixDirsPsr4[$prefix] = array_merge(
-                $this->prefixDirsPsr4[$prefix],
-                (array) $paths
-            );
-        }
-    }
-
-    /**
-     * Registers a set of PSR-0 directories for a given prefix,
-     * replacing any others previously set for this prefix.
-     *
-     * @param string          $prefix The prefix
-     * @param string[]|string $paths  The PSR-0 base directories
-     *
-     * @return void
-     */
-    public function set($prefix, $paths)
-    {
-        if (!$prefix) {
-            $this->fallbackDirsPsr0 = (array) $paths;
-        } else {
-            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
-        }
-    }
-
-    /**
-     * Registers a set of PSR-4 directories for a given namespace,
-     * replacing any others previously set for this namespace.
-     *
-     * @param string          $prefix The prefix/namespace, with trailing '\\'
-     * @param string[]|string $paths  The PSR-4 base directories
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    public function setPsr4($prefix, $paths)
-    {
-        if (!$prefix) {
-            $this->fallbackDirsPsr4 = (array) $paths;
-        } else {
-            $length = strlen($prefix);
-            if ('\\' !== $prefix[$length - 1]) {
-                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
-            }
-            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
-            $this->prefixDirsPsr4[$prefix] = (array) $paths;
-        }
-    }
-
-    /**
-     * Turns on searching the include path for class files.
-     *
-     * @param bool $useIncludePath
-     *
-     * @return void
-     */
-    public function setUseIncludePath($useIncludePath)
-    {
-        $this->useIncludePath = $useIncludePath;
-    }
-
-    /**
-     * Can be used to check if the autoloader uses the include path to check
-     * for classes.
-     *
-     * @return bool
-     */
-    public function getUseIncludePath()
-    {
-        return $this->useIncludePath;
-    }
-
-    /**
-     * Turns off searching the prefix and fallback directories for classes
-     * that have not been registered with the class map.
-     *
-     * @param bool $classMapAuthoritative
-     *
-     * @return void
-     */
-    public function setClassMapAuthoritative($classMapAuthoritative)
-    {
-        $this->classMapAuthoritative = $classMapAuthoritative;
-    }
-
-    /**
-     * Should class lookup fail if not found in the current class map?
-     *
-     * @return bool
-     */
-    public function isClassMapAuthoritative()
-    {
-        return $this->classMapAuthoritative;
-    }
-
-    /**
-     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
-     *
-     * @param string|null $apcuPrefix
-     *
-     * @return void
-     */
-    public function setApcuPrefix($apcuPrefix)
-    {
-        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
-    }
-
-    /**
-     * The APCu prefix in use, or null if APCu caching is not enabled.
-     *
-     * @return string|null
-     */
-    public function getApcuPrefix()
-    {
-        return $this->apcuPrefix;
-    }
-
-    /**
-     * Registers this instance as an autoloader.
-     *
-     * @param bool $prepend Whether to prepend the autoloader or not
-     *
-     * @return void
-     */
-    public function register($prepend = false)
-    {
-        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
-
-        if (null === $this->vendorDir) {
-            return;
-        }
-
-        if ($prepend) {
-            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
-        } else {
-            unset(self::$registeredLoaders[$this->vendorDir]);
-            self::$registeredLoaders[$this->vendorDir] = $this;
-        }
-    }
-
-    /**
-     * Unregisters this instance as an autoloader.
-     *
-     * @return void
-     */
-    public function unregister()
-    {
-        spl_autoload_unregister(array($this, 'loadClass'));
-
-        if (null !== $this->vendorDir) {
-            unset(self::$registeredLoaders[$this->vendorDir]);
-        }
-    }
-
-    /**
-     * Loads the given class or interface.
-     *
-     * @param  string    $class The name of the class
-     * @return true|null True if loaded, null otherwise
-     */
-    public function loadClass($class)
-    {
-        if ($file = $this->findFile($class)) {
-            includeFile($file);
-
-            return true;
-        }
-
-        return null;
-    }
-
-    /**
-     * Finds the path to the file where the class is defined.
-     *
-     * @param string $class The name of the class
-     *
-     * @return string|false The path if found, false otherwise
-     */
-    public function findFile($class)
-    {
-        // class map lookup
-        if (isset($this->classMap[$class])) {
-            return $this->classMap[$class];
-        }
-        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
-            return false;
-        }
-        if (null !== $this->apcuPrefix) {
-            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
-            if ($hit) {
-                return $file;
-            }
-        }
-
-        $file = $this->findFileWithExtension($class, '.php');
-
-        // Search for Hack files if we are running on HHVM
-        if (false === $file && defined('HHVM_VERSION')) {
-            $file = $this->findFileWithExtension($class, '.hh');
-        }
-
-        if (null !== $this->apcuPrefix) {
-            apcu_add($this->apcuPrefix.$class, $file);
-        }
-
-        if (false === $file) {
-            // Remember that this class does not exist.
-            $this->missingClasses[$class] = true;
-        }
-
-        return $file;
-    }
-
-    /**
-     * Returns the currently registered loaders indexed by their corresponding vendor directories.
-     *
-     * @return self[]
-     */
-    public static function getRegisteredLoaders()
-    {
-        return self::$registeredLoaders;
-    }
-
-    /**
-     * @param  string       $class
-     * @param  string       $ext
-     * @return string|false
-     */
-    private function findFileWithExtension($class, $ext)
-    {
-        // PSR-4 lookup
-        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
-
-        $first = $class[0];
-        if (isset($this->prefixLengthsPsr4[$first])) {
-            $subPath = $class;
-            while (false !== $lastPos = strrpos($subPath, '\\')) {
-                $subPath = substr($subPath, 0, $lastPos);
-                $search = $subPath . '\\';
-                if (isset($this->prefixDirsPsr4[$search])) {
-                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
-                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
-                        if (file_exists($file = $dir . $pathEnd)) {
-                            return $file;
-                        }
-                    }
-                }
-            }
-        }
-
-        // PSR-4 fallback dirs
-        foreach ($this->fallbackDirsPsr4 as $dir) {
-            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
-                return $file;
-            }
-        }
-
-        // PSR-0 lookup
-        if (false !== $pos = strrpos($class, '\\')) {
-            // namespaced class name
-            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
-                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
-        } else {
-            // PEAR-like class name
-            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
-        }
-
-        if (isset($this->prefixesPsr0[$first])) {
-            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
-                if (0 === strpos($class, $prefix)) {
-                    foreach ($dirs as $dir) {
-                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
-                            return $file;
-                        }
-                    }
-                }
-            }
-        }
-
-        // PSR-0 fallback dirs
-        foreach ($this->fallbackDirsPsr0 as $dir) {
-            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
-                return $file;
-            }
-        }
-
-        // PSR-0 include paths.
-        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
-            return $file;
-        }
-
-        return false;
-    }
+	/** @var ?string */
+	private $vendorDir;
+
+	// PSR-4
+	/**
+	 * @var array[]
+	 * @psalm-var array<string, array<string, int>>
+	 */
+	private $prefixLengthsPsr4 = array();
+	/**
+	 * @var array[]
+	 * @psalm-var array<string, array<int, string>>
+	 */
+	private $prefixDirsPsr4 = array();
+	/**
+	 * @var array[]
+	 * @psalm-var array<string, string>
+	 */
+	private $fallbackDirsPsr4 = array();
+
+	// PSR-0
+	/**
+	 * @var array[]
+	 * @psalm-var array<string, array<string, string[]>>
+	 */
+	private $prefixesPsr0 = array();
+	/**
+	 * @var array[]
+	 * @psalm-var array<string, string>
+	 */
+	private $fallbackDirsPsr0 = array();
+
+	/** @var bool */
+	private $useIncludePath = false;
+
+	/**
+	 * @var string[]
+	 * @psalm-var array<string, string>
+	 */
+	private $classMap = array();
+
+	/** @var bool */
+	private $classMapAuthoritative = false;
+
+	/**
+	 * @var bool[]
+	 * @psalm-var array<string, bool>
+	 */
+	private $missingClasses = array();
+
+	/** @var ?string */
+	private $apcuPrefix;
+
+	/**
+	 * @var self[]
+	 */
+	private static $registeredLoaders = array();
+
+	/**
+	 * @param ?string $vendorDir
+	 */
+	public function __construct($vendorDir = null)
+	{
+		$this->vendorDir = $vendorDir;
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getPrefixes()
+	{
+		if (!empty($this->prefixesPsr0)) {
+			return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
+		}
+
+		return array();
+	}
+
+	/**
+	 * @return array[]
+	 * @psalm-return array<string, array<int, string>>
+	 */
+	public function getPrefixesPsr4()
+	{
+		return $this->prefixDirsPsr4;
+	}
+
+	/**
+	 * @return array[]
+	 * @psalm-return array<string, string>
+	 */
+	public function getFallbackDirs()
+	{
+		return $this->fallbackDirsPsr0;
+	}
+
+	/**
+	 * @return array[]
+	 * @psalm-return array<string, string>
+	 */
+	public function getFallbackDirsPsr4()
+	{
+		return $this->fallbackDirsPsr4;
+	}
+
+	/**
+	 * @return string[] Array of classname => path
+	 * @psalm-return array<string, string>
+	 */
+	public function getClassMap()
+	{
+		return $this->classMap;
+	}
+
+	/**
+	 * @param string[] $classMap Class to filename map
+	 * @psalm-param array<string, string> $classMap
+	 *
+	 * @return void
+	 */
+	public function addClassMap(array $classMap)
+	{
+		if ($this->classMap) {
+			$this->classMap = array_merge($this->classMap, $classMap);
+		} else {
+			$this->classMap = $classMap;
+		}
+	}
+
+	/**
+	 * Registers a set of PSR-0 directories for a given prefix, either
+	 * appending or prepending to the ones previously set for this prefix.
+	 *
+	 * @param string          $prefix  The prefix
+	 * @param string[]|string $paths   The PSR-0 root directories
+	 * @param bool            $prepend Whether to prepend the directories
+	 *
+	 * @return void
+	 */
+	public function add($prefix, $paths, $prepend = false)
+	{
+		if (!$prefix) {
+			if ($prepend) {
+				$this->fallbackDirsPsr0 = array_merge(
+					(array) $paths,
+					$this->fallbackDirsPsr0
+				);
+			} else {
+				$this->fallbackDirsPsr0 = array_merge(
+					$this->fallbackDirsPsr0,
+					(array) $paths
+				);
+			}
+
+			return;
+		}
+
+		$first = $prefix[0];
+		if (!isset($this->prefixesPsr0[$first][$prefix])) {
+			$this->prefixesPsr0[$first][$prefix] = (array) $paths;
+
+			return;
+		}
+		if ($prepend) {
+			$this->prefixesPsr0[$first][$prefix] = array_merge(
+				(array) $paths,
+				$this->prefixesPsr0[$first][$prefix]
+			);
+		} else {
+			$this->prefixesPsr0[$first][$prefix] = array_merge(
+				$this->prefixesPsr0[$first][$prefix],
+				(array) $paths
+			);
+		}
+	}
+
+	/**
+	 * Registers a set of PSR-4 directories for a given namespace, either
+	 * appending or prepending to the ones previously set for this namespace.
+	 *
+	 * @param string          $prefix  The prefix/namespace, with trailing '\\'
+	 * @param string[]|string $paths   The PSR-4 base directories
+	 * @param bool            $prepend Whether to prepend the directories
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	public function addPsr4($prefix, $paths, $prepend = false)
+	{
+		if (!$prefix) {
+			// Register directories for the root namespace.
+			if ($prepend) {
+				$this->fallbackDirsPsr4 = array_merge(
+					(array) $paths,
+					$this->fallbackDirsPsr4
+				);
+			} else {
+				$this->fallbackDirsPsr4 = array_merge(
+					$this->fallbackDirsPsr4,
+					(array) $paths
+				);
+			}
+		} elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+			// Register directories for a new namespace.
+			$length = strlen($prefix);
+			if ('\\' !== $prefix[$length - 1]) {
+				throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+			}
+			$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+			$this->prefixDirsPsr4[$prefix] = (array) $paths;
+		} elseif ($prepend) {
+			// Prepend directories for an already registered namespace.
+			$this->prefixDirsPsr4[$prefix] = array_merge(
+				(array) $paths,
+				$this->prefixDirsPsr4[$prefix]
+			);
+		} else {
+			// Append directories for an already registered namespace.
+			$this->prefixDirsPsr4[$prefix] = array_merge(
+				$this->prefixDirsPsr4[$prefix],
+				(array) $paths
+			);
+		}
+	}
+
+	/**
+	 * Registers a set of PSR-0 directories for a given prefix,
+	 * replacing any others previously set for this prefix.
+	 *
+	 * @param string          $prefix The prefix
+	 * @param string[]|string $paths  The PSR-0 base directories
+	 *
+	 * @return void
+	 */
+	public function set($prefix, $paths)
+	{
+		if (!$prefix) {
+			$this->fallbackDirsPsr0 = (array) $paths;
+		} else {
+			$this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+		}
+	}
+
+	/**
+	 * Registers a set of PSR-4 directories for a given namespace,
+	 * replacing any others previously set for this namespace.
+	 *
+	 * @param string          $prefix The prefix/namespace, with trailing '\\'
+	 * @param string[]|string $paths  The PSR-4 base directories
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	public function setPsr4($prefix, $paths)
+	{
+		if (!$prefix) {
+			$this->fallbackDirsPsr4 = (array) $paths;
+		} else {
+			$length = strlen($prefix);
+			if ('\\' !== $prefix[$length - 1]) {
+				throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+			}
+			$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+			$this->prefixDirsPsr4[$prefix] = (array) $paths;
+		}
+	}
+
+	/**
+	 * Turns on searching the include path for class files.
+	 *
+	 * @param bool $useIncludePath
+	 *
+	 * @return void
+	 */
+	public function setUseIncludePath($useIncludePath)
+	{
+		$this->useIncludePath = $useIncludePath;
+	}
+
+	/**
+	 * Can be used to check if the autoloader uses the include path to check
+	 * for classes.
+	 *
+	 * @return bool
+	 */
+	public function getUseIncludePath()
+	{
+		return $this->useIncludePath;
+	}
+
+	/**
+	 * Turns off searching the prefix and fallback directories for classes
+	 * that have not been registered with the class map.
+	 *
+	 * @param bool $classMapAuthoritative
+	 *
+	 * @return void
+	 */
+	public function setClassMapAuthoritative($classMapAuthoritative)
+	{
+		$this->classMapAuthoritative = $classMapAuthoritative;
+	}
+
+	/**
+	 * Should class lookup fail if not found in the current class map?
+	 *
+	 * @return bool
+	 */
+	public function isClassMapAuthoritative()
+	{
+		return $this->classMapAuthoritative;
+	}
+
+	/**
+	 * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+	 *
+	 * @param string|null $apcuPrefix
+	 *
+	 * @return void
+	 */
+	public function setApcuPrefix($apcuPrefix)
+	{
+		$this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
+	}
+
+	/**
+	 * The APCu prefix in use, or null if APCu caching is not enabled.
+	 *
+	 * @return string|null
+	 */
+	public function getApcuPrefix()
+	{
+		return $this->apcuPrefix;
+	}
+
+	/**
+	 * Registers this instance as an autoloader.
+	 *
+	 * @param bool $prepend Whether to prepend the autoloader or not
+	 *
+	 * @return void
+	 */
+	public function register($prepend = false)
+	{
+		spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+
+		if (null === $this->vendorDir) {
+			return;
+		}
+
+		if ($prepend) {
+			self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
+		} else {
+			unset(self::$registeredLoaders[$this->vendorDir]);
+			self::$registeredLoaders[$this->vendorDir] = $this;
+		}
+	}
+
+	/**
+	 * Unregisters this instance as an autoloader.
+	 *
+	 * @return void
+	 */
+	public function unregister()
+	{
+		spl_autoload_unregister(array($this, 'loadClass'));
+
+		if (null !== $this->vendorDir) {
+			unset(self::$registeredLoaders[$this->vendorDir]);
+		}
+	}
+
+	/**
+	 * Loads the given class or interface.
+	 *
+	 * @param  string    $class The name of the class
+	 * @return true|null True if loaded, null otherwise
+	 */
+	public function loadClass($class)
+	{
+		if ($file = $this->findFile($class)) {
+			includeFile($file);
+
+			return true;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Finds the path to the file where the class is defined.
+	 *
+	 * @param string $class The name of the class
+	 *
+	 * @return string|false The path if found, false otherwise
+	 */
+	public function findFile($class)
+	{
+		// class map lookup
+		if (isset($this->classMap[$class])) {
+			return $this->classMap[$class];
+		}
+		if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+			return false;
+		}
+		if (null !== $this->apcuPrefix) {
+			$file = apcu_fetch($this->apcuPrefix.$class, $hit);
+			if ($hit) {
+				return $file;
+			}
+		}
+
+		$file = $this->findFileWithExtension($class, '.php');
+
+		// Search for Hack files if we are running on HHVM
+		if (false === $file && defined('HHVM_VERSION')) {
+			$file = $this->findFileWithExtension($class, '.hh');
+		}
+
+		if (null !== $this->apcuPrefix) {
+			apcu_add($this->apcuPrefix.$class, $file);
+		}
+
+		if (false === $file) {
+			// Remember that this class does not exist.
+			$this->missingClasses[$class] = true;
+		}
+
+		return $file;
+	}
+
+	/**
+	 * Returns the currently registered loaders indexed by their corresponding vendor directories.
+	 *
+	 * @return self[]
+	 */
+	public static function getRegisteredLoaders()
+	{
+		return self::$registeredLoaders;
+	}
+
+	/**
+	 * @param  string       $class
+	 * @param  string       $ext
+	 * @return string|false
+	 */
+	private function findFileWithExtension($class, $ext)
+	{
+		// PSR-4 lookup
+		$logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+		$first = $class[0];
+		if (isset($this->prefixLengthsPsr4[$first])) {
+			$subPath = $class;
+			while (false !== $lastPos = strrpos($subPath, '\\')) {
+				$subPath = substr($subPath, 0, $lastPos);
+				$search = $subPath . '\\';
+				if (isset($this->prefixDirsPsr4[$search])) {
+					$pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
+					foreach ($this->prefixDirsPsr4[$search] as $dir) {
+						if (file_exists($file = $dir . $pathEnd)) {
+							return $file;
+						}
+					}
+				}
+			}
+		}
+
+		// PSR-4 fallback dirs
+		foreach ($this->fallbackDirsPsr4 as $dir) {
+			if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+				return $file;
+			}
+		}
+
+		// PSR-0 lookup
+		if (false !== $pos = strrpos($class, '\\')) {
+			// namespaced class name
+			$logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+				. strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+		} else {
+			// PEAR-like class name
+			$logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+		}
+
+		if (isset($this->prefixesPsr0[$first])) {
+			foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+				if (0 === strpos($class, $prefix)) {
+					foreach ($dirs as $dir) {
+						if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+							return $file;
+						}
+					}
+				}
+			}
+		}
+
+		// PSR-0 fallback dirs
+		foreach ($this->fallbackDirsPsr0 as $dir) {
+			if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+				return $file;
+			}
+		}
+
+		// PSR-0 include paths.
+		if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+			return $file;
+		}
+
+		return false;
+	}
 }
 
 /**
@@ -568,5 +568,5 @@ 
  */
 function includeFile($file)
 {
-    include $file;
+	include $file;
 }