gravityview / GravityView

vendor/symfony/string/ByteString.php

Indentation +457 added lines, -457 removed lines

@@ -25,14 +25,14 @@ 
  */
 class ByteString extends AbstractString
 {
-    private const ALPHABET_ALPHANUMERIC = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+	private const ALPHABET_ALPHANUMERIC = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
-    public function __construct(string $string = '')
-    {
-        $this->string = $string;
-    }
+	public function __construct(string $string = '')
+	{
+		$this->string = $string;
+	}
 
-    /*
+	/*
      * The following method was derived from code of the Hack Standard Library (v4.40 - 2020-05-03)
      *
      * https://github.com/hhvm/hsl/blob/80a42c02f036f72a42f0415e80d6b847f4bf62d5/src/random/private.php#L16
@@ -42,465 +42,465 @@ 
      * Copyright (c) 2004-2020, Facebook, Inc. (https://www.facebook.com/)
      */
 
-    public static function fromRandom(int $length = 16, string $alphabet = null): self
-    {
-        if ($length <= 0) {
-            throw new InvalidArgumentException(sprintf('A strictly positive length is expected, "%d" given.', $length));
-        }
-
-        $alphabet = $alphabet ?? self::ALPHABET_ALPHANUMERIC;
-        $alphabetSize = \strlen($alphabet);
-        $bits = (int) ceil(log($alphabetSize, 2.0));
-        if ($bits <= 0 || $bits > 56) {
-            throw new InvalidArgumentException('The length of the alphabet must in the [2^1, 2^56] range.');
-        }
-
-        $ret = '';
-        while ($length > 0) {
-            $urandomLength = (int) ceil(2 * $length * $bits / 8.0);
-            $data = random_bytes($urandomLength);
-            $unpackedData = 0;
-            $unpackedBits = 0;
-            for ($i = 0; $i < $urandomLength && $length > 0; ++$i) {
-                // Unpack 8 bits
-                $unpackedData = ($unpackedData << 8) | \ord($data[$i]);
-                $unpackedBits += 8;
-
-                // While we have enough bits to select a character from the alphabet, keep
-                // consuming the random data
-                for (; $unpackedBits >= $bits && $length > 0; $unpackedBits -= $bits) {
-                    $index = ($unpackedData & ((1 << $bits) - 1));
-                    $unpackedData >>= $bits;
-                    // Unfortunately, the alphabet size is not necessarily a power of two.
-                    // Worst case, it is 2^k + 1, which means we need (k+1) bits and we
-                    // have around a 50% chance of missing as k gets larger
-                    if ($index < $alphabetSize) {
-                        $ret .= $alphabet[$index];
-                        --$length;
-                    }
-                }
-            }
-        }
-
-        return new static($ret);
-    }
-
-    public function bytesAt(int $offset): array
-    {
-        $str = $this->string[$offset] ?? '';
-
-        return '' === $str ? [] : [\ord($str)];
-    }
-
-    public function append(string ...$suffix): parent
-    {
-        $str = clone $this;
-        $str->string .= 1 >= \count($suffix) ? ($suffix[0] ?? '') : implode('', $suffix);
-
-        return $str;
-    }
-
-    public function camel(): parent
-    {
-        $str = clone $this;
-        $str->string = lcfirst(str_replace(' ', '', ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $this->string))));
-
-        return $str;
-    }
-
-    public function chunk(int $length = 1): array
-    {
-        if (1 > $length) {
-            throw new InvalidArgumentException('The chunk length must be greater than zero.');
-        }
-
-        if ('' === $this->string) {
-            return [];
-        }
-
-        $str = clone $this;
-        $chunks = [];
-
-        foreach (str_split($this->string, $length) as $chunk) {
-            $str->string = $chunk;
-            $chunks[] = clone $str;
-        }
-
-        return $chunks;
-    }
-
-    public function endsWith($suffix): bool
-    {
-        if ($suffix instanceof parent) {
-            $suffix = $suffix->string;
-        } elseif (\is_array($suffix) || $suffix instanceof \Traversable) {
-            return parent::endsWith($suffix);
-        } else {
-            $suffix = (string) $suffix;
-        }
-
-        return '' !== $suffix && \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix), null, $this->ignoreCase);
-    }
-
-    public function equalsTo($string): bool
-    {
-        if ($string instanceof parent) {
-            $string = $string->string;
-        } elseif (\is_array($string) || $string instanceof \Traversable) {
-            return parent::equalsTo($string);
-        } else {
-            $string = (string) $string;
-        }
-
-        if ('' !== $string && $this->ignoreCase) {
-            return 0 === strcasecmp($string, $this->string);
-        }
-
-        return $string === $this->string;
-    }
-
-    public function folded(): parent
-    {
-        $str = clone $this;
-        $str->string = strtolower($str->string);
-
-        return $str;
-    }
-
-    public function indexOf($needle, int $offset = 0): ?int
-    {
-        if ($needle instanceof parent) {
-            $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
-            return parent::indexOf($needle, $offset);
-        } else {
-            $needle = (string) $needle;
-        }
-
-        if ('' === $needle) {
-            return null;
-        }
-
-        $i = $this->ignoreCase ? stripos($this->string, $needle, $offset) : strpos($this->string, $needle, $offset);
-
-        return false === $i ? null : $i;
-    }
-
-    public function indexOfLast($needle, int $offset = 0): ?int
-    {
-        if ($needle instanceof parent) {
-            $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
-            return parent::indexOfLast($needle, $offset);
-        } else {
-            $needle = (string) $needle;
-        }
-
-        if ('' === $needle) {
-            return null;
-        }
-
-        $i = $this->ignoreCase ? strripos($this->string, $needle, $offset) : strrpos($this->string, $needle, $offset);
-
-        return false === $i ? null : $i;
-    }
-
-    public function isUtf8(): bool
-    {
-        return '' === $this->string || preg_match('//u', $this->string);
-    }
-
-    public function join(array $strings, string $lastGlue = null): parent
-    {
-        $str = clone $this;
-
-        $tail = null !== $lastGlue && 1 < \count($strings) ? $lastGlue.array_pop($strings) : '';
-        $str->string = implode($this->string, $strings).$tail;
-
-        return $str;
-    }
-
-    public function length(): int
-    {
-        return \strlen($this->string);
-    }
-
-    public function lower(): parent
-    {
-        $str = clone $this;
-        $str->string = strtolower($str->string);
-
-        return $str;
-    }
-
-    public function match(string $regexp, int $flags = 0, int $offset = 0): array
-    {
-        $match = ((\PREG_PATTERN_ORDER | \PREG_SET_ORDER) & $flags) ? 'preg_match_all' : 'preg_match';
-
-        if ($this->ignoreCase) {
-            $regexp .= 'i';
-        }
-
-        set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
-
-        try {
-            if (false === $match($regexp, $this->string, $matches, $flags | \PREG_UNMATCHED_AS_NULL, $offset)) {
-                $lastError = preg_last_error();
-
-                foreach (get_defined_constants(true)['pcre'] as $k => $v) {
-                    if ($lastError === $v && '_ERROR' === substr($k, -6)) {
-                        throw new RuntimeException('Matching failed with '.$k.'.');
-                    }
-                }
-
-                throw new RuntimeException('Matching failed with unknown error code.');
-            }
-        } finally {
-            restore_error_handler();
-        }
-
-        return $matches;
-    }
-
-    public function padBoth(int $length, string $padStr = ' '): parent
-    {
-        $str = clone $this;
-        $str->string = str_pad($this->string, $length, $padStr, \STR_PAD_BOTH);
-
-        return $str;
-    }
-
-    public function padEnd(int $length, string $padStr = ' '): parent
-    {
-        $str = clone $this;
-        $str->string = str_pad($this->string, $length, $padStr, \STR_PAD_RIGHT);
-
-        return $str;
-    }
-
-    public function padStart(int $length, string $padStr = ' '): parent
-    {
-        $str = clone $this;
-        $str->string = str_pad($this->string, $length, $padStr, \STR_PAD_LEFT);
-
-        return $str;
-    }
-
-    public function prepend(string ...$prefix): parent
-    {
-        $str = clone $this;
-        $str->string = (1 >= \count($prefix) ? ($prefix[0] ?? '') : implode('', $prefix)).$str->string;
-
-        return $str;
-    }
-
-    public function replace(string $from, string $to): parent
-    {
-        $str = clone $this;
-
-        if ('' !== $from) {
-            $str->string = $this->ignoreCase ? str_ireplace($from, $to, $this->string) : str_replace($from, $to, $this->string);
-        }
-
-        return $str;
-    }
-
-    public function replaceMatches(string $fromRegexp, $to): parent
-    {
-        if ($this->ignoreCase) {
-            $fromRegexp .= 'i';
-        }
-
-        if (\is_array($to)) {
-            if (!\is_callable($to)) {
-                throw new \TypeError(sprintf('Argument 2 passed to "%s::replaceMatches()" must be callable, array given.', static::class));
-            }
-
-            $replace = 'preg_replace_callback';
-        } else {
-            $replace = $to instanceof \Closure ? 'preg_replace_callback' : 'preg_replace';
-        }
-
-        set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
-
-        try {
-            if (null === $string = $replace($fromRegexp, $to, $this->string)) {
-                $lastError = preg_last_error();
-
-                foreach (get_defined_constants(true)['pcre'] as $k => $v) {
-                    if ($lastError === $v && '_ERROR' === substr($k, -6)) {
-                        throw new RuntimeException('Matching failed with '.$k.'.');
-                    }
-                }
-
-                throw new RuntimeException('Matching failed with unknown error code.');
-            }
-        } finally {
-            restore_error_handler();
-        }
-
-        $str = clone $this;
-        $str->string = $string;
-
-        return $str;
-    }
-
-    public function reverse(): parent
-    {
-        $str = clone $this;
-        $str->string = strrev($str->string);
-
-        return $str;
-    }
-
-    public function slice(int $start = 0, int $length = null): parent
-    {
-        $str = clone $this;
-        $str->string = (string) substr($this->string, $start, $length ?? \PHP_INT_MAX);
-
-        return $str;
-    }
-
-    public function snake(): parent
-    {
-        $str = $this->camel()->title();
-        $str->string = strtolower(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], '\1_\2', $str->string));
-
-        return $str;
-    }
-
-    public function splice(string $replacement, int $start = 0, int $length = null): parent
-    {
-        $str = clone $this;
-        $str->string = substr_replace($this->string, $replacement, $start, $length ?? \PHP_INT_MAX);
-
-        return $str;
-    }
-
-    public function split(string $delimiter, int $limit = null, int $flags = null): array
-    {
-        if (1 > $limit = $limit ?? \PHP_INT_MAX) {
-            throw new InvalidArgumentException('Split limit must be a positive integer.');
-        }
-
-        if ('' === $delimiter) {
-            throw new InvalidArgumentException('Split delimiter is empty.');
-        }
-
-        if (null !== $flags) {
-            return parent::split($delimiter, $limit, $flags);
-        }
-
-        $str = clone $this;
-        $chunks = $this->ignoreCase
-            ? preg_split('{'.preg_quote($delimiter).'}iD', $this->string, $limit)
-            : explode($delimiter, $this->string, $limit);
-
-        foreach ($chunks as &$chunk) {
-            $str->string = $chunk;
-            $chunk = clone $str;
-        }
-
-        return $chunks;
-    }
-
-    public function startsWith($prefix): bool
-    {
-        if ($prefix instanceof parent) {
-            $prefix = $prefix->string;
-        } elseif (!\is_string($prefix)) {
-            return parent::startsWith($prefix);
-        }
-
-        return '' !== $prefix && 0 === ($this->ignoreCase ? strncasecmp($this->string, $prefix, \strlen($prefix)) : strncmp($this->string, $prefix, \strlen($prefix)));
-    }
-
-    public function title(bool $allWords = false): parent
-    {
-        $str = clone $this;
-        $str->string = $allWords ? ucwords($str->string) : ucfirst($str->string);
-
-        return $str;
-    }
-
-    public function toUnicodeString(string $fromEncoding = null): UnicodeString
-    {
-        return new UnicodeString($this->toCodePointString($fromEncoding)->string);
-    }
-
-    public function toCodePointString(string $fromEncoding = null): CodePointString
-    {
-        $u = new CodePointString();
-
-        if (\in_array($fromEncoding, [null, 'utf8', 'utf-8', 'UTF8', 'UTF-8'], true) && preg_match('//u', $this->string)) {
-            $u->string = $this->string;
-
-            return $u;
-        }
+	public static function fromRandom(int $length = 16, string $alphabet = null): self
+	{
+		if ($length <= 0) {
+			throw new InvalidArgumentException(sprintf('A strictly positive length is expected, "%d" given.', $length));
+		}
+
+		$alphabet = $alphabet ?? self::ALPHABET_ALPHANUMERIC;
+		$alphabetSize = \strlen($alphabet);
+		$bits = (int) ceil(log($alphabetSize, 2.0));
+		if ($bits <= 0 || $bits > 56) {
+			throw new InvalidArgumentException('The length of the alphabet must in the [2^1, 2^56] range.');
+		}
+
+		$ret = '';
+		while ($length > 0) {
+			$urandomLength = (int) ceil(2 * $length * $bits / 8.0);
+			$data = random_bytes($urandomLength);
+			$unpackedData = 0;
+			$unpackedBits = 0;
+			for ($i = 0; $i < $urandomLength && $length > 0; ++$i) {
+				// Unpack 8 bits
+				$unpackedData = ($unpackedData << 8) | \ord($data[$i]);
+				$unpackedBits += 8;
+
+				// While we have enough bits to select a character from the alphabet, keep
+				// consuming the random data
+				for (; $unpackedBits >= $bits && $length > 0; $unpackedBits -= $bits) {
+					$index = ($unpackedData & ((1 << $bits) - 1));
+					$unpackedData >>= $bits;
+					// Unfortunately, the alphabet size is not necessarily a power of two.
+					// Worst case, it is 2^k + 1, which means we need (k+1) bits and we
+					// have around a 50% chance of missing as k gets larger
+					if ($index < $alphabetSize) {
+						$ret .= $alphabet[$index];
+						--$length;
+					}
+				}
+			}
+		}
+
+		return new static($ret);
+	}
+
+	public function bytesAt(int $offset): array
+	{
+		$str = $this->string[$offset] ?? '';
+
+		return '' === $str ? [] : [\ord($str)];
+	}
+
+	public function append(string ...$suffix): parent
+	{
+		$str = clone $this;
+		$str->string .= 1 >= \count($suffix) ? ($suffix[0] ?? '') : implode('', $suffix);
+
+		return $str;
+	}
+
+	public function camel(): parent
+	{
+		$str = clone $this;
+		$str->string = lcfirst(str_replace(' ', '', ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $this->string))));
+
+		return $str;
+	}
+
+	public function chunk(int $length = 1): array
+	{
+		if (1 > $length) {
+			throw new InvalidArgumentException('The chunk length must be greater than zero.');
+		}
+
+		if ('' === $this->string) {
+			return [];
+		}
+
+		$str = clone $this;
+		$chunks = [];
+
+		foreach (str_split($this->string, $length) as $chunk) {
+			$str->string = $chunk;
+			$chunks[] = clone $str;
+		}
+
+		return $chunks;
+	}
+
+	public function endsWith($suffix): bool
+	{
+		if ($suffix instanceof parent) {
+			$suffix = $suffix->string;
+		} elseif (\is_array($suffix) || $suffix instanceof \Traversable) {
+			return parent::endsWith($suffix);
+		} else {
+			$suffix = (string) $suffix;
+		}
+
+		return '' !== $suffix && \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix), null, $this->ignoreCase);
+	}
+
+	public function equalsTo($string): bool
+	{
+		if ($string instanceof parent) {
+			$string = $string->string;
+		} elseif (\is_array($string) || $string instanceof \Traversable) {
+			return parent::equalsTo($string);
+		} else {
+			$string = (string) $string;
+		}
+
+		if ('' !== $string && $this->ignoreCase) {
+			return 0 === strcasecmp($string, $this->string);
+		}
+
+		return $string === $this->string;
+	}
+
+	public function folded(): parent
+	{
+		$str = clone $this;
+		$str->string = strtolower($str->string);
+
+		return $str;
+	}
+
+	public function indexOf($needle, int $offset = 0): ?int
+	{
+		if ($needle instanceof parent) {
+			$needle = $needle->string;
+		} elseif (\is_array($needle) || $needle instanceof \Traversable) {
+			return parent::indexOf($needle, $offset);
+		} else {
+			$needle = (string) $needle;
+		}
+
+		if ('' === $needle) {
+			return null;
+		}
+
+		$i = $this->ignoreCase ? stripos($this->string, $needle, $offset) : strpos($this->string, $needle, $offset);
+
+		return false === $i ? null : $i;
+	}
+
+	public function indexOfLast($needle, int $offset = 0): ?int
+	{
+		if ($needle instanceof parent) {
+			$needle = $needle->string;
+		} elseif (\is_array($needle) || $needle instanceof \Traversable) {
+			return parent::indexOfLast($needle, $offset);
+		} else {
+			$needle = (string) $needle;
+		}
+
+		if ('' === $needle) {
+			return null;
+		}
+
+		$i = $this->ignoreCase ? strripos($this->string, $needle, $offset) : strrpos($this->string, $needle, $offset);
+
+		return false === $i ? null : $i;
+	}
+
+	public function isUtf8(): bool
+	{
+		return '' === $this->string || preg_match('//u', $this->string);
+	}
+
+	public function join(array $strings, string $lastGlue = null): parent
+	{
+		$str = clone $this;
+
+		$tail = null !== $lastGlue && 1 < \count($strings) ? $lastGlue.array_pop($strings) : '';
+		$str->string = implode($this->string, $strings).$tail;
+
+		return $str;
+	}
+
+	public function length(): int
+	{
+		return \strlen($this->string);
+	}
+
+	public function lower(): parent
+	{
+		$str = clone $this;
+		$str->string = strtolower($str->string);
+
+		return $str;
+	}
+
+	public function match(string $regexp, int $flags = 0, int $offset = 0): array
+	{
+		$match = ((\PREG_PATTERN_ORDER | \PREG_SET_ORDER) & $flags) ? 'preg_match_all' : 'preg_match';
+
+		if ($this->ignoreCase) {
+			$regexp .= 'i';
+		}
+
+		set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
+
+		try {
+			if (false === $match($regexp, $this->string, $matches, $flags | \PREG_UNMATCHED_AS_NULL, $offset)) {
+				$lastError = preg_last_error();
+
+				foreach (get_defined_constants(true)['pcre'] as $k => $v) {
+					if ($lastError === $v && '_ERROR' === substr($k, -6)) {
+						throw new RuntimeException('Matching failed with '.$k.'.');
+					}
+				}
+
+				throw new RuntimeException('Matching failed with unknown error code.');
+			}
+		} finally {
+			restore_error_handler();
+		}
+
+		return $matches;
+	}
+
+	public function padBoth(int $length, string $padStr = ' '): parent
+	{
+		$str = clone $this;
+		$str->string = str_pad($this->string, $length, $padStr, \STR_PAD_BOTH);
+
+		return $str;
+	}
+
+	public function padEnd(int $length, string $padStr = ' '): parent
+	{
+		$str = clone $this;
+		$str->string = str_pad($this->string, $length, $padStr, \STR_PAD_RIGHT);
+
+		return $str;
+	}
+
+	public function padStart(int $length, string $padStr = ' '): parent
+	{
+		$str = clone $this;
+		$str->string = str_pad($this->string, $length, $padStr, \STR_PAD_LEFT);
+
+		return $str;
+	}
+
+	public function prepend(string ...$prefix): parent
+	{
+		$str = clone $this;
+		$str->string = (1 >= \count($prefix) ? ($prefix[0] ?? '') : implode('', $prefix)).$str->string;
+
+		return $str;
+	}
+
+	public function replace(string $from, string $to): parent
+	{
+		$str = clone $this;
+
+		if ('' !== $from) {
+			$str->string = $this->ignoreCase ? str_ireplace($from, $to, $this->string) : str_replace($from, $to, $this->string);
+		}
+
+		return $str;
+	}
+
+	public function replaceMatches(string $fromRegexp, $to): parent
+	{
+		if ($this->ignoreCase) {
+			$fromRegexp .= 'i';
+		}
+
+		if (\is_array($to)) {
+			if (!\is_callable($to)) {
+				throw new \TypeError(sprintf('Argument 2 passed to "%s::replaceMatches()" must be callable, array given.', static::class));
+			}
+
+			$replace = 'preg_replace_callback';
+		} else {
+			$replace = $to instanceof \Closure ? 'preg_replace_callback' : 'preg_replace';
+		}
+
+		set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
+
+		try {
+			if (null === $string = $replace($fromRegexp, $to, $this->string)) {
+				$lastError = preg_last_error();
+
+				foreach (get_defined_constants(true)['pcre'] as $k => $v) {
+					if ($lastError === $v && '_ERROR' === substr($k, -6)) {
+						throw new RuntimeException('Matching failed with '.$k.'.');
+					}
+				}
+
+				throw new RuntimeException('Matching failed with unknown error code.');
+			}
+		} finally {
+			restore_error_handler();
+		}
+
+		$str = clone $this;
+		$str->string = $string;
+
+		return $str;
+	}
+
+	public function reverse(): parent
+	{
+		$str = clone $this;
+		$str->string = strrev($str->string);
+
+		return $str;
+	}
+
+	public function slice(int $start = 0, int $length = null): parent
+	{
+		$str = clone $this;
+		$str->string = (string) substr($this->string, $start, $length ?? \PHP_INT_MAX);
+
+		return $str;
+	}
+
+	public function snake(): parent
+	{
+		$str = $this->camel()->title();
+		$str->string = strtolower(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], '\1_\2', $str->string));
+
+		return $str;
+	}
+
+	public function splice(string $replacement, int $start = 0, int $length = null): parent
+	{
+		$str = clone $this;
+		$str->string = substr_replace($this->string, $replacement, $start, $length ?? \PHP_INT_MAX);
+
+		return $str;
+	}
+
+	public function split(string $delimiter, int $limit = null, int $flags = null): array
+	{
+		if (1 > $limit = $limit ?? \PHP_INT_MAX) {
+			throw new InvalidArgumentException('Split limit must be a positive integer.');
+		}
+
+		if ('' === $delimiter) {
+			throw new InvalidArgumentException('Split delimiter is empty.');
+		}
+
+		if (null !== $flags) {
+			return parent::split($delimiter, $limit, $flags);
+		}
+
+		$str = clone $this;
+		$chunks = $this->ignoreCase
+			? preg_split('{'.preg_quote($delimiter).'}iD', $this->string, $limit)
+			: explode($delimiter, $this->string, $limit);
+
+		foreach ($chunks as &$chunk) {
+			$str->string = $chunk;
+			$chunk = clone $str;
+		}
+
+		return $chunks;
+	}
+
+	public function startsWith($prefix): bool
+	{
+		if ($prefix instanceof parent) {
+			$prefix = $prefix->string;
+		} elseif (!\is_string($prefix)) {
+			return parent::startsWith($prefix);
+		}
+
+		return '' !== $prefix && 0 === ($this->ignoreCase ? strncasecmp($this->string, $prefix, \strlen($prefix)) : strncmp($this->string, $prefix, \strlen($prefix)));
+	}
+
+	public function title(bool $allWords = false): parent
+	{
+		$str = clone $this;
+		$str->string = $allWords ? ucwords($str->string) : ucfirst($str->string);
+
+		return $str;
+	}
+
+	public function toUnicodeString(string $fromEncoding = null): UnicodeString
+	{
+		return new UnicodeString($this->toCodePointString($fromEncoding)->string);
+	}
+
+	public function toCodePointString(string $fromEncoding = null): CodePointString
+	{
+		$u = new CodePointString();
+
+		if (\in_array($fromEncoding, [null, 'utf8', 'utf-8', 'UTF8', 'UTF-8'], true) && preg_match('//u', $this->string)) {
+			$u->string = $this->string;
+
+			return $u;
+		}
 
-        set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
-
-        try {
-            try {
-                $validEncoding = false !== mb_detect_encoding($this->string, $fromEncoding ?? 'Windows-1252', true);
-            } catch (InvalidArgumentException $e) {
-                if (!\function_exists('iconv')) {
-                    throw $e;
-                }
-
-                $u->string = iconv($fromEncoding ?? 'Windows-1252', 'UTF-8', $this->string);
+		set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
+
+		try {
+			try {
+				$validEncoding = false !== mb_detect_encoding($this->string, $fromEncoding ?? 'Windows-1252', true);
+			} catch (InvalidArgumentException $e) {
+				if (!\function_exists('iconv')) {
+					throw $e;
+				}
+
+				$u->string = iconv($fromEncoding ?? 'Windows-1252', 'UTF-8', $this->string);
 
-                return $u;
-            }
-        } finally {
-            restore_error_handler();
-        }
-
-        if (!$validEncoding) {
-            throw new InvalidArgumentException(sprintf('Invalid "%s" string.', $fromEncoding ?? 'Windows-1252'));
-        }
-
-        $u->string = mb_convert_encoding($this->string, 'UTF-8', $fromEncoding ?? 'Windows-1252');
-
-        return $u;
-    }
+				return $u;
+			}
+		} finally {
+			restore_error_handler();
+		}
+
+		if (!$validEncoding) {
+			throw new InvalidArgumentException(sprintf('Invalid "%s" string.', $fromEncoding ?? 'Windows-1252'));
+		}
+
+		$u->string = mb_convert_encoding($this->string, 'UTF-8', $fromEncoding ?? 'Windows-1252');
+
+		return $u;
+	}
 
-    public function trim(string $chars = " \t\n\r\0\x0B\x0C"): parent
-    {
-        $str = clone $this;
-        $str->string = trim($str->string, $chars);
-
-        return $str;
-    }
+	public function trim(string $chars = " \t\n\r\0\x0B\x0C"): parent
+	{
+		$str = clone $this;
+		$str->string = trim($str->string, $chars);
+
+		return $str;
+	}
 
-    public function trimEnd(string $chars = " \t\n\r\0\x0B\x0C"): parent
-    {
-        $str = clone $this;
-        $str->string = rtrim($str->string, $chars);
-
-        return $str;
-    }
+	public function trimEnd(string $chars = " \t\n\r\0\x0B\x0C"): parent
+	{
+		$str = clone $this;
+		$str->string = rtrim($str->string, $chars);
+
+		return $str;
+	}
 
-    public function trimStart(string $chars = " \t\n\r\0\x0B\x0C"): parent
-    {
-        $str = clone $this;
-        $str->string = ltrim($str->string, $chars);
+	public function trimStart(string $chars = " \t\n\r\0\x0B\x0C"): parent
+	{
+		$str = clone $this;
+		$str->string = ltrim($str->string, $chars);
 
-        return $str;
-    }
+		return $str;
+	}
 
-    public function upper(): parent
-    {
-        $str = clone $this;
-        $str->string = strtoupper($str->string);
+	public function upper(): parent
+	{
+		$str = clone $this;
+		$str->string = strtoupper($str->string);
 
-        return $str;
-    }
+		return $str;
+	}
 
-    public function width(bool $ignoreAnsiDecoration = true): int
-    {
-        $string = preg_match('//u', $this->string) ? $this->string : preg_replace('/[\x80-\xFF]/', '?', $this->string);
+	public function width(bool $ignoreAnsiDecoration = true): int
+	{
+		$string = preg_match('//u', $this->string) ? $this->string : preg_replace('/[\x80-\xFF]/', '?', $this->string);
 
-        return (new CodePointString($string))->width($ignoreAnsiDecoration);
-    }
+		return (new CodePointString($string))->width($ignoreAnsiDecoration);
+	}
 }

Spacing +142 added lines, -142 removed lines

@@ -27,7 +27,7 @@ 
 {
     private const ALPHABET_ALPHANUMERIC = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
-    public function __construct(string $string = '')
+    public function __construct( string $string = '' )
     {
         $this->string = $string;
     }
@@ -42,60 +42,60 @@ 
      * Copyright (c) 2004-2020, Facebook, Inc. (https://www.facebook.com/)
      */
 
-    public static function fromRandom(int $length = 16, string $alphabet = null): self
+    public static function fromRandom( int $length = 16, string $alphabet = null ): self
     {
-        if ($length <= 0) {
-            throw new InvalidArgumentException(sprintf('A strictly positive length is expected, "%d" given.', $length));
+        if ( $length <= 0 ) {
+            throw new InvalidArgumentException( sprintf( 'A strictly positive length is expected, "%d" given.', $length ) );
         }
 
         $alphabet = $alphabet ?? self::ALPHABET_ALPHANUMERIC;
-        $alphabetSize = \strlen($alphabet);
-        $bits = (int) ceil(log($alphabetSize, 2.0));
-        if ($bits <= 0 || $bits > 56) {
-            throw new InvalidArgumentException('The length of the alphabet must in the [2^1, 2^56] range.');
+        $alphabetSize = \strlen( $alphabet );
+        $bits = (int)ceil( log( $alphabetSize, 2.0 ) );
+        if ( $bits <= 0 || $bits > 56 ) {
+            throw new InvalidArgumentException( 'The length of the alphabet must in the [2^1, 2^56] range.' );
         }
 
         $ret = '';
-        while ($length > 0) {
-            $urandomLength = (int) ceil(2 * $length * $bits / 8.0);
-            $data = random_bytes($urandomLength);
+        while ( $length > 0 ) {
+            $urandomLength = (int)ceil( 2 * $length * $bits / 8.0 );
+            $data = random_bytes( $urandomLength );
             $unpackedData = 0;
             $unpackedBits = 0;
-            for ($i = 0; $i < $urandomLength && $length > 0; ++$i) {
+            for ( $i = 0; $i < $urandomLength && $length > 0; ++$i ) {
                 // Unpack 8 bits
-                $unpackedData = ($unpackedData << 8) | \ord($data[$i]);
+                $unpackedData = ( $unpackedData << 8 ) | \ord( $data[ $i ] );
                 $unpackedBits += 8;
 
                 // While we have enough bits to select a character from the alphabet, keep
                 // consuming the random data
-                for (; $unpackedBits >= $bits && $length > 0; $unpackedBits -= $bits) {
-                    $index = ($unpackedData & ((1 << $bits) - 1));
+                for ( ; $unpackedBits >= $bits && $length > 0; $unpackedBits -= $bits ) {
+                    $index = ( $unpackedData & ( ( 1 << $bits ) - 1 ) );
                     $unpackedData >>= $bits;
                     // Unfortunately, the alphabet size is not necessarily a power of two.
                     // Worst case, it is 2^k + 1, which means we need (k+1) bits and we
                     // have around a 50% chance of missing as k gets larger
-                    if ($index < $alphabetSize) {
-                        $ret .= $alphabet[$index];
+                    if ( $index < $alphabetSize ) {
+                        $ret .= $alphabet[ $index ];
                         --$length;
                     }
                 }
             }
         }
 
-        return new static($ret);
+        return new static( $ret );
     }
 
-    public function bytesAt(int $offset): array
+    public function bytesAt( int $offset ): array
     {
-        $str = $this->string[$offset] ?? '';
+        $str = $this->string[ $offset ] ?? '';
 
-        return '' === $str ? [] : [\ord($str)];
+        return '' === $str ? [ ] : [ \ord( $str ) ];
     }
 
-    public function append(string ...$suffix): parent
+    public function append( string ...$suffix ): parent
     {
         $str = clone $this;
-        $str->string .= 1 >= \count($suffix) ? ($suffix[0] ?? '') : implode('', $suffix);
+        $str->string .= 1 >= \count( $suffix ) ? ( $suffix[ 0 ] ?? '' ) : implode( '', $suffix );
 
         return $str;
     }
@@ -103,57 +103,57 @@ 
     public function camel(): parent
     {
         $str = clone $this;
-        $str->string = lcfirst(str_replace(' ', '', ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $this->string))));
+        $str->string = lcfirst( str_replace( ' ', '', ucwords( preg_replace( '/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $this->string ) ) ) );
 
         return $str;
     }
 
-    public function chunk(int $length = 1): array
+    public function chunk( int $length = 1 ): array
     {
-        if (1 > $length) {
-            throw new InvalidArgumentException('The chunk length must be greater than zero.');
+        if ( 1 > $length ) {
+            throw new InvalidArgumentException( 'The chunk length must be greater than zero.' );
         }
 
-        if ('' === $this->string) {
-            return [];
+        if ( '' === $this->string ) {
+            return [ ];
         }
 
         $str = clone $this;
-        $chunks = [];
+        $chunks = [ ];
 
-        foreach (str_split($this->string, $length) as $chunk) {
+        foreach ( str_split( $this->string, $length ) as $chunk ) {
             $str->string = $chunk;
-            $chunks[] = clone $str;
+            $chunks[ ] = clone $str;
         }
 
         return $chunks;
     }
 
-    public function endsWith($suffix): bool
+    public function endsWith( $suffix ): bool
     {
-        if ($suffix instanceof parent) {
+        if ( $suffix instanceof parent ) {
             $suffix = $suffix->string;
-        } elseif (\is_array($suffix) || $suffix instanceof \Traversable) {
-            return parent::endsWith($suffix);
+        } elseif ( \is_array( $suffix ) || $suffix instanceof \Traversable ) {
+            return parent::endsWith( $suffix );
         } else {
-            $suffix = (string) $suffix;
+            $suffix = (string)$suffix;
         }
 
-        return '' !== $suffix && \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix), null, $this->ignoreCase);
+        return '' !== $suffix && \strlen( $this->string ) >= \strlen( $suffix ) && 0 === substr_compare( $this->string, $suffix, -\strlen( $suffix ), null, $this->ignoreCase );
     }
 
-    public function equalsTo($string): bool
+    public function equalsTo( $string ): bool
     {
-        if ($string instanceof parent) {
+        if ( $string instanceof parent ) {
             $string = $string->string;
-        } elseif (\is_array($string) || $string instanceof \Traversable) {
-            return parent::equalsTo($string);
+        } elseif ( \is_array( $string ) || $string instanceof \Traversable ) {
+            return parent::equalsTo( $string );
         } else {
-            $string = (string) $string;
+            $string = (string)$string;
         }
 
-        if ('' !== $string && $this->ignoreCase) {
-            return 0 === strcasecmp($string, $this->string);
+        if ( '' !== $string && $this->ignoreCase ) {
+            return 0 === strcasecmp( $string, $this->string );
         }
 
         return $string === $this->string;
@@ -162,98 +162,98 @@ 
     public function folded(): parent
     {
         $str = clone $this;
-        $str->string = strtolower($str->string);
+        $str->string = strtolower( $str->string );
 
         return $str;
     }
 
-    public function indexOf($needle, int $offset = 0): ?int
+    public function indexOf( $needle, int $offset = 0 ): ?int
     {
-        if ($needle instanceof parent) {
+        if ( $needle instanceof parent ) {
             $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
-            return parent::indexOf($needle, $offset);
+        } elseif ( \is_array( $needle ) || $needle instanceof \Traversable ) {
+            return parent::indexOf( $needle, $offset );
         } else {
-            $needle = (string) $needle;
+            $needle = (string)$needle;
         }
 
-        if ('' === $needle) {
+        if ( '' === $needle ) {
             return null;
         }
 
-        $i = $this->ignoreCase ? stripos($this->string, $needle, $offset) : strpos($this->string, $needle, $offset);
+        $i = $this->ignoreCase ? stripos( $this->string, $needle, $offset ) : strpos( $this->string, $needle, $offset );
 
         return false === $i ? null : $i;
     }
 
-    public function indexOfLast($needle, int $offset = 0): ?int
+    public function indexOfLast( $needle, int $offset = 0 ): ?int
     {
-        if ($needle instanceof parent) {
+        if ( $needle instanceof parent ) {
             $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
-            return parent::indexOfLast($needle, $offset);
+        } elseif ( \is_array( $needle ) || $needle instanceof \Traversable ) {
+            return parent::indexOfLast( $needle, $offset );
         } else {
-            $needle = (string) $needle;
+            $needle = (string)$needle;
         }
 
-        if ('' === $needle) {
+        if ( '' === $needle ) {
             return null;
         }
 
-        $i = $this->ignoreCase ? strripos($this->string, $needle, $offset) : strrpos($this->string, $needle, $offset);
+        $i = $this->ignoreCase ? strripos( $this->string, $needle, $offset ) : strrpos( $this->string, $needle, $offset );
 
         return false === $i ? null : $i;
     }
 
     public function isUtf8(): bool
     {
-        return '' === $this->string || preg_match('//u', $this->string);
+        return '' === $this->string || preg_match( '//u', $this->string );
     }
 
-    public function join(array $strings, string $lastGlue = null): parent
+    public function join( array $strings, string $lastGlue = null ): parent
     {
         $str = clone $this;
 
-        $tail = null !== $lastGlue && 1 < \count($strings) ? $lastGlue.array_pop($strings) : '';
-        $str->string = implode($this->string, $strings).$tail;
+        $tail = null !== $lastGlue && 1 < \count( $strings ) ? $lastGlue . array_pop( $strings ) : '';
+        $str->string = implode( $this->string, $strings ) . $tail;
 
         return $str;
     }
 
     public function length(): int
     {
-        return \strlen($this->string);
+        return \strlen( $this->string );
     }
 
     public function lower(): parent
     {
         $str = clone $this;
-        $str->string = strtolower($str->string);
+        $str->string = strtolower( $str->string );
 
         return $str;
     }
 
-    public function match(string $regexp, int $flags = 0, int $offset = 0): array
+    public function match( string $regexp, int $flags = 0, int $offset = 0 ): array
     {
-        $match = ((\PREG_PATTERN_ORDER | \PREG_SET_ORDER) & $flags) ? 'preg_match_all' : 'preg_match';
+        $match = ( ( \PREG_PATTERN_ORDER | \PREG_SET_ORDER ) & $flags ) ? 'preg_match_all' : 'preg_match';
 
-        if ($this->ignoreCase) {
+        if ( $this->ignoreCase ) {
             $regexp .= 'i';
         }
 
-        set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
+        set_error_handler( static function( $t, $m ) { throw new InvalidArgumentException( $m ); });
 
         try {
-            if (false === $match($regexp, $this->string, $matches, $flags | \PREG_UNMATCHED_AS_NULL, $offset)) {
+            if ( false === $match( $regexp, $this->string, $matches, $flags | \PREG_UNMATCHED_AS_NULL, $offset ) ) {
                 $lastError = preg_last_error();
 
-                foreach (get_defined_constants(true)['pcre'] as $k => $v) {
-                    if ($lastError === $v && '_ERROR' === substr($k, -6)) {
-                        throw new RuntimeException('Matching failed with '.$k.'.');
+                foreach ( get_defined_constants( true )[ 'pcre' ] as $k => $v ) {
+                    if ( $lastError === $v && '_ERROR' === substr( $k, -6 ) ) {
+                        throw new RuntimeException( 'Matching failed with ' . $k . '.' );
                     }
                 }
 
-                throw new RuntimeException('Matching failed with unknown error code.');
+                throw new RuntimeException( 'Matching failed with unknown error code.' );
             }
         } finally {
             restore_error_handler();
@@ -262,58 +262,58 @@ 
         return $matches;
     }
 
-    public function padBoth(int $length, string $padStr = ' '): parent
+    public function padBoth( int $length, string $padStr = ' ' ): parent
     {
         $str = clone $this;
-        $str->string = str_pad($this->string, $length, $padStr, \STR_PAD_BOTH);
+        $str->string = str_pad( $this->string, $length, $padStr, \STR_PAD_BOTH );
 
         return $str;
     }
 
-    public function padEnd(int $length, string $padStr = ' '): parent
+    public function padEnd( int $length, string $padStr = ' ' ): parent
     {
         $str = clone $this;
-        $str->string = str_pad($this->string, $length, $padStr, \STR_PAD_RIGHT);
+        $str->string = str_pad( $this->string, $length, $padStr, \STR_PAD_RIGHT );
 
         return $str;
     }
 
-    public function padStart(int $length, string $padStr = ' '): parent
+    public function padStart( int $length, string $padStr = ' ' ): parent
     {
         $str = clone $this;
-        $str->string = str_pad($this->string, $length, $padStr, \STR_PAD_LEFT);
+        $str->string = str_pad( $this->string, $length, $padStr, \STR_PAD_LEFT );
 
         return $str;
     }
 
-    public function prepend(string ...$prefix): parent
+    public function prepend( string ...$prefix ): parent
     {
         $str = clone $this;
-        $str->string = (1 >= \count($prefix) ? ($prefix[0] ?? '') : implode('', $prefix)).$str->string;
+        $str->string = ( 1 >= \count( $prefix ) ? ( $prefix[ 0 ] ?? '' ) : implode( '', $prefix ) ) . $str->string;
 
         return $str;
     }
 
-    public function replace(string $from, string $to): parent
+    public function replace( string $from, string $to ): parent
     {
         $str = clone $this;
 
-        if ('' !== $from) {
-            $str->string = $this->ignoreCase ? str_ireplace($from, $to, $this->string) : str_replace($from, $to, $this->string);
+        if ( '' !== $from ) {
+            $str->string = $this->ignoreCase ? str_ireplace( $from, $to, $this->string ) : str_replace( $from, $to, $this->string );
         }
 
         return $str;
     }
 
-    public function replaceMatches(string $fromRegexp, $to): parent
+    public function replaceMatches( string $fromRegexp, $to ): parent
     {
-        if ($this->ignoreCase) {
+        if ( $this->ignoreCase ) {
             $fromRegexp .= 'i';
         }
 
-        if (\is_array($to)) {
-            if (!\is_callable($to)) {
-                throw new \TypeError(sprintf('Argument 2 passed to "%s::replaceMatches()" must be callable, array given.', static::class));
+        if ( \is_array( $to ) ) {
+            if ( ! \is_callable( $to ) ) {
+                throw new \TypeError( sprintf( 'Argument 2 passed to "%s::replaceMatches()" must be callable, array given.', static::class ) );
             }
 
             $replace = 'preg_replace_callback';
@@ -321,19 +321,19 @@ 
             $replace = $to instanceof \Closure ? 'preg_replace_callback' : 'preg_replace';
         }
 
-        set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
+        set_error_handler( static function( $t, $m ) { throw new InvalidArgumentException( $m ); });
 
         try {
-            if (null === $string = $replace($fromRegexp, $to, $this->string)) {
+            if ( null === $string = $replace( $fromRegexp, $to, $this->string ) ) {
                 $lastError = preg_last_error();
 
-                foreach (get_defined_constants(true)['pcre'] as $k => $v) {
-                    if ($lastError === $v && '_ERROR' === substr($k, -6)) {
-                        throw new RuntimeException('Matching failed with '.$k.'.');
+                foreach ( get_defined_constants( true )[ 'pcre' ] as $k => $v ) {
+                    if ( $lastError === $v && '_ERROR' === substr( $k, -6 ) ) {
+                        throw new RuntimeException( 'Matching failed with ' . $k . '.' );
                     }
                 }
 
-                throw new RuntimeException('Matching failed with unknown error code.');
+                throw new RuntimeException( 'Matching failed with unknown error code.' );
             }
         } finally {
             restore_error_handler();
@@ -348,15 +348,15 @@ 
     public function reverse(): parent
     {
         $str = clone $this;
-        $str->string = strrev($str->string);
+        $str->string = strrev( $str->string );
 
         return $str;
     }
 
-    public function slice(int $start = 0, int $length = null): parent
+    public function slice( int $start = 0, int $length = null ): parent
     {
         $str = clone $this;
-        $str->string = (string) substr($this->string, $start, $length ?? \PHP_INT_MAX);
+        $str->string = (string)substr( $this->string, $start, $length ?? \PHP_INT_MAX );
 
         return $str;
     }
@@ -364,39 +364,39 @@ 
     public function snake(): parent
     {
         $str = $this->camel()->title();
-        $str->string = strtolower(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], '\1_\2', $str->string));
+        $str->string = strtolower( preg_replace( [ '/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/' ], '\1_\2', $str->string ) );
 
         return $str;
     }
 
-    public function splice(string $replacement, int $start = 0, int $length = null): parent
+    public function splice( string $replacement, int $start = 0, int $length = null ): parent
     {
         $str = clone $this;
-        $str->string = substr_replace($this->string, $replacement, $start, $length ?? \PHP_INT_MAX);
+        $str->string = substr_replace( $this->string, $replacement, $start, $length ?? \PHP_INT_MAX );
 
         return $str;
     }
 
-    public function split(string $delimiter, int $limit = null, int $flags = null): array
+    public function split( string $delimiter, int $limit = null, int $flags = null ): array
     {
-        if (1 > $limit = $limit ?? \PHP_INT_MAX) {
-            throw new InvalidArgumentException('Split limit must be a positive integer.');
+        if ( 1 > $limit = $limit ?? \PHP_INT_MAX ) {
+            throw new InvalidArgumentException( 'Split limit must be a positive integer.' );
         }
 
-        if ('' === $delimiter) {
-            throw new InvalidArgumentException('Split delimiter is empty.');
+        if ( '' === $delimiter ) {
+            throw new InvalidArgumentException( 'Split delimiter is empty.' );
         }
 
-        if (null !== $flags) {
-            return parent::split($delimiter, $limit, $flags);
+        if ( null !== $flags ) {
+            return parent::split( $delimiter, $limit, $flags );
         }
 
         $str = clone $this;
         $chunks = $this->ignoreCase
-            ? preg_split('{'.preg_quote($delimiter).'}iD', $this->string, $limit)
-            : explode($delimiter, $this->string, $limit);
+            ? preg_split( '{' . preg_quote( $delimiter ) . '}iD', $this->string, $limit )
+            : explode( $delimiter, $this->string, $limit );
 
-        foreach ($chunks as &$chunk) {
+        foreach ( $chunks as &$chunk ) {
             $str->string = $chunk;
             $chunk = clone $str;
         }
@@ -404,51 +404,51 @@ 
         return $chunks;
     }
 
-    public function startsWith($prefix): bool
+    public function startsWith( $prefix ): bool
     {
-        if ($prefix instanceof parent) {
+        if ( $prefix instanceof parent ) {
             $prefix = $prefix->string;
-        } elseif (!\is_string($prefix)) {
-            return parent::startsWith($prefix);
+        } elseif ( ! \is_string( $prefix ) ) {
+            return parent::startsWith( $prefix );
         }
 
-        return '' !== $prefix && 0 === ($this->ignoreCase ? strncasecmp($this->string, $prefix, \strlen($prefix)) : strncmp($this->string, $prefix, \strlen($prefix)));
+        return '' !== $prefix && 0 === ( $this->ignoreCase ? strncasecmp( $this->string, $prefix, \strlen( $prefix ) ) : strncmp( $this->string, $prefix, \strlen( $prefix ) ) );
     }
 
-    public function title(bool $allWords = false): parent
+    public function title( bool $allWords = false ): parent
     {
         $str = clone $this;
-        $str->string = $allWords ? ucwords($str->string) : ucfirst($str->string);
+        $str->string = $allWords ? ucwords( $str->string ) : ucfirst( $str->string );
 
         return $str;
     }
 
-    public function toUnicodeString(string $fromEncoding = null): UnicodeString
+    public function toUnicodeString( string $fromEncoding = null ): UnicodeString
     {
-        return new UnicodeString($this->toCodePointString($fromEncoding)->string);
+        return new UnicodeString( $this->toCodePointString( $fromEncoding )->string );
     }
 
-    public function toCodePointString(string $fromEncoding = null): CodePointString
+    public function toCodePointString( string $fromEncoding = null ): CodePointString
     {
         $u = new CodePointString();
 
-        if (\in_array($fromEncoding, [null, 'utf8', 'utf-8', 'UTF8', 'UTF-8'], true) && preg_match('//u', $this->string)) {
+        if ( \in_array( $fromEncoding, [ null, 'utf8', 'utf-8', 'UTF8', 'UTF-8' ], true ) && preg_match( '//u', $this->string ) ) {
             $u->string = $this->string;
 
             return $u;
         }
 
-        set_error_handler(static function ($t, $m) { throw new InvalidArgumentException($m); });
+        set_error_handler( static function( $t, $m ) { throw new InvalidArgumentException( $m ); });
 
         try {
             try {
-                $validEncoding = false !== mb_detect_encoding($this->string, $fromEncoding ?? 'Windows-1252', true);
-            } catch (InvalidArgumentException $e) {
-                if (!\function_exists('iconv')) {
+                $validEncoding = false !== mb_detect_encoding( $this->string, $fromEncoding ?? 'Windows-1252', true );
+            } catch ( InvalidArgumentException $e ) {
+                if ( ! \function_exists( 'iconv' ) ) {
                     throw $e;
                 }
 
-                $u->string = iconv($fromEncoding ?? 'Windows-1252', 'UTF-8', $this->string);
+                $u->string = iconv( $fromEncoding ?? 'Windows-1252', 'UTF-8', $this->string );
 
                 return $u;
             }
@@ -456,35 +456,35 @@ 
             restore_error_handler();
         }
 
-        if (!$validEncoding) {
-            throw new InvalidArgumentException(sprintf('Invalid "%s" string.', $fromEncoding ?? 'Windows-1252'));
+        if ( ! $validEncoding ) {
+            throw new InvalidArgumentException( sprintf( 'Invalid "%s" string.', $fromEncoding ?? 'Windows-1252' ) );
         }
 
-        $u->string = mb_convert_encoding($this->string, 'UTF-8', $fromEncoding ?? 'Windows-1252');
+        $u->string = mb_convert_encoding( $this->string, 'UTF-8', $fromEncoding ?? 'Windows-1252' );
 
         return $u;
     }
 
-    public function trim(string $chars = " \t\n\r\0\x0B\x0C"): parent
+    public function trim( string $chars = " \t\n\r\0\x0B\x0C" ): parent
     {
         $str = clone $this;
-        $str->string = trim($str->string, $chars);
+        $str->string = trim( $str->string, $chars );
 
         return $str;
     }
 
-    public function trimEnd(string $chars = " \t\n\r\0\x0B\x0C"): parent
+    public function trimEnd( string $chars = " \t\n\r\0\x0B\x0C" ): parent
     {
         $str = clone $this;
-        $str->string = rtrim($str->string, $chars);
+        $str->string = rtrim( $str->string, $chars );
 
         return $str;
     }
 
-    public function trimStart(string $chars = " \t\n\r\0\x0B\x0C"): parent
+    public function trimStart( string $chars = " \t\n\r\0\x0B\x0C" ): parent
     {
         $str = clone $this;
-        $str->string = ltrim($str->string, $chars);
+        $str->string = ltrim( $str->string, $chars );
 
         return $str;
     }
@@ -492,15 +492,15 @@ 
     public function upper(): parent
     {
         $str = clone $this;
-        $str->string = strtoupper($str->string);
+        $str->string = strtoupper( $str->string );
 
         return $str;
     }
 
-    public function width(bool $ignoreAnsiDecoration = true): int
+    public function width( bool $ignoreAnsiDecoration = true ): int
     {
-        $string = preg_match('//u', $this->string) ? $this->string : preg_replace('/[\x80-\xFF]/', '?', $this->string);
+        $string = preg_match( '//u', $this->string ) ? $this->string : preg_replace( '/[\x80-\xFF]/', '?', $this->string );
 
-        return (new CodePointString($string))->width($ignoreAnsiDecoration);
+        return ( new CodePointString( $string ) )->width( $ignoreAnsiDecoration );
     }
 }

Braces +2 added lines, -4 removed lines

@@ -23,12 +23,10 @@
  *
  * @throws ExceptionInterface
  */
-class ByteString extends AbstractString
-{
+class ByteString extends AbstractString {
     private const ALPHABET_ALPHANUMERIC = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
-    public function __construct(string $string = '')
-    {
+    public function __construct(string $string = '') {
         $this->string = $string;
     }
 

vendor/symfony/string/Inflector/FrenchInflector.php

Indentation +136 added lines, -136 removed lines

@@ -18,140 +18,140 @@
  */
 final class FrenchInflector implements InflectorInterface
 {
-    /**
-     * A list of all rules for pluralise.
-     *
-     * @see https://la-conjugaison.nouvelobs.com/regles/grammaire/le-pluriel-des-noms-121.php
-     */
-    private const PLURALIZE_REGEXP = [
-        // First entry: regexp
-        // Second entry: replacement
-
-        // Words finishing with "s", "x" or "z" are invariables
-        // Les mots finissant par "s", "x" ou "z" sont invariables
-        ['/(s|x|z)$/i', '\1'],
-
-        // Words finishing with "eau" are pluralized with a "x"
-        // Les mots finissant par "eau" prennent tous un "x" au pluriel
-        ['/(eau)$/i', '\1x'],
-
-        // Words finishing with "au" are pluralized with a "x" excepted "landau"
-        // Les mots finissant par "au" prennent un "x" au pluriel sauf "landau"
-        ['/^(landau)$/i', '\1s'],
-        ['/(au)$/i', '\1x'],
-
-        // Words finishing with "eu" are pluralized with a "x" excepted "pneu", "bleu", "émeu"
-        // Les mots finissant en "eu" prennent un "x" au pluriel sauf "pneu", "bleu", "émeu"
-        ['/^(pneu|bleu|émeu)$/i', '\1s'],
-        ['/(eu)$/i', '\1x'],
-
-        // Words finishing with "al" are pluralized with a "aux" excepted
-        // Les mots finissant en "al" se terminent en "aux" sauf
-        ['/^(bal|carnaval|caracal|chacal|choral|corral|étal|festival|récital|val)$/i', '\1s'],
-        ['/al$/i', '\1aux'],
-
-        // Aspirail, bail, corail, émail, fermail, soupirail, travail, vantail et vitrail font leur pluriel en -aux
-        ['/^(aspir|b|cor|ém|ferm|soupir|trav|vant|vitr)ail$/i', '\1aux'],
-
-        // Bijou, caillou, chou, genou, hibou, joujou et pou qui prennent un x au pluriel
-        ['/^(bij|caill|ch|gen|hib|jouj|p)ou$/i', '\1oux'],
-
-        // Invariable words
-        ['/^(cinquante|soixante|mille)$/i', '\1'],
-
-        // French titles
-        ['/^(mon|ma)(sieur|dame|demoiselle|seigneur)$/', 'mes\2s'],
-        ['/^(Mon|Ma)(sieur|dame|demoiselle|seigneur)$/', 'Mes\2s'],
-    ];
-
-    /**
-     * A list of all rules for singularize.
-     */
-    private const SINGULARIZE_REGEXP = [
-        // First entry: regexp
-        // Second entry: replacement
-
-        // Aspirail, bail, corail, émail, fermail, soupirail, travail, vantail et vitrail font leur pluriel en -aux
-        ['/((aspir|b|cor|ém|ferm|soupir|trav|vant|vitr))aux$/i', '\1ail'],
-
-        // Words finishing with "eau" are pluralized with a "x"
-        // Les mots finissant par "eau" prennent tous un "x" au pluriel
-        ['/(eau)x$/i', '\1'],
-
-        // Words finishing with "al" are pluralized with a "aux" expected
-        // Les mots finissant en "al" se terminent en "aux" sauf
-        ['/(amir|anim|arsen|boc|can|capit|capor|chev|crist|génér|hopit|hôpit|idé|journ|littor|loc|m|mét|minér|princip|radic|termin)aux$/i', '\1al'],
-
-        // Words finishing with "au" are pluralized with a "x" excepted "landau"
-        // Les mots finissant par "au" prennent un "x" au pluriel sauf "landau"
-        ['/(au)x$/i', '\1'],
-
-        // Words finishing with "eu" are pluralized with a "x" excepted "pneu", "bleu", "émeu"
-        // Les mots finissant en "eu" prennent un "x" au pluriel sauf "pneu", "bleu", "émeu"
-        ['/(eu)x$/i', '\1'],
-
-        //  Words finishing with "ou" are pluralized with a "s" excepted bijou, caillou, chou, genou, hibou, joujou, pou
-        // Les mots finissant par "ou" prennent un "s" sauf bijou, caillou, chou, genou, hibou, joujou, pou
-        ['/(bij|caill|ch|gen|hib|jouj|p)oux$/i', '\1ou'],
-
-        // French titles
-        ['/^mes(dame|demoiselle)s$/', 'ma\1'],
-        ['/^Mes(dame|demoiselle)s$/', 'Ma\1'],
-        ['/^mes(sieur|seigneur)s$/', 'mon\1'],
-        ['/^Mes(sieur|seigneur)s$/', 'Mon\1'],
-
-        //Default rule
-        ['/s$/i', ''],
-    ];
-
-    /**
-     * A list of words which should not be inflected.
-     * This list is only used by singularize.
-     */
-    private const UNINFLECTED = '/^(abcès|accès|abus|albatros|anchois|anglais|autobus|bois|brebis|carquois|cas|chas|colis|concours|corps|cours|cyprès|décès|devis|discours|dos|embarras|engrais|entrelacs|excès|fils|fois|gâchis|gars|glas|héros|intrus|jars|jus|kermès|lacis|legs|lilas|marais|mars|matelas|mépris|mets|mois|mors|obus|os|palais|paradis|parcours|pardessus|pays|plusieurs|poids|pois|pouls|printemps|processus|progrès|puits|pus|rabais|radis|recors|recours|refus|relais|remords|remous|rictus|rhinocéros|repas|rubis|sas|secours|sens|souris|succès|talus|tapis|tas|taudis|temps|tiers|univers|velours|verglas|vernis|virus)$/i';
-
-    /**
-     * {@inheritdoc}
-     */
-    public function singularize(string $plural): array
-    {
-        if ($this->isInflectedWord($plural)) {
-            return [$plural];
-        }
-
-        foreach (self::SINGULARIZE_REGEXP as $rule) {
-            [$regexp, $replace] = $rule;
-
-            if (1 === preg_match($regexp, $plural)) {
-                return [preg_replace($regexp, $replace, $plural)];
-            }
-        }
-
-        return [$plural];
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function pluralize(string $singular): array
-    {
-        if ($this->isInflectedWord($singular)) {
-            return [$singular];
-        }
-
-        foreach (self::PLURALIZE_REGEXP as $rule) {
-            [$regexp, $replace] = $rule;
-
-            if (1 === preg_match($regexp, $singular)) {
-                return [preg_replace($regexp, $replace, $singular)];
-            }
-        }
-
-        return [$singular.'s'];
-    }
-
-    private function isInflectedWord(string $word): bool
-    {
-        return 1 === preg_match(self::UNINFLECTED, $word);
-    }
+	/**
+	 * A list of all rules for pluralise.
+	 *
+	 * @see https://la-conjugaison.nouvelobs.com/regles/grammaire/le-pluriel-des-noms-121.php
+	 */
+	private const PLURALIZE_REGEXP = [
+		// First entry: regexp
+		// Second entry: replacement
+
+		// Words finishing with "s", "x" or "z" are invariables
+		// Les mots finissant par "s", "x" ou "z" sont invariables
+		['/(s|x|z)$/i', '\1'],
+
+		// Words finishing with "eau" are pluralized with a "x"
+		// Les mots finissant par "eau" prennent tous un "x" au pluriel
+		['/(eau)$/i', '\1x'],
+
+		// Words finishing with "au" are pluralized with a "x" excepted "landau"
+		// Les mots finissant par "au" prennent un "x" au pluriel sauf "landau"
+		['/^(landau)$/i', '\1s'],
+		['/(au)$/i', '\1x'],
+
+		// Words finishing with "eu" are pluralized with a "x" excepted "pneu", "bleu", "émeu"
+		// Les mots finissant en "eu" prennent un "x" au pluriel sauf "pneu", "bleu", "émeu"
+		['/^(pneu|bleu|émeu)$/i', '\1s'],
+		['/(eu)$/i', '\1x'],
+
+		// Words finishing with "al" are pluralized with a "aux" excepted
+		// Les mots finissant en "al" se terminent en "aux" sauf
+		['/^(bal|carnaval|caracal|chacal|choral|corral|étal|festival|récital|val)$/i', '\1s'],
+		['/al$/i', '\1aux'],
+
+		// Aspirail, bail, corail, émail, fermail, soupirail, travail, vantail et vitrail font leur pluriel en -aux
+		['/^(aspir|b|cor|ém|ferm|soupir|trav|vant|vitr)ail$/i', '\1aux'],
+
+		// Bijou, caillou, chou, genou, hibou, joujou et pou qui prennent un x au pluriel
+		['/^(bij|caill|ch|gen|hib|jouj|p)ou$/i', '\1oux'],
+
+		// Invariable words
+		['/^(cinquante|soixante|mille)$/i', '\1'],
+
+		// French titles
+		['/^(mon|ma)(sieur|dame|demoiselle|seigneur)$/', 'mes\2s'],
+		['/^(Mon|Ma)(sieur|dame|demoiselle|seigneur)$/', 'Mes\2s'],
+	];
+
+	/**
+	 * A list of all rules for singularize.
+	 */
+	private const SINGULARIZE_REGEXP = [
+		// First entry: regexp
+		// Second entry: replacement
+
+		// Aspirail, bail, corail, émail, fermail, soupirail, travail, vantail et vitrail font leur pluriel en -aux
+		['/((aspir|b|cor|ém|ferm|soupir|trav|vant|vitr))aux$/i', '\1ail'],
+
+		// Words finishing with "eau" are pluralized with a "x"
+		// Les mots finissant par "eau" prennent tous un "x" au pluriel
+		['/(eau)x$/i', '\1'],
+
+		// Words finishing with "al" are pluralized with a "aux" expected
+		// Les mots finissant en "al" se terminent en "aux" sauf
+		['/(amir|anim|arsen|boc|can|capit|capor|chev|crist|génér|hopit|hôpit|idé|journ|littor|loc|m|mét|minér|princip|radic|termin)aux$/i', '\1al'],
+
+		// Words finishing with "au" are pluralized with a "x" excepted "landau"
+		// Les mots finissant par "au" prennent un "x" au pluriel sauf "landau"
+		['/(au)x$/i', '\1'],
+
+		// Words finishing with "eu" are pluralized with a "x" excepted "pneu", "bleu", "émeu"
+		// Les mots finissant en "eu" prennent un "x" au pluriel sauf "pneu", "bleu", "émeu"
+		['/(eu)x$/i', '\1'],
+
+		//  Words finishing with "ou" are pluralized with a "s" excepted bijou, caillou, chou, genou, hibou, joujou, pou
+		// Les mots finissant par "ou" prennent un "s" sauf bijou, caillou, chou, genou, hibou, joujou, pou
+		['/(bij|caill|ch|gen|hib|jouj|p)oux$/i', '\1ou'],
+
+		// French titles
+		['/^mes(dame|demoiselle)s$/', 'ma\1'],
+		['/^Mes(dame|demoiselle)s$/', 'Ma\1'],
+		['/^mes(sieur|seigneur)s$/', 'mon\1'],
+		['/^Mes(sieur|seigneur)s$/', 'Mon\1'],
+
+		//Default rule
+		['/s$/i', ''],
+	];
+
+	/**
+	 * A list of words which should not be inflected.
+	 * This list is only used by singularize.
+	 */
+	private const UNINFLECTED = '/^(abcès|accès|abus|albatros|anchois|anglais|autobus|bois|brebis|carquois|cas|chas|colis|concours|corps|cours|cyprès|décès|devis|discours|dos|embarras|engrais|entrelacs|excès|fils|fois|gâchis|gars|glas|héros|intrus|jars|jus|kermès|lacis|legs|lilas|marais|mars|matelas|mépris|mets|mois|mors|obus|os|palais|paradis|parcours|pardessus|pays|plusieurs|poids|pois|pouls|printemps|processus|progrès|puits|pus|rabais|radis|recors|recours|refus|relais|remords|remous|rictus|rhinocéros|repas|rubis|sas|secours|sens|souris|succès|talus|tapis|tas|taudis|temps|tiers|univers|velours|verglas|vernis|virus)$/i';
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function singularize(string $plural): array
+	{
+		if ($this->isInflectedWord($plural)) {
+			return [$plural];
+		}
+
+		foreach (self::SINGULARIZE_REGEXP as $rule) {
+			[$regexp, $replace] = $rule;
+
+			if (1 === preg_match($regexp, $plural)) {
+				return [preg_replace($regexp, $replace, $plural)];
+			}
+		}
+
+		return [$plural];
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function pluralize(string $singular): array
+	{
+		if ($this->isInflectedWord($singular)) {
+			return [$singular];
+		}
+
+		foreach (self::PLURALIZE_REGEXP as $rule) {
+			[$regexp, $replace] = $rule;
+
+			if (1 === preg_match($regexp, $singular)) {
+				return [preg_replace($regexp, $replace, $singular)];
+			}
+		}
+
+		return [$singular.'s'];
+	}
+
+	private function isInflectedWord(string $word): bool
+	{
+		return 1 === preg_match(self::UNINFLECTED, $word);
+	}
 }

Spacing +42 added lines, -42 removed lines

@@ -29,39 +29,39 @@ 
 
         // Words finishing with "s", "x" or "z" are invariables
         // Les mots finissant par "s", "x" ou "z" sont invariables
-        ['/(s|x|z)$/i', '\1'],
+        [ '/(s|x|z)$/i', '\1' ],
 
         // Words finishing with "eau" are pluralized with a "x"
         // Les mots finissant par "eau" prennent tous un "x" au pluriel
-        ['/(eau)$/i', '\1x'],
+        [ '/(eau)$/i', '\1x' ],
 
         // Words finishing with "au" are pluralized with a "x" excepted "landau"
         // Les mots finissant par "au" prennent un "x" au pluriel sauf "landau"
-        ['/^(landau)$/i', '\1s'],
-        ['/(au)$/i', '\1x'],
+        [ '/^(landau)$/i', '\1s' ],
+        [ '/(au)$/i', '\1x' ],
 
         // Words finishing with "eu" are pluralized with a "x" excepted "pneu", "bleu", "émeu"
         // Les mots finissant en "eu" prennent un "x" au pluriel sauf "pneu", "bleu", "émeu"
-        ['/^(pneu|bleu|émeu)$/i', '\1s'],
-        ['/(eu)$/i', '\1x'],
+        [ '/^(pneu|bleu|émeu)$/i', '\1s' ],
+        [ '/(eu)$/i', '\1x' ],
 
         // Words finishing with "al" are pluralized with a "aux" excepted
         // Les mots finissant en "al" se terminent en "aux" sauf
-        ['/^(bal|carnaval|caracal|chacal|choral|corral|étal|festival|récital|val)$/i', '\1s'],
-        ['/al$/i', '\1aux'],
+        [ '/^(bal|carnaval|caracal|chacal|choral|corral|étal|festival|récital|val)$/i', '\1s' ],
+        [ '/al$/i', '\1aux' ],
 
         // Aspirail, bail, corail, émail, fermail, soupirail, travail, vantail et vitrail font leur pluriel en -aux
-        ['/^(aspir|b|cor|ém|ferm|soupir|trav|vant|vitr)ail$/i', '\1aux'],
+        [ '/^(aspir|b|cor|ém|ferm|soupir|trav|vant|vitr)ail$/i', '\1aux' ],
 
         // Bijou, caillou, chou, genou, hibou, joujou et pou qui prennent un x au pluriel
-        ['/^(bij|caill|ch|gen|hib|jouj|p)ou$/i', '\1oux'],
+        [ '/^(bij|caill|ch|gen|hib|jouj|p)ou$/i', '\1oux' ],
 
         // Invariable words
-        ['/^(cinquante|soixante|mille)$/i', '\1'],
+        [ '/^(cinquante|soixante|mille)$/i', '\1' ],
 
         // French titles
-        ['/^(mon|ma)(sieur|dame|demoiselle|seigneur)$/', 'mes\2s'],
-        ['/^(Mon|Ma)(sieur|dame|demoiselle|seigneur)$/', 'Mes\2s'],
+        [ '/^(mon|ma)(sieur|dame|demoiselle|seigneur)$/', 'mes\2s' ],
+        [ '/^(Mon|Ma)(sieur|dame|demoiselle|seigneur)$/', 'Mes\2s' ],
     ];
 
     /**
@@ -72,36 +72,36 @@ 
         // Second entry: replacement
 
         // Aspirail, bail, corail, émail, fermail, soupirail, travail, vantail et vitrail font leur pluriel en -aux
-        ['/((aspir|b|cor|ém|ferm|soupir|trav|vant|vitr))aux$/i', '\1ail'],
+        [ '/((aspir|b|cor|ém|ferm|soupir|trav|vant|vitr))aux$/i', '\1ail' ],
 
         // Words finishing with "eau" are pluralized with a "x"
         // Les mots finissant par "eau" prennent tous un "x" au pluriel
-        ['/(eau)x$/i', '\1'],
+        [ '/(eau)x$/i', '\1' ],
 
         // Words finishing with "al" are pluralized with a "aux" expected
         // Les mots finissant en "al" se terminent en "aux" sauf
-        ['/(amir|anim|arsen|boc|can|capit|capor|chev|crist|génér|hopit|hôpit|idé|journ|littor|loc|m|mét|minér|princip|radic|termin)aux$/i', '\1al'],
+        [ '/(amir|anim|arsen|boc|can|capit|capor|chev|crist|génér|hopit|hôpit|idé|journ|littor|loc|m|mét|minér|princip|radic|termin)aux$/i', '\1al' ],
 
         // Words finishing with "au" are pluralized with a "x" excepted "landau"
         // Les mots finissant par "au" prennent un "x" au pluriel sauf "landau"
-        ['/(au)x$/i', '\1'],
+        [ '/(au)x$/i', '\1' ],
 
         // Words finishing with "eu" are pluralized with a "x" excepted "pneu", "bleu", "émeu"
         // Les mots finissant en "eu" prennent un "x" au pluriel sauf "pneu", "bleu", "émeu"
-        ['/(eu)x$/i', '\1'],
+        [ '/(eu)x$/i', '\1' ],
 
         //  Words finishing with "ou" are pluralized with a "s" excepted bijou, caillou, chou, genou, hibou, joujou, pou
         // Les mots finissant par "ou" prennent un "s" sauf bijou, caillou, chou, genou, hibou, joujou, pou
-        ['/(bij|caill|ch|gen|hib|jouj|p)oux$/i', '\1ou'],
+        [ '/(bij|caill|ch|gen|hib|jouj|p)oux$/i', '\1ou' ],
 
         // French titles
-        ['/^mes(dame|demoiselle)s$/', 'ma\1'],
-        ['/^Mes(dame|demoiselle)s$/', 'Ma\1'],
-        ['/^mes(sieur|seigneur)s$/', 'mon\1'],
-        ['/^Mes(sieur|seigneur)s$/', 'Mon\1'],
+        [ '/^mes(dame|demoiselle)s$/', 'ma\1' ],
+        [ '/^Mes(dame|demoiselle)s$/', 'Ma\1' ],
+        [ '/^mes(sieur|seigneur)s$/', 'mon\1' ],
+        [ '/^Mes(sieur|seigneur)s$/', 'Mon\1' ],
 
         //Default rule
-        ['/s$/i', ''],
+        [ '/s$/i', '' ],
     ];
 
     /**
@@ -113,45 +113,45 @@ 
     /**
      * {@inheritdoc}
      */
-    public function singularize(string $plural): array
+    public function singularize( string $plural ): array
     {
-        if ($this->isInflectedWord($plural)) {
-            return [$plural];
+        if ( $this->isInflectedWord( $plural ) ) {
+            return [ $plural ];
         }
 
-        foreach (self::SINGULARIZE_REGEXP as $rule) {
-            [$regexp, $replace] = $rule;
+        foreach ( self::SINGULARIZE_REGEXP as $rule ) {
+            [ $regexp, $replace ] = $rule;
 
-            if (1 === preg_match($regexp, $plural)) {
-                return [preg_replace($regexp, $replace, $plural)];
+            if ( 1 === preg_match( $regexp, $plural ) ) {
+                return [ preg_replace( $regexp, $replace, $plural ) ];
             }
         }
 
-        return [$plural];
+        return [ $plural ];
     }
 
     /**
      * {@inheritdoc}
      */
-    public function pluralize(string $singular): array
+    public function pluralize( string $singular ): array
     {
-        if ($this->isInflectedWord($singular)) {
-            return [$singular];
+        if ( $this->isInflectedWord( $singular ) ) {
+            return [ $singular ];
         }
 
-        foreach (self::PLURALIZE_REGEXP as $rule) {
-            [$regexp, $replace] = $rule;
+        foreach ( self::PLURALIZE_REGEXP as $rule ) {
+            [ $regexp, $replace ] = $rule;
 
-            if (1 === preg_match($regexp, $singular)) {
-                return [preg_replace($regexp, $replace, $singular)];
+            if ( 1 === preg_match( $regexp, $singular ) ) {
+                return [ preg_replace( $regexp, $replace, $singular ) ];
             }
         }
 
-        return [$singular.'s'];
+        return [ $singular . 's' ];
     }
 
-    private function isInflectedWord(string $word): bool
+    private function isInflectedWord( string $word ): bool
     {
-        return 1 === preg_match(self::UNINFLECTED, $word);
+        return 1 === preg_match( self::UNINFLECTED, $word );
     }
 }

Braces +1 added lines, -2 removed lines

@@ -16,8 +16,7 @@
  *
  * This class does only inflect nouns; not adjectives nor composed words like "soixante-dix".
  */
-final class FrenchInflector implements InflectorInterface
-{
+final class FrenchInflector implements InflectorInterface {
     /**
      * A list of all rules for pluralise.
      *

vendor/symfony/string/Inflector/InflectorInterface.php

Indentation +16 added lines, -16 removed lines

@@ -13,21 +13,21 @@
 
 interface InflectorInterface
 {
-    /**
-     * Returns the singular forms of a string.
-     *
-     * If the method can't determine the form with certainty, several possible singulars are returned.
-     *
-     * @return string[] An array of possible singular forms
-     */
-    public function singularize(string $plural): array;
+	/**
+	 * Returns the singular forms of a string.
+	 *
+	 * If the method can't determine the form with certainty, several possible singulars are returned.
+	 *
+	 * @return string[] An array of possible singular forms
+	 */
+	public function singularize(string $plural): array;
 
-    /**
-     * Returns the plural forms of a string.
-     *
-     * If the method can't determine the form with certainty, several possible plurals are returned.
-     *
-     * @return string[] An array of possible plural forms
-     */
-    public function pluralize(string $singular): array;
+	/**
+	 * Returns the plural forms of a string.
+	 *
+	 * If the method can't determine the form with certainty, several possible plurals are returned.
+	 *
+	 * @return string[] An array of possible plural forms
+	 */
+	public function pluralize(string $singular): array;
 }

Spacing +2 added lines, -2 removed lines

@@ -20,7 +20,7 @@ 
      *
      * @return string[] An array of possible singular forms
      */
-    public function singularize(string $plural): array;
+    public function singularize( string $plural ): array;
 
     /**
      * Returns the plural forms of a string.
@@ -29,5 +29,5 @@ 
      *
      * @return string[] An array of possible plural forms
      */
-    public function pluralize(string $singular): array;
+    public function pluralize( string $singular ): array;
 }

Braces +1 added lines, -2 removed lines

@@ -11,8 +11,7 @@
 
 namespace Symfony\Component\String\Inflector;
 
-interface InflectorInterface
-{
+interface InflectorInterface {
     /**
      * Returns the singular forms of a string.
      *

vendor/symfony/string/Inflector/EnglishInflector.php

Indentation +392 added lines, -392 removed lines

@@ -13,496 +13,496 @@
 
 final class EnglishInflector implements InflectorInterface
 {
-    /**
-     * Map English plural to singular suffixes.
-     *
-     * @see http://english-zone.com/spelling/plurals.html
-     */
-    private const PLURAL_MAP = [
-        // First entry: plural suffix, reversed
-        // Second entry: length of plural suffix
-        // Third entry: Whether the suffix may succeed a vocal
-        // Fourth entry: Whether the suffix may succeed a consonant
-        // Fifth entry: singular suffix, normal
+	/**
+	 * Map English plural to singular suffixes.
+	 *
+	 * @see http://english-zone.com/spelling/plurals.html
+	 */
+	private const PLURAL_MAP = [
+		// First entry: plural suffix, reversed
+		// Second entry: length of plural suffix
+		// Third entry: Whether the suffix may succeed a vocal
+		// Fourth entry: Whether the suffix may succeed a consonant
+		// Fifth entry: singular suffix, normal
 
-        // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['a', 1, true, true, ['on', 'um']],
+		// bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
+		['a', 1, true, true, ['on', 'um']],
 
-        // nebulae (nebula)
-        ['ea', 2, true, true, 'a'],
+		// nebulae (nebula)
+		['ea', 2, true, true, 'a'],
 
-        // services (service)
-        ['secivres', 8, true, true, 'service'],
+		// services (service)
+		['secivres', 8, true, true, 'service'],
 
-        // mice (mouse), lice (louse)
-        ['eci', 3, false, true, 'ouse'],
+		// mice (mouse), lice (louse)
+		['eci', 3, false, true, 'ouse'],
 
-        // geese (goose)
-        ['esee', 4, false, true, 'oose'],
+		// geese (goose)
+		['esee', 4, false, true, 'oose'],
 
-        // fungi (fungus), alumni (alumnus), syllabi (syllabus), radii (radius)
-        ['i', 1, true, true, 'us'],
+		// fungi (fungus), alumni (alumnus), syllabi (syllabus), radii (radius)
+		['i', 1, true, true, 'us'],
 
-        // men (man), women (woman)
-        ['nem', 3, true, true, 'man'],
+		// men (man), women (woman)
+		['nem', 3, true, true, 'man'],
 
-        // children (child)
-        ['nerdlihc', 8, true, true, 'child'],
+		// children (child)
+		['nerdlihc', 8, true, true, 'child'],
 
-        // oxen (ox)
-        ['nexo', 4, false, false, 'ox'],
+		// oxen (ox)
+		['nexo', 4, false, false, 'ox'],
 
-        // indices (index), appendices (appendix), prices (price)
-        ['seci', 4, false, true, ['ex', 'ix', 'ice']],
+		// indices (index), appendices (appendix), prices (price)
+		['seci', 4, false, true, ['ex', 'ix', 'ice']],
 
-        // selfies (selfie)
-        ['seifles', 7, true, true, 'selfie'],
+		// selfies (selfie)
+		['seifles', 7, true, true, 'selfie'],
 
-        // movies (movie)
-        ['seivom', 6, true, true, 'movie'],
+		// movies (movie)
+		['seivom', 6, true, true, 'movie'],
 
-        // conspectuses (conspectus), prospectuses (prospectus)
-        ['sesutcep', 8, true, true, 'pectus'],
+		// conspectuses (conspectus), prospectuses (prospectus)
+		['sesutcep', 8, true, true, 'pectus'],
 
-        // feet (foot)
-        ['teef', 4, true, true, 'foot'],
+		// feet (foot)
+		['teef', 4, true, true, 'foot'],
 
-        // geese (goose)
-        ['eseeg', 5, true, true, 'goose'],
+		// geese (goose)
+		['eseeg', 5, true, true, 'goose'],
 
-        // teeth (tooth)
-        ['hteet', 5, true, true, 'tooth'],
+		// teeth (tooth)
+		['hteet', 5, true, true, 'tooth'],
 
-        // news (news)
-        ['swen', 4, true, true, 'news'],
+		// news (news)
+		['swen', 4, true, true, 'news'],
 
-        // series (series)
-        ['seires', 6, true, true, 'series'],
+		// series (series)
+		['seires', 6, true, true, 'series'],
 
-        // babies (baby)
-        ['sei', 3, false, true, 'y'],
+		// babies (baby)
+		['sei', 3, false, true, 'y'],
 
-        // accesses (access), addresses (address), kisses (kiss)
-        ['sess', 4, true, false, 'ss'],
+		// accesses (access), addresses (address), kisses (kiss)
+		['sess', 4, true, false, 'ss'],
 
-        // analyses (analysis), ellipses (ellipsis), fungi (fungus),
-        // neuroses (neurosis), theses (thesis), emphases (emphasis),
-        // oases (oasis), crises (crisis), houses (house), bases (base),
-        // atlases (atlas)
-        ['ses', 3, true, true, ['s', 'se', 'sis']],
+		// analyses (analysis), ellipses (ellipsis), fungi (fungus),
+		// neuroses (neurosis), theses (thesis), emphases (emphasis),
+		// oases (oasis), crises (crisis), houses (house), bases (base),
+		// atlases (atlas)
+		['ses', 3, true, true, ['s', 'se', 'sis']],
 
-        // objectives (objective), alternative (alternatives)
-        ['sevit', 5, true, true, 'tive'],
+		// objectives (objective), alternative (alternatives)
+		['sevit', 5, true, true, 'tive'],
 
-        // drives (drive)
-        ['sevird', 6, false, true, 'drive'],
+		// drives (drive)
+		['sevird', 6, false, true, 'drive'],
 
-        // lives (life), wives (wife)
-        ['sevi', 4, false, true, 'ife'],
+		// lives (life), wives (wife)
+		['sevi', 4, false, true, 'ife'],
 
-        // moves (move)
-        ['sevom', 5, true, true, 'move'],
+		// moves (move)
+		['sevom', 5, true, true, 'move'],
 
-        // hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf), caves (cave), staves (staff)
-        ['sev', 3, true, true, ['f', 've', 'ff']],
+		// hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf), caves (cave), staves (staff)
+		['sev', 3, true, true, ['f', 've', 'ff']],
 
-        // axes (axis), axes (ax), axes (axe)
-        ['sexa', 4, false, false, ['ax', 'axe', 'axis']],
+		// axes (axis), axes (ax), axes (axe)
+		['sexa', 4, false, false, ['ax', 'axe', 'axis']],
 
-        // indexes (index), matrixes (matrix)
-        ['sex', 3, true, false, 'x'],
+		// indexes (index), matrixes (matrix)
+		['sex', 3, true, false, 'x'],
 
-        // quizzes (quiz)
-        ['sezz', 4, true, false, 'z'],
+		// quizzes (quiz)
+		['sezz', 4, true, false, 'z'],
 
-        // bureaus (bureau)
-        ['suae', 4, false, true, 'eau'],
+		// bureaus (bureau)
+		['suae', 4, false, true, 'eau'],
 
-        // fees (fee), trees (tree), employees (employee)
-        ['see', 3, true, true, 'ee'],
+		// fees (fee), trees (tree), employees (employee)
+		['see', 3, true, true, 'ee'],
 
-        // edges (edge)
-        ['segd', 4, true, true, 'dge'],
+		// edges (edge)
+		['segd', 4, true, true, 'dge'],
 
-        // roses (rose), garages (garage), cassettes (cassette),
-        // waltzes (waltz), heroes (hero), bushes (bush), arches (arch),
-        // shoes (shoe)
-        ['se', 2, true, true, ['', 'e']],
+		// roses (rose), garages (garage), cassettes (cassette),
+		// waltzes (waltz), heroes (hero), bushes (bush), arches (arch),
+		// shoes (shoe)
+		['se', 2, true, true, ['', 'e']],
 
-        // tags (tag)
-        ['s', 1, true, true, ''],
+		// tags (tag)
+		['s', 1, true, true, ''],
 
-        // chateaux (chateau)
-        ['xuae', 4, false, true, 'eau'],
+		// chateaux (chateau)
+		['xuae', 4, false, true, 'eau'],
 
-        // people (person)
-        ['elpoep', 6, true, true, 'person'],
-    ];
+		// people (person)
+		['elpoep', 6, true, true, 'person'],
+	];
 
-    /**
-     * Map English singular to plural suffixes.
-     *
-     * @see http://english-zone.com/spelling/plurals.html
-     */
-    private const SINGULAR_MAP = [
-        // First entry: singular suffix, reversed
-        // Second entry: length of singular suffix
-        // Third entry: Whether the suffix may succeed a vocal
-        // Fourth entry: Whether the suffix may succeed a consonant
-        // Fifth entry: plural suffix, normal
+	/**
+	 * Map English singular to plural suffixes.
+	 *
+	 * @see http://english-zone.com/spelling/plurals.html
+	 */
+	private const SINGULAR_MAP = [
+		// First entry: singular suffix, reversed
+		// Second entry: length of singular suffix
+		// Third entry: Whether the suffix may succeed a vocal
+		// Fourth entry: Whether the suffix may succeed a consonant
+		// Fifth entry: plural suffix, normal
 
-        // criterion (criteria)
-        ['airetirc', 8, false, false, 'criterion'],
+		// criterion (criteria)
+		['airetirc', 8, false, false, 'criterion'],
 
-        // nebulae (nebula)
-        ['aluben', 6, false, false, 'nebulae'],
+		// nebulae (nebula)
+		['aluben', 6, false, false, 'nebulae'],
 
-        // children (child)
-        ['dlihc', 5, true, true, 'children'],
+		// children (child)
+		['dlihc', 5, true, true, 'children'],
 
-        // prices (price)
-        ['eci', 3, false, true, 'ices'],
+		// prices (price)
+		['eci', 3, false, true, 'ices'],
 
-        // services (service)
-        ['ecivres', 7, true, true, 'services'],
+		// services (service)
+		['ecivres', 7, true, true, 'services'],
 
-        // lives (life), wives (wife)
-        ['efi', 3, false, true, 'ives'],
+		// lives (life), wives (wife)
+		['efi', 3, false, true, 'ives'],
 
-        // selfies (selfie)
-        ['eifles', 6, true, true, 'selfies'],
+		// selfies (selfie)
+		['eifles', 6, true, true, 'selfies'],
 
-        // movies (movie)
-        ['eivom', 5, true, true, 'movies'],
+		// movies (movie)
+		['eivom', 5, true, true, 'movies'],
 
-        // lice (louse)
-        ['esuol', 5, false, true, 'lice'],
+		// lice (louse)
+		['esuol', 5, false, true, 'lice'],
 
-        // mice (mouse)
-        ['esuom', 5, false, true, 'mice'],
+		// mice (mouse)
+		['esuom', 5, false, true, 'mice'],
 
-        // geese (goose)
-        ['esoo', 4, false, true, 'eese'],
+		// geese (goose)
+		['esoo', 4, false, true, 'eese'],
 
-        // houses (house), bases (base)
-        ['es', 2, true, true, 'ses'],
+		// houses (house), bases (base)
+		['es', 2, true, true, 'ses'],
 
-        // geese (goose)
-        ['esoog', 5, true, true, 'geese'],
+		// geese (goose)
+		['esoog', 5, true, true, 'geese'],
 
-        // caves (cave)
-        ['ev', 2, true, true, 'ves'],
+		// caves (cave)
+		['ev', 2, true, true, 'ves'],
 
-        // drives (drive)
-        ['evird', 5, false, true, 'drives'],
+		// drives (drive)
+		['evird', 5, false, true, 'drives'],
 
-        // objectives (objective), alternative (alternatives)
-        ['evit', 4, true, true, 'tives'],
+		// objectives (objective), alternative (alternatives)
+		['evit', 4, true, true, 'tives'],
 
-        // moves (move)
-        ['evom', 4, true, true, 'moves'],
+		// moves (move)
+		['evom', 4, true, true, 'moves'],
 
-        // staves (staff)
-        ['ffats', 5, true, true, 'staves'],
+		// staves (staff)
+		['ffats', 5, true, true, 'staves'],
 
-        // hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf)
-        ['ff', 2, true, true, 'ffs'],
+		// hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf)
+		['ff', 2, true, true, 'ffs'],
 
-        // hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf)
-        ['f', 1, true, true, ['fs', 'ves']],
+		// hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf)
+		['f', 1, true, true, ['fs', 'ves']],
 
-        // arches (arch)
-        ['hc', 2, true, true, 'ches'],
+		// arches (arch)
+		['hc', 2, true, true, 'ches'],
 
-        // bushes (bush)
-        ['hs', 2, true, true, 'shes'],
+		// bushes (bush)
+		['hs', 2, true, true, 'shes'],
 
-        // teeth (tooth)
-        ['htoot', 5, true, true, 'teeth'],
+		// teeth (tooth)
+		['htoot', 5, true, true, 'teeth'],
 
-        // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['mu', 2, true, true, 'a'],
+		// bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
+		['mu', 2, true, true, 'a'],
 
-        // men (man), women (woman)
-        ['nam', 3, true, true, 'men'],
+		// men (man), women (woman)
+		['nam', 3, true, true, 'men'],
 
-        // people (person)
-        ['nosrep', 6, true, true, ['persons', 'people']],
+		// people (person)
+		['nosrep', 6, true, true, ['persons', 'people']],
 
-        // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['noi', 3, true, true, 'ions'],
+		// bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
+		['noi', 3, true, true, 'ions'],
 
-        // coupon (coupons)
-        ['nop', 3, true, true, 'pons'],
+		// coupon (coupons)
+		['nop', 3, true, true, 'pons'],
 
-        // seasons (season), treasons (treason), poisons (poison), lessons (lesson)
-        ['nos', 3, true, true, 'sons'],
+		// seasons (season), treasons (treason), poisons (poison), lessons (lesson)
+		['nos', 3, true, true, 'sons'],
 
-        // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['no', 2, true, true, 'a'],
+		// bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
+		['no', 2, true, true, 'a'],
 
-        // echoes (echo)
-        ['ohce', 4, true, true, 'echoes'],
+		// echoes (echo)
+		['ohce', 4, true, true, 'echoes'],
 
-        // heroes (hero)
-        ['oreh', 4, true, true, 'heroes'],
+		// heroes (hero)
+		['oreh', 4, true, true, 'heroes'],
 
-        // atlases (atlas)
-        ['salta', 5, true, true, 'atlases'],
+		// atlases (atlas)
+		['salta', 5, true, true, 'atlases'],
 
-        // irises (iris)
-        ['siri', 4, true, true, 'irises'],
+		// irises (iris)
+		['siri', 4, true, true, 'irises'],
 
-        // analyses (analysis), ellipses (ellipsis), neuroses (neurosis)
-        // theses (thesis), emphases (emphasis), oases (oasis),
-        // crises (crisis)
-        ['sis', 3, true, true, 'ses'],
+		// analyses (analysis), ellipses (ellipsis), neuroses (neurosis)
+		// theses (thesis), emphases (emphasis), oases (oasis),
+		// crises (crisis)
+		['sis', 3, true, true, 'ses'],
 
-        // accesses (access), addresses (address), kisses (kiss)
-        ['ss', 2, true, false, 'sses'],
+		// accesses (access), addresses (address), kisses (kiss)
+		['ss', 2, true, false, 'sses'],
 
-        // syllabi (syllabus)
-        ['suballys', 8, true, true, 'syllabi'],
+		// syllabi (syllabus)
+		['suballys', 8, true, true, 'syllabi'],
 
-        // buses (bus)
-        ['sub', 3, true, true, 'buses'],
+		// buses (bus)
+		['sub', 3, true, true, 'buses'],
 
-        // circuses (circus)
-        ['suc', 3, true, true, 'cuses'],
+		// circuses (circus)
+		['suc', 3, true, true, 'cuses'],
 
-        // conspectuses (conspectus), prospectuses (prospectus)
-        ['sutcep', 6, true, true, 'pectuses'],
+		// conspectuses (conspectus), prospectuses (prospectus)
+		['sutcep', 6, true, true, 'pectuses'],
 
-        // fungi (fungus), alumni (alumnus), syllabi (syllabus), radii (radius)
-        ['su', 2, true, true, 'i'],
+		// fungi (fungus), alumni (alumnus), syllabi (syllabus), radii (radius)
+		['su', 2, true, true, 'i'],
 
-        // news (news)
-        ['swen', 4, true, true, 'news'],
+		// news (news)
+		['swen', 4, true, true, 'news'],
 
-        // feet (foot)
-        ['toof', 4, true, true, 'feet'],
+		// feet (foot)
+		['toof', 4, true, true, 'feet'],
 
-        // chateaux (chateau), bureaus (bureau)
-        ['uae', 3, false, true, ['eaus', 'eaux']],
+		// chateaux (chateau), bureaus (bureau)
+		['uae', 3, false, true, ['eaus', 'eaux']],
 
-        // oxen (ox)
-        ['xo', 2, false, false, 'oxen'],
+		// oxen (ox)
+		['xo', 2, false, false, 'oxen'],
 
-        // hoaxes (hoax)
-        ['xaoh', 4, true, false, 'hoaxes'],
+		// hoaxes (hoax)
+		['xaoh', 4, true, false, 'hoaxes'],
 
-        // indices (index)
-        ['xedni', 5, false, true, ['indicies', 'indexes']],
+		// indices (index)
+		['xedni', 5, false, true, ['indicies', 'indexes']],
 
-        // boxes (box)
-        ['xo', 2, false, true, 'oxes'],
+		// boxes (box)
+		['xo', 2, false, true, 'oxes'],
 
-        // indexes (index), matrixes (matrix)
-        ['x', 1, true, false, ['cies', 'xes']],
+		// indexes (index), matrixes (matrix)
+		['x', 1, true, false, ['cies', 'xes']],
 
-        // appendices (appendix)
-        ['xi', 2, false, true, 'ices'],
+		// appendices (appendix)
+		['xi', 2, false, true, 'ices'],
 
-        // babies (baby)
-        ['y', 1, false, true, 'ies'],
+		// babies (baby)
+		['y', 1, false, true, 'ies'],
 
-        // quizzes (quiz)
-        ['ziuq', 4, true, false, 'quizzes'],
+		// quizzes (quiz)
+		['ziuq', 4, true, false, 'quizzes'],
 
-        // waltzes (waltz)
-        ['z', 1, true, true, 'zes'],
-    ];
+		// waltzes (waltz)
+		['z', 1, true, true, 'zes'],
+	];
 
-    /**
-     * A list of words which should not be inflected, reversed.
-     */
-    private const UNINFLECTED = [
-        '',
+	/**
+	 * A list of words which should not be inflected, reversed.
+	 */
+	private const UNINFLECTED = [
+		'',
 
-        // data
-        'atad',
+		// data
+		'atad',
 
-        // deer
-        'reed',
+		// deer
+		'reed',
 
-        // feedback
-        'kcabdeef',
+		// feedback
+		'kcabdeef',
 
-        // fish
-        'hsif',
+		// fish
+		'hsif',
 
-        // info
-        'ofni',
+		// info
+		'ofni',
 
-        // moose
-        'esoom',
+		// moose
+		'esoom',
 
-        // series
-        'seires',
+		// series
+		'seires',
 
-        // sheep
-        'peehs',
+		// sheep
+		'peehs',
 
-        // species
-        'seiceps',
-    ];
-
-    /**
-     * {@inheritdoc}
-     */
-    public function singularize(string $plural): array
-    {
-        $pluralRev = strrev($plural);
-        $lowerPluralRev = strtolower($pluralRev);
-        $pluralLength = \strlen($lowerPluralRev);
-
-        // Check if the word is one which is not inflected, return early if so
-        if (\in_array($lowerPluralRev, self::UNINFLECTED, true)) {
-            return [$plural];
-        }
-
-        // The outer loop iterates over the entries of the plural table
-        // The inner loop $j iterates over the characters of the plural suffix
-        // in the plural table to compare them with the characters of the actual
-        // given plural suffix
-        foreach (self::PLURAL_MAP as $map) {
-            $suffix = $map[0];
-            $suffixLength = $map[1];
-            $j = 0;
-
-            // Compare characters in the plural table and of the suffix of the
-            // given plural one by one
-            while ($suffix[$j] === $lowerPluralRev[$j]) {
-                // Let $j point to the next character
-                ++$j;
-
-                // Successfully compared the last character
-                // Add an entry with the singular suffix to the singular array
-                if ($j === $suffixLength) {
-                    // Is there any character preceding the suffix in the plural string?
-                    if ($j < $pluralLength) {
-                        $nextIsVocal = false !== strpos('aeiou', $lowerPluralRev[$j]);
-
-                        if (!$map[2] && $nextIsVocal) {
-                            // suffix may not succeed a vocal but next char is one
-                            break;
-                        }
-
-                        if (!$map[3] && !$nextIsVocal) {
-                            // suffix may not succeed a consonant but next char is one
-                            break;
-                        }
-                    }
-
-                    $newBase = substr($plural, 0, $pluralLength - $suffixLength);
-                    $newSuffix = $map[4];
-
-                    // Check whether the first character in the plural suffix
-                    // is uppercased. If yes, uppercase the first character in
-                    // the singular suffix too
-                    $firstUpper = ctype_upper($pluralRev[$j - 1]);
-
-                    if (\is_array($newSuffix)) {
-                        $singulars = [];
-
-                        foreach ($newSuffix as $newSuffixEntry) {
-                            $singulars[] = $newBase.($firstUpper ? ucfirst($newSuffixEntry) : $newSuffixEntry);
-                        }
-
-                        return $singulars;
-                    }
-
-                    return [$newBase.($firstUpper ? ucfirst($newSuffix) : $newSuffix)];
-                }
-
-                // Suffix is longer than word
-                if ($j === $pluralLength) {
-                    break;
-                }
-            }
-        }
-
-        // Assume that plural and singular is identical
-        return [$plural];
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function pluralize(string $singular): array
-    {
-        $singularRev = strrev($singular);
-        $lowerSingularRev = strtolower($singularRev);
-        $singularLength = \strlen($lowerSingularRev);
-
-        // Check if the word is one which is not inflected, return early if so
-        if (\in_array($lowerSingularRev, self::UNINFLECTED, true)) {
-            return [$singular];
-        }
-
-        // The outer loop iterates over the entries of the singular table
-        // The inner loop $j iterates over the characters of the singular suffix
-        // in the singular table to compare them with the characters of the actual
-        // given singular suffix
-        foreach (self::SINGULAR_MAP as $map) {
-            $suffix = $map[0];
-            $suffixLength = $map[1];
-            $j = 0;
-
-            // Compare characters in the singular table and of the suffix of the
-            // given plural one by one
-
-            while ($suffix[$j] === $lowerSingularRev[$j]) {
-                // Let $j point to the next character
-                ++$j;
-
-                // Successfully compared the last character
-                // Add an entry with the plural suffix to the plural array
-                if ($j === $suffixLength) {
-                    // Is there any character preceding the suffix in the plural string?
-                    if ($j < $singularLength) {
-                        $nextIsVocal = false !== strpos('aeiou', $lowerSingularRev[$j]);
-
-                        if (!$map[2] && $nextIsVocal) {
-                            // suffix may not succeed a vocal but next char is one
-                            break;
-                        }
-
-                        if (!$map[3] && !$nextIsVocal) {
-                            // suffix may not succeed a consonant but next char is one
-                            break;
-                        }
-                    }
-
-                    $newBase = substr($singular, 0, $singularLength - $suffixLength);
-                    $newSuffix = $map[4];
-
-                    // Check whether the first character in the singular suffix
-                    // is uppercased. If yes, uppercase the first character in
-                    // the singular suffix too
-                    $firstUpper = ctype_upper($singularRev[$j - 1]);
-
-                    if (\is_array($newSuffix)) {
-                        $plurals = [];
-
-                        foreach ($newSuffix as $newSuffixEntry) {
-                            $plurals[] = $newBase.($firstUpper ? ucfirst($newSuffixEntry) : $newSuffixEntry);
-                        }
-
-                        return $plurals;
-                    }
-
-                    return [$newBase.($firstUpper ? ucfirst($newSuffix) : $newSuffix)];
-                }
-
-                // Suffix is longer than word
-                if ($j === $singularLength) {
-                    break;
-                }
-            }
-        }
-
-        // Assume that plural is singular with a trailing `s`
-        return [$singular.'s'];
-    }
+		// species
+		'seiceps',
+	];
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function singularize(string $plural): array
+	{
+		$pluralRev = strrev($plural);
+		$lowerPluralRev = strtolower($pluralRev);
+		$pluralLength = \strlen($lowerPluralRev);
+
+		// Check if the word is one which is not inflected, return early if so
+		if (\in_array($lowerPluralRev, self::UNINFLECTED, true)) {
+			return [$plural];
+		}
+
+		// The outer loop iterates over the entries of the plural table
+		// The inner loop $j iterates over the characters of the plural suffix
+		// in the plural table to compare them with the characters of the actual
+		// given plural suffix
+		foreach (self::PLURAL_MAP as $map) {
+			$suffix = $map[0];
+			$suffixLength = $map[1];
+			$j = 0;
+
+			// Compare characters in the plural table and of the suffix of the
+			// given plural one by one
+			while ($suffix[$j] === $lowerPluralRev[$j]) {
+				// Let $j point to the next character
+				++$j;
+
+				// Successfully compared the last character
+				// Add an entry with the singular suffix to the singular array
+				if ($j === $suffixLength) {
+					// Is there any character preceding the suffix in the plural string?
+					if ($j < $pluralLength) {
+						$nextIsVocal = false !== strpos('aeiou', $lowerPluralRev[$j]);
+
+						if (!$map[2] && $nextIsVocal) {
+							// suffix may not succeed a vocal but next char is one
+							break;
+						}
+
+						if (!$map[3] && !$nextIsVocal) {
+							// suffix may not succeed a consonant but next char is one
+							break;
+						}
+					}
+
+					$newBase = substr($plural, 0, $pluralLength - $suffixLength);
+					$newSuffix = $map[4];
+
+					// Check whether the first character in the plural suffix
+					// is uppercased. If yes, uppercase the first character in
+					// the singular suffix too
+					$firstUpper = ctype_upper($pluralRev[$j - 1]);
+
+					if (\is_array($newSuffix)) {
+						$singulars = [];
+
+						foreach ($newSuffix as $newSuffixEntry) {
+							$singulars[] = $newBase.($firstUpper ? ucfirst($newSuffixEntry) : $newSuffixEntry);
+						}
+
+						return $singulars;
+					}
+
+					return [$newBase.($firstUpper ? ucfirst($newSuffix) : $newSuffix)];
+				}
+
+				// Suffix is longer than word
+				if ($j === $pluralLength) {
+					break;
+				}
+			}
+		}
+
+		// Assume that plural and singular is identical
+		return [$plural];
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function pluralize(string $singular): array
+	{
+		$singularRev = strrev($singular);
+		$lowerSingularRev = strtolower($singularRev);
+		$singularLength = \strlen($lowerSingularRev);
+
+		// Check if the word is one which is not inflected, return early if so
+		if (\in_array($lowerSingularRev, self::UNINFLECTED, true)) {
+			return [$singular];
+		}
+
+		// The outer loop iterates over the entries of the singular table
+		// The inner loop $j iterates over the characters of the singular suffix
+		// in the singular table to compare them with the characters of the actual
+		// given singular suffix
+		foreach (self::SINGULAR_MAP as $map) {
+			$suffix = $map[0];
+			$suffixLength = $map[1];
+			$j = 0;
+
+			// Compare characters in the singular table and of the suffix of the
+			// given plural one by one
+
+			while ($suffix[$j] === $lowerSingularRev[$j]) {
+				// Let $j point to the next character
+				++$j;
+
+				// Successfully compared the last character
+				// Add an entry with the plural suffix to the plural array
+				if ($j === $suffixLength) {
+					// Is there any character preceding the suffix in the plural string?
+					if ($j < $singularLength) {
+						$nextIsVocal = false !== strpos('aeiou', $lowerSingularRev[$j]);
+
+						if (!$map[2] && $nextIsVocal) {
+							// suffix may not succeed a vocal but next char is one
+							break;
+						}
+
+						if (!$map[3] && !$nextIsVocal) {
+							// suffix may not succeed a consonant but next char is one
+							break;
+						}
+					}
+
+					$newBase = substr($singular, 0, $singularLength - $suffixLength);
+					$newSuffix = $map[4];
+
+					// Check whether the first character in the singular suffix
+					// is uppercased. If yes, uppercase the first character in
+					// the singular suffix too
+					$firstUpper = ctype_upper($singularRev[$j - 1]);
+
+					if (\is_array($newSuffix)) {
+						$plurals = [];
+
+						foreach ($newSuffix as $newSuffixEntry) {
+							$plurals[] = $newBase.($firstUpper ? ucfirst($newSuffixEntry) : $newSuffixEntry);
+						}
+
+						return $plurals;
+					}
+
+					return [$newBase.($firstUpper ? ucfirst($newSuffix) : $newSuffix)];
+				}
+
+				// Suffix is longer than word
+				if ($j === $singularLength) {
+					break;
+				}
+			}
+		}
+
+		// Assume that plural is singular with a trailing `s`
+		return [$singular.'s'];
+	}
 }

Spacing +139 added lines, -139 removed lines

@@ -26,117 +26,117 @@ 
         // Fifth entry: singular suffix, normal
 
         // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['a', 1, true, true, ['on', 'um']],
+        [ 'a', 1, true, true, [ 'on', 'um' ] ],
 
         // nebulae (nebula)
-        ['ea', 2, true, true, 'a'],
+        [ 'ea', 2, true, true, 'a' ],
 
         // services (service)
-        ['secivres', 8, true, true, 'service'],
+        [ 'secivres', 8, true, true, 'service' ],
 
         // mice (mouse), lice (louse)
-        ['eci', 3, false, true, 'ouse'],
+        [ 'eci', 3, false, true, 'ouse' ],
 
         // geese (goose)
-        ['esee', 4, false, true, 'oose'],
+        [ 'esee', 4, false, true, 'oose' ],
 
         // fungi (fungus), alumni (alumnus), syllabi (syllabus), radii (radius)
-        ['i', 1, true, true, 'us'],
+        [ 'i', 1, true, true, 'us' ],
 
         // men (man), women (woman)
-        ['nem', 3, true, true, 'man'],
+        [ 'nem', 3, true, true, 'man' ],
 
         // children (child)
-        ['nerdlihc', 8, true, true, 'child'],
+        [ 'nerdlihc', 8, true, true, 'child' ],
 
         // oxen (ox)
-        ['nexo', 4, false, false, 'ox'],
+        [ 'nexo', 4, false, false, 'ox' ],
 
         // indices (index), appendices (appendix), prices (price)
-        ['seci', 4, false, true, ['ex', 'ix', 'ice']],
+        [ 'seci', 4, false, true, [ 'ex', 'ix', 'ice' ] ],
 
         // selfies (selfie)
-        ['seifles', 7, true, true, 'selfie'],
+        [ 'seifles', 7, true, true, 'selfie' ],
 
         // movies (movie)
-        ['seivom', 6, true, true, 'movie'],
+        [ 'seivom', 6, true, true, 'movie' ],
 
         // conspectuses (conspectus), prospectuses (prospectus)
-        ['sesutcep', 8, true, true, 'pectus'],
+        [ 'sesutcep', 8, true, true, 'pectus' ],
 
         // feet (foot)
-        ['teef', 4, true, true, 'foot'],
+        [ 'teef', 4, true, true, 'foot' ],
 
         // geese (goose)
-        ['eseeg', 5, true, true, 'goose'],
+        [ 'eseeg', 5, true, true, 'goose' ],
 
         // teeth (tooth)
-        ['hteet', 5, true, true, 'tooth'],
+        [ 'hteet', 5, true, true, 'tooth' ],
 
         // news (news)
-        ['swen', 4, true, true, 'news'],
+        [ 'swen', 4, true, true, 'news' ],
 
         // series (series)
-        ['seires', 6, true, true, 'series'],
+        [ 'seires', 6, true, true, 'series' ],
 
         // babies (baby)
-        ['sei', 3, false, true, 'y'],
+        [ 'sei', 3, false, true, 'y' ],
 
         // accesses (access), addresses (address), kisses (kiss)
-        ['sess', 4, true, false, 'ss'],
+        [ 'sess', 4, true, false, 'ss' ],
 
         // analyses (analysis), ellipses (ellipsis), fungi (fungus),
         // neuroses (neurosis), theses (thesis), emphases (emphasis),
         // oases (oasis), crises (crisis), houses (house), bases (base),
         // atlases (atlas)
-        ['ses', 3, true, true, ['s', 'se', 'sis']],
+        [ 'ses', 3, true, true, [ 's', 'se', 'sis' ] ],
 
         // objectives (objective), alternative (alternatives)
-        ['sevit', 5, true, true, 'tive'],
+        [ 'sevit', 5, true, true, 'tive' ],
 
         // drives (drive)
-        ['sevird', 6, false, true, 'drive'],
+        [ 'sevird', 6, false, true, 'drive' ],
 
         // lives (life), wives (wife)
-        ['sevi', 4, false, true, 'ife'],
+        [ 'sevi', 4, false, true, 'ife' ],
 
         // moves (move)
-        ['sevom', 5, true, true, 'move'],
+        [ 'sevom', 5, true, true, 'move' ],
 
         // hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf), caves (cave), staves (staff)
-        ['sev', 3, true, true, ['f', 've', 'ff']],
+        [ 'sev', 3, true, true, [ 'f', 've', 'ff' ] ],
 
         // axes (axis), axes (ax), axes (axe)
-        ['sexa', 4, false, false, ['ax', 'axe', 'axis']],
+        [ 'sexa', 4, false, false, [ 'ax', 'axe', 'axis' ] ],
 
         // indexes (index), matrixes (matrix)
-        ['sex', 3, true, false, 'x'],
+        [ 'sex', 3, true, false, 'x' ],
 
         // quizzes (quiz)
-        ['sezz', 4, true, false, 'z'],
+        [ 'sezz', 4, true, false, 'z' ],
 
         // bureaus (bureau)
-        ['suae', 4, false, true, 'eau'],
+        [ 'suae', 4, false, true, 'eau' ],
 
         // fees (fee), trees (tree), employees (employee)
-        ['see', 3, true, true, 'ee'],
+        [ 'see', 3, true, true, 'ee' ],
 
         // edges (edge)
-        ['segd', 4, true, true, 'dge'],
+        [ 'segd', 4, true, true, 'dge' ],
 
         // roses (rose), garages (garage), cassettes (cassette),
         // waltzes (waltz), heroes (hero), bushes (bush), arches (arch),
         // shoes (shoe)
-        ['se', 2, true, true, ['', 'e']],
+        [ 'se', 2, true, true, [ '', 'e' ] ],
 
         // tags (tag)
-        ['s', 1, true, true, ''],
+        [ 's', 1, true, true, '' ],
 
         // chateaux (chateau)
-        ['xuae', 4, false, true, 'eau'],
+        [ 'xuae', 4, false, true, 'eau' ],
 
         // people (person)
-        ['elpoep', 6, true, true, 'person'],
+        [ 'elpoep', 6, true, true, 'person' ],
     ];
 
     /**
@@ -152,165 +152,165 @@ 
         // Fifth entry: plural suffix, normal
 
         // criterion (criteria)
-        ['airetirc', 8, false, false, 'criterion'],
+        [ 'airetirc', 8, false, false, 'criterion' ],
 
         // nebulae (nebula)
-        ['aluben', 6, false, false, 'nebulae'],
+        [ 'aluben', 6, false, false, 'nebulae' ],
 
         // children (child)
-        ['dlihc', 5, true, true, 'children'],
+        [ 'dlihc', 5, true, true, 'children' ],
 
         // prices (price)
-        ['eci', 3, false, true, 'ices'],
+        [ 'eci', 3, false, true, 'ices' ],
 
         // services (service)
-        ['ecivres', 7, true, true, 'services'],
+        [ 'ecivres', 7, true, true, 'services' ],
 
         // lives (life), wives (wife)
-        ['efi', 3, false, true, 'ives'],
+        [ 'efi', 3, false, true, 'ives' ],
 
         // selfies (selfie)
-        ['eifles', 6, true, true, 'selfies'],
+        [ 'eifles', 6, true, true, 'selfies' ],
 
         // movies (movie)
-        ['eivom', 5, true, true, 'movies'],
+        [ 'eivom', 5, true, true, 'movies' ],
 
         // lice (louse)
-        ['esuol', 5, false, true, 'lice'],
+        [ 'esuol', 5, false, true, 'lice' ],
 
         // mice (mouse)
-        ['esuom', 5, false, true, 'mice'],
+        [ 'esuom', 5, false, true, 'mice' ],
 
         // geese (goose)
-        ['esoo', 4, false, true, 'eese'],
+        [ 'esoo', 4, false, true, 'eese' ],
 
         // houses (house), bases (base)
-        ['es', 2, true, true, 'ses'],
+        [ 'es', 2, true, true, 'ses' ],
 
         // geese (goose)
-        ['esoog', 5, true, true, 'geese'],
+        [ 'esoog', 5, true, true, 'geese' ],
 
         // caves (cave)
-        ['ev', 2, true, true, 'ves'],
+        [ 'ev', 2, true, true, 'ves' ],
 
         // drives (drive)
-        ['evird', 5, false, true, 'drives'],
+        [ 'evird', 5, false, true, 'drives' ],
 
         // objectives (objective), alternative (alternatives)
-        ['evit', 4, true, true, 'tives'],
+        [ 'evit', 4, true, true, 'tives' ],
 
         // moves (move)
-        ['evom', 4, true, true, 'moves'],
+        [ 'evom', 4, true, true, 'moves' ],
 
         // staves (staff)
-        ['ffats', 5, true, true, 'staves'],
+        [ 'ffats', 5, true, true, 'staves' ],
 
         // hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf)
-        ['ff', 2, true, true, 'ffs'],
+        [ 'ff', 2, true, true, 'ffs' ],
 
         // hooves (hoof), dwarves (dwarf), elves (elf), leaves (leaf)
-        ['f', 1, true, true, ['fs', 'ves']],
+        [ 'f', 1, true, true, [ 'fs', 'ves' ] ],
 
         // arches (arch)
-        ['hc', 2, true, true, 'ches'],
+        [ 'hc', 2, true, true, 'ches' ],
 
         // bushes (bush)
-        ['hs', 2, true, true, 'shes'],
+        [ 'hs', 2, true, true, 'shes' ],
 
         // teeth (tooth)
-        ['htoot', 5, true, true, 'teeth'],
+        [ 'htoot', 5, true, true, 'teeth' ],
 
         // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['mu', 2, true, true, 'a'],
+        [ 'mu', 2, true, true, 'a' ],
 
         // men (man), women (woman)
-        ['nam', 3, true, true, 'men'],
+        [ 'nam', 3, true, true, 'men' ],
 
         // people (person)
-        ['nosrep', 6, true, true, ['persons', 'people']],
+        [ 'nosrep', 6, true, true, [ 'persons', 'people' ] ],
 
         // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['noi', 3, true, true, 'ions'],
+        [ 'noi', 3, true, true, 'ions' ],
 
         // coupon (coupons)
-        ['nop', 3, true, true, 'pons'],
+        [ 'nop', 3, true, true, 'pons' ],
 
         // seasons (season), treasons (treason), poisons (poison), lessons (lesson)
-        ['nos', 3, true, true, 'sons'],
+        [ 'nos', 3, true, true, 'sons' ],
 
         // bacteria (bacterium), criteria (criterion), phenomena (phenomenon)
-        ['no', 2, true, true, 'a'],
+        [ 'no', 2, true, true, 'a' ],
 
         // echoes (echo)
-        ['ohce', 4, true, true, 'echoes'],
+        [ 'ohce', 4, true, true, 'echoes' ],
 
         // heroes (hero)
-        ['oreh', 4, true, true, 'heroes'],
+        [ 'oreh', 4, true, true, 'heroes' ],
 
         // atlases (atlas)
-        ['salta', 5, true, true, 'atlases'],
+        [ 'salta', 5, true, true, 'atlases' ],
 
         // irises (iris)
-        ['siri', 4, true, true, 'irises'],
+        [ 'siri', 4, true, true, 'irises' ],
 
         // analyses (analysis), ellipses (ellipsis), neuroses (neurosis)
         // theses (thesis), emphases (emphasis), oases (oasis),
         // crises (crisis)
-        ['sis', 3, true, true, 'ses'],
+        [ 'sis', 3, true, true, 'ses' ],
 
         // accesses (access), addresses (address), kisses (kiss)
-        ['ss', 2, true, false, 'sses'],
+        [ 'ss', 2, true, false, 'sses' ],
 
         // syllabi (syllabus)
-        ['suballys', 8, true, true, 'syllabi'],
+        [ 'suballys', 8, true, true, 'syllabi' ],
 
         // buses (bus)
-        ['sub', 3, true, true, 'buses'],
+        [ 'sub', 3, true, true, 'buses' ],
 
         // circuses (circus)
-        ['suc', 3, true, true, 'cuses'],
+        [ 'suc', 3, true, true, 'cuses' ],
 
         // conspectuses (conspectus), prospectuses (prospectus)
-        ['sutcep', 6, true, true, 'pectuses'],
+        [ 'sutcep', 6, true, true, 'pectuses' ],
 
         // fungi (fungus), alumni (alumnus), syllabi (syllabus), radii (radius)
-        ['su', 2, true, true, 'i'],
+        [ 'su', 2, true, true, 'i' ],
 
         // news (news)
-        ['swen', 4, true, true, 'news'],
+        [ 'swen', 4, true, true, 'news' ],
 
         // feet (foot)
-        ['toof', 4, true, true, 'feet'],
+        [ 'toof', 4, true, true, 'feet' ],
 
         // chateaux (chateau), bureaus (bureau)
-        ['uae', 3, false, true, ['eaus', 'eaux']],
+        [ 'uae', 3, false, true, [ 'eaus', 'eaux' ] ],
 
         // oxen (ox)
-        ['xo', 2, false, false, 'oxen'],
+        [ 'xo', 2, false, false, 'oxen' ],
 
         // hoaxes (hoax)
-        ['xaoh', 4, true, false, 'hoaxes'],
+        [ 'xaoh', 4, true, false, 'hoaxes' ],
 
         // indices (index)
-        ['xedni', 5, false, true, ['indicies', 'indexes']],
+        [ 'xedni', 5, false, true, [ 'indicies', 'indexes' ] ],
 
         // boxes (box)
-        ['xo', 2, false, true, 'oxes'],
+        [ 'xo', 2, false, true, 'oxes' ],
 
         // indexes (index), matrixes (matrix)
-        ['x', 1, true, false, ['cies', 'xes']],
+        [ 'x', 1, true, false, [ 'cies', 'xes' ] ],
 
         // appendices (appendix)
-        ['xi', 2, false, true, 'ices'],
+        [ 'xi', 2, false, true, 'ices' ],
 
         // babies (baby)
-        ['y', 1, false, true, 'ies'],
+        [ 'y', 1, false, true, 'ies' ],
 
         // quizzes (quiz)
-        ['ziuq', 4, true, false, 'quizzes'],
+        [ 'ziuq', 4, true, false, 'quizzes' ],
 
         // waltzes (waltz)
-        ['z', 1, true, true, 'zes'],
+        [ 'z', 1, true, true, 'zes' ],
     ];
 
     /**
@@ -350,159 +350,159 @@ 
     /**
      * {@inheritdoc}
      */
-    public function singularize(string $plural): array
+    public function singularize( string $plural ): array
     {
-        $pluralRev = strrev($plural);
-        $lowerPluralRev = strtolower($pluralRev);
-        $pluralLength = \strlen($lowerPluralRev);
+        $pluralRev = strrev( $plural );
+        $lowerPluralRev = strtolower( $pluralRev );
+        $pluralLength = \strlen( $lowerPluralRev );
 
         // Check if the word is one which is not inflected, return early if so
-        if (\in_array($lowerPluralRev, self::UNINFLECTED, true)) {
-            return [$plural];
+        if ( \in_array( $lowerPluralRev, self::UNINFLECTED, true ) ) {
+            return [ $plural ];
         }
 
         // The outer loop iterates over the entries of the plural table
         // The inner loop $j iterates over the characters of the plural suffix
         // in the plural table to compare them with the characters of the actual
         // given plural suffix
-        foreach (self::PLURAL_MAP as $map) {
-            $suffix = $map[0];
-            $suffixLength = $map[1];
+        foreach ( self::PLURAL_MAP as $map ) {
+            $suffix = $map[ 0 ];
+            $suffixLength = $map[ 1 ];
             $j = 0;
 
             // Compare characters in the plural table and of the suffix of the
             // given plural one by one
-            while ($suffix[$j] === $lowerPluralRev[$j]) {
+            while ( $suffix[ $j ] === $lowerPluralRev[ $j ] ) {
                 // Let $j point to the next character
                 ++$j;
 
                 // Successfully compared the last character
                 // Add an entry with the singular suffix to the singular array
-                if ($j === $suffixLength) {
+                if ( $j === $suffixLength ) {
                     // Is there any character preceding the suffix in the plural string?
-                    if ($j < $pluralLength) {
-                        $nextIsVocal = false !== strpos('aeiou', $lowerPluralRev[$j]);
+                    if ( $j < $pluralLength ) {
+                        $nextIsVocal = false !== strpos( 'aeiou', $lowerPluralRev[ $j ] );
 
-                        if (!$map[2] && $nextIsVocal) {
+                        if ( ! $map[ 2 ] && $nextIsVocal ) {
                             // suffix may not succeed a vocal but next char is one
                             break;
                         }
 
-                        if (!$map[3] && !$nextIsVocal) {
+                        if ( ! $map[ 3 ] && ! $nextIsVocal ) {
                             // suffix may not succeed a consonant but next char is one
                             break;
                         }
                     }
 
-                    $newBase = substr($plural, 0, $pluralLength - $suffixLength);
-                    $newSuffix = $map[4];
+                    $newBase = substr( $plural, 0, $pluralLength - $suffixLength );
+                    $newSuffix = $map[ 4 ];
 
                     // Check whether the first character in the plural suffix
                     // is uppercased. If yes, uppercase the first character in
                     // the singular suffix too
-                    $firstUpper = ctype_upper($pluralRev[$j - 1]);
+                    $firstUpper = ctype_upper( $pluralRev[ $j - 1 ] );
 
-                    if (\is_array($newSuffix)) {
-                        $singulars = [];
+                    if ( \is_array( $newSuffix ) ) {
+                        $singulars = [ ];
 
-                        foreach ($newSuffix as $newSuffixEntry) {
-                            $singulars[] = $newBase.($firstUpper ? ucfirst($newSuffixEntry) : $newSuffixEntry);
+                        foreach ( $newSuffix as $newSuffixEntry ) {
+                            $singulars[ ] = $newBase . ( $firstUpper ? ucfirst( $newSuffixEntry ) : $newSuffixEntry );
                         }
 
                         return $singulars;
                     }
 
-                    return [$newBase.($firstUpper ? ucfirst($newSuffix) : $newSuffix)];
+                    return [ $newBase . ( $firstUpper ? ucfirst( $newSuffix ) : $newSuffix ) ];
                 }
 
                 // Suffix is longer than word
-                if ($j === $pluralLength) {
+                if ( $j === $pluralLength ) {
                     break;
                 }
             }
         }
 
         // Assume that plural and singular is identical
-        return [$plural];
+        return [ $plural ];
     }
 
     /**
      * {@inheritdoc}
      */
-    public function pluralize(string $singular): array
+    public function pluralize( string $singular ): array
     {
-        $singularRev = strrev($singular);
-        $lowerSingularRev = strtolower($singularRev);
-        $singularLength = \strlen($lowerSingularRev);
+        $singularRev = strrev( $singular );
+        $lowerSingularRev = strtolower( $singularRev );
+        $singularLength = \strlen( $lowerSingularRev );
 
         // Check if the word is one which is not inflected, return early if so
-        if (\in_array($lowerSingularRev, self::UNINFLECTED, true)) {
-            return [$singular];
+        if ( \in_array( $lowerSingularRev, self::UNINFLECTED, true ) ) {
+            return [ $singular ];
         }
 
         // The outer loop iterates over the entries of the singular table
         // The inner loop $j iterates over the characters of the singular suffix
         // in the singular table to compare them with the characters of the actual
         // given singular suffix
-        foreach (self::SINGULAR_MAP as $map) {
-            $suffix = $map[0];
-            $suffixLength = $map[1];
+        foreach ( self::SINGULAR_MAP as $map ) {
+            $suffix = $map[ 0 ];
+            $suffixLength = $map[ 1 ];
             $j = 0;
 
             // Compare characters in the singular table and of the suffix of the
             // given plural one by one
 
-            while ($suffix[$j] === $lowerSingularRev[$j]) {
+            while ( $suffix[ $j ] === $lowerSingularRev[ $j ] ) {
                 // Let $j point to the next character
                 ++$j;
 
                 // Successfully compared the last character
                 // Add an entry with the plural suffix to the plural array
-                if ($j === $suffixLength) {
+                if ( $j === $suffixLength ) {
                     // Is there any character preceding the suffix in the plural string?
-                    if ($j < $singularLength) {
-                        $nextIsVocal = false !== strpos('aeiou', $lowerSingularRev[$j]);
+                    if ( $j < $singularLength ) {
+                        $nextIsVocal = false !== strpos( 'aeiou', $lowerSingularRev[ $j ] );
 
-                        if (!$map[2] && $nextIsVocal) {
+                        if ( ! $map[ 2 ] && $nextIsVocal ) {
                             // suffix may not succeed a vocal but next char is one
                             break;
                         }
 
-                        if (!$map[3] && !$nextIsVocal) {
+                        if ( ! $map[ 3 ] && ! $nextIsVocal ) {
                             // suffix may not succeed a consonant but next char is one
                             break;
                         }
                     }
 
-                    $newBase = substr($singular, 0, $singularLength - $suffixLength);
-                    $newSuffix = $map[4];
+                    $newBase = substr( $singular, 0, $singularLength - $suffixLength );
+                    $newSuffix = $map[ 4 ];
 
                     // Check whether the first character in the singular suffix
                     // is uppercased. If yes, uppercase the first character in
                     // the singular suffix too
-                    $firstUpper = ctype_upper($singularRev[$j - 1]);
+                    $firstUpper = ctype_upper( $singularRev[ $j - 1 ] );
 
-                    if (\is_array($newSuffix)) {
-                        $plurals = [];
+                    if ( \is_array( $newSuffix ) ) {
+                        $plurals = [ ];
 
-                        foreach ($newSuffix as $newSuffixEntry) {
-                            $plurals[] = $newBase.($firstUpper ? ucfirst($newSuffixEntry) : $newSuffixEntry);
+                        foreach ( $newSuffix as $newSuffixEntry ) {
+                            $plurals[ ] = $newBase . ( $firstUpper ? ucfirst( $newSuffixEntry ) : $newSuffixEntry );
                         }
 
                         return $plurals;
                     }
 
-                    return [$newBase.($firstUpper ? ucfirst($newSuffix) : $newSuffix)];
+                    return [ $newBase . ( $firstUpper ? ucfirst( $newSuffix ) : $newSuffix ) ];
                 }
 
                 // Suffix is longer than word
-                if ($j === $singularLength) {
+                if ( $j === $singularLength ) {
                     break;
                 }
             }
         }
 
         // Assume that plural is singular with a trailing `s`
-        return [$singular.'s'];
+        return [ $singular . 's' ];
     }
 }

Braces +1 added lines, -2 removed lines

@@ -11,8 +11,7 @@
 
 namespace Symfony\Component\String\Inflector;
 
-final class EnglishInflector implements InflectorInterface
-{
+final class EnglishInflector implements InflectorInterface {
     /**
      * Map English plural to singular suffixes.
      *

vendor/symfony/filesystem/Exception/InvalidArgumentException.php

Braces +1 added lines, -2 removed lines

@@ -14,6 +14,5 @@
 /**
  * @author Christian Flothmann <christian.flothmann@sensiolabs.de>
  */
-class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
-{
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface {
 }

vendor/symfony/filesystem/Exception/FileNotFoundException.php

Indentation +11 added lines, -11 removed lines

@@ -19,16 +19,16 @@
  */
 class FileNotFoundException extends IOException
 {
-    public function __construct(string $message = null, int $code = 0, \Throwable $previous = null, string $path = null)
-    {
-        if (null === $message) {
-            if (null === $path) {
-                $message = 'File could not be found.';
-            } else {
-                $message = sprintf('File "%s" could not be found.', $path);
-            }
-        }
+	public function __construct(string $message = null, int $code = 0, \Throwable $previous = null, string $path = null)
+	{
+		if (null === $message) {
+			if (null === $path) {
+				$message = 'File could not be found.';
+			} else {
+				$message = sprintf('File "%s" could not be found.', $path);
+			}
+		}
 
-        parent::__construct($message, $code, $previous, $path);
-    }
+		parent::__construct($message, $code, $previous, $path);
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -19,16 +19,16 @@
  */
 class FileNotFoundException extends IOException
 {
-    public function __construct(string $message = null, int $code = 0, \Throwable $previous = null, string $path = null)
+    public function __construct( string $message = null, int $code = 0, \Throwable $previous = null, string $path = null )
     {
-        if (null === $message) {
-            if (null === $path) {
+        if ( null === $message ) {
+            if ( null === $path ) {
                 $message = 'File could not be found.';
             } else {
-                $message = sprintf('File "%s" could not be found.', $path);
+                $message = sprintf( 'File "%s" could not be found.', $path );
             }
         }
 
-        parent::__construct($message, $code, $previous, $path);
+        parent::__construct( $message, $code, $previous, $path );
     }
 }

Braces +2 added lines, -4 removed lines

@@ -17,10 +17,8 @@
  * @author Fabien Potencier <fabien@symfony.com>
  * @author Christian Gärtner <christiangaertner.film@googlemail.com>
  */
-class FileNotFoundException extends IOException
-{
-    public function __construct(string $message = null, int $code = 0, \Throwable $previous = null, string $path = null)
-    {
+class FileNotFoundException extends IOException {
+    public function __construct(string $message = null, int $code = 0, \Throwable $previous = null, string $path = null) {
         if (null === $message) {
             if (null === $path) {
                 $message = 'File could not be found.';

vendor/symfony/filesystem/Exception/ExceptionInterface.php

Braces +1 added lines, -2 removed lines

@@ -16,6 +16,5 @@
  *
  * @author Romain Neutron <imprec@gmail.com>
  */
-interface ExceptionInterface extends \Throwable
-{
+interface ExceptionInterface extends \Throwable {
 }

vendor/symfony/filesystem/Exception/IOException.php

Indentation +13 added lines, -13 removed lines

@@ -20,20 +20,20 @@
  */
 class IOException extends \RuntimeException implements IOExceptionInterface
 {
-    private $path;
+	private $path;
 
-    public function __construct(string $message, int $code = 0, \Throwable $previous = null, string $path = null)
-    {
-        $this->path = $path;
+	public function __construct(string $message, int $code = 0, \Throwable $previous = null, string $path = null)
+	{
+		$this->path = $path;
 
-        parent::__construct($message, $code, $previous);
-    }
+		parent::__construct($message, $code, $previous);
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getPath()
-    {
-        return $this->path;
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getPath()
+	{
+		return $this->path;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -22,11 +22,11 @@
 {
     private $path;
 
-    public function __construct(string $message, int $code = 0, \Throwable $previous = null, string $path = null)
+    public function __construct( string $message, int $code = 0, \Throwable $previous = null, string $path = null )
     {
         $this->path = $path;
 
-        parent::__construct($message, $code, $previous);
+        parent::__construct( $message, $code, $previous );
     }
 
     /**

Braces +3 added lines, -6 removed lines

@@ -18,12 +18,10 @@ 
  * @author Christian Gärtner <christiangaertner.film@googlemail.com>
  * @author Fabien Potencier <fabien@symfony.com>
  */
-class IOException extends \RuntimeException implements IOExceptionInterface
-{
+class IOException extends \RuntimeException implements IOExceptionInterface {
     private $path;
 
-    public function __construct(string $message, int $code = 0, \Throwable $previous = null, string $path = null)
-    {
+    public function __construct(string $message, int $code = 0, \Throwable $previous = null, string $path = null) {
         $this->path = $path;
 
         parent::__construct($message, $code, $previous);
@@ -32,8 +30,7 @@ 
     /**
      * {@inheritdoc}
      */
-    public function getPath()
-    {
+    public function getPath() {
         return $this->path;
     }
 }

vendor/symfony/filesystem/Exception/IOExceptionInterface.php

Indentation +6 added lines, -6 removed lines

@@ -18,10 +18,10 @@
  */
 interface IOExceptionInterface extends ExceptionInterface
 {
-    /**
-     * Returns the associated path for the exception.
-     *
-     * @return string|null The path
-     */
-    public function getPath();
+	/**
+	 * Returns the associated path for the exception.
+	 *
+	 * @return string|null The path
+	 */
+	public function getPath();
 }

Braces +1 added lines, -2 removed lines

@@ -16,8 +16,7 @@
  *
  * @author Christian Gärtner <christiangaertner.film@googlemail.com>
  */
-interface IOExceptionInterface extends ExceptionInterface
-{
+interface IOExceptionInterface extends ExceptionInterface {
     /**
      * Returns the associated path for the exception.
      *