Dolibarr / dolibarr

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/PHPStan/MacroExtension.php

Indentation +46 added lines, -46 removed lines

@@ -24,55 +24,55 @@
  */
 final class MacroExtension implements MethodsClassReflectionExtension
 {
-    /**
-     * @var PhpMethodReflectionFactory
-     */
-    protected $methodReflectionFactory;
+	/**
+	 * @var PhpMethodReflectionFactory
+	 */
+	protected $methodReflectionFactory;
 
-    /**
-     * @var MacroScanner
-     */
-    protected $scanner;
+	/**
+	 * @var MacroScanner
+	 */
+	protected $scanner;
 
-    /**
-     * Extension constructor.
-     *
-     * @param PhpMethodReflectionFactory $methodReflectionFactory
-     */
-    public function __construct(PhpMethodReflectionFactory $methodReflectionFactory)
-    {
-        $this->scanner = new MacroScanner();
-        $this->methodReflectionFactory = $methodReflectionFactory;
-    }
+	/**
+	 * Extension constructor.
+	 *
+	 * @param PhpMethodReflectionFactory $methodReflectionFactory
+	 */
+	public function __construct(PhpMethodReflectionFactory $methodReflectionFactory)
+	{
+		$this->scanner = new MacroScanner();
+		$this->methodReflectionFactory = $methodReflectionFactory;
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    public function hasMethod(ClassReflection $classReflection, string $methodName): bool
-    {
-        return $this->scanner->hasMethod($classReflection->getName(), $methodName);
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	public function hasMethod(ClassReflection $classReflection, string $methodName): bool
+	{
+		return $this->scanner->hasMethod($classReflection->getName(), $methodName);
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
-    {
-        $builtinMacro = $this->scanner->getMethod($classReflection->getName(), $methodName);
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
+	{
+		$builtinMacro = $this->scanner->getMethod($classReflection->getName(), $methodName);
 
-        return $this->methodReflectionFactory->create(
-            $classReflection,
-            null,
-            $builtinMacro,
-            $classReflection->getActiveTemplateTypeMap(),
-            [],
-            TypehintHelper::decideTypeFromReflection($builtinMacro->getReturnType()),
-            null,
-            null,
-            $builtinMacro->isDeprecated()->yes(),
-            $builtinMacro->isInternal(),
-            $builtinMacro->isFinal(),
-            $builtinMacro->getDocComment()
-        );
-    }
+		return $this->methodReflectionFactory->create(
+			$classReflection,
+			null,
+			$builtinMacro,
+			$classReflection->getActiveTemplateTypeMap(),
+			[],
+			TypehintHelper::decideTypeFromReflection($builtinMacro->getReturnType()),
+			null,
+			null,
+			$builtinMacro->isDeprecated()->yes(),
+			$builtinMacro->isInternal(),
+			$builtinMacro->isFinal(),
+			$builtinMacro->getDocComment()
+		);
+	}
 }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/CarbonInterval.php

Indentation +2582 added lines, -2582 removed lines

@@ -182,2598 +182,2598 @@
  */
 class CarbonInterval extends DateInterval implements CarbonConverterInterface
 {
-    use IntervalRounding;
-    use IntervalStep;
-    use Mixin {
-        Mixin::mixin as baseMixin;
-    }
-    use Options;
-
-    /**
-     * Interval spec period designators
-     */
-    public const PERIOD_PREFIX = 'P';
-    public const PERIOD_YEARS = 'Y';
-    public const PERIOD_MONTHS = 'M';
-    public const PERIOD_DAYS = 'D';
-    public const PERIOD_TIME_PREFIX = 'T';
-    public const PERIOD_HOURS = 'H';
-    public const PERIOD_MINUTES = 'M';
-    public const PERIOD_SECONDS = 'S';
-
-    /**
-     * A translator to ... er ... translate stuff
-     *
-     * @var \Symfony\Component\Translation\TranslatorInterface
-     */
-    protected static $translator;
-
-    /**
-     * @var array|null
-     */
-    protected static $cascadeFactors;
-
-    /**
-     * @var array
-     */
-    protected static $formats = [
-        'y' => 'y',
-        'Y' => 'y',
-        'o' => 'y',
-        'm' => 'm',
-        'n' => 'm',
-        'W' => 'weeks',
-        'd' => 'd',
-        'j' => 'd',
-        'z' => 'd',
-        'h' => 'h',
-        'g' => 'h',
-        'H' => 'h',
-        'G' => 'h',
-        'i' => 'i',
-        's' => 's',
-        'u' => 'micro',
-        'v' => 'milli',
-    ];
-
-    /**
-     * @var array|null
-     */
-    private static $flipCascadeFactors;
-
-    /**
-     * The registered macros.
-     *
-     * @var array
-     */
-    protected static $macros = [];
-
-    /**
-     * Timezone handler for settings() method.
-     *
-     * @var mixed
-     */
-    protected $tzName;
-
-    /**
-     * Set the instance's timezone from a string or object.
-     *
-     * @param \DateTimeZone|string $tzName
-     *
-     * @return static
-     */
-    public function setTimezone($tzName)
-    {
-        $this->tzName = $tzName;
-
-        return $this;
-    }
-
-    /**
-     * @internal
-     *
-     * Set the instance's timezone from a string or object and add/subtract the offset difference.
-     *
-     * @param \DateTimeZone|string $tzName
-     *
-     * @return static
-     */
-    public function shiftTimezone($tzName)
-    {
-        $this->tzName = $tzName;
-
-        return $this;
-    }
-
-    /**
-     * Mapping of units and factors for cascading.
-     *
-     * Should only be modified by changing the factors or referenced constants.
-     *
-     * @return array
-     */
-    public static function getCascadeFactors()
-    {
-        return static::$cascadeFactors ?: [
-            'milliseconds' => [Carbon::MICROSECONDS_PER_MILLISECOND, 'microseconds'],
-            'seconds' => [Carbon::MILLISECONDS_PER_SECOND, 'milliseconds'],
-            'minutes' => [Carbon::SECONDS_PER_MINUTE, 'seconds'],
-            'hours' => [Carbon::MINUTES_PER_HOUR, 'minutes'],
-            'dayz' => [Carbon::HOURS_PER_DAY, 'hours'],
-            'weeks' => [Carbon::DAYS_PER_WEEK, 'dayz'],
-            'months' => [Carbon::WEEKS_PER_MONTH, 'weeks'],
-            'years' => [Carbon::MONTHS_PER_YEAR, 'months'],
-        ];
-    }
-
-    private static function standardizeUnit($unit)
-    {
-        $unit = rtrim($unit, 'sz').'s';
-
-        return $unit === 'days' ? 'dayz' : $unit;
-    }
-
-    private static function getFlipCascadeFactors()
-    {
-        if (!self::$flipCascadeFactors) {
-            self::$flipCascadeFactors = [];
-
-            foreach (static::getCascadeFactors() as $to => [$factor, $from]) {
-                self::$flipCascadeFactors[self::standardizeUnit($from)] = [self::standardizeUnit($to), $factor];
-            }
-        }
-
-        return self::$flipCascadeFactors;
-    }
-
-    /**
-     * Set default cascading factors for ->cascade() method.
-     *
-     * @param array $cascadeFactors
-     */
-    public static function setCascadeFactors(array $cascadeFactors)
-    {
-        self::$flipCascadeFactors = null;
-        static::$cascadeFactors = $cascadeFactors;
-    }
-
-    ///////////////////////////////////////////////////////////////////
-    //////////////////////////// CONSTRUCTORS /////////////////////////
-    ///////////////////////////////////////////////////////////////////
-
-    /**
-     * Create a new CarbonInterval instance.
-     *
-     * @param Closure|DateInterval|string|int|null $years
-     * @param int|null                             $months
-     * @param int|null                             $weeks
-     * @param int|null                             $days
-     * @param int|null                             $hours
-     * @param int|null                             $minutes
-     * @param int|null                             $seconds
-     * @param int|null                             $microseconds
-     *
-     * @throws Exception when the interval_spec (passed as $years) cannot be parsed as an interval.
-     */
-    public function __construct($years = 1, $months = null, $weeks = null, $days = null, $hours = null, $minutes = null, $seconds = null, $microseconds = null)
-    {
-        if ($years instanceof Closure) {
-            $this->step = $years;
-            $years = null;
-        }
-
-        if ($years instanceof DateInterval) {
-            parent::__construct(static::getDateIntervalSpec($years));
-            $this->f = $years->f;
-            self::copyNegativeUnits($years, $this);
-
-            return;
-        }
-
-        $spec = $years;
-
-        if (!\is_string($spec) || (float) $years || preg_match('/^[\d.]/', $years)) {
-            $spec = static::PERIOD_PREFIX;
-
-            $spec .= $years > 0 ? $years.static::PERIOD_YEARS : '';
-            $spec .= $months > 0 ? $months.static::PERIOD_MONTHS : '';
-
-            $specDays = 0;
-            $specDays += $weeks > 0 ? $weeks * static::getDaysPerWeek() : 0;
-            $specDays += $days > 0 ? $days : 0;
-
-            $spec .= $specDays > 0 ? $specDays.static::PERIOD_DAYS : '';
-
-            if ($hours > 0 || $minutes > 0 || $seconds > 0) {
-                $spec .= static::PERIOD_TIME_PREFIX;
-                $spec .= $hours > 0 ? $hours.static::PERIOD_HOURS : '';
-                $spec .= $minutes > 0 ? $minutes.static::PERIOD_MINUTES : '';
-                $spec .= $seconds > 0 ? $seconds.static::PERIOD_SECONDS : '';
-            }
-
-            if ($spec === static::PERIOD_PREFIX) {
-                // Allow the zero interval.
-                $spec .= '0'.static::PERIOD_YEARS;
-            }
-        }
-
-        parent::__construct($spec);
-
-        if ($microseconds !== null) {
-            $this->f = $microseconds / Carbon::MICROSECONDS_PER_SECOND;
-        }
-    }
-
-    /**
-     * Returns the factor for a given source-to-target couple.
-     *
-     * @param string $source
-     * @param string $target
-     *
-     * @return int|null
-     */
-    public static function getFactor($source, $target)
-    {
-        $source = self::standardizeUnit($source);
-        $target = self::standardizeUnit($target);
-        $factors = self::getFlipCascadeFactors();
-
-        if (isset($factors[$source])) {
-            [$to, $factor] = $factors[$source];
-
-            if ($to === $target) {
-                return $factor;
-            }
-
-            return $factor * static::getFactor($to, $target);
-        }
-
-        return null;
-    }
-
-    /**
-     * Returns the factor for a given source-to-target couple if set,
-     * else try to find the appropriate constant as the factor, such as Carbon::DAYS_PER_WEEK.
-     *
-     * @param string $source
-     * @param string $target
-     *
-     * @return int|null
-     */
-    public static function getFactorWithDefault($source, $target)
-    {
-        $factor = self::getFactor($source, $target);
-
-        if ($factor) {
-            return $factor;
-        }
-
-        static $defaults = [
-            'month' => ['year' => Carbon::MONTHS_PER_YEAR],
-            'week' => ['month' => Carbon::WEEKS_PER_MONTH],
-            'day' => ['week' => Carbon::DAYS_PER_WEEK],
-            'hour' => ['day' => Carbon::HOURS_PER_DAY],
-            'minute' => ['hour' => Carbon::MINUTES_PER_HOUR],
-            'second' => ['minute' => Carbon::SECONDS_PER_MINUTE],
-            'millisecond' => ['second' => Carbon::MILLISECONDS_PER_SECOND],
-            'microsecond' => ['millisecond' => Carbon::MICROSECONDS_PER_MILLISECOND],
-        ];
-
-        return $defaults[$source][$target] ?? null;
-    }
-
-    /**
-     * Returns current config for days per week.
-     *
-     * @return int
-     */
-    public static function getDaysPerWeek()
-    {
-        return static::getFactor('dayz', 'weeks') ?: Carbon::DAYS_PER_WEEK;
-    }
-
-    /**
-     * Returns current config for hours per day.
-     *
-     * @return int
-     */
-    public static function getHoursPerDay()
-    {
-        return static::getFactor('hours', 'dayz') ?: Carbon::HOURS_PER_DAY;
-    }
-
-    /**
-     * Returns current config for minutes per hour.
-     *
-     * @return int
-     */
-    public static function getMinutesPerHour()
-    {
-        return static::getFactor('minutes', 'hours') ?: Carbon::MINUTES_PER_HOUR;
-    }
-
-    /**
-     * Returns current config for seconds per minute.
-     *
-     * @return int
-     */
-    public static function getSecondsPerMinute()
-    {
-        return static::getFactor('seconds', 'minutes') ?: Carbon::SECONDS_PER_MINUTE;
-    }
-
-    /**
-     * Returns current config for microseconds per second.
-     *
-     * @return int
-     */
-    public static function getMillisecondsPerSecond()
-    {
-        return static::getFactor('milliseconds', 'seconds') ?: Carbon::MILLISECONDS_PER_SECOND;
-    }
-
-    /**
-     * Returns current config for microseconds per second.
-     *
-     * @return int
-     */
-    public static function getMicrosecondsPerMillisecond()
-    {
-        return static::getFactor('microseconds', 'milliseconds') ?: Carbon::MICROSECONDS_PER_MILLISECOND;
-    }
-
-    /**
-     * Create a new CarbonInterval instance from specific values.
-     * This is an alias for the constructor that allows better fluent
-     * syntax as it allows you to do CarbonInterval::create(1)->fn() rather than
-     * (new CarbonInterval(1))->fn().
-     *
-     * @param int $years
-     * @param int $months
-     * @param int $weeks
-     * @param int $days
-     * @param int $hours
-     * @param int $minutes
-     * @param int $seconds
-     * @param int $microseconds
-     *
-     * @throws Exception when the interval_spec (passed as $years) cannot be parsed as an interval.
-     *
-     * @return static
-     */
-    public static function create($years = 1, $months = null, $weeks = null, $days = null, $hours = null, $minutes = null, $seconds = null, $microseconds = null)
-    {
-        return new static($years, $months, $weeks, $days, $hours, $minutes, $seconds, $microseconds);
-    }
-
-    /**
-     * Parse a string into a new CarbonInterval object according to the specified format.
-     *
-     * @example
-     * ```
-     * echo Carboninterval::createFromFormat('H:i', '1:30');
-     * ```
-     *
-     * @param string      $format   Format of the $interval input string
-     * @param string|null $interval Input string to convert into an interval
-     *
-     * @throws \Carbon\Exceptions\ParseErrorException when the $interval cannot be parsed as an interval.
-     *
-     * @return static
-     */
-    public static function createFromFormat(string $format, ?string $interval)
-    {
-        $instance = new static(0);
-        $length = mb_strlen($format);
-
-        if (preg_match('/s([,.])([uv])$/', $format, $match)) {
-            $interval = explode($match[1], $interval);
-            $index = \count($interval) - 1;
-            $interval[$index] = str_pad($interval[$index], $match[2] === 'v' ? 3 : 6, '0');
-            $interval = implode($match[1], $interval);
-        }
-
-        $interval = $interval ?? '';
-
-        for ($index = 0; $index < $length; $index++) {
-            $expected = mb_substr($format, $index, 1);
-            $nextCharacter = mb_substr($interval, 0, 1);
-            $unit = static::$formats[$expected] ?? null;
-
-            if ($unit) {
-                if (!preg_match('/^-?\d+/', $interval, $match)) {
-                    throw new ParseErrorException('number', $nextCharacter);
-                }
-
-                $interval = mb_substr($interval, mb_strlen($match[0]));
-                $instance->$unit += (int) ($match[0]);
-
-                continue;
-            }
-
-            if ($nextCharacter !== $expected) {
-                throw new ParseErrorException(
-                    "'$expected'",
-                    $nextCharacter,
-                    'Allowed substitutes for interval formats are '.implode(', ', array_keys(static::$formats))."\n".
-                    'See https://php.net/manual/en/function.date.php for their meaning'
-                );
-            }
-
-            $interval = mb_substr($interval, 1);
-        }
-
-        if ($interval !== '') {
-            throw new ParseErrorException(
-                'end of string',
-                $interval
-            );
-        }
-
-        return $instance;
-    }
-
-    /**
-     * Get a copy of the instance.
-     *
-     * @return static
-     */
-    public function copy()
-    {
-        $date = new static(0);
-        $date->copyProperties($this);
-        $date->step = $this->step;
-
-        return $date;
-    }
-
-    /**
-     * Get a copy of the instance.
-     *
-     * @return static
-     */
-    public function clone()
-    {
-        return $this->copy();
-    }
-
-    /**
-     * Provide static helpers to create instances.  Allows CarbonInterval::years(3).
-     *
-     * Note: This is done using the magic method to allow static and instance methods to
-     *       have the same names.
-     *
-     * @param string $method     magic method name called
-     * @param array  $parameters parameters list
-     *
-     * @return static|null
-     */
-    public static function __callStatic($method, $parameters)
-    {
-        try {
-            $interval = new static(0);
-            $localStrictModeEnabled = $interval->localStrictModeEnabled;
-            $interval->localStrictModeEnabled = true;
-
-            $result = static::hasMacro($method)
-                ? static::bindMacroContext(null, function () use (&$method, &$parameters, &$interval) {
-                    return $interval->callMacro($method, $parameters);
-                })
-                : $interval->$method(...$parameters);
-
-            $interval->localStrictModeEnabled = $localStrictModeEnabled;
-
-            return $result;
-        } catch (BadFluentSetterException $exception) {
-            if (Carbon::isStrictModeEnabled()) {
-                throw new BadFluentConstructorException($method, 0, $exception);
-            }
-
-            return null;
-        }
-    }
-
-    /**
-     * Return the current context from inside a macro callee or a new one if static.
-     *
-     * @return static
-     */
-    protected static function this()
-    {
-        return end(static::$macroContextStack) ?: new static(0);
-    }
-
-    /**
-     * Creates a CarbonInterval from string.
-     *
-     * Format:
-     *
-     * Suffix | Unit    | Example | DateInterval expression
-     * -------|---------|---------|------------------------
-     * y      | years   |   1y    | P1Y
-     * mo     | months  |   3mo   | P3M
-     * w      | weeks   |   2w    | P2W
-     * d      | days    |  28d    | P28D
-     * h      | hours   |   4h    | PT4H
-     * m      | minutes |  12m    | PT12M
-     * s      | seconds |  59s    | PT59S
-     *
-     * e. g. `1w 3d 4h 32m 23s` is converted to 10 days 4 hours 32 minutes and 23 seconds.
-     *
-     * Special cases:
-     *  - An empty string will return a zero interval
-     *  - Fractions are allowed for weeks, days, hours and minutes and will be converted
-     *    and rounded to the next smaller value (caution: 0.5w = 4d)
-     *
-     * @param string $intervalDefinition
-     *
-     * @return static
-     */
-    public static function fromString($intervalDefinition)
-    {
-        if (empty($intervalDefinition)) {
-            return new static(0);
-        }
-
-        $years = 0;
-        $months = 0;
-        $weeks = 0;
-        $days = 0;
-        $hours = 0;
-        $minutes = 0;
-        $seconds = 0;
-        $milliseconds = 0;
-        $microseconds = 0;
-
-        $pattern = '/(\d+(?:\.\d+)?)\h*([^\d\h]*)/i';
-        preg_match_all($pattern, $intervalDefinition, $parts, PREG_SET_ORDER);
-
-        while ([$part, $value, $unit] = array_shift($parts)) {
-            $intValue = (int) $value;
-            $fraction = (float) $value - $intValue;
-
-            // Fix calculation precision
-            switch (round($fraction, 6)) {
-                case 1:
-                    $fraction = 0;
-                    $intValue++;
-
-                    break;
-                case 0:
-                    $fraction = 0;
-
-                    break;
-            }
-
-            switch ($unit === 'µs' ? 'µs' : strtolower($unit)) {
-                case 'millennia':
-                case 'millennium':
-                    $years += $intValue * CarbonInterface::YEARS_PER_MILLENNIUM;
-
-                    break;
-
-                case 'century':
-                case 'centuries':
-                    $years += $intValue * CarbonInterface::YEARS_PER_CENTURY;
-
-                    break;
-
-                case 'decade':
-                case 'decades':
-                    $years += $intValue * CarbonInterface::YEARS_PER_DECADE;
-
-                    break;
-
-                case 'year':
-                case 'years':
-                case 'y':
-                    $years += $intValue;
-
-                    break;
-
-                case 'quarter':
-                case 'quarters':
-                    $months += $intValue * CarbonInterface::MONTHS_PER_QUARTER;
-
-                    break;
-
-                case 'month':
-                case 'months':
-                case 'mo':
-                    $months += $intValue;
-
-                    break;
-
-                case 'week':
-                case 'weeks':
-                case 'w':
-                    $weeks += $intValue;
-
-                    if ($fraction) {
-                        $parts[] = [null, $fraction * static::getDaysPerWeek(), 'd'];
-                    }
-
-                    break;
-
-                case 'day':
-                case 'days':
-                case 'd':
-                    $days += $intValue;
-
-                    if ($fraction) {
-                        $parts[] = [null, $fraction * static::getHoursPerDay(), 'h'];
-                    }
-
-                    break;
-
-                case 'hour':
-                case 'hours':
-                case 'h':
-                    $hours += $intValue;
+	use IntervalRounding;
+	use IntervalStep;
+	use Mixin {
+		Mixin::mixin as baseMixin;
+	}
+	use Options;
+
+	/**
+	 * Interval spec period designators
+	 */
+	public const PERIOD_PREFIX = 'P';
+	public const PERIOD_YEARS = 'Y';
+	public const PERIOD_MONTHS = 'M';
+	public const PERIOD_DAYS = 'D';
+	public const PERIOD_TIME_PREFIX = 'T';
+	public const PERIOD_HOURS = 'H';
+	public const PERIOD_MINUTES = 'M';
+	public const PERIOD_SECONDS = 'S';
+
+	/**
+	 * A translator to ... er ... translate stuff
+	 *
+	 * @var \Symfony\Component\Translation\TranslatorInterface
+	 */
+	protected static $translator;
+
+	/**
+	 * @var array|null
+	 */
+	protected static $cascadeFactors;
+
+	/**
+	 * @var array
+	 */
+	protected static $formats = [
+		'y' => 'y',
+		'Y' => 'y',
+		'o' => 'y',
+		'm' => 'm',
+		'n' => 'm',
+		'W' => 'weeks',
+		'd' => 'd',
+		'j' => 'd',
+		'z' => 'd',
+		'h' => 'h',
+		'g' => 'h',
+		'H' => 'h',
+		'G' => 'h',
+		'i' => 'i',
+		's' => 's',
+		'u' => 'micro',
+		'v' => 'milli',
+	];
+
+	/**
+	 * @var array|null
+	 */
+	private static $flipCascadeFactors;
+
+	/**
+	 * The registered macros.
+	 *
+	 * @var array
+	 */
+	protected static $macros = [];
+
+	/**
+	 * Timezone handler for settings() method.
+	 *
+	 * @var mixed
+	 */
+	protected $tzName;
+
+	/**
+	 * Set the instance's timezone from a string or object.
+	 *
+	 * @param \DateTimeZone|string $tzName
+	 *
+	 * @return static
+	 */
+	public function setTimezone($tzName)
+	{
+		$this->tzName = $tzName;
+
+		return $this;
+	}
+
+	/**
+	 * @internal
+	 *
+	 * Set the instance's timezone from a string or object and add/subtract the offset difference.
+	 *
+	 * @param \DateTimeZone|string $tzName
+	 *
+	 * @return static
+	 */
+	public function shiftTimezone($tzName)
+	{
+		$this->tzName = $tzName;
+
+		return $this;
+	}
+
+	/**
+	 * Mapping of units and factors for cascading.
+	 *
+	 * Should only be modified by changing the factors or referenced constants.
+	 *
+	 * @return array
+	 */
+	public static function getCascadeFactors()
+	{
+		return static::$cascadeFactors ?: [
+			'milliseconds' => [Carbon::MICROSECONDS_PER_MILLISECOND, 'microseconds'],
+			'seconds' => [Carbon::MILLISECONDS_PER_SECOND, 'milliseconds'],
+			'minutes' => [Carbon::SECONDS_PER_MINUTE, 'seconds'],
+			'hours' => [Carbon::MINUTES_PER_HOUR, 'minutes'],
+			'dayz' => [Carbon::HOURS_PER_DAY, 'hours'],
+			'weeks' => [Carbon::DAYS_PER_WEEK, 'dayz'],
+			'months' => [Carbon::WEEKS_PER_MONTH, 'weeks'],
+			'years' => [Carbon::MONTHS_PER_YEAR, 'months'],
+		];
+	}
+
+	private static function standardizeUnit($unit)
+	{
+		$unit = rtrim($unit, 'sz').'s';
+
+		return $unit === 'days' ? 'dayz' : $unit;
+	}
+
+	private static function getFlipCascadeFactors()
+	{
+		if (!self::$flipCascadeFactors) {
+			self::$flipCascadeFactors = [];
+
+			foreach (static::getCascadeFactors() as $to => [$factor, $from]) {
+				self::$flipCascadeFactors[self::standardizeUnit($from)] = [self::standardizeUnit($to), $factor];
+			}
+		}
+
+		return self::$flipCascadeFactors;
+	}
+
+	/**
+	 * Set default cascading factors for ->cascade() method.
+	 *
+	 * @param array $cascadeFactors
+	 */
+	public static function setCascadeFactors(array $cascadeFactors)
+	{
+		self::$flipCascadeFactors = null;
+		static::$cascadeFactors = $cascadeFactors;
+	}
+
+	///////////////////////////////////////////////////////////////////
+	//////////////////////////// CONSTRUCTORS /////////////////////////
+	///////////////////////////////////////////////////////////////////
+
+	/**
+	 * Create a new CarbonInterval instance.
+	 *
+	 * @param Closure|DateInterval|string|int|null $years
+	 * @param int|null                             $months
+	 * @param int|null                             $weeks
+	 * @param int|null                             $days
+	 * @param int|null                             $hours
+	 * @param int|null                             $minutes
+	 * @param int|null                             $seconds
+	 * @param int|null                             $microseconds
+	 *
+	 * @throws Exception when the interval_spec (passed as $years) cannot be parsed as an interval.
+	 */
+	public function __construct($years = 1, $months = null, $weeks = null, $days = null, $hours = null, $minutes = null, $seconds = null, $microseconds = null)
+	{
+		if ($years instanceof Closure) {
+			$this->step = $years;
+			$years = null;
+		}
+
+		if ($years instanceof DateInterval) {
+			parent::__construct(static::getDateIntervalSpec($years));
+			$this->f = $years->f;
+			self::copyNegativeUnits($years, $this);
+
+			return;
+		}
+
+		$spec = $years;
+
+		if (!\is_string($spec) || (float) $years || preg_match('/^[\d.]/', $years)) {
+			$spec = static::PERIOD_PREFIX;
+
+			$spec .= $years > 0 ? $years.static::PERIOD_YEARS : '';
+			$spec .= $months > 0 ? $months.static::PERIOD_MONTHS : '';
+
+			$specDays = 0;
+			$specDays += $weeks > 0 ? $weeks * static::getDaysPerWeek() : 0;
+			$specDays += $days > 0 ? $days : 0;
+
+			$spec .= $specDays > 0 ? $specDays.static::PERIOD_DAYS : '';
+
+			if ($hours > 0 || $minutes > 0 || $seconds > 0) {
+				$spec .= static::PERIOD_TIME_PREFIX;
+				$spec .= $hours > 0 ? $hours.static::PERIOD_HOURS : '';
+				$spec .= $minutes > 0 ? $minutes.static::PERIOD_MINUTES : '';
+				$spec .= $seconds > 0 ? $seconds.static::PERIOD_SECONDS : '';
+			}
+
+			if ($spec === static::PERIOD_PREFIX) {
+				// Allow the zero interval.
+				$spec .= '0'.static::PERIOD_YEARS;
+			}
+		}
+
+		parent::__construct($spec);
+
+		if ($microseconds !== null) {
+			$this->f = $microseconds / Carbon::MICROSECONDS_PER_SECOND;
+		}
+	}
+
+	/**
+	 * Returns the factor for a given source-to-target couple.
+	 *
+	 * @param string $source
+	 * @param string $target
+	 *
+	 * @return int|null
+	 */
+	public static function getFactor($source, $target)
+	{
+		$source = self::standardizeUnit($source);
+		$target = self::standardizeUnit($target);
+		$factors = self::getFlipCascadeFactors();
+
+		if (isset($factors[$source])) {
+			[$to, $factor] = $factors[$source];
+
+			if ($to === $target) {
+				return $factor;
+			}
+
+			return $factor * static::getFactor($to, $target);
+		}
+
+		return null;
+	}
+
+	/**
+	 * Returns the factor for a given source-to-target couple if set,
+	 * else try to find the appropriate constant as the factor, such as Carbon::DAYS_PER_WEEK.
+	 *
+	 * @param string $source
+	 * @param string $target
+	 *
+	 * @return int|null
+	 */
+	public static function getFactorWithDefault($source, $target)
+	{
+		$factor = self::getFactor($source, $target);
+
+		if ($factor) {
+			return $factor;
+		}
+
+		static $defaults = [
+			'month' => ['year' => Carbon::MONTHS_PER_YEAR],
+			'week' => ['month' => Carbon::WEEKS_PER_MONTH],
+			'day' => ['week' => Carbon::DAYS_PER_WEEK],
+			'hour' => ['day' => Carbon::HOURS_PER_DAY],
+			'minute' => ['hour' => Carbon::MINUTES_PER_HOUR],
+			'second' => ['minute' => Carbon::SECONDS_PER_MINUTE],
+			'millisecond' => ['second' => Carbon::MILLISECONDS_PER_SECOND],
+			'microsecond' => ['millisecond' => Carbon::MICROSECONDS_PER_MILLISECOND],
+		];
+
+		return $defaults[$source][$target] ?? null;
+	}
+
+	/**
+	 * Returns current config for days per week.
+	 *
+	 * @return int
+	 */
+	public static function getDaysPerWeek()
+	{
+		return static::getFactor('dayz', 'weeks') ?: Carbon::DAYS_PER_WEEK;
+	}
+
+	/**
+	 * Returns current config for hours per day.
+	 *
+	 * @return int
+	 */
+	public static function getHoursPerDay()
+	{
+		return static::getFactor('hours', 'dayz') ?: Carbon::HOURS_PER_DAY;
+	}
+
+	/**
+	 * Returns current config for minutes per hour.
+	 *
+	 * @return int
+	 */
+	public static function getMinutesPerHour()
+	{
+		return static::getFactor('minutes', 'hours') ?: Carbon::MINUTES_PER_HOUR;
+	}
+
+	/**
+	 * Returns current config for seconds per minute.
+	 *
+	 * @return int
+	 */
+	public static function getSecondsPerMinute()
+	{
+		return static::getFactor('seconds', 'minutes') ?: Carbon::SECONDS_PER_MINUTE;
+	}
+
+	/**
+	 * Returns current config for microseconds per second.
+	 *
+	 * @return int
+	 */
+	public static function getMillisecondsPerSecond()
+	{
+		return static::getFactor('milliseconds', 'seconds') ?: Carbon::MILLISECONDS_PER_SECOND;
+	}
+
+	/**
+	 * Returns current config for microseconds per second.
+	 *
+	 * @return int
+	 */
+	public static function getMicrosecondsPerMillisecond()
+	{
+		return static::getFactor('microseconds', 'milliseconds') ?: Carbon::MICROSECONDS_PER_MILLISECOND;
+	}
+
+	/**
+	 * Create a new CarbonInterval instance from specific values.
+	 * This is an alias for the constructor that allows better fluent
+	 * syntax as it allows you to do CarbonInterval::create(1)->fn() rather than
+	 * (new CarbonInterval(1))->fn().
+	 *
+	 * @param int $years
+	 * @param int $months
+	 * @param int $weeks
+	 * @param int $days
+	 * @param int $hours
+	 * @param int $minutes
+	 * @param int $seconds
+	 * @param int $microseconds
+	 *
+	 * @throws Exception when the interval_spec (passed as $years) cannot be parsed as an interval.
+	 *
+	 * @return static
+	 */
+	public static function create($years = 1, $months = null, $weeks = null, $days = null, $hours = null, $minutes = null, $seconds = null, $microseconds = null)
+	{
+		return new static($years, $months, $weeks, $days, $hours, $minutes, $seconds, $microseconds);
+	}
+
+	/**
+	 * Parse a string into a new CarbonInterval object according to the specified format.
+	 *
+	 * @example
+	 * ```
+	 * echo Carboninterval::createFromFormat('H:i', '1:30');
+	 * ```
+	 *
+	 * @param string      $format   Format of the $interval input string
+	 * @param string|null $interval Input string to convert into an interval
+	 *
+	 * @throws \Carbon\Exceptions\ParseErrorException when the $interval cannot be parsed as an interval.
+	 *
+	 * @return static
+	 */
+	public static function createFromFormat(string $format, ?string $interval)
+	{
+		$instance = new static(0);
+		$length = mb_strlen($format);
+
+		if (preg_match('/s([,.])([uv])$/', $format, $match)) {
+			$interval = explode($match[1], $interval);
+			$index = \count($interval) - 1;
+			$interval[$index] = str_pad($interval[$index], $match[2] === 'v' ? 3 : 6, '0');
+			$interval = implode($match[1], $interval);
+		}
+
+		$interval = $interval ?? '';
+
+		for ($index = 0; $index < $length; $index++) {
+			$expected = mb_substr($format, $index, 1);
+			$nextCharacter = mb_substr($interval, 0, 1);
+			$unit = static::$formats[$expected] ?? null;
+
+			if ($unit) {
+				if (!preg_match('/^-?\d+/', $interval, $match)) {
+					throw new ParseErrorException('number', $nextCharacter);
+				}
+
+				$interval = mb_substr($interval, mb_strlen($match[0]));
+				$instance->$unit += (int) ($match[0]);
+
+				continue;
+			}
+
+			if ($nextCharacter !== $expected) {
+				throw new ParseErrorException(
+					"'$expected'",
+					$nextCharacter,
+					'Allowed substitutes for interval formats are '.implode(', ', array_keys(static::$formats))."\n".
+					'See https://php.net/manual/en/function.date.php for their meaning'
+				);
+			}
+
+			$interval = mb_substr($interval, 1);
+		}
+
+		if ($interval !== '') {
+			throw new ParseErrorException(
+				'end of string',
+				$interval
+			);
+		}
+
+		return $instance;
+	}
+
+	/**
+	 * Get a copy of the instance.
+	 *
+	 * @return static
+	 */
+	public function copy()
+	{
+		$date = new static(0);
+		$date->copyProperties($this);
+		$date->step = $this->step;
+
+		return $date;
+	}
+
+	/**
+	 * Get a copy of the instance.
+	 *
+	 * @return static
+	 */
+	public function clone()
+	{
+		return $this->copy();
+	}
+
+	/**
+	 * Provide static helpers to create instances.  Allows CarbonInterval::years(3).
+	 *
+	 * Note: This is done using the magic method to allow static and instance methods to
+	 *       have the same names.
+	 *
+	 * @param string $method     magic method name called
+	 * @param array  $parameters parameters list
+	 *
+	 * @return static|null
+	 */
+	public static function __callStatic($method, $parameters)
+	{
+		try {
+			$interval = new static(0);
+			$localStrictModeEnabled = $interval->localStrictModeEnabled;
+			$interval->localStrictModeEnabled = true;
+
+			$result = static::hasMacro($method)
+				? static::bindMacroContext(null, function () use (&$method, &$parameters, &$interval) {
+					return $interval->callMacro($method, $parameters);
+				})
+				: $interval->$method(...$parameters);
+
+			$interval->localStrictModeEnabled = $localStrictModeEnabled;
+
+			return $result;
+		} catch (BadFluentSetterException $exception) {
+			if (Carbon::isStrictModeEnabled()) {
+				throw new BadFluentConstructorException($method, 0, $exception);
+			}
+
+			return null;
+		}
+	}
+
+	/**
+	 * Return the current context from inside a macro callee or a new one if static.
+	 *
+	 * @return static
+	 */
+	protected static function this()
+	{
+		return end(static::$macroContextStack) ?: new static(0);
+	}
+
+	/**
+	 * Creates a CarbonInterval from string.
+	 *
+	 * Format:
+	 *
+	 * Suffix | Unit    | Example | DateInterval expression
+	 * -------|---------|---------|------------------------
+	 * y      | years   |   1y    | P1Y
+	 * mo     | months  |   3mo   | P3M
+	 * w      | weeks   |   2w    | P2W
+	 * d      | days    |  28d    | P28D
+	 * h      | hours   |   4h    | PT4H
+	 * m      | minutes |  12m    | PT12M
+	 * s      | seconds |  59s    | PT59S
+	 *
+	 * e. g. `1w 3d 4h 32m 23s` is converted to 10 days 4 hours 32 minutes and 23 seconds.
+	 *
+	 * Special cases:
+	 *  - An empty string will return a zero interval
+	 *  - Fractions are allowed for weeks, days, hours and minutes and will be converted
+	 *    and rounded to the next smaller value (caution: 0.5w = 4d)
+	 *
+	 * @param string $intervalDefinition
+	 *
+	 * @return static
+	 */
+	public static function fromString($intervalDefinition)
+	{
+		if (empty($intervalDefinition)) {
+			return new static(0);
+		}
+
+		$years = 0;
+		$months = 0;
+		$weeks = 0;
+		$days = 0;
+		$hours = 0;
+		$minutes = 0;
+		$seconds = 0;
+		$milliseconds = 0;
+		$microseconds = 0;
+
+		$pattern = '/(\d+(?:\.\d+)?)\h*([^\d\h]*)/i';
+		preg_match_all($pattern, $intervalDefinition, $parts, PREG_SET_ORDER);
+
+		while ([$part, $value, $unit] = array_shift($parts)) {
+			$intValue = (int) $value;
+			$fraction = (float) $value - $intValue;
+
+			// Fix calculation precision
+			switch (round($fraction, 6)) {
+				case 1:
+					$fraction = 0;
+					$intValue++;
+
+					break;
+				case 0:
+					$fraction = 0;
+
+					break;
+			}
+
+			switch ($unit === 'µs' ? 'µs' : strtolower($unit)) {
+				case 'millennia':
+				case 'millennium':
+					$years += $intValue * CarbonInterface::YEARS_PER_MILLENNIUM;
+
+					break;
+
+				case 'century':
+				case 'centuries':
+					$years += $intValue * CarbonInterface::YEARS_PER_CENTURY;
+
+					break;
+
+				case 'decade':
+				case 'decades':
+					$years += $intValue * CarbonInterface::YEARS_PER_DECADE;
+
+					break;
+
+				case 'year':
+				case 'years':
+				case 'y':
+					$years += $intValue;
+
+					break;
+
+				case 'quarter':
+				case 'quarters':
+					$months += $intValue * CarbonInterface::MONTHS_PER_QUARTER;
+
+					break;
+
+				case 'month':
+				case 'months':
+				case 'mo':
+					$months += $intValue;
+
+					break;
+
+				case 'week':
+				case 'weeks':
+				case 'w':
+					$weeks += $intValue;
+
+					if ($fraction) {
+						$parts[] = [null, $fraction * static::getDaysPerWeek(), 'd'];
+					}
+
+					break;
+
+				case 'day':
+				case 'days':
+				case 'd':
+					$days += $intValue;
+
+					if ($fraction) {
+						$parts[] = [null, $fraction * static::getHoursPerDay(), 'h'];
+					}
+
+					break;
+
+				case 'hour':
+				case 'hours':
+				case 'h':
+					$hours += $intValue;
 
-                    if ($fraction) {
-                        $parts[] = [null, $fraction * static::getMinutesPerHour(), 'm'];
-                    }
+					if ($fraction) {
+						$parts[] = [null, $fraction * static::getMinutesPerHour(), 'm'];
+					}
 
-                    break;
+					break;
 
-                case 'minute':
-                case 'minutes':
-                case 'm':
-                    $minutes += $intValue;
+				case 'minute':
+				case 'minutes':
+				case 'm':
+					$minutes += $intValue;
 
-                    if ($fraction) {
-                        $parts[] = [null, $fraction * static::getSecondsPerMinute(), 's'];
-                    }
+					if ($fraction) {
+						$parts[] = [null, $fraction * static::getSecondsPerMinute(), 's'];
+					}
 
-                    break;
+					break;
 
-                case 'second':
-                case 'seconds':
-                case 's':
-                    $seconds += $intValue;
-
-                    if ($fraction) {
-                        $parts[] = [null, $fraction * static::getMillisecondsPerSecond(), 'ms'];
-                    }
-
-                    break;
-
-                case 'millisecond':
-                case 'milliseconds':
-                case 'milli':
-                case 'ms':
-                    $milliseconds += $intValue;
-
-                    if ($fraction) {
-                        $microseconds += round($fraction * static::getMicrosecondsPerMillisecond());
-                    }
-
-                    break;
-
-                case 'microsecond':
-                case 'microseconds':
-                case 'micro':
-                case 'µs':
-                    $microseconds += $intValue;
-
-                    break;
-
-                default:
-                    throw new InvalidIntervalException(
-                        sprintf('Invalid part %s in definition %s', $part, $intervalDefinition)
-                    );
-            }
-        }
-
-        return new static($years, $months, $weeks, $days, $hours, $minutes, $seconds, $milliseconds * Carbon::MICROSECONDS_PER_MILLISECOND + $microseconds);
-    }
-
-    /**
-     * Creates a CarbonInterval from string using a different locale.
-     *
-     * @param string      $interval interval string in the given language (may also contain English).
-     * @param string|null $locale   if locale is null or not specified, current global locale will be used instead.
-     *
-     * @return static
-     */
-    public static function parseFromLocale($interval, $locale = null)
-    {
-        return static::fromString(Carbon::translateTimeString($interval, $locale ?: static::getLocale(), 'en'));
-    }
-
-    private static function castIntervalToClass(DateInterval $interval, string $className)
-    {
-        $mainClass = DateInterval::class;
-
-        if (!is_a($className, $mainClass, true)) {
-            throw new InvalidCastException("$className is not a sub-class of $mainClass.");
-        }
-
-        $microseconds = $interval->f;
-        $instance = new $className(static::getDateIntervalSpec($interval));
-
-        if ($microseconds) {
-            $instance->f = $microseconds;
-        }
-
-        if ($interval instanceof self && is_a($className, self::class, true)) {
-            self::copyStep($interval, $instance);
-        }
-
-        self::copyNegativeUnits($interval, $instance);
-
-        return $instance;
-    }
-
-    private static function copyNegativeUnits(DateInterval $from, DateInterval $to): void
-    {
-        $to->invert = $from->invert;
-
-        foreach (['y', 'm', 'd', 'h', 'i', 's'] as $unit) {
-            if ($from->$unit < 0) {
-                $to->$unit *= -1;
-            }
-        }
-    }
-
-    private static function copyStep(self $from, self $to): void
-    {
-        $to->setStep($from->getStep());
-    }
-
-    /**
-     * Cast the current instance into the given class.
-     *
-     * @param string $className The $className::instance() method will be called to cast the current object.
-     *
-     * @return DateInterval
-     */
-    public function cast(string $className)
-    {
-        return self::castIntervalToClass($this, $className);
-    }
-
-    /**
-     * Create a CarbonInterval instance from a DateInterval one.  Can not instance
-     * DateInterval objects created from DateTime::diff() as you can't externally
-     * set the $days field.
-     *
-     * @param DateInterval $interval
-     *
-     * @return static
-     */
-    public static function instance(DateInterval $interval)
-    {
-        return self::castIntervalToClass($interval, static::class);
-    }
-
-    /**
-     * Make a CarbonInterval instance from given variable if possible.
-     *
-     * Always return a new instance. Parse only strings and only these likely to be intervals (skip dates
-     * and recurrences). Throw an exception for invalid format, but otherwise return null.
-     *
-     * @param mixed|int|DateInterval|string|Closure|null $interval interval or number of the given $unit
-     * @param string|null                                $unit     if specified, $interval must be an integer
-     *
-     * @return static|null
-     */
-    public static function make($interval, $unit = null)
-    {
-        if ($unit) {
-            $interval = "$interval ".Carbon::pluralUnit($unit);
-        }
-
-        if ($interval instanceof DateInterval) {
-            return static::instance($interval);
-        }
-
-        if ($interval instanceof Closure) {
-            return new static($interval);
-        }
-
-        if (!\is_string($interval)) {
-            return null;
-        }
-
-        return static::makeFromString($interval);
-    }
-
-    protected static function makeFromString(string $interval)
-    {
-        $interval = preg_replace('/\s+/', ' ', trim($interval));
-
-        if (preg_match('/^P[T\d]/', $interval)) {
-            return new static($interval);
-        }
-
-        if (preg_match('/^(?:\h*\d+(?:\.\d+)?\h*[a-z]+)+$/i', $interval)) {
-            return static::fromString($interval);
-        }
-
-        /** @var static $interval */
-        $interval = static::createFromDateString($interval);
-
-        return !$interval || $interval->isEmpty() ? null : $interval;
-    }
-
-    protected function resolveInterval($interval)
-    {
-        if (!($interval instanceof self)) {
-            return self::make($interval);
-        }
-
-        return $interval;
-    }
-
-    /**
-     * Sets up a DateInterval from the relative parts of the string.
-     *
-     * @param string $time
-     *
-     * @return static
-     *
-     * @link https://php.net/manual/en/dateinterval.createfromdatestring.php
-     */
-    #[ReturnTypeWillChange]
-    public static function createFromDateString($time)
-    {
-        $interval = @parent::createFromDateString(strtr($time, [
-            ',' => ' ',
-            ' and ' => ' ',
-        ]));
-
-        if ($interval instanceof DateInterval) {
-            $interval = static::instance($interval);
-        }
-
-        return $interval;
-    }
-
-    ///////////////////////////////////////////////////////////////////
-    ///////////////////////// GETTERS AND SETTERS /////////////////////
-    ///////////////////////////////////////////////////////////////////
-
-    /**
-     * Get a part of the CarbonInterval object.
-     *
-     * @param string $name
-     *
-     * @throws UnknownGetterException
-     *
-     * @return int|float|string
-     */
-    public function get($name)
-    {
-        if (str_starts_with($name, 'total')) {
-            return $this->total(substr($name, 5));
-        }
-
-        switch ($name) {
-            case 'years':
-                return $this->y;
-
-            case 'months':
-                return $this->m;
-
-            case 'dayz':
-                return $this->d;
-
-            case 'hours':
-                return $this->h;
-
-            case 'minutes':
-                return $this->i;
-
-            case 'seconds':
-                return $this->s;
-
-            case 'milli':
-            case 'milliseconds':
-                return (int) (round($this->f * Carbon::MICROSECONDS_PER_SECOND) / Carbon::MICROSECONDS_PER_MILLISECOND);
-
-            case 'micro':
-            case 'microseconds':
-                return (int) round($this->f * Carbon::MICROSECONDS_PER_SECOND);
-
-            case 'microExcludeMilli':
-                return (int) round($this->f * Carbon::MICROSECONDS_PER_SECOND) % Carbon::MICROSECONDS_PER_MILLISECOND;
-
-            case 'weeks':
-                return (int) ($this->d / static::getDaysPerWeek());
-
-            case 'daysExcludeWeeks':
-            case 'dayzExcludeWeeks':
-                return $this->d % static::getDaysPerWeek();
-
-            case 'locale':
-                return $this->getTranslatorLocale();
-
-            default:
-                throw new UnknownGetterException($name);
-        }
-    }
-
-    /**
-     * Get a part of the CarbonInterval object.
-     *
-     * @param string $name
-     *
-     * @throws UnknownGetterException
-     *
-     * @return int|float|string
-     */
-    public function __get($name)
-    {
-        return $this->get($name);
-    }
-
-    /**
-     * Set a part of the CarbonInterval object.
-     *
-     * @param string|array $name
-     * @param int          $value
-     *
-     * @throws UnknownSetterException
-     *
-     * @return $this
-     */
-    public function set($name, $value = null)
-    {
-        $properties = \is_array($name) ? $name : [$name => $value];
-
-        foreach ($properties as $key => $value) {
-            switch (Carbon::singularUnit(rtrim($key, 'z'))) {
-                case 'year':
-                    $this->y = $value;
-
-                    break;
-
-                case 'month':
-                    $this->m = $value;
-
-                    break;
-
-                case 'week':
-                    $this->d = $value * static::getDaysPerWeek();
-
-                    break;
-
-                case 'day':
-                    $this->d = $value;
-
-                    break;
-
-                case 'daysexcludeweek':
-                case 'dayzexcludeweek':
-                    $this->d = $this->weeks * static::getDaysPerWeek() + $value;
-
-                    break;
-
-                case 'hour':
-                    $this->h = $value;
-
-                    break;
-
-                case 'minute':
-                    $this->i = $value;
-
-                    break;
-
-                case 'second':
-                    $this->s = $value;
-
-                    break;
-
-                case 'milli':
-                case 'millisecond':
-                    $this->microseconds = $value * Carbon::MICROSECONDS_PER_MILLISECOND + $this->microseconds % Carbon::MICROSECONDS_PER_MILLISECOND;
-
-                    break;
-
-                case 'micro':
-                case 'microsecond':
-                    $this->f = $value / Carbon::MICROSECONDS_PER_SECOND;
-
-                    break;
-
-                default:
-                    if ($this->localStrictModeEnabled ?? Carbon::isStrictModeEnabled()) {
-                        throw new UnknownSetterException($key);
-                    }
-
-                    $this->$key = $value;
-            }
-        }
-
-        return $this;
-    }
-
-    /**
-     * Set a part of the CarbonInterval object.
-     *
-     * @param string $name
-     * @param int    $value
-     *
-     * @throws UnknownSetterException
-     */
-    public function __set($name, $value)
-    {
-        $this->set($name, $value);
-    }
-
-    /**
-     * Allow setting of weeks and days to be cumulative.
-     *
-     * @param int $weeks Number of weeks to set
-     * @param int $days  Number of days to set
-     *
-     * @return static
-     */
-    public function weeksAndDays($weeks, $days)
-    {
-        $this->dayz = ($weeks * static::getDaysPerWeek()) + $days;
-
-        return $this;
-    }
-
-    /**
-     * Returns true if the interval is empty for each unit.
-     *
-     * @return bool
-     */
-    public function isEmpty()
-    {
-        return $this->years === 0 &&
-            $this->months === 0 &&
-            $this->dayz === 0 &&
-            !$this->days &&
-            $this->hours === 0 &&
-            $this->minutes === 0 &&
-            $this->seconds === 0 &&
-            $this->microseconds === 0;
-    }
-
-    /**
-     * Register a custom macro.
-     *
-     * @example
-     * ```
-     * CarbonInterval::macro('twice', function () {
-     *   return $this->times(2);
-     * });
-     * echo CarbonInterval::hours(2)->twice();
-     * ```
-     *
-     * @param string          $name
-     * @param object|callable $macro
-     *
-     * @return void
-     */
-    public static function macro($name, $macro)
-    {
-        static::$macros[$name] = $macro;
-    }
-
-    /**
-     * Register macros from a mixin object.
-     *
-     * @example
-     * ```
-     * CarbonInterval::mixin(new class {
-     *   public function daysToHours() {
-     *     return function () {
-     *       $this->hours += $this->days;
-     *       $this->days = 0;
-     *
-     *       return $this;
-     *     };
-     *   }
-     *   public function hoursToDays() {
-     *     return function () {
-     *       $this->days += $this->hours;
-     *       $this->hours = 0;
-     *
-     *       return $this;
-     *     };
-     *   }
-     * });
-     * echo CarbonInterval::hours(5)->hoursToDays() . "\n";
-     * echo CarbonInterval::days(5)->daysToHours() . "\n";
-     * ```
-     *
-     * @param object|string $mixin
-     *
-     * @throws ReflectionException
-     *
-     * @return void
-     */
-    public static function mixin($mixin)
-    {
-        static::baseMixin($mixin);
-    }
-
-    /**
-     * Check if macro is registered.
-     *
-     * @param string $name
-     *
-     * @return bool
-     */
-    public static function hasMacro($name)
-    {
-        return isset(static::$macros[$name]);
-    }
-
-    /**
-     * Call given macro.
-     *
-     * @param string $name
-     * @param array  $parameters
-     *
-     * @return mixed
-     */
-    protected function callMacro($name, $parameters)
-    {
-        $macro = static::$macros[$name];
-
-        if ($macro instanceof Closure) {
-            $boundMacro = @$macro->bindTo($this, static::class) ?: @$macro->bindTo(null, static::class);
-
-            return ($boundMacro ?: $macro)(...$parameters);
-        }
-
-        return $macro(...$parameters);
-    }
-
-    /**
-     * Allow fluent calls on the setters... CarbonInterval::years(3)->months(5)->day().
-     *
-     * Note: This is done using the magic method to allow static and instance methods to
-     *       have the same names.
-     *
-     * @param string $method     magic method name called
-     * @param array  $parameters parameters list
-     *
-     * @throws BadFluentSetterException|Throwable
-     *
-     * @return static
-     */
-    public function __call($method, $parameters)
-    {
-        if (static::hasMacro($method)) {
-            return static::bindMacroContext($this, function () use (&$method, &$parameters) {
-                return $this->callMacro($method, $parameters);
-            });
-        }
-
-        $roundedValue = $this->callRoundMethod($method, $parameters);
-
-        if ($roundedValue !== null) {
-            return $roundedValue;
-        }
-
-        if (preg_match('/^(?<method>add|sub)(?<unit>[A-Z].*)$/', $method, $match)) {
-            return $this->{$match['method']}($parameters[0], $match['unit']);
-        }
-
-        try {
-            $this->set($method, \count($parameters) === 0 ? 1 : $parameters[0]);
-        } catch (UnknownSetterException $exception) {
-            if ($this->localStrictModeEnabled ?? Carbon::isStrictModeEnabled()) {
-                throw new BadFluentSetterException($method, 0, $exception);
-            }
-        }
-
-        return $this;
-    }
-
-    protected function getForHumansInitialVariables($syntax, $short)
-    {
-        if (\is_array($syntax)) {
-            return $syntax;
-        }
-
-        if (\is_int($short)) {
-            return [
-                'parts' => $short,
-                'short' => false,
-            ];
-        }
-
-        if (\is_bool($syntax)) {
-            return [
-                'short' => $syntax,
-                'syntax' => CarbonInterface::DIFF_ABSOLUTE,
-            ];
-        }
-
-        return [];
-    }
-
-    /**
-     * @param mixed $syntax
-     * @param mixed $short
-     * @param mixed $parts
-     * @param mixed $options
-     *
-     * @return array
-     */
-    protected function getForHumansParameters($syntax = null, $short = false, $parts = -1, $options = null)
-    {
-        $optionalSpace = ' ';
-        $default = $this->getTranslationMessage('list.0') ?? $this->getTranslationMessage('list') ?? ' ';
-        $join = $default === '' ? '' : ' ';
-        $altNumbers = false;
-        $aUnit = false;
-        $minimumUnit = 's';
-        $skip = [];
-        extract($this->getForHumansInitialVariables($syntax, $short));
-        $skip = array_filter((array) $skip, static function ($value) {
-            return \is_string($value) && $value !== '';
-        });
-
-        if ($syntax === null) {
-            $syntax = CarbonInterface::DIFF_ABSOLUTE;
-        }
-
-        if ($parts === -1) {
-            $parts = INF;
-        }
-
-        if ($options === null) {
-            $options = static::getHumanDiffOptions();
-        }
-
-        if ($join === false) {
-            $join = ' ';
-        } elseif ($join === true) {
-            $join = [
-                $default,
-                $this->getTranslationMessage('list.1') ?? $default,
-            ];
-        }
-
-        if ($altNumbers && $altNumbers !== true) {
-            $language = new Language($this->locale);
-            $altNumbers = \in_array($language->getCode(), (array) $altNumbers, true);
-        }
-
-        if (\is_array($join)) {
-            [$default, $last] = $join;
-
-            if ($default !== ' ') {
-                $optionalSpace = '';
-            }
-
-            $join = function ($list) use ($default, $last) {
-                if (\count($list) < 2) {
-                    return implode('', $list);
-                }
-
-                $end = array_pop($list);
-
-                return implode($default, $list).$last.$end;
-            };
-        }
-
-        if (\is_string($join)) {
-            if ($join !== ' ') {
-                $optionalSpace = '';
-            }
-
-            $glue = $join;
-            $join = function ($list) use ($glue) {
-                return implode($glue, $list);
-            };
-        }
-
-        $interpolations = [
-            ':optional-space' => $optionalSpace,
-        ];
-
-        return [$syntax, $short, $parts, $options, $join, $aUnit, $altNumbers, $interpolations, $minimumUnit, $skip];
-    }
-
-    protected static function getRoundingMethodFromOptions(int $options): ?string
-    {
-        if ($options & CarbonInterface::ROUND) {
-            return 'round';
-        }
-
-        if ($options & CarbonInterface::CEIL) {
-            return 'ceil';
-        }
-
-        if ($options & CarbonInterface::FLOOR) {
-            return 'floor';
-        }
-
-        return null;
-    }
-
-    /**
-     * Returns interval values as an array where key are the unit names and values the counts.
-     *
-     * @return int[]
-     */
-    public function toArray()
-    {
-        return [
-            'years' => $this->years,
-            'months' => $this->months,
-            'weeks' => $this->weeks,
-            'days' => $this->daysExcludeWeeks,
-            'hours' => $this->hours,
-            'minutes' => $this->minutes,
-            'seconds' => $this->seconds,
-            'microseconds' => $this->microseconds,
-        ];
-    }
-
-    /**
-     * Returns interval non-zero values as an array where key are the unit names and values the counts.
-     *
-     * @return int[]
-     */
-    public function getNonZeroValues()
-    {
-        return array_filter($this->toArray(), 'intval');
-    }
-
-    /**
-     * Returns interval values as an array where key are the unit names and values the counts
-     * from the biggest non-zero one the the smallest non-zero one.
-     *
-     * @return int[]
-     */
-    public function getValuesSequence()
-    {
-        $nonZeroValues = $this->getNonZeroValues();
-
-        if ($nonZeroValues === []) {
-            return [];
-        }
-
-        $keys = array_keys($nonZeroValues);
-        $firstKey = $keys[0];
-        $lastKey = $keys[\count($keys) - 1];
-        $values = [];
-        $record = false;
-
-        foreach ($this->toArray() as $unit => $count) {
-            if ($unit === $firstKey) {
-                $record = true;
-            }
-
-            if ($record) {
-                $values[$unit] = $count;
-            }
-
-            if ($unit === $lastKey) {
-                $record = false;
-            }
-        }
-
-        return $values;
-    }
-
-    /**
-     * Get the current interval in a human readable format in the current locale.
-     *
-     * @example
-     * ```
-     * echo CarbonInterval::fromString('4d 3h 40m')->forHumans() . "\n";
-     * echo CarbonInterval::fromString('4d 3h 40m')->forHumans(['parts' => 2]) . "\n";
-     * echo CarbonInterval::fromString('4d 3h 40m')->forHumans(['parts' => 3, 'join' => true]) . "\n";
-     * echo CarbonInterval::fromString('4d 3h 40m')->forHumans(['short' => true]) . "\n";
-     * echo CarbonInterval::fromString('1d 24h')->forHumans(['join' => ' or ']) . "\n";
-     * echo CarbonInterval::fromString('1d 24h')->forHumans(['minimumUnit' => 'hour']) . "\n";
-     * ```
-     *
-     * @param int|array $syntax  if array passed, parameters will be extracted from it, the array may contains:
-     *                           - 'syntax' entry (see below)
-     *                           - 'short' entry (see below)
-     *                           - 'parts' entry (see below)
-     *                           - 'options' entry (see below)
-     *                           - 'skip' entry, list of units to skip (array of strings or a single string,
-     *                           ` it can be the unit name (singular or plural) or its shortcut
-     *                           ` (y, m, w, d, h, min, s, ms, µs).
-     *                           - 'aUnit' entry, prefer "an hour" over "1 hour" if true
-     *                           - 'join' entry determines how to join multiple parts of the string
-     *                           `  - if $join is a string, it's used as a joiner glue
-     *                           `  - if $join is a callable/closure, it get the list of string and should return a string
-     *                           `  - if $join is an array, the first item will be the default glue, and the second item
-     *                           `    will be used instead of the glue for the last item
-     *                           `  - if $join is true, it will be guessed from the locale ('list' translation file entry)
-     *                           `  - if $join is missing, a space will be used as glue
-     *                           - 'minimumUnit' entry determines the smallest unit of time to display can be long or
-     *                           `  short form of the units, e.g. 'hour' or 'h' (default value: s)
-     *                           if int passed, it add modifiers:
-     *                           Possible values:
-     *                           - CarbonInterface::DIFF_ABSOLUTE          no modifiers
-     *                           - CarbonInterface::DIFF_RELATIVE_TO_NOW   add ago/from now modifier
-     *                           - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
-     *                           Default value: CarbonInterface::DIFF_ABSOLUTE
-     * @param bool      $short   displays short format of time units
-     * @param int       $parts   maximum number of parts to display (default value: -1: no limits)
-     * @param int       $options human diff options
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    public function forHumans($syntax = null, $short = false, $parts = -1, $options = null)
-    {
-        [$syntax, $short, $parts, $options, $join, $aUnit, $altNumbers, $interpolations, $minimumUnit, $skip] = $this
-            ->getForHumansParameters($syntax, $short, $parts, $options);
-
-        $interval = [];
-
-        $syntax = (int) ($syntax ?? CarbonInterface::DIFF_ABSOLUTE);
-        $absolute = $syntax === CarbonInterface::DIFF_ABSOLUTE;
-        $relativeToNow = $syntax === CarbonInterface::DIFF_RELATIVE_TO_NOW;
-        $count = 1;
-        $unit = $short ? 's' : 'second';
-        $isFuture = $this->invert === 1;
-        $transId = $relativeToNow ? ($isFuture ? 'from_now' : 'ago') : ($isFuture ? 'after' : 'before');
-        $declensionMode = null;
-
-        /** @var \Symfony\Component\Translation\Translator $translator */
-        $translator = $this->getLocalTranslator();
-
-        $handleDeclensions = function ($unit, $count, $index = 0, $parts = 1) use ($interpolations, $transId, $translator, $altNumbers, $absolute, &$declensionMode) {
-            if (!$absolute) {
-                $declensionMode = $declensionMode ?? $this->translate($transId.'_mode');
-
-                if ($this->needsDeclension($declensionMode, $index, $parts)) {
-                    // Some languages have special pluralization for past and future tense.
-                    $key = $unit.'_'.$transId;
-                    $result = $this->translate($key, $interpolations, $count, $translator, $altNumbers);
-
-                    if ($result !== $key) {
-                        return $result;
-                    }
-                }
-            }
-
-            $result = $this->translate($unit, $interpolations, $count, $translator, $altNumbers);
-
-            if ($result !== $unit) {
-                return $result;
-            }
-
-            return null;
-        };
-
-        $intervalValues = $this;
-        $method = static::getRoundingMethodFromOptions($options);
-
-        if ($method) {
-            $previousCount = INF;
-
-            while (
-                \count($intervalValues->getNonZeroValues()) > $parts &&
-                ($count = \count($keys = array_keys($intervalValues->getValuesSequence()))) > 1
-            ) {
-                $index = min($count, $previousCount - 1) - 2;
-
-                if ($index < 0) {
-                    break;
-                }
-
-                $intervalValues = $this->copy()->roundUnit(
-                    $keys[$index],
-                    1,
-                    $method
-                );
-                $previousCount = $count;
-            }
-        }
-
-        $diffIntervalArray = [
-            ['value' => $intervalValues->years,             'unit' => 'year',        'unitShort' => 'y'],
-            ['value' => $intervalValues->months,            'unit' => 'month',       'unitShort' => 'm'],
-            ['value' => $intervalValues->weeks,             'unit' => 'week',        'unitShort' => 'w'],
-            ['value' => $intervalValues->daysExcludeWeeks,  'unit' => 'day',         'unitShort' => 'd'],
-            ['value' => $intervalValues->hours,             'unit' => 'hour',        'unitShort' => 'h'],
-            ['value' => $intervalValues->minutes,           'unit' => 'minute',      'unitShort' => 'min'],
-            ['value' => $intervalValues->seconds,           'unit' => 'second',      'unitShort' => 's'],
-            ['value' => $intervalValues->milliseconds,      'unit' => 'millisecond', 'unitShort' => 'ms'],
-            ['value' => $intervalValues->microExcludeMilli, 'unit' => 'microsecond', 'unitShort' => 'µs'],
-        ];
-
-        if (!empty($skip)) {
-            foreach ($diffIntervalArray as $index => &$unitData) {
-                $nextIndex = $index + 1;
-
-                if ($unitData['value'] &&
-                    isset($diffIntervalArray[$nextIndex]) &&
-                    \count(array_intersect([$unitData['unit'], $unitData['unit'].'s', $unitData['unitShort']], $skip))
-                ) {
-                    $diffIntervalArray[$nextIndex]['value'] += $unitData['value'] *
-                        self::getFactorWithDefault($diffIntervalArray[$nextIndex]['unit'], $unitData['unit']);
-                    $unitData['value'] = 0;
-                }
-            }
-        }
-
-        $transChoice = function ($short, $unitData, $index, $parts) use ($absolute, $handleDeclensions, $translator, $aUnit, $altNumbers, $interpolations) {
-            $count = $unitData['value'];
-
-            if ($short) {
-                $result = $handleDeclensions($unitData['unitShort'], $count, $index, $parts);
-
-                if ($result !== null) {
-                    return $result;
-                }
-            } elseif ($aUnit) {
-                $result = $handleDeclensions('a_'.$unitData['unit'], $count, $index, $parts);
-
-                if ($result !== null) {
-                    return $result;
-                }
-            }
-
-            if (!$absolute) {
-                return $handleDeclensions($unitData['unit'], $count, $index, $parts);
-            }
-
-            return $this->translate($unitData['unit'], $interpolations, $count, $translator, $altNumbers);
-        };
-
-        $fallbackUnit = ['second', 's'];
-
-        foreach ($diffIntervalArray as $diffIntervalData) {
-            if ($diffIntervalData['value'] > 0) {
-                $unit = $short ? $diffIntervalData['unitShort'] : $diffIntervalData['unit'];
-                $count = $diffIntervalData['value'];
-                $interval[] = [$short, $diffIntervalData];
-            } elseif ($options & CarbonInterface::SEQUENTIAL_PARTS_ONLY && \count($interval) > 0) {
-                break;
-            }
-
-            // break the loop after we get the required number of parts in array
-            if (\count($interval) >= $parts) {
-                break;
-            }
-
-            // break the loop after we have reached the minimum unit
-            if (\in_array($minimumUnit, [$diffIntervalData['unit'], $diffIntervalData['unitShort']], true)) {
-                $fallbackUnit = [$diffIntervalData['unit'], $diffIntervalData['unitShort']];
-
-                break;
-            }
-        }
-
-        $actualParts = \count($interval);
-
-        foreach ($interval as $index => &$item) {
-            $item = $transChoice($item[0], $item[1], $index, $actualParts);
-        }
-
-        if (\count($interval) === 0) {
-            if ($relativeToNow && $options & CarbonInterface::JUST_NOW) {
-                $key = 'diff_now';
-                $translation = $this->translate($key, $interpolations, null, $translator);
-
-                if ($translation !== $key) {
-                    return $translation;
-                }
-            }
-
-            $count = $options & CarbonInterface::NO_ZERO_DIFF ? 1 : 0;
-            $unit = $fallbackUnit[$short ? 1 : 0];
-            $interval[] = $this->translate($unit, $interpolations, $count, $translator, $altNumbers);
-        }
-
-        // join the interval parts by a space
-        $time = $join($interval);
-
-        unset($diffIntervalArray, $interval);
-
-        if ($absolute) {
-            return $time;
-        }
-
-        $isFuture = $this->invert === 1;
-
-        $transId = $relativeToNow ? ($isFuture ? 'from_now' : 'ago') : ($isFuture ? 'after' : 'before');
-
-        if ($parts === 1) {
-            if ($relativeToNow && $unit === 'day') {
-                if ($count === 1 && $options & CarbonInterface::ONE_DAY_WORDS) {
-                    $key = $isFuture ? 'diff_tomorrow' : 'diff_yesterday';
-                    $translation = $this->translate($key, $interpolations, null, $translator);
-
-                    if ($translation !== $key) {
-                        return $translation;
-                    }
-                }
-
-                if ($count === 2 && $options & CarbonInterface::TWO_DAY_WORDS) {
-                    $key = $isFuture ? 'diff_after_tomorrow' : 'diff_before_yesterday';
-                    $translation = $this->translate($key, $interpolations, null, $translator);
-
-                    if ($translation !== $key) {
-                        return $translation;
-                    }
-                }
-            }
-
-            $aTime = $aUnit ? $handleDeclensions('a_'.$unit, $count) : null;
-
-            $time = $aTime ?: $handleDeclensions($unit, $count) ?: $time;
-        }
-
-        $time = [':time' => $time];
-
-        return $this->translate($transId, array_merge($time, $interpolations, $time), null, $translator);
-    }
-
-    /**
-     * Format the instance as a string using the forHumans() function.
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        $format = $this->localToStringFormat;
-
-        if (!$format) {
-            return $this->forHumans();
-        }
-
-        if ($format instanceof Closure) {
-            return $format($this);
-        }
-
-        return $this->format($format);
-    }
-
-    /**
-     * Return native DateInterval PHP object matching the current instance.
-     *
-     * @example
-     * ```
-     * var_dump(CarbonInterval::hours(2)->toDateInterval());
-     * ```
-     *
-     * @return DateInterval
-     */
-    public function toDateInterval()
-    {
-        return self::castIntervalToClass($this, DateInterval::class);
-    }
-
-    /**
-     * Convert the interval to a CarbonPeriod.
-     *
-     * @param DateTimeInterface|string|int ...$params Start date, [end date or recurrences] and optional settings.
-     *
-     * @return CarbonPeriod
-     */
-    public function toPeriod(...$params)
-    {
-        if ($this->tzName) {
-            $tz = \is_string($this->tzName) ? new DateTimeZone($this->tzName) : $this->tzName;
-
-            if ($tz instanceof DateTimeZone) {
-                array_unshift($params, $tz);
-            }
-        }
-
-        return CarbonPeriod::create($this, ...$params);
-    }
-
-    /**
-     * Invert the interval.
-     *
-     * @param bool|int $inverted if a parameter is passed, the passed value casted as 1 or 0 is used
-     *                           as the new value of the ->invert property.
-     *
-     * @return $this
-     */
-    public function invert($inverted = null)
-    {
-        $this->invert = (\func_num_args() === 0 ? !$this->invert : $inverted) ? 1 : 0;
-
-        return $this;
-    }
-
-    protected function solveNegativeInterval()
-    {
-        if (!$this->isEmpty() && $this->years <= 0 && $this->months <= 0 && $this->dayz <= 0 && $this->hours <= 0 && $this->minutes <= 0 && $this->seconds <= 0 && $this->microseconds <= 0) {
-            $this->years *= -1;
-            $this->months *= -1;
-            $this->dayz *= -1;
-            $this->hours *= -1;
-            $this->minutes *= -1;
-            $this->seconds *= -1;
-            $this->microseconds *= -1;
-            $this->invert();
-        }
-
-        return $this;
-    }
-
-    /**
-     * Add the passed interval to the current instance.
-     *
-     * @param string|DateInterval $unit
-     * @param int|float           $value
-     *
-     * @return $this
-     */
-    public function add($unit, $value = 1)
-    {
-        if (is_numeric($unit)) {
-            [$value, $unit] = [$unit, $value];
-        }
-
-        if (\is_string($unit) && !preg_match('/^\s*\d/', $unit)) {
-            $unit = "$value $unit";
-            $value = 1;
-        }
-
-        $interval = static::make($unit);
-
-        if (!$interval) {
-            throw new InvalidIntervalException('This type of data cannot be added/subtracted.');
-        }
-
-        if ($value !== 1) {
-            $interval->times($value);
-        }
-
-        $sign = ($this->invert === 1) !== ($interval->invert === 1) ? -1 : 1;
-        $this->years += $interval->y * $sign;
-        $this->months += $interval->m * $sign;
-        $this->dayz += ($interval->days === false ? $interval->d : $interval->days) * $sign;
-        $this->hours += $interval->h * $sign;
-        $this->minutes += $interval->i * $sign;
-        $this->seconds += $interval->s * $sign;
-        $this->microseconds += $interval->microseconds * $sign;
-
-        $this->solveNegativeInterval();
-
-        return $this;
-    }
-
-    /**
-     * Subtract the passed interval to the current instance.
-     *
-     * @param string|DateInterval $unit
-     * @param int|float           $value
-     *
-     * @return $this
-     */
-    public function sub($unit, $value = 1)
-    {
-        if (is_numeric($unit)) {
-            [$value, $unit] = [$unit, $value];
-        }
-
-        return $this->add($unit, -(float) $value);
-    }
-
-    /**
-     * Subtract the passed interval to the current instance.
-     *
-     * @param string|DateInterval $unit
-     * @param int|float           $value
-     *
-     * @return $this
-     */
-    public function subtract($unit, $value = 1)
-    {
-        return $this->sub($unit, $value);
-    }
-
-    /**
-     * Add given parameters to the current interval.
-     *
-     * @param int       $years
-     * @param int       $months
-     * @param int|float $weeks
-     * @param int|float $days
-     * @param int|float $hours
-     * @param int|float $minutes
-     * @param int|float $seconds
-     * @param int|float $microseconds
-     *
-     * @return $this
-     */
-    public function plus(
-        $years = 0,
-        $months = 0,
-        $weeks = 0,
-        $days = 0,
-        $hours = 0,
-        $minutes = 0,
-        $seconds = 0,
-        $microseconds = 0
-    ): self {
-        return $this->add("
+				case 'second':
+				case 'seconds':
+				case 's':
+					$seconds += $intValue;
+
+					if ($fraction) {
+						$parts[] = [null, $fraction * static::getMillisecondsPerSecond(), 'ms'];
+					}
+
+					break;
+
+				case 'millisecond':
+				case 'milliseconds':
+				case 'milli':
+				case 'ms':
+					$milliseconds += $intValue;
+
+					if ($fraction) {
+						$microseconds += round($fraction * static::getMicrosecondsPerMillisecond());
+					}
+
+					break;
+
+				case 'microsecond':
+				case 'microseconds':
+				case 'micro':
+				case 'µs':
+					$microseconds += $intValue;
+
+					break;
+
+				default:
+					throw new InvalidIntervalException(
+						sprintf('Invalid part %s in definition %s', $part, $intervalDefinition)
+					);
+			}
+		}
+
+		return new static($years, $months, $weeks, $days, $hours, $minutes, $seconds, $milliseconds * Carbon::MICROSECONDS_PER_MILLISECOND + $microseconds);
+	}
+
+	/**
+	 * Creates a CarbonInterval from string using a different locale.
+	 *
+	 * @param string      $interval interval string in the given language (may also contain English).
+	 * @param string|null $locale   if locale is null or not specified, current global locale will be used instead.
+	 *
+	 * @return static
+	 */
+	public static function parseFromLocale($interval, $locale = null)
+	{
+		return static::fromString(Carbon::translateTimeString($interval, $locale ?: static::getLocale(), 'en'));
+	}
+
+	private static function castIntervalToClass(DateInterval $interval, string $className)
+	{
+		$mainClass = DateInterval::class;
+
+		if (!is_a($className, $mainClass, true)) {
+			throw new InvalidCastException("$className is not a sub-class of $mainClass.");
+		}
+
+		$microseconds = $interval->f;
+		$instance = new $className(static::getDateIntervalSpec($interval));
+
+		if ($microseconds) {
+			$instance->f = $microseconds;
+		}
+
+		if ($interval instanceof self && is_a($className, self::class, true)) {
+			self::copyStep($interval, $instance);
+		}
+
+		self::copyNegativeUnits($interval, $instance);
+
+		return $instance;
+	}
+
+	private static function copyNegativeUnits(DateInterval $from, DateInterval $to): void
+	{
+		$to->invert = $from->invert;
+
+		foreach (['y', 'm', 'd', 'h', 'i', 's'] as $unit) {
+			if ($from->$unit < 0) {
+				$to->$unit *= -1;
+			}
+		}
+	}
+
+	private static function copyStep(self $from, self $to): void
+	{
+		$to->setStep($from->getStep());
+	}
+
+	/**
+	 * Cast the current instance into the given class.
+	 *
+	 * @param string $className The $className::instance() method will be called to cast the current object.
+	 *
+	 * @return DateInterval
+	 */
+	public function cast(string $className)
+	{
+		return self::castIntervalToClass($this, $className);
+	}
+
+	/**
+	 * Create a CarbonInterval instance from a DateInterval one.  Can not instance
+	 * DateInterval objects created from DateTime::diff() as you can't externally
+	 * set the $days field.
+	 *
+	 * @param DateInterval $interval
+	 *
+	 * @return static
+	 */
+	public static function instance(DateInterval $interval)
+	{
+		return self::castIntervalToClass($interval, static::class);
+	}
+
+	/**
+	 * Make a CarbonInterval instance from given variable if possible.
+	 *
+	 * Always return a new instance. Parse only strings and only these likely to be intervals (skip dates
+	 * and recurrences). Throw an exception for invalid format, but otherwise return null.
+	 *
+	 * @param mixed|int|DateInterval|string|Closure|null $interval interval or number of the given $unit
+	 * @param string|null                                $unit     if specified, $interval must be an integer
+	 *
+	 * @return static|null
+	 */
+	public static function make($interval, $unit = null)
+	{
+		if ($unit) {
+			$interval = "$interval ".Carbon::pluralUnit($unit);
+		}
+
+		if ($interval instanceof DateInterval) {
+			return static::instance($interval);
+		}
+
+		if ($interval instanceof Closure) {
+			return new static($interval);
+		}
+
+		if (!\is_string($interval)) {
+			return null;
+		}
+
+		return static::makeFromString($interval);
+	}
+
+	protected static function makeFromString(string $interval)
+	{
+		$interval = preg_replace('/\s+/', ' ', trim($interval));
+
+		if (preg_match('/^P[T\d]/', $interval)) {
+			return new static($interval);
+		}
+
+		if (preg_match('/^(?:\h*\d+(?:\.\d+)?\h*[a-z]+)+$/i', $interval)) {
+			return static::fromString($interval);
+		}
+
+		/** @var static $interval */
+		$interval = static::createFromDateString($interval);
+
+		return !$interval || $interval->isEmpty() ? null : $interval;
+	}
+
+	protected function resolveInterval($interval)
+	{
+		if (!($interval instanceof self)) {
+			return self::make($interval);
+		}
+
+		return $interval;
+	}
+
+	/**
+	 * Sets up a DateInterval from the relative parts of the string.
+	 *
+	 * @param string $time
+	 *
+	 * @return static
+	 *
+	 * @link https://php.net/manual/en/dateinterval.createfromdatestring.php
+	 */
+	#[ReturnTypeWillChange]
+	public static function createFromDateString($time)
+	{
+		$interval = @parent::createFromDateString(strtr($time, [
+			',' => ' ',
+			' and ' => ' ',
+		]));
+
+		if ($interval instanceof DateInterval) {
+			$interval = static::instance($interval);
+		}
+
+		return $interval;
+	}
+
+	///////////////////////////////////////////////////////////////////
+	///////////////////////// GETTERS AND SETTERS /////////////////////
+	///////////////////////////////////////////////////////////////////
+
+	/**
+	 * Get a part of the CarbonInterval object.
+	 *
+	 * @param string $name
+	 *
+	 * @throws UnknownGetterException
+	 *
+	 * @return int|float|string
+	 */
+	public function get($name)
+	{
+		if (str_starts_with($name, 'total')) {
+			return $this->total(substr($name, 5));
+		}
+
+		switch ($name) {
+			case 'years':
+				return $this->y;
+
+			case 'months':
+				return $this->m;
+
+			case 'dayz':
+				return $this->d;
+
+			case 'hours':
+				return $this->h;
+
+			case 'minutes':
+				return $this->i;
+
+			case 'seconds':
+				return $this->s;
+
+			case 'milli':
+			case 'milliseconds':
+				return (int) (round($this->f * Carbon::MICROSECONDS_PER_SECOND) / Carbon::MICROSECONDS_PER_MILLISECOND);
+
+			case 'micro':
+			case 'microseconds':
+				return (int) round($this->f * Carbon::MICROSECONDS_PER_SECOND);
+
+			case 'microExcludeMilli':
+				return (int) round($this->f * Carbon::MICROSECONDS_PER_SECOND) % Carbon::MICROSECONDS_PER_MILLISECOND;
+
+			case 'weeks':
+				return (int) ($this->d / static::getDaysPerWeek());
+
+			case 'daysExcludeWeeks':
+			case 'dayzExcludeWeeks':
+				return $this->d % static::getDaysPerWeek();
+
+			case 'locale':
+				return $this->getTranslatorLocale();
+
+			default:
+				throw new UnknownGetterException($name);
+		}
+	}
+
+	/**
+	 * Get a part of the CarbonInterval object.
+	 *
+	 * @param string $name
+	 *
+	 * @throws UnknownGetterException
+	 *
+	 * @return int|float|string
+	 */
+	public function __get($name)
+	{
+		return $this->get($name);
+	}
+
+	/**
+	 * Set a part of the CarbonInterval object.
+	 *
+	 * @param string|array $name
+	 * @param int          $value
+	 *
+	 * @throws UnknownSetterException
+	 *
+	 * @return $this
+	 */
+	public function set($name, $value = null)
+	{
+		$properties = \is_array($name) ? $name : [$name => $value];
+
+		foreach ($properties as $key => $value) {
+			switch (Carbon::singularUnit(rtrim($key, 'z'))) {
+				case 'year':
+					$this->y = $value;
+
+					break;
+
+				case 'month':
+					$this->m = $value;
+
+					break;
+
+				case 'week':
+					$this->d = $value * static::getDaysPerWeek();
+
+					break;
+
+				case 'day':
+					$this->d = $value;
+
+					break;
+
+				case 'daysexcludeweek':
+				case 'dayzexcludeweek':
+					$this->d = $this->weeks * static::getDaysPerWeek() + $value;
+
+					break;
+
+				case 'hour':
+					$this->h = $value;
+
+					break;
+
+				case 'minute':
+					$this->i = $value;
+
+					break;
+
+				case 'second':
+					$this->s = $value;
+
+					break;
+
+				case 'milli':
+				case 'millisecond':
+					$this->microseconds = $value * Carbon::MICROSECONDS_PER_MILLISECOND + $this->microseconds % Carbon::MICROSECONDS_PER_MILLISECOND;
+
+					break;
+
+				case 'micro':
+				case 'microsecond':
+					$this->f = $value / Carbon::MICROSECONDS_PER_SECOND;
+
+					break;
+
+				default:
+					if ($this->localStrictModeEnabled ?? Carbon::isStrictModeEnabled()) {
+						throw new UnknownSetterException($key);
+					}
+
+					$this->$key = $value;
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Set a part of the CarbonInterval object.
+	 *
+	 * @param string $name
+	 * @param int    $value
+	 *
+	 * @throws UnknownSetterException
+	 */
+	public function __set($name, $value)
+	{
+		$this->set($name, $value);
+	}
+
+	/**
+	 * Allow setting of weeks and days to be cumulative.
+	 *
+	 * @param int $weeks Number of weeks to set
+	 * @param int $days  Number of days to set
+	 *
+	 * @return static
+	 */
+	public function weeksAndDays($weeks, $days)
+	{
+		$this->dayz = ($weeks * static::getDaysPerWeek()) + $days;
+
+		return $this;
+	}
+
+	/**
+	 * Returns true if the interval is empty for each unit.
+	 *
+	 * @return bool
+	 */
+	public function isEmpty()
+	{
+		return $this->years === 0 &&
+			$this->months === 0 &&
+			$this->dayz === 0 &&
+			!$this->days &&
+			$this->hours === 0 &&
+			$this->minutes === 0 &&
+			$this->seconds === 0 &&
+			$this->microseconds === 0;
+	}
+
+	/**
+	 * Register a custom macro.
+	 *
+	 * @example
+	 * ```
+	 * CarbonInterval::macro('twice', function () {
+	 *   return $this->times(2);
+	 * });
+	 * echo CarbonInterval::hours(2)->twice();
+	 * ```
+	 *
+	 * @param string          $name
+	 * @param object|callable $macro
+	 *
+	 * @return void
+	 */
+	public static function macro($name, $macro)
+	{
+		static::$macros[$name] = $macro;
+	}
+
+	/**
+	 * Register macros from a mixin object.
+	 *
+	 * @example
+	 * ```
+	 * CarbonInterval::mixin(new class {
+	 *   public function daysToHours() {
+	 *     return function () {
+	 *       $this->hours += $this->days;
+	 *       $this->days = 0;
+	 *
+	 *       return $this;
+	 *     };
+	 *   }
+	 *   public function hoursToDays() {
+	 *     return function () {
+	 *       $this->days += $this->hours;
+	 *       $this->hours = 0;
+	 *
+	 *       return $this;
+	 *     };
+	 *   }
+	 * });
+	 * echo CarbonInterval::hours(5)->hoursToDays() . "\n";
+	 * echo CarbonInterval::days(5)->daysToHours() . "\n";
+	 * ```
+	 *
+	 * @param object|string $mixin
+	 *
+	 * @throws ReflectionException
+	 *
+	 * @return void
+	 */
+	public static function mixin($mixin)
+	{
+		static::baseMixin($mixin);
+	}
+
+	/**
+	 * Check if macro is registered.
+	 *
+	 * @param string $name
+	 *
+	 * @return bool
+	 */
+	public static function hasMacro($name)
+	{
+		return isset(static::$macros[$name]);
+	}
+
+	/**
+	 * Call given macro.
+	 *
+	 * @param string $name
+	 * @param array  $parameters
+	 *
+	 * @return mixed
+	 */
+	protected function callMacro($name, $parameters)
+	{
+		$macro = static::$macros[$name];
+
+		if ($macro instanceof Closure) {
+			$boundMacro = @$macro->bindTo($this, static::class) ?: @$macro->bindTo(null, static::class);
+
+			return ($boundMacro ?: $macro)(...$parameters);
+		}
+
+		return $macro(...$parameters);
+	}
+
+	/**
+	 * Allow fluent calls on the setters... CarbonInterval::years(3)->months(5)->day().
+	 *
+	 * Note: This is done using the magic method to allow static and instance methods to
+	 *       have the same names.
+	 *
+	 * @param string $method     magic method name called
+	 * @param array  $parameters parameters list
+	 *
+	 * @throws BadFluentSetterException|Throwable
+	 *
+	 * @return static
+	 */
+	public function __call($method, $parameters)
+	{
+		if (static::hasMacro($method)) {
+			return static::bindMacroContext($this, function () use (&$method, &$parameters) {
+				return $this->callMacro($method, $parameters);
+			});
+		}
+
+		$roundedValue = $this->callRoundMethod($method, $parameters);
+
+		if ($roundedValue !== null) {
+			return $roundedValue;
+		}
+
+		if (preg_match('/^(?<method>add|sub)(?<unit>[A-Z].*)$/', $method, $match)) {
+			return $this->{$match['method']}($parameters[0], $match['unit']);
+		}
+
+		try {
+			$this->set($method, \count($parameters) === 0 ? 1 : $parameters[0]);
+		} catch (UnknownSetterException $exception) {
+			if ($this->localStrictModeEnabled ?? Carbon::isStrictModeEnabled()) {
+				throw new BadFluentSetterException($method, 0, $exception);
+			}
+		}
+
+		return $this;
+	}
+
+	protected function getForHumansInitialVariables($syntax, $short)
+	{
+		if (\is_array($syntax)) {
+			return $syntax;
+		}
+
+		if (\is_int($short)) {
+			return [
+				'parts' => $short,
+				'short' => false,
+			];
+		}
+
+		if (\is_bool($syntax)) {
+			return [
+				'short' => $syntax,
+				'syntax' => CarbonInterface::DIFF_ABSOLUTE,
+			];
+		}
+
+		return [];
+	}
+
+	/**
+	 * @param mixed $syntax
+	 * @param mixed $short
+	 * @param mixed $parts
+	 * @param mixed $options
+	 *
+	 * @return array
+	 */
+	protected function getForHumansParameters($syntax = null, $short = false, $parts = -1, $options = null)
+	{
+		$optionalSpace = ' ';
+		$default = $this->getTranslationMessage('list.0') ?? $this->getTranslationMessage('list') ?? ' ';
+		$join = $default === '' ? '' : ' ';
+		$altNumbers = false;
+		$aUnit = false;
+		$minimumUnit = 's';
+		$skip = [];
+		extract($this->getForHumansInitialVariables($syntax, $short));
+		$skip = array_filter((array) $skip, static function ($value) {
+			return \is_string($value) && $value !== '';
+		});
+
+		if ($syntax === null) {
+			$syntax = CarbonInterface::DIFF_ABSOLUTE;
+		}
+
+		if ($parts === -1) {
+			$parts = INF;
+		}
+
+		if ($options === null) {
+			$options = static::getHumanDiffOptions();
+		}
+
+		if ($join === false) {
+			$join = ' ';
+		} elseif ($join === true) {
+			$join = [
+				$default,
+				$this->getTranslationMessage('list.1') ?? $default,
+			];
+		}
+
+		if ($altNumbers && $altNumbers !== true) {
+			$language = new Language($this->locale);
+			$altNumbers = \in_array($language->getCode(), (array) $altNumbers, true);
+		}
+
+		if (\is_array($join)) {
+			[$default, $last] = $join;
+
+			if ($default !== ' ') {
+				$optionalSpace = '';
+			}
+
+			$join = function ($list) use ($default, $last) {
+				if (\count($list) < 2) {
+					return implode('', $list);
+				}
+
+				$end = array_pop($list);
+
+				return implode($default, $list).$last.$end;
+			};
+		}
+
+		if (\is_string($join)) {
+			if ($join !== ' ') {
+				$optionalSpace = '';
+			}
+
+			$glue = $join;
+			$join = function ($list) use ($glue) {
+				return implode($glue, $list);
+			};
+		}
+
+		$interpolations = [
+			':optional-space' => $optionalSpace,
+		];
+
+		return [$syntax, $short, $parts, $options, $join, $aUnit, $altNumbers, $interpolations, $minimumUnit, $skip];
+	}
+
+	protected static function getRoundingMethodFromOptions(int $options): ?string
+	{
+		if ($options & CarbonInterface::ROUND) {
+			return 'round';
+		}
+
+		if ($options & CarbonInterface::CEIL) {
+			return 'ceil';
+		}
+
+		if ($options & CarbonInterface::FLOOR) {
+			return 'floor';
+		}
+
+		return null;
+	}
+
+	/**
+	 * Returns interval values as an array where key are the unit names and values the counts.
+	 *
+	 * @return int[]
+	 */
+	public function toArray()
+	{
+		return [
+			'years' => $this->years,
+			'months' => $this->months,
+			'weeks' => $this->weeks,
+			'days' => $this->daysExcludeWeeks,
+			'hours' => $this->hours,
+			'minutes' => $this->minutes,
+			'seconds' => $this->seconds,
+			'microseconds' => $this->microseconds,
+		];
+	}
+
+	/**
+	 * Returns interval non-zero values as an array where key are the unit names and values the counts.
+	 *
+	 * @return int[]
+	 */
+	public function getNonZeroValues()
+	{
+		return array_filter($this->toArray(), 'intval');
+	}
+
+	/**
+	 * Returns interval values as an array where key are the unit names and values the counts
+	 * from the biggest non-zero one the the smallest non-zero one.
+	 *
+	 * @return int[]
+	 */
+	public function getValuesSequence()
+	{
+		$nonZeroValues = $this->getNonZeroValues();
+
+		if ($nonZeroValues === []) {
+			return [];
+		}
+
+		$keys = array_keys($nonZeroValues);
+		$firstKey = $keys[0];
+		$lastKey = $keys[\count($keys) - 1];
+		$values = [];
+		$record = false;
+
+		foreach ($this->toArray() as $unit => $count) {
+			if ($unit === $firstKey) {
+				$record = true;
+			}
+
+			if ($record) {
+				$values[$unit] = $count;
+			}
+
+			if ($unit === $lastKey) {
+				$record = false;
+			}
+		}
+
+		return $values;
+	}
+
+	/**
+	 * Get the current interval in a human readable format in the current locale.
+	 *
+	 * @example
+	 * ```
+	 * echo CarbonInterval::fromString('4d 3h 40m')->forHumans() . "\n";
+	 * echo CarbonInterval::fromString('4d 3h 40m')->forHumans(['parts' => 2]) . "\n";
+	 * echo CarbonInterval::fromString('4d 3h 40m')->forHumans(['parts' => 3, 'join' => true]) . "\n";
+	 * echo CarbonInterval::fromString('4d 3h 40m')->forHumans(['short' => true]) . "\n";
+	 * echo CarbonInterval::fromString('1d 24h')->forHumans(['join' => ' or ']) . "\n";
+	 * echo CarbonInterval::fromString('1d 24h')->forHumans(['minimumUnit' => 'hour']) . "\n";
+	 * ```
+	 *
+	 * @param int|array $syntax  if array passed, parameters will be extracted from it, the array may contains:
+	 *                           - 'syntax' entry (see below)
+	 *                           - 'short' entry (see below)
+	 *                           - 'parts' entry (see below)
+	 *                           - 'options' entry (see below)
+	 *                           - 'skip' entry, list of units to skip (array of strings or a single string,
+	 *                           ` it can be the unit name (singular or plural) or its shortcut
+	 *                           ` (y, m, w, d, h, min, s, ms, µs).
+	 *                           - 'aUnit' entry, prefer "an hour" over "1 hour" if true
+	 *                           - 'join' entry determines how to join multiple parts of the string
+	 *                           `  - if $join is a string, it's used as a joiner glue
+	 *                           `  - if $join is a callable/closure, it get the list of string and should return a string
+	 *                           `  - if $join is an array, the first item will be the default glue, and the second item
+	 *                           `    will be used instead of the glue for the last item
+	 *                           `  - if $join is true, it will be guessed from the locale ('list' translation file entry)
+	 *                           `  - if $join is missing, a space will be used as glue
+	 *                           - 'minimumUnit' entry determines the smallest unit of time to display can be long or
+	 *                           `  short form of the units, e.g. 'hour' or 'h' (default value: s)
+	 *                           if int passed, it add modifiers:
+	 *                           Possible values:
+	 *                           - CarbonInterface::DIFF_ABSOLUTE          no modifiers
+	 *                           - CarbonInterface::DIFF_RELATIVE_TO_NOW   add ago/from now modifier
+	 *                           - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
+	 *                           Default value: CarbonInterface::DIFF_ABSOLUTE
+	 * @param bool      $short   displays short format of time units
+	 * @param int       $parts   maximum number of parts to display (default value: -1: no limits)
+	 * @param int       $options human diff options
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	public function forHumans($syntax = null, $short = false, $parts = -1, $options = null)
+	{
+		[$syntax, $short, $parts, $options, $join, $aUnit, $altNumbers, $interpolations, $minimumUnit, $skip] = $this
+			->getForHumansParameters($syntax, $short, $parts, $options);
+
+		$interval = [];
+
+		$syntax = (int) ($syntax ?? CarbonInterface::DIFF_ABSOLUTE);
+		$absolute = $syntax === CarbonInterface::DIFF_ABSOLUTE;
+		$relativeToNow = $syntax === CarbonInterface::DIFF_RELATIVE_TO_NOW;
+		$count = 1;
+		$unit = $short ? 's' : 'second';
+		$isFuture = $this->invert === 1;
+		$transId = $relativeToNow ? ($isFuture ? 'from_now' : 'ago') : ($isFuture ? 'after' : 'before');
+		$declensionMode = null;
+
+		/** @var \Symfony\Component\Translation\Translator $translator */
+		$translator = $this->getLocalTranslator();
+
+		$handleDeclensions = function ($unit, $count, $index = 0, $parts = 1) use ($interpolations, $transId, $translator, $altNumbers, $absolute, &$declensionMode) {
+			if (!$absolute) {
+				$declensionMode = $declensionMode ?? $this->translate($transId.'_mode');
+
+				if ($this->needsDeclension($declensionMode, $index, $parts)) {
+					// Some languages have special pluralization for past and future tense.
+					$key = $unit.'_'.$transId;
+					$result = $this->translate($key, $interpolations, $count, $translator, $altNumbers);
+
+					if ($result !== $key) {
+						return $result;
+					}
+				}
+			}
+
+			$result = $this->translate($unit, $interpolations, $count, $translator, $altNumbers);
+
+			if ($result !== $unit) {
+				return $result;
+			}
+
+			return null;
+		};
+
+		$intervalValues = $this;
+		$method = static::getRoundingMethodFromOptions($options);
+
+		if ($method) {
+			$previousCount = INF;
+
+			while (
+				\count($intervalValues->getNonZeroValues()) > $parts &&
+				($count = \count($keys = array_keys($intervalValues->getValuesSequence()))) > 1
+			) {
+				$index = min($count, $previousCount - 1) - 2;
+
+				if ($index < 0) {
+					break;
+				}
+
+				$intervalValues = $this->copy()->roundUnit(
+					$keys[$index],
+					1,
+					$method
+				);
+				$previousCount = $count;
+			}
+		}
+
+		$diffIntervalArray = [
+			['value' => $intervalValues->years,             'unit' => 'year',        'unitShort' => 'y'],
+			['value' => $intervalValues->months,            'unit' => 'month',       'unitShort' => 'm'],
+			['value' => $intervalValues->weeks,             'unit' => 'week',        'unitShort' => 'w'],
+			['value' => $intervalValues->daysExcludeWeeks,  'unit' => 'day',         'unitShort' => 'd'],
+			['value' => $intervalValues->hours,             'unit' => 'hour',        'unitShort' => 'h'],
+			['value' => $intervalValues->minutes,           'unit' => 'minute',      'unitShort' => 'min'],
+			['value' => $intervalValues->seconds,           'unit' => 'second',      'unitShort' => 's'],
+			['value' => $intervalValues->milliseconds,      'unit' => 'millisecond', 'unitShort' => 'ms'],
+			['value' => $intervalValues->microExcludeMilli, 'unit' => 'microsecond', 'unitShort' => 'µs'],
+		];
+
+		if (!empty($skip)) {
+			foreach ($diffIntervalArray as $index => &$unitData) {
+				$nextIndex = $index + 1;
+
+				if ($unitData['value'] &&
+					isset($diffIntervalArray[$nextIndex]) &&
+					\count(array_intersect([$unitData['unit'], $unitData['unit'].'s', $unitData['unitShort']], $skip))
+				) {
+					$diffIntervalArray[$nextIndex]['value'] += $unitData['value'] *
+						self::getFactorWithDefault($diffIntervalArray[$nextIndex]['unit'], $unitData['unit']);
+					$unitData['value'] = 0;
+				}
+			}
+		}
+
+		$transChoice = function ($short, $unitData, $index, $parts) use ($absolute, $handleDeclensions, $translator, $aUnit, $altNumbers, $interpolations) {
+			$count = $unitData['value'];
+
+			if ($short) {
+				$result = $handleDeclensions($unitData['unitShort'], $count, $index, $parts);
+
+				if ($result !== null) {
+					return $result;
+				}
+			} elseif ($aUnit) {
+				$result = $handleDeclensions('a_'.$unitData['unit'], $count, $index, $parts);
+
+				if ($result !== null) {
+					return $result;
+				}
+			}
+
+			if (!$absolute) {
+				return $handleDeclensions($unitData['unit'], $count, $index, $parts);
+			}
+
+			return $this->translate($unitData['unit'], $interpolations, $count, $translator, $altNumbers);
+		};
+
+		$fallbackUnit = ['second', 's'];
+
+		foreach ($diffIntervalArray as $diffIntervalData) {
+			if ($diffIntervalData['value'] > 0) {
+				$unit = $short ? $diffIntervalData['unitShort'] : $diffIntervalData['unit'];
+				$count = $diffIntervalData['value'];
+				$interval[] = [$short, $diffIntervalData];
+			} elseif ($options & CarbonInterface::SEQUENTIAL_PARTS_ONLY && \count($interval) > 0) {
+				break;
+			}
+
+			// break the loop after we get the required number of parts in array
+			if (\count($interval) >= $parts) {
+				break;
+			}
+
+			// break the loop after we have reached the minimum unit
+			if (\in_array($minimumUnit, [$diffIntervalData['unit'], $diffIntervalData['unitShort']], true)) {
+				$fallbackUnit = [$diffIntervalData['unit'], $diffIntervalData['unitShort']];
+
+				break;
+			}
+		}
+
+		$actualParts = \count($interval);
+
+		foreach ($interval as $index => &$item) {
+			$item = $transChoice($item[0], $item[1], $index, $actualParts);
+		}
+
+		if (\count($interval) === 0) {
+			if ($relativeToNow && $options & CarbonInterface::JUST_NOW) {
+				$key = 'diff_now';
+				$translation = $this->translate($key, $interpolations, null, $translator);
+
+				if ($translation !== $key) {
+					return $translation;
+				}
+			}
+
+			$count = $options & CarbonInterface::NO_ZERO_DIFF ? 1 : 0;
+			$unit = $fallbackUnit[$short ? 1 : 0];
+			$interval[] = $this->translate($unit, $interpolations, $count, $translator, $altNumbers);
+		}
+
+		// join the interval parts by a space
+		$time = $join($interval);
+
+		unset($diffIntervalArray, $interval);
+
+		if ($absolute) {
+			return $time;
+		}
+
+		$isFuture = $this->invert === 1;
+
+		$transId = $relativeToNow ? ($isFuture ? 'from_now' : 'ago') : ($isFuture ? 'after' : 'before');
+
+		if ($parts === 1) {
+			if ($relativeToNow && $unit === 'day') {
+				if ($count === 1 && $options & CarbonInterface::ONE_DAY_WORDS) {
+					$key = $isFuture ? 'diff_tomorrow' : 'diff_yesterday';
+					$translation = $this->translate($key, $interpolations, null, $translator);
+
+					if ($translation !== $key) {
+						return $translation;
+					}
+				}
+
+				if ($count === 2 && $options & CarbonInterface::TWO_DAY_WORDS) {
+					$key = $isFuture ? 'diff_after_tomorrow' : 'diff_before_yesterday';
+					$translation = $this->translate($key, $interpolations, null, $translator);
+
+					if ($translation !== $key) {
+						return $translation;
+					}
+				}
+			}
+
+			$aTime = $aUnit ? $handleDeclensions('a_'.$unit, $count) : null;
+
+			$time = $aTime ?: $handleDeclensions($unit, $count) ?: $time;
+		}
+
+		$time = [':time' => $time];
+
+		return $this->translate($transId, array_merge($time, $interpolations, $time), null, $translator);
+	}
+
+	/**
+	 * Format the instance as a string using the forHumans() function.
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		$format = $this->localToStringFormat;
+
+		if (!$format) {
+			return $this->forHumans();
+		}
+
+		if ($format instanceof Closure) {
+			return $format($this);
+		}
+
+		return $this->format($format);
+	}
+
+	/**
+	 * Return native DateInterval PHP object matching the current instance.
+	 *
+	 * @example
+	 * ```
+	 * var_dump(CarbonInterval::hours(2)->toDateInterval());
+	 * ```
+	 *
+	 * @return DateInterval
+	 */
+	public function toDateInterval()
+	{
+		return self::castIntervalToClass($this, DateInterval::class);
+	}
+
+	/**
+	 * Convert the interval to a CarbonPeriod.
+	 *
+	 * @param DateTimeInterface|string|int ...$params Start date, [end date or recurrences] and optional settings.
+	 *
+	 * @return CarbonPeriod
+	 */
+	public function toPeriod(...$params)
+	{
+		if ($this->tzName) {
+			$tz = \is_string($this->tzName) ? new DateTimeZone($this->tzName) : $this->tzName;
+
+			if ($tz instanceof DateTimeZone) {
+				array_unshift($params, $tz);
+			}
+		}
+
+		return CarbonPeriod::create($this, ...$params);
+	}
+
+	/**
+	 * Invert the interval.
+	 *
+	 * @param bool|int $inverted if a parameter is passed, the passed value casted as 1 or 0 is used
+	 *                           as the new value of the ->invert property.
+	 *
+	 * @return $this
+	 */
+	public function invert($inverted = null)
+	{
+		$this->invert = (\func_num_args() === 0 ? !$this->invert : $inverted) ? 1 : 0;
+
+		return $this;
+	}
+
+	protected function solveNegativeInterval()
+	{
+		if (!$this->isEmpty() && $this->years <= 0 && $this->months <= 0 && $this->dayz <= 0 && $this->hours <= 0 && $this->minutes <= 0 && $this->seconds <= 0 && $this->microseconds <= 0) {
+			$this->years *= -1;
+			$this->months *= -1;
+			$this->dayz *= -1;
+			$this->hours *= -1;
+			$this->minutes *= -1;
+			$this->seconds *= -1;
+			$this->microseconds *= -1;
+			$this->invert();
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Add the passed interval to the current instance.
+	 *
+	 * @param string|DateInterval $unit
+	 * @param int|float           $value
+	 *
+	 * @return $this
+	 */
+	public function add($unit, $value = 1)
+	{
+		if (is_numeric($unit)) {
+			[$value, $unit] = [$unit, $value];
+		}
+
+		if (\is_string($unit) && !preg_match('/^\s*\d/', $unit)) {
+			$unit = "$value $unit";
+			$value = 1;
+		}
+
+		$interval = static::make($unit);
+
+		if (!$interval) {
+			throw new InvalidIntervalException('This type of data cannot be added/subtracted.');
+		}
+
+		if ($value !== 1) {
+			$interval->times($value);
+		}
+
+		$sign = ($this->invert === 1) !== ($interval->invert === 1) ? -1 : 1;
+		$this->years += $interval->y * $sign;
+		$this->months += $interval->m * $sign;
+		$this->dayz += ($interval->days === false ? $interval->d : $interval->days) * $sign;
+		$this->hours += $interval->h * $sign;
+		$this->minutes += $interval->i * $sign;
+		$this->seconds += $interval->s * $sign;
+		$this->microseconds += $interval->microseconds * $sign;
+
+		$this->solveNegativeInterval();
+
+		return $this;
+	}
+
+	/**
+	 * Subtract the passed interval to the current instance.
+	 *
+	 * @param string|DateInterval $unit
+	 * @param int|float           $value
+	 *
+	 * @return $this
+	 */
+	public function sub($unit, $value = 1)
+	{
+		if (is_numeric($unit)) {
+			[$value, $unit] = [$unit, $value];
+		}
+
+		return $this->add($unit, -(float) $value);
+	}
+
+	/**
+	 * Subtract the passed interval to the current instance.
+	 *
+	 * @param string|DateInterval $unit
+	 * @param int|float           $value
+	 *
+	 * @return $this
+	 */
+	public function subtract($unit, $value = 1)
+	{
+		return $this->sub($unit, $value);
+	}
+
+	/**
+	 * Add given parameters to the current interval.
+	 *
+	 * @param int       $years
+	 * @param int       $months
+	 * @param int|float $weeks
+	 * @param int|float $days
+	 * @param int|float $hours
+	 * @param int|float $minutes
+	 * @param int|float $seconds
+	 * @param int|float $microseconds
+	 *
+	 * @return $this
+	 */
+	public function plus(
+		$years = 0,
+		$months = 0,
+		$weeks = 0,
+		$days = 0,
+		$hours = 0,
+		$minutes = 0,
+		$seconds = 0,
+		$microseconds = 0
+	): self {
+		return $this->add("
             $years years $months months $weeks weeks $days days
             $hours hours $minutes minutes $seconds seconds $microseconds microseconds
         ");
-    }
-
-    /**
-     * Add given parameters to the current interval.
-     *
-     * @param int       $years
-     * @param int       $months
-     * @param int|float $weeks
-     * @param int|float $days
-     * @param int|float $hours
-     * @param int|float $minutes
-     * @param int|float $seconds
-     * @param int|float $microseconds
-     *
-     * @return $this
-     */
-    public function minus(
-        $years = 0,
-        $months = 0,
-        $weeks = 0,
-        $days = 0,
-        $hours = 0,
-        $minutes = 0,
-        $seconds = 0,
-        $microseconds = 0
-    ): self {
-        return $this->sub("
+	}
+
+	/**
+	 * Add given parameters to the current interval.
+	 *
+	 * @param int       $years
+	 * @param int       $months
+	 * @param int|float $weeks
+	 * @param int|float $days
+	 * @param int|float $hours
+	 * @param int|float $minutes
+	 * @param int|float $seconds
+	 * @param int|float $microseconds
+	 *
+	 * @return $this
+	 */
+	public function minus(
+		$years = 0,
+		$months = 0,
+		$weeks = 0,
+		$days = 0,
+		$hours = 0,
+		$minutes = 0,
+		$seconds = 0,
+		$microseconds = 0
+	): self {
+		return $this->sub("
             $years years $months months $weeks weeks $days days
             $hours hours $minutes minutes $seconds seconds $microseconds microseconds
         ");
-    }
-
-    /**
-     * Multiply current instance given number of times. times() is naive, it multiplies each unit
-     * (so day can be greater than 31, hour can be greater than 23, etc.) and the result is rounded
-     * separately for each unit.
-     *
-     * Use times() when you want a fast and approximated calculation that does not cascade units.
-     *
-     * For a precise and cascaded calculation,
-     *
-     * @see multiply()
-     *
-     * @param float|int $factor
-     *
-     * @return $this
-     */
-    public function times($factor)
-    {
-        if ($factor < 0) {
-            $this->invert = $this->invert ? 0 : 1;
-            $factor = -$factor;
-        }
-
-        $this->years = (int) round($this->years * $factor);
-        $this->months = (int) round($this->months * $factor);
-        $this->dayz = (int) round($this->dayz * $factor);
-        $this->hours = (int) round($this->hours * $factor);
-        $this->minutes = (int) round($this->minutes * $factor);
-        $this->seconds = (int) round($this->seconds * $factor);
-        $this->microseconds = (int) round($this->microseconds * $factor);
-
-        return $this;
-    }
-
-    /**
-     * Divide current instance by a given divider. shares() is naive, it divides each unit separately
-     * and the result is rounded for each unit. So 5 hours and 20 minutes shared by 3 becomes 2 hours
-     * and 7 minutes.
-     *
-     * Use shares() when you want a fast and approximated calculation that does not cascade units.
-     *
-     * For a precise and cascaded calculation,
-     *
-     * @see divide()
-     *
-     * @param float|int $divider
-     *
-     * @return $this
-     */
-    public function shares($divider)
-    {
-        return $this->times(1 / $divider);
-    }
-
-    protected function copyProperties(self $interval, $ignoreSign = false)
-    {
-        $this->years = $interval->years;
-        $this->months = $interval->months;
-        $this->dayz = $interval->dayz;
-        $this->hours = $interval->hours;
-        $this->minutes = $interval->minutes;
-        $this->seconds = $interval->seconds;
-        $this->microseconds = $interval->microseconds;
-
-        if (!$ignoreSign) {
-            $this->invert = $interval->invert;
-        }
-
-        return $this;
-    }
-
-    /**
-     * Multiply and cascade current instance by a given factor.
-     *
-     * @param float|int $factor
-     *
-     * @return $this
-     */
-    public function multiply($factor)
-    {
-        if ($factor < 0) {
-            $this->invert = $this->invert ? 0 : 1;
-            $factor = -$factor;
-        }
-
-        $yearPart = (int) floor($this->years * $factor); // Split calculation to prevent imprecision
-
-        if ($yearPart) {
-            $this->years -= $yearPart / $factor;
-        }
-
-        return $this->copyProperties(
-            static::create($yearPart)
-                ->microseconds(abs($this->totalMicroseconds) * $factor)
-                ->cascade(),
-            true
-        );
-    }
-
-    /**
-     * Divide and cascade current instance by a given divider.
-     *
-     * @param float|int $divider
-     *
-     * @return $this
-     */
-    public function divide($divider)
-    {
-        return $this->multiply(1 / $divider);
-    }
-
-    /**
-     * Get the interval_spec string of a date interval.
-     *
-     * @param DateInterval $interval
-     *
-     * @return string
-     */
-    public static function getDateIntervalSpec(DateInterval $interval, bool $microseconds = false)
-    {
-        $date = array_filter([
-            static::PERIOD_YEARS => abs($interval->y),
-            static::PERIOD_MONTHS => abs($interval->m),
-            static::PERIOD_DAYS => abs($interval->d),
-        ]);
-
-        $seconds = abs($interval->s);
-        if ($microseconds && $interval->f > 0) {
-            $seconds = sprintf('%d.%06d', $seconds, abs($interval->f) * 1000000);
-        }
-
-        $time = array_filter([
-            static::PERIOD_HOURS => abs($interval->h),
-            static::PERIOD_MINUTES => abs($interval->i),
-            static::PERIOD_SECONDS => $seconds,
-        ]);
-
-        $specString = static::PERIOD_PREFIX;
-
-        foreach ($date as $key => $value) {
-            $specString .= $value.$key;
-        }
-
-        if (\count($time) > 0) {
-            $specString .= static::PERIOD_TIME_PREFIX;
-            foreach ($time as $key => $value) {
-                $specString .= $value.$key;
-            }
-        }
-
-        return $specString === static::PERIOD_PREFIX ? 'PT0S' : $specString;
-    }
-
-    /**
-     * Get the interval_spec string.
-     *
-     * @return string
-     */
-    public function spec(bool $microseconds = false)
-    {
-        return static::getDateIntervalSpec($this, $microseconds);
-    }
-
-    /**
-     * Comparing 2 date intervals.
-     *
-     * @param DateInterval $first
-     * @param DateInterval $second
-     *
-     * @return int
-     */
-    public static function compareDateIntervals(DateInterval $first, DateInterval $second)
-    {
-        $current = Carbon::now();
-        $passed = $current->avoidMutation()->add($second);
-        $current->add($first);
-
-        if ($current < $passed) {
-            return -1;
-        }
-        if ($current > $passed) {
-            return 1;
-        }
-
-        return 0;
-    }
-
-    /**
-     * Comparing with passed interval.
-     *
-     * @param DateInterval $interval
-     *
-     * @return int
-     */
-    public function compare(DateInterval $interval)
-    {
-        return static::compareDateIntervals($this, $interval);
-    }
-
-    private function invertCascade(array $values)
-    {
-        return $this->set(array_map(function ($value) {
-            return -$value;
-        }, $values))->doCascade(true)->invert();
-    }
-
-    private function doCascade(bool $deep)
-    {
-        $originalData = $this->toArray();
-        $originalData['milliseconds'] = (int) ($originalData['microseconds'] / static::getMicrosecondsPerMillisecond());
-        $originalData['microseconds'] = $originalData['microseconds'] % static::getMicrosecondsPerMillisecond();
-        $originalData['daysExcludeWeeks'] = $originalData['days'];
-        unset($originalData['days']);
-        $newData = $originalData;
-
-        foreach (self::getFlipCascadeFactors() as $source => [$target, $factor]) {
-            foreach (['source', 'target'] as $key) {
-                if ($$key === 'dayz') {
-                    $$key = 'daysExcludeWeeks';
-                }
-            }
-
-            $value = $newData[$source];
-            $modulo = ($factor + ($value % $factor)) % $factor;
-            $newData[$source] = $modulo;
-            $newData[$target] += ($value - $modulo) / $factor;
-        }
-
-        $positive = null;
-
-        if (!$deep) {
-            foreach ($newData as $value) {
-                if ($value) {
-                    if ($positive === null) {
-                        $positive = ($value > 0);
-
-                        continue;
-                    }
-
-                    if (($value > 0) !== $positive) {
-                        return $this->invertCascade($originalData)
-                            ->solveNegativeInterval();
-                    }
-                }
-            }
-        }
-
-        return $this->set($newData)
-            ->solveNegativeInterval();
-    }
-
-    /**
-     * Convert overflowed values into bigger units.
-     *
-     * @return $this
-     */
-    public function cascade()
-    {
-        return $this->doCascade(false);
-    }
-
-    public function hasNegativeValues(): bool
-    {
-        foreach ($this->toArray() as $value) {
-            if ($value < 0) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public function hasPositiveValues(): bool
-    {
-        foreach ($this->toArray() as $value) {
-            if ($value > 0) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Get amount of given unit equivalent to the interval.
-     *
-     * @param string $unit
-     *
-     * @throws UnknownUnitException|UnitNotConfiguredException
-     *
-     * @return float
-     */
-    public function total($unit)
-    {
-        $realUnit = $unit = strtolower($unit);
-
-        if (\in_array($unit, ['days', 'weeks'])) {
-            $realUnit = 'dayz';
-        } elseif (!\in_array($unit, ['microseconds', 'milliseconds', 'seconds', 'minutes', 'hours', 'dayz', 'months', 'years'])) {
-            throw new UnknownUnitException($unit);
-        }
-
-        $result = 0;
-        $cumulativeFactor = 0;
-        $unitFound = false;
-        $factors = self::getFlipCascadeFactors();
-        $daysPerWeek = static::getDaysPerWeek();
-
-        $values = [
-            'years' => $this->years,
-            'months' => $this->months,
-            'weeks' => (int) ($this->d / $daysPerWeek),
-            'dayz' => $this->d % $daysPerWeek,
-            'hours' => $this->hours,
-            'minutes' => $this->minutes,
-            'seconds' => $this->seconds,
-            'milliseconds' => (int) ($this->microseconds / Carbon::MICROSECONDS_PER_MILLISECOND),
-            'microseconds' => $this->microseconds % Carbon::MICROSECONDS_PER_MILLISECOND,
-        ];
-
-        if (isset($factors['dayz']) && $factors['dayz'][0] !== 'weeks') {
-            $values['dayz'] += $values['weeks'] * $daysPerWeek;
-            $values['weeks'] = 0;
-        }
-
-        foreach ($factors as $source => [$target, $factor]) {
-            if ($source === $realUnit) {
-                $unitFound = true;
-                $value = $values[$source];
-                $result += $value;
-                $cumulativeFactor = 1;
-            }
-
-            if ($factor === false) {
-                if ($unitFound) {
-                    break;
-                }
-
-                $result = 0;
-                $cumulativeFactor = 0;
-
-                continue;
-            }
-
-            if ($target === $realUnit) {
-                $unitFound = true;
-            }
-
-            if ($cumulativeFactor) {
-                $cumulativeFactor *= $factor;
-                $result += $values[$target] * $cumulativeFactor;
-
-                continue;
-            }
-
-            $value = $values[$source];
-
-            $result = ($result + $value) / $factor;
-        }
-
-        if (isset($target) && !$cumulativeFactor) {
-            $result += $values[$target];
-        }
-
-        if (!$unitFound) {
-            throw new UnitNotConfiguredException($unit);
-        }
-
-        if ($this->invert) {
-            $result *= -1;
-        }
-
-        if ($unit === 'weeks') {
-            return $result / $daysPerWeek;
-        }
-
-        return $result;
-    }
-
-    /**
-     * Determines if the instance is equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @see equalTo()
-     *
-     * @return bool
-     */
-    public function eq($interval): bool
-    {
-        return $this->equalTo($interval);
-    }
-
-    /**
-     * Determines if the instance is equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @return bool
-     */
-    public function equalTo($interval): bool
-    {
-        $interval = $this->resolveInterval($interval);
-
-        return $interval !== null && $this->totalMicroseconds === $interval->totalMicroseconds;
-    }
-
-    /**
-     * Determines if the instance is not equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @see notEqualTo()
-     *
-     * @return bool
-     */
-    public function ne($interval): bool
-    {
-        return $this->notEqualTo($interval);
-    }
-
-    /**
-     * Determines if the instance is not equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @return bool
-     */
-    public function notEqualTo($interval): bool
-    {
-        return !$this->eq($interval);
-    }
-
-    /**
-     * Determines if the instance is greater (longer) than another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @see greaterThan()
-     *
-     * @return bool
-     */
-    public function gt($interval): bool
-    {
-        return $this->greaterThan($interval);
-    }
-
-    /**
-     * Determines if the instance is greater (longer) than another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @return bool
-     */
-    public function greaterThan($interval): bool
-    {
-        $interval = $this->resolveInterval($interval);
-
-        return $interval === null || $this->totalMicroseconds > $interval->totalMicroseconds;
-    }
-
-    /**
-     * Determines if the instance is greater (longer) than or equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @see greaterThanOrEqualTo()
-     *
-     * @return bool
-     */
-    public function gte($interval): bool
-    {
-        return $this->greaterThanOrEqualTo($interval);
-    }
-
-    /**
-     * Determines if the instance is greater (longer) than or equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @return bool
-     */
-    public function greaterThanOrEqualTo($interval): bool
-    {
-        return $this->greaterThan($interval) || $this->equalTo($interval);
-    }
-
-    /**
-     * Determines if the instance is less (shorter) than another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @see lessThan()
-     *
-     * @return bool
-     */
-    public function lt($interval): bool
-    {
-        return $this->lessThan($interval);
-    }
-
-    /**
-     * Determines if the instance is less (shorter) than another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @return bool
-     */
-    public function lessThan($interval): bool
-    {
-        $interval = $this->resolveInterval($interval);
-
-        return $interval !== null && $this->totalMicroseconds < $interval->totalMicroseconds;
-    }
-
-    /**
-     * Determines if the instance is less (shorter) than or equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @see lessThanOrEqualTo()
-     *
-     * @return bool
-     */
-    public function lte($interval): bool
-    {
-        return $this->lessThanOrEqualTo($interval);
-    }
-
-    /**
-     * Determines if the instance is less (shorter) than or equal to another
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval
-     *
-     * @return bool
-     */
-    public function lessThanOrEqualTo($interval): bool
-    {
-        return $this->lessThan($interval) || $this->equalTo($interval);
-    }
-
-    /**
-     * Determines if the instance is between two others.
-     *
-     * The third argument allow you to specify if bounds are included or not (true by default)
-     * but for when you including/excluding bounds may produce different results in your application,
-     * we recommend to use the explicit methods ->betweenIncluded() or ->betweenExcluded() instead.
-     *
-     * @example
-     * ```
-     * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::days(3)); // true
-     * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::hours(36)); // false
-     * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::days(2)); // true
-     * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::days(2), false); // false
-     * ```
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval1
-     * @param CarbonInterval|DateInterval|mixed $interval2
-     * @param bool                              $equal     Indicates if an equal to comparison should be done
-     *
-     * @return bool
-     */
-    public function between($interval1, $interval2, $equal = true): bool
-    {
-        return $equal
-            ? $this->greaterThanOrEqualTo($interval1) && $this->lessThanOrEqualTo($interval2)
-            : $this->greaterThan($interval1) && $this->lessThan($interval2);
-    }
-
-    /**
-     * Determines if the instance is between two others, bounds excluded.
-     *
-     * @example
-     * ```
-     * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(3)); // true
-     * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::hours(36)); // false
-     * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(2)); // true
-     * ```
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval1
-     * @param CarbonInterval|DateInterval|mixed $interval2
-     *
-     * @return bool
-     */
-    public function betweenIncluded($interval1, $interval2): bool
-    {
-        return $this->between($interval1, $interval2, true);
-    }
-
-    /**
-     * Determines if the instance is between two others, bounds excluded.
-     *
-     * @example
-     * ```
-     * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(3)); // true
-     * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::hours(36)); // false
-     * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(2)); // false
-     * ```
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval1
-     * @param CarbonInterval|DateInterval|mixed $interval2
-     *
-     * @return bool
-     */
-    public function betweenExcluded($interval1, $interval2): bool
-    {
-        return $this->between($interval1, $interval2, false);
-    }
-
-    /**
-     * Determines if the instance is between two others
-     *
-     * @example
-     * ```
-     * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::days(3)); // true
-     * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::hours(36)); // false
-     * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::days(2)); // true
-     * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::days(2), false); // false
-     * ```
-     *
-     * @param CarbonInterval|DateInterval|mixed $interval1
-     * @param CarbonInterval|DateInterval|mixed $interval2
-     * @param bool                              $equal     Indicates if an equal to comparison should be done
-     *
-     * @return bool
-     */
-    public function isBetween($interval1, $interval2, $equal = true): bool
-    {
-        return $this->between($interval1, $interval2, $equal);
-    }
-
-    /**
-     * Round the current instance at the given unit with given precision if specified and the given function.
-     *
-     * @param string                             $unit
-     * @param float|int|string|DateInterval|null $precision
-     * @param string                             $function
-     *
-     * @throws Exception
-     *
-     * @return $this
-     */
-    public function roundUnit($unit, $precision = 1, $function = 'round')
-    {
-        $base = CarbonImmutable::parse('2000-01-01 00:00:00', 'UTC')
-            ->roundUnit($unit, $precision, $function);
-        $next = $base->add($this);
-        $inverted = $next < $base;
-
-        if ($inverted) {
-            $next = $base->sub($this);
-        }
-
-        $this->copyProperties(
-            $next
-                ->roundUnit($unit, $precision, $function)
-                ->diffAsCarbonInterval($base)
-        );
-
-        return $this->invert($inverted);
-    }
-
-    /**
-     * Truncate the current instance at the given unit with given precision if specified.
-     *
-     * @param string                             $unit
-     * @param float|int|string|DateInterval|null $precision
-     *
-     * @throws Exception
-     *
-     * @return $this
-     */
-    public function floorUnit($unit, $precision = 1)
-    {
-        return $this->roundUnit($unit, $precision, 'floor');
-    }
-
-    /**
-     * Ceil the current instance at the given unit with given precision if specified.
-     *
-     * @param string                             $unit
-     * @param float|int|string|DateInterval|null $precision
-     *
-     * @throws Exception
-     *
-     * @return $this
-     */
-    public function ceilUnit($unit, $precision = 1)
-    {
-        return $this->roundUnit($unit, $precision, 'ceil');
-    }
-
-    /**
-     * Round the current instance second with given precision if specified.
-     *
-     * @param float|int|string|DateInterval|null $precision
-     * @param string                             $function
-     *
-     * @throws Exception
-     *
-     * @return $this
-     */
-    public function round($precision = 1, $function = 'round')
-    {
-        return $this->roundWith($precision, $function);
-    }
-
-    /**
-     * Round the current instance second with given precision if specified.
-     *
-     * @param float|int|string|DateInterval|null $precision
-     *
-     * @throws Exception
-     *
-     * @return $this
-     */
-    public function floor($precision = 1)
-    {
-        return $this->round($precision, 'floor');
-    }
-
-    /**
-     * Ceil the current instance second with given precision if specified.
-     *
-     * @param float|int|string|DateInterval|null $precision
-     *
-     * @throws Exception
-     *
-     * @return $this
-     */
-    public function ceil($precision = 1)
-    {
-        return $this->round($precision, 'ceil');
-    }
-
-    private function needsDeclension(string $mode, int $index, int $parts): bool
-    {
-        switch ($mode) {
-            case 'last':
-                return $index === $parts - 1;
-            default:
-                return true;
-        }
-    }
+	}
+
+	/**
+	 * Multiply current instance given number of times. times() is naive, it multiplies each unit
+	 * (so day can be greater than 31, hour can be greater than 23, etc.) and the result is rounded
+	 * separately for each unit.
+	 *
+	 * Use times() when you want a fast and approximated calculation that does not cascade units.
+	 *
+	 * For a precise and cascaded calculation,
+	 *
+	 * @see multiply()
+	 *
+	 * @param float|int $factor
+	 *
+	 * @return $this
+	 */
+	public function times($factor)
+	{
+		if ($factor < 0) {
+			$this->invert = $this->invert ? 0 : 1;
+			$factor = -$factor;
+		}
+
+		$this->years = (int) round($this->years * $factor);
+		$this->months = (int) round($this->months * $factor);
+		$this->dayz = (int) round($this->dayz * $factor);
+		$this->hours = (int) round($this->hours * $factor);
+		$this->minutes = (int) round($this->minutes * $factor);
+		$this->seconds = (int) round($this->seconds * $factor);
+		$this->microseconds = (int) round($this->microseconds * $factor);
+
+		return $this;
+	}
+
+	/**
+	 * Divide current instance by a given divider. shares() is naive, it divides each unit separately
+	 * and the result is rounded for each unit. So 5 hours and 20 minutes shared by 3 becomes 2 hours
+	 * and 7 minutes.
+	 *
+	 * Use shares() when you want a fast and approximated calculation that does not cascade units.
+	 *
+	 * For a precise and cascaded calculation,
+	 *
+	 * @see divide()
+	 *
+	 * @param float|int $divider
+	 *
+	 * @return $this
+	 */
+	public function shares($divider)
+	{
+		return $this->times(1 / $divider);
+	}
+
+	protected function copyProperties(self $interval, $ignoreSign = false)
+	{
+		$this->years = $interval->years;
+		$this->months = $interval->months;
+		$this->dayz = $interval->dayz;
+		$this->hours = $interval->hours;
+		$this->minutes = $interval->minutes;
+		$this->seconds = $interval->seconds;
+		$this->microseconds = $interval->microseconds;
+
+		if (!$ignoreSign) {
+			$this->invert = $interval->invert;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Multiply and cascade current instance by a given factor.
+	 *
+	 * @param float|int $factor
+	 *
+	 * @return $this
+	 */
+	public function multiply($factor)
+	{
+		if ($factor < 0) {
+			$this->invert = $this->invert ? 0 : 1;
+			$factor = -$factor;
+		}
+
+		$yearPart = (int) floor($this->years * $factor); // Split calculation to prevent imprecision
+
+		if ($yearPart) {
+			$this->years -= $yearPart / $factor;
+		}
+
+		return $this->copyProperties(
+			static::create($yearPart)
+				->microseconds(abs($this->totalMicroseconds) * $factor)
+				->cascade(),
+			true
+		);
+	}
+
+	/**
+	 * Divide and cascade current instance by a given divider.
+	 *
+	 * @param float|int $divider
+	 *
+	 * @return $this
+	 */
+	public function divide($divider)
+	{
+		return $this->multiply(1 / $divider);
+	}
+
+	/**
+	 * Get the interval_spec string of a date interval.
+	 *
+	 * @param DateInterval $interval
+	 *
+	 * @return string
+	 */
+	public static function getDateIntervalSpec(DateInterval $interval, bool $microseconds = false)
+	{
+		$date = array_filter([
+			static::PERIOD_YEARS => abs($interval->y),
+			static::PERIOD_MONTHS => abs($interval->m),
+			static::PERIOD_DAYS => abs($interval->d),
+		]);
+
+		$seconds = abs($interval->s);
+		if ($microseconds && $interval->f > 0) {
+			$seconds = sprintf('%d.%06d', $seconds, abs($interval->f) * 1000000);
+		}
+
+		$time = array_filter([
+			static::PERIOD_HOURS => abs($interval->h),
+			static::PERIOD_MINUTES => abs($interval->i),
+			static::PERIOD_SECONDS => $seconds,
+		]);
+
+		$specString = static::PERIOD_PREFIX;
+
+		foreach ($date as $key => $value) {
+			$specString .= $value.$key;
+		}
+
+		if (\count($time) > 0) {
+			$specString .= static::PERIOD_TIME_PREFIX;
+			foreach ($time as $key => $value) {
+				$specString .= $value.$key;
+			}
+		}
+
+		return $specString === static::PERIOD_PREFIX ? 'PT0S' : $specString;
+	}
+
+	/**
+	 * Get the interval_spec string.
+	 *
+	 * @return string
+	 */
+	public function spec(bool $microseconds = false)
+	{
+		return static::getDateIntervalSpec($this, $microseconds);
+	}
+
+	/**
+	 * Comparing 2 date intervals.
+	 *
+	 * @param DateInterval $first
+	 * @param DateInterval $second
+	 *
+	 * @return int
+	 */
+	public static function compareDateIntervals(DateInterval $first, DateInterval $second)
+	{
+		$current = Carbon::now();
+		$passed = $current->avoidMutation()->add($second);
+		$current->add($first);
+
+		if ($current < $passed) {
+			return -1;
+		}
+		if ($current > $passed) {
+			return 1;
+		}
+
+		return 0;
+	}
+
+	/**
+	 * Comparing with passed interval.
+	 *
+	 * @param DateInterval $interval
+	 *
+	 * @return int
+	 */
+	public function compare(DateInterval $interval)
+	{
+		return static::compareDateIntervals($this, $interval);
+	}
+
+	private function invertCascade(array $values)
+	{
+		return $this->set(array_map(function ($value) {
+			return -$value;
+		}, $values))->doCascade(true)->invert();
+	}
+
+	private function doCascade(bool $deep)
+	{
+		$originalData = $this->toArray();
+		$originalData['milliseconds'] = (int) ($originalData['microseconds'] / static::getMicrosecondsPerMillisecond());
+		$originalData['microseconds'] = $originalData['microseconds'] % static::getMicrosecondsPerMillisecond();
+		$originalData['daysExcludeWeeks'] = $originalData['days'];
+		unset($originalData['days']);
+		$newData = $originalData;
+
+		foreach (self::getFlipCascadeFactors() as $source => [$target, $factor]) {
+			foreach (['source', 'target'] as $key) {
+				if ($$key === 'dayz') {
+					$$key = 'daysExcludeWeeks';
+				}
+			}
+
+			$value = $newData[$source];
+			$modulo = ($factor + ($value % $factor)) % $factor;
+			$newData[$source] = $modulo;
+			$newData[$target] += ($value - $modulo) / $factor;
+		}
+
+		$positive = null;
+
+		if (!$deep) {
+			foreach ($newData as $value) {
+				if ($value) {
+					if ($positive === null) {
+						$positive = ($value > 0);
+
+						continue;
+					}
+
+					if (($value > 0) !== $positive) {
+						return $this->invertCascade($originalData)
+							->solveNegativeInterval();
+					}
+				}
+			}
+		}
+
+		return $this->set($newData)
+			->solveNegativeInterval();
+	}
+
+	/**
+	 * Convert overflowed values into bigger units.
+	 *
+	 * @return $this
+	 */
+	public function cascade()
+	{
+		return $this->doCascade(false);
+	}
+
+	public function hasNegativeValues(): bool
+	{
+		foreach ($this->toArray() as $value) {
+			if ($value < 0) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public function hasPositiveValues(): bool
+	{
+		foreach ($this->toArray() as $value) {
+			if ($value > 0) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Get amount of given unit equivalent to the interval.
+	 *
+	 * @param string $unit
+	 *
+	 * @throws UnknownUnitException|UnitNotConfiguredException
+	 *
+	 * @return float
+	 */
+	public function total($unit)
+	{
+		$realUnit = $unit = strtolower($unit);
+
+		if (\in_array($unit, ['days', 'weeks'])) {
+			$realUnit = 'dayz';
+		} elseif (!\in_array($unit, ['microseconds', 'milliseconds', 'seconds', 'minutes', 'hours', 'dayz', 'months', 'years'])) {
+			throw new UnknownUnitException($unit);
+		}
+
+		$result = 0;
+		$cumulativeFactor = 0;
+		$unitFound = false;
+		$factors = self::getFlipCascadeFactors();
+		$daysPerWeek = static::getDaysPerWeek();
+
+		$values = [
+			'years' => $this->years,
+			'months' => $this->months,
+			'weeks' => (int) ($this->d / $daysPerWeek),
+			'dayz' => $this->d % $daysPerWeek,
+			'hours' => $this->hours,
+			'minutes' => $this->minutes,
+			'seconds' => $this->seconds,
+			'milliseconds' => (int) ($this->microseconds / Carbon::MICROSECONDS_PER_MILLISECOND),
+			'microseconds' => $this->microseconds % Carbon::MICROSECONDS_PER_MILLISECOND,
+		];
+
+		if (isset($factors['dayz']) && $factors['dayz'][0] !== 'weeks') {
+			$values['dayz'] += $values['weeks'] * $daysPerWeek;
+			$values['weeks'] = 0;
+		}
+
+		foreach ($factors as $source => [$target, $factor]) {
+			if ($source === $realUnit) {
+				$unitFound = true;
+				$value = $values[$source];
+				$result += $value;
+				$cumulativeFactor = 1;
+			}
+
+			if ($factor === false) {
+				if ($unitFound) {
+					break;
+				}
+
+				$result = 0;
+				$cumulativeFactor = 0;
+
+				continue;
+			}
+
+			if ($target === $realUnit) {
+				$unitFound = true;
+			}
+
+			if ($cumulativeFactor) {
+				$cumulativeFactor *= $factor;
+				$result += $values[$target] * $cumulativeFactor;
+
+				continue;
+			}
+
+			$value = $values[$source];
+
+			$result = ($result + $value) / $factor;
+		}
+
+		if (isset($target) && !$cumulativeFactor) {
+			$result += $values[$target];
+		}
+
+		if (!$unitFound) {
+			throw new UnitNotConfiguredException($unit);
+		}
+
+		if ($this->invert) {
+			$result *= -1;
+		}
+
+		if ($unit === 'weeks') {
+			return $result / $daysPerWeek;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Determines if the instance is equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @see equalTo()
+	 *
+	 * @return bool
+	 */
+	public function eq($interval): bool
+	{
+		return $this->equalTo($interval);
+	}
+
+	/**
+	 * Determines if the instance is equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @return bool
+	 */
+	public function equalTo($interval): bool
+	{
+		$interval = $this->resolveInterval($interval);
+
+		return $interval !== null && $this->totalMicroseconds === $interval->totalMicroseconds;
+	}
+
+	/**
+	 * Determines if the instance is not equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @see notEqualTo()
+	 *
+	 * @return bool
+	 */
+	public function ne($interval): bool
+	{
+		return $this->notEqualTo($interval);
+	}
+
+	/**
+	 * Determines if the instance is not equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @return bool
+	 */
+	public function notEqualTo($interval): bool
+	{
+		return !$this->eq($interval);
+	}
+
+	/**
+	 * Determines if the instance is greater (longer) than another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @see greaterThan()
+	 *
+	 * @return bool
+	 */
+	public function gt($interval): bool
+	{
+		return $this->greaterThan($interval);
+	}
+
+	/**
+	 * Determines if the instance is greater (longer) than another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @return bool
+	 */
+	public function greaterThan($interval): bool
+	{
+		$interval = $this->resolveInterval($interval);
+
+		return $interval === null || $this->totalMicroseconds > $interval->totalMicroseconds;
+	}
+
+	/**
+	 * Determines if the instance is greater (longer) than or equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @see greaterThanOrEqualTo()
+	 *
+	 * @return bool
+	 */
+	public function gte($interval): bool
+	{
+		return $this->greaterThanOrEqualTo($interval);
+	}
+
+	/**
+	 * Determines if the instance is greater (longer) than or equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @return bool
+	 */
+	public function greaterThanOrEqualTo($interval): bool
+	{
+		return $this->greaterThan($interval) || $this->equalTo($interval);
+	}
+
+	/**
+	 * Determines if the instance is less (shorter) than another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @see lessThan()
+	 *
+	 * @return bool
+	 */
+	public function lt($interval): bool
+	{
+		return $this->lessThan($interval);
+	}
+
+	/**
+	 * Determines if the instance is less (shorter) than another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @return bool
+	 */
+	public function lessThan($interval): bool
+	{
+		$interval = $this->resolveInterval($interval);
+
+		return $interval !== null && $this->totalMicroseconds < $interval->totalMicroseconds;
+	}
+
+	/**
+	 * Determines if the instance is less (shorter) than or equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @see lessThanOrEqualTo()
+	 *
+	 * @return bool
+	 */
+	public function lte($interval): bool
+	{
+		return $this->lessThanOrEqualTo($interval);
+	}
+
+	/**
+	 * Determines if the instance is less (shorter) than or equal to another
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval
+	 *
+	 * @return bool
+	 */
+	public function lessThanOrEqualTo($interval): bool
+	{
+		return $this->lessThan($interval) || $this->equalTo($interval);
+	}
+
+	/**
+	 * Determines if the instance is between two others.
+	 *
+	 * The third argument allow you to specify if bounds are included or not (true by default)
+	 * but for when you including/excluding bounds may produce different results in your application,
+	 * we recommend to use the explicit methods ->betweenIncluded() or ->betweenExcluded() instead.
+	 *
+	 * @example
+	 * ```
+	 * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::days(3)); // true
+	 * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::hours(36)); // false
+	 * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::days(2)); // true
+	 * CarbonInterval::hours(48)->between(CarbonInterval::day(), CarbonInterval::days(2), false); // false
+	 * ```
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval1
+	 * @param CarbonInterval|DateInterval|mixed $interval2
+	 * @param bool                              $equal     Indicates if an equal to comparison should be done
+	 *
+	 * @return bool
+	 */
+	public function between($interval1, $interval2, $equal = true): bool
+	{
+		return $equal
+			? $this->greaterThanOrEqualTo($interval1) && $this->lessThanOrEqualTo($interval2)
+			: $this->greaterThan($interval1) && $this->lessThan($interval2);
+	}
+
+	/**
+	 * Determines if the instance is between two others, bounds excluded.
+	 *
+	 * @example
+	 * ```
+	 * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(3)); // true
+	 * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::hours(36)); // false
+	 * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(2)); // true
+	 * ```
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval1
+	 * @param CarbonInterval|DateInterval|mixed $interval2
+	 *
+	 * @return bool
+	 */
+	public function betweenIncluded($interval1, $interval2): bool
+	{
+		return $this->between($interval1, $interval2, true);
+	}
+
+	/**
+	 * Determines if the instance is between two others, bounds excluded.
+	 *
+	 * @example
+	 * ```
+	 * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(3)); // true
+	 * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::hours(36)); // false
+	 * CarbonInterval::hours(48)->betweenExcluded(CarbonInterval::day(), CarbonInterval::days(2)); // false
+	 * ```
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval1
+	 * @param CarbonInterval|DateInterval|mixed $interval2
+	 *
+	 * @return bool
+	 */
+	public function betweenExcluded($interval1, $interval2): bool
+	{
+		return $this->between($interval1, $interval2, false);
+	}
+
+	/**
+	 * Determines if the instance is between two others
+	 *
+	 * @example
+	 * ```
+	 * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::days(3)); // true
+	 * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::hours(36)); // false
+	 * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::days(2)); // true
+	 * CarbonInterval::hours(48)->isBetween(CarbonInterval::day(), CarbonInterval::days(2), false); // false
+	 * ```
+	 *
+	 * @param CarbonInterval|DateInterval|mixed $interval1
+	 * @param CarbonInterval|DateInterval|mixed $interval2
+	 * @param bool                              $equal     Indicates if an equal to comparison should be done
+	 *
+	 * @return bool
+	 */
+	public function isBetween($interval1, $interval2, $equal = true): bool
+	{
+		return $this->between($interval1, $interval2, $equal);
+	}
+
+	/**
+	 * Round the current instance at the given unit with given precision if specified and the given function.
+	 *
+	 * @param string                             $unit
+	 * @param float|int|string|DateInterval|null $precision
+	 * @param string                             $function
+	 *
+	 * @throws Exception
+	 *
+	 * @return $this
+	 */
+	public function roundUnit($unit, $precision = 1, $function = 'round')
+	{
+		$base = CarbonImmutable::parse('2000-01-01 00:00:00', 'UTC')
+			->roundUnit($unit, $precision, $function);
+		$next = $base->add($this);
+		$inverted = $next < $base;
+
+		if ($inverted) {
+			$next = $base->sub($this);
+		}
+
+		$this->copyProperties(
+			$next
+				->roundUnit($unit, $precision, $function)
+				->diffAsCarbonInterval($base)
+		);
+
+		return $this->invert($inverted);
+	}
+
+	/**
+	 * Truncate the current instance at the given unit with given precision if specified.
+	 *
+	 * @param string                             $unit
+	 * @param float|int|string|DateInterval|null $precision
+	 *
+	 * @throws Exception
+	 *
+	 * @return $this
+	 */
+	public function floorUnit($unit, $precision = 1)
+	{
+		return $this->roundUnit($unit, $precision, 'floor');
+	}
+
+	/**
+	 * Ceil the current instance at the given unit with given precision if specified.
+	 *
+	 * @param string                             $unit
+	 * @param float|int|string|DateInterval|null $precision
+	 *
+	 * @throws Exception
+	 *
+	 * @return $this
+	 */
+	public function ceilUnit($unit, $precision = 1)
+	{
+		return $this->roundUnit($unit, $precision, 'ceil');
+	}
+
+	/**
+	 * Round the current instance second with given precision if specified.
+	 *
+	 * @param float|int|string|DateInterval|null $precision
+	 * @param string                             $function
+	 *
+	 * @throws Exception
+	 *
+	 * @return $this
+	 */
+	public function round($precision = 1, $function = 'round')
+	{
+		return $this->roundWith($precision, $function);
+	}
+
+	/**
+	 * Round the current instance second with given precision if specified.
+	 *
+	 * @param float|int|string|DateInterval|null $precision
+	 *
+	 * @throws Exception
+	 *
+	 * @return $this
+	 */
+	public function floor($precision = 1)
+	{
+		return $this->round($precision, 'floor');
+	}
+
+	/**
+	 * Ceil the current instance second with given precision if specified.
+	 *
+	 * @param float|int|string|DateInterval|null $precision
+	 *
+	 * @throws Exception
+	 *
+	 * @return $this
+	 */
+	public function ceil($precision = 1)
+	{
+		return $this->round($precision, 'ceil');
+	}
+
+	private function needsDeclension(string $mode, int $index, int $parts): bool
+	{
+		switch ($mode) {
+			case 'last':
+				return $index === $parts - 1;
+			default:
+				return true;
+		}
+	}
 }

Spacing +17 added lines, -19 removed lines

@@ -656,7 +656,7 @@ 
             $interval->localStrictModeEnabled = true;
 
             $result = static::hasMacro($method)
-                ? static::bindMacroContext(null, function () use (&$method, &$parameters, &$interval) {
+                ? static::bindMacroContext(null, function() use (&$method, &$parameters, &$interval) {
                     return $interval->callMacro($method, $parameters);
                 })
                 : $interval->$method(...$parameters);
@@ -746,9 +746,7 @@ 
             }
 
             switch ($unit === 'µs' ? 'µs' : strtolower($unit)) {
-                case 'millennia':
-                case 'millennium':
-                    $years += $intValue * CarbonInterface::YEARS_PER_MILLENNIUM;
+                case 'millennia' : case 'millennium' : $years += $intValue * CarbonInterface::YEARS_PER_MILLENNIUM;
 
                     break;
 
@@ -1343,7 +1341,7 @@ 
     public function __call($method, $parameters)
     {
         if (static::hasMacro($method)) {
-            return static::bindMacroContext($this, function () use (&$method, &$parameters) {
+            return static::bindMacroContext($this, function() use (&$method, &$parameters) {
                 return $this->callMacro($method, $parameters);
             });
         }
@@ -1410,7 +1408,7 @@ 
         $minimumUnit = 's';
         $skip = [];
         extract($this->getForHumansInitialVariables($syntax, $short));
-        $skip = array_filter((array) $skip, static function ($value) {
+        $skip = array_filter((array) $skip, static function($value) {
             return \is_string($value) && $value !== '';
         });
 
@@ -1447,7 +1445,7 @@ 
                 $optionalSpace = '';
             }
 
-            $join = function ($list) use ($default, $last) {
+            $join = function($list) use ($default, $last) {
                 if (\count($list) < 2) {
                     return implode('', $list);
                 }
@@ -1464,7 +1462,7 @@ 
             }
 
             $glue = $join;
-            $join = function ($list) use ($glue) {
+            $join = function($list) use ($glue) {
                 return implode($glue, $list);
             };
         }
@@ -1623,7 +1621,7 @@ 
         /** @var \Symfony\Component\Translation\Translator $translator */
         $translator = $this->getLocalTranslator();
 
-        $handleDeclensions = function ($unit, $count, $index = 0, $parts = 1) use ($interpolations, $transId, $translator, $altNumbers, $absolute, &$declensionMode) {
+        $handleDeclensions = function($unit, $count, $index = 0, $parts = 1) use ($interpolations, $transId, $translator, $altNumbers, $absolute, &$declensionMode) {
             if (!$absolute) {
                 $declensionMode = $declensionMode ?? $this->translate($transId.'_mode');
 
@@ -1673,14 +1671,14 @@ 
         }
 
         $diffIntervalArray = [
-            ['value' => $intervalValues->years,             'unit' => 'year',        'unitShort' => 'y'],
-            ['value' => $intervalValues->months,            'unit' => 'month',       'unitShort' => 'm'],
-            ['value' => $intervalValues->weeks,             'unit' => 'week',        'unitShort' => 'w'],
-            ['value' => $intervalValues->daysExcludeWeeks,  'unit' => 'day',         'unitShort' => 'd'],
-            ['value' => $intervalValues->hours,             'unit' => 'hour',        'unitShort' => 'h'],
-            ['value' => $intervalValues->minutes,           'unit' => 'minute',      'unitShort' => 'min'],
-            ['value' => $intervalValues->seconds,           'unit' => 'second',      'unitShort' => 's'],
-            ['value' => $intervalValues->milliseconds,      'unit' => 'millisecond', 'unitShort' => 'ms'],
+            ['value' => $intervalValues->years, 'unit' => 'year', 'unitShort' => 'y'],
+            ['value' => $intervalValues->months, 'unit' => 'month', 'unitShort' => 'm'],
+            ['value' => $intervalValues->weeks, 'unit' => 'week', 'unitShort' => 'w'],
+            ['value' => $intervalValues->daysExcludeWeeks, 'unit' => 'day', 'unitShort' => 'd'],
+            ['value' => $intervalValues->hours, 'unit' => 'hour', 'unitShort' => 'h'],
+            ['value' => $intervalValues->minutes, 'unit' => 'minute', 'unitShort' => 'min'],
+            ['value' => $intervalValues->seconds, 'unit' => 'second', 'unitShort' => 's'],
+            ['value' => $intervalValues->milliseconds, 'unit' => 'millisecond', 'unitShort' => 'ms'],
             ['value' => $intervalValues->microExcludeMilli, 'unit' => 'microsecond', 'unitShort' => 'µs'],
         ];
 
@@ -1699,7 +1697,7 @@ 
             }
         }
 
-        $transChoice = function ($short, $unitData, $index, $parts) use ($absolute, $handleDeclensions, $translator, $aUnit, $altNumbers, $interpolations) {
+        $transChoice = function($short, $unitData, $index, $parts) use ($absolute, $handleDeclensions, $translator, $aUnit, $altNumbers, $interpolations) {
             $count = $unitData['value'];
 
             if ($short) {
@@ -2233,7 +2231,7 @@ 
 
     private function invertCascade(array $values)
     {
-        return $this->set(array_map(function ($value) {
+        return $this->set(array_map(function($value) {
             return -$value;
         }, $values))->doCascade(true)->invert();
     }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/CarbonTimeZone.php

Indentation +298 added lines, -298 removed lines

@@ -19,302 +19,302 @@
 
 class CarbonTimeZone extends DateTimeZone
 {
-    public function __construct($timezone = null)
-    {
-        parent::__construct(static::getDateTimeZoneNameFromMixed($timezone));
-    }
-
-    protected static function parseNumericTimezone($timezone)
-    {
-        if ($timezone <= -100 || $timezone >= 100) {
-            throw new InvalidTimeZoneException('Absolute timezone offset cannot be greater than 100.');
-        }
-
-        return ($timezone >= 0 ? '+' : '').ltrim($timezone, '+').':00';
-    }
-
-    protected static function getDateTimeZoneNameFromMixed($timezone)
-    {
-        if ($timezone === null) {
-            return date_default_timezone_get();
-        }
-
-        if (\is_string($timezone)) {
-            $timezone = preg_replace('/^\s*([+-]\d+)(\d{2})\s*$/', '$1:$2', $timezone);
-        }
-
-        if (is_numeric($timezone)) {
-            return static::parseNumericTimezone($timezone);
-        }
-
-        return $timezone;
-    }
-
-    protected static function getDateTimeZoneFromName(&$name)
-    {
-        return @timezone_open($name = (string) static::getDateTimeZoneNameFromMixed($name));
-    }
-
-    /**
-     * Cast the current instance into the given class.
-     *
-     * @param string $className The $className::instance() method will be called to cast the current object.
-     *
-     * @return DateTimeZone
-     */
-    public function cast(string $className)
-    {
-        if (!method_exists($className, 'instance')) {
-            if (is_a($className, DateTimeZone::class, true)) {
-                return new $className($this->getName());
-            }
-
-            throw new InvalidCastException("$className has not the instance() method needed to cast the date.");
-        }
-
-        return $className::instance($this);
-    }
-
-    /**
-     * Create a CarbonTimeZone from mixed input.
-     *
-     * @param DateTimeZone|string|int|null $object     original value to get CarbonTimeZone from it.
-     * @param DateTimeZone|string|int|null $objectDump dump of the object for error messages.
-     *
-     * @throws InvalidTimeZoneException
-     *
-     * @return false|static
-     */
-    public static function instance($object = null, $objectDump = null)
-    {
-        $tz = $object;
-
-        if ($tz instanceof static) {
-            return $tz;
-        }
-
-        if ($tz === null) {
-            return new static();
-        }
-
-        if (!$tz instanceof DateTimeZone) {
-            $tz = static::getDateTimeZoneFromName($object);
-        }
-
-        if ($tz !== false) {
-            return new static($tz->getName());
-        }
-
-        if (Carbon::isStrictModeEnabled()) {
-            throw new InvalidTimeZoneException('Unknown or bad timezone ('.($objectDump ?: $object).')');
-        }
-
-        return false;
-    }
-
-    /**
-     * Returns abbreviated name of the current timezone according to DST setting.
-     *
-     * @param bool $dst
-     *
-     * @return string
-     */
-    public function getAbbreviatedName($dst = false)
-    {
-        $name = $this->getName();
-
-        foreach ($this->listAbbreviations() as $abbreviation => $zones) {
-            foreach ($zones as $zone) {
-                if ($zone['timezone_id'] === $name && $zone['dst'] == $dst) {
-                    return $abbreviation;
-                }
-            }
-        }
-
-        return 'unknown';
-    }
-
-    /**
-     * @alias getAbbreviatedName
-     *
-     * Returns abbreviated name of the current timezone according to DST setting.
-     *
-     * @param bool $dst
-     *
-     * @return string
-     */
-    public function getAbbr($dst = false)
-    {
-        return $this->getAbbreviatedName($dst);
-    }
-
-    /**
-     * Get the offset as string "sHH:MM" (such as "+00:00" or "-12:30").
-     *
-     * @param DateTimeInterface|null $date
-     *
-     * @return string
-     */
-    public function toOffsetName(DateTimeInterface $date = null)
-    {
-        return static::getOffsetNameFromMinuteOffset(
-            $this->getOffset($date ?: Carbon::now($this)) / 60
-        );
-    }
-
-    /**
-     * Returns a new CarbonTimeZone object using the offset string instead of region string.
-     *
-     * @param DateTimeInterface|null $date
-     *
-     * @return CarbonTimeZone
-     */
-    public function toOffsetTimeZone(DateTimeInterface $date = null)
-    {
-        return new static($this->toOffsetName($date));
-    }
-
-    /**
-     * Returns the first region string (such as "America/Toronto") that matches the current timezone or
-     * false if no match is found.
-     *
-     * @see timezone_name_from_abbr native PHP function.
-     *
-     * @param DateTimeInterface|null $date
-     * @param int                    $isDst
-     *
-     * @return string|false
-     */
-    public function toRegionName(DateTimeInterface $date = null, $isDst = 1)
-    {
-        $name = $this->getName();
-        $firstChar = substr($name, 0, 1);
-
-        if ($firstChar !== '+' && $firstChar !== '-') {
-            return $name;
-        }
-
-        $date = $date ?: Carbon::now($this);
-
-        // Integer construction no longer supported since PHP 8
-        // @codeCoverageIgnoreStart
-        try {
-            $offset = @$this->getOffset($date) ?: 0;
-        } catch (Throwable $e) {
-            $offset = 0;
-        }
-        // @codeCoverageIgnoreEnd
-
-        $name = @timezone_name_from_abbr('', $offset, $isDst);
-
-        if ($name) {
-            return $name;
-        }
-
-        foreach (timezone_identifiers_list() as $timezone) {
-            if (Carbon::instance($date)->tz($timezone)->getOffset() === $offset) {
-                return $timezone;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Returns a new CarbonTimeZone object using the region string instead of offset string.
-     *
-     * @param DateTimeInterface|null $date
-     *
-     * @return CarbonTimeZone|false
-     */
-    public function toRegionTimeZone(DateTimeInterface $date = null)
-    {
-        $tz = $this->toRegionName($date);
-
-        if ($tz !== false) {
-            return new static($tz);
-        }
-
-        if (Carbon::isStrictModeEnabled()) {
-            throw new InvalidTimeZoneException('Unknown timezone for offset '.$this->getOffset($date ?: Carbon::now($this)).' seconds.');
-        }
-
-        return false;
-    }
-
-    /**
-     * Cast to string (get timezone name).
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->getName();
-    }
-
-    /**
-     * Return the type number:
-     *
-     * Type 1; A UTC offset, such as -0300
-     * Type 2; A timezone abbreviation, such as GMT
-     * Type 3: A timezone identifier, such as Europe/London
-     */
-    public function getType(): int
-    {
-        return preg_match('/"timezone_type";i:(\d)/', serialize($this), $match) ? (int) $match[1] : 3;
-    }
-
-    /**
-     * Create a CarbonTimeZone from mixed input.
-     *
-     * @param DateTimeZone|string|int|null $object
-     *
-     * @return false|static
-     */
-    public static function create($object = null)
-    {
-        return static::instance($object);
-    }
-
-    /**
-     * Create a CarbonTimeZone from int/float hour offset.
-     *
-     * @param float $hourOffset number of hour of the timezone shift (can be decimal).
-     *
-     * @return false|static
-     */
-    public static function createFromHourOffset(float $hourOffset)
-    {
-        return static::createFromMinuteOffset($hourOffset * Carbon::MINUTES_PER_HOUR);
-    }
-
-    /**
-     * Create a CarbonTimeZone from int/float minute offset.
-     *
-     * @param float $minuteOffset number of total minutes of the timezone shift.
-     *
-     * @return false|static
-     */
-    public static function createFromMinuteOffset(float $minuteOffset)
-    {
-        return static::instance(static::getOffsetNameFromMinuteOffset($minuteOffset));
-    }
-
-    /**
-     * Convert a total minutes offset into a standardized timezone offset string.
-     *
-     * @param float $minutes number of total minutes of the timezone shift.
-     *
-     * @return string
-     */
-    public static function getOffsetNameFromMinuteOffset(float $minutes): string
-    {
-        $minutes = round($minutes);
-        $unsignedMinutes = abs($minutes);
-
-        return ($minutes < 0 ? '-' : '+').
-            str_pad((string) floor($unsignedMinutes / 60), 2, '0', STR_PAD_LEFT).
-            ':'.
-            str_pad((string) ($unsignedMinutes % 60), 2, '0', STR_PAD_LEFT);
-    }
+	public function __construct($timezone = null)
+	{
+		parent::__construct(static::getDateTimeZoneNameFromMixed($timezone));
+	}
+
+	protected static function parseNumericTimezone($timezone)
+	{
+		if ($timezone <= -100 || $timezone >= 100) {
+			throw new InvalidTimeZoneException('Absolute timezone offset cannot be greater than 100.');
+		}
+
+		return ($timezone >= 0 ? '+' : '').ltrim($timezone, '+').':00';
+	}
+
+	protected static function getDateTimeZoneNameFromMixed($timezone)
+	{
+		if ($timezone === null) {
+			return date_default_timezone_get();
+		}
+
+		if (\is_string($timezone)) {
+			$timezone = preg_replace('/^\s*([+-]\d+)(\d{2})\s*$/', '$1:$2', $timezone);
+		}
+
+		if (is_numeric($timezone)) {
+			return static::parseNumericTimezone($timezone);
+		}
+
+		return $timezone;
+	}
+
+	protected static function getDateTimeZoneFromName(&$name)
+	{
+		return @timezone_open($name = (string) static::getDateTimeZoneNameFromMixed($name));
+	}
+
+	/**
+	 * Cast the current instance into the given class.
+	 *
+	 * @param string $className The $className::instance() method will be called to cast the current object.
+	 *
+	 * @return DateTimeZone
+	 */
+	public function cast(string $className)
+	{
+		if (!method_exists($className, 'instance')) {
+			if (is_a($className, DateTimeZone::class, true)) {
+				return new $className($this->getName());
+			}
+
+			throw new InvalidCastException("$className has not the instance() method needed to cast the date.");
+		}
+
+		return $className::instance($this);
+	}
+
+	/**
+	 * Create a CarbonTimeZone from mixed input.
+	 *
+	 * @param DateTimeZone|string|int|null $object     original value to get CarbonTimeZone from it.
+	 * @param DateTimeZone|string|int|null $objectDump dump of the object for error messages.
+	 *
+	 * @throws InvalidTimeZoneException
+	 *
+	 * @return false|static
+	 */
+	public static function instance($object = null, $objectDump = null)
+	{
+		$tz = $object;
+
+		if ($tz instanceof static) {
+			return $tz;
+		}
+
+		if ($tz === null) {
+			return new static();
+		}
+
+		if (!$tz instanceof DateTimeZone) {
+			$tz = static::getDateTimeZoneFromName($object);
+		}
+
+		if ($tz !== false) {
+			return new static($tz->getName());
+		}
+
+		if (Carbon::isStrictModeEnabled()) {
+			throw new InvalidTimeZoneException('Unknown or bad timezone ('.($objectDump ?: $object).')');
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns abbreviated name of the current timezone according to DST setting.
+	 *
+	 * @param bool $dst
+	 *
+	 * @return string
+	 */
+	public function getAbbreviatedName($dst = false)
+	{
+		$name = $this->getName();
+
+		foreach ($this->listAbbreviations() as $abbreviation => $zones) {
+			foreach ($zones as $zone) {
+				if ($zone['timezone_id'] === $name && $zone['dst'] == $dst) {
+					return $abbreviation;
+				}
+			}
+		}
+
+		return 'unknown';
+	}
+
+	/**
+	 * @alias getAbbreviatedName
+	 *
+	 * Returns abbreviated name of the current timezone according to DST setting.
+	 *
+	 * @param bool $dst
+	 *
+	 * @return string
+	 */
+	public function getAbbr($dst = false)
+	{
+		return $this->getAbbreviatedName($dst);
+	}
+
+	/**
+	 * Get the offset as string "sHH:MM" (such as "+00:00" or "-12:30").
+	 *
+	 * @param DateTimeInterface|null $date
+	 *
+	 * @return string
+	 */
+	public function toOffsetName(DateTimeInterface $date = null)
+	{
+		return static::getOffsetNameFromMinuteOffset(
+			$this->getOffset($date ?: Carbon::now($this)) / 60
+		);
+	}
+
+	/**
+	 * Returns a new CarbonTimeZone object using the offset string instead of region string.
+	 *
+	 * @param DateTimeInterface|null $date
+	 *
+	 * @return CarbonTimeZone
+	 */
+	public function toOffsetTimeZone(DateTimeInterface $date = null)
+	{
+		return new static($this->toOffsetName($date));
+	}
+
+	/**
+	 * Returns the first region string (such as "America/Toronto") that matches the current timezone or
+	 * false if no match is found.
+	 *
+	 * @see timezone_name_from_abbr native PHP function.
+	 *
+	 * @param DateTimeInterface|null $date
+	 * @param int                    $isDst
+	 *
+	 * @return string|false
+	 */
+	public function toRegionName(DateTimeInterface $date = null, $isDst = 1)
+	{
+		$name = $this->getName();
+		$firstChar = substr($name, 0, 1);
+
+		if ($firstChar !== '+' && $firstChar !== '-') {
+			return $name;
+		}
+
+		$date = $date ?: Carbon::now($this);
+
+		// Integer construction no longer supported since PHP 8
+		// @codeCoverageIgnoreStart
+		try {
+			$offset = @$this->getOffset($date) ?: 0;
+		} catch (Throwable $e) {
+			$offset = 0;
+		}
+		// @codeCoverageIgnoreEnd
+
+		$name = @timezone_name_from_abbr('', $offset, $isDst);
+
+		if ($name) {
+			return $name;
+		}
+
+		foreach (timezone_identifiers_list() as $timezone) {
+			if (Carbon::instance($date)->tz($timezone)->getOffset() === $offset) {
+				return $timezone;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns a new CarbonTimeZone object using the region string instead of offset string.
+	 *
+	 * @param DateTimeInterface|null $date
+	 *
+	 * @return CarbonTimeZone|false
+	 */
+	public function toRegionTimeZone(DateTimeInterface $date = null)
+	{
+		$tz = $this->toRegionName($date);
+
+		if ($tz !== false) {
+			return new static($tz);
+		}
+
+		if (Carbon::isStrictModeEnabled()) {
+			throw new InvalidTimeZoneException('Unknown timezone for offset '.$this->getOffset($date ?: Carbon::now($this)).' seconds.');
+		}
+
+		return false;
+	}
+
+	/**
+	 * Cast to string (get timezone name).
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->getName();
+	}
+
+	/**
+	 * Return the type number:
+	 *
+	 * Type 1; A UTC offset, such as -0300
+	 * Type 2; A timezone abbreviation, such as GMT
+	 * Type 3: A timezone identifier, such as Europe/London
+	 */
+	public function getType(): int
+	{
+		return preg_match('/"timezone_type";i:(\d)/', serialize($this), $match) ? (int) $match[1] : 3;
+	}
+
+	/**
+	 * Create a CarbonTimeZone from mixed input.
+	 *
+	 * @param DateTimeZone|string|int|null $object
+	 *
+	 * @return false|static
+	 */
+	public static function create($object = null)
+	{
+		return static::instance($object);
+	}
+
+	/**
+	 * Create a CarbonTimeZone from int/float hour offset.
+	 *
+	 * @param float $hourOffset number of hour of the timezone shift (can be decimal).
+	 *
+	 * @return false|static
+	 */
+	public static function createFromHourOffset(float $hourOffset)
+	{
+		return static::createFromMinuteOffset($hourOffset * Carbon::MINUTES_PER_HOUR);
+	}
+
+	/**
+	 * Create a CarbonTimeZone from int/float minute offset.
+	 *
+	 * @param float $minuteOffset number of total minutes of the timezone shift.
+	 *
+	 * @return false|static
+	 */
+	public static function createFromMinuteOffset(float $minuteOffset)
+	{
+		return static::instance(static::getOffsetNameFromMinuteOffset($minuteOffset));
+	}
+
+	/**
+	 * Convert a total minutes offset into a standardized timezone offset string.
+	 *
+	 * @param float $minutes number of total minutes of the timezone shift.
+	 *
+	 * @return string
+	 */
+	public static function getOffsetNameFromMinuteOffset(float $minutes): string
+	{
+		$minutes = round($minutes);
+		$unsignedMinutes = abs($minutes);
+
+		return ($minutes < 0 ? '-' : '+').
+			str_pad((string) floor($unsignedMinutes / 60), 2, '0', STR_PAD_LEFT).
+			':'.
+			str_pad((string) ($unsignedMinutes % 60), 2, '0', STR_PAD_LEFT);
+	}
 }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/Translator.php

Indentation +7 added lines, -7 removed lines

@@ -16,17 +16,17 @@
 use Symfony\Contracts\Translation\TranslatorInterface;
 
 $transMethod = new ReflectionMethod(
-    class_exists(TranslatorInterface::class)
-        ? TranslatorInterface::class
-        : Translation\Translator::class,
-    'trans'
+	class_exists(TranslatorInterface::class)
+		? TranslatorInterface::class
+		: Translation\Translator::class,
+	'trans'
 );
 
 require $transMethod->hasReturnType()
-    ? __DIR__.'/../../lazy/Carbon/TranslatorStrongType.php'
-    : __DIR__.'/../../lazy/Carbon/TranslatorWeakType.php';
+	? __DIR__.'/../../lazy/Carbon/TranslatorStrongType.php'
+	: __DIR__.'/../../lazy/Carbon/TranslatorWeakType.php';
 
 class Translator extends LazyTranslator
 {
-    // Proxy dynamically loaded LazyTranslator in a static way
+	// Proxy dynamically loaded LazyTranslator in a static way
 }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/CarbonImmutable.php

Indentation +59 added lines, -59 removed lines

@@ -509,74 +509,74 @@
  */
 class CarbonImmutable extends DateTimeImmutable implements CarbonInterface
 {
-    use Date {
-        __clone as dateTraitClone;
-    }
+	use Date {
+		__clone as dateTraitClone;
+	}
 
-    public function __clone()
-    {
-        $this->dateTraitClone();
-        $this->endOfTime = false;
-        $this->startOfTime = false;
-    }
+	public function __clone()
+	{
+		$this->dateTraitClone();
+		$this->endOfTime = false;
+		$this->startOfTime = false;
+	}
 
-    /**
-     * Create a very old date representing start of time.
-     *
-     * @return static
-     */
-    public static function startOfTime(): self
-    {
-        $date = static::parse('0001-01-01')->years(self::getStartOfTimeYear());
-        $date->startOfTime = true;
+	/**
+	 * Create a very old date representing start of time.
+	 *
+	 * @return static
+	 */
+	public static function startOfTime(): self
+	{
+		$date = static::parse('0001-01-01')->years(self::getStartOfTimeYear());
+		$date->startOfTime = true;
 
-        return $date;
-    }
+		return $date;
+	}
 
-    /**
-     * Create a very far date representing end of time.
-     *
-     * @return static
-     */
-    public static function endOfTime(): self
-    {
-        $date = static::parse('9999-12-31 23:59:59.999999')->years(self::getEndOfTimeYear());
-        $date->endOfTime = true;
+	/**
+	 * Create a very far date representing end of time.
+	 *
+	 * @return static
+	 */
+	public static function endOfTime(): self
+	{
+		$date = static::parse('9999-12-31 23:59:59.999999')->years(self::getEndOfTimeYear());
+		$date->endOfTime = true;
 
-        return $date;
-    }
+		return $date;
+	}
 
-    /**
-     * @codeCoverageIgnore
-     */
-    private static function getEndOfTimeYear(): int
-    {
-        if (version_compare(PHP_VERSION, '7.3.0-dev', '<')) {
-            return 145261681241552;
-        }
+	/**
+	 * @codeCoverageIgnore
+	 */
+	private static function getEndOfTimeYear(): int
+	{
+		if (version_compare(PHP_VERSION, '7.3.0-dev', '<')) {
+			return 145261681241552;
+		}
 
-        // Remove if https://bugs.php.net/bug.php?id=81107 is fixed
-        if (version_compare(PHP_VERSION, '8.1.0-dev', '>=')) {
-            return 1118290769066902787;
-        }
+		// Remove if https://bugs.php.net/bug.php?id=81107 is fixed
+		if (version_compare(PHP_VERSION, '8.1.0-dev', '>=')) {
+			return 1118290769066902787;
+		}
 
-        return PHP_INT_MAX;
-    }
+		return PHP_INT_MAX;
+	}
 
-    /**
-     * @codeCoverageIgnore
-     */
-    private static function getStartOfTimeYear(): int
-    {
-        if (version_compare(PHP_VERSION, '7.3.0-dev', '<')) {
-            return -135908816449551;
-        }
+	/**
+	 * @codeCoverageIgnore
+	 */
+	private static function getStartOfTimeYear(): int
+	{
+		if (version_compare(PHP_VERSION, '7.3.0-dev', '<')) {
+			return -135908816449551;
+		}
 
-        // Remove if https://bugs.php.net/bug.php?id=81107 is fixed
-        if (version_compare(PHP_VERSION, '8.1.0-dev', '>=')) {
-            return -1118290769066898816;
-        }
+		// Remove if https://bugs.php.net/bug.php?id=81107 is fixed
+		if (version_compare(PHP_VERSION, '8.1.0-dev', '>=')) {
+			return -1118290769066898816;
+		}
 
-        return max(PHP_INT_MIN, -9223372036854773760);
-    }
+		return max(PHP_INT_MIN, -9223372036854773760);
+	}
 }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/FactoryImmutable.php

Indentation +1 added lines, -1 removed lines

@@ -239,5 +239,5 @@
  */
 class FactoryImmutable extends Factory
 {
-    protected $className = CarbonImmutable::class;
+	protected $className = CarbonImmutable::class;
 }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/Language.php

Indentation +323 added lines, -323 removed lines

@@ -16,327 +16,327 @@
 
 class Language implements JsonSerializable
 {
-    /**
-     * @var array
-     */
-    protected static $languagesNames;
-
-    /**
-     * @var array
-     */
-    protected static $regionsNames;
-
-    /**
-     * @var string
-     */
-    protected $id;
-
-    /**
-     * @var string
-     */
-    protected $code;
-
-    /**
-     * @var string|null
-     */
-    protected $variant;
-
-    /**
-     * @var string|null
-     */
-    protected $region;
-
-    /**
-     * @var array
-     */
-    protected $names;
-
-    /**
-     * @var string
-     */
-    protected $isoName;
-
-    /**
-     * @var string
-     */
-    protected $nativeName;
-
-    public function __construct(string $id)
-    {
-        $this->id = str_replace('-', '_', $id);
-        $parts = explode('_', $this->id);
-        $this->code = $parts[0];
-
-        if (isset($parts[1])) {
-            if (!preg_match('/^[A-Z]+$/', $parts[1])) {
-                $this->variant = $parts[1];
-                $parts[1] = $parts[2] ?? null;
-            }
-            if ($parts[1]) {
-                $this->region = $parts[1];
-            }
-        }
-    }
-
-    /**
-     * Get the list of the known languages.
-     *
-     * @return array
-     */
-    public static function all()
-    {
-        if (!static::$languagesNames) {
-            static::$languagesNames = require __DIR__.'/List/languages.php';
-        }
-
-        return static::$languagesNames;
-    }
-
-    /**
-     * Get the list of the known regions.
-     *
-     * @return array
-     */
-    public static function regions()
-    {
-        if (!static::$regionsNames) {
-            static::$regionsNames = require __DIR__.'/List/regions.php';
-        }
-
-        return static::$regionsNames;
-    }
-
-    /**
-     * Get both isoName and nativeName as an array.
-     *
-     * @return array
-     */
-    public function getNames(): array
-    {
-        if (!$this->names) {
-            $this->names = static::all()[$this->code] ?? [
-                'isoName' => $this->code,
-                'nativeName' => $this->code,
-            ];
-        }
-
-        return $this->names;
-    }
-
-    /**
-     * Returns the original locale ID.
-     *
-     * @return string
-     */
-    public function getId(): string
-    {
-        return $this->id;
-    }
-
-    /**
-     * Returns the code of the locale "en"/"fr".
-     *
-     * @return string
-     */
-    public function getCode(): string
-    {
-        return $this->code;
-    }
-
-    /**
-     * Returns the variant code such as cyrl/latn.
-     *
-     * @return string|null
-     */
-    public function getVariant(): ?string
-    {
-        return $this->variant;
-    }
-
-    /**
-     * Returns the variant such as Cyrillic/Latin.
-     *
-     * @return string|null
-     */
-    public function getVariantName(): ?string
-    {
-        if ($this->variant === 'Latn') {
-            return 'Latin';
-        }
-
-        if ($this->variant === 'Cyrl') {
-            return 'Cyrillic';
-        }
-
-        return $this->variant;
-    }
-
-    /**
-     * Returns the region part of the locale.
-     *
-     * @return string|null
-     */
-    public function getRegion(): ?string
-    {
-        return $this->region;
-    }
-
-    /**
-     * Returns the region name for the current language.
-     *
-     * @return string|null
-     */
-    public function getRegionName(): ?string
-    {
-        return $this->region ? (static::regions()[$this->region] ?? $this->region) : null;
-    }
-
-    /**
-     * Returns the long ISO language name.
-     *
-     * @return string
-     */
-    public function getFullIsoName(): string
-    {
-        if (!$this->isoName) {
-            $this->isoName = $this->getNames()['isoName'];
-        }
-
-        return $this->isoName;
-    }
-
-    /**
-     * Set the ISO language name.
-     *
-     * @param string $isoName
-     */
-    public function setIsoName(string $isoName): self
-    {
-        $this->isoName = $isoName;
-
-        return $this;
-    }
-
-    /**
-     * Return the full name of the language in this language.
-     *
-     * @return string
-     */
-    public function getFullNativeName(): string
-    {
-        if (!$this->nativeName) {
-            $this->nativeName = $this->getNames()['nativeName'];
-        }
-
-        return $this->nativeName;
-    }
-
-    /**
-     * Set the name of the language in this language.
-     *
-     * @param string $nativeName
-     */
-    public function setNativeName(string $nativeName): self
-    {
-        $this->nativeName = $nativeName;
-
-        return $this;
-    }
-
-    /**
-     * Returns the short ISO language name.
-     *
-     * @return string
-     */
-    public function getIsoName(): string
-    {
-        $name = $this->getFullIsoName();
-
-        return trim(strstr($name, ',', true) ?: $name);
-    }
-
-    /**
-     * Get the short name of the language in this language.
-     *
-     * @return string
-     */
-    public function getNativeName(): string
-    {
-        $name = $this->getFullNativeName();
-
-        return trim(strstr($name, ',', true) ?: $name);
-    }
-
-    /**
-     * Get a string with short ISO name, region in parentheses if applicable, variant in parentheses if applicable.
-     *
-     * @return string
-     */
-    public function getIsoDescription()
-    {
-        $region = $this->getRegionName();
-        $variant = $this->getVariantName();
-
-        return $this->getIsoName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
-    }
-
-    /**
-     * Get a string with short native name, region in parentheses if applicable, variant in parentheses if applicable.
-     *
-     * @return string
-     */
-    public function getNativeDescription()
-    {
-        $region = $this->getRegionName();
-        $variant = $this->getVariantName();
-
-        return $this->getNativeName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
-    }
-
-    /**
-     * Get a string with long ISO name, region in parentheses if applicable, variant in parentheses if applicable.
-     *
-     * @return string
-     */
-    public function getFullIsoDescription()
-    {
-        $region = $this->getRegionName();
-        $variant = $this->getVariantName();
-
-        return $this->getFullIsoName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
-    }
-
-    /**
-     * Get a string with long native name, region in parentheses if applicable, variant in parentheses if applicable.
-     *
-     * @return string
-     */
-    public function getFullNativeDescription()
-    {
-        $region = $this->getRegionName();
-        $variant = $this->getVariantName();
-
-        return $this->getFullNativeName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
-    }
-
-    /**
-     * Returns the original locale ID.
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->getId();
-    }
-
-    /**
-     * Get a string with short ISO name, region in parentheses if applicable, variant in parentheses if applicable.
-     *
-     * @return string
-     */
-    #[ReturnTypeWillChange]
-    public function jsonSerialize()
-    {
-        return $this->getIsoDescription();
-    }
+	/**
+	 * @var array
+	 */
+	protected static $languagesNames;
+
+	/**
+	 * @var array
+	 */
+	protected static $regionsNames;
+
+	/**
+	 * @var string
+	 */
+	protected $id;
+
+	/**
+	 * @var string
+	 */
+	protected $code;
+
+	/**
+	 * @var string|null
+	 */
+	protected $variant;
+
+	/**
+	 * @var string|null
+	 */
+	protected $region;
+
+	/**
+	 * @var array
+	 */
+	protected $names;
+
+	/**
+	 * @var string
+	 */
+	protected $isoName;
+
+	/**
+	 * @var string
+	 */
+	protected $nativeName;
+
+	public function __construct(string $id)
+	{
+		$this->id = str_replace('-', '_', $id);
+		$parts = explode('_', $this->id);
+		$this->code = $parts[0];
+
+		if (isset($parts[1])) {
+			if (!preg_match('/^[A-Z]+$/', $parts[1])) {
+				$this->variant = $parts[1];
+				$parts[1] = $parts[2] ?? null;
+			}
+			if ($parts[1]) {
+				$this->region = $parts[1];
+			}
+		}
+	}
+
+	/**
+	 * Get the list of the known languages.
+	 *
+	 * @return array
+	 */
+	public static function all()
+	{
+		if (!static::$languagesNames) {
+			static::$languagesNames = require __DIR__.'/List/languages.php';
+		}
+
+		return static::$languagesNames;
+	}
+
+	/**
+	 * Get the list of the known regions.
+	 *
+	 * @return array
+	 */
+	public static function regions()
+	{
+		if (!static::$regionsNames) {
+			static::$regionsNames = require __DIR__.'/List/regions.php';
+		}
+
+		return static::$regionsNames;
+	}
+
+	/**
+	 * Get both isoName and nativeName as an array.
+	 *
+	 * @return array
+	 */
+	public function getNames(): array
+	{
+		if (!$this->names) {
+			$this->names = static::all()[$this->code] ?? [
+				'isoName' => $this->code,
+				'nativeName' => $this->code,
+			];
+		}
+
+		return $this->names;
+	}
+
+	/**
+	 * Returns the original locale ID.
+	 *
+	 * @return string
+	 */
+	public function getId(): string
+	{
+		return $this->id;
+	}
+
+	/**
+	 * Returns the code of the locale "en"/"fr".
+	 *
+	 * @return string
+	 */
+	public function getCode(): string
+	{
+		return $this->code;
+	}
+
+	/**
+	 * Returns the variant code such as cyrl/latn.
+	 *
+	 * @return string|null
+	 */
+	public function getVariant(): ?string
+	{
+		return $this->variant;
+	}
+
+	/**
+	 * Returns the variant such as Cyrillic/Latin.
+	 *
+	 * @return string|null
+	 */
+	public function getVariantName(): ?string
+	{
+		if ($this->variant === 'Latn') {
+			return 'Latin';
+		}
+
+		if ($this->variant === 'Cyrl') {
+			return 'Cyrillic';
+		}
+
+		return $this->variant;
+	}
+
+	/**
+	 * Returns the region part of the locale.
+	 *
+	 * @return string|null
+	 */
+	public function getRegion(): ?string
+	{
+		return $this->region;
+	}
+
+	/**
+	 * Returns the region name for the current language.
+	 *
+	 * @return string|null
+	 */
+	public function getRegionName(): ?string
+	{
+		return $this->region ? (static::regions()[$this->region] ?? $this->region) : null;
+	}
+
+	/**
+	 * Returns the long ISO language name.
+	 *
+	 * @return string
+	 */
+	public function getFullIsoName(): string
+	{
+		if (!$this->isoName) {
+			$this->isoName = $this->getNames()['isoName'];
+		}
+
+		return $this->isoName;
+	}
+
+	/**
+	 * Set the ISO language name.
+	 *
+	 * @param string $isoName
+	 */
+	public function setIsoName(string $isoName): self
+	{
+		$this->isoName = $isoName;
+
+		return $this;
+	}
+
+	/**
+	 * Return the full name of the language in this language.
+	 *
+	 * @return string
+	 */
+	public function getFullNativeName(): string
+	{
+		if (!$this->nativeName) {
+			$this->nativeName = $this->getNames()['nativeName'];
+		}
+
+		return $this->nativeName;
+	}
+
+	/**
+	 * Set the name of the language in this language.
+	 *
+	 * @param string $nativeName
+	 */
+	public function setNativeName(string $nativeName): self
+	{
+		$this->nativeName = $nativeName;
+
+		return $this;
+	}
+
+	/**
+	 * Returns the short ISO language name.
+	 *
+	 * @return string
+	 */
+	public function getIsoName(): string
+	{
+		$name = $this->getFullIsoName();
+
+		return trim(strstr($name, ',', true) ?: $name);
+	}
+
+	/**
+	 * Get the short name of the language in this language.
+	 *
+	 * @return string
+	 */
+	public function getNativeName(): string
+	{
+		$name = $this->getFullNativeName();
+
+		return trim(strstr($name, ',', true) ?: $name);
+	}
+
+	/**
+	 * Get a string with short ISO name, region in parentheses if applicable, variant in parentheses if applicable.
+	 *
+	 * @return string
+	 */
+	public function getIsoDescription()
+	{
+		$region = $this->getRegionName();
+		$variant = $this->getVariantName();
+
+		return $this->getIsoName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
+	}
+
+	/**
+	 * Get a string with short native name, region in parentheses if applicable, variant in parentheses if applicable.
+	 *
+	 * @return string
+	 */
+	public function getNativeDescription()
+	{
+		$region = $this->getRegionName();
+		$variant = $this->getVariantName();
+
+		return $this->getNativeName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
+	}
+
+	/**
+	 * Get a string with long ISO name, region in parentheses if applicable, variant in parentheses if applicable.
+	 *
+	 * @return string
+	 */
+	public function getFullIsoDescription()
+	{
+		$region = $this->getRegionName();
+		$variant = $this->getVariantName();
+
+		return $this->getFullIsoName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
+	}
+
+	/**
+	 * Get a string with long native name, region in parentheses if applicable, variant in parentheses if applicable.
+	 *
+	 * @return string
+	 */
+	public function getFullNativeDescription()
+	{
+		$region = $this->getRegionName();
+		$variant = $this->getVariantName();
+
+		return $this->getFullNativeName().($region ? ' ('.$region.')' : '').($variant ? ' ('.$variant.')' : '');
+	}
+
+	/**
+	 * Returns the original locale ID.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->getId();
+	}
+
+	/**
+	 * Get a string with short ISO name, region in parentheses if applicable, variant in parentheses if applicable.
+	 *
+	 * @return string
+	 */
+	#[ReturnTypeWillChange]
+	public function jsonSerialize()
+	{
+		return $this->getIsoDescription();
+	}
 }

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/AbstractTranslator.php

Indentation +374 added lines, -374 removed lines

@@ -20,378 +20,378 @@
 
 abstract class AbstractTranslator extends Translation\Translator
 {
-    /**
-     * Translator singletons for each language.
-     *
-     * @var array
-     */
-    protected static $singletons = [];
-
-    /**
-     * List of custom localized messages.
-     *
-     * @var array
-     */
-    protected $messages = [];
-
-    /**
-     * List of custom directories that contain translation files.
-     *
-     * @var string[]
-     */
-    protected $directories = [];
-
-    /**
-     * Set to true while constructing.
-     *
-     * @var bool
-     */
-    protected $initializing = false;
-
-    /**
-     * List of locales aliases.
-     *
-     * @var string[]
-     */
-    protected $aliases = [
-        'me' => 'sr_Latn_ME',
-        'scr' => 'sh',
-    ];
-
-    /**
-     * Return a singleton instance of Translator.
-     *
-     * @param string|null $locale optional initial locale ("en" - english by default)
-     *
-     * @return static
-     */
-    public static function get($locale = null)
-    {
-        $locale = $locale ?: 'en';
-        $key = static::class === Translator::class ? $locale : static::class.'|'.$locale;
-
-        if (!isset(static::$singletons[$key])) {
-            static::$singletons[$key] = new static($locale);
-        }
-
-        return static::$singletons[$key];
-    }
-
-    public function __construct($locale, MessageFormatterInterface $formatter = null, $cacheDir = null, $debug = false)
-    {
-        parent::setLocale($locale);
-        $this->initializing = true;
-        $this->directories = [__DIR__.'/Lang'];
-        $this->addLoader('array', new ArrayLoader());
-        parent::__construct($locale, $formatter, $cacheDir, $debug);
-        $this->initializing = false;
-    }
-
-    /**
-     * Returns the list of directories translation files are searched in.
-     *
-     * @return array
-     */
-    public function getDirectories(): array
-    {
-        return $this->directories;
-    }
-
-    /**
-     * Set list of directories translation files are searched in.
-     *
-     * @param array $directories new directories list
-     *
-     * @return $this
-     */
-    public function setDirectories(array $directories)
-    {
-        $this->directories = $directories;
-
-        return $this;
-    }
-
-    /**
-     * Add a directory to the list translation files are searched in.
-     *
-     * @param string $directory new directory
-     *
-     * @return $this
-     */
-    public function addDirectory(string $directory)
-    {
-        $this->directories[] = $directory;
-
-        return $this;
-    }
-
-    /**
-     * Remove a directory from the list translation files are searched in.
-     *
-     * @param string $directory directory path
-     *
-     * @return $this
-     */
-    public function removeDirectory(string $directory)
-    {
-        $search = rtrim(strtr($directory, '\\', '/'), '/');
-
-        return $this->setDirectories(array_filter($this->getDirectories(), function ($item) use ($search) {
-            return rtrim(strtr($item, '\\', '/'), '/') !== $search;
-        }));
-    }
-
-    /**
-     * Reset messages of a locale (all locale if no locale passed).
-     * Remove custom messages and reload initial messages from matching
-     * file in Lang directory.
-     *
-     * @param string|null $locale
-     *
-     * @return bool
-     */
-    public function resetMessages($locale = null)
-    {
-        if ($locale === null) {
-            $this->messages = [];
-
-            return true;
-        }
-
-        foreach ($this->getDirectories() as $directory) {
-            $data = @include sprintf('%s/%s.php', rtrim($directory, '\\/'), $locale);
-
-            if ($data !== false) {
-                $this->messages[$locale] = $data;
-                $this->addResource('array', $this->messages[$locale], $locale);
-
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Returns the list of files matching a given locale prefix (or all if empty).
-     *
-     * @param string $prefix prefix required to filter result
-     *
-     * @return array
-     */
-    public function getLocalesFiles($prefix = '')
-    {
-        $files = [];
-
-        foreach ($this->getDirectories() as $directory) {
-            $directory = rtrim($directory, '\\/');
-
-            foreach (glob("$directory/$prefix*.php") as $file) {
-                $files[] = $file;
-            }
-        }
-
-        return array_unique($files);
-    }
-
-    /**
-     * Returns the list of internally available locales and already loaded custom locales.
-     * (It will ignore custom translator dynamic loading.)
-     *
-     * @param string $prefix prefix required to filter result
-     *
-     * @return array
-     */
-    public function getAvailableLocales($prefix = '')
-    {
-        $locales = [];
-        foreach ($this->getLocalesFiles($prefix) as $file) {
-            $locales[] = substr($file, strrpos($file, '/') + 1, -4);
-        }
-
-        return array_unique(array_merge($locales, array_keys($this->messages)));
-    }
-
-    protected function translate(?string $id, array $parameters = [], ?string $domain = null, ?string $locale = null): string
-    {
-        if ($domain === null) {
-            $domain = 'messages';
-        }
-
-        $catalogue = $this->getCatalogue($locale);
-        $format = $this instanceof TranslatorStrongTypeInterface
-            ? $this->getFromCatalogue($catalogue, (string) $id, $domain)
-            : $this->getCatalogue($locale)->get((string) $id, $domain); // @codeCoverageIgnore
-
-        if ($format instanceof Closure) {
-            // @codeCoverageIgnoreStart
-            try {
-                $count = (new ReflectionFunction($format))->getNumberOfRequiredParameters();
-            } catch (ReflectionException $exception) {
-                $count = 0;
-            }
-            // @codeCoverageIgnoreEnd
-
-            return $format(
-                ...array_values($parameters),
-                ...array_fill(0, max(0, $count - \count($parameters)), null)
-            );
-        }
-
-        return parent::trans($id, $parameters, $domain, $locale);
-    }
-
-    /**
-     * Init messages language from matching file in Lang directory.
-     *
-     * @param string $locale
-     *
-     * @return bool
-     */
-    protected function loadMessagesFromFile($locale)
-    {
-        return isset($this->messages[$locale]) || $this->resetMessages($locale);
-    }
-
-    /**
-     * Set messages of a locale and take file first if present.
-     *
-     * @param string $locale
-     * @param array  $messages
-     *
-     * @return $this
-     */
-    public function setMessages($locale, $messages)
-    {
-        $this->loadMessagesFromFile($locale);
-        $this->addResource('array', $messages, $locale);
-        $this->messages[$locale] = array_merge(
-            $this->messages[$locale] ?? [],
-            $messages
-        );
-
-        return $this;
-    }
-
-    /**
-     * Set messages of the current locale and take file first if present.
-     *
-     * @param array $messages
-     *
-     * @return $this
-     */
-    public function setTranslations($messages)
-    {
-        return $this->setMessages($this->getLocale(), $messages);
-    }
-
-    /**
-     * Get messages of a locale, if none given, return all the
-     * languages.
-     *
-     * @param string|null $locale
-     *
-     * @return array
-     */
-    public function getMessages($locale = null)
-    {
-        return $locale === null ? $this->messages : $this->messages[$locale];
-    }
-
-    /**
-     * Set the current translator locale and indicate if the source locale file exists
-     *
-     * @param string $locale locale ex. en
-     *
-     * @return bool
-     */
-    public function setLocale($locale)
-    {
-        $locale = preg_replace_callback('/[-_]([a-z]{2,}|\d{2,})/', function ($matches) {
-            // _2-letters or YUE is a region, _3+-letters is a variant
-            $upper = strtoupper($matches[1]);
-
-            if ($upper === 'YUE' || $upper === 'ISO' || \strlen($upper) < 3) {
-                return "_$upper";
-            }
-
-            return '_'.ucfirst($matches[1]);
-        }, strtolower($locale));
-
-        $previousLocale = $this->getLocale();
-
-        if ($previousLocale === $locale && isset($this->messages[$locale])) {
-            return true;
-        }
-
-        unset(static::$singletons[$previousLocale]);
-
-        if ($locale === 'auto') {
-            $completeLocale = setlocale(LC_TIME, '0');
-            $locale = preg_replace('/^([^_.-]+).*$/', '$1', $completeLocale);
-            $locales = $this->getAvailableLocales($locale);
-
-            $completeLocaleChunks = preg_split('/[_.-]+/', $completeLocale);
-
-            $getScore = function ($language) use ($completeLocaleChunks) {
-                return self::compareChunkLists($completeLocaleChunks, preg_split('/[_.-]+/', $language));
-            };
-
-            usort($locales, function ($first, $second) use ($getScore) {
-                return $getScore($second) <=> $getScore($first);
-            });
-
-            $locale = $locales[0];
-        }
-
-        if (isset($this->aliases[$locale])) {
-            $locale = $this->aliases[$locale];
-        }
-
-        // If subtag (ex: en_CA) first load the macro (ex: en) to have a fallback
-        if (str_contains($locale, '_') &&
-            $this->loadMessagesFromFile($macroLocale = preg_replace('/^([^_]+).*$/', '$1', $locale))
-        ) {
-            parent::setLocale($macroLocale);
-        }
-
-        if (!$this->loadMessagesFromFile($locale) && !$this->initializing) {
-            return false;
-        }
-
-        parent::setLocale($locale);
-
-        return true;
-    }
-
-    /**
-     * Show locale on var_dump().
-     *
-     * @return array
-     */
-    public function __debugInfo()
-    {
-        return [
-            'locale' => $this->getLocale(),
-        ];
-    }
-
-    private static function compareChunkLists($referenceChunks, $chunks)
-    {
-        $score = 0;
-
-        foreach ($referenceChunks as $index => $chunk) {
-            if (!isset($chunks[$index])) {
-                $score++;
-
-                continue;
-            }
-
-            if (strtolower($chunks[$index]) === strtolower($chunk)) {
-                $score += 10;
-            }
-        }
-
-        return $score;
-    }
+	/**
+	 * Translator singletons for each language.
+	 *
+	 * @var array
+	 */
+	protected static $singletons = [];
+
+	/**
+	 * List of custom localized messages.
+	 *
+	 * @var array
+	 */
+	protected $messages = [];
+
+	/**
+	 * List of custom directories that contain translation files.
+	 *
+	 * @var string[]
+	 */
+	protected $directories = [];
+
+	/**
+	 * Set to true while constructing.
+	 *
+	 * @var bool
+	 */
+	protected $initializing = false;
+
+	/**
+	 * List of locales aliases.
+	 *
+	 * @var string[]
+	 */
+	protected $aliases = [
+		'me' => 'sr_Latn_ME',
+		'scr' => 'sh',
+	];
+
+	/**
+	 * Return a singleton instance of Translator.
+	 *
+	 * @param string|null $locale optional initial locale ("en" - english by default)
+	 *
+	 * @return static
+	 */
+	public static function get($locale = null)
+	{
+		$locale = $locale ?: 'en';
+		$key = static::class === Translator::class ? $locale : static::class.'|'.$locale;
+
+		if (!isset(static::$singletons[$key])) {
+			static::$singletons[$key] = new static($locale);
+		}
+
+		return static::$singletons[$key];
+	}
+
+	public function __construct($locale, MessageFormatterInterface $formatter = null, $cacheDir = null, $debug = false)
+	{
+		parent::setLocale($locale);
+		$this->initializing = true;
+		$this->directories = [__DIR__.'/Lang'];
+		$this->addLoader('array', new ArrayLoader());
+		parent::__construct($locale, $formatter, $cacheDir, $debug);
+		$this->initializing = false;
+	}
+
+	/**
+	 * Returns the list of directories translation files are searched in.
+	 *
+	 * @return array
+	 */
+	public function getDirectories(): array
+	{
+		return $this->directories;
+	}
+
+	/**
+	 * Set list of directories translation files are searched in.
+	 *
+	 * @param array $directories new directories list
+	 *
+	 * @return $this
+	 */
+	public function setDirectories(array $directories)
+	{
+		$this->directories = $directories;
+
+		return $this;
+	}
+
+	/**
+	 * Add a directory to the list translation files are searched in.
+	 *
+	 * @param string $directory new directory
+	 *
+	 * @return $this
+	 */
+	public function addDirectory(string $directory)
+	{
+		$this->directories[] = $directory;
+
+		return $this;
+	}
+
+	/**
+	 * Remove a directory from the list translation files are searched in.
+	 *
+	 * @param string $directory directory path
+	 *
+	 * @return $this
+	 */
+	public function removeDirectory(string $directory)
+	{
+		$search = rtrim(strtr($directory, '\\', '/'), '/');
+
+		return $this->setDirectories(array_filter($this->getDirectories(), function ($item) use ($search) {
+			return rtrim(strtr($item, '\\', '/'), '/') !== $search;
+		}));
+	}
+
+	/**
+	 * Reset messages of a locale (all locale if no locale passed).
+	 * Remove custom messages and reload initial messages from matching
+	 * file in Lang directory.
+	 *
+	 * @param string|null $locale
+	 *
+	 * @return bool
+	 */
+	public function resetMessages($locale = null)
+	{
+		if ($locale === null) {
+			$this->messages = [];
+
+			return true;
+		}
+
+		foreach ($this->getDirectories() as $directory) {
+			$data = @include sprintf('%s/%s.php', rtrim($directory, '\\/'), $locale);
+
+			if ($data !== false) {
+				$this->messages[$locale] = $data;
+				$this->addResource('array', $this->messages[$locale], $locale);
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns the list of files matching a given locale prefix (or all if empty).
+	 *
+	 * @param string $prefix prefix required to filter result
+	 *
+	 * @return array
+	 */
+	public function getLocalesFiles($prefix = '')
+	{
+		$files = [];
+
+		foreach ($this->getDirectories() as $directory) {
+			$directory = rtrim($directory, '\\/');
+
+			foreach (glob("$directory/$prefix*.php") as $file) {
+				$files[] = $file;
+			}
+		}
+
+		return array_unique($files);
+	}
+
+	/**
+	 * Returns the list of internally available locales and already loaded custom locales.
+	 * (It will ignore custom translator dynamic loading.)
+	 *
+	 * @param string $prefix prefix required to filter result
+	 *
+	 * @return array
+	 */
+	public function getAvailableLocales($prefix = '')
+	{
+		$locales = [];
+		foreach ($this->getLocalesFiles($prefix) as $file) {
+			$locales[] = substr($file, strrpos($file, '/') + 1, -4);
+		}
+
+		return array_unique(array_merge($locales, array_keys($this->messages)));
+	}
+
+	protected function translate(?string $id, array $parameters = [], ?string $domain = null, ?string $locale = null): string
+	{
+		if ($domain === null) {
+			$domain = 'messages';
+		}
+
+		$catalogue = $this->getCatalogue($locale);
+		$format = $this instanceof TranslatorStrongTypeInterface
+			? $this->getFromCatalogue($catalogue, (string) $id, $domain)
+			: $this->getCatalogue($locale)->get((string) $id, $domain); // @codeCoverageIgnore
+
+		if ($format instanceof Closure) {
+			// @codeCoverageIgnoreStart
+			try {
+				$count = (new ReflectionFunction($format))->getNumberOfRequiredParameters();
+			} catch (ReflectionException $exception) {
+				$count = 0;
+			}
+			// @codeCoverageIgnoreEnd
+
+			return $format(
+				...array_values($parameters),
+				...array_fill(0, max(0, $count - \count($parameters)), null)
+			);
+		}
+
+		return parent::trans($id, $parameters, $domain, $locale);
+	}
+
+	/**
+	 * Init messages language from matching file in Lang directory.
+	 *
+	 * @param string $locale
+	 *
+	 * @return bool
+	 */
+	protected function loadMessagesFromFile($locale)
+	{
+		return isset($this->messages[$locale]) || $this->resetMessages($locale);
+	}
+
+	/**
+	 * Set messages of a locale and take file first if present.
+	 *
+	 * @param string $locale
+	 * @param array  $messages
+	 *
+	 * @return $this
+	 */
+	public function setMessages($locale, $messages)
+	{
+		$this->loadMessagesFromFile($locale);
+		$this->addResource('array', $messages, $locale);
+		$this->messages[$locale] = array_merge(
+			$this->messages[$locale] ?? [],
+			$messages
+		);
+
+		return $this;
+	}
+
+	/**
+	 * Set messages of the current locale and take file first if present.
+	 *
+	 * @param array $messages
+	 *
+	 * @return $this
+	 */
+	public function setTranslations($messages)
+	{
+		return $this->setMessages($this->getLocale(), $messages);
+	}
+
+	/**
+	 * Get messages of a locale, if none given, return all the
+	 * languages.
+	 *
+	 * @param string|null $locale
+	 *
+	 * @return array
+	 */
+	public function getMessages($locale = null)
+	{
+		return $locale === null ? $this->messages : $this->messages[$locale];
+	}
+
+	/**
+	 * Set the current translator locale and indicate if the source locale file exists
+	 *
+	 * @param string $locale locale ex. en
+	 *
+	 * @return bool
+	 */
+	public function setLocale($locale)
+	{
+		$locale = preg_replace_callback('/[-_]([a-z]{2,}|\d{2,})/', function ($matches) {
+			// _2-letters or YUE is a region, _3+-letters is a variant
+			$upper = strtoupper($matches[1]);
+
+			if ($upper === 'YUE' || $upper === 'ISO' || \strlen($upper) < 3) {
+				return "_$upper";
+			}
+
+			return '_'.ucfirst($matches[1]);
+		}, strtolower($locale));
+
+		$previousLocale = $this->getLocale();
+
+		if ($previousLocale === $locale && isset($this->messages[$locale])) {
+			return true;
+		}
+
+		unset(static::$singletons[$previousLocale]);
+
+		if ($locale === 'auto') {
+			$completeLocale = setlocale(LC_TIME, '0');
+			$locale = preg_replace('/^([^_.-]+).*$/', '$1', $completeLocale);
+			$locales = $this->getAvailableLocales($locale);
+
+			$completeLocaleChunks = preg_split('/[_.-]+/', $completeLocale);
+
+			$getScore = function ($language) use ($completeLocaleChunks) {
+				return self::compareChunkLists($completeLocaleChunks, preg_split('/[_.-]+/', $language));
+			};
+
+			usort($locales, function ($first, $second) use ($getScore) {
+				return $getScore($second) <=> $getScore($first);
+			});
+
+			$locale = $locales[0];
+		}
+
+		if (isset($this->aliases[$locale])) {
+			$locale = $this->aliases[$locale];
+		}
+
+		// If subtag (ex: en_CA) first load the macro (ex: en) to have a fallback
+		if (str_contains($locale, '_') &&
+			$this->loadMessagesFromFile($macroLocale = preg_replace('/^([^_]+).*$/', '$1', $locale))
+		) {
+			parent::setLocale($macroLocale);
+		}
+
+		if (!$this->loadMessagesFromFile($locale) && !$this->initializing) {
+			return false;
+		}
+
+		parent::setLocale($locale);
+
+		return true;
+	}
+
+	/**
+	 * Show locale on var_dump().
+	 *
+	 * @return array
+	 */
+	public function __debugInfo()
+	{
+		return [
+			'locale' => $this->getLocale(),
+		];
+	}
+
+	private static function compareChunkLists($referenceChunks, $chunks)
+	{
+		$score = 0;
+
+		foreach ($referenceChunks as $index => $chunk) {
+			if (!isset($chunks[$index])) {
+				$score++;
+
+				continue;
+			}
+
+			if (strtolower($chunks[$index]) === strtolower($chunk)) {
+				$score += 10;
+			}
+		}
+
+		return $score;
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -136,7 +136,7 @@ 
     {
         $search = rtrim(strtr($directory, '\\', '/'), '/');
 
-        return $this->setDirectories(array_filter($this->getDirectories(), function ($item) use ($search) {
+        return $this->setDirectories(array_filter($this->getDirectories(), function($item) use ($search) {
             return rtrim(strtr($item, '\\', '/'), '/') !== $search;
         }));
     }
@@ -307,7 +307,7 @@ 
      */
     public function setLocale($locale)
     {
-        $locale = preg_replace_callback('/[-_]([a-z]{2,}|\d{2,})/', function ($matches) {
+        $locale = preg_replace_callback('/[-_]([a-z]{2,}|\d{2,})/', function($matches) {
             // _2-letters or YUE is a region, _3+-letters is a variant
             $upper = strtoupper($matches[1]);
 
@@ -333,11 +333,11 @@ 
 
             $completeLocaleChunks = preg_split('/[_.-]+/', $completeLocale);
 
-            $getScore = function ($language) use ($completeLocaleChunks) {
+            $getScore = function($language) use ($completeLocaleChunks) {
                 return self::compareChunkLists($completeLocaleChunks, preg_split('/[_.-]+/', $language));
             };
 
-            usort($locales, function ($first, $second) use ($getScore) {
+            usort($locales, function($first, $second) use ($getScore) {
                 return $getScore($second) <=> $getScore($first);
             });
 

htdocs/includes/webklex/php-imap/vendor/nesbot/carbon/src/Carbon/Carbon.php

Indentation +10 added lines, -10 removed lines

@@ -509,15 +509,15 @@
  */
 class Carbon extends DateTime implements CarbonInterface
 {
-    use Date;
+	use Date;
 
-    /**
-     * Returns true if the current class/instance is mutable.
-     *
-     * @return bool
-     */
-    public static function isMutable()
-    {
-        return true;
-    }
+	/**
+	 * Returns true if the current class/instance is mutable.
+	 *
+	 * @return bool
+	 */
+	public static function isMutable()
+	{
+		return true;
+	}
 }