Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

git clone https://repo.autonoma.ca/repo/treetrek.git

M Config.php

 <?php
 class Config {
   const SITE_TITLE = "Dave Jarvis' Repositories";
   private static function getHomeDirectory() {
     if( !empty( $_SERVER['HOME'] ) ) {
       return $_SERVER['HOME'];
+    }
     if( !empty( getenv( 'HOME' ) ) ) {
       return getenv( 'HOME' );
+    }
   public const SITE_TITLE    = "Dave Jarvis' Repositories";
   private const REPOS_SUBDIR = '/repos';
   private const LOG_FILE     = '/error.log';
     if( function_exists( 'posix_getpwuid' ) &&
         function_exists( 'posix_getuid' ) ) {
       $userInfo = posix_getpwuid( posix_getuid() );
   public function init() {
     ini_set( 'display_errors', 0 );
     ini_set( 'log_errors', 1 );
     ini_set( 'error_log', __DIR__ . self::LOG_FILE );
+  }
       if( !empty( $userInfo['dir'] ) ) {
         return $userInfo['dir'];
+      }
+    }
   public function createRouter() {
     $path = $this->getHomeDirectory() . self::REPOS_SUBDIR;
     return '';
     return new Router( $path );
+  }
   public static function getReposPath() {
     return self::getHomeDirectory() . '/repos';
+  }
   private function getHomeDirectory() {
     $home = !empty( $_SERVER['HOME'] ) ? $_SERVER['HOME'] : '';
     $home = $home === '' && !empty( getenv( 'HOME' ) )
       ? getenv( 'HOME' )
       : $home;
   public static function init() {
     ini_set( 'display_errors', 0 );
     ini_set( 'log_errors', 1 );
     ini_set( 'error_log', __DIR__ . '/error.log' );
     return
         $home === '' &&
         function_exists( 'posix_getpwuid' ) &&
         function_exists( 'posix_getuid' )
       ? (posix_getpwuid( posix_getuid() )['dir'] ?? '')
       : $home;
+  }
+}

M File.php

 class File {
   private const CAT_IMAGE = 'image';
   private const CAT_VIDEO = 'video';
   private const CAT_AUDIO = 'audio';
   private const CAT_TEXT = 'text';
   private const CAT_IMAGE   = 'image';
   private const CAT_VIDEO   = 'video';
   private const CAT_AUDIO   = 'audio';
   private const CAT_TEXT    = 'text';
   private const CAT_ARCHIVE = 'archive';
   private const CAT_BINARY = 'binary';
   private const CAT_BINARY  = 'binary';
   private const ARCHIVE_EXTENSIONS = [
   private const ICON_FOLDER  = 'fa-folder';
   private const ICON_PDF     = 'fa-file-pdf';
   private const ICON_ARCHIVE = 'fa-file-archive';
   private const ICON_IMAGE   = 'fa-file-image';
   private const ICON_AUDIO   = 'fa-file-audio';
   private const ICON_VIDEO   = 'fa-file-video';
   private const ICON_CODE    = 'fa-file-code';
   private const ICON_FILE    = 'fa-file';
   private const MODE_DIR       = '40000';
   private const MODE_DIR_LONG  = '040000';
   private const MEDIA_EMPTY    = 'application/x-empty';
   private const MEDIA_OCTET    = 'application/octet-stream';
   private const MEDIA_PDF      = 'application/pdf';
   private const MEDIA_TEXT     = 'text/';
   private const MEDIA_SVG      = 'image/svg';
   private const MEDIA_APP_TEXT = [
     'application/javascript',
     'application/json',
     'application/xml',
     'application/x-httpd-php',
     'application/x-sh'
   ];
   private const ARCHIVE_EXT = [
     'zip', 'tar', 'gz', '7z', 'rar', 'jar', 'lha', 'bz', 'tgz', 'cab',
     'iso', 'dmg', 'xz', 'z', 'ar', 'war', 'ear', 'pak', 'hqx', 'arj',
   private int $size;
   private bool $isDir;
   private string $mediaType;
   private string $category;
     string $contents = ''
   ) {
     $this->name = $name;
     $this->sha = $sha;
     $this->mode = $mode;
     $this->name      = $name;
     $this->sha       = $sha;
     $this->mode      = $mode;
     $this->timestamp = $timestamp;
     $this->size = $size;
     $this->isDir = $mode === '40000' || $mode === '040000';
     $buffer = $this->isDir ? '' : $contents;
     $this->size      = $size;
     $this->isDir     = $mode === self::MODE_DIR ||
                        $mode === self::MODE_DIR_LONG;
     $buffer          = $this->isDir ? '' : $contents;
     $this->mediaType = $this->detectMediaType( $buffer );
     $this->category = $this->detectCategory( $name );
     $this->binary = $this->detectBinary();
     $this->category  = $this->detectCategory( $name );
     $this->binary    = $this->detectBinary();
+  }
       $this->size
     );
+  }
   public function emitRawHeaders(): void {
     header( "Content-Type: " . $this->mediaType );
     header( "Content-Length: " . $this->size );
     header( "Content-Disposition: attachment; filename=\"" .
       addslashes( basename( $this->name ) ) . "\"" );
+  }
+  }
   public function highlight( FileRenderer $renderer, string $content ): string {
   public function highlight(
     FileRenderer $renderer,
     string $content
   ): string {
     return $renderer->highlight( $this->name, $content, $this->mediaType );
+  }
   public function isDir(): bool {
     return $this->isDir;
+  }
   public function isName( string $name ): bool {
     return $this->name === $name;
+  }
   public function emitRawHeaders(): void {
     header( "Content-Type: " . $this->mediaType );
     header( "Content-Length: " . $this->size );
     header( "Content-Disposition: attachment; filename=\"" .
       addslashes( basename( $this->name ) ) . "\"" );
+  }
   private function resolveIcon(): string {
     return $this->isDir
       ? 'fa-folder'
       : (str_contains( $this->mediaType, 'application/pdf' )
         ? 'fa-file-pdf'
       ? self::ICON_FOLDER
       : (str_contains( $this->mediaType, self::MEDIA_PDF )
         ? self::ICON_PDF
         : match( $this->category ) {
           self::CAT_ARCHIVE => 'fa-file-archive',
           self::CAT_IMAGE => 'fa-file-image',
           self::CAT_AUDIO => 'fa-file-audio',
           self::CAT_VIDEO => 'fa-file-video',
           self::CAT_TEXT => 'fa-file-code',
           default => 'fa-file',
           self::CAT_ARCHIVE => self::ICON_ARCHIVE,
           self::CAT_IMAGE   => self::ICON_IMAGE,
           self::CAT_AUDIO   => self::ICON_AUDIO,
           self::CAT_VIDEO   => self::ICON_VIDEO,
           self::CAT_TEXT    => self::ICON_CODE,
           default           => self::ICON_FILE,
         });
+  }
   private function detectMediaType( string $buffer ): string {
     if( $buffer === '' ) return 'application/x-empty';
     $finfo = new finfo( FILEINFO_MIME_TYPE );
     $mediaType = $finfo->buffer( $buffer );
     return $mediaType ?: 'application/octet-stream';
     return $buffer === ''
       ? self::MEDIA_EMPTY
       : ((new finfo( FILEINFO_MIME_TYPE ))
           ->buffer( substr( $buffer, 0, 256 ) )
         ?: self::MEDIA_OCTET);
+  }
   private function detectCategory( string $filename = '' ): string {
     $parts = explode( '/', $this->mediaType );
   private function detectCategory( string $filename ): string {
     $main = explode( '/', $this->mediaType )[0];
     $main = $this->isArchive( $filename ) ||
             str_contains( $this->mediaType, 'compressed' )
       ? self::CAT_ARCHIVE
       : $main;
     return match( true ) {
       $parts[0] === 'image' => self::CAT_IMAGE,
       $parts[0] === 'video' => self::CAT_VIDEO,
       $parts[0] === 'audio' => self::CAT_AUDIO,
       $parts[0] === 'text' => self::CAT_TEXT,
       $this->isArchiveFile( $filename ) => self::CAT_ARCHIVE,
       str_contains( $this->mediaType, 'compressed' ) => self::CAT_ARCHIVE,
       default => self::CAT_BINARY,
     $main = $main !== self::CAT_ARCHIVE &&
             $this->isMediaTypeText()
       ? 'text'
       : $main;
     return match( $main ) {
       'image'           => self::CAT_IMAGE,
       'video'           => self::CAT_VIDEO,
       'audio'           => self::CAT_AUDIO,
       'text'            => self::CAT_TEXT,
       self::CAT_ARCHIVE => self::CAT_ARCHIVE,
       default           => self::CAT_BINARY,
     };
+  }
   private function detectBinary(): bool {
     return $this->mediaType !== 'application/x-empty'
         && !str_starts_with( $this->mediaType, 'text/' );
     return $this->mediaType !== self::MEDIA_EMPTY &&
            !$this->isMediaTypeText() &&
            !str_contains( $this->mediaType, self::MEDIA_SVG );
+  }
   private function isArchiveFile( string $filename ): bool {
   private function isMediaTypeText(): bool {
     return str_starts_with( $this->mediaType, self::MEDIA_TEXT ) ||
            in_array( $this->mediaType, self::MEDIA_APP_TEXT, true );
+  }
   private function isArchive( string $filename ): bool {
     return in_array(
       strtolower( pathinfo( $filename, PATHINFO_EXTENSION ) ),
       self::ARCHIVE_EXTENSIONS,
       self::ARCHIVE_EXT,
       true
     );

M RepositoryList.php

 <?php
 class RepositoryList {
   private $reposPath;
   private const GIT_EXT       = '.git';
   private const ORDER_FILE    = '/order.txt';
   private const GLOB_PATTERN  = '/*';
   private const HIDDEN_PREFIX = '.';
   private const EXCLUDE_CHAR  = '-';
   private const SORT_MAX      = PHP_INT_MAX;
   public function __construct( $path ) {
   private const KEY_SAFE_NAME = 'safe_name';
   private const KEY_EXCLUDE   = 'exclude';
   private const KEY_ORDER     = 'order';
   private const KEY_PATH      = 'path';
   private const KEY_NAME      = 'name';
   private string $reposPath;
   public function __construct( string $path ) {
     $this->reposPath = $path;
+  }
   public function eachRepository( callable $callback ) {
   public function eachRepository( callable $callback ): void {
     $repos = $this->sortRepositories( $this->loadRepositories() );
     foreach( $repos as $repo ) {
       $callback( $repo );
+    }
+  }
   private function loadRepositories(): array {
     $repos = [];
     $dirs = glob( $this->reposPath . '/*', GLOB_ONLYDIR );
     $path  = $this->reposPath . self::GLOB_PATTERN;
     $dirs  = glob( $path, GLOB_ONLYDIR );
     if( $dirs === false ) {
       return;
     if( $dirs !== false ) {
       $repos = $this->processDirectories( $dirs );
+    }
     return $repos;
+  }
   private function processDirectories( array $dirs ): array {
     $repos = [];
     foreach( $dirs as $dir ) {
       $basename = basename( $dir );
       $data = $this->createRepositoryData( $dir );
       if( $basename[0] === '.' ) {
         continue;
       if( $data !== [] ) {
         $repos[$data[self::KEY_NAME]] = $data;
+      }
+    }
       $name = $basename;
     return $repos;
+  }
       if( str_ends_with( $name, '.git' ) ) {
         $name = substr( $name, 0, -4 );
+      }
   private function createRepositoryData( string $dir ): array {
     $data = [];
     $base = basename( $dir );
       $repos[$name] = [
         'name' => $name,
         'safe_name' => $name,
         'path' => $dir
     if( $base[0] !== self::HIDDEN_PREFIX ) {
       $name = $this->extractName( $base );
       $data = [
         self::KEY_NAME      => $name,
         self::KEY_SAFE_NAME => $name,
         self::KEY_PATH      => $dir,
       ];
+    }
     $this->sortRepositories( $repos );
     return $data;
+  }
     foreach( $repos as $repo ) {
       $callback( $repo );
   private function extractName( string $base ): string {
     $name = $base;
     if( str_ends_with( $base, self::GIT_EXT ) ) {
       $len  = strlen( self::GIT_EXT );
       $name = substr( $base, 0, -$len );
+    }
     return $name;
+  }
   private function sortRepositories( array &$repos ) {
     $orderFile = __DIR__ . '/order.txt';
   private function sortRepositories( array $repos ): array {
     $file = __DIR__ . self::ORDER_FILE;
     if( !file_exists( $orderFile ) ) {
     if( file_exists( $file ) ) {
       $repos = $this->applyCustomOrder( $repos, $file );
     } else {
       ksort( $repos, SORT_NATURAL | SORT_FLAG_CASE );
       return;
+    }
     $lines = file( $orderFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES );
     $order = [];
     return $repos;
+  }
   private function applyCustomOrder( array $repos, string $file ): array {
     $lines = file( $file, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES );
     if( $lines !== false ) {
       $config = $this->parseOrderFile( $lines );
       $repos  = $this->filterExcluded( $repos, $config[self::KEY_EXCLUDE] );
       $repos  = $this->sortWithConfig( $repos, $config[self::KEY_ORDER] );
+    }
     return $repos;
+  }
   private function parseOrderFile( array $lines ): array {
     $order   = [];
     $exclude = [];
     foreach( $lines as $line ) {
       $line = trim( $line );
       if( $line === '' ) {
         continue;
+      }
       $trim = trim( $line );
       if( $line[0] === '-' ) {
         $exclude[substr( $line, 1 )] = true;
       } else {
         $order[$line] = count( $order );
       if( $trim !== '' ) {
         if( str_starts_with( $trim, self::EXCLUDE_CHAR ) ) {
           $exclude = $this->addExclusion( $exclude, $trim );
         } else {
           $order[$trim] = count( $order );
+        }
+      }
+    }
     return [ self::KEY_ORDER => $order, self::KEY_EXCLUDE => $exclude ];
+  }
   private function addExclusion( array $exclude, string $line ): array {
     $name           = substr( $line, 1 );
     $exclude[$name] = true;
     return $exclude;
+  }
   private function filterExcluded( array $repos, array $exclude ): array {
     foreach( $repos as $key => $repo ) {
       if( isset( $exclude[$repo['safe_name']] ) ) {
       if( isset( $exclude[$repo[self::KEY_SAFE_NAME]] ) ) {
         unset( $repos[$key] );
+      }
+    }
     uasort( $repos, function( $a, $b ) use ( $order ) {
       $nameA = $a['safe_name'];
       $nameB = $b['safe_name'];
       $posA = $order[$nameA] ?? PHP_INT_MAX;
       $posB = $order[$nameB] ?? PHP_INT_MAX;
       if( $posA === $posB ) {
         return strcasecmp( $nameA, $nameB );
+      }
     return $repos;
+  }
       return $posA <=> $posB;
   private function sortWithConfig( array $repos, array $order ): array {
     uasort( $repos, function( array $repoA, array $repoB ) use( $order ): int {
       return $this->compareRepositories( $repoA, $repoB, $order );
     } );
     return $repos;
+  }
   private function compareRepositories(
     array $repoA,
     array $repoB,
     array $order
   ): int {
     $safeA = $repoA[self::KEY_SAFE_NAME];
     $safeB = $repoB[self::KEY_SAFE_NAME];
     $posA  = $order[$safeA] ?? self::SORT_MAX;
     $posB  = $order[$safeB] ?? self::SORT_MAX;
     $result = $posA === $posB
       ? strcasecmp( $safeA, $safeB )
       : $posA <=> $posB;
     return $result;
+  }
+}

M Router.php

 class Router {
   private $repos = [];
   private $git;
   private const ACTION_TREE    = 'tree';
   private const ACTION_BLOB    = 'blob';
   private const ACTION_RAW     = 'raw';
   private const ACTION_COMMITS = 'commits';
   private const ACTION_COMMIT  = 'commit';
   private const ACTION_COMPARE = 'compare';
   private const ACTION_TAGS    = 'tags';
   private const GET_REPOSITORY = 'repo';
   private const GET_ACTION     = 'action';
   private const GET_HASH       = 'hash';
   private const GET_NAME       = 'name';
   private const REFERENCE_HEAD = 'HEAD';
   private const ROUTE_REPO     = 'repo';
   private const EXTENSION_GIT  = '.git';
   private array $repos = [];
   private Git $git;
   private string $repoName   = '';
   private array $repoData    = [];
   private string $action     = '';
   private string $commitHash = '';
   private string $filePath   = '';
   private string $baseHash   = '';
   public function __construct( string $reposPath ) {
     $this->git = new Git( $reposPath );
     $list = new RepositoryList( $reposPath );
     $list      = new RepositoryList( $reposPath );
     $list->eachRepository( function( $repo ) {
       $this->repos[$repo['safe_name']] = $repo;
     } );
     });
+  }
   public function route(): Page {
     if( empty( $_GET ) && !empty( $_SERVER['QUERY_STRING'] ) ) {
       parse_str( $_SERVER['QUERY_STRING'], $_GET );
+    }
     $uri = parse_url( $_SERVER['REQUEST_URI'], PHP_URL_PATH );
     $scriptName = dirname( $_SERVER['SCRIPT_NAME'] );
     $this->normalizeQueryString();
     $uriParts = $this->parseUriParts();
     $repoName = !empty( $uriParts ) ? array_shift( $uriParts ) : '';
     $page     = new HomePage( $this->repos, $this->git );
     if( $scriptName !== '/' && strpos( $uri, $scriptName ) === 0 ) {
       $uri = substr( $uri, strlen( $scriptName ) );
     if( $repoName !== '' ) {
       if( str_ends_with( $repoName, self::EXTENSION_GIT ) ) {
         $page = $this->handleCloneRoute( $repoName, $uriParts );
       } elseif( isset( $this->repos[$repoName] ) ) {
         $page = $this->resolveActionRoute( $repoName, $uriParts );
+      }
+    }
     $uri = trim( $uri, '/' );
     $parts = explode( '/', $uri );
     return $page;
+  }
     if( !empty( $parts ) && $parts[0] === 'repo' ) {
       array_shift( $parts );
   private function handleCloneRoute(
     string $repoName,
     array $uriParts
   ): Page {
     $realName = substr( $repoName, 0, -4 );
     $path     = '';
     if( isset( $this->repos[$realName]['path'] ) ) {
       $path = $this->repos[$realName]['path'];
     } elseif( isset( $this->repos[$repoName]['path'] ) ) {
       $path = $this->repos[$repoName]['path'];
+    }
     if( empty( $parts ) || empty( $parts[0] ) ) {
       return new HomePage( $this->repos, $this->git );
     if( $path === '' ) {
       http_response_code( 404 );
       exit( "Repository not found" );
+    }
     $repoName = array_shift( $parts );
     $this->git->setRepository( $path );
     if( str_ends_with( $repoName, '.git' ) ) {
       $realName = substr( $repoName, 0, -4 );
       $repoPath = $this->repos[$realName]['path'] ??
                   $this->repos[$repoName]['path'] ?? null;
     return new ClonePage( $this->git, implode( '/', $uriParts ) );
+  }
       if( !$repoPath ) {
         http_response_code( 404 );
         echo "Repository not found";
         exit;
+      }
   private function resolveActionRoute(
     string $repoName,
     array $uriParts
   ): Page {
     $this->repoData = $this->repos[$repoName];
     $this->repoName = $repoName;
       $this->git->setRepository( $repoPath );
     $this->git->setRepository( $this->repoData['path'] );
       return new ClonePage( $this->git, implode( '/', $parts ) );
+    }
     $act = array_shift( $uriParts );
     $this->action = $act ?: self::ACTION_TREE;
     if( !isset( $this->repos[$repoName] ) ) {
       return new HomePage( $this->repos, $this->git );
+    }
     $this->commitHash = self::REFERENCE_HEAD;
     $this->filePath   = '';
     $this->baseHash   = '';
     $currRepo = $this->repos[$repoName];
     $this->git->setRepository( $currRepo['path'] );
     $action = array_shift( $parts ) ?: 'tree';
     $hash = '';
     $path = '';
     $baseHash = '';
     $hasHash = [
       self::ACTION_TREE, self::ACTION_BLOB, self::ACTION_RAW,
       self::ACTION_COMMITS
     ];
     if( in_array( $action, ['tree', 'blob', 'raw', 'commits'] ) ) {
       $hash = array_shift( $parts ) ?: 'HEAD';
       $path = implode( '/', $parts );
     } elseif( $action === 'commit' ) {
       $hash = array_shift( $parts );
     } elseif( $action === 'compare' ) {
       $hash = array_shift( $parts );
       $baseHash = array_shift( $parts );
     if( in_array( $this->action, $hasHash ) ) {
       $hash = array_shift( $uriParts );
       $this->commitHash = $hash ?: self::REFERENCE_HEAD;
       $this->filePath   = implode( '/', $uriParts );
     } elseif( $this->action === self::ACTION_COMMIT ) {
       $this->commitHash = array_shift( $uriParts ) ?? self::REFERENCE_HEAD;
     } elseif( $this->action === self::ACTION_COMPARE ) {
       $this->commitHash = array_shift( $uriParts ) ?? self::REFERENCE_HEAD;
       $this->baseHash   = array_shift( $uriParts ) ?? '';
+    }
     $_GET['repo'] = $repoName;
     $_GET['action'] = $action;
     $_GET['hash'] = $hash;
     $_GET['name'] = $path;
     $this->populateGet();
     return match( $action ) {
       'tree', 'blob' => new FilePage(
         $this->repos, $currRepo, $this->git, $hash, $path
     return $this->createPage();
+  }
   private function createPage(): Page {
     return match( $this->action ) {
       self::ACTION_TREE,
       self::ACTION_BLOB    => new FilePage(
         $this->repos, $this->repoData, $this->git, $this->commitHash,
         $this->filePath
       ),
       'raw' => new RawPage( $this->git, $hash ),
       'commits' => new CommitsPage( $this->repos, $currRepo, $this->git, $hash ),
       'commit' => new DiffPage( $this->repos, $currRepo, $this->git, $hash ),
       'tags' => new TagsPage( $this->repos, $currRepo, $this->git ),
       'compare' => new ComparePage(
         $this->repos, $currRepo, $this->git, $hash, $baseHash
       self::ACTION_RAW     => new RawPage(
         $this->git, $this->commitHash
       ),
       default => new FilePage( $this->repos, $currRepo, $this->git, 'HEAD', '' )
       self::ACTION_COMMITS => new CommitsPage(
         $this->repos, $this->repoData, $this->git, $this->commitHash
       ),
       self::ACTION_COMMIT  => new DiffPage(
         $this->repos, $this->repoData, $this->git, $this->commitHash
       ),
       self::ACTION_TAGS    => new TagsPage(
         $this->repos, $this->repoData, $this->git
       ),
       self::ACTION_COMPARE => new ComparePage(
         $this->repos, $this->repoData, $this->git, $this->commitHash,
         $this->baseHash
       ),
       default              => new FilePage(
         $this->repos, $this->repoData, $this->git, self::REFERENCE_HEAD, ''
+      )
     };
+  }
   private function normalizeQueryString(): void {
     if( empty( $_GET ) && !empty( $_SERVER['QUERY_STRING'] ) ) {
       parse_str( $_SERVER['QUERY_STRING'], $_GET );
+    }
+  }
   private function parseUriParts(): array {
     $requestUri = parse_url( $_SERVER['REQUEST_URI'], PHP_URL_PATH );
     $scriptName = dirname( $_SERVER['SCRIPT_NAME'] );
     if( $scriptName !== '/' && strpos( $requestUri, $scriptName ) === 0 ) {
       $requestUri = substr( $requestUri, strlen( $scriptName ) );
+    }
     $requestUri = trim( $requestUri, '/' );
     $uriParts   = explode( '/', $requestUri );
     if( !empty( $uriParts ) && $uriParts[0] === self::ROUTE_REPO ) {
       array_shift( $uriParts );
+    }
     return $uriParts;
+  }
   private function populateGet(): void {
     $_GET[self::GET_REPOSITORY] = $this->repoName;
     $_GET[self::GET_ACTION]     = $this->action;
     $_GET[self::GET_HASH]       = $this->commitHash;
     $_GET[self::GET_NAME]       = $this->filePath;
+  }
+}

M Tag.php

     string $author
   ) {
     $this->name = $name;
     $this->sha = $sha;
     $this->name      = $name;
     $this->sha       = $sha;
     $this->targetSha = $targetSha;
     $this->timestamp = $timestamp;
     $this->message = $message;
     $this->author = $author;
     $this->message   = $message;
     $this->author    = $author;
+  }
+  }
+}

M UrlBuilder.php

 <?php
 class UrlBuilder {
   private const REPO_PREFIX = '/repo/';
   private const HEAD_REF    = '/HEAD';
   private const ACT_TREE    = 'tree';
   private $repo;
   private $action;
   private $hash;
   private $name;
   private $switcher;
   public function withRepo( $repo ) {
     $this->repo = $repo;
     return $this;
+  }
   public function withAction( $action ) {
     $this->action = $action;
     return $this;
+  }
   public function withHash( $hash ) {
     $this->hash = $hash;
     return $this;
+  }
   public function withName( $name ) {
     $this->name = $name;
     return $this;
+  }
   public function withSwitcher( $jsValue ) {
     $this->switcher = $jsValue;
     return $this;
+  }
   public function build() {
     if( $this->switcher ) {
       return "window.location.href='/repo/' + " . $this->switcher;
+    }
     if( !$this->repo ) {
       return '/';
+    }
     $url = '/repo/' . $this->repo;
     if( !$this->action && $this->name ) {
       $this->action = 'tree';
+    }
     return $this->switcher
       ? "window.location.href='" . self::REPO_PREFIX . "' + " . $this->switcher
       : ($this->repo ? $this->assembleUrl() : '/');
+  }
     if( $this->action ) {
       $url .= '/' . $this->action;
   private function assembleUrl() {
     $url = self::REPO_PREFIX . $this->repo;
     $act = !$this->action && $this->name ? self::ACT_TREE : $this->action;
       if( $this->hash ) {
          $url .= '/' . $this->hash;
       } elseif( in_array( $this->action, ['tree', 'blob', 'raw', 'commits'] ) ) {
          $url .= '/HEAD';
+      }
     if( $act ) {
       $url .= '/' . $act . $this->resolveHashSegment( $act );
+    }
     if( $this->name ) {
       $url .= '/' . ltrim( $this->name, '/' );
+    }
     return $url;
+  }
   private function resolveHashSegment( $act ) {
     return $this->hash
       ? '/' . $this->hash
       : (in_array( $act, ['tree', 'blob', 'raw', 'commits'] )
         ? self::HEAD_REF
         : '');
+  }
+}

M git/Git.php

 class Git {
   private const MAX_READ_SIZE = 1048576;
   private string $repoPath;
   private string $objectsPath;
   private GitRefs $refs;
   private GitPacks $packs;
   public function __construct( string $repoPath ) {
     $this->setRepository( $repoPath );
+  }
   public function setRepository( string $repoPath ): void {
     $this->repoPath    = rtrim( $repoPath, '/' );
     $this->objectsPath = $this->repoPath . '/objects';
     $this->refs        = new GitRefs( $this->repoPath );
     $this->packs       = new GitPacks( $this->objectsPath );
+  }
   public function resolve( string $reference ): string {
     return $this->refs->resolve( $reference );
+  }
   public function getMainBranch(): array {
     return $this->refs->getMainBranch();
+  }
   public function eachBranch( callable $callback ): void {
     $this->refs->scanRefs( 'refs/heads', $callback );
+  }
   public function eachTag( callable $callback ): void {
     $this->refs->scanRefs( 'refs/tags', function( $name, $sha ) use (
       $callback
     ) {
       $data = $this->read( $sha );
       $tag  = $this->parseTagData( $name, $sha, $data );
       $callback( $tag );
     } );
+  }
   public function walk(
     string $refOrSha,
     callable $callback,
     string $path = ''
   ): void {
     $sha     = $this->resolve( $refOrSha );
     $treeSha = '';
     if( $sha !== '' ) {
       $treeSha = $this->getTreeSha( $sha );
+    }
     if( $path !== '' && $treeSha !== '' ) {
       $info    = $this->resolvePath( $treeSha, $path );
       $treeSha = $info['isDir'] ? $info['sha'] : '';
+    }
     if( $treeSha !== '' ) {
       $this->walkTree( $treeSha, $callback );
+    }
+  }
   public function readFile( string $ref, string $path ): File {
     $sha  = $this->resolve( $ref );
     $tree = $sha !== '' ? $this->getTreeSha( $sha ) : '';
     $info = $tree !== '' ? $this->resolvePath( $tree, $path ) : [];
     $file = new MissingFile();
     if( isset( $info['sha'] ) && !$info['isDir'] && $info['sha'] !== '' ) {
       $file = new File(
         basename( $path ),
         $info['sha'],
         $info['mode'],
 ,
         $this->getObjectSize( $info['sha'] ),
         $this->peek( $info['sha'] )
       );
+    }
     return $file;
+  }
   public function getObjectSize( string $sha, string $path = '' ): int {
     $target = $sha;
     if( $path !== '' ) {
       $info   = $this->resolvePath(
         $this->getTreeSha( $this->resolve( $sha ) ),
         $path
       );
       $target = $info['sha'] ?? '';
+    }
     return $target !== ''
       ? $this->packs->getSize( $target ) ?? $this->getLooseObjectSize( $target )
       : 0;
+  }
   public function stream(
     string $sha,
     callable $callback,
     string $path = ''
   ): void {
     $target = $sha;
     if( $path !== '' ) {
       $info   = $this->resolvePath(
         $this->getTreeSha( $this->resolve( $sha ) ),
         $path
       );
       $target = isset( $info['isDir'] ) && !$info['isDir']
         ? $info['sha']
         : '';
+    }
     if( $target !== '' ) {
       $this->slurp( $target, $callback );
+    }
+  }
   private function getTreeSha( string $commitOrTreeSha ): string {
     $data = $this->read( $commitOrTreeSha );
     $sha  = $commitOrTreeSha;
     if( preg_match( '/^object ([0-9a-f]{40})/m', $data, $matches ) ) {
       $sha = $this->getTreeSha( $matches[1] );
+    }
     if( $sha === $commitOrTreeSha &&
         preg_match( '/^tree ([0-9a-f]{40})/m', $data, $matches ) ) {
       $sha = $matches[1];
+    }
     return $sha;
+  }
   private function resolvePath( string $treeSha, string $path ): array {
     $parts = explode( '/', trim( $path, '/' ) );
     $sha   = $treeSha;
     $mode  = '40000';
     foreach( $parts as $part ) {
       $entry = $part !== '' && $sha !== ''
         ? $this->findTreeEntry( $sha, $part )
         : [ 'sha' => '', 'mode' => '' ];
       $sha   = $entry['sha'];
       $mode  = $entry['mode'];
+    }
     return [
       'sha'   => $sha,
       'mode'  => $mode,
       'isDir' => $mode === '40000' || $mode === '040000'
     ];
+  }
   private function findTreeEntry( string $treeSha, string $name ): array {
     $data  = $this->read( $treeSha );
     $pos   = 0;
     $len   = strlen( $data );
     $entry = [ 'sha' => '', 'mode' => '' ];
     while( $pos < $len ) {
       $space = strpos( $data, ' ', $pos );
       $eos   = strpos( $data, "\0", $space );
       if( $space === false || $eos === false ) {
         break;
+      }
       if( substr( $data, $space + 1, $eos - $space - 1 ) === $name ) {
         $entry = [
           'sha'  => bin2hex( substr( $data, $eos + 1, 20 ) ),
           'mode' => substr( $data, $pos, $space - $pos )
         ];
         break;
+      }
       $pos   = $eos + 21;
+    }
     return $entry;
+  }
   private function parseTagData(
     string $name,
     string $sha,
     string $data
   ): Tag {
     $isAnn   = strncmp( $data, 'object ', 7 ) === 0;
     $pattern = $isAnn
       ? '/^tagger (.*) <(.*)> (\d+) [+\-]\d{4}$/m'
       : '/^author (.*) <(.*)> (\d+) [+\-]\d{4}$/m';
     $id      = $this->parseIdentity( $data, $pattern );
     $target  = $isAnn
       ? $this->extractPattern( $data, '/^object (.*)$/m', 1, $sha )
       : $sha;
     return new Tag(
       $name,
       $sha,
       $target,
       $id['timestamp'],
       $this->extractMessage( $data ),
       $id['name']
     );
+  }
   private function extractPattern(
     string $data,
     string $pattern,
     int $group,
     string $default = ''
   ): string {
     return preg_match( $pattern, $data, $matches )
       ? $matches[$group]
       : $default;
+  }
   private function parseIdentity( string $data, string $pattern ): array {
     $found = preg_match( $pattern, $data, $matches );
     return [
       'name'      => $found ? trim($matches[1]) : 'Unknown',
       'email'     => $found ? $matches[2] : '',
       'timestamp' => $found ? (int)$matches[3] : 0
     ];
+  }
   private function extractMessage( string $data ): string {
     $pos = strpos( $data, "\n\n" );
     return $pos !== false ? trim( substr( $data, $pos + 2 ) ) : '';
+  }
   public function peek( string $sha, int $length = 255 ): string {
     $size = $this->packs->getSize( $sha );
     return $size === null
       ? $this->peekLooseObject( $sha, $length )
       : $this->packs->peek( $sha, $length ) ?? '';
+  }
   public function read( string $sha ): string {
     $size    = $this->getObjectSize( $sha );
     $content = '';
     if( $size > 0 && $size <= self::MAX_READ_SIZE ) {
       $this->slurp( $sha, function( $chunk ) use ( &$content ) {
         $content .= $chunk;
       } );
+    }
     return $content;
+  }
   private function slurp( string $sha, callable $callback ): void {
     $path = $this->getLoosePath( $sha );
     if( is_file($path) ) {
       $this->slurpLooseObject( $path, $callback );
+    }
     if( !is_file($path) ) {
       $this->slurpPackedObject( $sha, $callback );
+    }
+  }
   private function iterateInflated( string $path, callable $processor ): void {
     $this->withInflatedFile(
       $path,
       function( $handle, $inflator ) use ( $processor ) {
         $found = false;
         $buffer = '';
         while( !feof($handle) ) {
           $inflated = inflate_add( $inflator, fread( $handle, 16384 ) );
           if( $inflated === false ) {
             break;
+          }
           if( !$found ) {
             $buffer .= $inflated;
             $eos     = strpos( $buffer, "\0" );
             if( $eos !== false ) {
               $found = true;
               $body  = substr( $buffer, $eos + 1 );
               $head  = substr( $buffer, 0, $eos );
               if( $processor( $body, $head ) === false ) {
                 break;
+              }
+            }
           } elseif( $found ) {
             if( $processor( $inflated, null ) === false ) {
               break;
+            }
+          }
+        }
+      }
     );
+  }
   private function slurpLooseObject(
     string $path,
     callable $callback
   ): void {
     $this->iterateInflated(
       $path,
       function( $chunk ) use ( $callback ) {
         if( $chunk !== '' ) {
           $callback( $chunk );
+        }
         return true;
+      }
     );
+  }
   private function withInflatedFile( string $path, callable $callback ): void {
     $handle = fopen( $path, 'rb' );
     $infl   = $handle ? inflate_init( ZLIB_ENCODING_DEFLATE ) : null;
     if( $handle && $infl ) {
       $callback( $handle, $infl );
       fclose( $handle );
+    }
+  }
   private function slurpPackedObject( string $sha, callable $callback ): void {
     $streamed = $this->packs->stream( $sha, $callback );
     if( !$streamed ) {
       $data = $this->packs->read( $sha );
       if( $data !== null && $data !== '' ) {
         $callback( $data );
+      }
+    }
+  }
   private function peekLooseObject( string $sha, int $length ): string {
     $path = $this->getLoosePath( $sha );
     return is_file($path)
       ? $this->inflateLooseObjectPrefix( $path, $length )
       : '';
+  }
   private function inflateLooseObjectPrefix(
     string $path,
     int $length
   ): string {
     $buf = '';
     $this->iterateInflated(
       $path,
       function( $chunk ) use ( $length, &$buf ) {
         $buf .= $chunk;
         return strlen($buf) < $length;
+      }
     );
     return substr( $buf, 0, $length );
+  }
   public function history( string $ref, int $limit, callable $callback ): void {
     $sha   = $this->resolve( $ref );
     $count = 0;
     while( $sha !== '' && $count < $limit ) {
       $commit = $this->parseCommit( $sha );
       if( $commit->sha === '' ) {
         $sha = '';
+      }
       if( $sha !== '' ) {
         $callback( $commit );
         $sha   = $commit->parentSha;
         $count++;
+      }
+    }
+  }
   private function parseCommit( string $sha ): object {
     $data = $this->read( $sha );
     return $data !== ''
       ? $this->buildCommitObject( $sha, $data )
       : (object)[ 'sha' => '' ];
+  }
   private function buildCommitObject( string $sha, string $data ): object {
     $id = $this->parseIdentity( $data, '/^author (.*) <(.*)> (\d+)/m' );
     return (object)[
       'sha'       => $sha,
       'message'   => $this->extractMessage( $data ),
       'author'    => $id['name'],
       'email'     => $id['email'],
       'date'      => $id['timestamp'],
       'parentSha' => $this->extractPattern( $data, '/^parent (.*)$/m', 1 )
     ];
+  }
   private function walkTree( string $sha, callable $callback ): void {
     $data = $this->read( $sha );
     $tree = $data !== '' && preg_match( '/^tree (.*)$/m', $data, $m )
       ? $this->read($m[1])
       : $data;
     if( $tree !== '' && $this->isTreeData($tree) ) {
       $this->processTree( $tree, $callback );
+    }
+  }
   private function processTree( string $data, callable $callback ): void {
     $pos = 0;
     $len = strlen( $data );
     while( $pos < $len ) {
       $entry = $this->parseTreeEntry( $data, $pos, $len );
       if( $entry === null ) {
         break;
+      }
       $callback( $entry['file'] );
       $pos = $entry['nextPosition'];
+    }
+  }
   private function parseTreeEntry(
     string $data,
     int $pos,
     int $len
   ): ?array {
     $space = strpos( $data, ' ', $pos );
     $eos   = strpos( $data, "\0", $space );
     return $space !== false && $eos !== false && $eos + 21 <= $len
       ? $this->buildTreeEntryResult( $data, $pos, $space, $eos )
       : null;
+  }
   private function buildTreeEntryResult(
     string $data,
     int $pos,
     int $space,
     int $eos
   ): array {
     $mode = substr( $data, $pos, $space - $pos );
     $sha  = bin2hex( substr( $data, $eos + 1, 20 ) );
     $isD  = $mode === '40000' || $mode === '040000';
     return [
       'file' => new File(
         substr( $data, $space + 1, $eos - $space - 1 ),
         $sha,
         $mode,
 ,
         $isD ? 0 : $this->getObjectSize( $sha ),
         $isD ? '' : $this->peek( $sha )
       ),
       'nextPosition' => $eos + 21
     ];
+  }
   private function isTreeData( string $data ): bool {
     $len   = strlen( $data );
     $patt  = '/^(40000|100644|100755|120000|160000) /';
     $match = $len >= 25 && preg_match( $patt, $data );
     $eos   = $match ? strpos( $data, "\0" ) : false;
     return $match && $eos !== false && $eos + 21 <= $len;
+  }
   private function getLoosePath( string $sha ): string {
     return "{$this->objectsPath}/" .
       substr( $sha, 0, 2 ) . "/" .
       substr( $sha, 2 );
+  }
   private function getLooseObjectSize( string $sha ): int {
     $path = $this->getLoosePath( $sha );
     return is_file($path) ? $this->readLooseObjectHeader($path) : 0;
+  }
   private function readLooseObjectHeader( string $path ): int {
     $size = 0;
     $this->iterateInflated( $path, function( $chunk, $header ) use ( &$size ) {
       if( $header !== null ) {
         $parts = explode( ' ', $header );
         $size  = isset( $parts[1] ) ? (int)$parts[1] : 0;
+      }
       return false;
     } );
     return $size;
+  }
   public function streamRaw( string $subPath ): bool {
     return strpos($subPath, '..') === false
       ? $this->streamRawFile( $subPath )
       : false;
+  }
   private function streamRawFile( string $subPath ): bool {
     $path = "{$this->repoPath}/$subPath";
     return is_file($path) ? $this->streamIfPathValid($path) : false;
+  }
   private function streamIfPathValid( string $fullPath ): bool {
     $real    = realpath( $fullPath );
     $repo    = realpath( $this->repoPath );
     $isValid = $real && strpos($real, $repo) === 0;
     return $isValid ? readfile($fullPath) !== false : false;
+  }
   public function eachRef( callable $callback ): void {
     $head = $this->resolve( 'HEAD' );
     if( $head !== '' ) {
       $callback( 'HEAD', $head );
+    }
     $this->refs->scanRefs( 'refs/heads', function( $n, $s ) use ( $callback ) {
       $callback( "refs/heads/$n", $s );
     } );
     $this->refs->scanRefs( 'refs/tags', function( $n, $s ) use ( $callback ) {
       $callback( "refs/tags/$n", $s );
     } );
+  }
   public function collectObjects( array $wants, array $haves = [] ): array {
     $objs = [];
     $seen = [];
     foreach( $wants as $sha ) {
       $this->collectObjectsRecursive( $sha, $objs, $seen );
+    }
     foreach( $haves as $sha ) {
       unset($objs[$sha]);
+    }
     return $objs;
+  }
   private function collectObjectsRecursive(
     string $sha,
     array &$objs,
     array &$seen
   ): void {
     if( !isset( $seen[$sha] ) ) {
       $seen[$sha] = true;
       $data       = $this->read( $sha );
       $type       = $this->getObjectType( $data );
       $objs[$sha] = [ 'type' => $type, 'size' => strlen($data) ];
       if( $type === 1 ) {
         $this->collectCommitLinks( $data, $objs, $seen );
+      }
       if( $type === 2 ) {
         $this->collectTreeLinks( $data, $objs, $seen );
+      }
       if( $type === 4 && preg_match( '/^object (.*)$/m', $data, $m ) ) {
         $this->collectObjectsRecursive( $m[1], $objs, $seen );
+      }
+    }
+  }
   private function collectCommitLinks( $data, &$objs, &$seen ): void {
     if( preg_match( '/^tree (.*)$/m', $data, $m ) ) {
       $this->collectObjectsRecursive( $m[1], $objs, $seen );
+    }
     if( preg_match( '/^parent (.*)$/m', $data, $m ) ) {
       $this->collectObjectsRecursive( $m[1], $objs, $seen );
+    }
+  }
   private function collectTreeLinks( $data, &$objs, &$seen ): void {
     $pos = 0;
     $len = strlen( $data );
     while( $pos < $len ) {
       $space = strpos( $data, ' ', $pos );
       $eos   = strpos( $data, "\0", $space );
       if( $space === false || $eos === false ) {
         break;
+      }
       $sha   = bin2hex( substr( $data, $eos + 1, 20 ) );
       $this->collectObjectsRecursive( $sha, $objs, $seen );
       $pos   = $eos + 21;
+    }
+  }
   private function getObjectType( string $data ): int {
     $isTree = strpos($data, "tree ") === 0;
     $isObj  = strpos($data, "object ") === 0;
     return $isTree
       ? 1
       : ( $this->isTreeData($data) ? 2 : ( $isObj ? 4 : 3 ) );
+  }
   public function generatePackfile( array $objs ): string {
     $pData = '';
     if( empty($objs) ) {
       $pData = "PACK" . pack( 'N', 2 ) . pack( 'N', 0 );
+    }
     if( !empty($objs) ) {
       $data = '';
       foreach( $objs as $sha => $info ) {
         $cont  = $this->read( $sha );
         $size  = strlen($cont);
         $byte  = $info['type'] << 4 | $size & 0x0f;
         $size >>= 4;
         while( $size > 0 ) {
           $data .= chr( $byte | 0x80 );
           $byte  = $size & 0x7f;
           $size >>= 7;
+        }
         $data .= chr( $byte ) . gzcompress( $cont );
+      }
       $pData = "PACK" . pack( 'N', 2 ) . pack( 'N', count($objs) ) . $data;
+    }
     return $pData . hash( 'sha1', $pData, true );
   private const MAX_READ = 1048576;
   private string   $repoPath;
   private string   $objPath;
   private GitRefs  $refs;
   private GitPacks $packs;
   public function __construct( string $repoPath ) {
     $this->setRepository( $repoPath );
+  }
   public function setRepository( string $repoPath ): void {
     $this->repoPath = rtrim( $repoPath, '/' );
     $this->objPath  = $this->repoPath . '/objects';
     $this->refs     = new GitRefs( $this->repoPath );
     $this->packs    = new GitPacks( $this->objPath );
+  }
   public function resolve( string $reference ): string {
     return $this->refs->resolve( $reference );
+  }
   public function getMainBranch(): array {
     return $this->refs->getMainBranch();
+  }
   public function eachBranch( callable $callback ): void {
     $this->refs->scanRefs( 'refs/heads', $callback );
+  }
   public function eachTag( callable $callback ): void {
     $this->refs->scanRefs( 'refs/tags', function( $name, $sha ) use (
       $callback
     ) {
       $data = $this->read( $sha );
       $tag  = $this->parseTagData( $name, $sha, $data );
       $callback( $tag );
     } );
+  }
   public function walk(
     string $refOrSha,
     callable $callback,
     string $path = ''
   ): void {
     $sha     = $this->resolve( $refOrSha );
     $treeSha = '';
     if( $sha !== '' ) {
       $treeSha = $this->getTreeSha( $sha );
+    }
     if( $path !== '' && $treeSha !== '' ) {
       $info    = $this->resolvePath( $treeSha, $path );
       $treeSha = $info['isDir'] ? $info['sha'] : '';
+    }
     if( $treeSha !== '' ) {
       $this->walkTree( $treeSha, $callback );
+    }
+  }
   public function readFile( string $ref, string $path ): File {
     $sha  = $this->resolve( $ref );
     $tree = $sha !== '' ? $this->getTreeSha( $sha ) : '';
     $info = $tree !== '' ? $this->resolvePath( $tree, $path ) : [];
     $file = new MissingFile();
     if( isset( $info['sha'] ) && !$info['isDir'] && $info['sha'] !== '' ) {
       $file = new File(
         basename( $path ),
         $info['sha'],
         $info['mode'],
 ,
         $this->getObjectSize( $info['sha'] ),
         $this->peek( $info['sha'] )
       );
+    }
     return $file;
+  }
   public function getObjectSize( string $sha, string $path = '' ): int {
     $target = $sha;
     $result = 0;
     if( $path !== '' ) {
       $info   = $this->resolvePath(
         $this->getTreeSha( $this->resolve( $sha ) ),
         $path
       );
       $target = $info['sha'] ?? '';
+    }
     if( $target !== '' ) {
       $result = $this->packs->getSize( $target );
       if( $result === 0 ) {
         $result = $this->getLooseObjectSize( $target );
+      }
+    }
     return $result;
+  }
   public function stream(
     string $sha,
     callable $callback,
     string $path = ''
   ): void {
     $target = $sha;
     if( $path !== '' ) {
       $info   = $this->resolvePath(
         $this->getTreeSha( $this->resolve( $sha ) ),
         $path
       );
       $target = isset( $info['isDir'] ) && !$info['isDir']
         ? $info['sha']
         : '';
+    }
     if( $target !== '' ) {
       $this->slurp( $target, $callback );
+    }
+  }
   public function peek( string $sha, int $length = 255 ): string {
     $size = $this->packs->getSize( $sha );
     return $size === 0
       ? $this->peekLooseObject( $sha, $length )
       : $this->packs->peek( $sha, $length );
+  }
   public function read( string $sha ): string {
     $size    = $this->getObjectSize( $sha );
     $content = '';
     if( $size > 0 && $size <= self::MAX_READ ) {
       $this->slurp( $sha, function( $chunk ) use ( &$content ) {
         $content .= $chunk;
       } );
+    }
     return $content;
+  }
   public function history(
     string $ref,
     int $limit,
     callable $callback
   ): void {
     $sha   = $this->resolve( $ref );
     $count = 0;
     while( $sha !== '' && $count < $limit ) {
       $commit = $this->parseCommit( $sha );
       if( $commit->sha === '' ) {
         $sha = '';
+      }
       if( $sha !== '' ) {
         $callback( $commit );
         $sha = $commit->parentSha;
         $count++;
+      }
+    }
+  }
   public function streamRaw( string $subPath ): bool {
     $result = false;
     if( strpos( $subPath, '..' ) === false ) {
       $path = "{$this->repoPath}/$subPath";
       if( is_file( $path ) ) {
         $real = realpath( $path );
         $repo = realpath( $this->repoPath );
         if( $real && strpos( $real, $repo ) === 0 ) {
           $result = readfile( $path ) !== false;
+        }
+      }
+    }
     return $result;
+  }
   public function eachRef( callable $callback ): void {
     $head = $this->resolve( 'HEAD' );
     if( $head !== '' ) {
       $callback( 'HEAD', $head );
+    }
     $this->refs->scanRefs( 'refs/heads', function( $n, $s ) use ( $callback ) {
       $callback( "refs/heads/$n", $s );
     } );
     $this->refs->scanRefs( 'refs/tags', function( $n, $s ) use ( $callback ) {
       $callback( "refs/tags/$n", $s );
     } );
+  }
   public function generatePackfile( array $objs ): string {
     $pData = "PACK" . pack( 'N', 2 ) . pack( 'N', 0 );
     if( !empty( $objs ) ) {
       $data = '';
       foreach( $objs as $sha => $info ) {
         $cont  = $this->read( $sha );
         $size  = strlen( $cont );
         $byte  = $info['type'] << 4 | $size & 0x0f;
         $size >>= 4;
         while( $size > 0 ) {
           $data .= chr( $byte | 0x80 );
           $byte  = $size & 0x7f;
           $size >>= 7;
+        }
         $data .= chr( $byte ) . gzcompress( $cont );
+      }
       $pData = "PACK" . pack( 'N', 2 ) . pack( 'N', count( $objs ) ) . $data;
+    }
     return $pData . hash( 'sha1', $pData, true );
+  }
   private function getTreeSha( string $commitOrTreeSha ): string {
     $data = $this->read( $commitOrTreeSha );
     $sha  = $commitOrTreeSha;
     if( preg_match( '/^object ([0-9a-f]{40})/m', $data, $matches ) ) {
       $sha = $this->getTreeSha( $matches[1] );
+    }
     if( $sha === $commitOrTreeSha &&
         preg_match( '/^tree ([0-9a-f]{40})/m', $data, $matches ) ) {
       $sha = $matches[1];
+    }
     return $sha;
+  }
   private function resolvePath( string $treeSha, string $path ): array {
     $parts = explode( '/', trim( $path, '/' ) );
     $sha   = $treeSha;
     $mode  = '40000';
     foreach( $parts as $part ) {
       $entry = [ 'sha' => '', 'mode' => '' ];
       if( $part !== '' && $sha !== '' ) {
         $entry = $this->findTreeEntry( $sha, $part );
+      }
       $sha   = $entry['sha'];
       $mode  = $entry['mode'];
+    }
     return [
       'sha'   => $sha,
       'mode'  => $mode,
       'isDir' => $mode === '40000' || $mode === '040000'
     ];
+  }
   private function findTreeEntry( string $treeSha, string $name ): array {
     $data  = $this->read( $treeSha );
     $pos   = 0;
     $len   = strlen( $data );
     $entry = [ 'sha' => '', 'mode' => '' ];
     while( $pos < $len ) {
       $space = strpos( $data, ' ', $pos );
       $eos   = strpos( $data, "\0", $space );
       if( $space === false || $eos === false ) {
         break;
+      }
       if( substr( $data, $space + 1, $eos - $space - 1 ) === $name ) {
         $entry = [
           'sha'  => bin2hex( substr( $data, $eos + 1, 20 ) ),
           'mode' => substr( $data, $pos, $space - $pos )
         ];
         break;
+      }
       $pos = $eos + 21;
+    }
     return $entry;
+  }
   private function parseTagData(
     string $name,
     string $sha,
     string $data
   ): Tag {
     $isAnn   = strncmp( $data, 'object ', 7 ) === 0;
     $pattern = $isAnn
       ? '/^tagger (.*) <(.*)> (\d+) [+\-]\d{4}$/m'
       : '/^author (.*) <(.*)> (\d+) [+\-]\d{4}$/m';
     $id      = $this->parseIdentity( $data, $pattern );
     $target  = $isAnn
       ? $this->extractPattern( $data, '/^object (.*)$/m', 1, $sha )
       : $sha;
     return new Tag(
       $name,
       $sha,
       $target,
       $id['timestamp'],
       $this->extractMessage( $data ),
       $id['name']
     );
+  }
   private function extractPattern(
     string $data,
     string $pattern,
     int $group,
     string $default = ''
   ): string {
     return preg_match( $pattern, $data, $matches )
       ? $matches[$group]
       : $default;
+  }
   private function parseIdentity( string $data, string $pattern ): array {
     $found = preg_match( $pattern, $data, $matches );
     return [
       'name'      => $found ? trim( $matches[1] ) : 'Unknown',
       'email'     => $found ? $matches[2] : '',
       'timestamp' => $found ? (int)$matches[3] : 0
     ];
+  }
   private function extractMessage( string $data ): string {
     $pos = strpos( $data, "\n\n" );
     return $pos !== false ? trim( substr( $data, $pos + 2 ) ) : '';
+  }
   private function slurp( string $sha, callable $callback ): void {
     $path = $this->getLoosePath( $sha );
     if( is_file( $path ) ) {
       $this->slurpLooseObject( $path, $callback );
     } else {
       $this->slurpPackedObject( $sha, $callback );
+    }
+  }
   private function slurpLooseObject( string $path, callable $callback ): void {
     $this->iterateInflated(
       $path,
       function( $chunk ) use ( $callback ) {
         if( $chunk !== '' ) {
           $callback( $chunk );
+        }
         return true;
+      }
     );
+  }
   private function slurpPackedObject( string $sha, callable $callback ): void {
     $streamed = $this->packs->stream( $sha, $callback );
     if( !$streamed ) {
       $data = $this->packs->read( $sha );
       if( $data !== '' ) {
         $callback( $data );
+      }
+    }
+  }
   private function iterateInflated(
     string $path,
     callable $processor
   ): void {
     $handle = fopen( $path, 'rb' );
     $infl   = $handle ? inflate_init( ZLIB_ENCODING_DEFLATE ) : null;
     $found  = false;
     $buffer = '';
     if( $handle && $infl ) {
       while( !feof( $handle ) ) {
         $chunk    = fread( $handle, 16384 );
         $inflated = inflate_add( $infl, $chunk );
         if( $inflated === false ) {
           break;
+        }
         if( !$found ) {
           $buffer .= $inflated;
           $eos     = strpos( $buffer, "\0" );
           if( $eos !== false ) {
             $found = true;
             $body  = substr( $buffer, $eos + 1 );
             $head  = substr( $buffer, 0, $eos );
             if( $processor( $body, $head ) === false ) {
               break;
+            }
+          }
         } elseif( $processor( $inflated, null ) === false ) {
           break;
+        }
+      }
       fclose( $handle );
+    }
+  }
   private function peekLooseObject( string $sha, int $length ): string {
     $path = $this->getLoosePath( $sha );
     $buf  = '';
     if( is_file( $path ) ) {
       $this->iterateInflated(
         $path,
         function( $chunk ) use ( $length, &$buf ) {
           $buf .= $chunk;
           return strlen( $buf ) < $length;
+        }
       );
+    }
     return substr( $buf, 0, $length );
+  }
   private function parseCommit( string $sha ): object {
     $data   = $this->read( $sha );
     $result = (object)[ 'sha' => '' ];
     if( $data !== '' ) {
       $id = $this->parseIdentity(
         $data,
         '/^author (.*) <(.*)> (\d+)/m'
       );
       $result = (object)[
         'sha'       => $sha,
         'message'   => $this->extractMessage( $data ),
         'author'    => $id['name'],
         'email'     => $id['email'],
         'date'      => $id['timestamp'],
         'parentSha' => $this->extractPattern( $data, '/^parent (.*)$/m', 1 )
       ];
+    }
     return $result;
+  }
   private function walkTree( string $sha, callable $callback ): void {
     $data = $this->read( $sha );
     $tree = $data;
     if( $data !== '' && preg_match( '/^tree (.*)$/m', $data, $m ) ) {
       $tree = $this->read( $m[1] );
+    }
     if( $tree !== '' && $this->isTreeData( $tree ) ) {
       $this->processTree( $tree, $callback );
+    }
+  }
   private function processTree( string $data, callable $callback ): void {
     $pos = 0;
     $len = strlen( $data );
     while( $pos < $len ) {
       $space = strpos( $data, ' ', $pos );
       $eos   = strpos( $data, "\0", $space );
       $entry = null;
       if( $space !== false && $eos !== false && $eos + 21 <= $len ) {
         $mode = substr( $data, $pos, $space - $pos );
         $sha  = bin2hex( substr( $data, $eos + 1, 20 ) );
         $isD  = $mode === '40000' || $mode === '040000';
         $entry = [
           'file' => new File(
             substr( $data, $space + 1, $eos - $space - 1 ),
             $sha,
             $mode,
 ,
             $isD ? 0 : $this->getObjectSize( $sha ),
             $isD ? '' : $this->peek( $sha )
           ),
           'nextPosition' => $eos + 21
         ];
+      }
       if( $entry === null ) {
         break;
+      }
       $callback( $entry['file'] );
       $pos = $entry['nextPosition'];
+    }
+  }
   private function isTreeData( string $data ): bool {
     $len   = strlen( $data );
     $patt  = '/^(40000|100644|100755|120000|160000) /';
     $match = $len >= 25 && preg_match( $patt, $data );
     $eos   = $match ? strpos( $data, "\0" ) : false;
     return $match && $eos !== false && $eos + 21 <= $len;
+  }
   private function getLoosePath( string $sha ): string {
     return "{$this->objPath}/" . substr( $sha, 0, 2 ) . "/" .
       substr( $sha, 2 );
+  }
   private function getLooseObjectSize( string $sha ): int {
     $path = $this->getLoosePath( $sha );
     $size = 0;
     if( is_file( $path ) ) {
       $this->iterateInflated(
         $path,
         function( $c, $head ) use ( &$size ) {
           if( $head !== null ) {
             $parts = explode( ' ', $head );
             $size  = isset( $parts[1] ) ? (int)$parts[1] : 0;
+          }
           return false;
+        }
       );
+    }
     return $size;
+  }
   public function collectObjects( array $wants, array $haves = [] ): array {
     $objs   = [];
     $result = [];
     foreach( $wants as $sha ) {
       $objs = $this->collectObjectsRecursive( $sha, $objs, 0 );
+    }
     foreach( $haves as $sha ) {
       if( isset( $objs[$sha] ) ) {
         unset( $objs[$sha] );
+      }
+    }
     $result = $objs;
     return $result;
+  }
   private function collectObjectsRecursive(
     string $sha,
     array $objs,
     int $expectedType = 0
   ): array {
     $result = $objs;
     if( !isset( $result[$sha] ) ) {
       $data = $this->read( $sha );
       $type = $expectedType === 0
         ? $this->getObjectType( $data )
         : $expectedType;
       $result[$sha] = [
         'type' => $type,
         'size' => strlen( $data )
       ];
       if( $type === 1 ) {
         $hasTree = preg_match( '/^tree ([0-9a-f]{40})/m', $data, $m );
         if( $hasTree ) {
           $result = $this->collectObjectsRecursive( $m[1], $result, 2 );
+        }
         $hasParents = preg_match_all(
           '/^parent ([0-9a-f]{40})/m',
           $data,
           $m
         );
         if( $hasParents ) {
           foreach( $m[1] as $parentSha ) {
             $result = $this->collectObjectsRecursive(
               $parentSha,
               $result,
             );
+          }
+        }
+      }
       if( $type === 2 ) {
         $pos = 0;
         $len = strlen( $data );
         while( $pos < $len ) {
           $sp  = strpos( $data, ' ', $pos );
           $eos = strpos( $data, "\0", $sp );
           if( $sp === false || $eos === false ) {
             break;
+          }
           $mode     = substr( $data, $pos, $sp - $pos );
           $s        = bin2hex( substr( $data, $eos + 1, 20 ) );
           $isDir    = $mode === '40000' || $mode === '040000';
           $nextType = $isDir ? 2 : 3;
           $pos      = $eos + 21;
           $result = $this->collectObjectsRecursive(
             $s,
             $result,
             $nextType
           );
+        }
+      }
       $isTagTarget = $type === 4 &&
         preg_match( '/^object ([0-9a-f]{40})/m', $data, $m );
       if( $isTagTarget ) {
         $nextType = 1;
         if( preg_match( '/^type (commit|tree|blob|tag)/m', $data, $t ) ) {
           $map = [
             'commit' => 1,
             'tree'   => 2,
             'blob'   => 3,
             'tag'    => 4
           ];
           $nextType = $map[$t[1]] ?? 1;
+        }
         $result = $this->collectObjectsRecursive(
           $m[1],
           $result,
           $nextType
         );
+      }
+    }
     return $result;
+  }
   private function getObjectType( string $data ): int {
     $isTree = strpos( $data, "tree " ) === 0;
     $isObj  = strpos( $data, "object " ) === 0;
     $result = 3;
     if( $isTree ) {
       $result = 1;
     } elseif( $isObj ) {
       $result = 4;
     } elseif( $this->isTreeData( $data ) ) {
       $result = 2;
+    }
     return $result;
+  }
+}

M git/GitDiff.php

 class GitDiff {
   private Git $git;
   private const MAX_DIFF_SIZE = 1048576;
   public function __construct( Git $git ) {
     $this->git = $git;
+  }
   public function diff( string $oldSha, string $newSha ) {
     $oldTree = $oldSha ? $this->getTreeHash( $oldSha ) : null;
     $newTree = $newSha ? $this->getTreeHash( $newSha ) : null;
     return $this->diffTrees( $oldTree, $newTree );
+  }
   public function compare( string $commitHash ) {
     $commitData = $this->git->read( $commitHash );
     $parentHash = preg_match(
       '/^parent ([0-9a-f]{40})/m',
       $commitData,
       $matches
     ) ? $matches[1] : '';
     $newTree = $this->getTreeHash( $commitHash );
     $oldTree = $parentHash ? $this->getTreeHash( $parentHash ) : null;
     return $this->diffTrees( $oldTree, $newTree );
+  }
   private function getTreeHash( $commitSha ) {
     $data = $this->git->read( $commitSha );
     return preg_match( '/^tree ([0-9a-f]{40})/m', $data, $matches )
       ? $matches[1]
       : null;
+  }
   private function diffTrees( $oldTreeSha, $newTreeSha, $path = '' ) {
     $changes = [];
     if( $oldTreeSha !== $newTreeSha ) {
       $oldEntries = $oldTreeSha ? $this->parseTree( $oldTreeSha ) : [];
       $newEntries = $newTreeSha ? $this->parseTree( $newTreeSha ) : [];
       $allNames = array_unique(
         array_merge( array_keys( $oldEntries ), array_keys( $newEntries ) )
       );
       sort( $allNames );
       foreach( $allNames as $name ) {
         $old         = $oldEntries[$name] ?? null;
         $new         = $newEntries[$name] ?? null;
         $currentPath = $path ? "$path/$name" : $name;
         if( !$old ) {
           $changes = $new['is_dir']
             ? array_merge(
                 $changes,
                 $this->diffTrees( null, $new['sha'], $currentPath )
+              )
             : array_merge(
                 $changes,
                 [$this->createChange( 'A', $currentPath, null, $new['sha'] )]
               );
         } elseif( !$new ) {
           $changes = $old['is_dir']
             ? array_merge(
                 $changes,
                 $this->diffTrees( $old['sha'], null, $currentPath )
+              )
             : array_merge(
                 $changes,
                 [$this->createChange( 'D', $currentPath, $old['sha'], null )]
               );
         } elseif( $old['sha'] !== $new['sha'] ) {
           $changes = ($old['is_dir'] && $new['is_dir'])
             ? array_merge(
                 $changes,
                 $this->diffTrees( $old['sha'], $new['sha'], $currentPath )
+              )
             : (($old['is_dir'] || $new['is_dir'])
               ? $changes
               : array_merge(
                   $changes,
                   [$this->createChange(
                     'M',
                     $currentPath,
                     $old['sha'],
                     $new['sha']
                   )]
                 ));
+        }
+      }
+    }
     return $changes;
+  }
   private function parseTree( $sha ) {
     $data    = $this->git->read( $sha );
     $entries = [];
     $len     = strlen( $data );
     $pos     = 0;
     while( $pos < $len ) {
       $space = strpos( $data, ' ', $pos );
       $null  = strpos( $data, "\0", $space );
       if( $space === false || $null === false ) {
         break;
+      }
       $mode = substr( $data, $pos, $space - $pos );
       $name = substr( $data, $space + 1, $null - $space - 1 );
       $hash = bin2hex( substr( $data, $null + 1, 20 ) );
       $entries[$name] = [
         'mode'   => $mode,
         'sha'    => $hash,
         'is_dir' => $mode === '40000' || $mode === '040000'
       ];
       $pos = $null + 21;
+    }
     return $entries;
+  }
   private function createChange( $type, $path, $oldSha, $newSha ) {
     $oldSize = $oldSha ? $this->git->getObjectSize( $oldSha ) : 0;
     $newSize = $newSha ? $this->git->getObjectSize( $newSha ) : 0;
     $result  = [];
     if( $oldSize > self::MAX_DIFF_SIZE || $newSize > self::MAX_DIFF_SIZE ) {
       $result = [
         'type'      => $type,
         'path'      => $path,
         'is_binary' => true,
         'hunks'     => []
       ];
     } else {
       $oldContent = $oldSha ? $this->git->read( $oldSha ) : '';
       $newContent = $newSha ? $this->git->read( $newSha ) : '';
       $isBinary =
         ($newSha && (new VirtualDiffFile( $path, $newContent ))->isBinary()) ||
         (!$newSha && $oldSha &&
           (new VirtualDiffFile( $path, $oldContent ))->isBinary());
       $result = [
         'type'      => $type,
         'path'      => $path,
         'is_binary' => $isBinary,
         'hunks'     => $isBinary
           ? null
           : $this->calculateDiff( $oldContent, $newContent )
       ];
+    }
     return $result;
+  }
   private function calculateDiff( $old, $new ) {
     $old = str_replace( "\r\n", "\n", $old );
     $new = str_replace( "\r\n", "\n", $new );
     $oldLines = explode( "\n", $old );
     $newLines = explode( "\n", $new );
     $m = count( $oldLines );
     $n = count( $newLines );
     $start = 0;
     while(
       $start < $m &&
       $start < $n &&
       $oldLines[$start] === $newLines[$start]
     ) {
       $start++;
+    }
     $end = 0;
     while(
       $m - $end > $start &&
       $n - $end > $start &&
       $oldLines[$m - 1 - $end] === $newLines[$n - 1 - $end]
     ) {
       $end++;
+    }
     $oldSlice = array_slice( $oldLines, $start, $m - $start - $end );
     $newSlice = array_slice( $newLines, $start, $n - $start - $end );
     $result = null;
     if( (count( $oldSlice ) * count( $newSlice )) > 500000 ) {
       $result = [['t' => 'gap']];
     } else {
       $ops = $this->computeLCS( $oldSlice, $newSlice );
       $groupedOps = [];
       $bufferDel  = [];
       $bufferAdd  = [];
       foreach( $ops as $op ) {
         if( $op['t'] === ' ' ) {
           foreach( $bufferDel as $o ) { $groupedOps[] = $o; }
           foreach( $bufferAdd as $o ) { $groupedOps[] = $o; }
           $bufferDel    = [];
           $bufferAdd    = [];
           $groupedOps[] = $op;
         } elseif( $op['t'] === '-' ) {
           $bufferDel[] = $op;
         } elseif( $op['t'] === '+' ) {
           $bufferAdd[] = $op;
+        }
+      }
       foreach( $bufferDel as $o ) { $groupedOps[] = $o; }
       foreach( $bufferAdd as $o ) { $groupedOps[] = $o; }
       $ops    = $groupedOps;
       $stream = [];
       for( $i = 0; $i < $start; $i++ ) {
         $stream[] = [
           't'  => ' ',
           'l'  => $oldLines[$i],
           'no' => $i + 1,
           'nn' => $i + 1
         ];
+      }
       $currO = $start + 1;
       $currN = $start + 1;
       foreach( $ops as $op ) {
         if( $op['t'] === ' ' ) {
           $stream[] = [
             't'  => ' ',
             'l'  => $op['l'],
             'no' => $currO++,
             'nn' => $currN++
           ];
         } elseif( $op['t'] === '-' ) {
           $stream[] = [
             't'  => '-',
             'l'  => $op['l'],
             'no' => $currO++,
             'nn' => null
           ];
         } elseif( $op['t'] === '+' ) {
           $stream[] = [
             't'  => '+',
             'l'  => $op['l'],
             'no' => null,
             'nn' => $currN++
           ];
+        }
+      }
       for( $i = $m - $end; $i < $m; $i++ ) {
         $stream[] = [
           't'  => ' ',
           'l'  => $oldLines[$i],
           'no' => $currO++,
           'nn' => $currN++
         ];
+      }
       $finalLines       = [];
       $lastVisibleIndex = -1;
       $streamLen        = count( $stream );
       $contextLines     = 3;
       for( $i = 0; $i < $streamLen; $i++ ) {
         $show = false;
         if( $stream[$i]['t'] !== ' ' ) {
           $show = true;
         } else {
           for( $j = 1; $j <= $contextLines; $j++ ) {
             if( ($i + $j) < $streamLen && $stream[$i + $j]['t'] !== ' ' ) {
               $show = true;
               break;
+            }
+          }
           if( !$show ) {
             for( $j = 1; $j <= $contextLines; $j++ ) {
               if( ($i - $j) >= 0 && $stream[$i - $j]['t'] !== ' ' ) {
                 $show = true;
                 break;
+              }
+            }
+          }
+        }
         if( $show ) {
           if( $lastVisibleIndex !== -1 && $i > $lastVisibleIndex + 1 ) {
             $finalLines[] = ['t' => 'gap'];
+          }
           $finalLines[]     = $stream[$i];
           $lastVisibleIndex = $i;
+        }
+      }
       $result = $finalLines;
+    }
     return $result;
+  }
   private function computeLCS( $old, $new ) {
     $m = count( $old );
     $n = count( $new );
     $c = array_fill( 0, $m + 1, array_fill( 0, $n + 1, 0 ) );
     for( $i = 1; $i <= $m; $i++ ) {
       for( $j = 1; $j <= $n; $j++ ) {
         $c[$i][$j] = ($old[$i - 1] === $new[$j - 1])
           ? $c[$i - 1][$j - 1] + 1
           : max( $c[$i][$j - 1], $c[$i - 1][$j] );
+      }
+    }
     $diff = [];
     $i    = $m;
     $j    = $n;
     while( $i > 0 || $j > 0 ) {
       if( $i > 0 && $j > 0 && $old[$i - 1] === $new[$j - 1] ) {
         array_unshift( $diff, ['t' => ' ', 'l' => $old[$i - 1]] );
         $i--;
         $j--;
       } elseif( $j > 0 && ($i === 0 || $c[$i][$j - 1] >= $c[$i - 1][$j]) ) {
         array_unshift( $diff, ['t' => '+', 'l' => $new[$j - 1]] );
         $j--;
       } elseif( $i > 0 && ($j === 0 || $c[$i][$j - 1] < $c[$i - 1][$j]) ) {
         array_unshift( $diff, ['t' => '-', 'l' => $old[$i - 1]] );
         $i--;
+      }
+    }
     return $diff;
   private const MAX_DIFF_SIZE = 262144;
   public function __construct( Git $git ) {
     $this->git = $git;
+  }
   public function diff( string $oldSha, string $newSha ): Generator {
     $oldTree = $oldSha !== '' ? $this->getTreeHash( $oldSha ) : '';
     $newTree = $newSha !== '' ? $this->getTreeHash( $newSha ) : '';
     yield from $this->diffTrees( $oldTree, $newTree );
+  }
   public function compare( string $commitHash ): Generator {
     $commitData = $this->git->read( $commitHash );
     $parentHash = '';
     if( preg_match( '/^parent ([0-9a-f]{40})/m', $commitData, $m ) ) {
       $parentHash = $m[1];
+    }
     $newTree = $this->getTreeHash( $commitHash );
     $oldTree = $parentHash !== '' ? $this->getTreeHash( $parentHash ) : '';
     yield from $this->diffTrees( $oldTree, $newTree );
+  }
   private function getTreeHash( string $commitSha ): string {
     $data   = $this->git->read( $commitSha );
     $result = '';
     if( preg_match( '/^tree ([0-9a-f]{40})/m', $data, $matches ) ) {
       $result = $matches[1];
+    }
     return $result;
+  }
   private function diffTrees(
     string $oldTreeSha,
     string $newTreeSha,
     string $path = ''
   ): Generator {
     if( $oldTreeSha !== $newTreeSha ) {
       $oldEntries = $oldTreeSha !== ''
         ? $this->parseTree( $oldTreeSha )
         : [];
       $newEntries = $newTreeSha !== ''
         ? $this->parseTree( $newTreeSha )
         : [];
       $allNames   = array_unique(
         array_merge( array_keys( $oldEntries ), array_keys( $newEntries ) )
       );
       sort( $allNames );
       foreach( $allNames as $name ) {
         $old         = $oldEntries[$name] ?? null;
         $new         = $newEntries[$name] ?? null;
         $currentPath = $path !== '' ? "$path/$name" : $name;
         if( !$old && $new ) {
           if( $new['is_dir'] ) {
             yield from $this->diffTrees( '', $new['sha'], $currentPath );
           } else {
             yield $this->createChange( 'A', $currentPath, '', $new['sha'] );
+          }
         } elseif( !$new && $old ) {
           if( $old['is_dir'] ) {
             yield from $this->diffTrees( $old['sha'], '', $currentPath );
           } else {
             yield $this->createChange( 'D', $currentPath, $old['sha'], '' );
+          }
         } elseif( $old && $new && $old['sha'] !== $new['sha'] ) {
           if( $old['is_dir'] && $new['is_dir'] ) {
             yield from $this->diffTrees(
               $old['sha'],
               $new['sha'],
               $currentPath
             );
           } elseif( !$old['is_dir'] && !$new['is_dir'] ) {
             yield $this->createChange(
               'M',
               $currentPath,
               $old['sha'],
               $new['sha']
             );
+          }
+        }
+      }
+    }
+  }
   private function parseTree( string $sha ): array {
     $data    = $this->git->read( $sha );
     $entries = [];
     $len     = strlen( $data );
     $pos     = 0;
     while( $pos < $len ) {
       $space = strpos( $data, ' ', $pos );
       $null  = strpos( $data, "\0", $space );
       if( $space === false || $null === false ) {
         break;
+      }
       $mode = substr( $data, $pos, $space - $pos );
       $name = substr( $data, $space + 1, $null - $space - 1 );
       $hash = bin2hex( substr( $data, $null + 1, 20 ) );
       $entries[$name] = [
         'mode'   => $mode,
         'sha'    => $hash,
         'is_dir' => $mode === '40000' || $mode === '040000'
       ];
       $pos = $null + 21;
+    }
     return $entries;
+  }
   private function createChange(
     string $type,
     string $path,
     string $oldSha,
     string $newSha
   ): array {
     $oldSize = $oldSha !== '' ? $this->git->getObjectSize( $oldSha ) : 0;
     $newSize = $newSha !== '' ? $this->git->getObjectSize( $newSha ) : 0;
     $result  = [];
     if( $oldSize > self::MAX_DIFF_SIZE || $newSize > self::MAX_DIFF_SIZE ) {
       $result = [
         'type'      => $type,
         'path'      => $path,
         'is_binary' => true,
         'hunks'     => []
       ];
     } else {
       $oldContent = $oldSha !== '' ? $this->git->read( $oldSha ) : '';
       $newContent = $newSha !== '' ? $this->git->read( $newSha ) : '';
       $vDiffOld   = new VirtualDiffFile( $path, $oldContent );
       $vDiffNew   = new VirtualDiffFile( $path, $newContent );
       $isBinary = ($newSha !== '' && $vDiffNew->isBinary()) ||
                   ($newSha === '' && $oldSha !== '' && $vDiffOld->isBinary());
       $result = [
         'type'      => $type,
         'path'      => $path,
         'is_binary' => $isBinary,
         'hunks'     => $isBinary
           ? null
           : $this->calculateDiff( $oldContent, $newContent )
       ];
+    }
     return $result;
+  }
   private function calculateDiff( string $old, string $new ): array {
     $oldLines = explode( "\n", str_replace( "\r\n", "\n", $old ) );
     $newLines = explode( "\n", str_replace( "\r\n", "\n", $new ) );
     $m        = count( $oldLines );
     $n        = count( $newLines );
     $start    = 0;
     $end      = 0;
     while( $start < $m && $start < $n &&
            $oldLines[$start] === $newLines[$start] ) {
       $start++;
+    }
     while( $m - $end > $start && $n - $end > $start &&
            $oldLines[$m - 1 - $end] === $newLines[$n - 1 - $end] ) {
       $end++;
+    }
     $context = 2;
     $limit   = 100000;
     $stream  = [];
     $pStart = max( 0, $start - $context );
     for( $i = $pStart; $i < $start; $i++ ) {
       $stream[] = [
         't'  => ' ',
         'l'  => $oldLines[$i],
         'no' => $i + 1,
         'nn' => $i + 1
       ];
+    }
     $oldSlice = array_slice( $oldLines, $start, $m - $start - $end );
     $newSlice = array_slice( $newLines, $start, $n - $start - $end );
     $mid      = [];
     if( (count( $oldSlice ) * count( $newSlice )) > $limit ) {
       $mid = $this->buildFallbackDiff( $oldSlice, $newSlice, $start );
     } else {
       $ops = $this->computeLCS( $oldSlice, $newSlice );
       $mid = $this->buildDiffStream( $ops, $start );
+    }
     foreach( $mid as $line ) {
       $stream[] = $line;
+    }
     $sLimit = min( $end, $context );
     for( $i = 0; $i < $sLimit; $i++ ) {
       $idxO = $m - $end + $i;
       $idxN = $n - $end + $i;
       $stream[] = [
         't'  => ' ',
         'l'  => $oldLines[$idxO],
         'no' => $idxO + 1,
         'nn' => $idxN + 1
       ];
+    }
     return $this->formatDiffOutput( $stream );
+  }
   private function formatDiffOutput( array $stream ): array {
     $n       = count( $stream );
     $keep    = array_fill( 0, $n, false );
     $context = 2;
     for( $i = 0; $i < $n; $i++ ) {
       if( $stream[$i]['t'] !== ' ' ) {
         $low  = max( 0, $i - $context );
         $high = min( $n - 1, $i + $context );
         for( $j = $low; $j <= $high; $j++ ) {
           $keep[$j] = true;
+        }
+      }
+    }
     $result = [];
     $buffer = [];
     for( $i = 0; $i < $n; $i++ ) {
       if( $keep[$i] ) {
         $cnt = count( $buffer );
         if( $cnt > 0 ) {
           if( $cnt > 5 ) {
             $result[] = [ 't' => 'gap' ];
           } else {
             foreach( $buffer as $bufLine ) {
               $result[] = $bufLine;
+            }
+          }
           $buffer = [];
+        }
         $result[] = $stream[$i];
       } else {
         $buffer[] = $stream[$i];
+      }
+    }
     $cnt = count( $buffer );
     if( $cnt > 0 ) {
       if( $cnt > 5 ) {
         $result[] = [ 't' => 'gap' ];
       } else {
         foreach( $buffer as $bufLine ) {
           $result[] = $bufLine;
+        }
+      }
+    }
     return $result;
+  }
   private function buildFallbackDiff(
     array $old,
     array $new,
     int $offset
   ): array {
     $stream = [];
     $currO  = $offset + 1;
     $currN  = $offset + 1;
     foreach( $old as $line ) {
       $stream[] = [
         't'  => '-',
         'l'  => $line,
         'no' => $currO++,
         'nn' => null
       ];
+    }
     foreach( $new as $line ) {
       $stream[] = [
         't'  => '+',
         'l'  => $line,
         'no' => null,
         'nn' => $currN++
       ];
+    }
     return $stream;
+  }
   private function buildDiffStream( array $ops, int $start ): array {
     $stream = [];
     $currO  = $start + 1;
     $currN  = $start + 1;
     foreach( $ops as $op ) {
       $stream[] = [
         't'  => $op['t'],
         'l'  => $op['l'],
         'no' => $op['t'] === '+' ? null : $currO++,
         'nn' => $op['t'] === '-' ? null : $currN++
       ];
+    }
     return $stream;
+  }
   private function computeLCS( array $old, array $new ): array {
     $m = count( $old );
     $n = count( $new );
     $c = array_fill( 0, $m + 1, array_fill( 0, $n + 1, 0 ) );
     for( $i = 1; $i <= $m; $i++ ) {
       for( $j = 1; $j <= $n; $j++ ) {
         $c[$i][$j] = ($old[$i - 1] === $new[$j - 1])
           ? $c[$i - 1][$j - 1] + 1
           : max( $c[$i][$j - 1], $c[$i - 1][$j] );
+      }
+    }
     $diff = [];
     $i    = $m;
     $j    = $n;
     while( $i > 0 || $j > 0 ) {
       if( $i > 0 && $j > 0 && $old[$i - 1] === $new[$j - 1] ) {
         $diff[] = [ 't' => ' ', 'l' => $old[$i - 1] ];
         $i--;
         $j--;
       } elseif( $j > 0 && ($i === 0 || $c[$i][$j - 1] >= $c[$i - 1][$j]) ) {
         $diff[] = [ 't' => '+', 'l' => $new[$j - 1] ];
         $j--;
       } elseif( $i > 0 && ($j === 0 || $c[$i][$j - 1] < $c[$i - 1][$j]) ) {
         $diff[] = [ 't' => '-', 'l' => $old[$i - 1] ];
         $i--;
+      }
+    }
     return array_reverse( $diff );
+  }
+}

M git/GitPacks.php

 <?php
 class GitPacks {
   private const MAX_READ = 1040576;
   private const MAX_RAM = 1048576;
   private string $objectsPath;
   private array $packFiles;
   private ?string $lastPack = null;
   private array $fileHandles       = [];
   private array $fanoutCache       = [];
   private array $shaBucketCache    = [];
   private array $offsetBucketCache = [];
   public function __construct( string $objectsPath ) {
     $this->objectsPath = $objectsPath;
     $this->packFiles   = glob( "{$this->objectsPath}/pack/*.idx" ) ?: [];
+  }
   public function __destruct() {
     foreach( $this->fileHandles as $handle ) {
       if( is_resource( $handle ) ) {
         fclose( $handle );
+      }
+    }
+  }
   public function peek( string $sha, int $len = 12 ): ?string {
     $info = $this->findPackInfo( $sha );
     if( $info['offset'] === -1 ) {
       return null;
+    }
     $handle = $this->getHandle( $info['file'] );
     if( !$handle ) {
       return null;
+    }
     return $this->readPackEntry( $handle, $info['offset'], $len, $len );
+  }
   public function read( string $sha ): ?string {
     $info = $this->findPackInfo( $sha );
     if( $info['offset'] === -1 ) {
       return null;
+    }
     $size = $this->extractPackedSize( $info['file'], $info['offset'] );
     if( $size > self::MAX_RAM ) {
       return null;
+    }
     $handle = $this->getHandle( $info['file'] );
     return $handle
       ? $this->readPackEntry( $handle, $info['offset'], $size )
       : null;
+  }
   public function stream( string $sha, callable $callback ): bool {
     $info = $this->findPackInfo( $sha );
     if( $info['offset'] === -1 ) {
       return false;
+    }
     $size   = $this->extractPackedSize( $info['file'], $info['offset'] );
     $handle = $this->getHandle( $info['file'] );
     if( !$handle ) {
       return false;
+    }
     return $this->streamPackEntry(
       $handle,
       $info['offset'],
       $size,
       $callback
     );
+  }
   public function getSize( string $sha ): ?int {
     $info = $this->findPackInfo( $sha );
     if( $info['offset'] === -1 ) {
       return null;
+    }
     return $this->extractPackedSize( $info['file'], $info['offset'] );
+  }
   private function findPackInfo( string $sha ): array {
     if( !ctype_xdigit( $sha ) || strlen( $sha ) !== 40 ) {
       return ['offset' => -1];
+    }
     $binarySha = hex2bin( $sha );
     if( $this->lastPack ) {
       $offset = $this->findInIdx( $this->lastPack, $binarySha );
       if( $offset !== -1 ) {
         return $this->makeResult( $this->lastPack, $offset );
+      }
+    }
     foreach( $this->packFiles as $indexFile ) {
       if( $indexFile === $this->lastPack ) {
         continue;
+      }
       $offset = $this->findInIdx( $indexFile, $binarySha );
       if( $offset !== -1 ) {
         $this->lastPack = $indexFile;
         return $this->makeResult( $indexFile, $offset );
+      }
+    }
     return ['offset' => -1];
+  }
   private function makeResult( string $indexPath, int $offset ): array {
     return [
       'file'   => str_replace( '.idx', '.pack', $indexPath ),
       'offset' => $offset
     ];
+  }
   private function findInIdx( string $indexFile, string $binarySha ): int {
     $fileHandle = $this->getHandle( $indexFile );
     if( !$fileHandle ) {
       return -1;
+    }
     if( !isset( $this->fanoutCache[$indexFile] ) ) {
       fseek( $fileHandle, 0 );
       if( fread( $fileHandle, 8 ) === "\377tOc\0\0\0\2" ) {
         $this->fanoutCache[$indexFile] = array_values(
           unpack( 'N*', fread( $fileHandle, 1024 ) )
         );
       } else {
         return -1;
+      }
+    }
     $fanout = $this->fanoutCache[$indexFile];
     $firstByte = ord( $binarySha[0] );
     $start     = $firstByte === 0 ? 0 : $fanout[$firstByte - 1];
     $end       = $fanout[$firstByte];
     if( $end <= $start ) {
       return -1;
+    }
     $cacheKey = "$indexFile:$firstByte";
     if( !isset( $this->shaBucketCache[$cacheKey] ) ) {
       $count = $end - $start;
       fseek( $fileHandle, 1032 + ($start * 20) );
       $this->shaBucketCache[$cacheKey] = fread( $fileHandle, $count * 20 );
       fseek(
         $fileHandle,
 + ($fanout[255] * 24) + ($start * 4)
       );
       $this->offsetBucketCache[$cacheKey] = fread( $fileHandle, $count * 4 );
+    }
     $shaBlock = $this->shaBucketCache[$cacheKey];
     $count    = strlen( $shaBlock ) / 20;
     $low      = 0;
     $high     = $count - 1;
     $foundIdx = -1;
     while( $low <= $high ) {
       $mid     = ($low + $high) >> 1;
       $compare = substr( $shaBlock, $mid * 20, 20 );
       if( $compare < $binarySha ) {
         $low = $mid + 1;
       } elseif( $compare > $binarySha ) {
         $high = $mid - 1;
       } else {
         $foundIdx = $mid;
         break;
+      }
+    }
     if( $foundIdx === -1 ) {
       return -1;
+    }
     $offsetData = substr(
       $this->offsetBucketCache[$cacheKey],
       $foundIdx * 4,
     );
     $offset = unpack( 'N', $offsetData )[1];
     if( $offset & 0x80000000 ) {
       $packTotal = $fanout[255];
       $pos64     = 1032 + ($packTotal * 28) +
                    (($offset & 0x7FFFFFFF) * 8);
       fseek( $fileHandle, $pos64 );
       $offset = unpack( 'J', fread( $fileHandle, 8 ) )[1];
+    }
     return (int)$offset;
+  }
   private function readPackEntry(
     $fileHandle,
     int $offset,
     int $expectedSize,
     int $cap = 0
   ): string {
     fseek( $fileHandle, $offset );
     $header = $this->readVarInt( $fileHandle );
     $type   = ($header['byte'] >> 4) & 7;
     if( $type === 6 ) {
       return $this->handleOfsDelta(
         $fileHandle,
         $offset,
         $expectedSize,
         $cap
       );
+    }
     if( $type === 7 ) {
       return $this->handleRefDelta( $fileHandle, $expectedSize, $cap );
+    }
     return $this->decompressToString( $fileHandle, $expectedSize, $cap );
+  }
   private function streamPackEntry(
     $fileHandle,
     int $offset,
     int $expectedSize,
     callable $callback
   ): bool {
     fseek( $fileHandle, $offset );
     $header = $this->readVarInt( $fileHandle );
     $type   = ($header['byte'] >> 4) & 7;
     if( $type === 6 || $type === 7 ) {
       return $this->streamDeltaObject(
         $fileHandle,
         $offset,
         $type,
         $expectedSize,
         $callback
       );
+    }
     return $this->streamDecompression( $fileHandle, $callback );
+  }
   private function streamDeltaObject(
     $fileHandle,
     int $offset,
     int $type,
     int $expectedSize,
     callable $callback
   ): bool {
     fseek( $fileHandle, $offset );
     $this->readVarInt( $fileHandle );
     if( $type === 6 ) {
       $byte     = ord( fread( $fileHandle, 1 ) );
       $negative = $byte & 127;
       while( $byte & 128 ) {
         $byte     = ord( fread( $fileHandle, 1 ) );
         $negative = (($negative + 1) << 7) | ($byte & 127);
+      }
       $deltaPos   = ftell( $fileHandle );
       $baseOffset = $offset - $negative;
       $base = '';
       $this->streamPackEntry(
         $fileHandle,
         $baseOffset,
 ,
         function( $chunk ) use ( &$base ) { $base .= $chunk; }
       );
       fseek( $fileHandle, $deltaPos );
     } else {
       $baseSha = bin2hex( fread( $fileHandle, 20 ) );
       $base     = '';
       $streamed = $this->stream(
         $baseSha,
         function( $chunk ) use ( &$base ) { $base .= $chunk; }
       );
       if( !$streamed ) {
         return false;
+      }
+    }
     $inflator = inflate_init( ZLIB_ENCODING_DEFLATE );
     if( $inflator === false ) {
       return false;
+    }
     // 0: source size, 1: target size, 2: opcodes
     $headerState = 0;
     $buffer      = '';
     while( !feof( $fileHandle ) ) {
       // Read small chunks to prevent memory spikes
       $chunk = fread( $fileHandle, 8192 );
       if( $chunk === false || $chunk === '' ) {
         break;
+      }
       $data = @inflate_add( $inflator, $chunk );
       if( $data === false ) {
         break;
+      }
       $buffer .= $data;
       // Process the buffer
       while( true ) {
         $bufLen = strlen( $buffer );
         if( $bufLen === 0 ) {
           break;
+        }
         if( $headerState < 2 ) {
           $pos = 0;
           while( $pos < $bufLen && (ord( $buffer[$pos] ) & 128) ) {
             $pos++;
+          }
           if( $pos === $bufLen && (ord( $buffer[$pos - 1] ) & 128) ) {
             break;
+          }
           $pos++;
           $buffer = substr( $buffer, $pos );
           $headerState++;
           continue;
+        }
         $opcode = ord( $buffer[0] );
         if( $opcode & 128 ) {
           $needed = 1;
           if( $opcode & 0x01 ) { $needed++; }
           if( $opcode & 0x02 ) { $needed++; }
           if( $opcode & 0x04 ) { $needed++; }
           if( $opcode & 0x08 ) { $needed++; }
           if( $opcode & 0x10 ) { $needed++; }
           if( $opcode & 0x20 ) { $needed++; }
           if( $opcode & 0x40 ) { $needed++; }
           if( $bufLen < $needed ) {
             break;
+          }
           $off = 0;
           $len = 0;
           $p   = 1;
           if( $opcode & 0x01 ) { $off |= ord( $buffer[$p++] ); }
           if( $opcode & 0x02 ) { $off |= ord( $buffer[$p++] ) << 8; }
           if( $opcode & 0x04 ) { $off |= ord( $buffer[$p++] ) << 16; }
           if( $opcode & 0x08 ) { $off |= ord( $buffer[$p++] ) << 24; }
           if( $opcode & 0x10 ) { $len |= ord( $buffer[$p++] ); }
           if( $opcode & 0x20 ) { $len |= ord( $buffer[$p++] ) << 8; }
           if( $opcode & 0x40 ) { $len |= ord( $buffer[$p++] ) << 16; }
           if( $len === 0 ) { $len = 0x10000; }
           $callback( substr( $base, $off, $len ) );
           $buffer = substr( $buffer, $needed );
         } else {
           $len = $opcode & 127;
           if( $bufLen < 1 + $len ) {
             break;
+          }
           $callback( substr( $buffer, 1, $len ) );
           $buffer = substr( $buffer, 1 + $len );
+        }
+      }
       if( inflate_get_status( $inflator ) === ZLIB_STREAM_END ) {
         break;
+      }
+    }
     return true;
+  }
   private function streamDecompression(
     $fileHandle,
     callable $callback
   ): bool {
     $inflator = inflate_init( ZLIB_ENCODING_DEFLATE );
     if( $inflator === false ) {
       return false;
+    }
     while( !feof( $fileHandle ) ) {
       $chunk = fread( $fileHandle, 8192 );
       if( $chunk === false || $chunk === '' ) {
         break;
+      }
       $data = @inflate_add( $inflator, $chunk );
       if( $data !== false && $data !== '' ) {
         $callback( $data );
+      }
       if(
         $data === false ||
         inflate_get_status( $inflator ) === ZLIB_STREAM_END
       ) {
         break;
+      }
+    }
     return true;
+  }
   private function decompressToString(
     $fileHandle,
     int $maxSize,
     int $cap = 0
   ): string {
     $inflator = inflate_init( ZLIB_ENCODING_DEFLATE );
     if( $inflator === false ) {
       return '';
+    }
     $result = '';
     while( !feof( $fileHandle ) ) {
       $chunk = fread( $fileHandle, 8192 );
       if( $chunk === false || $chunk === '' ) {
         break;
+      }
       $data = @inflate_add( $inflator, $chunk );
       if( $data !== false ) {
         $result .= $data;
+      }
       if( $cap > 0 && strlen( $result ) >= $cap ) {
         return substr( $result, 0, $cap );
+      }
       if(
         $data === false ||
         inflate_get_status( $inflator ) === ZLIB_STREAM_END
       ) {
         break;
+      }
+    }
     return $result;
+  }
   private function extractPackedSize( string $packPath, int $offset ): int {
     $fileHandle = $this->getHandle( $packPath );
     if( !$fileHandle ) {
       return 0;
+    }
     fseek( $fileHandle, $offset );
     $header = $this->readVarInt( $fileHandle );
     $size   = $header['value'];
     $type   = ($header['byte'] >> 4) & 7;
     if( $type === 6 || $type === 7 ) {
       return $this->readDeltaTargetSize( $fileHandle, $type );
+    }
     return $size;
+  }
   private function handleOfsDelta(
     $fileHandle,
     int $offset,
     int $expectedSize,
     int $cap = 0
   ): string {
     $byte     = ord( fread( $fileHandle, 1 ) );
     $negative = $byte & 127;
     while( $byte & 128 ) {
       $byte     = ord( fread( $fileHandle, 1 ) );
       $negative = (($negative + 1) << 7) | ($byte & 127);
+    }
     $currentPos = ftell( $fileHandle );
     $baseOffset = $offset - $negative;
     fseek( $fileHandle, $baseOffset );
     $baseHeader = $this->readVarInt( $fileHandle );
     $baseSize   = $baseHeader['value'];
     fseek( $fileHandle, $baseOffset );
     $base = $this->readPackEntry( $fileHandle, $baseOffset, $baseSize, $cap );
     fseek( $fileHandle, $currentPos );
     $remainingBytes = min( self::MAX_READ, max( $expectedSize * 2, 1048576 ) );
     $compressed     = fread( $fileHandle, $remainingBytes );
     $delta          = @gzuncompress( $compressed ) ?: '';
     return $this->applyDelta( $base, $delta, $cap );
+  }
   private function handleRefDelta(
     $fileHandle,
     int $expectedSize,
     int $cap = 0
   ): string {
     $baseSha = bin2hex( fread( $fileHandle, 20 ) );
     if( $cap > 0 ) {
       $base = $this->peek( $baseSha, $cap ) ?? '';
     } else {
       $base = $this->read( $baseSha ) ?? '';
+    }
     $remainingBytes = min( self::MAX_READ, max( $expectedSize * 2, 1048576 ) );
     $compressed     = fread( $fileHandle, $remainingBytes );
     $delta          = @gzuncompress( $compressed ) ?: '';
     return $this->applyDelta( $base, $delta, $cap );
+  }
   private function applyDelta( string $base, string $delta, int $cap = 0 ): string {
     $position = 0;
     $this->skipSize( $delta, $position );
     $this->skipSize( $delta, $position );
     $output      = '';
     $deltaLength = strlen( $delta );
     while( $position < $deltaLength ) {
       if( $cap > 0 && strlen( $output ) >= $cap ) {
         break;
+      }
       $opcode = ord( $delta[$position++] );
       if( $opcode & 128 ) {
         $offset = 0;
         $length = 0;
         if( $opcode & 0x01 ) { $offset |= ord( $delta[$position++] ); }
         if( $opcode & 0x02 ) { $offset |= ord( $delta[$position++] ) << 8; }
         if( $opcode & 0x04 ) { $offset |= ord( $delta[$position++] ) << 16; }
         if( $opcode & 0x08 ) { $offset |= ord( $delta[$position++] ) << 24; }
         if( $opcode & 0x10 ) { $length |= ord( $delta[$position++] ); }
         if( $opcode & 0x20 ) { $length |= ord( $delta[$position++] ) << 8; }
         if( $opcode & 0x40 ) { $length |= ord( $delta[$position++] ) << 16; }
         if( $length === 0 ) { $length = 0x10000; }
         $output .= substr( $base, $offset, $length );
       } else {
         $length = $opcode & 127;
         $output .= substr( $delta, $position, $length );
         $position += $length;
+      }
+    }
     return $output;
+  }
   private function readVarInt( $fileHandle ): array {
     $byte  = ord( fread( $fileHandle, 1 ) );
     $value = $byte & 15;
     $shift = 4;
     $first = $byte;
     while( $byte & 128 ) {
       $byte  = ord( fread( $fileHandle, 1 ) );
       $value |= (($byte & 127) << $shift);
       $shift += 7;
+    }
     return ['value' => $value, 'byte' => $first];
+  }
   private function readDeltaTargetSize( $fileHandle, int $type ): int {
     if( $type === 6 ) {
       $byte = ord( fread( $fileHandle, 1 ) );
       while( $byte & 128 ) {
         $byte = ord( fread( $fileHandle, 1 ) );
+      }
     } else {
       fseek( $fileHandle, 20, SEEK_CUR );
+    }
     $inflator = inflate_init( ZLIB_ENCODING_DEFLATE );
     if( $inflator === false ) {
       return 0;
+    }
     $header      = '';
     $attempts    = 0;
     $maxAttempts = 64;
     while(
       !feof( $fileHandle ) &&
       strlen( $header ) < 32 &&
       $attempts < $maxAttempts
     ) {
       $chunk = fread( $fileHandle, 512 );
       if( $chunk === false || $chunk === '' ) {
         break;
+      }
       $output = @inflate_add( $inflator, $chunk, ZLIB_NO_FLUSH );
       if( $output !== false ) {
         $header .= $output;
+      }
       if( inflate_get_status( $inflator ) === ZLIB_STREAM_END ) {
         break;
+      }
       $attempts++;
+    }
     $position = 0;
     if( strlen( $header ) > 0 ) {
       $this->skipSize( $header, $position );
       return $this->readSize( $header, $position );
+    }
     return 0;
+  }
   private function skipSize( string $data, int &$position ): void {
     $length = strlen( $data );
     while( $position < $length && (ord( $data[$position++] ) & 128) ) {
+    }
+  }
   private function readSize( string $data, int &$position ): int {
     $byte  = ord( $data[$position++] );
     $value = $byte & 127;
     $shift = 7;
     while( $byte & 128 ) {
       $byte  = ord( $data[$position++] );
       $value |= (($byte & 127) << $shift);
       $shift += 7;
+    }
     return $value;
   private const MAX_READ     = 1040576;
   private const MAX_RAM      = 1048576;
   private const MAX_BASE_RAM = 524288;
   private const MAX_DEPTH    = 50;
   private string $objectsPath;
   private array  $packFiles;
   private string $lastPack = '';
   private array  $fileHandles;
   private array  $fanoutCache;
   private array  $shaBucketCache;
   private array  $offsetBucketCache;
   public function __construct( string $objectsPath ) {
     $this->objectsPath       = $objectsPath;
     $this->packFiles         = glob( "{$this->objectsPath}/pack/*.idx" ) ?: [];
     $this->fileHandles       = [];
     $this->fanoutCache       = [];
     $this->shaBucketCache    = [];
     $this->offsetBucketCache = [];
+  }
   public function __destruct() {
     foreach( $this->fileHandles as $handle ) {
       if( is_resource( $handle ) ) {
         fclose( $handle );
+      }
+    }
+  }
   public function peek( string $sha, int $len = 12 ): string {
     $info   = $this->findPackInfo( $sha );
     $result = '';
     if( $info['offset'] !== 0 ) {
       $handle = $this->getHandle( $info['file'] );
       if( $handle ) {
         $result = $this->readPackEntry(
           $handle,
           $info['offset'],
           $len,
           $len
         );
+      }
+    }
     return $result;
+  }
   public function read( string $sha ): string {
     $info   = $this->findPackInfo( $sha );
     $result = '';
     if( $info['offset'] !== 0 ) {
       $size = $this->extractPackedSize( $info['file'], $info['offset'] );
       if( $size <= self::MAX_RAM ) {
         $handle = $this->getHandle( $info['file'] );
         if( $handle ) {
           $result = $this->readPackEntry(
             $handle,
             $info['offset'],
             $size
           );
+        }
+      }
+    }
     return $result;
+  }
   public function stream( string $sha, callable $callback ): bool {
     return $this->streamInternal( $sha, $callback, 0 );
+  }
   private function streamInternal(
     string $sha,
     callable $callback,
     int $depth
   ): bool {
     $info   = $this->findPackInfo( $sha );
     $result = false;
     if( $info['offset'] !== 0 ) {
       $size   = $this->extractPackedSize( $info['file'], $info['offset'] );
       $handle = $this->getHandle( $info['file'] );
       if( $handle ) {
         $result = $this->streamPackEntry(
           $handle,
           $info['offset'],
           $size,
           $callback,
           $depth
         );
+      }
+    }
     return $result;
+  }
   public function getSize( string $sha ): int {
     $info   = $this->findPackInfo( $sha );
     $result = 0;
     if( $info['offset'] !== 0 ) {
       $result = $this->extractPackedSize( $info['file'], $info['offset'] );
+    }
     return $result;
+  }
   private function findPackInfo( string $sha ): array {
     $result = [ 'offset' => 0, 'file' => '' ];
     if( strlen( $sha ) === 40 && ctype_xdigit( $sha ) ) {
       $binarySha = hex2bin( $sha );
       if( $this->lastPack !== '' ) {
         $offset = $this->findInIdx( $this->lastPack, $binarySha );
         if( $offset !== 0 ) {
           $result = [
             'file'   => str_replace( '.idx', '.pack', $this->lastPack ),
             'offset' => $offset
           ];
+        }
+      }
       if( $result['offset'] === 0 ) {
         foreach( $this->packFiles as $indexFile ) {
           if( $indexFile !== $this->lastPack ) {
             $offset = $this->findInIdx( $indexFile, $binarySha );
             if( $offset !== 0 ) {
               $this->lastPack = $indexFile;
               $result         = [
                 'file'   => str_replace( '.idx', '.pack', $indexFile ),
                 'offset' => $offset
               ];
               break;
+            }
+          }
+        }
+      }
+    }
     return $result;
+  }
   private function findInIdx( string $indexFile, string $binarySha ): int {
     $handle = $this->getHandle( $indexFile );
     $result = 0;
     if( $handle ) {
       if( !isset( $this->fanoutCache[$indexFile] ) ) {
         fseek( $handle, 0 );
         $head = fread( $handle, 8 );
         if( $head === "\377tOc\0\0\0\2" ) {
           $this->fanoutCache[$indexFile] = array_values(
             unpack( 'N*', fread( $handle, 1024 ) )
           );
+        }
+      }
       if( isset( $this->fanoutCache[$indexFile] ) ) {
         $fanout = $this->fanoutCache[$indexFile];
         $byte   = ord( $binarySha[0] );
         $start  = $byte === 0 ? 0 : $fanout[$byte - 1];
         $end    = $fanout[$byte];
         if( $end > $start ) {
           $result = $this->binarySearchIdx(
             $indexFile,
             $handle,
             $start,
             $end,
             $binarySha,
             $fanout[255]
           );
+        }
+      }
+    }
     return $result;
+  }
   private function binarySearchIdx(
     string $indexFile,
     $handle,
     int $start,
     int $end,
     string $binarySha,
     int $total
   ): int {
     $key    = "$indexFile:$start";
     $count  = $end - $start;
     $result = 0;
     if( !isset( $this->shaBucketCache[$key] ) ) {
       fseek( $handle, 1032 + ($start * 20) );
       $this->shaBucketCache[$key] = fread( $handle, $count * 20 );
       fseek( $handle, 1032 + ($total * 24) + ($start * 4) );
       $this->offsetBucketCache[$key] = fread( $handle, $count * 4 );
+    }
     $shaBlock = $this->shaBucketCache[$key];
     $low      = 0;
     $high     = $count - 1;
     $found    = -1;
     while( $low <= $high ) {
       $mid = ($low + $high) >> 1;
       $cmp = substr( $shaBlock, $mid * 20, 20 );
       if( $cmp < $binarySha ) {
         $low = $mid + 1;
       } elseif( $cmp > $binarySha ) {
         $high = $mid - 1;
       } else {
         $found = $mid;
         break;
+      }
+    }
     if( $found !== -1 ) {
       $packed = substr( $this->offsetBucketCache[$key], $found * 4, 4 );
       $offset = unpack( 'N', $packed )[1];
       if( $offset & 0x80000000 ) {
         $pos64 = 1032 + ($total * 28) + (($offset & 0x7FFFFFFF) * 8);
         fseek( $handle, $pos64 );
         $offset = unpack( 'J', fread( $handle, 8 ) )[1];
+      }
       $result = (int)$offset;
+    }
     return $result;
+  }
   private function readPackEntry(
     $handle,
     int $offset,
     int $size,
     int $cap = 0
   ): string {
     fseek( $handle, $offset );
     $header = $this->readVarInt( $handle );
     $type   = ($header['byte'] >> 4) & 7;
     return ($type === 6)
       ? $this->handleOfsDelta( $handle, $offset, $size, $cap )
       : (($type === 7)
         ? $this->handleRefDelta( $handle, $size, $cap )
         : $this->decompressToString( $handle, $cap ));
+  }
   private function streamPackEntry(
     $handle,
     int $offset,
     int $size,
     callable $callback,
     int $depth = 0
   ): bool {
     fseek( $handle, $offset );
     $header = $this->readVarInt( $handle );
     $type   = ($header['byte'] >> 4) & 7;
     return ($type === 6 || $type === 7)
       ? $this->streamDeltaObject( $handle, $offset, $type, $callback, $depth )
       : $this->streamDecompression( $handle, $callback );
+  }
   private function streamDeltaObject(
     $handle,
     int $offset,
     int $type,
     callable $callback,
     int $depth = 0
   ): bool {
     if( $depth >= self::MAX_DEPTH ) {
       return false;
+    }
     fseek( $handle, $offset );
     $this->readVarInt( $handle );
     $result = false;
     if( $type === 6 ) {
       $neg      = $this->readOffsetDelta( $handle );
       $deltaPos = ftell( $handle );
       $base     = '';
       $baseSize = $this->extractPackedSize( $handle, $offset - $neg );
       if( $baseSize > self::MAX_BASE_RAM ) {
         return false;
+      }
       $this->streamPackEntry(
         $handle,
         $offset - $neg,
 ,
         function( $c ) use ( &$base ) { $base .= $c; },
         $depth + 1
       );
       fseek( $handle, $deltaPos );
       $result = $this->applyDeltaStream( $handle, $base, $callback );
     } else {
       $baseSha  = bin2hex( fread( $handle, 20 ) );
       $baseSize = $this->getSize( $baseSha );
       if( $baseSize > self::MAX_BASE_RAM ) {
         return false;
+      }
       $base = '';
       if( $this->streamInternal( $baseSha, function( $c ) use ( &$base ) {
         $base .= $c;
       }, $depth + 1 ) ) {
         $result = $this->applyDeltaStream( $handle, $base, $callback );
+      }
+    }
     return $result;
+  }
   private function applyDeltaStream(
     $handle,
     string $base,
     callable $callback
   ): bool {
     $infl = inflate_init( ZLIB_ENCODING_DEFLATE );
     $ok   = false;
     if( $infl ) {
       $state  = 0;
       $buffer = '';
       $ok     = true;
       while( !feof( $handle ) ) {
         $chunk = fread( $handle, 8192 );
         if( $chunk === '' ) {
           break;
+        }
         $data = @inflate_add( $infl, $chunk );
         if( $data === false ) {
           $ok = false;
           break;
+        }
         $buffer .= $data;
         while( true ) {
           $len = strlen( $buffer );
           if( $len === 0 ) {
             break;
+          }
           if( $state < 2 ) {
             $pos = 0;
             while( $pos < $len && (ord( $buffer[$pos] ) & 128) ) { $pos++; }
             if( $pos === $len && (ord( $buffer[$pos - 1] ) & 128) ) {
               break;
+            }
             $buffer = substr( $buffer, $pos + 1 );
             $state++;
             continue;
+          }
           $op = ord( $buffer[0] );
           if( $op & 128 ) {
             $need = $this->getCopyInstructionSize( $op );
             if( $len < 1 + $need ) {
               break;
+            }
             $info = $this->parseCopyInstruction( $op, $buffer, 1 );
             $callback( substr( $base, $info['off'], $info['len'] ) );
             $buffer = substr( $buffer, 1 + $need );
           } else {
             $ln = $op & 127;
             if( $len < 1 + $ln ) {
               break;
+            }
             $callback( substr( $buffer, 1, $ln ) );
             $buffer = substr( $buffer, 1 + $ln );
+          }
+        }
         if( inflate_get_status( $infl ) === ZLIB_STREAM_END ) {
           break;
+        }
+      }
+    }
     return $ok;
+  }
   private function streamDecompression( $handle, callable $callback ): bool {
     $infl = inflate_init( ZLIB_ENCODING_DEFLATE );
     if( !$infl ) {
       return false;
+    }
     while( !feof( $handle ) ) {
       $chunk = fread( $handle, 8192 );
       if( $chunk === '' ) {
         break;
+      }
       $data = @inflate_add( $infl, $chunk );
       if( $data !== false && $data !== '' ) {
         $callback( $data );
+      }
       if( $data === false ||
           inflate_get_status( $infl ) === ZLIB_STREAM_END ) {
         break;
+      }
+    }
     return true;
+  }
   private function decompressToString(
     $handle,
     int $cap = 0
   ): string {
     $infl = inflate_init( ZLIB_ENCODING_DEFLATE );
     $res  = '';
     if( $infl ) {
       while( !feof( $handle ) ) {
         $chunk = fread( $handle, 8192 );
         if( $chunk === '' ) {
           break;
+        }
         $data = @inflate_add( $infl, $chunk );
         if( $data !== false ) {
           $res .= $data;
+        }
         if( $cap > 0 && strlen( $res ) >= $cap ) {
           $res = substr( $res, 0, $cap );
           break;
+        }
         if( $data === false ||
             inflate_get_status( $infl ) === ZLIB_STREAM_END ) {
           break;
+        }
+      }
+    }
     return $res;
+  }
   private function extractPackedSize( $packPathOrHandle, int $offset ): int {
     $handle = is_resource( $packPathOrHandle )
       ? $packPathOrHandle
       : $this->getHandle( $packPathOrHandle );
     $size   = 0;
     if( $handle ) {
       fseek( $handle, $offset );
       $header = $this->readVarInt( $handle );
       $size   = $header['value'];
       $type   = ($header['byte'] >> 4) & 7;
       if( $type === 6 || $type === 7 ) {
         $size = $this->readDeltaTargetSize( $handle, $type );
+      }
+    }
     return $size;
+  }
   private function handleOfsDelta(
     $handle,
     int $offset,
     int $size,
     int $cap
   ): string {
     $neg  = $this->readOffsetDelta( $handle );
     $cur  = ftell( $handle );
     $base = $offset - $neg;
     fseek( $handle, $base );
     $bHead = $this->readVarInt( $handle );
     fseek( $handle, $base );
     $bData = $this->readPackEntry( $handle, $base, $bHead['value'], $cap );
     fseek( $handle, $cur );
     $rem   = min( self::MAX_READ, max( $size * 2, 1048576 ) );
     $comp  = fread( $handle, $rem );
     $delta = @gzuncompress( $comp ) ?: '';
     return $this->applyDelta( $bData, $delta, $cap );
+  }
   private function handleRefDelta( $handle, int $size, int $cap ): string {
     $sha = bin2hex( fread( $handle, 20 ) );
     $bas = $cap > 0 ? $this->peek( $sha, $cap ) : $this->read( $sha );
     $rem = min( self::MAX_READ, max( $size * 2, 1048576 ) );
     $cmp = fread( $handle, $rem );
     $del = @gzuncompress( $cmp ) ?: '';
     return $this->applyDelta( $bas, $del, $cap );
+  }
   private function applyDelta( string $base, string $delta, int $cap ): string {
     $pos = 0;
     $res = $this->readDeltaSize( $delta, $pos );
     $pos += $res['used'];
     $res = $this->readDeltaSize( $delta, $pos );
     $pos += $res['used'];
     $out = '';
     $len = strlen( $delta );
     while( $pos < $len ) {
       if( $cap > 0 && strlen( $out ) >= $cap ) {
         break;
+      }
       $op = ord( $delta[$pos++] );
       if( $op & 128 ) {
         $info = $this->parseCopyInstruction( $op, $delta, $pos );
         $out .= substr( $base, $info['off'], $info['len'] );
         $pos += $info['used'];
       } else {
         $ln = $op & 127;
         $out .= substr( $delta, $pos, $ln );
         $pos += $ln;
+      }
+    }
     return $out;
+  }
   private function parseCopyInstruction(
     int $op,
     string $data,
     int $pos
   ): array {
     $off = 0;
     $len = 0;
     $ptr = $pos;
     if( $op & 0x01 ) { $off |= ord( $data[$ptr++] ); }
     if( $op & 0x02 ) { $off |= ord( $data[$ptr++] ) << 8; }
     if( $op & 0x04 ) { $off |= ord( $data[$ptr++] ) << 16; }
     if( $op & 0x08 ) { $off |= ord( $data[$ptr++] ) << 24; }
     if( $op & 0x10 ) { $len |= ord( $data[$ptr++] ); }
     if( $op & 0x20 ) { $len |= ord( $data[$ptr++] ) << 8; }
     if( $op & 0x40 ) { $len |= ord( $data[$ptr++] ) << 16; }
     return [
       'off'  => $off,
       'len'  => $len ?: 0x10000,
       'used' => $ptr - $pos
     ];
+  }
   private function getCopyInstructionSize( int $op ): int {
     $c = $op & 0x7F;
     $c = $c - (( $c >> 1 ) & 0x55);
     $c = (( $c >> 2 ) & 0x33) + ( $c & 0x33 );
     $c = (( $c >> 4 ) + $c) & 0x0F;
     return $c;
+  }
   private function readVarInt( $handle ): array {
     $byte = ord( fread( $handle, 1 ) );
     $val  = $byte & 15;
     $shft = 4;
     $fst  = $byte;
     while( $byte & 128 ) {
       $byte = ord( fread( $handle, 1 ) );
       $val |= (($byte & 127) << $shft);
       $shft += 7;
+    }
     return [ 'value' => $val, 'byte' => $fst ];
+  }
   private function readOffsetDelta( $handle ): int {
     $byte = ord( fread( $handle, 1 ) );
     $neg  = $byte & 127;
     while( $byte & 128 ) {
       $byte = ord( fread( $handle, 1 ) );
       $neg  = (($neg + 1) << 7) | ($byte & 127);
+    }
     return $neg;
+  }
   private function readDeltaTargetSize( $handle, int $type ): int {
     if( $type === 6 ) {
       $b = ord( fread( $handle, 1 ) );
       while( $b & 128 ) { $b = ord( fread( $handle, 1 ) ); }
     } else {
       fseek( $handle, 20, SEEK_CUR );
+    }
     $infl = inflate_init( ZLIB_ENCODING_DEFLATE );
     $head = '';
     $try  = 0;
     if( $infl ) {
       while( !feof( $handle ) && strlen( $head ) < 32 && $try < 64 ) {
         $chunk = fread( $handle, 512 );
         if( $chunk === '' ) {
           break;
+        }
         $out = @inflate_add( $infl, $chunk, ZLIB_NO_FLUSH );
         if( $out !== false ) {
           $head .= $out;
+        }
         if( inflate_get_status( $infl ) === ZLIB_STREAM_END ) {
           break;
+        }
         $try++;
+      }
+    }
     $pos = 0;
     if( strlen( $head ) > 0 ) {
       $res = $this->readDeltaSize( $head, $pos );
       $pos += $res['used'];
       $res = $this->readDeltaSize( $head, $pos );
       return $res['val'];
+    }
     return 0;
+  }
   private function readDeltaSize( string $data, int $pos ): array {
     $len   = strlen( $data );
     $val   = 0;
     $shift = 0;
     $start = $pos;
     while( $pos < $len ) {
       $byte = ord( $data[$pos++] );
       $val |= ($byte & 0x7F) << $shift;
       if( !($byte & 0x80) ) {
         break;
+      }
       $shift += 7;
+    }
     return [ 'val' => $val, 'used' => $pos - $start ];
+  }

M git/GitRefs.php

   public function resolve( string $input ): string {
     if( preg_match( '/^[0-9a-f]{40}$/', $input ) ) {
       return $input;
+    }
     $headFile = "{$this->repoPath}/HEAD";
     $result = '';
     if( $input === 'HEAD' && file_exists( $headFile ) ) {
       $head = trim( file_get_contents( $headFile ) );
     if( preg_match( '/^[0-9a-f]{40}$/', $input ) ) {
       $result = $input;
     } else {
       $headFile = "{$this->repoPath}/HEAD";
       return strpos( $head, 'ref: ' ) === 0
         ? $this->resolve( substr( $head, 5 ) )
         : $head;
       if( $input === 'HEAD' && file_exists( $headFile ) ) {
         $head = trim( file_get_contents( $headFile ) );
         $result = strpos( $head, 'ref: ' ) === 0
           ? $this->resolve( substr( $head, 5 ) )
           : $head;
       } else {
         $result = $this->resolveRef( $input );
+      }
+    }
     return $this->resolveRef( $input );
     return $result;
+  }
+      }
     );
     $found = [];
     foreach( ['main', 'master', 'trunk', 'develop'] as $try ) {
       if( isset( $branches[$try] ) ) {
         return ['name' => $try, 'hash' => $branches[$try]];
         $found = [ 'name' => $try, 'hash' => $branches[$try] ];
         break;
+      }
+    }
     $firstKey = array_key_first( $branches );
     if( empty( $found ) ) {
       $key = array_key_first( $branches );
       $found = $key
         ? [ 'name' => $key, 'hash' => $branches[$key] ]
         : [ 'name' => '', 'hash' => '' ];
+    }
     return $firstKey
       ? ['name' => $firstKey, 'hash' => $branches[$firstKey]]
       : ['name' => '', 'hash' => ''];
     return $found;
+  }
   public function scanRefs( string $prefix, callable $callback ): void {
     $dir = "{$this->repoPath}/$prefix";
     if( is_dir( $dir ) ) {
       $files = array_diff( scandir( $dir ), ['.', '..'] );
       foreach( $files as $file ) {
         $callback( $file, trim( file_get_contents( "$dir/$file" ) ) );
+      }
+    }
+  }
   private function resolveRef( string $input ): string {
     $paths = [$input, "refs/heads/$input", "refs/tags/$input"];
     $paths  = [$input, "refs/heads/$input", "refs/tags/$input"];
     $result = '';
     foreach( $paths as $ref ) {
       $path = "{$this->repoPath}/$ref";
       if( file_exists( $path ) ) {
         return trim( file_get_contents( $path ) );
         $result = trim( file_get_contents( $path ) );
         break;
+      }
+    }
     $packedPath = "{$this->repoPath}/packed-refs";
     if( $result === '' ) {
       $packedPath = "{$this->repoPath}/packed-refs";
       if( file_exists( $packedPath ) ) {
         $result = $this->findInPackedRefs( $packedPath, $input );
+      }
+    }
     return file_exists( $packedPath )
       ? $this->findInPackedRefs( $packedPath, $input )
       : '';
     return $result;
+  }
   private function findInPackedRefs( string $path, string $input ): string {
     $targets = [$input, "refs/heads/$input", "refs/tags/$input"];
     foreach( file( $path ) as $line ) {
       if( $line[0] === '#' || $line[0] === '^' ) {
         continue;
+      }
       $parts = explode( ' ', trim( $line ) );
     $lines   = file( $path );
     $result  = '';
       if( count( $parts ) >= 2 && in_array( $parts[1], $targets ) ) {
         return $parts[0];
     foreach( $lines as $line ) {
       if( $line[0] !== '#' && $line[0] !== '^' ) {
         $parts = explode( ' ', trim( $line ) );
         if( count( $parts ) >= 2 && in_array( $parts[1], $targets ) ) {
           $result = $parts[0];
           break;
+        }
+      }
+    }
     return '';
     return $result;
+  }
+}

A images/diff-gap.svg

 <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#8b949e">
   <path d="M12 2 L7 7 H10 V9 H14 V7 H17 Z" />
   <circle cx="8" cy="12" r="1.5" />
   <circle cx="12" cy="12" r="1.5" />
   <circle cx="16" cy="12" r="1.5" />
   <path d="M12 22 L7 17 H10 V15 H14 V17 H17 Z" />
 </svg>

M index.php

 require_once __DIR__ . '/Router.php';
 Config::init();
 $router = new Router( Config::getReposPath() );
 $page = $router->route();
 $config = new Config();
 $router = $config->createRouter();
 $page   = $router->route();
 $page->render();

M pages/BasePage.php

 abstract class BasePage implements Page {
   protected $repositories;
   protected $title;
   private $repositories;
   private $title;
   public function __construct( array $repositories ) {
   public function __construct( array $repositories, string $title = '' ) {
     $this->repositories = $repositories;
     $this->title        = $title;
+  }
   protected function renderLayout( $contentCallback, $currentRepo = null ) {
   protected function renderLayout(
     $contentCallback,
     array $currentRepo = []
   ) {
     $siteTitle = Config::SITE_TITLE;
     $pageTitle = $this->title
       ? ' - ' . htmlspecialchars( $this->title )
       : '';
     ?>
     <!DOCTYPE html>
     <html lang="en">
     <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title><?php
         echo Config::SITE_TITLE .
           ( $this->title ? ' - ' . htmlspecialchars( $this->title ) : '' );
       ?></title>
       <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
       <link rel="stylesheet" href="/styles/repo.css">
     </head>
     <body>
     <div class="container">
       <header>
         <h1><?php echo Config::SITE_TITLE; ?></h1>
         <nav class="nav">
           <a href="<?php echo (new UrlBuilder())->build(); ?>">Home</a>
           <?php if( $currentRepo ):
             $safeName = $currentRepo['safe_name'];
             ?>
             <a href="<?php echo (new UrlBuilder())->withRepo( $safeName )->withAction( 'tree' )->build(); ?>">Files</a>
             <a href="<?php echo (new UrlBuilder())->withRepo( $safeName )->withAction( 'commits' )->build(); ?>">Commits</a>
             <a href="<?php echo (new UrlBuilder())->withRepo( $safeName )->withAction( 'tags' )->build(); ?>">Tags</a>
           <?php endif; ?>
 <!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title><?php echo $siteTitle . $pageTitle; ?></title>
   <link rel="stylesheet"
     href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/7.0.1/css/all.min.css">
   <link rel="stylesheet" href="/styles/repo.css">
 </head>
 <body>
 <div class="container">
   <header>
     <h1><?php echo Config::SITE_TITLE; ?></h1>
           <?php if( $currentRepo ): ?>
           <div class="repo-selector">
             <label>Repository:</label>
             <select onchange="<?php echo (new UrlBuilder())->withSwitcher( 'this.value' )->build(); ?>">
               <?php foreach( $this->repositories as $r ): ?>
               <option value="<?php echo htmlspecialchars( $r['safe_name'] ); ?>"
                 <?php echo $r['safe_name'] === $currentRepo['safe_name'] ? 'selected' : ''; ?>>
                 <?php echo htmlspecialchars( $r['name'] ); ?>
               </option>
               <?php endforeach; ?>
             </select>
           </div>
           <?php endif; ?>
         </nav>
       </header>
     <?php if( $currentRepo ) { ?>
       <input type="checkbox" id="clone-toggle" class="clone-checkbox">
     <?php } ?>
       <?php call_user_func( $contentCallback ); ?>
     <nav class="nav">
       <a href="<?php echo (new UrlBuilder())->build(); ?>">Home</a>
       <?php if( $currentRepo ) { ?>
         <?php $safeName = $currentRepo['safe_name']; ?>
         <a href="<?php echo (new UrlBuilder())
           ->withRepo( $safeName )
           ->withAction( 'tree' )
           ->build(); ?>">Files</a>
         <a href="<?php echo (new UrlBuilder())
           ->withRepo( $safeName )
           ->withAction( 'commits' )
           ->build(); ?>">Commits</a>
         <a href="<?php echo (new UrlBuilder())
           ->withRepo( $safeName )
           ->withAction( 'tags' )
           ->build(); ?>">Tags</a>
     </div>
     </body>
     </html>
         <label for="clone-toggle" class="clone-link">Clone</label>
       <?php } ?>
       <?php if( $currentRepo ) { ?>
       <div class="repo-selector">
         <label>Repository:</label>
         <select onchange="<?php echo (new UrlBuilder())
           ->withSwitcher( 'this.value' )
           ->build(); ?>">
           <?php foreach( $this->repositories as $r ) { ?>
           <option
             value="<?php echo htmlspecialchars( $r['safe_name'] ); ?>"
             <?php
             echo $r['safe_name'] === $currentRepo['safe_name']
               ? 'selected'
               : '';
             ?>>
             <?php echo htmlspecialchars( $r['name'] ); ?>
           </option>
           <?php } ?>
         </select>
       </div>
       <?php } ?>
     </nav>
     <?php if( $currentRepo ) { ?>
       <div class="clone-region">
         <div class="clone-wrapper">
           <?php
             $cloneCmd = 'git clone https://repo.autonoma.ca/repo/' .
               $currentRepo['safe_name'] . '.git';
           ?>
           <span class="clone-sizer"><?php echo htmlspecialchars( $cloneCmd ); ?></span>
           <input type="text" class="clone-input" readonly
             value="<?php echo htmlspecialchars( $cloneCmd ); ?>">
         </div>
       </div>
     <?php } ?>
   </header>
   <?php call_user_func( $contentCallback ); ?>
 </div>
 </body>
 </html>
     <?php
+  }
   protected function renderBreadcrumbs( $repo, $trail = [] ) {
   protected function renderBreadcrumbs( array $repo, array $trail = [] ) {
     $repoUrl = (new UrlBuilder())->withRepo( $repo['safe_name'] )->build();

M pages/ClonePage.php

   public function __construct( Git $git, string $subPath ) {
     $this->git = $git;
     $this->git     = $git;
     $this->subPath = $subPath;
+  }
     header( 'Cache-Control: no-cache' );
     $input = file_get_contents( 'php://input' );
     $wants = [];
     $haves = [];
     $offset = 0;
     $input   = file_get_contents( 'php://input' );
     $wants   = [];
     $haves   = [];
     $offset  = 0;
     $isGzip  = isset( $_SERVER['HTTP_CONTENT_ENCODING'] ) &&
                $_SERVER['HTTP_CONTENT_ENCODING'] === 'gzip';
     if( $isGzip ) {
       $decoded = gzdecode( $input );
       if( is_string( $decoded ) ) {
         $input = $decoded;
+      }
+    }
     while( $offset < strlen( $input ) ) {
       $line = $this->readPacketLine( $input, $offset );
       $result = $this->readPacketLine( $input, $offset );
       $line   = $result[0];
       $next   = $result[1];
       if( $line === null || $line === 'done' ) {
       if( $next === $offset || $line === 'done' ) {
         break;
+      }
       $offset = $next;
       if( $line === '' ) {
   private function sendSidebandData( int $band, string $data ): void {
     $chunkSize = 65000;
     $len = strlen( $data );
     $len       = strlen( $data );
     for( $offset = 0; $offset < $len; $offset += $chunkSize ) {
       $chunk = substr( $data, $offset, $chunkSize );
       $this->packetWrite( chr( $band ) . $chunk );
+    }
+  }
   private function readPacketLine( string $input, int &$offset ): ?string {
     $line = null;
   private function readPacketLine( string $input, int $offset ): array {
     $line = '';
     $next = $offset;
     if( $offset + 4 <= strlen( $input ) ) {
       $lenHex = substr( $input, $offset, 4 );
       if( ctype_xdigit( $lenHex ) ) {
         $len = hexdec( $lenHex );
         $offset += 4;
         $valid = $len >= 4 && $offset + ( $len - 4 ) <= strlen( $input );
         $line = ($len === 0)
           ? ''
           : ($valid ? substr( $input, $offset, $len - 4 ) : null);
         $offset += ($len >= 4) ? ($len - 4) : 0;
         if( $len === 0 ) {
           $next = $offset + 4;
         } elseif( $len >= 4 ) {
           if( $offset + $len <= strlen( $input ) ) {
             $line = substr( $input, $offset + 4, $len - 4 );
             $next = $offset + $len;
+          }
+        }
+      }
+    }
     return $line;
     return [$line, $next];
+  }

M pages/CommitsPage.php

     string $hash
   ) {
     parent::__construct( $repositories );
     parent::__construct( $repositories, $currentRepo['name'] );
     $this->currentRepo = $currentRepo;
     $this->git = $git;
     $this->hash = $hash;
     $this->title = $currentRepo['name'];
     $this->git         = $git;
     $this->hash        = $hash;
+  }
   public function render() {
     $this->renderLayout( function() {
       $main = $this->git->getMainBranch();
       if( !$main ) {
         echo '<div class="empty-state"><h3>No branches</h3>' .
              '<p>Empty repository.</p></div>';
         return;
+      }
       } else {
         $this->renderBreadcrumbs( $this->currentRepo, ['Commits'] );
       $this->renderBreadcrumbs( $this->currentRepo, ['Commits'] );
         echo '<h2>Commit History <span class="branch-badge">' .
              htmlspecialchars( $main['name'] ) . '</span></h2>';
         echo '<div class="commit-list">';
       echo '<h2>Commit History <span class="branch-badge">' .
            htmlspecialchars( $main['name'] ) . '</span></h2>';
       echo '<div class="commit-list">';
         $start = $this->hash ?: $main['hash'];
       $start = $this->hash ?: $main['hash'];
         $this->git->history( $start, 100, function( $commit ) {
           $msg = htmlspecialchars( explode( "\n", $commit->message )[0] );
       $this->git->history( $start, 100, function( $commit ) {
         $msg = htmlspecialchars( explode( "\n", $commit->message )[0] );
           $url = (new UrlBuilder())
             ->withRepo( $this->currentRepo['safe_name'] )
             ->withAction( 'commit' )
             ->withHash( $commit->sha )
             ->build();
         $url = (new UrlBuilder())
           ->withRepo( $this->currentRepo['safe_name'] )
           ->withAction( 'commit' )
           ->withHash( $commit->sha )
           ->build();
           echo '<div class="commit-row">';
           echo '<a href="' . $url . '" class="sha">' .
                substr( $commit->sha, 0, 7 ) . '</a>';
           echo '<span class="message">' . $msg . '</span>';
           echo '<span class="meta">' .
                htmlspecialchars( $commit->author ) .
                ' &bull; ' . date( 'Y-m-d', $commit->date ) . '</span>';
           echo '</div>';
         } );
         echo '<div class="commit-row">';
         echo '<a href="' . $url . '" class="sha">' . substr( $commit->sha, 0, 7 ) . '</a>';
         echo '<span class="message">' . $msg . '</span>';
         echo '<span class="meta">' . htmlspecialchars( $commit->author ) .
              ' &bull; ' . date( 'Y-m-d', $commit->date ) . '</span>';
         echo '</div>';
       } );
       echo '</div>';
+      }
     }, $this->currentRepo );
+  }

M pages/ComparePage.php

     string $oldSha
   ) {
     parent::__construct( $repositories );
     $title = $currentRepo['name'] . ' - Compare';
     parent::__construct( $repositories, $title );
     $this->currentRepo = $currentRepo;
     $this->git = $git;
     $this->newSha = $newSha;
     $this->oldSha = $oldSha;
     $this->title = $currentRepo['name'] . ' - Compare';
     $this->git         = $git;
     $this->newSha      = $newSha;
     $this->oldSha      = $oldSha;
+  }
       );
       $differ = new GitDiff( $this->git );
       $differ  = new GitDiff( $this->git );
       $changes = $differ->diff( $this->oldSha, $this->newSha );
       if( empty( $changes ) ) {
         echo '<div class="empty-state"><h3>No changes</h3>' .
              '<p>No differences.</p></div>';
         return;
+      }
       foreach( $changes as $change ) {
         $this->renderDiffFile( $change );
       } else {
         foreach( $changes as $change ) {
           $this->renderDiffFile( $change );
+        }
+      }
     }, $this->currentRepo );
     $statusClass = $typeMap[$change['type']] ?? 'modified';
     $path = htmlspecialchars( $change['path'] );
     $path        = htmlspecialchars( $change['path'] );
     echo '<div class="diff-file">';
     if( isset( $line['t'] ) && $line['t'] === 'gap' ) {
       echo '<tr class="diff-gap"><td colspan="3">...</td></tr>';
       return;
+    }
     $class = match( $line['t'] ) {
       '+' => 'diff-add',
       '-' => 'diff-del',
       default => ''
     };
     } else {
       $class = match( $line['t'] ) {
         '+'     => 'diff-add',
         '-'     => 'diff-del',
         default => ''
       };
     echo '<tr class="' . $class . '">';
     echo '<td class="diff-line-num">' . ($line['no'] ?? '') . '</td>';
     echo '<td class="diff-line-num">' . ($line['nn'] ?? '') . '</td>';
     echo '<td class="diff-code"><pre>' .
          htmlspecialchars( $line['l'] ?? '' ) . '</pre></td>';
     echo '</tr>';
       echo '<tr class="' . $class . '">';
       echo '<td class="diff-line-num">' . ($line['no'] ?? '') . '</td>';
       echo '<td class="diff-line-num">' . ($line['nn'] ?? '') . '</td>';
       echo '<td class="diff-code"><pre>' .
            htmlspecialchars( $line['l'] ?? '' ) . '</pre></td>';
       echo '</tr>';
+    }
+  }
+}

M pages/DiffPage.php

     string $hash
   ) {
     parent::__construct( $repositories );
     parent::__construct( $repositories, substr( $hash, 0, 7 ) );
     $this->currentRepo = $currentRepo;
     $this->git = $git;
     $this->hash = $hash;
     $this->title = substr( $hash, 0, 7 );
     $this->git         = $git;
     $this->hash        = $hash;
+  }
   public function render() {
     $this->renderLayout( function() {
       $commitData = $this->git->read( $this->hash );
       $diffEngine = new GitDiff( $this->git );
       $lines = explode( "\n", $commitData );
       $msg = '';
       $isMsg = false;
       $headers = [];
       $lines      = explode( "\n", $commitData );
       $msg        = '';
       $isMsg      = false;
       $headers    = [];
       foreach( $lines as $line ) {
         '<a href="' . $commitsUrl . '">Commits</a>',
         substr( $this->hash, 0, 7 )
       ]);
       ] );
       $author = $headers['author'] ?? 'Unknown';
       $author = preg_replace( '/<[^>]+>/', '<email>', $author );
       echo '<div class="commit-details">';
       echo '<div class="commit-header">';
       echo '<h1 class="commit-title">' . htmlspecialchars( trim( $msg ) ) . '</h1>';
       echo '<h1 class="commit-title">' .
            htmlspecialchars( trim( $msg ) ) . '</h1>';
       echo '<div class="commit-info">';
       echo '<div class="commit-info-row"><span class="commit-info-label">Author</span>' .
            '<span class="commit-author">' . htmlspecialchars( $author ) . '</span></div>';
       echo '<div class="commit-info-row"><span class="commit-info-label">Commit</span>' .
            '<span class="commit-info-value">' . $this->hash . '</span></div>';
       echo '<div class="commit-info-row">' .
            '<span class="commit-info-label">Author</span>' .
            '<span class="commit-author">' .
            htmlspecialchars( $author ) . '</span></div>';
       echo '<div class="commit-info-row">' .
            '<span class="commit-info-label">Commit</span>' .
            '<span class="commit-info-value">' .
            $this->hash . '</span></div>';
       if( isset( $headers['parent'] ) ) {
         $url = (new UrlBuilder())
           ->withRepo( $this->currentRepo['safe_name'] )
           ->withAction( 'commit' )
           ->withHash( $headers['parent'] )
           ->build();
         echo '<div class="commit-info-row"><span class="commit-info-label">Parent</span>' .
         echo '<div class="commit-info-row">' .
              '<span class="commit-info-label">Parent</span>' .
              '<span class="commit-info-value">';
         echo '<a href="' . $url . '" class="parent-link">' .
   private function renderFileDiff( $change ) {
     $statusIcon = 'fa-file';
     $statusIcon  = 'fa-file';
     $statusClass = '';
     if( $change['type'] === 'A' ) {
       $statusIcon = 'fa-plus-circle';
       $statusIcon  = 'fa-plus-circle';
       $statusClass = 'status-add';
+    }
     if( $change['type'] === 'D' ) {
       $statusIcon = 'fa-minus-circle';
       $statusIcon  = 'fa-minus-circle';
       $statusClass = 'status-del';
+    }
     if( $change['type'] === 'M' ) {
       $statusIcon = 'fa-pencil-alt';
       $statusIcon  = 'fa-pencil-alt';
       $statusClass = 'status-mod';
+    }
     echo '<div class="diff-file">';
     echo '<div class="diff-header">';
     echo '<span class="diff-status ' . $statusClass . '">' .
          '<i class="fa ' . $statusIcon . '"></i></span>';
     echo '<span class="diff-path">' . htmlspecialchars( $change['path'] ) . '</span>';
     echo '<span class="diff-path">' .
          htmlspecialchars( $change['path'] ) . '</span>';
     echo '</div>';
       foreach( $change['hunks'] as $line ) {
         if( isset( $line['t'] ) && $line['t'] === 'gap' ) {
           echo '<tr class="diff-gap"><td colspan="3">...</td></tr>';
           echo '<tr class="diff-gap"><td colspan="3">';
           echo '<img src="/images/diff-gap.svg" class="diff-gap-icon" />';
           echo '</td></tr>';
           continue;
+        }
         $class = 'diff-ctx';
         $char = ' ';
         $char  = ' ';
         if( $line['t'] === '+' ) {
           $class = 'diff-add';
           $char = '+';
           $char  = '+';
+        }
         if( $line['t'] === '-' ) {
           $class = 'diff-del';
           $char = '-';
           $char  = '-';
+        }
         echo '<tr class="' . $class . '">';
         echo '<td class="diff-num" data-num="' . $line['no'] . '"></td>';
         echo '<td class="diff-num" data-num="' . $line['nn'] . '"></td>';
         echo '<td class="diff-code"><span class="diff-marker">' . $char . '</span>' .
              htmlspecialchars( $line['l'] ) . '</td>';
         echo '<td class="diff-code"><span class="diff-marker">' .
              $char . '</span>' . htmlspecialchars( $line['l'] ) . '</td>';
         echo '</tr>';
+      }

M pages/FilePage.php

 class FilePage extends BasePage {
   private const MAX_HIGHLIGHT_SIZE = 65536;
   private const MAX_DISPLAY_SIZE = 524288;
   private const MAX_DISPLAY_SIZE   = 524288;
   private $currentRepo;
     string $path = ''
   ) {
     parent::__construct( $repositories );
     parent::__construct( $repositories, $currentRepo['name'] );
     $this->currentRepo = $currentRepo;
     $this->git = $git;
     $this->hash = $hash ?: 'HEAD';
     $this->path = $path;
     $this->title = $currentRepo['name'];
     $this->git         = $git;
     $this->hash        = $hash ?: 'HEAD';
     $this->path        = $path;
+  }
+  }
   private function isExactFileMatch($entries) {
      return count( $entries ) === 1 &&
             $entries[0]->isName( basename( $this->path ) ) &&
             !$entries[0]->isDir;
   private function isExactFileMatch( $entries ) {
     return count( $entries ) === 1 &&
            $entries[0]->isName( basename( $this->path ) ) &&
            !$entries[0]->isDir;
+  }
     echo '<table class="file-list-table">';
     echo '<thead><tr><th></th><th>Name</th><th class="file-mode-cell">Mode</th><th class="file-size-cell">Size</th></tr></thead>';
     echo '<thead><tr><th></th><th>Name</th>' .
          '<th class="file-mode-cell">Mode</th>' .
          '<th class="file-size-cell">Size</th></tr></thead>';
     echo '<tbody>';
   private function renderBlob( $targetHash ) {
     $filename = $this->path;
     $file = $this->git->readFile( $targetHash, $filename );
     $size = $this->git->getObjectSize( $targetHash, $filename );
     $file     = $this->git->readFile( $targetHash, $filename );
     $size     = $this->git->getObjectSize( $targetHash, $filename );
     $renderer = new HtmlFileRenderer( $this->currentRepo['safe_name'], dirname($filename), $targetHash );
     $renderer = new HtmlFileRenderer(
       $this->currentRepo['safe_name'],
       dirname( $filename ),
       $targetHash
     );
     $this->emitBreadcrumbs( $targetHash, 'File', $filename );
     if( $size === 0 && !$file ) {
        echo '<div class="empty-state">File not found.</div>';
        return;
+    }
       echo '<div class="empty-state">File not found.</div>';
     } else {
       $rawUrl = (new UrlBuilder())
         ->withRepo( $this->currentRepo['safe_name'] )
         ->withAction( 'raw' )
         ->withHash( $targetHash )
         ->withName( $filename )
         ->build();
     $rawUrl = (new UrlBuilder())
       ->withRepo( $this->currentRepo['safe_name'] )
       ->withAction( 'raw' )
       ->withHash( $targetHash )
       ->withName( $filename )
       ->build();
       if( !$file->renderMedia( $renderer, $rawUrl ) ) {
         if( $file->isText() ) {
           if( $size > self::MAX_DISPLAY_SIZE ) {
             ob_start();
             $file->renderSize( $renderer );
             $sizeStr = ob_get_clean();
             $this->renderDownloadState(
               $targetHash,
               "File is too large to display ($sizeStr)."
             );
           } else {
             $content = '';
             $this->git->stream(
               $targetHash,
               function( $d ) use ( &$content ) {
                 $content .= $d;
               },
               $filename
             );
     if( !$file->renderMedia( $renderer, $rawUrl ) ) {
       if( $file->isText() ) {
         if( $size > self::MAX_DISPLAY_SIZE ) {
           ob_start();
           $file->renderSize( $renderer );
           $sizeStr = ob_get_clean();
           $this->renderDownloadState( $targetHash, "File is too large to display ($sizeStr)." );
             echo '<div class="blob-content"><pre class="blob-code">' .
                  ($size > self::MAX_HIGHLIGHT_SIZE
                     ? htmlspecialchars( $content )
                     : $file->highlight( $renderer, $content )) .
                  '</pre></div>';
+          }
         } else {
           $content = '';
           $this->git->stream( $targetHash, function( $d ) use ( &$content ) {
             $content .= $d;
           }, $filename );
           echo '<div class="blob-content"><pre class="blob-code">' .
                ($size > self::MAX_HIGHLIGHT_SIZE
                   ? htmlspecialchars( $content )
                   : $file->highlight( $renderer, $content )) .
                '</pre></div>';
           $this->renderDownloadState(
             $targetHash,
             "This is a binary file."
           );
+        }
       } else {
         $this->renderDownloadState( $targetHash, "This is a binary file." );
+      }
+    }
     if( $path ) {
       $parts = explode( '/', trim( $path, '/' ) );
       $acc = '';
       $acc   = '';
       foreach( $parts as $idx => $part ) {
             ->build();
           $trail[] = '<a href="' . $url . '">' . htmlspecialchars( $part ) . '</a>';
           $trail[] = '<a href="' . $url . '">' .
                      htmlspecialchars( $part ) . '</a>';
+        }
+      }

M pages/HomePage.php

 class HomePage extends BasePage {
   private $repositories;
   private $git;
   public function __construct( array $repositories, Git $git ) {
     parent::__construct( $repositories );
     $this->git = $git;
     $this->repositories = $repositories;
     $this->git          = $git;
+  }
   public function render() {
     $this->renderLayout( function() {
       echo '<h2>Repositories</h2>';
       if( empty( $this->repositories ) ) {
         echo '<div class="empty-state">No repositories found.</div>';
         return;
+      }
       } else {
         echo '<div class="repo-grid">';
       echo '<div class="repo-grid">';
         foreach( $this->repositories as $repo ) {
           $this->renderRepoCard( $repo );
+        }
       foreach( $this->repositories as $repo ) {
         $this->renderRepoCard( $repo );
         echo '</div>';
+      }
       echo '</div>';
     } );
+  }
   private function renderRepoCard( $repo ) {
     $this->git->setRepository( $repo['path'] );
     $main = $this->git->getMainBranch();
     $main  = $this->git->getMainBranch();
     $stats = [
       'branches' => 0,
       'tags' => 0
       'tags'     => 0
     ];
     $branchLabel = $stats['branches'] === 1 ? 'branch' : 'branches';
     $tagLabel = $stats['tags'] === 1 ? 'tag' : 'tags';
     $tagLabel    = $stats['tags'] === 1 ? 'tag' : 'tags';
     echo $stats['branches'] . ' ' . $branchLabel . ', ' .

M pages/Page.php

 <?php
 interface Page {
     public function render();
   public function render();
+}

M pages/TagsPage.php

     Git $git
   ) {
     parent::__construct( $repositories );
     parent::__construct(
       $repositories,
       $currentRepo['name'] . ' - Tags'
     );
     $this->currentRepo = $currentRepo;
     $this->git = $git;
     $this->title = $currentRepo['name'] . ' - Tags';
     $this->git         = $git;
+  }
         echo '<p>No tags found.</p>';
       } else {
         $renderer = new HtmlTagRenderer( $this->currentRepo['safe_name'] );
         $renderer = new HtmlTagRenderer(
           $this->currentRepo['safe_name']
         );
         echo '<table class="tag-table">';
         $count = count( $tags );
         for( $i = 0; $i < $count; $i++ ) {
           $tag = $tags[$i];
           $tag     = $tags[$i];
           $prevTag = $tags[$i + 1] ?? null;
           $tag->render( $renderer, $prevTag );

M render/Highlighter.php

     $this->content  = $content;
     $this->language = $this->detectLanguage( $mediaType, $filename );
     $this->rules    = LanguageDefinitions::get( $this->language ) ?? [];
     $this->rules    = LanguageDefinitions::get( $this->language );
+  }
   public function render(): string {
     $result = htmlspecialchars( $this->content );
     if( !empty( $this->rules ) ) {
       $patterns = [];
       foreach( $this->rules as $name => $pattern ) {
         $delimiter = $pattern[0];
         $inner     = substr(
           $pattern,
 ,
           strrpos( $pattern, $delimiter ) - 1
         );
         $inner     = str_replace( '~', '\~', $inner );
         $delimiter  = $pattern[0];
         $pos        = strrpos( $pattern, $delimiter ) - 1;
         $inner      = substr( $pattern, 1, $pos );
         $inner      = str_replace( '~', '\~', $inner );
         $patterns[] = "(?P<{$name}>{$inner})";
+      }
       if( !in_array( $this->language, ['markdown', 'rmd'] ) ) {
         $patterns[] = "(?P<punctuation>[\\{\\}\\(\\)\\[\\]\\;\\,])";
         $patterns[] = "(?P<punctuation>[\\{\\}\\(\\)\\[\\]\\;\\,\\:])";
+      }
       $patterns[] = "(?P<any>[\s\S])";
       $combined   = '~' . implode( '|', $patterns ) . '~msu';
       $imploded   = implode( '|', $patterns );
       $combined   = '~' . $imploded . '~msu';
       $processed = preg_replace_callback( $combined, function( $matches ) {
       }, $this->content );
       if( $processed !== null ) {
       if( is_string( $processed ) ) {
         $result = $processed;
+      }
     return $this->processSegments( $content, $pattern, function( $part ) {
         $out = htmlspecialchars( $part );
       if( !str_starts_with( $part, '$' ) || strlen( $part ) <= 1 ) {
         $out = $this->wrap( $part, 'hl-string' );
       } else {
         $isComplex = str_starts_with( $part, '${' ) &&
                      str_ends_with( $part, '}' );
         if( str_starts_with( $part, '${' ) && str_ends_with( $part, '}' ) ) {
             $inner = substr( $part, 2, -1 );
             $out   = $this->wrap( '${', 'hl-interp-punct', false ) .
                      $this->wrap( $inner, 'hl-variable' ) .
                      $this->wrap( '}', 'hl-interp-punct', false );
         } elseif( str_starts_with( $part, '$' ) && strlen( $part ) > 1 ) {
             $inner = substr( $part, 1 );
             $out   = $this->wrap( '$', 'hl-interp-punct', false ) .
                      $this->wrap( $inner, 'hl-variable' );
         } else {
             $out = $this->wrap( $part, 'hl-string' );
+        }
         return $out;
     });
         $inner  = $isComplex ? substr( $part, 2, -1 ) : substr( $part, 1 );
         $prefix = $isComplex ? '${' : '$';
         $suffix = $isComplex
           ? $this->wrap( '}', 'hl-interp-punct', false )
           : '';
         $out = $this->wrap( $prefix, 'hl-interp-punct', false ) .
                $this->wrap( $inner, 'hl-variable' ) .
                $suffix;
+      }
       return $out;
     } );
+  }
   private function renderMath( string $content ): string {
     return $this->processSegments( $content, '/(`[^`]+`)/', function( $part ) {
         if( str_starts_with( $part, '`' ) && str_ends_with( $part, '`' ) ) {
             return $this->wrap( $part, 'hl-function' );
+        }
         return $this->wrap( $part, 'hl-math' );
     });
     $pattern = '/(`[^`]+`)/';
     return $this->processSegments( $content, $pattern, function( $part ) {
       $output = $this->wrap( $part, 'hl-math' );
       if( str_starts_with( $part, '`' ) && str_ends_with( $part, '`' ) ) {
         $output = $this->wrap( $part, 'hl-function' );
+      }
       return $output;
     } );
+  }
     bool $escape = true
   ): string {
     $safeContent = $escape ? htmlspecialchars( $content ) : $content;
     $safeContent = $content;
     if( $escape ) {
       $safeContent = htmlspecialchars( $content );
+    }
     return '<span class="' . $className . '">' . $safeContent . '</span>';
+  }
   private function detectLanguage(
     string $mediaType,
     string $filename
   ): string {
     $basename  = basename( $filename );
     $extension = strtolower( pathinfo( $filename, PATHINFO_EXTENSION ) );
     $language  = null;
     $language = match( $basename ) {
     $language  = match( $basename ) {
       'Containerfile',
       'Dockerfile'     => 'containerfile',
       'Makefile'       => 'makefile',
       'Jenkinsfile'    => 'groovy',
       default          => null
       'Dockerfile'  => 'containerfile',
       'Makefile'    => 'makefile',
       'Jenkinsfile' => 'groovy',
       default       => ''
     };
     if( $language === null ) {
     if( $language === '' ) {
       $language = match( $extension ) {
         'php', 'phtml', 'php8', 'php7' => 'php',
         'r'                            => 'r',
         'xml', 'svg'                   => 'xml',
         'xsl', 'xslt'                  => 'xslt',
         'html', 'htm'                  => 'html',
         'css'                          => 'css',
         'mk', 'mak'                    => 'makefile',
         'diff', 'patch'                => 'diff',
         default                        => null
         'for', 'f', 'f90', 'f95'       => 'fortran',
         default                        => ''
       };
+    }
     if( $language === null ) {
     if( $language === '' ) {
        $language = match( $mediaType ) {
         'text/x-php', 'application/x-php',
         'application/xml', 'text/xml',
         'image/svg+xml'                     => 'xml',
         'application/xslt+xml'              => 'xslt',
         'text/x-shellscript',
         'application/x-sh'                  => 'bash',
         'application/toml', 'text/toml'     => 'toml',
         'text/x-diff', 'text/x-patch'       => 'diff',
         'text/x-fortran'                    => 'fortran',
         default                             => 'text'
       };

M render/LanguageDefinitions.php

 class LanguageDefinitions {
   public static function get( string $lang ): array {
     $int   = '(-?\b\d+(\.\d+)?\b)';
     $str   = '("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')';
     $float = '(-?\d+(\.\d+)?([eE][+-]?\d+)?)';
     $rules = [
       'gradle' => [
         'comment'       => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*"|""".*?""")/',
         'string'        => '/(\'(?:\\\\.|[^\'\\\\])*\'|\'\'\'.*?\'\'\'|\/.*?\/)/',
         'keyword'       => '/\b(?:def|task|group|version|ext|return|if|else)\b/',
         'function'      => '/\b(apply|plugin|sourceCompatibility|targetCompatibility|repositories|dependencies|test|plugins|buildscript|allprojects|subprojects|project|implementation|api|compileOnly|runtimeOnly|testImplementation|testRuntimeOnly|mavenCentral|google|jcenter|classpath)\b|\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\(|{)/',
         'variable'      => '/(\$[a-zA-Z_][a-zA-Z0-9_]*|\$\{[^}]+\})/',
         'boolean'       => '/\b(?:true|false|null)\b/',
         'number'        => '/' . $int . '/',
       ],
       'tex' => [
         'comment'  => '/(%[^\r\n]*)/m',
         'math'     => '/(\$\$?.*?\$\$?)/s',
         'keyword'  => '/(\\\\(?:def|edef|gdef|xdef|let|futurelet|if|else|fi|ifnum|ifdim|ifodd|ifmmode|ifx|ifeof|iftrue|iffalse|ifcase|or|loop|repeat|newif|expandafter|noexpand|csname|endcsname|string|number|the|long|outer|global|par|advance|hsize|vsize|hoffset|voffset|displaywidth|parindent|baselineskip|leftskip|rightskip|hangindent|hangafter|parshape|pageno|nopagenumbers|folio|headline|footline|hbox|vbox|vtop|vcenter|rlap|llap|hskip|vskip|hfil|hfill|hfilneg|vfil|vfill|mskip|quad|qquad|enspace|thinspace|enskip|strut|phantom|vphantom|hphantom|smash|raise|lower|moveleft|moveright|halign|valign|noalign|openup|cr|crcr|omit|span|multispan|tabskip|settabs|matrix|pmatrix|bordermatrix|eqalign|displaylines|eqno|leqno|cases|left|right|over|atop|choose|brace|brack|root|of|buildrel|input|end|bye|item|itemitem|indent|noindent|narrower|rm|bf|tt|sl|it|font|char|magnification|magstep|magstephalf|day|month|year|jobname|romannumeral|uppercase|lowercase|footnote|topinsert|pageinsert|midinsert|endinsert|underbar|hfuzz|vfuzz|overfullrule|raggedright|raggedbottom|everypar|everymath|everydisplay|everycr))\b/',
         'function' => '/(\\\\[a-zA-Z@]+|\\\\[^a-zA-Z@])/',
         'variable' => '/(#[0-9])/',
       ],
       'php' => [
         'tag'           => '/(<\?php|<\?|=\?>|\?>)/',
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*")/',
         'string'        => '/(\'(?:\\\\.|[^\'\\\\])*\')/',
         'comment'       => '/(\/\/[^\r\n]*|#[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'          => '/\b(?:array|bool|callable|float|int|iterable|mixed|never|object|string|void)\b/',
         'keyword'       => '/\b(?:abstract|and|as|break|case|catch|class|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|print|private|protected|public|readonly|require|require_once|return|static|switch|throw|trait|try|unset|use|var|while|xor|yield)\b/',
         'function'      => '/\b([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)\s*(?=\()/',
         'variable'      => '/(\$[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)/',
         'number'        => '/' . $int . '/',
         'boolean'       => '/\b(true|false|null)\b/i',
       ],
       'bash' => [
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*")/',
         'string'        => '/(\'.*?\')/',
         'comment'       => '/(#[^\n]*)/',
         'keyword'       => '/(?<!-)\b(?:alias|bg|bind|break|builtin|case|cd|command|compgen|complete|continue|coproc|declare|dirs|disown|do|done|echo|elif|else|enable|esac|eval|exec|exit|export|fc|fg|fi|for|function|getopts|hash|help|history|if|jobs|kill|let|local|logout|popd|printf|pushd|pwd|read|readonly|return|select|set|shift|shopt|source|suspend|test|then|time|times|trap|type|typeset|ulimit|umask|unalias|unset|until|wait|while)\b/',
         'function'      => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'variable'      => '/(\$[a-zA-Z_][a-zA-Z0-9_]*|\$\{[^}]+\})/',
         'number'        => '/' . $int . '/',
       ],
       'batch' => [
         'comment'  => '/((?i:rem)\b[^\n]*|::[^\n]*)/',
         'string'   => '/("[^"]*")/',
         'keyword'  => '/(?i)\b(?:if|else|goto|for|in|do|exit|echo|pause|set|shift|start|cd|dir|copy|del|md|rd|cls|setlocal|endlocal|enabledelayedexpansion|defined|exist|not|errorlevel|setx|findstr|reg|nul|tokens|usebackq|equ|neq|lss|leq|gtr|geq)\b/',
         'function' => '/(?i)\b(call)\b/',
         'variable' => '/(![\w-]+!|%[\w\(\)-]+%|%%[~a-zA-Z]+|%[~a-zA-Z0-9]+)/',
         'label'    => '/(^\s*:[a-zA-Z0-9_-]+)/m',
         'number'   => '/' . $int . '/',
       ],
       'c' => [
         'string'       => '/' . $str . '/',
         'comment'      => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'include'      => '/(^\s*#include[^\r\n]*)/m',
         'preprocessor' => '/(^\s*#(?!include\b)[^\r\n]*)/m',
         'type'         => '/\b(?:char|double|float|int|long|short|void|signed|unsigned)\b/',
         'keyword'      => '/\b(?:auto|break|case|const|continue|default|do|else|enum|extern|for|goto|if|noreturn|register|return|sizeof|static|struct|switch|typedef|union|volatile|while)\b/',
         'function'     => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'       => '/' . $int . '/',
       ],
       'cpp' => [
         'string'       => '/' . $str . '/',
         'comment'      => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'include'      => '/(^\s*#include[^\r\n]*)/m',
         'preprocessor' => '/(^\s*#(?!include\b)[^\r\n]*)/m',
         'type'         => '/\b(?:bool|char|char8_t|char16_t|char32_t|double|float|int|long|short|signed|unsigned|void|wchar_t)\b/',
         'keyword'      => '/\b(?:alignas|alignof|and|and_eq|asm|auto|bitand|bitor|break|case|catch|class|co_await|co_return|co_yield|compl|concept|const|consteval|constexpr|constinit|const_cast|continue|decltype|default|delete|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|goto|if|inline|mutable|namespace|new|noexcept|noreturn|not|not_eq|nullptr|operator|or|or_eq|private|protected|public|register|reinterpret_cast|requires|return|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|using|virtual|volatile|while|xor|xor_eq)\b/',
         'boolean'      => '/\b(?:true|false)\b/',
         'function'     => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'       => '/' . $int . '/',
       ],
       'java' => [
         'class'    => '/(@[a-zA-Z_][a-zA-Z0-9_]*)/',
         'string'   => '/' . $str . '/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:boolean|byte|char|double|float|int|long|short|void)\b/',
         'keyword'  => '/\b(?:abstract|assert|break|case|catch|class|const|continue|default|do|else|enum|extends|final|finally|for|goto|if|implements|import|instanceof|interface|native|new|non-sealed|package|permits|private|protected|public|record|return|sealed|static|strictfp|super|switch|synchronized|this|throw|throws|transient|try|var|volatile|while|yield)\b/',
         'boolean'  => '/\b(?:true|false|null)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'go' => [
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|`.*?`)/s',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:bool|byte|complex64|complex128|error|float32|float64|int|int8|int16|int32|int64|rune|string|uint|uint8|uint16|uint32|uint64|uintptr)\b/',
         'keyword'  => '/\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go|goto|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/',
         'boolean'  => '/\b(?:true|false|nil|iota)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'rust' => [
         'string'   => '/' . $str . '/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:bool|char|f32|f64|i8|i16|i32|i64|i128|isize|str|u8|u16|u32|u64|u128|usize)\b/',
         'keyword'  => '/\b(?:as|async|await|break|const|continue|crate|dyn|else|enum|extern|fn|for|if|impl|in|let|loop|match|mod|move|mut|pub|ref|return|self|Self|static|struct|super|trait|type|union|unsafe|use|where|while)\b/',
         'boolean'  => '/\b(?:true|false)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'python' => [
         'string'   => '/(\'\'\'.*?\'\'\'|""".*?"""|"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')/s',
         'comment'  => '/(#[^\r\n]*)/m',
         'type'     => '/\b(?:bool|bytearray|bytes|complex|dict|float|frozenset|int|list|memoryview|object|range|set|str|tuple)\b/',
         'keyword'  => '/\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\b/',
         'boolean'  => '/\b(?:False|None|True)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'ruby' => [
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*")/',
         'string'        => '/(\'(?:\\\\.|[^\'\\\\])*\')/',
         'comment'       => '/(#[^\r\n]*)/m',
         'keyword'       => '/\b(?:alias|and|begin|break|case|class|def|defined|do|else|elsif|end|ensure|for|if|in|module|next|not|or|redo|rescue|retry|return|self|super|then|undef|unless|until|when|while|yield)\b/',
         'boolean'       => '/\b(?:true|false|nil)\b/',
         'function'      => '/\b([a-zA-Z_][a-zA-Z0-9_]*[?!]?)\s*(?=\()/',
         'variable'      => '/(@[a-zA-Z_]\w*|\$[a-zA-Z_]\w*)/',
         'number'        => '/' . $int . '/',
       ],
       'lua' => [
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|\[\[.*?\]\])/s',
         'comment'  => '/(--\[\[.*?\]\]|--[^\r\n]*)/ms',
         'keyword'  => '/\b(?:and|break|do|else|elseif|end|for|function|if|in|local|not|or|repeat|return|then|until|while)\b/',
         'boolean'  => '/\b(?:false|nil|true)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'javascript' => [
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|`(?:\\\\.|[^`\\\\])*`)/s',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'keyword'  => '/\b(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|if|import|in|instanceof|let|new|of|return|static|super|switch|this|throw|try|typeof|var|void|while|with|yield)\b/',
         'boolean'  => '/\b(?:true|false|null|undefined)\b/',
         'function' => '/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'typescript' => [
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|`(?:\\\\.|[^`\\\\])*`)/s',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:boolean|number|string|void|any|never|unknown|object|symbol|bigint)\b/',
         'keyword'  => '/\b(?:abstract|as|break|case|catch|class|const|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|if|implements|import|in|instanceof|interface|is|let|module|namespace|new|of|package|private|protected|public|readonly|require|return|static|super|switch|this|throw|try|type|typeof|var|while|with|yield)\b/',
         'boolean'  => '/\b(?:true|false|null|undefined)\b/',
         'function' => '/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'xml' => [
         'comment'   => '/()/',
         'string'    => '/' . $str . '/',
         'tag'       => '/(<\/?[!a-zA-Z0-9:-]+|\s*\/?>|<\?xml|\?>)/',
         'attribute' => '/([a-zA-Z0-9:-]+)(?=\=)/',
       ],
       'html' => [
         'comment'   => '/()/',
         'string'    => '/' . $str . '/',
         'tag'       => '/(<\/?[!a-zA-Z0-9:-]+|\s*\/?>)/',
         'attribute' => '/([a-zA-Z0-9:-]+)(?=\=)/',
       ],
       'css' => [
         'comment'  => '/(\/\*.*?\*\/)/s',
         'tag'      => '/(?<=^|\}|\{)\s*([a-zA-Z0-9_\-#\.\s,>+~]+)(?=\{)/m',
         'property' => '/([a-zA-Z-]+)(?=\s*:)/',
         'string'   => '/' . $str . '/',
         'number'   => '/(-?(\d*\.)?\d+(px|em|rem|%|vh|vw|s|ms|deg))/',
       ],
       'json' => [
         'attribute' => '/("(?:\\\\.|[^"\\\\])*")(?=\s*:)/',
         'string'    => '/("(?:\\\\.|[^"\\\\])*")/',
         'boolean'   => '/\b(true|false|null)\b/',
         'number'    => '/\b(-?\d+(\.\d+)?([eE][+-]?\d+)?)\b/',
       ],
       'sql' => [
         'string'   => '/(\'.*?\')/',
         'comment'  => '/(--[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/(?i)\b(?:BIGINT|BIT|BOOLEAN|CHAR|DATE|DATETIME|DECIMAL|DOUBLE|FLOAT|INT|INTEGER|MONEY|NUMERIC|REAL|SMALLINT|TEXT|TIME|TIMESTAMP|TINYINT|VARCHAR)\b/',
         'keyword'  => '/(?i)\b(ADD|ALTER|AND|AS|ASC|BEGIN|BETWEEN|BY|CASE|CHECK|COLUMN|COMMIT|CONSTRAINT|CREATE|DATABASE|DEFAULT|DELETE|DESC|DISTINCT|DROP|ELSE|END|EXISTS|FOREIGN|FROM|FULL|FUNCTION|GRANT|GROUP|HAVING|IF|IN|INDEX|INNER|INSERT|INTO|IS|JOIN|KEY|LEFT|LIKE|LIMIT|NOT|NULL|OFFSET|ON|OR|ORDER|OUTER|PRIMARY|PROCEDURE|REFERENCES|REVOKE|RIGHT|ROLLBACK|SCHEMA|SELECT|SET|TABLE|THEN|TRANSACTION|TRIGGER|TRUNCATE|UNION|UNIQUE|UPDATE|VALUES|VIEW|WHEN|WHERE)\b/',
         'boolean'  => '/(?i)\b(NULL|TRUE|FALSE)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'yaml' => [
         'comment'       => '/(#[^\r\n]*)/m',
         'variable'      => '/^(\s*[a-zA-Z0-9_-]+:)/m',
         'string_interp' => '/((?<=:)\s*[^\r\n]*)/',
         'number'        => '/' . $float . '/',
       ],
       'properties' => [
         'comment'       => '/(^[ \t]*[#!][^\r\n]*)/m',
         'variable'      => '/(^[ \t]*[^:=\s]+)(?=[ \t]*[:=])/m',
         'string_interp' => '/((?<=[=:])\s*[^\r\n]*)/',
       ],
       'ini' => [
         'comment'   => '/(^[ \t]*[;#][^\r\n]*)/m',
         'keyword'   => '/(^\[[^\]\r\n]+\])/m',
         'variable'  => '/(^[ \t]*[a-zA-Z0-9_\.\-]+)(?=\s*=)/m',
         'string'    => '/((?<==)\s*[^\r\n]*)/',
       ],
       'toml' => [
         'comment'   => '/(#[^\r\n]*)/',
         'keyword'   => '/(^\[[^\]\r\n]+\])/m',
         'variable'  => '/(\b[a-zA-Z0-9_-]+\b)(?=\s*=)/',
         'string'    => '/(' . $str . '|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\')/',
         'boolean'   => '/\b(true|false)\b/',
         'date'      => '/(\d{4}-\d{2}-\d{2}(?:[Tt ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?)/',
         'number'    => '/' . $float . '/',
       ],
       'markdown' => [
         'code'      => '/(^(?:    |\t)[^\n]*(?:\n(?:    |\t)[^\n]*)*)/',
         'comment'   => '/(```[\s\S]*?```|~~~[\s\S]*?~~~)/',
         'math'      => '/(\$((?:[^`\n$]|`[^`\n]*`)+)\$)/',
         'keyword'   => '/^(#{1,6})(?=\s)/m',
         'string'    => '/(\*\*[^\n*]+\*\*|__[^\n_]+__)/',
         'attribute' => '/(?<!\*)(\*[^\n*]+\*)(?!\*)|(?<!_)(_[^\n_]+_)(?!_)/',
         'function'  => '/(`[^`\n]+`)/',
         'variable'  => '/(\[[^\]]+\]\([^\)]+\))/',
         'operator'  => '/^(\s*[-*+](?=\s)|\s*\d+\.(?=\s))/m',
       ],
       'rmd' => [
         'code'      => '/(^(?:    |\t)[^\n]*(?:\n(?:    |\t)[^\n]*)*)/',
         'comment'   => '/(```\{r[^\}]*\}[\s\S]*?```)/',
         'math'      => '/(\$((?:[^`\n$]|`[^`\n]*`)+)\$)/',
         'keyword'   => '/^(#{1,6})(?=\s)/m',
         'string'    => '/(\*\*[^\n*]+\*\*|__[^\n_]+__)/',
         'attribute' => '/(?<!\*)(\*[^\n*]+\*)(?!\*)|(?<!_)(_[^\n_]+_)(?!_)/',
         'function'  => '/(`[^`\n]+`)/',
         'variable'  => '/(\[[^\]]+\]\([^\)]+\))/',
         'operator'  => '/^(\s*[-*+](?=\s)|\s*\d+\.(?=\s))/m',
       ],
       'r' => [
         'string'   => '/' . $str . '/',
         'comment'  => '/(#[^\r\n]*)/m',
         'keyword'  => '/\b(?:if|else|repeat|while|function|for|in|next|break)\b/',
         'boolean'  => '/\b(?:TRUE|FALSE|NULL|Inf|NaN|NA)\b/',
         'function' => '/\b([a-zA-Z_.][a-zA-Z0-9_.]*)\s*(?=\()/',
         'number'   => '/' . $float . '/',
       ],
       'csharp' => [
         'string'       => '/(@"(?:""|[^"])*"|' . $str . ')/',
         'comment'      => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'preprocessor' => '/(^\s*#[^\r\n]*)/m',
         'type'         => '/\b(?:bool|byte|char|decimal|double|float|int|long|object|sbyte|short|string|uint|ulong|ushort|void)\b/',
         'keyword'      => '/\b(?:abstract|as|base|break|case|catch|checked|class|const|continue|default|delegate|do|else|enum|event|explicit|extern|false|finally|fixed|for|foreach|goto|if|implicit|in|interface|internal|is|lock|namespace|new|null|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|struct|switch|this|throw|true|try|typeof|unchecked|unsafe|using|virtual|volatile|while)\b/',
         'function'     => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'       => '/' . $int . '/',
       ],
       'kotlin' => [
         'string'   => '/("""[\s\S]*?"""|' . $str . ')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:Boolean|Byte|Char|Double|Float|Int|Long|Short|String|Void|Unit|Any|Nothing)\b/',
         'keyword'  => '/\b(?:as|break|class|continue|do|else|false|for|fun|if|in|interface|is|null|object|package|return|super|this|throw|true|try|typealias|typeof|val|var|when|while)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'scala' => [
         'string'   => '/("""[\s\S]*?"""|' . $str . ')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:Boolean|Byte|Char|Double|Float|Int|Long|Short|String|Unit|Any|AnyRef|AnyVal|Nothing|Null|void)\b/',
         'keyword'  => '/\b(?:abstract|case|catch|class|def|do|else|extends|false|final|finally|for|forSome|if|implicit|import|lazy|match|new|null|object|override|package|private|protected|return|sealed|super|this|throw|trait|try|true|type|val|var|while|with|yield)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'groovy' => [
         'string'        => '/(\'\'\'[\s\S]*?\'\'\'|""".*?"""|"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|\/[^\/]+\/)/',
         'comment'       => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'          => '/\b(?:boolean|byte|char|double|float|int|long|short|void)\b/',
         'keyword'       => '/\b(?:def|as|assert|break|case|catch|class|const|continue|default|do|else|enum|extends|false|finally|for|goto|if|implements|import|in|instanceof|interface|new|null|package|return|super|switch|this|throw|throws|trait|true|try|var|while)\b/',
         'function'      => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'        => '/' . $int . '/',
       ],
       'dart' => [
         'string'   => '/(r?\'\'\'[\s\S]*?\'\'\'|r?"""[\s\S]*?"""|"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:void|bool|int|double|num|dynamic)\b/',
         'keyword'  => '/\b(?:abstract|as|assert|async|await|break|case|catch|class|const|continue|default|do|else|enum|export|extends|extension|external|factory|false|final|finally|for|get|if|implements|import|in|interface|is|library|mixin|new|null|on|operator|part|rethrow|return|set|static|super|switch|sync|this|throw|true|try|typedef|var|while|with|yield)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'swift' => [
         'string'   => '/("""[\s\S]*?"""|' . $str . ')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:Int|Double|Float|Bool|String|Void|Character|Any|AnyObject)\b/',
         'keyword'  => '/\b(?:associatedtype|class|deinit|enum|extension|fileprivate|func|import|init|inout|internal|let|open|operator|private|protocol|public|rethrows|static|struct|subscript|typealias|var|break|case|continue|default|defer|do|else|fallthrough|for|guard|if|in|repeat|return|switch|where|while|as|catch|false|is|nil|super|self|Self|throw|throws|true|try)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'perl' => [
         'comment'  => '/(#[^\r\n]*)/',
         'string'   => '/(' . $str . '|`[^`]*`)/',
         'variable' => '/([$@%](?:\{[a-zA-Z_]\w*\}|[a-zA-Z_]\w*))/',
         'keyword'  => '/\b(?:my|local|our|state|use|sub|package|if|else|elsif|unless|while|until|for|foreach|do|last|next|redo|goto|continue|return|print|printf|say|die|warn|eval|try|catch)\b/',
         'number'   => '/' . $float . '/',
       ],
       'powershell' => [
         'comment'  => '/(<#[\s\S]*?#>|#[^\r\n]*)/',
         'string'   => '/(@"(?:""|[^"])*"@|@\'(?:[^[\'])*\'@|"(?:`.|[^"`])*"|\'(?:[^[\'])*\')/',
         'variable' => '/(\$[a-zA-Z0-9_]+)/',
         'keyword'  => '/(?i)\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|In|InlineScript|Hidden|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_-]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'containerfile' => [
         'comment' => '/(#[^\r\n]*)/',
         'string'  => '/' . $str . '/',
         'keyword' => '/(?i)^\s*(?:FROM|MAINTAINER|RUN|CMD|LABEL|EXPOSE|ENV|ADD|COPY|ENTRYPOINT|VOLUME|USER|WORKDIR|ARG|ONBUILD|STOPSIGNAL|HEALTHCHECK|SHELL)\b/m',
       ],
       'makefile' => [
         'comment'  => '/(#[^\r\n]*)/',
         'variable' => '/(\$+[{(][^})]+[})])/',
         'keyword'  => '/(?i)\b(?:include|define|endef|export|override|ifdef|ifndef|ifeq|ifneq|else|endif|vpath)\b/',
         'function' => '/^([a-zA-Z0-9._-]+):/m',
       ],
       'diff' => [
         'comment'  => '/^(?:---| \+\+\+|index|diff).*/m',
         'meta'     => '/^(?:@@).*/m',
         'inserted' => '/(^\+.*)/m',
         'deleted'  => '/(^-.*)/m',
+      ]
     ];
     return $rules[strtolower( $lang )] ?? [];
     $int        = '(-?\b\d+(\.\d+)?\b)';
     $str        = '("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')';
     $float      = '(-?\d+(\.\d+)?([eE][+-]?\d+)?)';
     $normalized = strtolower( $lang );
     $result     = [];
     $rules      = [
       'gradle' => [
         'comment'       => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*"|""".*?""")/',
         'string'        => '/(\'(?:\\\\.|[^\'\\\\])*\'|\'\'\'.*?\'\'\'' .
                            '|\/.*?\/)/',
         'keyword'       => '/\b(?:def|task|group|version|ext|return|if|' .
                            'else)\b/',
         'function'      => '/\b(apply|plugin|sourceCompatibility|' .
                            'targetCompatibility|repositories|dependencies|' .
                            'test|plugins|buildscript|allprojects|' .
                            'subprojects|project|implementation|api|' .
                            'compileOnly|runtimeOnly|testImplementation|' .
                            'testRuntimeOnly|mavenCentral|google|jcenter|' .
                            'classpath)\b|\b([a-zA-Z_][a-zA-Z0-9_]*)\s*' .
                            '(?=\(|{)/',
         'variable'      => '/(\$[a-zA-Z_][a-zA-Z0-9_]*|\$\{[^}]+\})/',
         'boolean'       => '/\b(?:true|false|null)\b/',
         'number'        => '/' . $int . '/',
       ],
       'tex' => [
         'comment'  => '/(%[^\r\n]*)/m',
         'math'     => '/(\$\$?.*?\$\$?)/s',
         'keyword'  => '/(\\\\(?:def|edef|gdef|xdef|let|futurelet|if|else|' .
                       'fi|ifnum|ifdim|ifodd|ifmmode|ifx|ifeof|iftrue|' .
                       'iffalse|ifcase|or|loop|repeat|newif|expandafter|' .
                       'noexpand|csname|endcsname|string|number|the|long|' .
                       'outer|global|par|advance|hsize|vsize|hoffset|' .
                       'voffset|displaywidth|parindent|baselineskip|' .
                       'leftskip|rightskip|hangindent|hangafter|parshape|' .
                       'pageno|nopagenumbers|folio|headline|footline|hbox|' .
                       'vbox|vtop|vcenter|rlap|llap|hskip|vskip|hfil|hfill|' .
                       'hfilneg|vfil|vfill|mskip|quad|qquad|enspace|' .
                       'thinspace|enskip|strut|phantom|vphantom|hphantom|' .
                       'smash|raise|lower|moveleft|moveright|halign|valign|' .
                       'noalign|openup|cr|crcr|omit|span|multispan|tabskip|' .
                       'settabs|matrix|pmatrix|bordermatrix|eqalign|' .
                       'displaylines|eqno|leqno|cases|left|right|over|atop|' .
                       'choose|brace|brack|root|of|buildrel|input|end|bye|' .
                       'item|itemitem|indent|noindent|narrower|rm|bf|tt|sl|' .
                       'it|font|char|magnification|magstep|magstephalf|day|' .
                       'month|year|jobname|romannumeral|uppercase|lowercase|' .
                       'footnote|topinsert|pageinsert|midinsert|endinsert|' .
                       'underbar|hfuzz|vfuzz|overfullrule|raggedright|' .
                       'raggedbottom|everypar|everymath|everydisplay|' .
                       'everycr))\b/',
         'function' => '/(\\\\[a-zA-Z@]+|\\\\[^a-zA-Z@])/',
         'variable' => '/(#[0-9])/',
       ],
       'php' => [
         'tag'           => '/(<\?php|<\?|=\?>|\?>)/',
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*")/',
         'string'        => '/(\'(?:\\\\.|[^\'\\\\])*\')/',
         'comment'       => '/(\/\/[^\r\n]*|#[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'          => '/\b(?:array|bool|callable|float|int|iterable|' .
                            'mixed|never|object|string|void)\b/',
         'keyword'       => '/\b(?:abstract|and|as|break|case|catch|class|' .
                            'clone|const|continue|declare|default|die|do|' .
                            'echo|else|elseif|empty|enddeclare|endfor|' .
                            'endforeach|endif|endswitch|endwhile|enum|eval|' .
                            'exit|extends|final|finally|fn|for|foreach|' .
                            'function|global|goto|if|implements|include|' .
                            'include_once|instanceof|insteadof|interface|' .
                            'isset|list|match|namespace|new|or|print|' .
                            'private|protected|public|readonly|require|' .
                            'require_once|return|static|switch|throw|trait|' .
                            'try|unset|use|var|while|xor|yield)\b/',
         'function'      => '/\b([a-zA-Z_\x7f-\xff]' .
                            '[a-zA-Z0-9_\x7f-\xff]*)\s*(?=\()/',
         'variable'      => '/(\$[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)/',
         'number'        => '/' . $int . '/',
         'boolean'       => '/\b(true|false|null)\b/i',
       ],
       'bash' => [
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*")/',
         'string'        => '/(\'.*?\')/',
         'comment'       => '/(#[^\n]*)/',
         'keyword'       => '/(?<!-)\b(?:alias|bg|bind|break|builtin|case|' .
                            'cd|command|compgen|complete|continue|coproc|' .
                            'declare|dirs|disown|do|done|echo|elif|else|' .
                            'enable|esac|eval|exec|exit|export|fc|fg|fi|' .
                            'for|function|getopts|hash|help|history|if|' .
                            'jobs|kill|let|local|logout|popd|printf|pushd|' .
                            'pwd|read|readonly|return|select|set|shift|' .
                            'shopt|source|suspend|test|then|time|times|' .
                            'trap|type|typeset|ulimit|umask|unalias|unset|' .
                            'until|wait|while)\b/',
         'function'      => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'variable'      => '/(\$[a-zA-Z_][a-zA-Z0-9_]*|\$\{[^}]+\})/',
         'number'        => '/' . $int . '/',
       ],
       'batch' => [
         'comment'  => '/((?i:rem)\b[^\n]*|::[^\n]*)/',
         'string'   => '/("[^"]*")/',
         'keyword'  => '/(?i)\b(?:if|else|goto|for|in|do|exit|echo|pause|' .
                       'set|shift|start|cd|dir|copy|del|md|rd|cls|setlocal|' .
                       'endlocal|enabledelayedexpansion|defined|exist|not|' .
                       'errorlevel|setx|findstr|reg|nul|tokens|usebackq|' .
                       'equ|neq|lss|leq|gtr|geq)\b/',
         'function' => '/(?i)\b(call)\b/',
         'variable' => '/(![\w-]+!|%[\w\(\)-]+%|%%[~a-zA-Z]+|' .
                       '%[~a-zA-Z0-9]+)/',
         'label'    => '/(^\s*:[a-zA-Z0-9_-]+)/m',
         'number'   => '/' . $int . '/',
       ],
       'c' => [
         'string'       => '/' . $str . '/',
         'comment'      => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'include'      => '/(^\s*#include[^\r\n]*)/m',
         'preprocessor' => '/(^\s*#(?!include\b)[^\r\n]*)/m',
         'type'         => '/\b(?:char|double|float|int|long|short|void|' .
                           'signed|unsigned)\b/',
         'keyword'      => '/\b(?:auto|break|case|const|continue|default|' .
                           'do|else|enum|extern|for|goto|if|noreturn|' .
                           'register|return|sizeof|static|struct|switch|' .
                           'typedef|union|volatile|while)\b/',
         'function'     => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'       => '/' . $int . '/',
       ],
       'cpp' => [
         'string'       => '/' . $str . '/',
         'comment'      => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'include'      => '/(^\s*#include[^\r\n]*)/m',
         'preprocessor' => '/(^\s*#(?!include\b)[^\r\n]*)/m',
         'type'         => '/\b(?:bool|char|char8_t|char16_t|char32_t|' .
                           'double|float|int|long|short|signed|unsigned|' .
                           'void|wchar_t)\b/',
         'keyword'      => '/\b(?:alignas|alignof|and|and_eq|asm|auto|' .
                           'bitand|bitor|break|case|catch|class|co_await|' .
                           'co_return|co_yield|compl|concept|const|' .
                           'consteval|constexpr|constinit|const_cast|' .
                           'continue|decltype|default|delete|do|' .
                           'dynamic_cast|else|enum|explicit|export|extern|' .
                           'for|friend|goto|if|inline|mutable|namespace|' .
                           'new|noexcept|noreturn|not|not_eq|nullptr|' .
                           'operator|or|or_eq|private|protected|public|' .
                           'register|reinterpret_cast|requires|return|' .
                           'sizeof|static|static_assert|static_cast|' .
                           'struct|switch|template|this|thread_local|' .
                           'throw|try|typedef|typeid|typename|union|using|' .
                           'virtual|volatile|while|xor|xor_eq)\b/',
         'boolean'      => '/\b(?:true|false)\b/',
         'function'     => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'       => '/' . $int . '/',
       ],
       'java' => [
         'class'    => '/(@[a-zA-Z_][a-zA-Z0-9_]*)/',
         'string'   => '/' . $str . '/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:boolean|byte|char|double|float|int|long|' .
                       'short|void)\b/',
         'keyword'  => '/\b(?:abstract|assert|break|case|catch|class|' .
                       'const|continue|default|do|else|enum|extends|final|' .
                       'finally|for|goto|if|implements|import|instanceof|' .
                       'interface|native|new|non-sealed|package|permits|' .
                       'private|protected|public|record|return|sealed|' .
                       'static|strictfp|super|switch|synchronized|this|' .
                       'throw|throws|transient|try|var|volatile|while|' .
                       'yield)\b/',
         'boolean'  => '/\b(?:true|false|null)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'go' => [
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|`.*?`)/s',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:bool|byte|complex64|complex128|error|' .
                       'float32|float64|int|int8|int16|int32|int64|rune|' .
                       'string|uint|uint8|uint16|uint32|uint64|uintptr)\b/',
         'keyword'  => '/\b(?:break|case|chan|const|continue|default|' .
                       'defer|else|fallthrough|for|func|go|goto|if|import|' .
                       'interface|map|package|range|return|select|struct|' .
                       'switch|type|var)\b/',
         'boolean'  => '/\b(?:true|false|nil|iota)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'rust' => [
         'string'   => '/' . $str . '/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:bool|char|f32|f64|i8|i16|i32|i64|i128|isize|' .
                       'str|u8|u16|u32|u64|u128|usize)\b/',
         'keyword'  => '/\b(?:as|async|await|break|const|continue|crate|' .
                       'dyn|else|enum|extern|fn|for|if|impl|in|let|loop|' .
                       'match|mod|move|mut|pub|ref|return|self|Self|' .
                       'static|struct|super|trait|type|union|unsafe|use|' .
                       'where|while)\b/',
         'boolean'  => '/\b(?:true|false)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'python' => [
         'string'   => '/(\'\'\'.*?\'\'\'|""".*?"""|"(?:\\\\.|[^"\\\\])*"|' .
                       '\'(?:\\\\.|[^\'\\\\])*\')/s',
         'comment'  => '/(#[^\r\n]*)/m',
         'type'     => '/\b(?:bool|bytearray|bytes|complex|dict|float|' .
                       'frozenset|int|list|memoryview|object|range|set|' .
                       'str|tuple)\b/',
         'keyword'  => '/\b(?:and|as|assert|async|await|break|class|' .
                       'continue|def|del|elif|else|except|finally|for|' .
                       'from|global|if|import|in|is|lambda|nonlocal|not|' .
                       'or|pass|raise|return|try|while|with|yield)\b/',
         'boolean'  => '/\b(?:False|None|True)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'ruby' => [
         'string_interp' => '/("(?:\\\\.|[^"\\\\])*")/',
         'string'        => '/(\'(?:\\\\.|[^\'\\\\])*\')/',
         'comment'       => '/(#[^\r\n]*)/m',
         'keyword'       => '/\b(?:alias|and|begin|break|case|class|def|' .
                            'defined|do|else|elsif|end|ensure|for|if|in|' .
                            'module|next|not|or|redo|rescue|retry|return|' .
                            'self|super|then|undef|unless|until|when|' .
                            'while|yield)\b/',
         'boolean'       => '/\b(?:true|false|nil)\b/',
         'function'      => '/\b([a-zA-Z_][a-zA-Z0-9_]*[?!]?)\s*(?=\()/',
         'variable'      => '/(@[a-zA-Z_]\w*|\$[a-zA-Z_]\w*)/',
         'number'        => '/' . $int . '/',
       ],
       'lua' => [
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|' .
                       '\[\[.*?\]\])/s',
         'comment'  => '/(--\[\[.*?\]\]|--[^\r\n]*)/ms',
         'keyword'  => '/\b(?:and|break|do|else|elseif|end|for|function|' .
                       'if|in|local|not|or|repeat|return|then|until|' .
                       'while)\b/',
         'boolean'  => '/\b(?:false|nil|true)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'javascript' => [
         'regex'    => '/(\/(?![/*])(?:\\\\.|[^\\/\r\n])+\/[a-zA-Z]*)/',
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|' .
                       '`(?:\\\\.|[^`\\\\])*`)/s',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'keyword'  => '/\b(?:as|async|await|break|case|catch|class|' .
                       'const|continue|debugger|default|delete|do|else|' .
                       'enum|export|extends|finally|for|from|function|if|' .
                       'import|in|instanceof|let|new|of|return|static|' .
                       'super|switch|this|throw|try|typeof|var|void|' .
                       'while|with|yield)\b/',
         'boolean'  => '/\b(?:true|false|null|undefined)\b/',
         'function' => '/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'typescript' => [
         'regex'    => '/(\/(?![/*])(?:\\\\.|[^\\/\r\n])+\/[a-zA-Z]*)/',
         'string'   => '/("(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|' .
                       '`(?:\\\\.|[^`\\\\])*`)/s',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:boolean|number|string|void|any|never|' .
                       'unknown|object|symbol|bigint)\b/',
         'keyword'  => '/\b(?:abstract|as|break|case|catch|class|const|' .
                       'continue|debugger|declare|default|delete|do|else|' .
                       'enum|export|extends|finally|for|from|function|if|' .
                       'implements|import|in|instanceof|interface|is|let|' .
                       'module|namespace|new|of|package|private|' .
                       'protected|public|readonly|require|return|static|' .
                       'super|switch|this|throw|try|type|typeof|var|' .
                       'while|with|yield)\b/',
         'boolean'  => '/\b(?:true|false|null|undefined)\b/',
         'function' => '/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'html' => [
         'comment'   => '/(<!--[\s\S]*?-->)/',
         'string'    => '/' . $str . '/',
         'tag'       => '/<\/?[!a-zA-Z0-9:-]+|\s*\/?>/',
         'attribute' => '/[a-zA-Z0-9:-]+(?=\=)/',
       ],
       'xml' => [
         'comment'   => '/(<!--[\s\S]*?-->)/',
         'string'    => '/' . $str . '/',
         'tag'       => '/<\/?[!a-zA-Z0-9:-]+|\s*\/?>|<\?xml|\?>/',
         'attribute' => '/[a-zA-Z0-9:-]+(?=\=)/',
       ],
       'xslt' => [
         'comment'   => '/(<!--[\s\S]*?-->)/',
         'string'    => '/' . $str . '/',
         'keyword'   => '/<\/?[a-zA-Z0-9-]*:?(?:accept|accumulator|' .
                        'accumulator-rule|analyze-string|apply-imports|' .
                        'apply-templates|assert|attribute|attribute-set|' .
                        'break|call-template|catch|character-map|choose|' .
                        'comment|context-item|copy|copy-of|' .
                        'decimal-format|document|element|evaluate|' .
                        'expose|fallback|for-each|for-each-group|fork|' .
                        'function|global-context-item|if|import|include|' .
                        'iterate|key|map|map-entry|matching-substring|' .
                        'merge|merge-action|merge-key|merge-source|' .
                        'message|mode|namespace|namespace-alias|' .
                        'next-iteration|next-match|' .
                        'non-matching-substring|on-empty|on-non-empty|' .
                        'otherwise|output|output-character|override|' .
                        'package|param|perform-sort|preserve-space|' .
                        'processing-instruction|result-document|sequence|' .
                        'sort|source-document|strip-space|stylesheet|' .
                        'template|text|transform|try|use-package|' .
                        'value-of|variable|when|where-populated|' .
                        'with-param)\b/',
         'function'  => '/\b[a-zA-Z_][a-zA-Z0-9_-]*\s*(?=\()/',
         'variable'  => '/\$[a-zA-Z0-9_-]+/',
         'tag'       => '/<\/?[!a-zA-Z0-9:-]+|\s*\/?>|<\?xml|\?>/',
         'attribute' => '/[a-zA-Z0-9:-]+(?=\=)/',
       ],
       'css' => [
         'comment'  => '/(\/\*.*?\*\/)/s',
         'tag'      => '/(?<=^|\}|\{)\s*([a-zA-Z0-9_\-#\.\s,>+~]+)(?=\{)/m',
         'property' => '/([a-zA-Z-]+)(?=\s*:)/',
         'string'   => '/' . $str . '/',
         'number'   => '/(-?(\d*\.)?\d+(px|em|rem|%|vh|vw|s|ms|deg))/',
       ],
       'json' => [
         'attribute' => '/("(?:\\\\.|[^"\\\\])*")(?=\s*:)/',
         'string'    => '/("(?:\\\\.|[^"\\\\])*")/',
         'boolean'   => '/\b(true|false|null)\b/',
         'number'    => '/\b(-?\d+(\.\d+)?([eE][+-]?\d+)?)\b/',
       ],
       'sql' => [
         'string'   => '/(\'.*?\')/',
         'comment'  => '/(--[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/(?i)\b(?:BIGINT|BIT|BOOLEAN|CHAR|DATE|DATETIME|' .
                       'DECIMAL|DOUBLE|FLOAT|INT|INTEGER|MONEY|NUMERIC|' .
                       'REAL|SMALLINT|TEXT|TIME|TIMESTAMP|TINYINT|' .
                       'VARCHAR)\b/',
         'keyword'  => '/(?i)\b(ADD|ALTER|AND|AS|ASC|BEGIN|BETWEEN|BY|' .
                       'CASE|CHECK|COLUMN|COMMIT|CONSTRAINT|CREATE|' .
                       'DATABASE|DEFAULT|DELETE|DESC|DISTINCT|DROP|ELSE|' .
                       'END|EXISTS|FOREIGN|FROM|FULL|FUNCTION|GRANT|' .
                       'GROUP|HAVING|IF|IN|INDEX|INNER|INSERT|INTO|IS|' .
                       'JOIN|KEY|LEFT|LIKE|LIMIT|NOT|NULL|OFFSET|ON|OR|' .
                       'ORDER|OUTER|PRIMARY|PROCEDURE|REFERENCES|REVOKE|' .
                       'RIGHT|ROLLBACK|SCHEMA|SELECT|SET|TABLE|THEN|' .
                       'TRANSACTION|TRIGGER|TRUNCATE|UNION|UNIQUE|' .
                       'UPDATE|VALUES|VIEW|WHEN|WHERE)\b/',
         'boolean'  => '/(?i)\b(NULL|TRUE|FALSE)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'yaml' => [
         'comment'       => '/(#[^\r\n]*)/m',
         'variable'      => '/^(\s*[a-zA-Z0-9_-]+:)/m',
         'string_interp' => '/((?<=:)\s*[^\r\n]*)/',
         'number'        => '/' . $float . '/',
       ],
       'properties' => [
         'comment'       => '/(^[ \t]*[#!][^\r\n]*)/m',
         'variable'      => '/(^[ \t]*[^:=\s]+)(?=[ \t]*[:=])/m',
         'string_interp' => '/((?<=[=:])\s*[^\r\n]*)/',
       ],
       'ini' => [
         'comment'   => '/(^[ \t]*[;#][^\r\n]*)/m',
         'keyword'   => '/(^\[[^\]\r\n]+\])/m',
         'variable'  => '/(^[ \t]*[a-zA-Z0-9_\.\-]+)(?=\s*=)/m',
         'string'    => '/((?<==)\s*[^\r\n]*)/',
       ],
       'toml' => [
         'comment'   => '/(#[^\r\n]*)/',
         'keyword'   => '/(^\[[^\]\r\n]+\])/m',
         'variable'  => '/(\b[a-zA-Z0-9_-]+\b)(?=\s*=)/',
         'string'    => '/(' . $str . '|"""[\s\S]*?"""|' .
                        '\'\'\'[\s\S]*?\'\'\')/',
         'boolean'   => '/\b(true|false)\b/',
         'date'      => '/(\d{4}-\d{2}-\d{2}(?:[Tt ]\d{2}:\d{2}:\d{2}' .
                        '(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?)/',
         'number'    => '/' . $float . '/',
       ],
       'markdown' => [
         'code'      => '/(^(?:    |\t)[^\n]*(?:\n(?:    |\t)[^\n]*)*)/',
         'comment'   => '/(```[\s\S]*?```|~~~[\s\S]*?~~~)/',
         'math'      => '/(\$((?:[^`\n$]|`[^`\n]*`)+)\$)/',
         'keyword'   => '/^(#{1,6})(?=\s)/m',
         'string'    => '/(\*\*[^\n*]+\*\*|__[^\n_]+__)/',
         'attribute' => '/(?<!\*)(\*[^\n*]+\*)(?!\*)|' .
                        '(?<!_)(_[^\n_]+_)(?!_)/',
         'function'  => '/(`[^`\n]+`)/',
         'variable'  => '/(\[[^\]]+\]\([^\)]+\))/',
         'operator'  => '/^(\s*[-*+](?=\s)|\s*\d+\.(?=\s))/m',
       ],
       'rmd' => [
         'code'      => '/(^(?:    |\t)[^\n]*(?:\n(?:    |\t)[^\n]*)*)/',
         'comment'   => '/(```\{r[^\}]*\}[\s\S]*?```)/',
         'math'      => '/(\$((?:[^`\n$]|`[^`\n]*`)+)\$)/',
         'keyword'   => '/^(#{1,6})(?=\s)/m',
         'string'    => '/(\*\*[^\n*]+\*\*|__[^\n_]+__)/',
         'attribute' => '/(?<!\*)(\*[^\n*]+\*)(?!\*)|' .
                        '(?<!_)(_[^\n_]+_)(?!_)/',
         'function'  => '/(`[^`\n]+`)/',
         'variable'  => '/(\[[^\]]+\]\([^\)]+\))/',
         'operator'  => '/^(\s*[-*+](?=\s)|\s*\d+\.(?=\s))/m',
       ],
       'r' => [
         'string'   => '/' . $str . '/',
         'comment'  => '/(#[^\r\n]*)/m',
         'keyword'  => '/\b(?:if|else|repeat|while|function|for|in|next|' .
                       'break)\b/',
         'boolean'  => '/\b(?:TRUE|FALSE|NULL|Inf|NaN|NA)\b/',
         'function' => '/\b([a-zA-Z_.][a-zA-Z0-9_.]*)\s*(?=\()/',
         'number'   => '/' . $float . '/',
       ],
       'csharp' => [
         'string'       => '/(@"(?:""|[^"])*"|' . $str . ')/',
         'comment'      => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'preprocessor' => '/(^\s*#[^\r\n]*)/m',
         'type'         => '/\b(?:bool|byte|char|decimal|double|float|' .
                           'int|long|object|sbyte|short|string|uint|' .
                           'ulong|ushort|void)\b/',
         'keyword'      => '/\b(?:abstract|as|base|break|case|catch|' .
                           'checked|class|const|continue|default|' .
                           'delegate|do|else|enum|event|explicit|extern|' .
                           'false|finally|fixed|for|foreach|goto|if|' .
                           'implicit|in|interface|internal|is|lock|' .
                           'namespace|new|null|operator|out|override|' .
                           'params|private|protected|public|readonly|ref|' .
                           'return|sealed|sizeof|stackalloc|static|' .
                           'struct|switch|this|throw|true|try|typeof|' .
                           'unchecked|unsafe|using|virtual|volatile|' .
                           'while)\b/',
         'function'     => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'       => '/' . $int . '/',
       ],
       'kotlin' => [
         'string'   => '/("""[\s\S]*?"""|' . $str . ')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:Boolean|Byte|Char|Double|Float|Int|Long|' .
                       'Short|String|Void|Unit|Any|Nothing)\b/',
         'keyword'  => '/\b(?:as|break|class|continue|do|else|false|for|' .
                       'fun|if|in|interface|is|null|object|package|' .
                       'return|super|this|throw|true|try|typealias|' .
                       'typeof|val|var|when|while)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'scala' => [
         'string'   => '/("""[\s\S]*?"""|' . $str . ')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:Boolean|Byte|Char|Double|Float|Int|Long|' .
                       'Short|String|Unit|Any|AnyRef|AnyVal|Nothing|' .
                       'Null|void)\b/',
         'keyword'  => '/\b(?:abstract|case|catch|class|def|do|else|' .
                       'extends|false|final|finally|for|forSome|if|' .
                       'implicit|import|lazy|match|new|null|object|' .
                       'override|package|private|protected|return|' .
                       'sealed|super|this|throw|trait|try|true|type|val|' .
                       'var|while|with|yield)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'groovy' => [
         'string'        => '/(\'\'\'[\s\S]*?\'\'\'|""".*?"""|' .
                            '"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'' .
                            '|\/[^\/]+\/)/',
         'comment'       => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'          => '/\b(?:boolean|byte|char|double|float|int|' .
                            'long|short|void)\b/',
         'keyword'       => '/\b(?:def|as|assert|break|case|catch|class|' .
                            'const|continue|default|do|else|enum|extends|' .
                            'false|finally|for|goto|if|implements|import|' .
                            'in|instanceof|interface|new|null|package|' .
                            'return|super|switch|this|throw|throws|trait|' .
                            'true|try|var|while)\b/',
         'function'      => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'        => '/' . $int . '/',
       ],
       'dart' => [
         'string'   => '/(r?\'\'\'[\s\S]*?\'\'\'|r?"""[\s\S]*?"""|' .
                       '"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:void|bool|int|double|num|dynamic)\b/',
         'keyword'  => '/\b(?:abstract|as|assert|async|await|break|case|' .
                       'catch|class|const|continue|default|do|else|enum|' .
                       'export|extends|extension|external|factory|false|' .
                       'final|finally|for|get|if|implements|import|in|' .
                       'interface|is|library|mixin|new|null|on|operator|' .
                       'part|rethrow|return|set|static|super|switch|' .
                       'sync|this|throw|true|try|typedef|var|while|with|' .
                       'yield)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'swift' => [
         'string'   => '/("""[\s\S]*?"""|' . $str . ')/',
         'comment'  => '/(\/\/[^\r\n]*|\/\*.*?\*\/)/ms',
         'type'     => '/\b(?:Int|Double|Float|Bool|String|Void|' .
                       'Character|Any|AnyObject)\b/',
         'keyword'  => '/\b(?:associatedtype|class|deinit|enum|' .
                       'extension|fileprivate|func|import|init|inout|' .
                       'internal|let|open|operator|private|protocol|' .
                       'public|rethrows|static|struct|subscript|' .
                       'typealias|var|break|case|continue|default|defer|' .
                       'do|else|fallthrough|for|guard|if|in|repeat|' .
                       'return|switch|where|while|as|catch|false|is|nil|' .
                       'super|self|Self|throw|throws|true|try)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'perl' => [
         'comment'  => '/(#[^\r\n]*)/',
         'string'   => '/(' . $str . '|`[^`]*`)/',
         'variable' => '/([$@%](?:\{[a-zA-Z_]\w*\}|[a-zA-Z_]\w*))/',
         'keyword'  => '/\b(?:my|local|our|state|use|sub|package|if|' .
                       'else|elsif|unless|while|until|for|foreach|do|' .
                       'last|next|redo|goto|continue|return|print|' .
                       'printf|say|die|warn|eval|try|catch)\b/',
         'number'   => '/' . $float . '/',
       ],
       'powershell' => [
         'comment'  => '/(<#[\s\S]*?#>|#[^\r\n]*)/',
         'string'   => '/(@"(?:""|[^"])*"@|@\'(?:[^[\'])*\'@|' .
                       '"(?:`.|[^"`])*"|\'(?:[^[\'])*\')/',
         'variable' => '/(\$[a-zA-Z0-9_]+)/',
         'keyword'  => '/(?i)\b(?:Begin|Break|Catch|Class|Continue|Data|' .
                       'Define|Do|DynamicParam|Else|ElseIf|End|Exit|' .
                       'Filter|Finally|For|ForEach|From|Function|If|In|' .
                       'InlineScript|Hidden|Parallel|Param|Process|' .
                       'Return|Sequence|Switch|Throw|Trap|Try|Until|' .
                       'Using|Var|While|Workflow)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_-]*)\s*(?=\()/',
         'number'   => '/' . $int . '/',
       ],
       'containerfile' => [
         'comment' => '/(#[^\r\n]*)/',
         'string'  => '/' . $str . '/',
         'keyword' => '/(?i)^\s*(?:FROM|MAINTAINER|RUN|CMD|LABEL|EXPOSE|' .
                      'ENV|ADD|COPY|ENTRYPOINT|VOLUME|USER|WORKDIR|ARG|' .
                      'ONBUILD|STOPSIGNAL|HEALTHCHECK|SHELL)\b/m',
       ],
       'makefile' => [
         'comment'  => '/(#[^\r\n]*)/',
         'variable' => '/(\$+[{(][^})]+[})])/',
         'keyword'  => '/(?i)\b(?:include|define|endef|export|override|' .
                       'ifdef|ifndef|ifeq|ifneq|else|endif|vpath)\b/',
         'function' => '/^([a-zA-Z0-9._-]+):/m',
       ],
       'diff' => [
         'comment'  => '/^(?:---| \+\+\+|index|diff).*/m',
         'meta'     => '/^(?:@@).*/m',
         'inserted' => '/(^\+.*)/m',
         'deleted'  => '/(^-.*)/m',
       ],
       'fortran' => [
         'comment'  => '/(^[Cc*][^\r\n]*|![^\r\n]*)/m',
         'string'   => '/(\'.*?\')/',
         'boolean'  => '/\B(\.(?:TRUE|FALSE)\.)\B/i',
         'operator' => '/\B(\.(?:EQ|NE|LT|LE|GT|GE|NOT|' .
                       'AND|OR|EQV|NEQV)\.)\B/i',
         'type'     => '/(?i)\b(?:INTEGER(?:\*[0-9]+)?|' .
                       'REAL(?:\*[0-9]+)?|DOUBLE PRECISION|' .
                       'COMPLEX|LOGICAL(?:\*[0-9]+)?|CHARACTER)\b/',
         'keyword'  => '/(?i)\b(?:IMPLICIT|COMMON|CALL|GO\s*TO|IF|' .
                       'READ|PRINT|WRITE|STOP|REWIND|FORMAT|END|' .
                       'SUBROUTINE|RETURN|EQUIVALENCE|DATA|' .
                       'BLOCK\s*DATA|FUNCTION|DO|CONTINUE|THEN|ELSE|' .
                       'ELSEIF|ENDIF|SAVE|DIMENSION|PAUSE|ASSIGN|TO)\b/',
         'function' => '/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/',
         'number'   => '/\b(\d+(\.\d+)?([eEdD][+-]?\d+)?)\b/',
         'label'    => '/^[ \t]*([0-9]+)/m'
+      ]
     ];
     if( array_key_exists( $normalized, $rules ) ) {
       $result = $rules[$normalized];
+    }
     return $result;
+  }
+}

M styles/repo.css

 .blob-code pre {
     overflow-x: auto;
+}
 .refs-list {
   display: grid;
   gap: 10px;
+}
 .ref-item {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   padding: 12px 16px;
   display: flex;
   align-items: center;
   gap: 12px;
+}
 .ref-type {
   background: #238636;
   color: white;
   padding: 2px 8px;
   border-radius: 12px;
   font-size: 0.75rem;
   font-weight: 600;
   text-transform: uppercase;
+}
 .ref-type.tag {
   background: #8957e5;
+}
 .ref-name {
   font-weight: 600;
   color: #f0f6fc;
+}
 .empty-state {
   text-align: center;
   padding: 60px 20px;
   color: #8b949e;
+}
 .commit-details {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   padding: 20px;
   margin-bottom: 20px;
+}
 .commit-header {
   margin-bottom: 20px;
+}
 .commit-title {
   font-size: 1.25rem;
   color: #f0f6fc;
   margin-bottom: 10px;
+}
 .commit-info {
   display: grid;
   gap: 8px;
   font-size: 0.875rem;
+}
 .commit-info-row {
   display: flex;
   gap: 10px;
+}
 .commit-info-label {
   color: #8b949e;
   width: 80px;
   flex-shrink: 0;
+}
 .commit-info-value {
   color: #c9d1d9;
   font-family: monospace;
+}
 .parent-link {
   color: #58a6ff;
   text-decoration: none;
+}
 .parent-link:hover {
   text-decoration: underline;
+}
 .repo-grid {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
   gap: 16px;
   margin-top: 20px;
+}
 .repo-card {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 8px;
   padding: 20px;
   text-decoration: none;
   color: inherit;
   transition: border-color 0.2s, transform 0.1s;
+}
 .repo-card:hover {
   border-color: #58a6ff;
   transform: translateY(-2px);
+}
 .repo-card h3 {
   color: #58a6ff;
   margin-bottom: 8px;
   font-size: 1.1rem;
+}
 .repo-card p {
   color: #8b949e;
   font-size: 0.875rem;
   margin: 0;
+}
 .current-repo {
   background: #21262d;
   border: 1px solid #58a6ff;
   padding: 8px 16px;
   border-radius: 6px;
   font-size: 0.875rem;
   color: #f0f6fc;
+}
 .current-repo strong {
   color: #58a6ff;
+}
 .branch-badge {
   background: #238636;
   color: white;
   padding: 2px 8px;
   border-radius: 12px;
   font-size: 0.75rem;
   font-weight: 600;
   margin-left: 10px;
+}
 .commit-row {
   display: flex;
   padding: 10px 0;
   border-bottom: 1px solid #30363d;
   gap: 15px;
   align-items: baseline;
+}
 .commit-row:last-child {
   border-bottom: none;
+}
 .commit-row .sha {
   font-family: monospace;
   color: #58a6ff;
   text-decoration: none;
+}
 .commit-row .message {
   flex: 1;
   font-weight: 500;
+}
 .commit-row .meta {
   font-size: 0.85em;
   color: #8b949e;
   white-space: nowrap;
+}
 .blob-content-image {
   text-align: center;
   padding: 20px;
   background: #0d1117;
+}
 .blob-content-image img {
   max-width: 100%;
   border: 1px solid #30363d;
+}
 .blob-content-video {
   text-align: center;
   padding: 20px;
   background: #000;
+}
 .blob-content-video video {
   max-width: 100%;
   max-height: 80vh;
+}
 .blob-content-audio {
   text-align: center;
   padding: 40px;
   background: #161b22;
+}
 .blob-content-audio audio {
   width: 100%;
   max-width: 600px;
+}
 .download-state {
   text-align: center;
   padding: 40px;
   border: 1px solid #30363d;
   border-radius: 6px;
   margin-top: 10px;
+}
 .download-state p {
   margin-bottom: 20px;
   color: #8b949e;
+}
 .btn-download {
   display: inline-block;
   padding: 6px 16px;
   background: #238636;
   color: white;
   text-decoration: none;
   border-radius: 6px;
   font-weight: 600;
+}
 .repo-info-banner {
   margin-top: 15px;
+}
 .file-icon-container {
   width: 20px;
   text-align: center;
   margin-right: 5px;
   color: #8b949e;
+}
 .file-size {
   color: #8b949e;
   font-size: 0.8em;
   margin-left: 10px;
+}
 .file-date {
   color: #8b949e;
   font-size: 0.8em;
   margin-left: auto;
+}
 .repo-card-time {
   margin-top: 8px;
   color: #58a6ff;
+}
 .diff-container {
   display: flex;
   flex-direction: column;
   gap: 20px;
+}
 .diff-file {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   overflow: hidden;
+}
 .diff-header {
   background: #21262d;
   padding: 10px 16px;
   border-bottom: 1px solid #30363d;
   display: flex;
   align-items: center;
   gap: 10px;
+}
 .diff-path {
   font-family: monospace;
   font-size: 0.9rem;
   color: #f0f6fc;
+}
 .diff-binary {
   padding: 20px;
   text-align: center;
   color: #8b949e;
   font-style: italic;
+}
 .diff-content {
   overflow-x: auto;
+}
 .diff-content table {
   width: 100%;
   border-collapse: collapse;
   font-family: 'SFMono-Regular', Consolas, monospace;
   font-size: 12px;
+}
 .diff-content td {
   padding: 2px 0;
   line-height: 20px;
+}
 .diff-num {
   width: 1%;
   min-width: 40px;
   text-align: right;
   padding-right: 10px;
   color: #6e7681;
   user-select: none;
   background: #0d1117;
   border-right: 1px solid #30363d;
+}
 .diff-num::before {
   content: attr(data-num);
+}
 .diff-code {
   padding-left: 10px;
   white-space: pre-wrap;
   word-break: break-all;
   color: #c9d1d9;
+}
 .diff-marker {
   display: inline-block;
   width: 15px;
   user-select: none;
   color: #8b949e;
+}
 /* Protanopia Safe Colors: Blue (Add) and Yellow (Del) */
 .diff-add {
   background-color: rgba(2, 59, 149, 0.25);
+}
 .diff-add .diff-code {
   color: #79c0ff;
+}
 .diff-add .diff-marker {
   color: #79c0ff;
+}
 .diff-del {
   background-color: rgba(148, 99, 0, 0.25);
+}
 .diff-del .diff-code {
   color: #d29922;
+}
 .diff-del .diff-marker {
   color: #d29922;
+}
 .diff-gap {
   background: #0d1117;
   color: #484f58;
   text-align: center;
   font-size: 0.8em;
   height: 20px;
+}
 .diff-gap td {
   padding: 0;
   line-height: 20px;
   background: rgba(110, 118, 129, 0.1);
+}
 .status-add { color: #58a6ff; }
 .status-del { color: #d29922; }
 .status-mod { color: #a371f7; }
 .tag-table, .file-list-table {
   width: 100%;
   border-collapse: collapse;
   margin-top: 10px;
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   overflow: hidden;
+}
 .tag-table th, .file-list-table th {
   text-align: left;
   padding: 10px 16px;
   border-bottom: 2px solid #30363d;
   color: #8b949e;
   font-size: 0.875rem;
   font-weight: 600;
   white-space: nowrap;
+}
 .tag-table td, .file-list-table td {
   padding: 12px 16px;
   border-bottom: 1px solid #21262d;
   vertical-align: middle;
   color: #c9d1d9;
   font-size: 0.9rem;
+}
 .tag-table tr:hover td, .file-list-table tr:hover td {
   background: #161b22;
+}
 .tag-table .tag-name {
   min-width: 140px;
   width: 20%;
+}
 .tag-table .tag-message {
   width: auto;
   white-space: normal;
   word-break: break-word;
   color: #c9d1d9;
   font-weight: 500;
+}
 .tag-table .tag-author,
 .tag-table .tag-time,
 .tag-table .tag-hash {
   width: 1%;
   white-space: nowrap;
+}
 .tag-table .tag-time {
   text-align: right;
   color: #8b949e;
+}
 .tag-table .tag-hash {
   text-align: right;
+}
 .tag-table .tag-name a {
   color: #58a6ff;
   text-decoration: none;
   font-family: 'SFMono-Regular', Consolas, monospace;
+}
 .tag-table .tag-author {
   color: #c9d1d9;
+}
 .tag-table .tag-age-header {
   text-align: right;
+}
 .tag-table .tag-commit-header {
   text-align: right;
+}
 .tag-table .commit-hash {
   font-family: 'SFMono-Regular', Consolas, monospace;
   color: #58a6ff;
   text-decoration: none;
+}
 .tag-table .commit-hash:hover {
   text-decoration: underline;
+}
 .file-list-table .file-icon-cell {
     width: 20px;
     text-align: center;
     color: #8b949e;
     padding-right: 0;
+}
 .file-list-table .file-name-cell a {
     color: #58a6ff;
     text-decoration: none;
     font-weight: 500;
+}
 .file-list-table .file-name-cell a:hover {
     text-decoration: underline;
+}
 .file-list-table .file-mode-cell {
     font-family: 'SFMono-Regular', Consolas, monospace;
     color: #8b949e;
     font-size: 0.8rem;
     width: 1%;
     white-space: nowrap;
     text-align: center;
+}
 .file-list-table .file-size-cell {
     color: #8b949e;
     text-align: right;
     width: 1%;
     white-space: nowrap;
     font-size: 0.85rem;
+}
 .file-list-table .file-date-cell {
     color: #8b949e;
     text-align: right;
     width: 150px;
     font-size: 0.85rem;
     white-space: nowrap;
+}
 .blob-code {
   font-family: 'SFMono-Regular', Consolas, monospace;
   background-color: #161b22;
   color: #fcfcfa;
   font-size: 0.875rem;
   line-height: 1.6;
   tab-size: 2;
+}
 .hl-comment,
 .hl-doc-comment {
   color: #727072;
   font-style: italic;
+}
 .hl-function,
 .hl-method {
   color: #78dce8;
+}
 .hl-tag {
   color: #3e8bff;
+}
 .hl-class,
 .hl-interface,
 .hl-struct {
   color: #a9dc76;
+}
 .hl-type {
   color: #a9dc76;
+}
 .hl-keyword,
 .hl-storage,
 .hl-modifier,
 .hl-statement {
   color: #ff6188;
   font-weight: 600;
+}
 .hl-string,
 .hl-string_interp {
   color: #ffd866;
+}
 .hl-number,
 .hl-boolean,
 .hl-constant,
 .hl-preprocessor {
   color: #ab9df2;
+}
 .hl-variable {
   color: #fcfcfa;
+}
 .hl-attribute,
 .hl-property {
   color: #fc9867;
+}
 .hl-operator,
 .hl-punctuation,
 .hl-escape {
   color: #939293;
+}
 .hl-interp-punct {
   color: #ff6188;
+}
 .hl-math {
   color: #ab9df2;
   font-style: italic;
+}
 .hl-code {
   display: inline-block;
   width: 100%;
   background-color: #0d1117;
   color: #c9d1d9;
   padding: 2px 4px;
   border-radius: 3px;
+}
 @media (max-width: 768px) {
   .container {
     padding: 10px;
+  }
   h1 { font-size: 1.5rem; }
   h2 { font-size: 1.2rem; }
   .nav {
     flex-direction: column;
     align-items: flex-start;
     gap: 10px;
+  }
   .repo-selector {
     margin-left: 0;
     width: 100%;
+  }
   .repo-selector select {
     flex: 1;
+  }
   .file-list-table th,
   .file-list-table td {
     padding: 8px 10px;
+  }
   .file-list-table .file-mode-cell,
   .file-list-table .file-date-cell {
     display: none;
+  }
   .commit-details {
     padding: 15px;
+  }
   .commit-title {
     font-size: 1.1rem;
     word-break: break-word;
+  }
   .commit-info-row {
     flex-direction: column;
     gap: 2px;
     margin-bottom: 10px;
+  }
   .commit-info-label {
     width: 100%;
     font-size: 0.8rem;
     color: #8b949e;
+  }
   .commit-info-value {
     word-break: break-all;
     font-family: 'SFMono-Regular', Consolas, monospace;
     font-size: 0.9rem;
     padding-left: 0;
+  }
   .commit-row {
     flex-direction: column;
     gap: 5px;
+  }
   .commit-row .message {
     width: 100%;
     white-space: normal;
+  }
   .commit-row .meta {
     font-size: 0.8rem;
+  }
   .tag-table .tag-author,
   .tag-table .tag-time,
   .tag-table .tag-hash {
     font-size: 0.8rem;
+  }
   .blob-code, .diff-content {
     overflow-x: scroll;
     -webkit-overflow-scrolling: touch;
+  }
+}
 @media screen and (orientation: landscape) and (max-height: 600px) {
   .container {
     max-width: 100%;
+  }
   header {
     margin-bottom: 15px;
     padding-bottom: 10px;
+  }
   .file-list-table .file-date-cell {
     display: table-cell;
+  }
   overflow-x: auto;
+}
 .refs-list {
   display: grid;
   gap: 10px;
+}
 .ref-item {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   padding: 12px 16px;
   display: flex;
   align-items: center;
   gap: 12px;
+}
 .ref-type {
   background: #238636;
   color: white;
   padding: 2px 8px;
   border-radius: 12px;
   font-size: 0.75rem;
   font-weight: 600;
   text-transform: uppercase;
+}
 .ref-type.tag {
   background: #8957e5;
+}
 .ref-name {
   font-weight: 600;
   color: #f0f6fc;
+}
 .empty-state {
   text-align: center;
   padding: 60px 20px;
   color: #8b949e;
+}
 .commit-details {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   padding: 20px;
   margin-bottom: 20px;
+}
 .commit-header {
   margin-bottom: 20px;
+}
 .commit-title {
   font-size: 1.25rem;
   color: #f0f6fc;
   margin-bottom: 10px;
+}
 .commit-info {
   display: grid;
   gap: 8px;
   font-size: 0.875rem;
+}
 .commit-info-row {
   display: flex;
   gap: 10px;
+}
 .commit-info-label {
   color: #8b949e;
   width: 80px;
   flex-shrink: 0;
+}
 .commit-info-value {
   color: #c9d1d9;
   font-family: monospace;
+}
 .parent-link {
   color: #58a6ff;
   text-decoration: none;
+}
 .parent-link:hover {
   text-decoration: underline;
+}
 .repo-grid {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
   gap: 16px;
   margin-top: 20px;
+}
 .repo-card {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 8px;
   padding: 20px;
   text-decoration: none;
   color: inherit;
   transition: border-color 0.2s, transform 0.1s;
+}
 .repo-card:hover {
   border-color: #58a6ff;
   transform: translateY(-2px);
+}
 .repo-card h3 {
   color: #58a6ff;
   margin-bottom: 8px;
   font-size: 1.1rem;
+}
 .repo-card p {
   color: #8b949e;
   font-size: 0.875rem;
   margin: 0;
+}
 .current-repo {
   background: #21262d;
   border: 1px solid #58a6ff;
   padding: 8px 16px;
   border-radius: 6px;
   font-size: 0.875rem;
   color: #f0f6fc;
+}
 .current-repo strong {
   color: #58a6ff;
+}
 .branch-badge {
   background: #238636;
   color: white;
   padding: 2px 8px;
   border-radius: 12px;
   font-size: 0.75rem;
   font-weight: 600;
   margin-left: 10px;
+}
 .commit-row {
   display: flex;
   padding: 10px 0;
   border-bottom: 1px solid #30363d;
   gap: 15px;
   align-items: baseline;
+}
 .commit-row:last-child {
   border-bottom: none;
+}
 .commit-row .sha {
   font-family: monospace;
   color: #58a6ff;
   text-decoration: none;
+}
 .commit-row .message {
   flex: 1;
   font-weight: 500;
+}
 .commit-row .meta {
   font-size: 0.85em;
   color: #8b949e;
   white-space: nowrap;
+}
 .blob-content-image {
   text-align: center;
   padding: 20px;
   background: #0d1117;
+}
 .blob-content-image img {
   max-width: 100%;
   border: 1px solid #30363d;
+}
 .blob-content-video {
   text-align: center;
   padding: 20px;
   background: #000;
+}
 .blob-content-video video {
   max-width: 100%;
   max-height: 80vh;
+}
 .blob-content-audio {
   text-align: center;
   padding: 40px;
   background: #161b22;
+}
 .blob-content-audio audio {
   width: 100%;
   max-width: 600px;
+}
 .download-state {
   text-align: center;
   padding: 40px;
   border: 1px solid #30363d;
   border-radius: 6px;
   margin-top: 10px;
+}
 .download-state p {
   margin-bottom: 20px;
   color: #8b949e;
+}
 .btn-download {
   display: inline-block;
   padding: 6px 16px;
   background: #238636;
   color: white;
   text-decoration: none;
   border-radius: 6px;
   font-weight: 600;
+}
 .repo-info-banner {
   margin-top: 15px;
+}
 .file-icon-container {
   width: 20px;
   text-align: center;
   margin-right: 5px;
   color: #8b949e;
+}
 .file-size {
   color: #8b949e;
   font-size: 0.8em;
   margin-left: 10px;
+}
 .file-date {
   color: #8b949e;
   font-size: 0.8em;
   margin-left: auto;
+}
 .repo-card-time {
   margin-top: 8px;
   color: #58a6ff;
+}
 .diff-container {
   display: flex;
   flex-direction: column;
   gap: 20px;
+}
 .diff-file {
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   overflow: hidden;
+}
 .diff-header {
   background: #21262d;
   padding: 10px 16px;
   border-bottom: 1px solid #30363d;
   display: flex;
   align-items: center;
   gap: 10px;
+}
 .diff-path {
   font-family: monospace;
   font-size: 0.9rem;
   color: #f0f6fc;
+}
 .diff-binary {
   padding: 20px;
   text-align: center;
   color: #8b949e;
   font-style: italic;
+}
 .diff-content {
   overflow-x: auto;
+}
 .diff-content table {
   width: 100%;
   border-collapse: collapse;
   font-family: 'SFMono-Regular', Consolas, monospace;
   font-size: 12px;
+}
 .diff-content td {
   padding: 2px 0;
   line-height: 20px;
+}
 .diff-num {
   width: 1%;
   min-width: 40px;
   text-align: right;
   padding-right: 10px;
   color: #6e7681;
   user-select: none;
   background: #0d1117;
   border-right: 1px solid #30363d;
+}
 .diff-num::before {
   content: attr(data-num);
+}
 .diff-code {
   padding-left: 10px;
   white-space: pre-wrap;
   word-break: break-all;
   color: #c9d1d9;
+}
 .diff-marker {
   display: inline-block;
   width: 15px;
   user-select: none;
   color: #8b949e;
+}
 .diff-add {
   background-color: rgba(2, 59, 149, 0.25);
+}
 .diff-add .diff-code {
   color: #79c0ff;
+}
 .diff-add .diff-marker {
   color: #79c0ff;
+}
 .diff-del {
   background-color: rgba(148, 99, 0, 0.25);
+}
 .diff-del .diff-code {
   color: #d29922;
+}
 .diff-del .diff-marker {
   color: #d29922;
+}
 .diff-gap {
   background: #0d1117;
   color: #484f58;
   text-align: center;
   font-size: 0.8em;
   height: 20px;
+}
 .diff-gap td {
   padding: 8px 0;
   background: #161b22;
   border-top: 1px solid #30363d;
   border-bottom: 1px solid #30363d;
   text-align: center;
+}
 .diff-gap-icon {
   vertical-align: middle;
+}
 .status-add { color: #58a6ff; }
 .status-del { color: #d29922; }
 .status-mod { color: #a371f7; }
 .tag-table, .file-list-table {
   width: 100%;
   border-collapse: collapse;
   margin-top: 10px;
   background: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
   overflow: hidden;
+}
 .tag-table th, .file-list-table th {
   text-align: left;
   padding: 10px 16px;
   border-bottom: 2px solid #30363d;
   color: #8b949e;
   font-size: 0.875rem;
   font-weight: 600;
   white-space: nowrap;
+}
 .tag-table td, .file-list-table td {
   padding: 12px 16px;
   border-bottom: 1px solid #21262d;
   vertical-align: middle;
   color: #c9d1d9;
   font-size: 0.9rem;
+}
 .tag-table tr:hover td, .file-list-table tr:hover td {
   background: #161b22;
+}
 .tag-table .tag-name {
   min-width: 140px;
   width: 20%;
+}
 .tag-table .tag-message {
   width: auto;
   white-space: normal;
   word-break: break-word;
   color: #c9d1d9;
   font-weight: 500;
+}
 .tag-table .tag-author,
 .tag-table .tag-time,
 .tag-table .tag-hash {
   width: 1%;
   white-space: nowrap;
+}
 .tag-table .tag-time {
   text-align: right;
   color: #8b949e;
+}
 .tag-table .tag-hash {
   text-align: right;
+}
 .tag-table .tag-name a {
   color: #58a6ff;
   text-decoration: none;
   font-family: 'SFMono-Regular', Consolas, monospace;
+}
 .tag-table .tag-author {
   color: #c9d1d9;
+}
 .tag-table .tag-age-header {
   text-align: right;
+}
 .tag-table .tag-commit-header {
   text-align: right;
+}
 .tag-table .commit-hash {
   font-family: 'SFMono-Regular', Consolas, monospace;
   color: #58a6ff;
   text-decoration: none;
+}
 .tag-table .commit-hash:hover {
   text-decoration: underline;
+}
 .file-list-table .file-icon-cell {
   width: 20px;
   text-align: center;
   color: #8b949e;
   padding-right: 0;
+}
 .file-list-table .file-name-cell a {
   color: #58a6ff;
   text-decoration: none;
   font-weight: 500;
+}
 .file-list-table .file-name-cell a:hover {
   text-decoration: underline;
+}
 .file-list-table .file-mode-cell {
   font-family: 'SFMono-Regular', Consolas, monospace;
   color: #8b949e;
   font-size: 0.8rem;
   width: 1%;
   white-space: nowrap;
   text-align: center;
+}
 .file-list-table .file-size-cell {
   color: #8b949e;
   text-align: right;
   width: 1%;
   white-space: nowrap;
   font-size: 0.85rem;
+}
 .file-list-table .file-date-cell {
   color: #8b949e;
   text-align: right;
   width: 150px;
   font-size: 0.85rem;
   white-space: nowrap;
+}
 .blob-code {
   font-family: 'SFMono-Regular', Consolas, monospace;
   background-color: #161b22;
   color: #fcfcfa;
   font-size: 0.875rem;
   line-height: 1.6;
   tab-size: 2;
+}
 .hl-comment,
 .hl-doc-comment {
   color: #727072;
   font-style: italic;
+}
 .hl-function,
 .hl-method {
   color: #78dce8;
+}
 .hl-tag {
   color: #3e8bff;
+}
 .hl-class,
 .hl-interface,
 .hl-struct {
   color: #a9dc76;
+}
 .hl-type {
   color: #a9dc76;
+}
 .hl-keyword,
 .hl-storage,
 .hl-modifier,
 .hl-statement {
   color: #ff6188;
   font-weight: 600;
+}
 .hl-string,
 .hl-string_interp {
   color: #ffd866;
+}
 .hl-number,
 .hl-boolean,
 .hl-constant,
 .hl-preprocessor {
   color: #ab9df2;
+}
 .hl-variable {
   color: #fcfcfa;
+}
 .hl-attribute,
 .hl-property {
   color: #fc9867;
+}
 .hl-operator,
 .hl-punctuation,
 .hl-escape {
   color: #939293;
+}
 .hl-interp-punct {
   color: #ff6188;
+}
 .hl-math {
   color: #ab9df2;
   font-style: italic;
+}
 .hl-code {
   display: inline-block;
   width: 100%;
   background-color: #0d1117;
   color: #c9d1d9;
   padding: 2px 4px;
   border-radius: 3px;
+}
 @media (max-width: 768px) {
   .container {
     padding: 10px;
+  }
   h1 { font-size: 1.5rem; }
   h2 { font-size: 1.2rem; }
   .nav {
     flex-direction: column;
     align-items: flex-start;
     gap: 10px;
+  }
   .repo-selector {
     margin-left: 0;
     width: 100%;
+  }
   .repo-selector select {
     flex: 1;
+  }
   .file-list-table th,
   .file-list-table td {
     padding: 8px 10px;
+  }
   .file-list-table .file-mode-cell,
   .file-list-table .file-date-cell {
     display: none;
+  }
   .commit-details {
     padding: 15px;
+  }
   .commit-title {
     font-size: 1.1rem;
     word-break: break-word;
+  }
   .commit-info-row {
     flex-direction: column;
     gap: 2px;
     margin-bottom: 10px;
+  }
   .commit-info-label {
     width: 100%;
     font-size: 0.8rem;
     color: #8b949e;
+  }
   .commit-info-value {
     word-break: break-all;
     font-family: 'SFMono-Regular', Consolas, monospace;
     font-size: 0.9rem;
     padding-left: 0;
+  }
   .commit-row {
     flex-direction: column;
     gap: 5px;
+  }
   .commit-row .message {
     width: 100%;
     white-space: normal;
+  }
   .commit-row .meta {
     font-size: 0.8rem;
+  }
   .tag-table .tag-author,
   .tag-table .tag-time,
   .tag-table .tag-hash {
     font-size: 0.8rem;
+  }
   .blob-code, .diff-content {
     overflow-x: scroll;
     -webkit-overflow-scrolling: touch;
+  }
+}
 @media screen and (orientation: landscape) and (max-height: 600px) {
   .container {
     max-width: 100%;
+  }
   header {
     margin-bottom: 15px;
     padding-bottom: 10px;
+  }
   .file-list-table .file-date-cell {
     display: table-cell;
+  }
+}
 .clone-checkbox {
   display: none;
+}
 .clone-link {
   cursor: pointer;
   color: #58a6ff;
   text-decoration: none;
+}
 .clone-link:hover {
   text-decoration: underline;
+}
 .clone-region {
   display: none;
   margin-top: 10px;
   padding: 10px;
   background-color: #161b22;
   border: 1px solid #30363d;
   border-radius: 6px;
+}
 .clone-checkbox:checked ~ .clone-region {
   display: block;
+}
 .clone-wrapper {
   display: inline-grid;
   vertical-align: top;
+}
 .clone-sizer {
   grid-area: 1 / 1;
   visibility: hidden;
   white-space: pre;
   font-family: monospace;
   font-size: 13px;
   padding: 8px;
   border: 1px solid transparent;
+}
 .clone-input {
   grid-area: 1 / 1;
   width: 100%;
   padding: 8px;
   background: #0d1117;
   color: #c9d1d9;
   border: 1px solid #30363d;
   border-radius: 4px;
   font-family: monospace;
   font-size: 13px;
   box-sizing: border-box;
+}