@averay/codeformat 0.2.1 → 0.2.2

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/NoMultipleStatementsPerLineFixer.php

@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\Fixer\Indentation;
+use PhpCsFixer\Fixer\WhitespacesAwareFixerInterface;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * Fixer for rules defined in PSR2 ¶2.3 Lines: There must not be more than one statement per line.
+ */
+final class NoMultipleStatementsPerLineFixer extends AbstractFixer implements WhitespacesAwareFixerInterface
+{
+    use Indentation;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'There must not be more than one statement per line.',
+            [new CodeSample("<?php\nfoo(); bar();\n")]
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before BracesPositionFixer, CurlyBracesPositionFixer.
+     * Must run after ControlStructureBracesFixer, NoEmptyStatementFixer, YieldFromArrayToYieldsFixer.
+     */
+    public function getPriority(): int
+    {
+        return -1;
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isTokenKindFound(';');
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        for ($index = 1, $max = \count($tokens) - 1; $index < $max; ++$index) {
+            if ($tokens[$index]->isGivenKind(T_FOR)) {
+                $index = $tokens->findBlockEnd(
+                    Tokens::BLOCK_TYPE_PARENTHESIS_BRACE,
+                    $tokens->getNextTokenOfKind($index, ['('])
+                );
+
+                continue;
+            }
+
+            if ($tokens[$index]->isGivenKind(CT::T_PROPERTY_HOOK_BRACE_OPEN)) {
+                $index = $tokens->findBlockEnd(
+                    Tokens::BLOCK_TYPE_PROPERTY_HOOK,
+                    $index
+                );
+
+                continue;
+            }
+
+            if (!$tokens[$index]->equals(';')) {
+                continue;
+            }
+
+            for ($nextIndex = $index + 1; $nextIndex < $max; ++$nextIndex) {
+                $token = $tokens[$nextIndex];
+
+                if ($token->isWhitespace() || $token->isComment()) {
+                    if (Preg::match('/\R/', $token->getContent())) {
+                        break;
+                    }
+
+                    continue;
+                }
+
+                if (!$token->equalsAny(['}', [T_CLOSE_TAG], [T_ENDIF], [T_ENDFOR], [T_ENDSWITCH], [T_ENDWHILE], [T_ENDFOREACH]])) {
+                    $whitespaceIndex = $index;
+                    do {
+                        $token = $tokens[++$whitespaceIndex];
+                    } while ($token->isComment());
+
+                    $newline = $this->whitespacesConfig->getLineEnding().$this->getLineIndentation($tokens, $index);
+
+                    if ($tokens->ensureWhitespaceAtIndex($whitespaceIndex, 0, $newline)) {
+                        ++$max;
+                    }
+                }
+
+                break;
+            }
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/NoTrailingCommaInSinglelineFixer.php

@@ -0,0 +1,162 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\FixerConfiguration\AllowedValueSubset;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Analyzer\AttributeAnalyzer;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  elements?: list<'arguments'|'array'|'array_destructuring'|'group_import'>,
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  elements: list<'arguments'|'array'|'array_destructuring'|'group_import'>,
+ * }
+ */
+final class NoTrailingCommaInSinglelineFixer extends AbstractFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'If a list of values separated by a comma is contained on a single line, then the last item MUST NOT have a trailing comma.',
+            [
+                new CodeSample("<?php\nfoo(\$a,);\n\$foo = array(1,);\n[\$foo, \$bar,] = \$array;\nuse a\\{ClassA, ClassB,};\n"),
+                new CodeSample("<?php\nfoo(\$a,);\n[\$foo, \$bar,] = \$array;\n", ['elements' => ['array_destructuring']]),
+            ]
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return
+            $tokens->isTokenKindFound(',')
+            && $tokens->isAnyTokenKindsFound([')', CT::T_ARRAY_SQUARE_BRACE_CLOSE, CT::T_DESTRUCTURING_SQUARE_BRACE_CLOSE, CT::T_GROUP_IMPORT_BRACE_CLOSE]);
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        $elements = ['arguments', 'array', 'array_destructuring', 'group_import'];
+
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('elements', 'Which elements to fix.'))
+                ->setAllowedTypes(['string[]'])
+                ->setAllowedValues([new AllowedValueSubset($elements)])
+                ->setDefault($elements)
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        for ($index = $tokens->count() - 1; $index >= 0; --$index) {
+            if (!$tokens[$index]->equals(')') && !$tokens[$index]->isGivenKind([CT::T_ARRAY_SQUARE_BRACE_CLOSE, CT::T_DESTRUCTURING_SQUARE_BRACE_CLOSE, CT::T_GROUP_IMPORT_BRACE_CLOSE])) {
+                continue;
+            }
+
+            $commaIndex = $tokens->getPrevMeaningfulToken($index);
+
+            if (!$tokens[$commaIndex]->equals(',')) {
+                continue;
+            }
+
+            $block = Tokens::detectBlockType($tokens[$index]);
+            $blockOpenIndex = $tokens->findBlockStart($block['type'], $index);
+
+            if ($tokens->isPartialCodeMultiline($blockOpenIndex, $index)) {
+                continue;
+            }
+
+            if (!$this->shouldBeCleared($tokens, $blockOpenIndex)) {
+                continue;
+            }
+
+            do {
+                $tokens->clearTokenAndMergeSurroundingWhitespace($commaIndex);
+                $commaIndex = $tokens->getPrevMeaningfulToken($commaIndex);
+            } while ($tokens[$commaIndex]->equals(','));
+
+            $tokens->removeTrailingWhitespace($commaIndex);
+        }
+    }
+
+    private function shouldBeCleared(Tokens $tokens, int $openIndex): bool
+    {
+        $elements = $this->configuration['elements'];
+
+        if ($tokens[$openIndex]->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_OPEN)) {
+            return \in_array('array', $elements, true);
+        }
+
+        if ($tokens[$openIndex]->isGivenKind(CT::T_DESTRUCTURING_SQUARE_BRACE_OPEN)) {
+            return \in_array('array_destructuring', $elements, true);
+        }
+
+        if ($tokens[$openIndex]->isGivenKind(CT::T_GROUP_IMPORT_BRACE_OPEN)) {
+            return \in_array('group_import', $elements, true);
+        }
+
+        if (!$tokens[$openIndex]->equals('(')) {
+            return false;
+        }
+
+        $beforeOpen = $tokens->getPrevMeaningfulToken($openIndex);
+
+        if ($tokens[$beforeOpen]->isGivenKind(T_ARRAY)) {
+            return \in_array('array', $elements, true);
+        }
+
+        if ($tokens[$beforeOpen]->isGivenKind(T_LIST)) {
+            return \in_array('array_destructuring', $elements, true);
+        }
+
+        if ($tokens[$beforeOpen]->isGivenKind([T_UNSET, T_ISSET, T_VARIABLE, T_CLASS])) {
+            return \in_array('arguments', $elements, true);
+        }
+
+        if ($tokens[$beforeOpen]->isGivenKind(T_STRING)) {
+            return !AttributeAnalyzer::isAttribute($tokens, $beforeOpen) && \in_array('arguments', $elements, true);
+        }
+
+        if ($tokens[$beforeOpen]->equalsAny([')', ']', [CT::T_DYNAMIC_VAR_BRACE_CLOSE], [CT::T_ARRAY_INDEX_CURLY_BRACE_CLOSE]])) {
+            $block = Tokens::detectBlockType($tokens[$beforeOpen]);
+
+            return
+                (
+                    Tokens::BLOCK_TYPE_ARRAY_INDEX_CURLY_BRACE === $block['type']
+                    || Tokens::BLOCK_TYPE_DYNAMIC_VAR_BRACE === $block['type']
+                    || Tokens::BLOCK_TYPE_INDEX_SQUARE_BRACE === $block['type']
+                    || Tokens::BLOCK_TYPE_PARENTHESIS_BRACE === $block['type']
+                ) && \in_array('arguments', $elements, true);
+        }
+
+        return false;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/NonPrintableCharacterFixer.php

@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * Removes Zero-width space (ZWSP), Non-breaking space (NBSP) and other invisible unicode symbols.
+ *
+ * @author Ivan Boprzenkov <ivan.borzenkov@gmail.com>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  use_escape_sequences_in_strings?: bool,
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  use_escape_sequences_in_strings: bool,
+ * }
+ */
+final class NonPrintableCharacterFixer extends AbstractFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    /**
+     * @var list<int>
+     */
+    private const TOKENS = [
+        T_STRING_VARNAME,
+        T_INLINE_HTML,
+        T_VARIABLE,
+        T_COMMENT,
+        T_ENCAPSED_AND_WHITESPACE,
+        T_CONSTANT_ENCAPSED_STRING,
+        T_DOC_COMMENT,
+    ];
+
+    /**
+     * @var array<string, array{string, string}>
+     */
+    private array $symbolsReplace;
+
+    public function __construct()
+    {
+        parent::__construct();
+
+        $this->symbolsReplace = [
+            pack('H*', 'e2808b') => ['', '200b'], // ZWSP U+200B
+            pack('H*', 'e28087') => [' ', '2007'], // FIGURE SPACE U+2007
+            pack('H*', 'e280af') => [' ', '202f'], // NBSP U+202F
+            pack('H*', 'e281a0') => ['', '2060'], // WORD JOINER U+2060
+            pack('H*', 'c2a0') => [' ', 'a0'], // NO-BREAK SPACE U+A0
+        ];
+    }
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Remove Zero-width space (ZWSP), Non-breaking space (NBSP) and other invisible unicode symbols.',
+            [
+                new CodeSample(
+                    '<?php echo "'.pack('H*', 'e2808b').'Hello'.pack('H*', 'e28087').'World'.pack('H*', 'c2a0')."!\";\n"
+                ),
+                new CodeSample(
+                    '<?php echo "'.pack('H*', 'e2808b').'Hello'.pack('H*', 'e28087').'World'.pack('H*', 'c2a0')."!\";\n",
+                    ['use_escape_sequences_in_strings' => false]
+                ),
+            ],
+            null,
+            'Risky when strings contain intended invisible characters.'
+        );
+    }
+
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isAnyTokenKindsFound(self::TOKENS);
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('use_escape_sequences_in_strings', 'Whether characters should be replaced with escape sequences in strings.'))
+                ->setAllowedTypes(['bool'])
+                ->setDefault(true)
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $replacements = [];
+        $escapeSequences = [];
+
+        foreach ($this->symbolsReplace as $character => [$replacement, $codepoint]) {
+            $replacements[$character] = $replacement;
+            $escapeSequences[$character] = '\u{'.$codepoint.'}';
+        }
+
+        foreach ($tokens as $index => $token) {
+            $content = $token->getContent();
+
+            if (
+                true === $this->configuration['use_escape_sequences_in_strings']
+                && $token->isGivenKind([T_CONSTANT_ENCAPSED_STRING, T_ENCAPSED_AND_WHITESPACE])
+            ) {
+                if (!Preg::match('/'.implode('|', array_keys($escapeSequences)).'/', $content)) {
+                    continue;
+                }
+
+                $previousToken = $tokens[$index - 1];
+                $stringTypeChanged = false;
+                $swapQuotes = false;
+
+                if ($previousToken->isGivenKind(T_START_HEREDOC)) {
+                    $previousTokenContent = $previousToken->getContent();
+
+                    if (str_contains($previousTokenContent, '\'')) {
+                        $tokens[$index - 1] = new Token([T_START_HEREDOC, str_replace('\'', '', $previousTokenContent)]);
+                        $stringTypeChanged = true;
+                    }
+                } elseif (str_starts_with($content, "'")) {
+                    $stringTypeChanged = true;
+                    $swapQuotes = true;
+                }
+
+                if ($swapQuotes) {
+                    $content = str_replace("\\'", "'", $content);
+                }
+
+                if ($stringTypeChanged) {
+                    $content = Preg::replace('/(\\\{1,2})/', '\\\\\\\\', $content);
+                    $content = str_replace('$', '\$', $content);
+                }
+
+                if ($swapQuotes) {
+                    $content = str_replace('"', '\"', $content);
+                    $content = Preg::replace('/^\'(.*)\'$/s', '"$1"', $content);
+                }
+
+                $tokens[$index] = new Token([$token->getId(), strtr($content, $escapeSequences)]);
+
+                continue;
+            }
+
+            if ($token->isGivenKind(self::TOKENS)) {
+                $newContent = strtr($content, $replacements);
+
+                // variable name cannot contain space
+                if ($token->isGivenKind([T_STRING_VARNAME, T_VARIABLE]) && str_contains($newContent, ' ')) {
+                    continue;
+                }
+
+                // multiline comment must have "*/" only at the end
+                if ($token->isGivenKind([T_COMMENT, T_DOC_COMMENT]) && str_starts_with($newContent, '/*') && strpos($newContent, '*/') !== \strlen($newContent) - 2) {
+                    continue;
+                }
+
+                $tokens[$index] = new Token([$token->getId(), $newContent]);
+            }
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/NumericLiteralSeparatorFixer.php

@@ -0,0 +1,232 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * Let's you add underscores to numeric literals.
+ *
+ * Inspired by:
+ * - {@link https://github.com/kubawerlos/php-cs-fixer-custom-fixers/blob/main/src/Fixer/NumericLiteralSeparatorFixer.php}
+ * - {@link https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/rules/numeric-separators-style.js}
+ *
+ * @author Marvin Heilemann <marvin.heilemann+github@googlemail.com>
+ * @author Greg Korba <greg@codito.dev>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  override_existing?: bool,
+ *  strategy?: 'no_separator'|'use_separator',
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  override_existing: bool,
+ *  strategy: 'no_separator'|'use_separator',
+ * }
+ */
+final class NumericLiteralSeparatorFixer extends AbstractFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    public const STRATEGY_USE_SEPARATOR = 'use_separator';
+    public const STRATEGY_NO_SEPARATOR = 'no_separator';
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Adds separators to numeric literals of any kind.',
+            [
+                new CodeSample(
+                    <<<'PHP'
+                        <?php
+                        $integer = 1234567890;
+
+                        PHP
+                    ,
+                ),
+                new CodeSample(
+                    <<<'PHP'
+                        <?php
+                        $integer = 1234_5678;
+                        $octal = 01_234_56;
+                        $binary = 0b00_10_01_00;
+                        $hexadecimal = 0x3D45_8F4F;
+
+                        PHP
+                    ,
+                    ['strategy' => self::STRATEGY_NO_SEPARATOR],
+                ),
+                new CodeSample(
+                    <<<'PHP'
+                        <?php
+                        $integer = 12345678;
+                        $octal = 0123456;
+                        $binary = 0b0010010011011010;
+                        $hexadecimal = 0x3D458F4F;
+
+                        PHP
+                    ,
+                    ['strategy' => self::STRATEGY_USE_SEPARATOR],
+                ),
+                new CodeSample(
+                    "<?php \$var = 24_40_21;\n",
+                    ['override_existing' => true]
+                ),
+            ]
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isAnyTokenKindsFound([T_DNUMBER, T_LNUMBER]);
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder(
+                'override_existing',
+                'Whether literals already containing underscores should be reformatted.'
+            ))
+                ->setAllowedTypes(['bool'])
+                ->setDefault(false)
+                ->getOption(),
+            (new FixerOptionBuilder(
+                'strategy',
+                'Whether numeric literal should be separated by underscores or not.'
+            ))
+                ->setAllowedValues([self::STRATEGY_USE_SEPARATOR, self::STRATEGY_NO_SEPARATOR])
+                ->setDefault(self::STRATEGY_USE_SEPARATOR)
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        foreach ($tokens as $index => $token) {
+            if (!$token->isGivenKind([T_DNUMBER, T_LNUMBER])) {
+                continue;
+            }
+
+            $content = $token->getContent();
+
+            $newContent = $this->formatValue($content);
+
+            if ($content === $newContent) {
+                // Skip Token override if its the same content, like when it
+                // already got a valid literal separator structure.
+                continue;
+            }
+
+            $tokens[$index] = new Token([$token->getId(), $newContent]);
+        }
+    }
+
+    private function formatValue(string $value): string
+    {
+        if (self::STRATEGY_NO_SEPARATOR === $this->configuration['strategy']) {
+            return str_contains($value, '_') ? str_replace('_', '', $value) : $value;
+        }
+
+        if (true === $this->configuration['override_existing']) {
+            $value = str_replace('_', '', $value);
+        } elseif (str_contains($value, '_')) {
+            // Keep already underscored literals untouched.
+            return $value;
+        }
+
+        $lowerValue = strtolower($value);
+
+        if (str_starts_with($lowerValue, '0b')) {
+            // Binary
+            return $this->insertEveryRight($value, 8, 2);
+        }
+
+        if (str_starts_with($lowerValue, '0x')) {
+            // Hexadecimal
+            return $this->insertEveryRight($value, 2, 2);
+        }
+
+        if (str_starts_with($lowerValue, '0o')) {
+            // Octal
+            return $this->insertEveryRight($value, 3, 2);
+        }
+        if (str_starts_with($lowerValue, '0') && !str_contains($lowerValue, '.')) {
+            // Octal notation prior PHP 8.1 but still valid
+            return $this->insertEveryRight($value, 3, 1);
+        }
+
+        // All other types
+
+        /** If its a negative value we need an offset */
+        $negativeOffset = static fn ($v) => str_contains($v, '-') ? 1 : 0;
+
+        Preg::matchAll('/([0-9-_]+)?((\.)([0-9_]*))?((e)([0-9-_]+))?/i', $value, $result);
+
+        $integer = $result[1][0];
+        $joinedValue = $this->insertEveryRight($integer, 3, $negativeOffset($integer));
+
+        $dot = $result[3][0];
+        if ('' !== $dot) {
+            $integer = $result[4][0];
+            $decimal = $this->insertEveryLeft($integer, 3, $negativeOffset($integer));
+            $joinedValue = $joinedValue.$dot.$decimal;
+        }
+
+        $tim = $result[6][0];
+        if ('' !== $tim) {
+            $integer = $result[7][0];
+            $times = $this->insertEveryRight($integer, 3, $negativeOffset($integer));
+            $joinedValue = $joinedValue.$tim.$times;
+        }
+
+        return $joinedValue;
+    }
+
+    private function insertEveryRight(string $value, int $length, int $offset = 0): string
+    {
+        $position = $length * -1;
+        while ($position > -(\strlen($value) - $offset)) {
+            $value = substr_replace($value, '_', $position, 0);
+            $position -= $length + 1;
+        }
+
+        return $value;
+    }
+
+    private function insertEveryLeft(string $value, int $length, int $offset = 0): string
+    {
+        $position = $length;
+        while ($position < \strlen($value)) {
+            $value = substr_replace($value, '_', $position, $offset);
+            $position += $length + 1;
+        }
+
+        return $value;
+    }
+}