gravityview / GravityView

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

Spacing +7 added lines, -7 removed lines

@@ -28,7 +28,7 @@ 
      * @param  string  $method
      * @return void
      */
-    public function __construct(Collection $collection, $method)
+    public function __construct( Collection $collection, $method )
     {
         $this->method = $method;
         $this->collection = $collection;
@@ -40,10 +40,10 @@ 
      * @param  string  $key
      * @return mixed
      */
-    public function __get($key)
+    public function __get( $key )
     {
-        return $this->collection->{$this->method}(function ($value) use ($key) {
-            return is_array($value) ? $value[$key] : $value->{$key};
+        return $this->collection->{$this->method}( function( $value ) use ( $key ) {
+            return is_array( $value ) ? $value[ $key ] : $value->{$key};
         });
     }
 
@@ -54,10 +54,10 @@ 
      * @param  array  $parameters
      * @return mixed
      */
-    public function __call($method, $parameters)
+    public function __call( $method, $parameters )
     {
-        return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
-            return $value->{$method}(...$parameters);
+        return $this->collection->{$this->method}( function( $value ) use ( $method, $parameters ) {
+            return $value->{$method}( ...$parameters );
         });
     }
 }

Braces +4 added lines, -8 removed lines

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

vendor/illuminate/support/Collection.php

Indentation +1636 added lines, -1636 removed lines

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

Spacing +365 added lines, -365 removed lines

@@ -23,7 +23,7 @@ 
      *
      * @var array
      */
-    protected $items = [];
+    protected $items = [ ];
 
     /**
      * The methods that can be proxied.
@@ -41,9 +41,9 @@ 
      * @param  mixed  $items
      * @return void
      */
-    public function __construct($items = [])
+    public function __construct( $items = [ ] )
     {
-        $this->items = $this->getArrayableItems($items);
+        $this->items = $this->getArrayableItems( $items );
     }
 
     /**
@@ -52,9 +52,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public static function make($items = [])
+    public static function make( $items = [ ] )
     {
-        return new static($items);
+        return new static( $items );
     }
 
     /**
@@ -64,17 +64,17 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public static function times($number, callable $callback = null)
+    public static function times( $number, callable $callback = null )
     {
-        if ($number < 1) {
+        if ( $number < 1 ) {
             return new static;
         }
 
-        if (is_null($callback)) {
-            return new static(range(1, $number));
+        if ( is_null( $callback ) ) {
+            return new static( range( 1, $number ) );
         }
 
-        return (new static(range(1, $number)))->map($callback);
+        return ( new static( range( 1, $number ) ) )->map( $callback );
     }
 
     /**
@@ -93,10 +93,10 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function avg($callback = null)
+    public function avg( $callback = null )
     {
-        if ($count = $this->count()) {
-            return $this->sum($callback) / $count;
+        if ( $count = $this->count() ) {
+            return $this->sum( $callback ) / $count;
         }
     }
 
@@ -106,9 +106,9 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function average($callback = null)
+    public function average( $callback = null )
     {
-        return $this->avg($callback);
+        return $this->avg( $callback );
     }
 
     /**
@@ -117,26 +117,26 @@ 
      * @param  null $key
      * @return mixed
      */
-    public function median($key = null)
+    public function median( $key = null )
     {
         $count = $this->count();
 
-        if ($count == 0) {
+        if ( $count == 0 ) {
             return;
         }
 
-        $values = with(isset($key) ? $this->pluck($key) : $this)
+        $values = with( isset( $key ) ? $this->pluck( $key ) : $this )
                     ->sort()->values();
 
-        $middle = (int) ($count / 2);
+        $middle = (int)( $count / 2 );
 
-        if ($count % 2) {
-            return $values->get($middle);
+        if ( $count % 2 ) {
+            return $values->get( $middle );
         }
 
-        return (new static([
-            $values->get($middle - 1), $values->get($middle),
-        ]))->average();
+        return ( new static( [
+            $values->get( $middle - 1 ), $values->get( $middle ),
+        ] ) )->average();
     }
 
     /**
@@ -145,27 +145,27 @@ 
      * @param  mixed  $key
      * @return array|null
      */
-    public function mode($key = null)
+    public function mode( $key = null )
     {
         $count = $this->count();
 
-        if ($count == 0) {
+        if ( $count == 0 ) {
             return;
         }
 
-        $collection = isset($key) ? $this->pluck($key) : $this;
+        $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;
+        $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 $sorted->filter( function( $value ) use ( $highestValue ) {
             return $value == $highestValue;
         })->sort()->keys()->all();
     }
@@ -177,7 +177,7 @@ 
      */
     public function collapse()
     {
-        return new static(Arr::collapse($this->items));
+        return new static( Arr::collapse( $this->items ) );
     }
 
     /**
@@ -188,23 +188,23 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function contains($key, $operator = null, $value = null)
+    public function contains( $key, $operator = null, $value = null )
     {
-        if (func_num_args() == 1) {
-            if ($this->useAsCallable($key)) {
-                return ! is_null($this->first($key));
+        if ( func_num_args() == 1 ) {
+            if ( $this->useAsCallable( $key ) ) {
+                return ! is_null( $this->first( $key ) );
             }
 
-            return in_array($key, $this->items);
+            return in_array( $key, $this->items );
         }
 
-        if (func_num_args() == 2) {
+        if ( func_num_args() == 2 ) {
             $value = $operator;
 
             $operator = '=';
         }
 
-        return $this->contains($this->operatorForWhere($key, $operator, $value));
+        return $this->contains( $this->operatorForWhere( $key, $operator, $value ) );
     }
 
     /**
@@ -214,19 +214,19 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function containsStrict($key, $value = null)
+    public function containsStrict( $key, $value = null )
     {
-        if (func_num_args() == 2) {
-            return $this->contains(function ($item) use ($key, $value) {
-                return data_get($item, $key) === $value;
+        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));
+        if ( $this->useAsCallable( $key ) ) {
+            return ! is_null( $this->first( $key ) );
         }
 
-        return in_array($key, $this->items, true);
+        return in_array( $key, $this->items, true );
     }
 
     /**
@@ -235,11 +235,11 @@ 
      * @param  mixed  ...$lists
      * @return static
      */
-    public function crossJoin(...$lists)
+    public function crossJoin( ...$lists )
     {
-        return new static(Arr::crossJoin(
-            $this->items, ...array_map([$this, 'getArrayableItems'], $lists)
-        ));
+        return new static( Arr::crossJoin(
+            $this->items, ...array_map( [ $this, 'getArrayableItems' ], $lists )
+        ) );
     }
 
     /**
@@ -248,9 +248,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diff($items)
+    public function diff( $items )
     {
-        return new static(array_diff($this->items, $this->getArrayableItems($items)));
+        return new static( array_diff( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -259,9 +259,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diffAssoc($items)
+    public function diffAssoc( $items )
     {
-        return new static(array_diff_assoc($this->items, $this->getArrayableItems($items)));
+        return new static( array_diff_assoc( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -270,9 +270,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diffKeys($items)
+    public function diffKeys( $items )
     {
-        return new static(array_diff_key($this->items, $this->getArrayableItems($items)));
+        return new static( array_diff_key( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -281,10 +281,10 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function each(callable $callback)
+    public function each( callable $callback )
     {
-        foreach ($this->items as $key => $item) {
-            if ($callback($item, $key) === false) {
+        foreach ( $this->items as $key => $item ) {
+            if ( $callback( $item, $key ) === false ) {
                 break;
             }
         }
@@ -298,10 +298,10 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function eachSpread(callable $callback)
+    public function eachSpread( callable $callback )
     {
-        return $this->each(function ($chunk) use ($callback) {
-            return $callback(...$chunk);
+        return $this->each( function( $chunk ) use ( $callback ) {
+            return $callback( ...$chunk );
         });
     }
 
@@ -313,13 +313,13 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function every($key, $operator = null, $value = null)
+    public function every( $key, $operator = null, $value = null )
     {
-        if (func_num_args() == 1) {
-            $callback = $this->valueRetriever($key);
+        if ( func_num_args() == 1 ) {
+            $callback = $this->valueRetriever( $key );
 
-            foreach ($this->items as $k => $v) {
-                if (! $callback($v, $k)) {
+            foreach ( $this->items as $k => $v ) {
+                if ( ! $callback( $v, $k ) ) {
                     return false;
                 }
             }
@@ -327,13 +327,13 @@ 
             return true;
         }
 
-        if (func_num_args() == 2) {
+        if ( func_num_args() == 2 ) {
             $value = $operator;
 
             $operator = '=';
         }
 
-        return $this->every($this->operatorForWhere($key, $operator, $value));
+        return $this->every( $this->operatorForWhere( $key, $operator, $value ) );
     }
 
     /**
@@ -342,11 +342,11 @@ 
      * @param  mixed  $keys
      * @return static
      */
-    public function except($keys)
+    public function except( $keys )
     {
-        $keys = is_array($keys) ? $keys : func_get_args();
+        $keys = is_array( $keys ) ? $keys : func_get_args();
 
-        return new static(Arr::except($this->items, $keys));
+        return new static( Arr::except( $this->items, $keys ) );
     }
 
     /**
@@ -355,13 +355,13 @@ 
      * @param  callable|null  $callback
      * @return static
      */
-    public function filter(callable $callback = null)
+    public function filter( callable $callback = null )
     {
-        if ($callback) {
-            return new static(Arr::where($this->items, $callback));
+        if ( $callback ) {
+            return new static( Arr::where( $this->items, $callback ) );
         }
 
-        return new static(array_filter($this->items));
+        return new static( array_filter( $this->items ) );
     }
 
     /**
@@ -372,12 +372,12 @@ 
      * @param  callable  $default
      * @return mixed
      */
-    public function when($value, callable $callback, callable $default = null)
+    public function when( $value, callable $callback, callable $default = null )
     {
-        if ($value) {
-            return $callback($this);
-        } elseif ($default) {
-            return $default($this);
+        if ( $value ) {
+            return $callback( $this );
+        } elseif ( $default ) {
+            return $default( $this );
         }
 
         return $this;
@@ -391,9 +391,9 @@ 
      * @param  callable  $default
      * @return mixed
      */
-    public function unless($value, callable $callback, callable $default = null)
+    public function unless( $value, callable $callback, callable $default = null )
     {
-        return $this->when(! $value, $callback, $default);
+        return $this->when( ! $value, $callback, $default );
     }
 
     /**
@@ -404,15 +404,15 @@ 
      * @param  mixed  $value
      * @return static
      */
-    public function where($key, $operator, $value = null)
+    public function where( $key, $operator, $value = null )
     {
-        if (func_num_args() == 2) {
+        if ( func_num_args() == 2 ) {
             $value = $operator;
 
             $operator = '=';
         }
 
-        return $this->filter($this->operatorForWhere($key, $operator, $value));
+        return $this->filter( $this->operatorForWhere( $key, $operator, $value ) );
     }
 
     /**
@@ -423,12 +423,12 @@ 
      * @param  mixed  $value
      * @return \Closure
      */
-    protected function operatorForWhere($key, $operator, $value)
+    protected function operatorForWhere( $key, $operator, $value )
     {
-        return function ($item) use ($key, $operator, $value) {
-            $retrieved = data_get($item, $key);
+        return function( $item ) use ( $key, $operator, $value ) {
+            $retrieved = data_get( $item, $key );
 
-            switch ($operator) {
+            switch ( $operator ) {
                 default:
                 case '=':
                 case '==':  return $retrieved == $value;
@@ -451,9 +451,9 @@ 
      * @param  mixed  $value
      * @return static
      */
-    public function whereStrict($key, $value)
+    public function whereStrict( $key, $value )
     {
-        return $this->where($key, '===', $value);
+        return $this->where( $key, '===', $value );
     }
 
     /**
@@ -464,12 +464,12 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function whereIn($key, $values, $strict = false)
+    public function whereIn( $key, $values, $strict = false )
     {
-        $values = $this->getArrayableItems($values);
+        $values = $this->getArrayableItems( $values );
 
-        return $this->filter(function ($item) use ($key, $values, $strict) {
-            return in_array(data_get($item, $key), $values, $strict);
+        return $this->filter( function( $item ) use ( $key, $values, $strict ) {
+            return in_array( data_get( $item, $key ), $values, $strict );
         });
     }
 
@@ -480,9 +480,9 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function whereInStrict($key, $values)
+    public function whereInStrict( $key, $values )
     {
-        return $this->whereIn($key, $values, true);
+        return $this->whereIn( $key, $values, true );
     }
 
     /**
@@ -493,12 +493,12 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function whereNotIn($key, $values, $strict = false)
+    public function whereNotIn( $key, $values, $strict = false )
     {
-        $values = $this->getArrayableItems($values);
+        $values = $this->getArrayableItems( $values );
 
-        return $this->reject(function ($item) use ($key, $values, $strict) {
-            return in_array(data_get($item, $key), $values, $strict);
+        return $this->reject( function( $item ) use ( $key, $values, $strict ) {
+            return in_array( data_get( $item, $key ), $values, $strict );
         });
     }
 
@@ -509,9 +509,9 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function whereNotInStrict($key, $values)
+    public function whereNotInStrict( $key, $values )
     {
-        return $this->whereNotIn($key, $values, true);
+        return $this->whereNotIn( $key, $values, true );
     }
 
     /**
@@ -521,9 +521,9 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function first(callable $callback = null, $default = null)
+    public function first( callable $callback = null, $default = null )
     {
-        return Arr::first($this->items, $callback, $default);
+        return Arr::first( $this->items, $callback, $default );
     }
 
     /**
@@ -532,9 +532,9 @@ 
      * @param  int  $depth
      * @return static
      */
-    public function flatten($depth = INF)
+    public function flatten( $depth = INF )
     {
-        return new static(Arr::flatten($this->items, $depth));
+        return new static( Arr::flatten( $this->items, $depth ) );
     }
 
     /**
@@ -544,7 +544,7 @@ 
      */
     public function flip()
     {
-        return new static(array_flip($this->items));
+        return new static( array_flip( $this->items ) );
     }
 
     /**
@@ -553,10 +553,10 @@ 
      * @param  string|array  $keys
      * @return $this
      */
-    public function forget($keys)
+    public function forget( $keys )
     {
-        foreach ((array) $keys as $key) {
-            $this->offsetUnset($key);
+        foreach ( (array)$keys as $key ) {
+            $this->offsetUnset( $key );
         }
 
         return $this;
@@ -569,13 +569,13 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function get($key, $default = null)
+    public function get( $key, $default = null )
     {
-        if ($this->offsetExists($key)) {
-            return $this->items[$key];
+        if ( $this->offsetExists( $key ) ) {
+            return $this->items[ $key ];
         }
 
-        return value($default);
+        return value( $default );
     }
 
     /**
@@ -585,31 +585,31 @@ 
      * @param  bool  $preserveKeys
      * @return static
      */
-    public function groupBy($groupBy, $preserveKeys = false)
+    public function groupBy( $groupBy, $preserveKeys = false )
     {
-        $groupBy = $this->valueRetriever($groupBy);
+        $groupBy = $this->valueRetriever( $groupBy );
 
-        $results = [];
+        $results = [ ];
 
-        foreach ($this->items as $key => $value) {
-            $groupKeys = $groupBy($value, $key);
+        foreach ( $this->items as $key => $value ) {
+            $groupKeys = $groupBy( $value, $key );
 
-            if (! is_array($groupKeys)) {
-                $groupKeys = [$groupKeys];
+            if ( ! is_array( $groupKeys ) ) {
+                $groupKeys = [ $groupKeys ];
             }
 
-            foreach ($groupKeys as $groupKey) {
-                $groupKey = is_bool($groupKey) ? (int) $groupKey : $groupKey;
+            foreach ( $groupKeys as $groupKey ) {
+                $groupKey = is_bool( $groupKey ) ? (int)$groupKey : $groupKey;
 
-                if (! array_key_exists($groupKey, $results)) {
-                    $results[$groupKey] = new static;
+                if ( ! array_key_exists( $groupKey, $results ) ) {
+                    $results[ $groupKey ] = new static;
                 }
 
-                $results[$groupKey]->offsetSet($preserveKeys ? $key : null, $value);
+                $results[ $groupKey ]->offsetSet( $preserveKeys ? $key : null, $value );
             }
         }
 
-        return new static($results);
+        return new static( $results );
     }
 
     /**
@@ -618,23 +618,23 @@ 
      * @param  callable|string  $keyBy
      * @return static
      */
-    public function keyBy($keyBy)
+    public function keyBy( $keyBy )
     {
-        $keyBy = $this->valueRetriever($keyBy);
+        $keyBy = $this->valueRetriever( $keyBy );
 
-        $results = [];
+        $results = [ ];
 
-        foreach ($this->items as $key => $item) {
-            $resolvedKey = $keyBy($item, $key);
+        foreach ( $this->items as $key => $item ) {
+            $resolvedKey = $keyBy( $item, $key );
 
-            if (is_object($resolvedKey)) {
-                $resolvedKey = (string) $resolvedKey;
+            if ( is_object( $resolvedKey ) ) {
+                $resolvedKey = (string)$resolvedKey;
             }
 
-            $results[$resolvedKey] = $item;
+            $results[ $resolvedKey ] = $item;
         }
 
-        return new static($results);
+        return new static( $results );
     }
 
     /**
@@ -643,9 +643,9 @@ 
      * @param  mixed  $key
      * @return bool
      */
-    public function has($key)
+    public function has( $key )
     {
-        return $this->offsetExists($key);
+        return $this->offsetExists( $key );
     }
 
     /**
@@ -655,15 +655,15 @@ 
      * @param  string  $glue
      * @return string
      */
-    public function implode($value, $glue = null)
+    public function implode( $value, $glue = null )
     {
         $first = $this->first();
 
-        if (is_array($first) || is_object($first)) {
-            return implode($glue, $this->pluck($value)->all());
+        if ( is_array( $first ) || is_object( $first ) ) {
+            return implode( $glue, $this->pluck( $value )->all() );
         }
 
-        return implode($value, $this->items);
+        return implode( $value, $this->items );
     }
 
     /**
@@ -672,9 +672,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function intersect($items)
+    public function intersect( $items )
     {
-        return new static(array_intersect($this->items, $this->getArrayableItems($items)));
+        return new static( array_intersect( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -683,9 +683,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function intersectKey($items)
+    public function intersectKey( $items )
     {
-        return new static(array_intersect_key($this->items, $this->getArrayableItems($items)));
+        return new static( array_intersect_key( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -695,7 +695,7 @@ 
      */
     public function isEmpty()
     {
-        return empty($this->items);
+        return empty( $this->items );
     }
 
     /**
@@ -714,9 +714,9 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    protected function useAsCallable($value)
+    protected function useAsCallable( $value )
     {
-        return ! is_string($value) && is_callable($value);
+        return ! is_string( $value ) && is_callable( $value );
     }
 
     /**
@@ -726,7 +726,7 @@ 
      */
     public function keys()
     {
-        return new static(array_keys($this->items));
+        return new static( array_keys( $this->items ) );
     }
 
     /**
@@ -736,9 +736,9 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function last(callable $callback = null, $default = null)
+    public function last( callable $callback = null, $default = null )
     {
-        return Arr::last($this->items, $callback, $default);
+        return Arr::last( $this->items, $callback, $default );
     }
 
     /**
@@ -748,9 +748,9 @@ 
      * @param  string|null  $key
      * @return static
      */
-    public function pluck($value, $key = null)
+    public function pluck( $value, $key = null )
     {
-        return new static(Arr::pluck($this->items, $value, $key));
+        return new static( Arr::pluck( $this->items, $value, $key ) );
     }
 
     /**
@@ -759,13 +759,13 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function map(callable $callback)
+    public function map( callable $callback )
     {
-        $keys = array_keys($this->items);
+        $keys = array_keys( $this->items );
 
-        $items = array_map($callback, $this->items, $keys);
+        $items = array_map( $callback, $this->items, $keys );
 
-        return new static(array_combine($keys, $items));
+        return new static( array_combine( $keys, $items ) );
     }
 
     /**
@@ -774,10 +774,10 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapSpread(callable $callback)
+    public function mapSpread( callable $callback )
     {
-        return $this->map(function ($chunk) use ($callback) {
-            return $callback(...$chunk);
+        return $this->map( function( $chunk ) use ( $callback ) {
+            return $callback( ...$chunk );
         });
     }
 
@@ -789,15 +789,15 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapToGroups(callable $callback)
+    public function mapToGroups( callable $callback )
     {
-        $groups = $this->map($callback)->reduce(function ($groups, $pair) {
-            $groups[key($pair)][] = reset($pair);
+        $groups = $this->map( $callback )->reduce( function( $groups, $pair ) {
+            $groups[ key( $pair ) ][ ] = reset( $pair );
 
             return $groups;
-        }, []);
+        }, [ ] );
 
-        return (new static($groups))->map([$this, 'make']);
+        return ( new static( $groups ) )->map( [ $this, 'make' ] );
     }
 
     /**
@@ -808,19 +808,19 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapWithKeys(callable $callback)
+    public function mapWithKeys( callable $callback )
     {
-        $result = [];
+        $result = [ ];
 
-        foreach ($this->items as $key => $value) {
-            $assoc = $callback($value, $key);
+        foreach ( $this->items as $key => $value ) {
+            $assoc = $callback( $value, $key );
 
-            foreach ($assoc as $mapKey => $mapValue) {
-                $result[$mapKey] = $mapValue;
+            foreach ( $assoc as $mapKey => $mapValue ) {
+                $result[ $mapKey ] = $mapValue;
             }
         }
 
-        return new static($result);
+        return new static( $result );
     }
 
     /**
@@ -829,9 +829,9 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function flatMap(callable $callback)
+    public function flatMap( callable $callback )
     {
-        return $this->map($callback)->collapse();
+        return $this->map( $callback )->collapse();
     }
 
     /**
@@ -840,16 +840,16 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function max($callback = null)
+    public function max( $callback = null )
     {
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        return $this->filter(function ($value) {
-            return ! is_null($value);
-        })->reduce(function ($result, $item) use ($callback) {
-            $value = $callback($item);
+        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;
+            return is_null( $result ) || $value > $result ? $value : $result;
         });
     }
 
@@ -859,9 +859,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function merge($items)
+    public function merge( $items )
     {
-        return new static(array_merge($this->items, $this->getArrayableItems($items)));
+        return new static( array_merge( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -870,9 +870,9 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function combine($values)
+    public function combine( $values )
     {
-        return new static(array_combine($this->all(), $this->getArrayableItems($values)));
+        return new static( array_combine( $this->all(), $this->getArrayableItems( $values ) ) );
     }
 
     /**
@@ -881,9 +881,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function union($items)
+    public function union( $items )
     {
-        return new static($this->items + $this->getArrayableItems($items));
+        return new static( $this->items + $this->getArrayableItems( $items ) );
     }
 
     /**
@@ -892,16 +892,16 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function min($callback = null)
+    public function min( $callback = null )
     {
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        return $this->filter(function ($value) {
-            return ! is_null($value);
-        })->reduce(function ($result, $item) use ($callback) {
-            $value = $callback($item);
+        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;
+            return is_null( $result ) || $value < $result ? $value : $result;
         });
     }
 
@@ -912,21 +912,21 @@ 
      * @param  int  $offset
      * @return static
      */
-    public function nth($step, $offset = 0)
+    public function nth( $step, $offset = 0 )
     {
-        $new = [];
+        $new = [ ];
 
         $position = 0;
 
-        foreach ($this->items as $item) {
-            if ($position % $step === $offset) {
-                $new[] = $item;
+        foreach ( $this->items as $item ) {
+            if ( $position % $step === $offset ) {
+                $new[ ] = $item;
             }
 
             $position++;
         }
 
-        return new static($new);
+        return new static( $new );
     }
 
     /**
@@ -935,15 +935,15 @@ 
      * @param  mixed  $keys
      * @return static
      */
-    public function only($keys)
+    public function only( $keys )
     {
-        if (is_null($keys)) {
-            return new static($this->items);
+        if ( is_null( $keys ) ) {
+            return new static( $this->items );
         }
 
-        $keys = is_array($keys) ? $keys : func_get_args();
+        $keys = is_array( $keys ) ? $keys : func_get_args();
 
-        return new static(Arr::only($this->items, $keys));
+        return new static( Arr::only( $this->items, $keys ) );
     }
 
     /**
@@ -953,9 +953,9 @@ 
      * @param  int  $perPage
      * @return static
      */
-    public function forPage($page, $perPage)
+    public function forPage( $page, $perPage )
     {
-        return $this->slice(($page - 1) * $perPage, $perPage);
+        return $this->slice( ( $page - 1 ) * $perPage, $perPage );
     }
 
     /**
@@ -964,17 +964,17 @@ 
      * @param  callable|string  $callback
      * @return static
      */
-    public function partition($callback)
+    public function partition( $callback )
     {
-        $partitions = [new static, new static];
+        $partitions = [ new static, new static ];
 
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        foreach ($this->items as $key => $item) {
-            $partitions[(int) ! $callback($item)][$key] = $item;
+        foreach ( $this->items as $key => $item ) {
+            $partitions[ (int)! $callback( $item ) ][ $key ] = $item;
         }
 
-        return new static($partitions);
+        return new static( $partitions );
     }
 
     /**
@@ -983,9 +983,9 @@ 
      * @param  callable $callback
      * @return mixed
      */
-    public function pipe(callable $callback)
+    public function pipe( callable $callback )
     {
-        return $callback($this);
+        return $callback( $this );
     }
 
     /**
@@ -995,7 +995,7 @@ 
      */
     public function pop()
     {
-        return array_pop($this->items);
+        return array_pop( $this->items );
     }
 
     /**
@@ -1005,9 +1005,9 @@ 
      * @param  mixed  $key
      * @return $this
      */
-    public function prepend($value, $key = null)
+    public function prepend( $value, $key = null )
     {
-        $this->items = Arr::prepend($this->items, $value, $key);
+        $this->items = Arr::prepend( $this->items, $value, $key );
 
         return $this;
     }
@@ -1018,9 +1018,9 @@ 
      * @param  mixed  $value
      * @return $this
      */
-    public function push($value)
+    public function push( $value )
     {
-        $this->offsetSet(null, $value);
+        $this->offsetSet( null, $value );
 
         return $this;
     }
@@ -1031,12 +1031,12 @@ 
      * @param  \Traversable  $source
      * @return self
      */
-    public function concat($source)
+    public function concat( $source )
     {
-        $result = new static($this);
+        $result = new static( $this );
 
-        foreach ($source as $item) {
-            $result->push($item);
+        foreach ( $source as $item ) {
+            $result->push( $item );
         }
 
         return $result;
@@ -1049,9 +1049,9 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function pull($key, $default = null)
+    public function pull( $key, $default = null )
     {
-        return Arr::pull($this->items, $key, $default);
+        return Arr::pull( $this->items, $key, $default );
     }
 
     /**
@@ -1061,9 +1061,9 @@ 
      * @param  mixed  $value
      * @return $this
      */
-    public function put($key, $value)
+    public function put( $key, $value )
     {
-        $this->offsetSet($key, $value);
+        $this->offsetSet( $key, $value );
 
         return $this;
     }
@@ -1076,13 +1076,13 @@ 
      *
      * @throws \InvalidArgumentException
      */
-    public function random($number = null)
+    public function random( $number = null )
     {
-        if (is_null($number)) {
-            return Arr::random($this->items);
+        if ( is_null( $number ) ) {
+            return Arr::random( $this->items );
         }
 
-        return new static(Arr::random($this->items, $number));
+        return new static( Arr::random( $this->items, $number ) );
     }
 
     /**
@@ -1092,9 +1092,9 @@ 
      * @param  mixed  $initial
      * @return mixed
      */
-    public function reduce(callable $callback, $initial = null)
+    public function reduce( callable $callback, $initial = null )
     {
-        return array_reduce($this->items, $callback, $initial);
+        return array_reduce( $this->items, $callback, $initial );
     }
 
     /**
@@ -1103,15 +1103,15 @@ 
      * @param  callable|mixed  $callback
      * @return static
      */
-    public function reject($callback)
+    public function reject( $callback )
     {
-        if ($this->useAsCallable($callback)) {
-            return $this->filter(function ($value, $key) use ($callback) {
-                return ! $callback($value, $key);
+        if ( $this->useAsCallable( $callback ) ) {
+            return $this->filter( function( $value, $key ) use ( $callback ) {
+                return ! $callback( $value, $key );
             });
         }
 
-        return $this->filter(function ($item) use ($callback) {
+        return $this->filter( function( $item ) use ( $callback ) {
             return $item != $callback;
         });
     }
@@ -1123,7 +1123,7 @@ 
      */
     public function reverse()
     {
-        return new static(array_reverse($this->items, true));
+        return new static( array_reverse( $this->items, true ) );
     }
 
     /**
@@ -1133,14 +1133,14 @@ 
      * @param  bool  $strict
      * @return mixed
      */
-    public function search($value, $strict = false)
+    public function search( $value, $strict = false )
     {
-        if (! $this->useAsCallable($value)) {
-            return array_search($value, $this->items, $strict);
+        if ( ! $this->useAsCallable( $value ) ) {
+            return array_search( $value, $this->items, $strict );
         }
 
-        foreach ($this->items as $key => $item) {
-            if (call_user_func($value, $item, $key)) {
+        foreach ( $this->items as $key => $item ) {
+            if ( call_user_func( $value, $item, $key ) ) {
                 return $key;
             }
         }
@@ -1155,7 +1155,7 @@ 
      */
     public function shift()
     {
-        return array_shift($this->items);
+        return array_shift( $this->items );
     }
 
     /**
@@ -1164,21 +1164,21 @@ 
      * @param  int  $seed
      * @return static
      */
-    public function shuffle($seed = null)
+    public function shuffle( $seed = null )
     {
         $items = $this->items;
 
-        if (is_null($seed)) {
-            shuffle($items);
+        if ( is_null( $seed ) ) {
+            shuffle( $items );
         } else {
-            srand($seed);
+            srand( $seed );
 
-            usort($items, function () {
+            usort( $items, function() {
                 return rand(-1, 1);
             });
         }
 
-        return new static($items);
+        return new static( $items );
     }
 
     /**
@@ -1188,9 +1188,9 @@ 
      * @param  int  $length
      * @return static
      */
-    public function slice($offset, $length = null)
+    public function slice( $offset, $length = null )
     {
-        return new static(array_slice($this->items, $offset, $length, true));
+        return new static( array_slice( $this->items, $offset, $length, true ) );
     }
 
     /**
@@ -1199,15 +1199,15 @@ 
      * @param  int  $numberOfGroups
      * @return static
      */
-    public function split($numberOfGroups)
+    public function split( $numberOfGroups )
     {
-        if ($this->isEmpty()) {
+        if ( $this->isEmpty() ) {
             return new static;
         }
 
-        $groupSize = ceil($this->count() / $numberOfGroups);
+        $groupSize = ceil( $this->count() / $numberOfGroups );
 
-        return $this->chunk($groupSize);
+        return $this->chunk( $groupSize );
     }
 
     /**
@@ -1216,19 +1216,19 @@ 
      * @param  int  $size
      * @return static
      */
-    public function chunk($size)
+    public function chunk( $size )
     {
-        if ($size <= 0) {
+        if ( $size <= 0 ) {
             return new static;
         }
 
-        $chunks = [];
+        $chunks = [ ];
 
-        foreach (array_chunk($this->items, $size, true) as $chunk) {
-            $chunks[] = new static($chunk);
+        foreach ( array_chunk( $this->items, $size, true ) as $chunk ) {
+            $chunks[ ] = new static( $chunk );
         }
 
-        return new static($chunks);
+        return new static( $chunks );
     }
 
     /**
@@ -1237,15 +1237,15 @@ 
      * @param  callable|null  $callback
      * @return static
      */
-    public function sort(callable $callback = null)
+    public function sort( callable $callback = null )
     {
         $items = $this->items;
 
         $callback
-            ? uasort($items, $callback)
-            : asort($items);
+            ? uasort( $items, $callback )
+            : asort( $items );
 
-        return new static($items);
+        return new static( $items );
     }
 
     /**
@@ -1256,30 +1256,30 @@ 
      * @param  bool  $descending
      * @return static
      */
-    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
+    public function sortBy( $callback, $options = SORT_REGULAR, $descending = false )
     {
-        $results = [];
+        $results = [ ];
 
-        $callback = $this->valueRetriever($callback);
+        $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);
+        foreach ( $this->items as $key => $value ) {
+            $results[ $key ] = $callback( $value, $key );
         }
 
-        $descending ? arsort($results, $options)
-                    : asort($results, $options);
+        $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];
+        foreach ( array_keys( $results ) as $key ) {
+            $results[ $key ] = $this->items[ $key ];
         }
 
-        return new static($results);
+        return new static( $results );
     }
 
     /**
@@ -1289,9 +1289,9 @@ 
      * @param  int  $options
      * @return static
      */
-    public function sortByDesc($callback, $options = SORT_REGULAR)
+    public function sortByDesc( $callback, $options = SORT_REGULAR )
     {
-        return $this->sortBy($callback, $options, true);
+        return $this->sortBy( $callback, $options, true );
     }
 
     /**
@@ -1302,13 +1302,13 @@ 
      * @param  mixed  $replacement
      * @return static
      */
-    public function splice($offset, $length = null, $replacement = [])
+    public function splice( $offset, $length = null, $replacement = [ ] )
     {
-        if (func_num_args() == 1) {
-            return new static(array_splice($this->items, $offset));
+        if ( func_num_args() == 1 ) {
+            return new static( array_splice( $this->items, $offset ) );
         }
 
-        return new static(array_splice($this->items, $offset, $length, $replacement));
+        return new static( array_splice( $this->items, $offset, $length, $replacement ) );
     }
 
     /**
@@ -1317,17 +1317,17 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function sum($callback = null)
+    public function sum( $callback = null )
     {
-        if (is_null($callback)) {
-            return array_sum($this->items);
+        if ( is_null( $callback ) ) {
+            return array_sum( $this->items );
         }
 
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        return $this->reduce(function ($result, $item) use ($callback) {
-            return $result + $callback($item);
-        }, 0);
+        return $this->reduce( function( $result, $item ) use ( $callback ) {
+            return $result + $callback( $item );
+        }, 0 );
     }
 
     /**
@@ -1336,13 +1336,13 @@ 
      * @param  int  $limit
      * @return static
      */
-    public function take($limit)
+    public function take( $limit )
     {
-        if ($limit < 0) {
-            return $this->slice($limit, abs($limit));
+        if ( $limit < 0 ) {
+            return $this->slice( $limit, abs( $limit ) );
         }
 
-        return $this->slice(0, $limit);
+        return $this->slice( 0, $limit );
     }
 
     /**
@@ -1351,9 +1351,9 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function tap(callable $callback)
+    public function tap( callable $callback )
     {
-        $callback(new static($this->items));
+        $callback( new static( $this->items ) );
 
         return $this;
     }
@@ -1364,9 +1364,9 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function transform(callable $callback)
+    public function transform( callable $callback )
     {
-        $this->items = $this->map($callback)->all();
+        $this->items = $this->map( $callback )->all();
 
         return $this;
     }
@@ -1378,22 +1378,22 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function unique($key = null, $strict = false)
+    public function unique( $key = null, $strict = false )
     {
-        if (is_null($key)) {
-            return new static(array_unique($this->items, SORT_REGULAR));
+        if ( is_null( $key ) ) {
+            return new static( array_unique( $this->items, SORT_REGULAR ) );
         }
 
-        $callback = $this->valueRetriever($key);
+        $callback = $this->valueRetriever( $key );
 
-        $exists = [];
+        $exists = [ ];
 
-        return $this->reject(function ($item, $key) use ($callback, $strict, &$exists) {
-            if (in_array($id = $callback($item, $key), $exists, $strict)) {
+        return $this->reject( function( $item, $key ) use ( $callback, $strict, &$exists ) {
+            if ( in_array( $id = $callback( $item, $key ), $exists, $strict ) ) {
                 return true;
             }
 
-            $exists[] = $id;
+            $exists[ ] = $id;
         });
     }
 
@@ -1403,9 +1403,9 @@ 
      * @param  string|callable|null  $key
      * @return static
      */
-    public function uniqueStrict($key = null)
+    public function uniqueStrict( $key = null )
     {
-        return $this->unique($key, true);
+        return $this->unique( $key, true );
     }
 
     /**
@@ -1415,7 +1415,7 @@ 
      */
     public function values()
     {
-        return new static(array_values($this->items));
+        return new static( array_values( $this->items ) );
     }
 
     /**
@@ -1424,14 +1424,14 @@ 
      * @param  string  $value
      * @return callable
      */
-    protected function valueRetriever($value)
+    protected function valueRetriever( $value )
     {
-        if ($this->useAsCallable($value)) {
+        if ( $this->useAsCallable( $value ) ) {
             return $value;
         }
 
-        return function ($item) use ($value) {
-            return data_get($item, $value);
+        return function( $item ) use ( $value ) {
+            return data_get( $item, $value );
         };
     }
 
@@ -1444,17 +1444,17 @@ 
      * @param  mixed ...$items
      * @return static
      */
-    public function zip($items)
+    public function zip( $items )
     {
-        $arrayableItems = array_map(function ($items) {
-            return $this->getArrayableItems($items);
-        }, func_get_args());
+        $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);
+        $params = array_merge( [ function() {
+            return new static( func_get_args() );
+        }, $this->items ], $arrayableItems );
 
-        return new static(call_user_func_array('array_map', $params));
+        return new static( call_user_func_array( 'array_map', $params ) );
     }
 
     /**
@@ -1464,9 +1464,9 @@ 
      */
     public function toArray()
     {
-        return array_map(function ($value) {
+        return array_map( function( $value ) {
             return $value instanceof Arrayable ? $value->toArray() : $value;
-        }, $this->items);
+        }, $this->items );
     }
 
     /**
@@ -1476,17 +1476,17 @@ 
      */
     public function jsonSerialize()
     {
-        return array_map(function ($value) {
-            if ($value instanceof JsonSerializable) {
+        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) {
+            } elseif ( $value instanceof Jsonable ) {
+                return json_decode( $value->toJson(), true );
+            } elseif ( $value instanceof Arrayable ) {
                 return $value->toArray();
             } else {
                 return $value;
             }
-        }, $this->items);
+        }, $this->items );
     }
 
     /**
@@ -1495,9 +1495,9 @@ 
      * @param  int  $options
      * @return string
      */
-    public function toJson($options = 0)
+    public function toJson( $options = 0 )
     {
-        return json_encode($this->jsonSerialize(), $options);
+        return json_encode( $this->jsonSerialize(), $options );
     }
 
     /**
@@ -1507,7 +1507,7 @@ 
      */
     public function getIterator()
     {
-        return new ArrayIterator($this->items);
+        return new ArrayIterator( $this->items );
     }
 
     /**
@@ -1516,9 +1516,9 @@ 
      * @param  int  $flags
      * @return \CachingIterator
      */
-    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
+    public function getCachingIterator( $flags = CachingIterator::CALL_TOSTRING )
     {
-        return new CachingIterator($this->getIterator(), $flags);
+        return new CachingIterator( $this->getIterator(), $flags );
     }
 
     /**
@@ -1528,7 +1528,7 @@ 
      */
     public function count()
     {
-        return count($this->items);
+        return count( $this->items );
     }
 
     /**
@@ -1538,7 +1538,7 @@ 
      */
     public function toBase()
     {
-        return new self($this);
+        return new self( $this );
     }
 
     /**
@@ -1547,9 +1547,9 @@ 
      * @param  mixed  $key
      * @return bool
      */
-    public function offsetExists($key)
+    public function offsetExists( $key )
     {
-        return array_key_exists($key, $this->items);
+        return array_key_exists( $key, $this->items );
     }
 
     /**
@@ -1558,9 +1558,9 @@ 
      * @param  mixed  $key
      * @return mixed
      */
-    public function offsetGet($key)
+    public function offsetGet( $key )
     {
-        return $this->items[$key];
+        return $this->items[ $key ];
     }
 
     /**
@@ -1570,12 +1570,12 @@ 
      * @param  mixed  $value
      * @return void
      */
-    public function offsetSet($key, $value)
+    public function offsetSet( $key, $value )
     {
-        if (is_null($key)) {
-            $this->items[] = $value;
+        if ( is_null( $key ) ) {
+            $this->items[ ] = $value;
         } else {
-            $this->items[$key] = $value;
+            $this->items[ $key ] = $value;
         }
     }
 
@@ -1585,9 +1585,9 @@ 
      * @param  string  $key
      * @return void
      */
-    public function offsetUnset($key)
+    public function offsetUnset( $key )
     {
-        unset($this->items[$key]);
+        unset( $this->items[ $key ] );
     }
 
     /**
@@ -1606,23 +1606,23 @@ 
      * @param  mixed  $items
      * @return array
      */
-    protected function getArrayableItems($items)
+    protected function getArrayableItems( $items )
     {
-        if (is_array($items)) {
+        if ( is_array( $items ) ) {
             return $items;
-        } elseif ($items instanceof self) {
+        } elseif ( $items instanceof self ) {
             return $items->all();
-        } elseif ($items instanceof Arrayable) {
+        } elseif ( $items instanceof Arrayable ) {
             return $items->toArray();
-        } elseif ($items instanceof Jsonable) {
-            return json_decode($items->toJson(), true);
-        } elseif ($items instanceof JsonSerializable) {
+        } 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);
+        } elseif ( $items instanceof Traversable ) {
+            return iterator_to_array( $items );
         }
 
-        return (array) $items;
+        return (array)$items;
     }
 
     /**
@@ -1631,9 +1631,9 @@ 
      * @param  string  $method
      * @return void
      */
-    public static function proxy($method)
+    public static function proxy( $method )
     {
-        static::$proxies[] = $method;
+        static::$proxies[ ] = $method;
     }
 
     /**
@@ -1644,12 +1644,12 @@ 
      *
      * @throws \Exception
      */
-    public function __get($key)
+    public function __get( $key )
     {
-        if (! in_array($key, static::$proxies)) {
-            throw new Exception("Property [{$key}] does not exist on this collection instance.");
+        if ( ! in_array( $key, static::$proxies ) ) {
+            throw new Exception( "Property [{$key}] does not exist on this collection instance." );
         }
 
-        return new HigherOrderCollectionProxy($this, $key);
+        return new HigherOrderCollectionProxy( $this, $key );
     }
 }

Braces +105 added lines, -210 removed lines

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

vendor/illuminate/support/Facades/Input.php

Indentation +22 added lines, -22 removed lines

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

Spacing +2 added lines, -2 removed lines

@@ -16,9 +16,9 @@
      * @param  mixed   $default
      * @return mixed
      */
-    public static function get($key = null, $default = null)
+    public static function get( $key = null, $default = null )
     {
-        return static::$app['request']->input($key, $default);
+        return static::$app[ 'request' ]->input( $key, $default );
     }
 
     /**

Braces +3 added lines, -6 removed lines

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

vendor/illuminate/support/Arr.php

Indentation +591 added lines, -591 removed lines

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

Spacing +148 added lines, -148 removed lines

@@ -16,9 +16,9 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public static function accessible($value)
+    public static function accessible( $value )
     {
-        return is_array($value) || $value instanceof ArrayAccess;
+        return is_array( $value ) || $value instanceof ArrayAccess;
     }
 
     /**
@@ -29,10 +29,10 @@ 
      * @param  mixed   $value
      * @return array
      */
-    public static function add($array, $key, $value)
+    public static function add( $array, $key, $value )
     {
-        if (is_null(static::get($array, $key))) {
-            static::set($array, $key, $value);
+        if ( is_null( static::get( $array, $key ) ) ) {
+            static::set( $array, $key, $value );
         }
 
         return $array;
@@ -44,18 +44,18 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function collapse($array)
+    public static function collapse( $array )
     {
-        $results = [];
+        $results = [ ];
 
-        foreach ($array as $values) {
-            if ($values instanceof Collection) {
+        foreach ( $array as $values ) {
+            if ( $values instanceof Collection ) {
                 $values = $values->all();
-            } elseif (! is_array($values)) {
+            } elseif ( ! is_array( $values ) ) {
                 continue;
             }
 
-            $results = array_merge($results, $values);
+            $results = array_merge( $results, $values );
         }
 
         return $results;
@@ -67,18 +67,18 @@ 
      * @param  array  ...$arrays
      * @return array
      */
-    public static function crossJoin(...$arrays)
+    public static function crossJoin( ...$arrays )
     {
-        $results = [[]];
+        $results = [ [ ] ];
 
-        foreach ($arrays as $index => $array) {
-            $append = [];
+        foreach ( $arrays as $index => $array ) {
+            $append = [ ];
 
-            foreach ($results as $product) {
-                foreach ($array as $item) {
-                    $product[$index] = $item;
+            foreach ( $results as $product ) {
+                foreach ( $array as $item ) {
+                    $product[ $index ] = $item;
 
-                    $append[] = $product;
+                    $append[ ] = $product;
                 }
             }
 
@@ -94,9 +94,9 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function divide($array)
+    public static function divide( $array )
     {
-        return [array_keys($array), array_values($array)];
+        return [ array_keys( $array ), array_values( $array ) ];
     }
 
     /**
@@ -106,15 +106,15 @@ 
      * @param  string  $prepend
      * @return array
      */
-    public static function dot($array, $prepend = '')
+    public static function dot( $array, $prepend = '' )
     {
-        $results = [];
+        $results = [ ];
 
-        foreach ($array as $key => $value) {
-            if (is_array($value) && ! empty($value)) {
-                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+        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;
+                $results[ $prepend . $key ] = $value;
             }
         }
 
@@ -128,9 +128,9 @@ 
      * @param  array|string  $keys
      * @return array
      */
-    public static function except($array, $keys)
+    public static function except( $array, $keys )
     {
-        static::forget($array, $keys);
+        static::forget( $array, $keys );
 
         return $array;
     }
@@ -142,13 +142,13 @@ 
      * @param  string|int  $key
      * @return bool
      */
-    public static function exists($array, $key)
+    public static function exists( $array, $key )
     {
-        if ($array instanceof ArrayAccess) {
-            return $array->offsetExists($key);
+        if ( $array instanceof ArrayAccess ) {
+            return $array->offsetExists( $key );
         }
 
-        return array_key_exists($key, $array);
+        return array_key_exists( $key, $array );
     }
 
     /**
@@ -159,25 +159,25 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public static function first($array, callable $callback = null, $default = null)
+    public static function first( $array, callable $callback = null, $default = null )
     {
-        if (is_null($callback)) {
-            if (empty($array)) {
-                return value($default);
+        if ( is_null( $callback ) ) {
+            if ( empty( $array ) ) {
+                return value( $default );
             }
 
-            foreach ($array as $item) {
+            foreach ( $array as $item ) {
                 return $item;
             }
         }
 
-        foreach ($array as $key => $value) {
-            if (call_user_func($callback, $value, $key)) {
+        foreach ( $array as $key => $value ) {
+            if ( call_user_func( $callback, $value, $key ) ) {
                 return $value;
             }
         }
 
-        return value($default);
+        return value( $default );
     }
 
     /**
@@ -188,13 +188,13 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public static function last($array, callable $callback = null, $default = null)
+    public static function last( $array, callable $callback = null, $default = null )
     {
-        if (is_null($callback)) {
-            return empty($array) ? value($default) : end($array);
+        if ( is_null( $callback ) ) {
+            return empty( $array ) ? value( $default ) : end( $array );
         }
 
-        return static::first(array_reverse($array, true), $callback, $default);
+        return static::first( array_reverse( $array, true ), $callback, $default );
     }
 
     /**
@@ -204,19 +204,19 @@ 
      * @param  int  $depth
      * @return array
      */
-    public static function flatten($array, $depth = INF)
+    public static function flatten( $array, $depth = INF )
     {
-        return array_reduce($array, function ($result, $item) use ($depth) {
+        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));
+            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));
+                return array_merge( $result, static::flatten( $item, $depth - 1 ) );
             }
-        }, []);
+        }, [ ] );
     }
 
     /**
@@ -226,40 +226,40 @@ 
      * @param  array|string  $keys
      * @return void
      */
-    public static function forget(&$array, $keys)
+    public static function forget( &$array, $keys )
     {
         $original = &$array;
 
-        $keys = (array) $keys;
+        $keys = (array)$keys;
 
-        if (count($keys) === 0) {
+        if ( count( $keys ) === 0 ) {
             return;
         }
 
-        foreach ($keys as $key) {
+        foreach ( $keys as $key ) {
             // if the exact key exists in the top-level, remove it
-            if (static::exists($array, $key)) {
-                unset($array[$key]);
+            if ( static::exists( $array, $key ) ) {
+                unset( $array[ $key ] );
 
                 continue;
             }
 
-            $parts = explode('.', $key);
+            $parts = explode( '.', $key );
 
             // clean up before each pass
             $array = &$original;
 
-            while (count($parts) > 1) {
-                $part = array_shift($parts);
+            while ( count( $parts ) > 1 ) {
+                $part = array_shift( $parts );
 
-                if (isset($array[$part]) && is_array($array[$part])) {
-                    $array = &$array[$part];
+                if ( isset( $array[ $part ] ) && is_array( $array[ $part ] ) ) {
+                    $array = &$array[ $part ];
                 } else {
                     continue 2;
                 }
             }
 
-            unset($array[array_shift($parts)]);
+            unset( $array[ array_shift( $parts ) ] );
         }
     }
 
@@ -271,25 +271,25 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function get($array, $key, $default = null)
+    public static function get( $array, $key, $default = null )
     {
-        if (! static::accessible($array)) {
-            return value($default);
+        if ( ! static::accessible( $array ) ) {
+            return value( $default );
         }
 
-        if (is_null($key)) {
+        if ( is_null( $key ) ) {
             return $array;
         }
 
-        if (static::exists($array, $key)) {
-            return $array[$key];
+        if ( static::exists( $array, $key ) ) {
+            return $array[ $key ];
         }
 
-        foreach (explode('.', $key) as $segment) {
-            if (static::accessible($array) && static::exists($array, $segment)) {
-                $array = $array[$segment];
+        foreach ( explode( '.', $key ) as $segment ) {
+            if ( static::accessible( $array ) && static::exists( $array, $segment ) ) {
+                $array = $array[ $segment ];
             } else {
-                return value($default);
+                return value( $default );
             }
         }
 
@@ -303,32 +303,32 @@ 
      * @param  string|array  $keys
      * @return bool
      */
-    public static function has($array, $keys)
+    public static function has( $array, $keys )
     {
-        if (is_null($keys)) {
+        if ( is_null( $keys ) ) {
             return false;
         }
 
-        $keys = (array) $keys;
+        $keys = (array)$keys;
 
-        if (! $array) {
+        if ( ! $array ) {
             return false;
         }
 
-        if ($keys === []) {
+        if ( $keys === [ ] ) {
             return false;
         }
 
-        foreach ($keys as $key) {
+        foreach ( $keys as $key ) {
             $subKeyArray = $array;
 
-            if (static::exists($array, $key)) {
+            if ( static::exists( $array, $key ) ) {
                 continue;
             }
 
-            foreach (explode('.', $key) as $segment) {
-                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
-                    $subKeyArray = $subKeyArray[$segment];
+            foreach ( explode( '.', $key ) as $segment ) {
+                if ( static::accessible( $subKeyArray ) && static::exists( $subKeyArray, $segment ) ) {
+                    $subKeyArray = $subKeyArray[ $segment ];
                 } else {
                     return false;
                 }
@@ -346,11 +346,11 @@ 
      * @param  array  $array
      * @return bool
      */
-    public static function isAssoc(array $array)
+    public static function isAssoc( array $array )
     {
-        $keys = array_keys($array);
+        $keys = array_keys( $array );
 
-        return array_keys($keys) !== $keys;
+        return array_keys( $keys ) !== $keys;
     }
 
     /**
@@ -360,9 +360,9 @@ 
      * @param  array|string  $keys
      * @return array
      */
-    public static function only($array, $keys)
+    public static function only( $array, $keys )
     {
-        return array_intersect_key($array, array_flip((array) $keys));
+        return array_intersect_key( $array, array_flip( (array)$keys ) );
     }
 
     /**
@@ -373,28 +373,28 @@ 
      * @param  string|array|null  $key
      * @return array
      */
-    public static function pluck($array, $value, $key = null)
+    public static function pluck( $array, $value, $key = null )
     {
-        $results = [];
+        $results = [ ];
 
-        list($value, $key) = static::explodePluckParameters($value, $key);
+        list( $value, $key ) = static::explodePluckParameters( $value, $key );
 
-        foreach ($array as $item) {
-            $itemValue = data_get($item, $value);
+        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;
+            if ( is_null( $key ) ) {
+                $results[ ] = $itemValue;
             } else {
-                $itemKey = data_get($item, $key);
+                $itemKey = data_get( $item, $key );
 
-                if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
-                    $itemKey = (string) $itemKey;
+                if ( is_object( $itemKey ) && method_exists( $itemKey, '__toString' ) ) {
+                    $itemKey = (string)$itemKey;
                 }
 
-                $results[$itemKey] = $itemValue;
+                $results[ $itemKey ] = $itemValue;
             }
         }
 
@@ -408,13 +408,13 @@ 
      * @param  string|array|null  $key
      * @return array
      */
-    protected static function explodePluckParameters($value, $key)
+    protected static function explodePluckParameters( $value, $key )
     {
-        $value = is_string($value) ? explode('.', $value) : $value;
+        $value = is_string( $value ) ? explode( '.', $value ) : $value;
 
-        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
+        $key = is_null( $key ) || is_array( $key ) ? $key : explode( '.', $key );
 
-        return [$value, $key];
+        return [ $value, $key ];
     }
 
     /**
@@ -425,12 +425,12 @@ 
      * @param  mixed  $key
      * @return array
      */
-    public static function prepend($array, $value, $key = null)
+    public static function prepend( $array, $value, $key = null )
     {
-        if (is_null($key)) {
-            array_unshift($array, $value);
+        if ( is_null( $key ) ) {
+            array_unshift( $array, $value );
         } else {
-            $array = [$key => $value] + $array;
+            $array = [ $key => $value ] + $array;
         }
 
         return $array;
@@ -444,11 +444,11 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function pull(&$array, $key, $default = null)
+    public static function pull( &$array, $key, $default = null )
     {
-        $value = static::get($array, $key, $default);
+        $value = static::get( $array, $key, $default );
 
-        static::forget($array, $key);
+        static::forget( $array, $key );
 
         return $value;
     }
@@ -462,32 +462,32 @@ 
      *
      * @throws \InvalidArgumentException
      */
-    public static function random($array, $number = null)
+    public static function random( $array, $number = null )
     {
-        $requested = is_null($number) ? 1 : $number;
+        $requested = is_null( $number ) ? 1 : $number;
 
-        $count = count($array);
+        $count = count( $array );
 
-        if ($requested > $count) {
+        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 ( is_null( $number ) ) {
+            return $array[ array_rand( $array ) ];
         }
 
-        if ((int) $number === 0) {
-            return [];
+        if ( (int)$number === 0 ) {
+            return [ ];
         }
 
-        $keys = array_rand($array, $number);
+        $keys = array_rand( $array, $number );
 
-        $results = [];
+        $results = [ ];
 
-        foreach ((array) $keys as $key) {
-            $results[] = $array[$key];
+        foreach ( (array)$keys as $key ) {
+            $results[ ] = $array[ $key ];
         }
 
         return $results;
@@ -503,28 +503,28 @@ 
      * @param  mixed   $value
      * @return array
      */
-    public static function set(&$array, $key, $value)
+    public static function set( &$array, $key, $value )
     {
-        if (is_null($key)) {
+        if ( is_null( $key ) ) {
             return $array = $value;
         }
 
-        $keys = explode('.', $key);
+        $keys = explode( '.', $key );
 
-        while (count($keys) > 1) {
-            $key = array_shift($keys);
+        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] = [];
+            if ( ! isset( $array[ $key ] ) || ! is_array( $array[ $key ] ) ) {
+                $array[ $key ] = [ ];
             }
 
-            $array = &$array[$key];
+            $array = &$array[ $key ];
         }
 
-        $array[array_shift($keys)] = $value;
+        $array[ array_shift( $keys ) ] = $value;
 
         return $array;
     }
@@ -535,9 +535,9 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function shuffle($array)
+    public static function shuffle( $array )
     {
-        shuffle($array);
+        shuffle( $array );
 
         return $array;
     }
@@ -549,9 +549,9 @@ 
      * @param  callable|string  $callback
      * @return array
      */
-    public static function sort($array, $callback)
+    public static function sort( $array, $callback )
     {
-        return Collection::make($array)->sortBy($callback)->all();
+        return Collection::make( $array )->sortBy( $callback )->all();
     }
 
     /**
@@ -560,18 +560,18 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function sortRecursive($array)
+    public static function sortRecursive( $array )
     {
-        foreach ($array as &$value) {
-            if (is_array($value)) {
-                $value = static::sortRecursive($value);
+        foreach ( $array as &$value ) {
+            if ( is_array( $value ) ) {
+                $value = static::sortRecursive( $value );
             }
         }
 
-        if (static::isAssoc($array)) {
-            ksort($array);
+        if ( static::isAssoc( $array ) ) {
+            ksort( $array );
         } else {
-            sort($array);
+            sort( $array );
         }
 
         return $array;
@@ -584,9 +584,9 @@ 
      * @param  callable  $callback
      * @return array
      */
-    public static function where($array, callable $callback)
+    public static function where( $array, callable $callback )
     {
-        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
+        return array_filter( $array, $callback, ARRAY_FILTER_USE_BOTH );
     }
 
     /**
@@ -595,8 +595,8 @@ 
      * @param  mixed  $value
      * @return array
      */
-    public static function wrap($value)
+    public static function wrap( $value )
     {
-        return ! is_array($value) ? [$value] : $value;
+        return ! is_array( $value ) ? [ $value ] : $value;
     }
 }

Braces +28 added lines, -56 removed lines

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

vendor/illuminate/support/Debug/HtmlDumper.php

Indentation +20 added lines, -20 removed lines

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

Braces +1 added lines, -2 removed lines

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

vendor/illuminate/support/Debug/Dumper.php

Indentation +15 added lines, -15 removed lines

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

Spacing +4 added lines, -4 removed lines

@@ -13,14 +13,14 @@
      * @param  mixed  $value
      * @return void
      */
-    public function dump($value)
+    public function dump( $value )
     {
-        if (class_exists(CliDumper::class)) {
+        if ( class_exists( CliDumper::class ) ) {
             $dumper = 'cli' === PHP_SAPI ? new CliDumper : new HtmlDumper;
 
-            $dumper->dump((new VarCloner)->cloneVar($value));
+            $dumper->dump( ( new VarCloner )->cloneVar( $value ) );
         } else {
-            var_dump($value);
+            var_dump( $value );
         }
     }
 }

Braces +2 added lines, -4 removed lines

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

vendor/illuminate/contracts/Logging/Log.php

Indentation +82 added lines, -82 removed lines

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

Spacing +10 added lines, -10 removed lines

@@ -11,7 +11,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function alert($message, array $context = []);
+    public function alert( $message, array $context = [ ] );
 
     /**
      * Log a critical message to the logs.
@@ -20,7 +20,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function critical($message, array $context = []);
+    public function critical( $message, array $context = [ ] );
 
     /**
      * Log an error message to the logs.
@@ -29,7 +29,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function error($message, array $context = []);
+    public function error( $message, array $context = [ ] );
 
     /**
      * Log a warning message to the logs.
@@ -38,7 +38,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function warning($message, array $context = []);
+    public function warning( $message, array $context = [ ] );
 
     /**
      * Log a notice to the logs.
@@ -47,7 +47,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function notice($message, array $context = []);
+    public function notice( $message, array $context = [ ] );
 
     /**
      * Log an informational message to the logs.
@@ -56,7 +56,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function info($message, array $context = []);
+    public function info( $message, array $context = [ ] );
 
     /**
      * Log a debug message to the logs.
@@ -65,7 +65,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function debug($message, array $context = []);
+    public function debug( $message, array $context = [ ] );
 
     /**
      * Log a message to the logs.
@@ -75,7 +75,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function log($level, $message, array $context = []);
+    public function log( $level, $message, array $context = [ ] );
 
     /**
      * Register a file log handler.
@@ -84,7 +84,7 @@ 
      * @param  string  $level
      * @return void
      */
-    public function useFiles($path, $level = 'debug');
+    public function useFiles( $path, $level = 'debug' );
 
     /**
      * Register a daily file log handler.
@@ -94,5 +94,5 @@ 
      * @param  string  $level
      * @return void
      */
-    public function useDailyFiles($path, $days = 0, $level = 'debug');
+    public function useDailyFiles( $path, $days = 0, $level = 'debug' );
 }

Braces +1 added lines, -2 removed lines

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

vendor/symfony/polyfill-mbstring/Mbstring.php

Braces +42 added lines, -84 removed lines

@@ -65,8 +65,7 @@ 
  *
  * @internal
  */
-final class Mbstring
-{
+final class Mbstring {
     public const MB_CASE_FOLD = \PHP_INT_MAX;
 
     private const CASE_FOLD = [
@@ -78,8 +77,7 @@ 
     private static $language = 'neutral';
     private static $internalEncoding = 'UTF-8';
 
-    public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
-    {
+    public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null) {
         if (\is_array($fromEncoding) || ($fromEncoding !== null && false !== strpos($fromEncoding, ','))) {
             $fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
         } else {
@@ -116,8 +114,7 @@ 
         return \iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
     }
 
-    public static function mb_convert_variables($toEncoding, $fromEncoding, &...$vars)
-    {
+    public static function mb_convert_variables($toEncoding, $fromEncoding, &...$vars) {
         $ok = true;
         array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
             if (false === $v = self::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
@@ -128,18 +125,15 @@ 
         return $ok ? $fromEncoding : false;
     }
 
-    public static function mb_decode_mimeheader($s)
-    {
+    public static function mb_decode_mimeheader($s) {
         return \iconv_mime_decode($s, 2, self::$internalEncoding);
     }
 
-    public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
-    {
+    public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null) {
         trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', \E_USER_WARNING);
     }
 
-    public static function mb_decode_numericentity($s, $convmap, $encoding = null)
-    {
+    public static function mb_decode_numericentity($s, $convmap, $encoding = null) {
         if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
             trigger_error('mb_decode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
 
@@ -198,8 +192,7 @@ 
         return \iconv('UTF-8', $encoding.'//IGNORE', $s);
     }
 
-    public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false)
-    {
+    public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false) {
         if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
             trigger_error('mb_encode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
 
@@ -268,8 +261,7 @@ 
         return \iconv('UTF-8', $encoding.'//IGNORE', $result);
     }
 
-    public static function mb_convert_case($s, $mode, $encoding = null)
-    {
+    public static function mb_convert_case($s, $mode, $encoding = null) {
         $s = (string) $s;
         if ('' === $s) {
             return '';
@@ -346,8 +338,7 @@ 
         return \iconv('UTF-8', $encoding.'//IGNORE', $s);
     }
 
-    public static function mb_internal_encoding($encoding = null)
-    {
+    public static function mb_internal_encoding($encoding = null) {
         if (null === $encoding) {
             return self::$internalEncoding;
         }
@@ -367,8 +358,7 @@ 
         throw new \ValueError(sprintf('Argument #1 ($encoding) must be a valid encoding, "%s" given', $encoding));
     }
 
-    public static function mb_language($lang = null)
-    {
+    public static function mb_language($lang = null) {
         if (null === $lang) {
             return self::$language;
         }
@@ -388,13 +378,11 @@ 
         throw new \ValueError(sprintf('Argument #1 ($language) must be a valid language, "%s" given', $lang));
     }
 
-    public static function mb_list_encodings()
-    {
+    public static function mb_list_encodings() {
         return ['UTF-8'];
     }
 
-    public static function mb_encoding_aliases($encoding)
-    {
+    public static function mb_encoding_aliases($encoding) {
         switch (strtoupper($encoding)) {
             case 'UTF8':
             case 'UTF-8':
@@ -404,8 +392,7 @@ 
         return false;
     }
 
-    public static function mb_check_encoding($var = null, $encoding = null)
-    {
+    public static function mb_check_encoding($var = null, $encoding = null) {
         if (null === $encoding) {
             if (null === $var) {
                 return false;
@@ -416,8 +403,7 @@ 
         return self::mb_detect_encoding($var, [$encoding]) || false !== @\iconv($encoding, $encoding, $var);
     }
 
-    public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
-    {
+    public static function mb_detect_encoding($str, $encodingList = null, $strict = false) {
         if (null === $encodingList) {
             $encodingList = self::$encodingList;
         } else {
@@ -452,8 +438,7 @@ 
         return false;
     }
 
-    public static function mb_detect_order($encodingList = null)
-    {
+    public static function mb_detect_order($encodingList = null) {
         if (null === $encodingList) {
             return self::$encodingList;
         }
@@ -481,8 +466,7 @@ 
         return true;
     }
 
-    public static function mb_strlen($s, $encoding = null)
-    {
+    public static function mb_strlen($s, $encoding = null) {
         $encoding = self::getEncoding($encoding);
         if ('CP850' === $encoding || 'ASCII' === $encoding) {
             return \strlen($s);
@@ -491,8 +475,7 @@ 
         return @\iconv_strlen($s, $encoding);
     }
 
-    public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
-    {
+    public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null) {
         $encoding = self::getEncoding($encoding);
         if ('CP850' === $encoding || 'ASCII' === $encoding) {
             return strpos($haystack, $needle, $offset);
@@ -512,8 +495,7 @@ 
         return \iconv_strpos($haystack, $needle, $offset, $encoding);
     }
 
-    public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
-    {
+    public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null) {
         $encoding = self::getEncoding($encoding);
         if ('CP850' === $encoding || 'ASCII' === $encoding) {
             return strrpos($haystack, $needle, $offset);
@@ -539,8 +521,7 @@ 
         return false !== $pos ? $offset + $pos : false;
     }
 
-    public static function mb_str_split($string, $split_length = 1, $encoding = null)
-    {
+    public static function mb_str_split($string, $split_length = 1, $encoding = null) {
         if (null !== $string && !is_scalar($string) && !(\is_object($string) && method_exists($string, '__toString'))) {
             trigger_error('mb_str_split() expects parameter 1 to be string, '.\gettype($string).' given', \E_USER_WARNING);
 
@@ -581,18 +562,15 @@ 
         return $result;
     }
 
-    public static function mb_strtolower($s, $encoding = null)
-    {
+    public static function mb_strtolower($s, $encoding = null) {
         return self::mb_convert_case($s, \MB_CASE_LOWER, $encoding);
     }
 
-    public static function mb_strtoupper($s, $encoding = null)
-    {
+    public static function mb_strtoupper($s, $encoding = null) {
         return self::mb_convert_case($s, \MB_CASE_UPPER, $encoding);
     }
 
-    public static function mb_substitute_character($c = null)
-    {
+    public static function mb_substitute_character($c = null) {
         if (null === $c) {
             return 'none';
         }
@@ -609,8 +587,7 @@ 
         throw new \ValueError('Argument #1 ($substitute_character) must be "none", "long", "entity" or a valid codepoint');
     }
 
-    public static function mb_substr($s, $start, $length = null, $encoding = null)
-    {
+    public static function mb_substr($s, $start, $length = null, $encoding = null) {
         $encoding = self::getEncoding($encoding);
         if ('CP850' === $encoding || 'ASCII' === $encoding) {
             return (string) substr($s, $start, null === $length ? 2147483647 : $length);
@@ -635,23 +612,20 @@ 
         return (string) \iconv_substr($s, $start, $length, $encoding);
     }
 
-    public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
-    {
+    public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null) {
         $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
         $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
 
         return self::mb_strpos($haystack, $needle, $offset, $encoding);
     }
 
-    public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
-    {
+    public static function mb_stristr($haystack, $needle, $part = false, $encoding = null) {
         $pos = self::mb_stripos($haystack, $needle, 0, $encoding);
 
         return self::getSubpart($pos, $part, $haystack, $encoding);
     }
 
-    public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
-    {
+    public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null) {
         $encoding = self::getEncoding($encoding);
         if ('CP850' === $encoding || 'ASCII' === $encoding) {
             $pos = strrpos($haystack, $needle);
@@ -663,24 +637,21 @@ 
         return self::getSubpart($pos, $part, $haystack, $encoding);
     }
 
-    public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
-    {
+    public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null) {
         $needle = self::mb_substr($needle, 0, 1, $encoding);
         $pos = self::mb_strripos($haystack, $needle, $encoding);
 
         return self::getSubpart($pos, $part, $haystack, $encoding);
     }
 
-    public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
-    {
+    public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null) {
         $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
         $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
 
         return self::mb_strrpos($haystack, $needle, $offset, $encoding);
     }
 
-    public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
-    {
+    public static function mb_strstr($haystack, $needle, $part = false, $encoding = null) {
         $pos = strpos($haystack, $needle);
         if (false === $pos) {
             return false;
@@ -692,8 +663,7 @@ 
         return substr($haystack, $pos);
     }
 
-    public static function mb_get_info($type = 'all')
-    {
+    public static function mb_get_info($type = 'all') {
         $info = [
             'internal_encoding' => self::$internalEncoding,
             'http_output' => 'pass',
@@ -721,18 +691,15 @@ 
         return false;
     }
 
-    public static function mb_http_input($type = '')
-    {
+    public static function mb_http_input($type = '') {
         return false;
     }
 
-    public static function mb_http_output($encoding = null)
-    {
+    public static function mb_http_output($encoding = null) {
         return null !== $encoding ? 'pass' === $encoding : 'pass';
     }
 
-    public static function mb_strwidth($s, $encoding = null)
-    {
+    public static function mb_strwidth($s, $encoding = null) {
         $encoding = self::getEncoding($encoding);
 
         if ('UTF-8' !== $encoding) {
@@ -744,18 +711,15 @@ 
         return ($wide << 1) + \iconv_strlen($s, 'UTF-8');
     }
 
-    public static function mb_substr_count($haystack, $needle, $encoding = null)
-    {
+    public static function mb_substr_count($haystack, $needle, $encoding = null) {
         return substr_count($haystack, $needle);
     }
 
-    public static function mb_output_handler($contents, $status)
-    {
+    public static function mb_output_handler($contents, $status) {
         return $contents;
     }
 
-    public static function mb_chr($code, $encoding = null)
-    {
+    public static function mb_chr($code, $encoding = null) {
         if (0x80 > $code %= 0x200000) {
             $s = \chr($code);
         } elseif (0x800 > $code) {
@@ -773,8 +737,7 @@ 
         return $s;
     }
 
-    public static function mb_ord($s, $encoding = null)
-    {
+    public static function mb_ord($s, $encoding = null) {
         if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
             $s = mb_convert_encoding($s, 'UTF-8', $encoding);
         }
@@ -797,8 +760,7 @@ 
         return $code;
     }
 
-    private static function getSubpart($pos, $part, $haystack, $encoding)
-    {
+    private static function getSubpart($pos, $part, $haystack, $encoding) {
         if (false === $pos) {
             return false;
         }
@@ -809,8 +771,7 @@ 
         return self::mb_substr($haystack, $pos, null, $encoding);
     }
 
-    private static function html_encoding_callback(array $m)
-    {
+    private static function html_encoding_callback(array $m) {
         $i = 1;
         $entities = '';
         $m = unpack('C*', htmlentities($m[0], \ENT_COMPAT, 'UTF-8'));
@@ -834,13 +795,11 @@ 
         return $entities;
     }
 
-    private static function title_case(array $s)
-    {
+    private static function title_case(array $s) {
         return self::mb_convert_case($s[1], \MB_CASE_UPPER, 'UTF-8').self::mb_convert_case($s[2], \MB_CASE_LOWER, 'UTF-8');
     }
 
-    private static function getData($file)
-    {
+    private static function getData($file) {
         if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
             return require $file;
         }
@@ -848,8 +807,7 @@ 
         return false;
     }
 
-    private static function getEncoding($encoding)
-    {
+    private static function getEncoding($encoding) {
         if (null === $encoding) {
             return self::$internalEncoding;
         }

Indentation +803 added lines, -803 removed lines

@@ -70,807 +70,807 @@
  */
 final class Mbstring
 {
-    public const MB_CASE_FOLD = \PHP_INT_MAX;
-
-    private const CASE_FOLD = [
-        ['µ', 'ſ', "\xCD\x85", 'ς', "\xCF\x90", "\xCF\x91", "\xCF\x95", "\xCF\x96", "\xCF\xB0", "\xCF\xB1", "\xCF\xB5", "\xE1\xBA\x9B", "\xE1\xBE\xBE"],
-        ['μ', 's', 'ι',        'σ', 'β',        'θ',        'φ',        'π',        'κ',        'ρ',        'ε',        "\xE1\xB9\xA1", 'ι'],
-    ];
-
-    private static $encodingList = ['ASCII', 'UTF-8'];
-    private static $language = 'neutral';
-    private static $internalEncoding = 'UTF-8';
-
-    public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
-    {
-        if (\is_array($fromEncoding) || ($fromEncoding !== null && false !== strpos($fromEncoding, ','))) {
-            $fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
-        } else {
-            $fromEncoding = self::getEncoding($fromEncoding);
-        }
-
-        $toEncoding = self::getEncoding($toEncoding);
-
-        if ('BASE64' === $fromEncoding) {
-            $s = base64_decode($s);
-            $fromEncoding = $toEncoding;
-        }
-
-        if ('BASE64' === $toEncoding) {
-            return base64_encode($s);
-        }
-
-        if ('HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding) {
-            if ('HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding) {
-                $fromEncoding = 'Windows-1252';
-            }
-            if ('UTF-8' !== $fromEncoding) {
-                $s = \iconv($fromEncoding, 'UTF-8//IGNORE', $s);
-            }
-
-            return preg_replace_callback('/[\x80-\xFF]+/', [__CLASS__, 'html_encoding_callback'], $s);
-        }
-
-        if ('HTML-ENTITIES' === $fromEncoding) {
-            $s = html_entity_decode($s, \ENT_COMPAT, 'UTF-8');
-            $fromEncoding = 'UTF-8';
-        }
-
-        return \iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
-    }
-
-    public static function mb_convert_variables($toEncoding, $fromEncoding, &...$vars)
-    {
-        $ok = true;
-        array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
-            if (false === $v = self::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
-                $ok = false;
-            }
-        });
-
-        return $ok ? $fromEncoding : false;
-    }
-
-    public static function mb_decode_mimeheader($s)
-    {
-        return \iconv_mime_decode($s, 2, self::$internalEncoding);
-    }
-
-    public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
-    {
-        trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', \E_USER_WARNING);
-    }
-
-    public static function mb_decode_numericentity($s, $convmap, $encoding = null)
-    {
-        if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
-            trigger_error('mb_decode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
-
-            return null;
-        }
-
-        if (!\is_array($convmap) || (80000 > \PHP_VERSION_ID && !$convmap)) {
-            return false;
-        }
-
-        if (null !== $encoding && !is_scalar($encoding)) {
-            trigger_error('mb_decode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', \E_USER_WARNING);
-
-            return '';  // Instead of null (cf. mb_encode_numericentity).
-        }
-
-        $s = (string) $s;
-        if ('' === $s) {
-            return '';
-        }
-
-        $encoding = self::getEncoding($encoding);
-
-        if ('UTF-8' === $encoding) {
-            $encoding = null;
-            if (!preg_match('//u', $s)) {
-                $s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
-            }
-        } else {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
-        }
-
-        $cnt = floor(\count($convmap) / 4) * 4;
-
-        for ($i = 0; $i < $cnt; $i += 4) {
-            // collector_decode_htmlnumericentity ignores $convmap[$i + 3]
-            $convmap[$i] += $convmap[$i + 2];
-            $convmap[$i + 1] += $convmap[$i + 2];
-        }
-
-        $s = preg_replace_callback('/&#(?:0*([0-9]+)|x0*([0-9a-fA-F]+))(?!&);?/', function (array $m) use ($cnt, $convmap) {
-            $c = isset($m[2]) ? (int) hexdec($m[2]) : $m[1];
-            for ($i = 0; $i < $cnt; $i += 4) {
-                if ($c >= $convmap[$i] && $c <= $convmap[$i + 1]) {
-                    return self::mb_chr($c - $convmap[$i + 2]);
-                }
-            }
-
-            return $m[0];
-        }, $s);
-
-        if (null === $encoding) {
-            return $s;
-        }
-
-        return \iconv('UTF-8', $encoding.'//IGNORE', $s);
-    }
-
-    public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false)
-    {
-        if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
-            trigger_error('mb_encode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
-
-            return null;
-        }
-
-        if (!\is_array($convmap) || (80000 > \PHP_VERSION_ID && !$convmap)) {
-            return false;
-        }
-
-        if (null !== $encoding && !is_scalar($encoding)) {
-            trigger_error('mb_encode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', \E_USER_WARNING);
-
-            return null;  // Instead of '' (cf. mb_decode_numericentity).
-        }
-
-        if (null !== $is_hex && !is_scalar($is_hex)) {
-            trigger_error('mb_encode_numericentity() expects parameter 4 to be boolean, '.\gettype($s).' given', \E_USER_WARNING);
-
-            return null;
-        }
-
-        $s = (string) $s;
-        if ('' === $s) {
-            return '';
-        }
-
-        $encoding = self::getEncoding($encoding);
-
-        if ('UTF-8' === $encoding) {
-            $encoding = null;
-            if (!preg_match('//u', $s)) {
-                $s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
-            }
-        } else {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
-        }
-
-        static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
-
-        $cnt = floor(\count($convmap) / 4) * 4;
-        $i = 0;
-        $len = \strlen($s);
-        $result = '';
-
-        while ($i < $len) {
-            $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
-            $uchr = substr($s, $i, $ulen);
-            $i += $ulen;
-            $c = self::mb_ord($uchr);
-
-            for ($j = 0; $j < $cnt; $j += 4) {
-                if ($c >= $convmap[$j] && $c <= $convmap[$j + 1]) {
-                    $cOffset = ($c + $convmap[$j + 2]) & $convmap[$j + 3];
-                    $result .= $is_hex ? sprintf('&#x%X;', $cOffset) : '&#'.$cOffset.';';
-                    continue 2;
-                }
-            }
-            $result .= $uchr;
-        }
-
-        if (null === $encoding) {
-            return $result;
-        }
-
-        return \iconv('UTF-8', $encoding.'//IGNORE', $result);
-    }
-
-    public static function mb_convert_case($s, $mode, $encoding = null)
-    {
-        $s = (string) $s;
-        if ('' === $s) {
-            return '';
-        }
-
-        $encoding = self::getEncoding($encoding);
-
-        if ('UTF-8' === $encoding) {
-            $encoding = null;
-            if (!preg_match('//u', $s)) {
-                $s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
-            }
-        } else {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
-        }
-
-        if (\MB_CASE_TITLE == $mode) {
-            static $titleRegexp = null;
-            if (null === $titleRegexp) {
-                $titleRegexp = self::getData('titleCaseRegexp');
-            }
-            $s = preg_replace_callback($titleRegexp, [__CLASS__, 'title_case'], $s);
-        } else {
-            if (\MB_CASE_UPPER == $mode) {
-                static $upper = null;
-                if (null === $upper) {
-                    $upper = self::getData('upperCase');
-                }
-                $map = $upper;
-            } else {
-                if (self::MB_CASE_FOLD === $mode) {
-                    $s = str_replace(self::CASE_FOLD[0], self::CASE_FOLD[1], $s);
-                }
-
-                static $lower = null;
-                if (null === $lower) {
-                    $lower = self::getData('lowerCase');
-                }
-                $map = $lower;
-            }
-
-            static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
-
-            $i = 0;
-            $len = \strlen($s);
-
-            while ($i < $len) {
-                $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
-                $uchr = substr($s, $i, $ulen);
-                $i += $ulen;
-
-                if (isset($map[$uchr])) {
-                    $uchr = $map[$uchr];
-                    $nlen = \strlen($uchr);
-
-                    if ($nlen == $ulen) {
-                        $nlen = $i;
-                        do {
-                            $s[--$nlen] = $uchr[--$ulen];
-                        } while ($ulen);
-                    } else {
-                        $s = substr_replace($s, $uchr, $i - $ulen, $ulen);
-                        $len += $nlen - $ulen;
-                        $i += $nlen - $ulen;
-                    }
-                }
-            }
-        }
-
-        if (null === $encoding) {
-            return $s;
-        }
-
-        return \iconv('UTF-8', $encoding.'//IGNORE', $s);
-    }
-
-    public static function mb_internal_encoding($encoding = null)
-    {
-        if (null === $encoding) {
-            return self::$internalEncoding;
-        }
-
-        $normalizedEncoding = self::getEncoding($encoding);
-
-        if ('UTF-8' === $normalizedEncoding || false !== @\iconv($normalizedEncoding, $normalizedEncoding, ' ')) {
-            self::$internalEncoding = $normalizedEncoding;
-
-            return true;
-        }
-
-        if (80000 > \PHP_VERSION_ID) {
-            return false;
-        }
-
-        throw new \ValueError(sprintf('Argument #1 ($encoding) must be a valid encoding, "%s" given', $encoding));
-    }
-
-    public static function mb_language($lang = null)
-    {
-        if (null === $lang) {
-            return self::$language;
-        }
-
-        switch ($normalizedLang = strtolower($lang)) {
-            case 'uni':
-            case 'neutral':
-                self::$language = $normalizedLang;
-
-                return true;
-        }
-
-        if (80000 > \PHP_VERSION_ID) {
-            return false;
-        }
-
-        throw new \ValueError(sprintf('Argument #1 ($language) must be a valid language, "%s" given', $lang));
-    }
-
-    public static function mb_list_encodings()
-    {
-        return ['UTF-8'];
-    }
-
-    public static function mb_encoding_aliases($encoding)
-    {
-        switch (strtoupper($encoding)) {
-            case 'UTF8':
-            case 'UTF-8':
-                return ['utf8'];
-        }
-
-        return false;
-    }
-
-    public static function mb_check_encoding($var = null, $encoding = null)
-    {
-        if (null === $encoding) {
-            if (null === $var) {
-                return false;
-            }
-            $encoding = self::$internalEncoding;
-        }
-
-        return self::mb_detect_encoding($var, [$encoding]) || false !== @\iconv($encoding, $encoding, $var);
-    }
-
-    public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
-    {
-        if (null === $encodingList) {
-            $encodingList = self::$encodingList;
-        } else {
-            if (!\is_array($encodingList)) {
-                $encodingList = array_map('trim', explode(',', $encodingList));
-            }
-            $encodingList = array_map('strtoupper', $encodingList);
-        }
-
-        foreach ($encodingList as $enc) {
-            switch ($enc) {
-                case 'ASCII':
-                    if (!preg_match('/[\x80-\xFF]/', $str)) {
-                        return $enc;
-                    }
-                    break;
-
-                case 'UTF8':
-                case 'UTF-8':
-                    if (preg_match('//u', $str)) {
-                        return 'UTF-8';
-                    }
-                    break;
-
-                default:
-                    if (0 === strncmp($enc, 'ISO-8859-', 9)) {
-                        return $enc;
-                    }
-            }
-        }
-
-        return false;
-    }
-
-    public static function mb_detect_order($encodingList = null)
-    {
-        if (null === $encodingList) {
-            return self::$encodingList;
-        }
-
-        if (!\is_array($encodingList)) {
-            $encodingList = array_map('trim', explode(',', $encodingList));
-        }
-        $encodingList = array_map('strtoupper', $encodingList);
-
-        foreach ($encodingList as $enc) {
-            switch ($enc) {
-                default:
-                    if (strncmp($enc, 'ISO-8859-', 9)) {
-                        return false;
-                    }
-                    // no break
-                case 'ASCII':
-                case 'UTF8':
-                case 'UTF-8':
-            }
-        }
-
-        self::$encodingList = $encodingList;
-
-        return true;
-    }
-
-    public static function mb_strlen($s, $encoding = null)
-    {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return \strlen($s);
-        }
-
-        return @\iconv_strlen($s, $encoding);
-    }
-
-    public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
-    {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return strpos($haystack, $needle, $offset);
-        }
-
-        $needle = (string) $needle;
-        if ('' === $needle) {
-            if (80000 > \PHP_VERSION_ID) {
-                trigger_error(__METHOD__.': Empty delimiter', \E_USER_WARNING);
-
-                return false;
-            }
-
-            return 0;
-        }
-
-        return \iconv_strpos($haystack, $needle, $offset, $encoding);
-    }
-
-    public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
-    {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return strrpos($haystack, $needle, $offset);
-        }
-
-        if ($offset != (int) $offset) {
-            $offset = 0;
-        } elseif ($offset = (int) $offset) {
-            if ($offset < 0) {
-                if (0 > $offset += self::mb_strlen($needle)) {
-                    $haystack = self::mb_substr($haystack, 0, $offset, $encoding);
-                }
-                $offset = 0;
-            } else {
-                $haystack = self::mb_substr($haystack, $offset, 2147483647, $encoding);
-            }
-        }
-
-        $pos = '' !== $needle || 80000 > \PHP_VERSION_ID
-            ? \iconv_strrpos($haystack, $needle, $encoding)
-            : self::mb_strlen($haystack, $encoding);
-
-        return false !== $pos ? $offset + $pos : false;
-    }
-
-    public static function mb_str_split($string, $split_length = 1, $encoding = null)
-    {
-        if (null !== $string && !is_scalar($string) && !(\is_object($string) && method_exists($string, '__toString'))) {
-            trigger_error('mb_str_split() expects parameter 1 to be string, '.\gettype($string).' given', \E_USER_WARNING);
-
-            return null;
-        }
-
-        if (1 > $split_length = (int) $split_length) {
-            if (80000 > \PHP_VERSION_ID) {
-                trigger_error('The length of each segment must be greater than zero', \E_USER_WARNING);
-                return false;
-            }
-
-            throw new \ValueError('Argument #2 ($length) must be greater than 0');
-        }
-
-        if (null === $encoding) {
-            $encoding = mb_internal_encoding();
-        }
-
-        if ('UTF-8' === $encoding = self::getEncoding($encoding)) {
-            $rx = '/(';
-            while (65535 < $split_length) {
-                $rx .= '.{65535}';
-                $split_length -= 65535;
-            }
-            $rx .= '.{'.$split_length.'})/us';
-
-            return preg_split($rx, $string, -1, \PREG_SPLIT_DELIM_CAPTURE | \PREG_SPLIT_NO_EMPTY);
-        }
-
-        $result = [];
-        $length = mb_strlen($string, $encoding);
-
-        for ($i = 0; $i < $length; $i += $split_length) {
-            $result[] = mb_substr($string, $i, $split_length, $encoding);
-        }
-
-        return $result;
-    }
-
-    public static function mb_strtolower($s, $encoding = null)
-    {
-        return self::mb_convert_case($s, \MB_CASE_LOWER, $encoding);
-    }
-
-    public static function mb_strtoupper($s, $encoding = null)
-    {
-        return self::mb_convert_case($s, \MB_CASE_UPPER, $encoding);
-    }
-
-    public static function mb_substitute_character($c = null)
-    {
-        if (null === $c) {
-            return 'none';
-        }
-        if (0 === strcasecmp($c, 'none')) {
-            return true;
-        }
-        if (80000 > \PHP_VERSION_ID) {
-            return false;
-        }
-        if (\is_int($c) || 'long' === $c || 'entity' === $c) {
-            return false;
-        }
-
-        throw new \ValueError('Argument #1 ($substitute_character) must be "none", "long", "entity" or a valid codepoint');
-    }
-
-    public static function mb_substr($s, $start, $length = null, $encoding = null)
-    {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return (string) substr($s, $start, null === $length ? 2147483647 : $length);
-        }
-
-        if ($start < 0) {
-            $start = \iconv_strlen($s, $encoding) + $start;
-            if ($start < 0) {
-                $start = 0;
-            }
-        }
-
-        if (null === $length) {
-            $length = 2147483647;
-        } elseif ($length < 0) {
-            $length = \iconv_strlen($s, $encoding) + $length - $start;
-            if ($length < 0) {
-                return '';
-            }
-        }
-
-        return (string) \iconv_substr($s, $start, $length, $encoding);
-    }
-
-    public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
-    {
-        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
-        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
-
-        return self::mb_strpos($haystack, $needle, $offset, $encoding);
-    }
-
-    public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
-    {
-        $pos = self::mb_stripos($haystack, $needle, 0, $encoding);
-
-        return self::getSubpart($pos, $part, $haystack, $encoding);
-    }
-
-    public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
-    {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            $pos = strrpos($haystack, $needle);
-        } else {
-            $needle = self::mb_substr($needle, 0, 1, $encoding);
-            $pos = \iconv_strrpos($haystack, $needle, $encoding);
-        }
-
-        return self::getSubpart($pos, $part, $haystack, $encoding);
-    }
-
-    public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
-    {
-        $needle = self::mb_substr($needle, 0, 1, $encoding);
-        $pos = self::mb_strripos($haystack, $needle, $encoding);
-
-        return self::getSubpart($pos, $part, $haystack, $encoding);
-    }
-
-    public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
-    {
-        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
-        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
-
-        return self::mb_strrpos($haystack, $needle, $offset, $encoding);
-    }
-
-    public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
-    {
-        $pos = strpos($haystack, $needle);
-        if (false === $pos) {
-            return false;
-        }
-        if ($part) {
-            return substr($haystack, 0, $pos);
-        }
-
-        return substr($haystack, $pos);
-    }
-
-    public static function mb_get_info($type = 'all')
-    {
-        $info = [
-            'internal_encoding' => self::$internalEncoding,
-            'http_output' => 'pass',
-            'http_output_conv_mimetypes' => '^(text/|application/xhtml\+xml)',
-            'func_overload' => 0,
-            'func_overload_list' => 'no overload',
-            'mail_charset' => 'UTF-8',
-            'mail_header_encoding' => 'BASE64',
-            'mail_body_encoding' => 'BASE64',
-            'illegal_chars' => 0,
-            'encoding_translation' => 'Off',
-            'language' => self::$language,
-            'detect_order' => self::$encodingList,
-            'substitute_character' => 'none',
-            'strict_detection' => 'Off',
-        ];
-
-        if ('all' === $type) {
-            return $info;
-        }
-        if (isset($info[$type])) {
-            return $info[$type];
-        }
-
-        return false;
-    }
-
-    public static function mb_http_input($type = '')
-    {
-        return false;
-    }
-
-    public static function mb_http_output($encoding = null)
-    {
-        return null !== $encoding ? 'pass' === $encoding : 'pass';
-    }
-
-    public static function mb_strwidth($s, $encoding = null)
-    {
-        $encoding = self::getEncoding($encoding);
-
-        if ('UTF-8' !== $encoding) {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
-        }
-
-        $s = preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide);
-
-        return ($wide << 1) + \iconv_strlen($s, 'UTF-8');
-    }
-
-    public static function mb_substr_count($haystack, $needle, $encoding = null)
-    {
-        return substr_count($haystack, $needle);
-    }
-
-    public static function mb_output_handler($contents, $status)
-    {
-        return $contents;
-    }
-
-    public static function mb_chr($code, $encoding = null)
-    {
-        if (0x80 > $code %= 0x200000) {
-            $s = \chr($code);
-        } elseif (0x800 > $code) {
-            $s = \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
-        } elseif (0x10000 > $code) {
-            $s = \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
-        } else {
-            $s = \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
-        }
-
-        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
-            $s = mb_convert_encoding($s, $encoding, 'UTF-8');
-        }
-
-        return $s;
-    }
-
-    public static function mb_ord($s, $encoding = null)
-    {
-        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
-            $s = mb_convert_encoding($s, 'UTF-8', $encoding);
-        }
-
-        if (1 === \strlen($s)) {
-            return \ord($s);
-        }
-
-        $code = ($s = unpack('C*', substr($s, 0, 4))) ? $s[1] : 0;
-        if (0xF0 <= $code) {
-            return (($code - 0xF0) << 18) + (($s[2] - 0x80) << 12) + (($s[3] - 0x80) << 6) + $s[4] - 0x80;
-        }
-        if (0xE0 <= $code) {
-            return (($code - 0xE0) << 12) + (($s[2] - 0x80) << 6) + $s[3] - 0x80;
-        }
-        if (0xC0 <= $code) {
-            return (($code - 0xC0) << 6) + $s[2] - 0x80;
-        }
-
-        return $code;
-    }
-
-    private static function getSubpart($pos, $part, $haystack, $encoding)
-    {
-        if (false === $pos) {
-            return false;
-        }
-        if ($part) {
-            return self::mb_substr($haystack, 0, $pos, $encoding);
-        }
-
-        return self::mb_substr($haystack, $pos, null, $encoding);
-    }
-
-    private static function html_encoding_callback(array $m)
-    {
-        $i = 1;
-        $entities = '';
-        $m = unpack('C*', htmlentities($m[0], \ENT_COMPAT, 'UTF-8'));
-
-        while (isset($m[$i])) {
-            if (0x80 > $m[$i]) {
-                $entities .= \chr($m[$i++]);
-                continue;
-            }
-            if (0xF0 <= $m[$i]) {
-                $c = (($m[$i++] - 0xF0) << 18) + (($m[$i++] - 0x80) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
-            } elseif (0xE0 <= $m[$i]) {
-                $c = (($m[$i++] - 0xE0) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
-            } else {
-                $c = (($m[$i++] - 0xC0) << 6) + $m[$i++] - 0x80;
-            }
-
-            $entities .= '&#'.$c.';';
-        }
-
-        return $entities;
-    }
-
-    private static function title_case(array $s)
-    {
-        return self::mb_convert_case($s[1], \MB_CASE_UPPER, 'UTF-8').self::mb_convert_case($s[2], \MB_CASE_LOWER, 'UTF-8');
-    }
-
-    private static function getData($file)
-    {
-        if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
-            return require $file;
-        }
-
-        return false;
-    }
-
-    private static function getEncoding($encoding)
-    {
-        if (null === $encoding) {
-            return self::$internalEncoding;
-        }
-
-        if ('UTF-8' === $encoding) {
-            return 'UTF-8';
-        }
-
-        $encoding = strtoupper($encoding);
-
-        if ('8BIT' === $encoding || 'BINARY' === $encoding) {
-            return 'CP850';
-        }
-
-        if ('UTF8' === $encoding) {
-            return 'UTF-8';
-        }
-
-        return $encoding;
-    }
+	public const MB_CASE_FOLD = \PHP_INT_MAX;
+
+	private const CASE_FOLD = [
+		['µ', 'ſ', "\xCD\x85", 'ς', "\xCF\x90", "\xCF\x91", "\xCF\x95", "\xCF\x96", "\xCF\xB0", "\xCF\xB1", "\xCF\xB5", "\xE1\xBA\x9B", "\xE1\xBE\xBE"],
+		['μ', 's', 'ι',        'σ', 'β',        'θ',        'φ',        'π',        'κ',        'ρ',        'ε',        "\xE1\xB9\xA1", 'ι'],
+	];
+
+	private static $encodingList = ['ASCII', 'UTF-8'];
+	private static $language = 'neutral';
+	private static $internalEncoding = 'UTF-8';
+
+	public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
+	{
+		if (\is_array($fromEncoding) || ($fromEncoding !== null && false !== strpos($fromEncoding, ','))) {
+			$fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
+		} else {
+			$fromEncoding = self::getEncoding($fromEncoding);
+		}
+
+		$toEncoding = self::getEncoding($toEncoding);
+
+		if ('BASE64' === $fromEncoding) {
+			$s = base64_decode($s);
+			$fromEncoding = $toEncoding;
+		}
+
+		if ('BASE64' === $toEncoding) {
+			return base64_encode($s);
+		}
+
+		if ('HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding) {
+			if ('HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding) {
+				$fromEncoding = 'Windows-1252';
+			}
+			if ('UTF-8' !== $fromEncoding) {
+				$s = \iconv($fromEncoding, 'UTF-8//IGNORE', $s);
+			}
+
+			return preg_replace_callback('/[\x80-\xFF]+/', [__CLASS__, 'html_encoding_callback'], $s);
+		}
+
+		if ('HTML-ENTITIES' === $fromEncoding) {
+			$s = html_entity_decode($s, \ENT_COMPAT, 'UTF-8');
+			$fromEncoding = 'UTF-8';
+		}
+
+		return \iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
+	}
+
+	public static function mb_convert_variables($toEncoding, $fromEncoding, &...$vars)
+	{
+		$ok = true;
+		array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
+			if (false === $v = self::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
+				$ok = false;
+			}
+		});
+
+		return $ok ? $fromEncoding : false;
+	}
+
+	public static function mb_decode_mimeheader($s)
+	{
+		return \iconv_mime_decode($s, 2, self::$internalEncoding);
+	}
+
+	public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
+	{
+		trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', \E_USER_WARNING);
+	}
+
+	public static function mb_decode_numericentity($s, $convmap, $encoding = null)
+	{
+		if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
+			trigger_error('mb_decode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+
+			return null;
+		}
+
+		if (!\is_array($convmap) || (80000 > \PHP_VERSION_ID && !$convmap)) {
+			return false;
+		}
+
+		if (null !== $encoding && !is_scalar($encoding)) {
+			trigger_error('mb_decode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+
+			return '';  // Instead of null (cf. mb_encode_numericentity).
+		}
+
+		$s = (string) $s;
+		if ('' === $s) {
+			return '';
+		}
+
+		$encoding = self::getEncoding($encoding);
+
+		if ('UTF-8' === $encoding) {
+			$encoding = null;
+			if (!preg_match('//u', $s)) {
+				$s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
+			}
+		} else {
+			$s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+		}
+
+		$cnt = floor(\count($convmap) / 4) * 4;
+
+		for ($i = 0; $i < $cnt; $i += 4) {
+			// collector_decode_htmlnumericentity ignores $convmap[$i + 3]
+			$convmap[$i] += $convmap[$i + 2];
+			$convmap[$i + 1] += $convmap[$i + 2];
+		}
+
+		$s = preg_replace_callback('/&#(?:0*([0-9]+)|x0*([0-9a-fA-F]+))(?!&);?/', function (array $m) use ($cnt, $convmap) {
+			$c = isset($m[2]) ? (int) hexdec($m[2]) : $m[1];
+			for ($i = 0; $i < $cnt; $i += 4) {
+				if ($c >= $convmap[$i] && $c <= $convmap[$i + 1]) {
+					return self::mb_chr($c - $convmap[$i + 2]);
+				}
+			}
+
+			return $m[0];
+		}, $s);
+
+		if (null === $encoding) {
+			return $s;
+		}
+
+		return \iconv('UTF-8', $encoding.'//IGNORE', $s);
+	}
+
+	public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false)
+	{
+		if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
+			trigger_error('mb_encode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+
+			return null;
+		}
+
+		if (!\is_array($convmap) || (80000 > \PHP_VERSION_ID && !$convmap)) {
+			return false;
+		}
+
+		if (null !== $encoding && !is_scalar($encoding)) {
+			trigger_error('mb_encode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+
+			return null;  // Instead of '' (cf. mb_decode_numericentity).
+		}
+
+		if (null !== $is_hex && !is_scalar($is_hex)) {
+			trigger_error('mb_encode_numericentity() expects parameter 4 to be boolean, '.\gettype($s).' given', \E_USER_WARNING);
+
+			return null;
+		}
+
+		$s = (string) $s;
+		if ('' === $s) {
+			return '';
+		}
+
+		$encoding = self::getEncoding($encoding);
+
+		if ('UTF-8' === $encoding) {
+			$encoding = null;
+			if (!preg_match('//u', $s)) {
+				$s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
+			}
+		} else {
+			$s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+		}
+
+		static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
+
+		$cnt = floor(\count($convmap) / 4) * 4;
+		$i = 0;
+		$len = \strlen($s);
+		$result = '';
+
+		while ($i < $len) {
+			$ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
+			$uchr = substr($s, $i, $ulen);
+			$i += $ulen;
+			$c = self::mb_ord($uchr);
+
+			for ($j = 0; $j < $cnt; $j += 4) {
+				if ($c >= $convmap[$j] && $c <= $convmap[$j + 1]) {
+					$cOffset = ($c + $convmap[$j + 2]) & $convmap[$j + 3];
+					$result .= $is_hex ? sprintf('&#x%X;', $cOffset) : '&#'.$cOffset.';';
+					continue 2;
+				}
+			}
+			$result .= $uchr;
+		}
+
+		if (null === $encoding) {
+			return $result;
+		}
+
+		return \iconv('UTF-8', $encoding.'//IGNORE', $result);
+	}
+
+	public static function mb_convert_case($s, $mode, $encoding = null)
+	{
+		$s = (string) $s;
+		if ('' === $s) {
+			return '';
+		}
+
+		$encoding = self::getEncoding($encoding);
+
+		if ('UTF-8' === $encoding) {
+			$encoding = null;
+			if (!preg_match('//u', $s)) {
+				$s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
+			}
+		} else {
+			$s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+		}
+
+		if (\MB_CASE_TITLE == $mode) {
+			static $titleRegexp = null;
+			if (null === $titleRegexp) {
+				$titleRegexp = self::getData('titleCaseRegexp');
+			}
+			$s = preg_replace_callback($titleRegexp, [__CLASS__, 'title_case'], $s);
+		} else {
+			if (\MB_CASE_UPPER == $mode) {
+				static $upper = null;
+				if (null === $upper) {
+					$upper = self::getData('upperCase');
+				}
+				$map = $upper;
+			} else {
+				if (self::MB_CASE_FOLD === $mode) {
+					$s = str_replace(self::CASE_FOLD[0], self::CASE_FOLD[1], $s);
+				}
+
+				static $lower = null;
+				if (null === $lower) {
+					$lower = self::getData('lowerCase');
+				}
+				$map = $lower;
+			}
+
+			static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
+
+			$i = 0;
+			$len = \strlen($s);
+
+			while ($i < $len) {
+				$ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
+				$uchr = substr($s, $i, $ulen);
+				$i += $ulen;
+
+				if (isset($map[$uchr])) {
+					$uchr = $map[$uchr];
+					$nlen = \strlen($uchr);
+
+					if ($nlen == $ulen) {
+						$nlen = $i;
+						do {
+							$s[--$nlen] = $uchr[--$ulen];
+						} while ($ulen);
+					} else {
+						$s = substr_replace($s, $uchr, $i - $ulen, $ulen);
+						$len += $nlen - $ulen;
+						$i += $nlen - $ulen;
+					}
+				}
+			}
+		}
+
+		if (null === $encoding) {
+			return $s;
+		}
+
+		return \iconv('UTF-8', $encoding.'//IGNORE', $s);
+	}
+
+	public static function mb_internal_encoding($encoding = null)
+	{
+		if (null === $encoding) {
+			return self::$internalEncoding;
+		}
+
+		$normalizedEncoding = self::getEncoding($encoding);
+
+		if ('UTF-8' === $normalizedEncoding || false !== @\iconv($normalizedEncoding, $normalizedEncoding, ' ')) {
+			self::$internalEncoding = $normalizedEncoding;
+
+			return true;
+		}
+
+		if (80000 > \PHP_VERSION_ID) {
+			return false;
+		}
+
+		throw new \ValueError(sprintf('Argument #1 ($encoding) must be a valid encoding, "%s" given', $encoding));
+	}
+
+	public static function mb_language($lang = null)
+	{
+		if (null === $lang) {
+			return self::$language;
+		}
+
+		switch ($normalizedLang = strtolower($lang)) {
+			case 'uni':
+			case 'neutral':
+				self::$language = $normalizedLang;
+
+				return true;
+		}
+
+		if (80000 > \PHP_VERSION_ID) {
+			return false;
+		}
+
+		throw new \ValueError(sprintf('Argument #1 ($language) must be a valid language, "%s" given', $lang));
+	}
+
+	public static function mb_list_encodings()
+	{
+		return ['UTF-8'];
+	}
+
+	public static function mb_encoding_aliases($encoding)
+	{
+		switch (strtoupper($encoding)) {
+			case 'UTF8':
+			case 'UTF-8':
+				return ['utf8'];
+		}
+
+		return false;
+	}
+
+	public static function mb_check_encoding($var = null, $encoding = null)
+	{
+		if (null === $encoding) {
+			if (null === $var) {
+				return false;
+			}
+			$encoding = self::$internalEncoding;
+		}
+
+		return self::mb_detect_encoding($var, [$encoding]) || false !== @\iconv($encoding, $encoding, $var);
+	}
+
+	public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
+	{
+		if (null === $encodingList) {
+			$encodingList = self::$encodingList;
+		} else {
+			if (!\is_array($encodingList)) {
+				$encodingList = array_map('trim', explode(',', $encodingList));
+			}
+			$encodingList = array_map('strtoupper', $encodingList);
+		}
+
+		foreach ($encodingList as $enc) {
+			switch ($enc) {
+				case 'ASCII':
+					if (!preg_match('/[\x80-\xFF]/', $str)) {
+						return $enc;
+					}
+					break;
+
+				case 'UTF8':
+				case 'UTF-8':
+					if (preg_match('//u', $str)) {
+						return 'UTF-8';
+					}
+					break;
+
+				default:
+					if (0 === strncmp($enc, 'ISO-8859-', 9)) {
+						return $enc;
+					}
+			}
+		}
+
+		return false;
+	}
+
+	public static function mb_detect_order($encodingList = null)
+	{
+		if (null === $encodingList) {
+			return self::$encodingList;
+		}
+
+		if (!\is_array($encodingList)) {
+			$encodingList = array_map('trim', explode(',', $encodingList));
+		}
+		$encodingList = array_map('strtoupper', $encodingList);
+
+		foreach ($encodingList as $enc) {
+			switch ($enc) {
+				default:
+					if (strncmp($enc, 'ISO-8859-', 9)) {
+						return false;
+					}
+					// no break
+				case 'ASCII':
+				case 'UTF8':
+				case 'UTF-8':
+			}
+		}
+
+		self::$encodingList = $encodingList;
+
+		return true;
+	}
+
+	public static function mb_strlen($s, $encoding = null)
+	{
+		$encoding = self::getEncoding($encoding);
+		if ('CP850' === $encoding || 'ASCII' === $encoding) {
+			return \strlen($s);
+		}
+
+		return @\iconv_strlen($s, $encoding);
+	}
+
+	public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
+	{
+		$encoding = self::getEncoding($encoding);
+		if ('CP850' === $encoding || 'ASCII' === $encoding) {
+			return strpos($haystack, $needle, $offset);
+		}
+
+		$needle = (string) $needle;
+		if ('' === $needle) {
+			if (80000 > \PHP_VERSION_ID) {
+				trigger_error(__METHOD__.': Empty delimiter', \E_USER_WARNING);
+
+				return false;
+			}
+
+			return 0;
+		}
+
+		return \iconv_strpos($haystack, $needle, $offset, $encoding);
+	}
+
+	public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
+	{
+		$encoding = self::getEncoding($encoding);
+		if ('CP850' === $encoding || 'ASCII' === $encoding) {
+			return strrpos($haystack, $needle, $offset);
+		}
+
+		if ($offset != (int) $offset) {
+			$offset = 0;
+		} elseif ($offset = (int) $offset) {
+			if ($offset < 0) {
+				if (0 > $offset += self::mb_strlen($needle)) {
+					$haystack = self::mb_substr($haystack, 0, $offset, $encoding);
+				}
+				$offset = 0;
+			} else {
+				$haystack = self::mb_substr($haystack, $offset, 2147483647, $encoding);
+			}
+		}
+
+		$pos = '' !== $needle || 80000 > \PHP_VERSION_ID
+			? \iconv_strrpos($haystack, $needle, $encoding)
+			: self::mb_strlen($haystack, $encoding);
+
+		return false !== $pos ? $offset + $pos : false;
+	}
+
+	public static function mb_str_split($string, $split_length = 1, $encoding = null)
+	{
+		if (null !== $string && !is_scalar($string) && !(\is_object($string) && method_exists($string, '__toString'))) {
+			trigger_error('mb_str_split() expects parameter 1 to be string, '.\gettype($string).' given', \E_USER_WARNING);
+
+			return null;
+		}
+
+		if (1 > $split_length = (int) $split_length) {
+			if (80000 > \PHP_VERSION_ID) {
+				trigger_error('The length of each segment must be greater than zero', \E_USER_WARNING);
+				return false;
+			}
+
+			throw new \ValueError('Argument #2 ($length) must be greater than 0');
+		}
+
+		if (null === $encoding) {
+			$encoding = mb_internal_encoding();
+		}
+
+		if ('UTF-8' === $encoding = self::getEncoding($encoding)) {
+			$rx = '/(';
+			while (65535 < $split_length) {
+				$rx .= '.{65535}';
+				$split_length -= 65535;
+			}
+			$rx .= '.{'.$split_length.'})/us';
+
+			return preg_split($rx, $string, -1, \PREG_SPLIT_DELIM_CAPTURE | \PREG_SPLIT_NO_EMPTY);
+		}
+
+		$result = [];
+		$length = mb_strlen($string, $encoding);
+
+		for ($i = 0; $i < $length; $i += $split_length) {
+			$result[] = mb_substr($string, $i, $split_length, $encoding);
+		}
+
+		return $result;
+	}
+
+	public static function mb_strtolower($s, $encoding = null)
+	{
+		return self::mb_convert_case($s, \MB_CASE_LOWER, $encoding);
+	}
+
+	public static function mb_strtoupper($s, $encoding = null)
+	{
+		return self::mb_convert_case($s, \MB_CASE_UPPER, $encoding);
+	}
+
+	public static function mb_substitute_character($c = null)
+	{
+		if (null === $c) {
+			return 'none';
+		}
+		if (0 === strcasecmp($c, 'none')) {
+			return true;
+		}
+		if (80000 > \PHP_VERSION_ID) {
+			return false;
+		}
+		if (\is_int($c) || 'long' === $c || 'entity' === $c) {
+			return false;
+		}
+
+		throw new \ValueError('Argument #1 ($substitute_character) must be "none", "long", "entity" or a valid codepoint');
+	}
+
+	public static function mb_substr($s, $start, $length = null, $encoding = null)
+	{
+		$encoding = self::getEncoding($encoding);
+		if ('CP850' === $encoding || 'ASCII' === $encoding) {
+			return (string) substr($s, $start, null === $length ? 2147483647 : $length);
+		}
+
+		if ($start < 0) {
+			$start = \iconv_strlen($s, $encoding) + $start;
+			if ($start < 0) {
+				$start = 0;
+			}
+		}
+
+		if (null === $length) {
+			$length = 2147483647;
+		} elseif ($length < 0) {
+			$length = \iconv_strlen($s, $encoding) + $length - $start;
+			if ($length < 0) {
+				return '';
+			}
+		}
+
+		return (string) \iconv_substr($s, $start, $length, $encoding);
+	}
+
+	public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
+	{
+		$haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
+		$needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+
+		return self::mb_strpos($haystack, $needle, $offset, $encoding);
+	}
+
+	public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
+	{
+		$pos = self::mb_stripos($haystack, $needle, 0, $encoding);
+
+		return self::getSubpart($pos, $part, $haystack, $encoding);
+	}
+
+	public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
+	{
+		$encoding = self::getEncoding($encoding);
+		if ('CP850' === $encoding || 'ASCII' === $encoding) {
+			$pos = strrpos($haystack, $needle);
+		} else {
+			$needle = self::mb_substr($needle, 0, 1, $encoding);
+			$pos = \iconv_strrpos($haystack, $needle, $encoding);
+		}
+
+		return self::getSubpart($pos, $part, $haystack, $encoding);
+	}
+
+	public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
+	{
+		$needle = self::mb_substr($needle, 0, 1, $encoding);
+		$pos = self::mb_strripos($haystack, $needle, $encoding);
+
+		return self::getSubpart($pos, $part, $haystack, $encoding);
+	}
+
+	public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
+	{
+		$haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
+		$needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+
+		return self::mb_strrpos($haystack, $needle, $offset, $encoding);
+	}
+
+	public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
+	{
+		$pos = strpos($haystack, $needle);
+		if (false === $pos) {
+			return false;
+		}
+		if ($part) {
+			return substr($haystack, 0, $pos);
+		}
+
+		return substr($haystack, $pos);
+	}
+
+	public static function mb_get_info($type = 'all')
+	{
+		$info = [
+			'internal_encoding' => self::$internalEncoding,
+			'http_output' => 'pass',
+			'http_output_conv_mimetypes' => '^(text/|application/xhtml\+xml)',
+			'func_overload' => 0,
+			'func_overload_list' => 'no overload',
+			'mail_charset' => 'UTF-8',
+			'mail_header_encoding' => 'BASE64',
+			'mail_body_encoding' => 'BASE64',
+			'illegal_chars' => 0,
+			'encoding_translation' => 'Off',
+			'language' => self::$language,
+			'detect_order' => self::$encodingList,
+			'substitute_character' => 'none',
+			'strict_detection' => 'Off',
+		];
+
+		if ('all' === $type) {
+			return $info;
+		}
+		if (isset($info[$type])) {
+			return $info[$type];
+		}
+
+		return false;
+	}
+
+	public static function mb_http_input($type = '')
+	{
+		return false;
+	}
+
+	public static function mb_http_output($encoding = null)
+	{
+		return null !== $encoding ? 'pass' === $encoding : 'pass';
+	}
+
+	public static function mb_strwidth($s, $encoding = null)
+	{
+		$encoding = self::getEncoding($encoding);
+
+		if ('UTF-8' !== $encoding) {
+			$s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+		}
+
+		$s = preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide);
+
+		return ($wide << 1) + \iconv_strlen($s, 'UTF-8');
+	}
+
+	public static function mb_substr_count($haystack, $needle, $encoding = null)
+	{
+		return substr_count($haystack, $needle);
+	}
+
+	public static function mb_output_handler($contents, $status)
+	{
+		return $contents;
+	}
+
+	public static function mb_chr($code, $encoding = null)
+	{
+		if (0x80 > $code %= 0x200000) {
+			$s = \chr($code);
+		} elseif (0x800 > $code) {
+			$s = \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
+		} elseif (0x10000 > $code) {
+			$s = \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+		} else {
+			$s = \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+		}
+
+		if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
+			$s = mb_convert_encoding($s, $encoding, 'UTF-8');
+		}
+
+		return $s;
+	}
+
+	public static function mb_ord($s, $encoding = null)
+	{
+		if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
+			$s = mb_convert_encoding($s, 'UTF-8', $encoding);
+		}
+
+		if (1 === \strlen($s)) {
+			return \ord($s);
+		}
+
+		$code = ($s = unpack('C*', substr($s, 0, 4))) ? $s[1] : 0;
+		if (0xF0 <= $code) {
+			return (($code - 0xF0) << 18) + (($s[2] - 0x80) << 12) + (($s[3] - 0x80) << 6) + $s[4] - 0x80;
+		}
+		if (0xE0 <= $code) {
+			return (($code - 0xE0) << 12) + (($s[2] - 0x80) << 6) + $s[3] - 0x80;
+		}
+		if (0xC0 <= $code) {
+			return (($code - 0xC0) << 6) + $s[2] - 0x80;
+		}
+
+		return $code;
+	}
+
+	private static function getSubpart($pos, $part, $haystack, $encoding)
+	{
+		if (false === $pos) {
+			return false;
+		}
+		if ($part) {
+			return self::mb_substr($haystack, 0, $pos, $encoding);
+		}
+
+		return self::mb_substr($haystack, $pos, null, $encoding);
+	}
+
+	private static function html_encoding_callback(array $m)
+	{
+		$i = 1;
+		$entities = '';
+		$m = unpack('C*', htmlentities($m[0], \ENT_COMPAT, 'UTF-8'));
+
+		while (isset($m[$i])) {
+			if (0x80 > $m[$i]) {
+				$entities .= \chr($m[$i++]);
+				continue;
+			}
+			if (0xF0 <= $m[$i]) {
+				$c = (($m[$i++] - 0xF0) << 18) + (($m[$i++] - 0x80) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+			} elseif (0xE0 <= $m[$i]) {
+				$c = (($m[$i++] - 0xE0) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+			} else {
+				$c = (($m[$i++] - 0xC0) << 6) + $m[$i++] - 0x80;
+			}
+
+			$entities .= '&#'.$c.';';
+		}
+
+		return $entities;
+	}
+
+	private static function title_case(array $s)
+	{
+		return self::mb_convert_case($s[1], \MB_CASE_UPPER, 'UTF-8').self::mb_convert_case($s[2], \MB_CASE_LOWER, 'UTF-8');
+	}
+
+	private static function getData($file)
+	{
+		if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
+			return require $file;
+		}
+
+		return false;
+	}
+
+	private static function getEncoding($encoding)
+	{
+		if (null === $encoding) {
+			return self::$internalEncoding;
+		}
+
+		if ('UTF-8' === $encoding) {
+			return 'UTF-8';
+		}
+
+		$encoding = strtoupper($encoding);
+
+		if ('8BIT' === $encoding || 'BINARY' === $encoding) {
+			return 'CP850';
+		}
+
+		if ('UTF8' === $encoding) {
+			return 'UTF-8';
+		}
+
+		return $encoding;
+	}
 }

Spacing +308 added lines, -308 removed lines

@@ -73,57 +73,57 @@ 
     public const MB_CASE_FOLD = \PHP_INT_MAX;
 
     private const CASE_FOLD = [
-        ['µ', 'ſ', "\xCD\x85", 'ς', "\xCF\x90", "\xCF\x91", "\xCF\x95", "\xCF\x96", "\xCF\xB0", "\xCF\xB1", "\xCF\xB5", "\xE1\xBA\x9B", "\xE1\xBE\xBE"],
-        ['μ', 's', 'ι',        'σ', 'β',        'θ',        'φ',        'π',        'κ',        'ρ',        'ε',        "\xE1\xB9\xA1", 'ι'],
+        [ 'µ', 'ſ', "\xCD\x85", 'ς', "\xCF\x90", "\xCF\x91", "\xCF\x95", "\xCF\x96", "\xCF\xB0", "\xCF\xB1", "\xCF\xB5", "\xE1\xBA\x9B", "\xE1\xBE\xBE" ],
+        [ 'μ', 's', 'ι', 'σ', 'β', 'θ', 'φ', 'π', 'κ', 'ρ', 'ε', "\xE1\xB9\xA1", 'ι' ],
     ];
 
-    private static $encodingList = ['ASCII', 'UTF-8'];
+    private static $encodingList = [ 'ASCII', 'UTF-8' ];
     private static $language = 'neutral';
     private static $internalEncoding = 'UTF-8';
 
-    public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
+    public static function mb_convert_encoding( $s, $toEncoding, $fromEncoding = null )
     {
-        if (\is_array($fromEncoding) || ($fromEncoding !== null && false !== strpos($fromEncoding, ','))) {
-            $fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
+        if ( \is_array( $fromEncoding ) || ( $fromEncoding !== null && false !== strpos( $fromEncoding, ',' ) ) ) {
+            $fromEncoding = self::mb_detect_encoding( $s, $fromEncoding );
         } else {
-            $fromEncoding = self::getEncoding($fromEncoding);
+            $fromEncoding = self::getEncoding( $fromEncoding );
         }
 
-        $toEncoding = self::getEncoding($toEncoding);
+        $toEncoding = self::getEncoding( $toEncoding );
 
-        if ('BASE64' === $fromEncoding) {
-            $s = base64_decode($s);
+        if ( 'BASE64' === $fromEncoding ) {
+            $s = base64_decode( $s );
             $fromEncoding = $toEncoding;
         }
 
-        if ('BASE64' === $toEncoding) {
-            return base64_encode($s);
+        if ( 'BASE64' === $toEncoding ) {
+            return base64_encode( $s );
         }
 
-        if ('HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding) {
-            if ('HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding) {
+        if ( 'HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding ) {
+            if ( 'HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding ) {
                 $fromEncoding = 'Windows-1252';
             }
-            if ('UTF-8' !== $fromEncoding) {
-                $s = \iconv($fromEncoding, 'UTF-8//IGNORE', $s);
+            if ( 'UTF-8' !== $fromEncoding ) {
+                $s = \iconv( $fromEncoding, 'UTF-8//IGNORE', $s );
             }
 
-            return preg_replace_callback('/[\x80-\xFF]+/', [__CLASS__, 'html_encoding_callback'], $s);
+            return preg_replace_callback( '/[\x80-\xFF]+/', [ __CLASS__, 'html_encoding_callback' ], $s );
         }
 
-        if ('HTML-ENTITIES' === $fromEncoding) {
-            $s = html_entity_decode($s, \ENT_COMPAT, 'UTF-8');
+        if ( 'HTML-ENTITIES' === $fromEncoding ) {
+            $s = html_entity_decode( $s, \ENT_COMPAT, 'UTF-8' );
             $fromEncoding = 'UTF-8';
         }
 
-        return \iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
+        return \iconv( $fromEncoding, $toEncoding . '//IGNORE', $s );
     }
 
-    public static function mb_convert_variables($toEncoding, $fromEncoding, &...$vars)
+    public static function mb_convert_variables( $toEncoding, $fromEncoding, &...$vars )
     {
         $ok = true;
-        array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
-            if (false === $v = self::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
+        array_walk_recursive( $vars, function( &$v ) use ( &$ok, $toEncoding, $fromEncoding ) {
+            if ( false === $v = self::mb_convert_encoding( $v, $toEncoding, $fromEncoding ) ) {
                 $ok = false;
             }
         });
@@ -131,210 +131,210 @@ 
         return $ok ? $fromEncoding : false;
     }
 
-    public static function mb_decode_mimeheader($s)
+    public static function mb_decode_mimeheader( $s )
     {
-        return \iconv_mime_decode($s, 2, self::$internalEncoding);
+        return \iconv_mime_decode( $s, 2, self::$internalEncoding );
     }
 
-    public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
+    public static function mb_encode_mimeheader( $s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null )
     {
-        trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', \E_USER_WARNING);
+        trigger_error( 'mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', \E_USER_WARNING );
     }
 
-    public static function mb_decode_numericentity($s, $convmap, $encoding = null)
+    public static function mb_decode_numericentity( $s, $convmap, $encoding = null )
     {
-        if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
-            trigger_error('mb_decode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+        if ( null !== $s && ! is_scalar( $s ) && ! ( \is_object( $s ) && method_exists( $s, '__toString' ) ) ) {
+            trigger_error( 'mb_decode_numericentity() expects parameter 1 to be string, ' . \gettype( $s ) . ' given', \E_USER_WARNING );
 
             return null;
         }
 
-        if (!\is_array($convmap) || (80000 > \PHP_VERSION_ID && !$convmap)) {
+        if ( ! \is_array( $convmap ) || ( 80000 > \PHP_VERSION_ID && ! $convmap ) ) {
             return false;
         }
 
-        if (null !== $encoding && !is_scalar($encoding)) {
-            trigger_error('mb_decode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+        if ( null !== $encoding && ! is_scalar( $encoding ) ) {
+            trigger_error( 'mb_decode_numericentity() expects parameter 3 to be string, ' . \gettype( $s ) . ' given', \E_USER_WARNING );
 
-            return '';  // Instead of null (cf. mb_encode_numericentity).
+            return ''; // Instead of null (cf. mb_encode_numericentity).
         }
 
-        $s = (string) $s;
-        if ('' === $s) {
+        $s = (string)$s;
+        if ( '' === $s ) {
             return '';
         }
 
-        $encoding = self::getEncoding($encoding);
+        $encoding = self::getEncoding( $encoding );
 
-        if ('UTF-8' === $encoding) {
+        if ( 'UTF-8' === $encoding ) {
             $encoding = null;
-            if (!preg_match('//u', $s)) {
-                $s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            if ( ! preg_match( '//u', $s ) ) {
+                $s = @\iconv( 'UTF-8', 'UTF-8//IGNORE', $s );
             }
         } else {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+            $s = \iconv( $encoding, 'UTF-8//IGNORE', $s );
         }
 
-        $cnt = floor(\count($convmap) / 4) * 4;
+        $cnt = floor( \count( $convmap ) / 4 ) * 4;
 
-        for ($i = 0; $i < $cnt; $i += 4) {
+        for ( $i = 0; $i < $cnt; $i += 4 ) {
             // collector_decode_htmlnumericentity ignores $convmap[$i + 3]
-            $convmap[$i] += $convmap[$i + 2];
-            $convmap[$i + 1] += $convmap[$i + 2];
+            $convmap[ $i ] += $convmap[ $i + 2 ];
+            $convmap[ $i + 1 ] += $convmap[ $i + 2 ];
         }
 
-        $s = preg_replace_callback('/&#(?:0*([0-9]+)|x0*([0-9a-fA-F]+))(?!&);?/', function (array $m) use ($cnt, $convmap) {
-            $c = isset($m[2]) ? (int) hexdec($m[2]) : $m[1];
-            for ($i = 0; $i < $cnt; $i += 4) {
-                if ($c >= $convmap[$i] && $c <= $convmap[$i + 1]) {
-                    return self::mb_chr($c - $convmap[$i + 2]);
+        $s = preg_replace_callback( '/&#(?:0*([0-9]+)|x0*([0-9a-fA-F]+))(?!&);?/', function( array $m ) use ( $cnt, $convmap ) {
+            $c = isset( $m[ 2 ] ) ? (int)hexdec( $m[ 2 ] ) : $m[ 1 ];
+            for ( $i = 0; $i < $cnt; $i += 4 ) {
+                if ( $c >= $convmap[ $i ] && $c <= $convmap[ $i + 1 ] ) {
+                    return self::mb_chr( $c - $convmap[ $i + 2 ] );
                 }
             }
 
-            return $m[0];
-        }, $s);
+            return $m[ 0 ];
+        }, $s );
 
-        if (null === $encoding) {
+        if ( null === $encoding ) {
             return $s;
         }
 
-        return \iconv('UTF-8', $encoding.'//IGNORE', $s);
+        return \iconv( 'UTF-8', $encoding . '//IGNORE', $s );
     }
 
-    public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false)
+    public static function mb_encode_numericentity( $s, $convmap, $encoding = null, $is_hex = false )
     {
-        if (null !== $s && !is_scalar($s) && !(\is_object($s) && method_exists($s, '__toString'))) {
-            trigger_error('mb_encode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+        if ( null !== $s && ! is_scalar( $s ) && ! ( \is_object( $s ) && method_exists( $s, '__toString' ) ) ) {
+            trigger_error( 'mb_encode_numericentity() expects parameter 1 to be string, ' . \gettype( $s ) . ' given', \E_USER_WARNING );
 
             return null;
         }
 
-        if (!\is_array($convmap) || (80000 > \PHP_VERSION_ID && !$convmap)) {
+        if ( ! \is_array( $convmap ) || ( 80000 > \PHP_VERSION_ID && ! $convmap ) ) {
             return false;
         }
 
-        if (null !== $encoding && !is_scalar($encoding)) {
-            trigger_error('mb_encode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', \E_USER_WARNING);
+        if ( null !== $encoding && ! is_scalar( $encoding ) ) {
+            trigger_error( 'mb_encode_numericentity() expects parameter 3 to be string, ' . \gettype( $s ) . ' given', \E_USER_WARNING );
 
-            return null;  // Instead of '' (cf. mb_decode_numericentity).
+            return null; // Instead of '' (cf. mb_decode_numericentity).
         }
 
-        if (null !== $is_hex && !is_scalar($is_hex)) {
-            trigger_error('mb_encode_numericentity() expects parameter 4 to be boolean, '.\gettype($s).' given', \E_USER_WARNING);
+        if ( null !== $is_hex && ! is_scalar( $is_hex ) ) {
+            trigger_error( 'mb_encode_numericentity() expects parameter 4 to be boolean, ' . \gettype( $s ) . ' given', \E_USER_WARNING );
 
             return null;
         }
 
-        $s = (string) $s;
-        if ('' === $s) {
+        $s = (string)$s;
+        if ( '' === $s ) {
             return '';
         }
 
-        $encoding = self::getEncoding($encoding);
+        $encoding = self::getEncoding( $encoding );
 
-        if ('UTF-8' === $encoding) {
+        if ( 'UTF-8' === $encoding ) {
             $encoding = null;
-            if (!preg_match('//u', $s)) {
-                $s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            if ( ! preg_match( '//u', $s ) ) {
+                $s = @\iconv( 'UTF-8', 'UTF-8//IGNORE', $s );
             }
         } else {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+            $s = \iconv( $encoding, 'UTF-8//IGNORE', $s );
         }
 
-        static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
+        static $ulenMask = [ "\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4 ];
 
-        $cnt = floor(\count($convmap) / 4) * 4;
+        $cnt = floor( \count( $convmap ) / 4 ) * 4;
         $i = 0;
-        $len = \strlen($s);
+        $len = \strlen( $s );
         $result = '';
 
-        while ($i < $len) {
-            $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
-            $uchr = substr($s, $i, $ulen);
+        while ( $i < $len ) {
+            $ulen = $s[ $i ] < "\x80" ? 1 : $ulenMask[ $s[ $i ] & "\xF0" ];
+            $uchr = substr( $s, $i, $ulen );
             $i += $ulen;
-            $c = self::mb_ord($uchr);
+            $c = self::mb_ord( $uchr );
 
-            for ($j = 0; $j < $cnt; $j += 4) {
-                if ($c >= $convmap[$j] && $c <= $convmap[$j + 1]) {
-                    $cOffset = ($c + $convmap[$j + 2]) & $convmap[$j + 3];
-                    $result .= $is_hex ? sprintf('&#x%X;', $cOffset) : '&#'.$cOffset.';';
+            for ( $j = 0; $j < $cnt; $j += 4 ) {
+                if ( $c >= $convmap[ $j ] && $c <= $convmap[ $j + 1 ] ) {
+                    $cOffset = ( $c + $convmap[ $j + 2 ] ) & $convmap[ $j + 3 ];
+                    $result .= $is_hex ? sprintf( '&#x%X;', $cOffset ) : '&#' . $cOffset . ';';
                     continue 2;
                 }
             }
             $result .= $uchr;
         }
 
-        if (null === $encoding) {
+        if ( null === $encoding ) {
             return $result;
         }
 
-        return \iconv('UTF-8', $encoding.'//IGNORE', $result);
+        return \iconv( 'UTF-8', $encoding . '//IGNORE', $result );
     }
 
-    public static function mb_convert_case($s, $mode, $encoding = null)
+    public static function mb_convert_case( $s, $mode, $encoding = null )
     {
-        $s = (string) $s;
-        if ('' === $s) {
+        $s = (string)$s;
+        if ( '' === $s ) {
             return '';
         }
 
-        $encoding = self::getEncoding($encoding);
+        $encoding = self::getEncoding( $encoding );
 
-        if ('UTF-8' === $encoding) {
+        if ( 'UTF-8' === $encoding ) {
             $encoding = null;
-            if (!preg_match('//u', $s)) {
-                $s = @\iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            if ( ! preg_match( '//u', $s ) ) {
+                $s = @\iconv( 'UTF-8', 'UTF-8//IGNORE', $s );
             }
         } else {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+            $s = \iconv( $encoding, 'UTF-8//IGNORE', $s );
         }
 
-        if (\MB_CASE_TITLE == $mode) {
+        if ( \MB_CASE_TITLE == $mode ) {
             static $titleRegexp = null;
-            if (null === $titleRegexp) {
-                $titleRegexp = self::getData('titleCaseRegexp');
+            if ( null === $titleRegexp ) {
+                $titleRegexp = self::getData( 'titleCaseRegexp' );
             }
-            $s = preg_replace_callback($titleRegexp, [__CLASS__, 'title_case'], $s);
+            $s = preg_replace_callback( $titleRegexp, [ __CLASS__, 'title_case' ], $s );
         } else {
-            if (\MB_CASE_UPPER == $mode) {
+            if ( \MB_CASE_UPPER == $mode ) {
                 static $upper = null;
-                if (null === $upper) {
-                    $upper = self::getData('upperCase');
+                if ( null === $upper ) {
+                    $upper = self::getData( 'upperCase' );
                 }
                 $map = $upper;
             } else {
-                if (self::MB_CASE_FOLD === $mode) {
-                    $s = str_replace(self::CASE_FOLD[0], self::CASE_FOLD[1], $s);
+                if ( self::MB_CASE_FOLD === $mode ) {
+                    $s = str_replace( self::CASE_FOLD[ 0 ], self::CASE_FOLD[ 1 ], $s );
                 }
 
                 static $lower = null;
-                if (null === $lower) {
-                    $lower = self::getData('lowerCase');
+                if ( null === $lower ) {
+                    $lower = self::getData( 'lowerCase' );
                 }
                 $map = $lower;
             }
 
-            static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
+            static $ulenMask = [ "\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4 ];
 
             $i = 0;
-            $len = \strlen($s);
+            $len = \strlen( $s );
 
-            while ($i < $len) {
-                $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
-                $uchr = substr($s, $i, $ulen);
+            while ( $i < $len ) {
+                $ulen = $s[ $i ] < "\x80" ? 1 : $ulenMask[ $s[ $i ] & "\xF0" ];
+                $uchr = substr( $s, $i, $ulen );
                 $i += $ulen;
 
-                if (isset($map[$uchr])) {
-                    $uchr = $map[$uchr];
-                    $nlen = \strlen($uchr);
+                if ( isset( $map[ $uchr ] ) ) {
+                    $uchr = $map[ $uchr ];
+                    $nlen = \strlen( $uchr );
 
-                    if ($nlen == $ulen) {
+                    if ( $nlen == $ulen ) {
                         $nlen = $i;
                         do {
-                            $s[--$nlen] = $uchr[--$ulen];
-                        } while ($ulen);
+                            $s[--$nlen ] = $uchr[--$ulen ];
+                        } while ( $ulen );
                     } else {
-                        $s = substr_replace($s, $uchr, $i - $ulen, $ulen);
+                        $s = substr_replace( $s, $uchr, $i - $ulen, $ulen );
                         $len += $nlen - $ulen;
                         $i += $nlen - $ulen;
                     }
@@ -342,41 +342,41 @@ 
             }
         }
 
-        if (null === $encoding) {
+        if ( null === $encoding ) {
             return $s;
         }
 
-        return \iconv('UTF-8', $encoding.'//IGNORE', $s);
+        return \iconv( 'UTF-8', $encoding . '//IGNORE', $s );
     }
 
-    public static function mb_internal_encoding($encoding = null)
+    public static function mb_internal_encoding( $encoding = null )
     {
-        if (null === $encoding) {
+        if ( null === $encoding ) {
             return self::$internalEncoding;
         }
 
-        $normalizedEncoding = self::getEncoding($encoding);
+        $normalizedEncoding = self::getEncoding( $encoding );
 
-        if ('UTF-8' === $normalizedEncoding || false !== @\iconv($normalizedEncoding, $normalizedEncoding, ' ')) {
+        if ( 'UTF-8' === $normalizedEncoding || false !== @\iconv( $normalizedEncoding, $normalizedEncoding, ' ' ) ) {
             self::$internalEncoding = $normalizedEncoding;
 
             return true;
         }
 
-        if (80000 > \PHP_VERSION_ID) {
+        if ( 80000 > \PHP_VERSION_ID ) {
             return false;
         }
 
-        throw new \ValueError(sprintf('Argument #1 ($encoding) must be a valid encoding, "%s" given', $encoding));
+        throw new \ValueError( sprintf( 'Argument #1 ($encoding) must be a valid encoding, "%s" given', $encoding ) );
     }
 
-    public static function mb_language($lang = null)
+    public static function mb_language( $lang = null )
     {
-        if (null === $lang) {
+        if ( null === $lang ) {
             return self::$language;
         }
 
-        switch ($normalizedLang = strtolower($lang)) {
+        switch ( $normalizedLang = strtolower( $lang ) ) {
             case 'uni':
             case 'neutral':
                 self::$language = $normalizedLang;
@@ -384,69 +384,69 @@ 
                 return true;
         }
 
-        if (80000 > \PHP_VERSION_ID) {
+        if ( 80000 > \PHP_VERSION_ID ) {
             return false;
         }
 
-        throw new \ValueError(sprintf('Argument #1 ($language) must be a valid language, "%s" given', $lang));
+        throw new \ValueError( sprintf( 'Argument #1 ($language) must be a valid language, "%s" given', $lang ) );
     }
 
     public static function mb_list_encodings()
     {
-        return ['UTF-8'];
+        return [ 'UTF-8' ];
     }
 
-    public static function mb_encoding_aliases($encoding)
+    public static function mb_encoding_aliases( $encoding )
     {
-        switch (strtoupper($encoding)) {
+        switch ( strtoupper( $encoding ) ) {
             case 'UTF8':
             case 'UTF-8':
-                return ['utf8'];
+                return [ 'utf8' ];
         }
 
         return false;
     }
 
-    public static function mb_check_encoding($var = null, $encoding = null)
+    public static function mb_check_encoding( $var = null, $encoding = null )
     {
-        if (null === $encoding) {
-            if (null === $var) {
+        if ( null === $encoding ) {
+            if ( null === $var ) {
                 return false;
             }
             $encoding = self::$internalEncoding;
         }
 
-        return self::mb_detect_encoding($var, [$encoding]) || false !== @\iconv($encoding, $encoding, $var);
+        return self::mb_detect_encoding( $var, [ $encoding ] ) || false !== @\iconv( $encoding, $encoding, $var );
     }
 
-    public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
+    public static function mb_detect_encoding( $str, $encodingList = null, $strict = false )
     {
-        if (null === $encodingList) {
+        if ( null === $encodingList ) {
             $encodingList = self::$encodingList;
         } else {
-            if (!\is_array($encodingList)) {
-                $encodingList = array_map('trim', explode(',', $encodingList));
+            if ( ! \is_array( $encodingList ) ) {
+                $encodingList = array_map( 'trim', explode( ',', $encodingList ) );
             }
-            $encodingList = array_map('strtoupper', $encodingList);
+            $encodingList = array_map( 'strtoupper', $encodingList );
         }
 
-        foreach ($encodingList as $enc) {
-            switch ($enc) {
+        foreach ( $encodingList as $enc ) {
+            switch ( $enc ) {
                 case 'ASCII':
-                    if (!preg_match('/[\x80-\xFF]/', $str)) {
+                    if ( ! preg_match( '/[\x80-\xFF]/', $str ) ) {
                         return $enc;
                     }
                     break;
 
                 case 'UTF8':
                 case 'UTF-8':
-                    if (preg_match('//u', $str)) {
+                    if ( preg_match( '//u', $str ) ) {
                         return 'UTF-8';
                     }
                     break;
 
                 default:
-                    if (0 === strncmp($enc, 'ISO-8859-', 9)) {
+                    if ( 0 === strncmp( $enc, 'ISO-8859-', 9 ) ) {
                         return $enc;
                     }
             }
@@ -455,21 +455,21 @@ 
         return false;
     }
 
-    public static function mb_detect_order($encodingList = null)
+    public static function mb_detect_order( $encodingList = null )
     {
-        if (null === $encodingList) {
+        if ( null === $encodingList ) {
             return self::$encodingList;
         }
 
-        if (!\is_array($encodingList)) {
-            $encodingList = array_map('trim', explode(',', $encodingList));
+        if ( ! \is_array( $encodingList ) ) {
+            $encodingList = array_map( 'trim', explode( ',', $encodingList ) );
         }
-        $encodingList = array_map('strtoupper', $encodingList);
+        $encodingList = array_map( 'strtoupper', $encodingList );
 
-        foreach ($encodingList as $enc) {
-            switch ($enc) {
+        foreach ( $encodingList as $enc ) {
+            switch ( $enc ) {
                 default:
-                    if (strncmp($enc, 'ISO-8859-', 9)) {
+                    if ( strncmp( $enc, 'ISO-8859-', 9 ) ) {
                         return false;
                     }
                     // no break
@@ -484,27 +484,27 @@ 
         return true;
     }
 
-    public static function mb_strlen($s, $encoding = null)
+    public static function mb_strlen( $s, $encoding = null )
     {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return \strlen($s);
+        $encoding = self::getEncoding( $encoding );
+        if ( 'CP850' === $encoding || 'ASCII' === $encoding ) {
+            return \strlen( $s );
         }
 
-        return @\iconv_strlen($s, $encoding);
+        return @\iconv_strlen( $s, $encoding );
     }
 
-    public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
+    public static function mb_strpos( $haystack, $needle, $offset = 0, $encoding = null )
     {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return strpos($haystack, $needle, $offset);
+        $encoding = self::getEncoding( $encoding );
+        if ( 'CP850' === $encoding || 'ASCII' === $encoding ) {
+            return strpos( $haystack, $needle, $offset );
         }
 
-        $needle = (string) $needle;
-        if ('' === $needle) {
-            if (80000 > \PHP_VERSION_ID) {
-                trigger_error(__METHOD__.': Empty delimiter', \E_USER_WARNING);
+        $needle = (string)$needle;
+        if ( '' === $needle ) {
+            if ( 80000 > \PHP_VERSION_ID ) {
+                trigger_error( __METHOD__ . ': Empty delimiter', \E_USER_WARNING );
 
                 return false;
             }
@@ -512,190 +512,190 @@ 
             return 0;
         }
 
-        return \iconv_strpos($haystack, $needle, $offset, $encoding);
+        return \iconv_strpos( $haystack, $needle, $offset, $encoding );
     }
 
-    public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
+    public static function mb_strrpos( $haystack, $needle, $offset = 0, $encoding = null )
     {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return strrpos($haystack, $needle, $offset);
+        $encoding = self::getEncoding( $encoding );
+        if ( 'CP850' === $encoding || 'ASCII' === $encoding ) {
+            return strrpos( $haystack, $needle, $offset );
         }
 
-        if ($offset != (int) $offset) {
+        if ( $offset != (int)$offset ) {
             $offset = 0;
-        } elseif ($offset = (int) $offset) {
-            if ($offset < 0) {
-                if (0 > $offset += self::mb_strlen($needle)) {
-                    $haystack = self::mb_substr($haystack, 0, $offset, $encoding);
+        } elseif ( $offset = (int)$offset ) {
+            if ( $offset < 0 ) {
+                if ( 0 > $offset += self::mb_strlen( $needle ) ) {
+                    $haystack = self::mb_substr( $haystack, 0, $offset, $encoding );
                 }
                 $offset = 0;
             } else {
-                $haystack = self::mb_substr($haystack, $offset, 2147483647, $encoding);
+                $haystack = self::mb_substr( $haystack, $offset, 2147483647, $encoding );
             }
         }
 
         $pos = '' !== $needle || 80000 > \PHP_VERSION_ID
-            ? \iconv_strrpos($haystack, $needle, $encoding)
-            : self::mb_strlen($haystack, $encoding);
+            ? \iconv_strrpos( $haystack, $needle, $encoding )
+            : self::mb_strlen( $haystack, $encoding );
 
         return false !== $pos ? $offset + $pos : false;
     }
 
-    public static function mb_str_split($string, $split_length = 1, $encoding = null)
+    public static function mb_str_split( $string, $split_length = 1, $encoding = null )
     {
-        if (null !== $string && !is_scalar($string) && !(\is_object($string) && method_exists($string, '__toString'))) {
-            trigger_error('mb_str_split() expects parameter 1 to be string, '.\gettype($string).' given', \E_USER_WARNING);
+        if ( null !== $string && ! is_scalar( $string ) && ! ( \is_object( $string ) && method_exists( $string, '__toString' ) ) ) {
+            trigger_error( 'mb_str_split() expects parameter 1 to be string, ' . \gettype( $string ) . ' given', \E_USER_WARNING );
 
             return null;
         }
 
-        if (1 > $split_length = (int) $split_length) {
-            if (80000 > \PHP_VERSION_ID) {
-                trigger_error('The length of each segment must be greater than zero', \E_USER_WARNING);
+        if ( 1 > $split_length = (int)$split_length ) {
+            if ( 80000 > \PHP_VERSION_ID ) {
+                trigger_error( 'The length of each segment must be greater than zero', \E_USER_WARNING );
                 return false;
             }
 
-            throw new \ValueError('Argument #2 ($length) must be greater than 0');
+            throw new \ValueError( 'Argument #2 ($length) must be greater than 0' );
         }
 
-        if (null === $encoding) {
+        if ( null === $encoding ) {
             $encoding = mb_internal_encoding();
         }
 
-        if ('UTF-8' === $encoding = self::getEncoding($encoding)) {
+        if ( 'UTF-8' === $encoding = self::getEncoding( $encoding ) ) {
             $rx = '/(';
-            while (65535 < $split_length) {
+            while ( 65535 < $split_length ) {
                 $rx .= '.{65535}';
                 $split_length -= 65535;
             }
-            $rx .= '.{'.$split_length.'})/us';
+            $rx .= '.{' . $split_length . '})/us';
 
-            return preg_split($rx, $string, -1, \PREG_SPLIT_DELIM_CAPTURE | \PREG_SPLIT_NO_EMPTY);
+            return preg_split( $rx, $string, -1, \PREG_SPLIT_DELIM_CAPTURE | \PREG_SPLIT_NO_EMPTY );
         }
 
-        $result = [];
-        $length = mb_strlen($string, $encoding);
+        $result = [ ];
+        $length = mb_strlen( $string, $encoding );
 
-        for ($i = 0; $i < $length; $i += $split_length) {
-            $result[] = mb_substr($string, $i, $split_length, $encoding);
+        for ( $i = 0; $i < $length; $i += $split_length ) {
+            $result[ ] = mb_substr( $string, $i, $split_length, $encoding );
         }
 
         return $result;
     }
 
-    public static function mb_strtolower($s, $encoding = null)
+    public static function mb_strtolower( $s, $encoding = null )
     {
-        return self::mb_convert_case($s, \MB_CASE_LOWER, $encoding);
+        return self::mb_convert_case( $s, \MB_CASE_LOWER, $encoding );
     }
 
-    public static function mb_strtoupper($s, $encoding = null)
+    public static function mb_strtoupper( $s, $encoding = null )
     {
-        return self::mb_convert_case($s, \MB_CASE_UPPER, $encoding);
+        return self::mb_convert_case( $s, \MB_CASE_UPPER, $encoding );
     }
 
-    public static function mb_substitute_character($c = null)
+    public static function mb_substitute_character( $c = null )
     {
-        if (null === $c) {
+        if ( null === $c ) {
             return 'none';
         }
-        if (0 === strcasecmp($c, 'none')) {
+        if ( 0 === strcasecmp( $c, 'none' ) ) {
             return true;
         }
-        if (80000 > \PHP_VERSION_ID) {
+        if ( 80000 > \PHP_VERSION_ID ) {
             return false;
         }
-        if (\is_int($c) || 'long' === $c || 'entity' === $c) {
+        if ( \is_int( $c ) || 'long' === $c || 'entity' === $c ) {
             return false;
         }
 
-        throw new \ValueError('Argument #1 ($substitute_character) must be "none", "long", "entity" or a valid codepoint');
+        throw new \ValueError( 'Argument #1 ($substitute_character) must be "none", "long", "entity" or a valid codepoint' );
     }
 
-    public static function mb_substr($s, $start, $length = null, $encoding = null)
+    public static function mb_substr( $s, $start, $length = null, $encoding = null )
     {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            return (string) substr($s, $start, null === $length ? 2147483647 : $length);
+        $encoding = self::getEncoding( $encoding );
+        if ( 'CP850' === $encoding || 'ASCII' === $encoding ) {
+            return (string)substr( $s, $start, null === $length ? 2147483647 : $length );
         }
 
-        if ($start < 0) {
-            $start = \iconv_strlen($s, $encoding) + $start;
-            if ($start < 0) {
+        if ( $start < 0 ) {
+            $start = \iconv_strlen( $s, $encoding ) + $start;
+            if ( $start < 0 ) {
                 $start = 0;
             }
         }
 
-        if (null === $length) {
+        if ( null === $length ) {
             $length = 2147483647;
-        } elseif ($length < 0) {
-            $length = \iconv_strlen($s, $encoding) + $length - $start;
-            if ($length < 0) {
+        } elseif ( $length < 0 ) {
+            $length = \iconv_strlen( $s, $encoding ) + $length - $start;
+            if ( $length < 0 ) {
                 return '';
             }
         }
 
-        return (string) \iconv_substr($s, $start, $length, $encoding);
+        return (string)\iconv_substr( $s, $start, $length, $encoding );
     }
 
-    public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
+    public static function mb_stripos( $haystack, $needle, $offset = 0, $encoding = null )
     {
-        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
-        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+        $haystack = self::mb_convert_case( $haystack, self::MB_CASE_FOLD, $encoding );
+        $needle = self::mb_convert_case( $needle, self::MB_CASE_FOLD, $encoding );
 
-        return self::mb_strpos($haystack, $needle, $offset, $encoding);
+        return self::mb_strpos( $haystack, $needle, $offset, $encoding );
     }
 
-    public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
+    public static function mb_stristr( $haystack, $needle, $part = false, $encoding = null )
     {
-        $pos = self::mb_stripos($haystack, $needle, 0, $encoding);
+        $pos = self::mb_stripos( $haystack, $needle, 0, $encoding );
 
-        return self::getSubpart($pos, $part, $haystack, $encoding);
+        return self::getSubpart( $pos, $part, $haystack, $encoding );
     }
 
-    public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
+    public static function mb_strrchr( $haystack, $needle, $part = false, $encoding = null )
     {
-        $encoding = self::getEncoding($encoding);
-        if ('CP850' === $encoding || 'ASCII' === $encoding) {
-            $pos = strrpos($haystack, $needle);
+        $encoding = self::getEncoding( $encoding );
+        if ( 'CP850' === $encoding || 'ASCII' === $encoding ) {
+            $pos = strrpos( $haystack, $needle );
         } else {
-            $needle = self::mb_substr($needle, 0, 1, $encoding);
-            $pos = \iconv_strrpos($haystack, $needle, $encoding);
+            $needle = self::mb_substr( $needle, 0, 1, $encoding );
+            $pos = \iconv_strrpos( $haystack, $needle, $encoding );
         }
 
-        return self::getSubpart($pos, $part, $haystack, $encoding);
+        return self::getSubpart( $pos, $part, $haystack, $encoding );
     }
 
-    public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
+    public static function mb_strrichr( $haystack, $needle, $part = false, $encoding = null )
     {
-        $needle = self::mb_substr($needle, 0, 1, $encoding);
-        $pos = self::mb_strripos($haystack, $needle, $encoding);
+        $needle = self::mb_substr( $needle, 0, 1, $encoding );
+        $pos = self::mb_strripos( $haystack, $needle, $encoding );
 
-        return self::getSubpart($pos, $part, $haystack, $encoding);
+        return self::getSubpart( $pos, $part, $haystack, $encoding );
     }
 
-    public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
+    public static function mb_strripos( $haystack, $needle, $offset = 0, $encoding = null )
     {
-        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
-        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+        $haystack = self::mb_convert_case( $haystack, self::MB_CASE_FOLD, $encoding );
+        $needle = self::mb_convert_case( $needle, self::MB_CASE_FOLD, $encoding );
 
-        return self::mb_strrpos($haystack, $needle, $offset, $encoding);
+        return self::mb_strrpos( $haystack, $needle, $offset, $encoding );
     }
 
-    public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
+    public static function mb_strstr( $haystack, $needle, $part = false, $encoding = null )
     {
-        $pos = strpos($haystack, $needle);
-        if (false === $pos) {
+        $pos = strpos( $haystack, $needle );
+        if ( false === $pos ) {
             return false;
         }
-        if ($part) {
-            return substr($haystack, 0, $pos);
+        if ( $part ) {
+            return substr( $haystack, 0, $pos );
         }
 
-        return substr($haystack, $pos);
+        return substr( $haystack, $pos );
     }
 
-    public static function mb_get_info($type = 'all')
+    public static function mb_get_info( $type = 'all' )
     {
         $info = [
             'internal_encoding' => self::$internalEncoding,
@@ -714,160 +714,160 @@ 
             'strict_detection' => 'Off',
         ];
 
-        if ('all' === $type) {
+        if ( 'all' === $type ) {
             return $info;
         }
-        if (isset($info[$type])) {
-            return $info[$type];
+        if ( isset( $info[ $type ] ) ) {
+            return $info[ $type ];
         }
 
         return false;
     }
 
-    public static function mb_http_input($type = '')
+    public static function mb_http_input( $type = '' )
     {
         return false;
     }
 
-    public static function mb_http_output($encoding = null)
+    public static function mb_http_output( $encoding = null )
     {
         return null !== $encoding ? 'pass' === $encoding : 'pass';
     }
 
-    public static function mb_strwidth($s, $encoding = null)
+    public static function mb_strwidth( $s, $encoding = null )
     {
-        $encoding = self::getEncoding($encoding);
+        $encoding = self::getEncoding( $encoding );
 
-        if ('UTF-8' !== $encoding) {
-            $s = \iconv($encoding, 'UTF-8//IGNORE', $s);
+        if ( 'UTF-8' !== $encoding ) {
+            $s = \iconv( $encoding, 'UTF-8//IGNORE', $s );
         }
 
-        $s = preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide);
+        $s = preg_replace( '/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide );
 
-        return ($wide << 1) + \iconv_strlen($s, 'UTF-8');
+        return ( $wide << 1 ) + \iconv_strlen( $s, 'UTF-8' );
     }
 
-    public static function mb_substr_count($haystack, $needle, $encoding = null)
+    public static function mb_substr_count( $haystack, $needle, $encoding = null )
     {
-        return substr_count($haystack, $needle);
+        return substr_count( $haystack, $needle );
     }
 
-    public static function mb_output_handler($contents, $status)
+    public static function mb_output_handler( $contents, $status )
     {
         return $contents;
     }
 
-    public static function mb_chr($code, $encoding = null)
+    public static function mb_chr( $code, $encoding = null )
     {
-        if (0x80 > $code %= 0x200000) {
-            $s = \chr($code);
-        } elseif (0x800 > $code) {
-            $s = \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
-        } elseif (0x10000 > $code) {
-            $s = \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+        if ( 0x80 > $code %= 0x200000 ) {
+            $s = \chr( $code );
+        } elseif ( 0x800 > $code ) {
+            $s = \chr( 0xC0 | $code >> 6 ) . \chr( 0x80 | $code & 0x3F );
+        } elseif ( 0x10000 > $code ) {
+            $s = \chr( 0xE0 | $code >> 12 ) . \chr( 0x80 | $code >> 6 & 0x3F ) . \chr( 0x80 | $code & 0x3F );
         } else {
-            $s = \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+            $s = \chr( 0xF0 | $code >> 18 ) . \chr( 0x80 | $code >> 12 & 0x3F ) . \chr( 0x80 | $code >> 6 & 0x3F ) . \chr( 0x80 | $code & 0x3F );
         }
 
-        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
-            $s = mb_convert_encoding($s, $encoding, 'UTF-8');
+        if ( 'UTF-8' !== $encoding = self::getEncoding( $encoding ) ) {
+            $s = mb_convert_encoding( $s, $encoding, 'UTF-8' );
         }
 
         return $s;
     }
 
-    public static function mb_ord($s, $encoding = null)
+    public static function mb_ord( $s, $encoding = null )
     {
-        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
-            $s = mb_convert_encoding($s, 'UTF-8', $encoding);
+        if ( 'UTF-8' !== $encoding = self::getEncoding( $encoding ) ) {
+            $s = mb_convert_encoding( $s, 'UTF-8', $encoding );
         }
 
-        if (1 === \strlen($s)) {
-            return \ord($s);
+        if ( 1 === \strlen( $s ) ) {
+            return \ord( $s );
         }
 
-        $code = ($s = unpack('C*', substr($s, 0, 4))) ? $s[1] : 0;
-        if (0xF0 <= $code) {
-            return (($code - 0xF0) << 18) + (($s[2] - 0x80) << 12) + (($s[3] - 0x80) << 6) + $s[4] - 0x80;
+        $code = ( $s = unpack( 'C*', substr( $s, 0, 4 ) ) ) ? $s[ 1 ] : 0;
+        if ( 0xF0 <= $code ) {
+            return ( ( $code - 0xF0 ) << 18 ) + ( ( $s[ 2 ] - 0x80 ) << 12 ) + ( ( $s[ 3 ] - 0x80 ) << 6 ) + $s[ 4 ] - 0x80;
         }
-        if (0xE0 <= $code) {
-            return (($code - 0xE0) << 12) + (($s[2] - 0x80) << 6) + $s[3] - 0x80;
+        if ( 0xE0 <= $code ) {
+            return ( ( $code - 0xE0 ) << 12 ) + ( ( $s[ 2 ] - 0x80 ) << 6 ) + $s[ 3 ] - 0x80;
         }
-        if (0xC0 <= $code) {
-            return (($code - 0xC0) << 6) + $s[2] - 0x80;
+        if ( 0xC0 <= $code ) {
+            return ( ( $code - 0xC0 ) << 6 ) + $s[ 2 ] - 0x80;
         }
 
         return $code;
     }
 
-    private static function getSubpart($pos, $part, $haystack, $encoding)
+    private static function getSubpart( $pos, $part, $haystack, $encoding )
     {
-        if (false === $pos) {
+        if ( false === $pos ) {
             return false;
         }
-        if ($part) {
-            return self::mb_substr($haystack, 0, $pos, $encoding);
+        if ( $part ) {
+            return self::mb_substr( $haystack, 0, $pos, $encoding );
         }
 
-        return self::mb_substr($haystack, $pos, null, $encoding);
+        return self::mb_substr( $haystack, $pos, null, $encoding );
     }
 
-    private static function html_encoding_callback(array $m)
+    private static function html_encoding_callback( array $m )
     {
         $i = 1;
         $entities = '';
-        $m = unpack('C*', htmlentities($m[0], \ENT_COMPAT, 'UTF-8'));
+        $m = unpack( 'C*', htmlentities( $m[ 0 ], \ENT_COMPAT, 'UTF-8' ) );
 
-        while (isset($m[$i])) {
-            if (0x80 > $m[$i]) {
-                $entities .= \chr($m[$i++]);
+        while ( isset( $m[ $i ] ) ) {
+            if ( 0x80 > $m[ $i ] ) {
+                $entities .= \chr( $m[ $i++ ] );
                 continue;
             }
-            if (0xF0 <= $m[$i]) {
-                $c = (($m[$i++] - 0xF0) << 18) + (($m[$i++] - 0x80) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
-            } elseif (0xE0 <= $m[$i]) {
-                $c = (($m[$i++] - 0xE0) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+            if ( 0xF0 <= $m[ $i ] ) {
+                $c = ( ( $m[ $i++ ] - 0xF0 ) << 18 ) + ( ( $m[ $i++ ] - 0x80 ) << 12 ) + ( ( $m[ $i++ ] - 0x80 ) << 6 ) + $m[ $i++ ] - 0x80;
+            } elseif ( 0xE0 <= $m[ $i ] ) {
+                $c = ( ( $m[ $i++ ] - 0xE0 ) << 12 ) + ( ( $m[ $i++ ] - 0x80 ) << 6 ) + $m[ $i++ ] - 0x80;
             } else {
-                $c = (($m[$i++] - 0xC0) << 6) + $m[$i++] - 0x80;
+                $c = ( ( $m[ $i++ ] - 0xC0 ) << 6 ) + $m[ $i++ ] - 0x80;
             }
 
-            $entities .= '&#'.$c.';';
+            $entities .= '&#' . $c . ';';
         }
 
         return $entities;
     }
 
-    private static function title_case(array $s)
+    private static function title_case( array $s )
     {
-        return self::mb_convert_case($s[1], \MB_CASE_UPPER, 'UTF-8').self::mb_convert_case($s[2], \MB_CASE_LOWER, 'UTF-8');
+        return self::mb_convert_case( $s[ 1 ], \MB_CASE_UPPER, 'UTF-8' ) . self::mb_convert_case( $s[ 2 ], \MB_CASE_LOWER, 'UTF-8' );
     }
 
-    private static function getData($file)
+    private static function getData( $file )
     {
-        if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
+        if ( file_exists( $file = __DIR__ . '/Resources/unidata/' . $file . '.php' ) ) {
             return require $file;
         }
 
         return false;
     }
 
-    private static function getEncoding($encoding)
+    private static function getEncoding( $encoding )
     {
-        if (null === $encoding) {
+        if ( null === $encoding ) {
             return self::$internalEncoding;
         }
 
-        if ('UTF-8' === $encoding) {
+        if ( 'UTF-8' === $encoding ) {
             return 'UTF-8';
         }
 
-        $encoding = strtoupper($encoding);
+        $encoding = strtoupper( $encoding );
 
-        if ('8BIT' === $encoding || 'BINARY' === $encoding) {
+        if ( '8BIT' === $encoding || 'BINARY' === $encoding ) {
             return 'CP850';
         }
 
-        if ('UTF8' === $encoding) {
+        if ( 'UTF8' === $encoding ) {
             return 'UTF-8';
         }
 

includes/plugin-and-theme-hooks/class-gravityview-plugin-hooks-gravity-forms-dropbox.php

Spacing +1 added lines, -1 removed lines

@@ -52,7 +52,7 @@
 		}
 
 		// The image source has ?raw=1; don't check for valid image extensions.
-		$image_atts['validate_src'] = false;
+		$image_atts[ 'validate_src' ] = false;
 
 		return $image_atts;
 	}