Linker.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Linker;
 
use MediaWiki\Context\ContextSource;
use MediaWiki\Context\DerivativeContext;
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\FileRepo\File\File;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Html\Html;
use MediaWiki\Html\HtmlHelper;
use MediaWiki\Language\MessageLocalizer;
use MediaWiki\MainConfigNames;
use MediaWiki\Media\MediaTransformError;
use MediaWiki\Media\MediaTransformOutput;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Parser\Parser;
use MediaWiki\Permissions\Authority;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleValue;
use MediaWiki\User\ExternalUserNames;
use MediaWiki\User\UserIdentityValue;
use Wikimedia\Assert\Assert;
use Wikimedia\HtmlArmor\HtmlArmor;
use Wikimedia\Rdbms\SelectQueryBuilder;
use Wikimedia\RemexHtml\Serializer\SerializerNode;
 
class Linker {
    public const TOOL_LINKS_NOBLOCK = 1;
    public const TOOL_LINKS_EMAIL = 2;
 
    public static function link(
        $target, $html = null, $customAttribs = [], $query = [], $options = []
    ) {
        if ( !$target instanceof LinkTarget ) {
            wfWarn( __METHOD__ . ': Requires $target to be a LinkTarget object.', 2 );
            return "<!-- ERROR -->$html";
        }
 
        $options = (array)$options;
        $linkRenderer = self::getLinkRenderer( $options );
 
        if ( $html !== null ) {
            $text = new HtmlArmor( $html );
        } else {
            $text = null;
        }
 
        if ( in_array( 'known', $options, true ) ) {
            return $linkRenderer->makeKnownLink( $target, $text, $customAttribs, $query );
        }
 
        if ( in_array( 'broken', $options, true ) ) {
            return $linkRenderer->makeBrokenLink( $target, $text, $customAttribs, $query );
        }
 
        if ( in_array( 'noclasses', $options, true ) ) {
            return $linkRenderer->makePreloadedLink( $target, $text, '', $customAttribs, $query );
        }
 
        return $linkRenderer->makeLink( $target, $text, $customAttribs, $query );
    }
 
    public static function linkKnown(
        $target, $html = null, $customAttribs = [],
        $query = [], $options = [ 'known' ]
    ) {
        return self::link( $target, $html, $customAttribs, $query, $options );
    }
 
    public static function makeSelfLinkObj( $nt, $html = '', $query = '', $trail = '', $prefix = '', $hash = '' ) {
        $nt = Title::newFromLinkTarget( $nt );
        $attrs = [];
        if ( $hash ) {
            $attrs['class'] = 'mw-selflink-fragment';
            $attrs['href'] = '#' . $hash;
        } else {
            // For backwards compatibility with gadgets we add selflink as well.
            $attrs['class'] = 'mw-selflink selflink';
        }
        $ret = Html::rawElement( 'a', $attrs, $prefix . $html ) . $trail;
        $hookRunner = new HookRunner( MediaWikiServices::getInstance()->getHookContainer() );
        if ( !$hookRunner->onSelfLinkBegin( $nt, $html, $trail, $prefix, $ret ) ) {
            return $ret;
        }
 
        if ( $html == '' ) {
            $html = htmlspecialchars( $nt->getPrefixedText() );
        }
        [ $inside, $trail ] = self::splitTrail( $trail );
        return Html::rawElement( 'a', $attrs, $prefix . $html . $inside ) . $trail;
    }
 
    public static function getInvalidTitleDescription( IContextSource $context, $namespace, $title ) {
        // First we check whether the namespace exists or not.
        if ( MediaWikiServices::getInstance()->getNamespaceInfo()->exists( $namespace ) ) {
            if ( $namespace == NS_MAIN ) {
                $name = $context->msg( 'blanknamespace' )->text();
            } else {
                $name = MediaWikiServices::getInstance()->getContentLanguage()->
                    getFormattedNsText( $namespace );
            }
            return $context->msg( 'invalidtitle-knownnamespace', $namespace, $name, $title )->text();
        }
 
        return $context->msg( 'invalidtitle-unknownnamespace', $namespace, $title )->text();
    }
 
    private static function fnamePart( $url ) {
        $basename = strrchr( $url, '/' );
        if ( $basename === false ) {
            $basename = $url;
        } else {
            $basename = substr( $basename, 1 );
        }
        return $basename;
    }
 
    public static function makeExternalImage( $url, $alt = '' ) {
        if ( $alt == '' ) {
            $alt = self::fnamePart( $url );
        }
        $img = '';
        $success = ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
            ->onLinkerMakeExternalImage( $url, $alt, $img );
        if ( !$success ) {
            wfDebug( "Hook LinkerMakeExternalImage changed the output of external image "
                . "with url {$url} and alt text {$alt} to {$img}" );
            return $img;
        }
        return Html::element( 'img',
            [
                'src' => $url,
                'alt' => $alt
            ]
        );
    }
 
    public static function makeImageLink( Parser $parser, LinkTarget $title,
        $file, $frameParams = [], $handlerParams = [], $time = false,
        $query = '', $widthOption = null
    ) {
        $title = Title::newFromLinkTarget( $title );
        $res = null;
        $hookRunner = new HookRunner( MediaWikiServices::getInstance()->getHookContainer() );
        if ( !$hookRunner->onImageBeforeProduceHTML( null, $title,
            // @phan-suppress-next-line PhanTypeMismatchArgument Type mismatch on pass-by-ref args
            $file, $frameParams, $handlerParams, $time, $res,
            // @phan-suppress-next-line PhanTypeMismatchArgument Type mismatch on pass-by-ref args
            $parser, $query, $widthOption )
        ) {
            return $res;
        }
 
        if ( $file && !$file->allowInlineDisplay() ) {
            wfDebug( __METHOD__ . ': ' . $title->getPrefixedDBkey() . ' does not allow inline display' );
            return self::link( $title );
        }
 
        // Clean up parameters
        $page = $handlerParams['page'] ?? false;
        if ( !isset( $frameParams['align'] ) ) {
            $frameParams['align'] = '';
        }
        if ( !isset( $frameParams['title'] ) ) {
            $frameParams['title'] = '';
        }
        if ( !isset( $frameParams['class'] ) ) {
            $frameParams['class'] = '';
        }
 
        $services = MediaWikiServices::getInstance();
        $config = $services->getMainConfig();
 
        $classes = [];
        if (
            !isset( $handlerParams['width'] ) &&
            !isset( $frameParams['manualthumb'] ) &&
            !isset( $frameParams['framed'] )
        ) {
            $classes[] = 'mw-default-size';
        }
 
        $prefix = $postfix = '';
 
        if ( $file && !isset( $handlerParams['width'] ) ) {
            if ( isset( $handlerParams['height'] ) && $file->isVectorized() ) {
                // If its a vector image, and user only specifies height
                // we don't want it to be limited by its "normal" width.
                $svgMaxSize = $config->get( MainConfigNames::SVGMaxSize );
                $handlerParams['width'] = $svgMaxSize;
            } else {
                $handlerParams['width'] = $file->getWidth( $page );
            }
 
            if ( isset( $frameParams['thumbnail'] )
                || isset( $frameParams['manualthumb'] )
                || isset( $frameParams['framed'] )
                || isset( $frameParams['frameless'] )
                || !$handlerParams['width']
            ) {
                $thumbLimits = $config->get( MainConfigNames::ThumbLimits );
                $thumbUpright = $config->get( MainConfigNames::ThumbUpright );
                if ( $widthOption === null || !isset( $thumbLimits[$widthOption] ) ) {
                    $userOptionsLookup = $services->getUserOptionsLookup();
                    $widthOption = $userOptionsLookup->getDefaultOption( 'thumbsize' );
                }
 
                // Reduce width for upright images when parameter 'upright' is used
                if ( isset( $frameParams['upright'] ) && $frameParams['upright'] == 0 ) {
                    $frameParams['upright'] = $thumbUpright;
                }
 
                // For caching health: If width scaled down due to upright
                // parameter, round to full __0 pixel to avoid the creation of a
                // lot of odd thumbs.
                $prefWidth = isset( $frameParams['upright'] ) ?
                    round( $thumbLimits[$widthOption] * $frameParams['upright'], -1 ) :
                    $thumbLimits[$widthOption];
 
                // Use width which is smaller: real image width or user preference width
                // Unless image is scalable vector.
                if ( !isset( $handlerParams['height'] ) && ( $handlerParams['width'] <= 0 ||
                        $prefWidth < $handlerParams['width'] || $file->isVectorized() ) ) {
                    $handlerParams['width'] = $prefWidth;
                }
            }
        }
 
        // Parser::makeImage has a similarly named variable
        $hasVisibleCaption = isset( $frameParams['thumbnail'] ) ||
            isset( $frameParams['manualthumb'] ) ||
            isset( $frameParams['framed'] );
 
        if ( $hasVisibleCaption ) {
            return $prefix . self::makeThumbLink2(
                $title, $file, $frameParams, $handlerParams, $time, $query,
                $classes, $parser
            ) . $postfix;
        }
 
        $rdfaType = 'mw:File';
 
        if ( isset( $frameParams['frameless'] ) ) {
            $rdfaType .= '/Frameless';
            if ( $file ) {
                $srcWidth = $file->getWidth( $page );
                # For "frameless" option: do not present an image bigger than the
                # source (for bitmap-style images). This is the same behavior as the
                # "thumb" option does it already.
                if ( $srcWidth && !$file->mustRender() && $handlerParams['width'] > $srcWidth ) {
                    $handlerParams['width'] = $srcWidth;
                }
            }
        }
 
        if ( $file && isset( $handlerParams['width'] ) ) {
            # Create a resized image, without the additional thumbnail features
            $thumb = $file->transform( $handlerParams );
        } else {
            $thumb = false;
        }
 
        $isBadFile = $file && $thumb &&
            $parser->getBadFileLookup()->isBadFile( $title->getDBkey(), $parser->getTitle() );
 
        if ( !$thumb || $thumb->isError() || $isBadFile ) {
            $rdfaType = 'mw:Error ' . $rdfaType;
            $currentExists = $file && $file->exists();
            if ( $currentExists && !$thumb ) {
                $label = wfMessage( 'thumbnail_error', '' )->text();
            } elseif ( $thumb && $thumb->isError() ) {
                Assert::invariant(
                    $thumb instanceof MediaTransformError,
                    'Unknown MediaTransformOutput: ' . get_class( $thumb )
                );
                $label = $thumb->toText();
            } else {
                $label = $frameParams['alt'] ?? '';
            }
            $s = self::makeBrokenImageLinkObj(
                $title, $label, '', '', '', (bool)$time, $handlerParams, $currentExists
            );
        } else {
            self::processResponsiveImages( $file, $thumb, $handlerParams );
            $params = [];
            // An empty alt indicates an image is not a key part of the content
            // and that non-visual browsers may omit it from rendering.  Only
            // set the parameter if it's explicitly requested.
            if ( isset( $frameParams['alt'] ) ) {
                $params['alt'] = $frameParams['alt'];
            }
            $params['title'] = $frameParams['title'];
            $params += [
                'img-class' => 'mw-file-element',
            ];
            $params = self::getImageLinkMTOParams( $frameParams, $query, $parser ) + $params;
            $s = $thumb->toHtml( $params );
        }
 
        $wrapper = 'span';
        $caption = '';
 
        if ( $frameParams['align'] != '' ) {
            $wrapper = 'figure';
            // Possible values: mw-halign-left mw-halign-center mw-halign-right mw-halign-none
            $classes[] = "mw-halign-{$frameParams['align']}";
            $caption = Html::rawElement(
                'figcaption', [], $frameParams['caption'] ?? ''
            );
        } elseif ( isset( $frameParams['valign'] ) ) {
            // Possible values: mw-valign-middle mw-valign-baseline mw-valign-sub
            // mw-valign-super mw-valign-top mw-valign-text-top mw-valign-bottom
            // mw-valign-text-bottom
            $classes[] = "mw-valign-{$frameParams['valign']}";
        }
 
        if ( isset( $frameParams['border'] ) ) {
            $classes[] = 'mw-image-border';
        }
 
        if ( isset( $frameParams['class'] ) ) {
            $classes[] = $frameParams['class'];
        }
 
        $attribs = [
            'class' => $classes,
            'typeof' => $rdfaType,
        ];
 
        $s = Html::rawElement( $wrapper, $attribs, $s . $caption );
 
        return str_replace( "\n", ' ', $s );
    }
 
    public static function getImageLinkMTOParams( $frameParams, $query = '', $parser = null ) {
        $mtoParams = [];
        if ( isset( $frameParams['link-url'] ) && $frameParams['link-url'] !== '' ) {
            $mtoParams['custom-url-link'] = $frameParams['link-url'];
            if ( isset( $frameParams['link-target'] ) ) {
                $mtoParams['custom-target-link'] = $frameParams['link-target'];
            }
            if ( $parser ) {
                $extLinkAttrs = $parser->getExternalLinkAttribs( $frameParams['link-url'] );
                foreach ( $extLinkAttrs as $name => $val ) {
                    // Currently could include 'rel' and 'target'
                    $mtoParams['parser-extlink-' . $name] = $val;
                }
            }
        } elseif ( isset( $frameParams['link-title'] ) && $frameParams['link-title'] !== '' ) {
            $mtoParams['custom-title-link'] = Title::newFromLinkTarget(
                self::getLinkRenderer()->normalizeTarget( $frameParams['link-title'] )
            );
            if ( isset( $frameParams['link-title-query'] ) ) {
                $mtoParams['custom-title-link-query'] = $frameParams['link-title-query'];
            }
        } elseif ( !empty( $frameParams['no-link'] ) ) {
            // No link
        } else {
            $mtoParams['desc-link'] = true;
            $mtoParams['desc-query'] = $query;
        }
        return $mtoParams;
    }
 
    public static function makeThumbLinkObj(
        LinkTarget $title, $file, $label = '', $alt = '', $align = null,
        $params = [], $framed = false, $manualthumb = ''
    ) {
        $frameParams = [
            'alt' => $alt,
            'caption' => $label,
            'align' => $align
        ];
        $classes = [];
        if ( $manualthumb ) {
            $frameParams['manualthumb'] = $manualthumb;
        } elseif ( $framed ) {
            $frameParams['framed'] = true;
        } elseif ( !isset( $params['width'] ) ) {
            $classes[] = 'mw-default-size';
        }
        return self::makeThumbLink2(
            $title, $file, $frameParams, $params, false, '', $classes
        );
    }
 
    public static function makeThumbLink2(
        LinkTarget $title, $file, $frameParams = [], $handlerParams = [],
        $time = false, $query = '', array $classes = [], ?Parser $parser = null
    ) {
        $exists = $file && $file->exists();
        $services = MediaWikiServices::getInstance();
 
        $page = $handlerParams['page'] ?? false;
        $lang = $handlerParams['lang'] ?? false;
 
        if ( !isset( $frameParams['align'] ) ) {
            $frameParams['align'] = '';
        }
        if ( !isset( $frameParams['caption'] ) ) {
            $frameParams['caption'] = '';
        }
 
        if ( empty( $handlerParams['width'] ) ) {
            // Reduce width for upright images when parameter 'upright' is used
            $handlerParams['width'] = isset( $frameParams['upright'] ) ? 130 : 180;
        }
 
        $thumb = false;
        $noscale = false;
        $manualthumb = false;
        $manual_title = '';
        $rdfaType = 'mw:File/Thumb';
 
        if ( !$exists ) {
            // Same precedence as the $exists case
            if ( !isset( $frameParams['manualthumb'] ) && isset( $frameParams['framed'] ) ) {
                $rdfaType = 'mw:File/Frame';
            }
            $outerWidth = $handlerParams['width'] + 2;
        } else {
            if ( isset( $frameParams['manualthumb'] ) ) {
                # Use manually specified thumbnail
                $manual_title = Title::makeTitleSafe( NS_FILE, $frameParams['manualthumb'] );
                if ( $manual_title ) {
                    $manual_img = $services->getRepoGroup()
                        ->findFile( $manual_title );
                    if ( $manual_img ) {
                        $thumb = $manual_img->getUnscaledThumb( $handlerParams );
                        $manualthumb = true;
                    }
                }
            } else {
                $srcWidth = $file->getWidth( $page );
                if ( isset( $frameParams['framed'] ) ) {
                    $rdfaType = 'mw:File/Frame';
                    if ( !$file->isVectorized() ) {
                        // Use image dimensions, don't scale
                        $noscale = true;
                    } else {
                        // framed is unscaled, but for vectorized images
                        // we need to a width for scaling up for the high density variants
                        $handlerParams['width'] = $srcWidth;
                    }
                }
 
                // Do not present an image bigger than the source, for bitmap-style images
                // This is a hack to maintain compatibility with arbitrary pre-1.10 behavior
                if ( $srcWidth && !$file->mustRender() && $handlerParams['width'] > $srcWidth ) {
                    $handlerParams['width'] = $srcWidth;
                }
 
                $thumb = $noscale
                    ? $file->getUnscaledThumb( $handlerParams )
                    : $file->transform( $handlerParams );
            }
 
            if ( $thumb ) {
                $outerWidth = $thumb->getWidth() + 2;
            } else {
                $outerWidth = $handlerParams['width'] + 2;
            }
        }
 
        if ( $parser && $rdfaType === 'mw:File/Thumb' ) {
            $parser->getOutput()->addModules( [ 'mediawiki.page.media' ] );
        }
 
        $url = Title::newFromLinkTarget( $title )->getLocalURL( $query );
        $linkTitleQuery = [];
        if ( $page || $lang ) {
            if ( $page ) {
                $linkTitleQuery['page'] = $page;
            }
            if ( $lang ) {
                $linkTitleQuery['lang'] = $lang;
            }
            # ThumbnailImage::toHtml() already adds page= onto the end of DjVu URLs
            # So we don't need to pass it here in $query. However, the URL for the
            # zoom icon still needs it, so we make a unique query for it. See T16771
            $url = wfAppendQuery( $url, $linkTitleQuery );
        }
 
        if ( $manualthumb
            && !isset( $frameParams['link-title'] )
            && !isset( $frameParams['link-url'] )
            && !isset( $frameParams['no-link'] ) ) {
            $frameParams['link-title'] = $title;
            $frameParams['link-title-query'] = $linkTitleQuery;
        }
 
        if ( $frameParams['align'] != '' ) {
            // Possible values: mw-halign-left mw-halign-center mw-halign-right mw-halign-none
            $classes[] = "mw-halign-{$frameParams['align']}";
        }
 
        if ( isset( $frameParams['class'] ) ) {
            $classes[] = $frameParams['class'];
        }
 
        $s = '';
 
        $isBadFile = $exists && $thumb && $parser &&
            $parser->getBadFileLookup()->isBadFile(
                $manualthumb ? $manual_title->getDBkey() : $title->getDBkey(),
                $parser->getTitle()
            );
 
        if ( !$exists ) {
            $rdfaType = 'mw:Error ' . $rdfaType;
            $label = $frameParams['alt'] ?? '';
            $s .= self::makeBrokenImageLinkObj(
                $title, $label, '', '', '', (bool)$time, $handlerParams, false
            );
            $zoomIcon = '';
        } elseif ( !$thumb || $thumb->isError() || $isBadFile ) {
            $rdfaType = 'mw:Error ' . $rdfaType;
            if ( $thumb && $thumb->isError() ) {
                Assert::invariant(
                    $thumb instanceof MediaTransformError,
                    'Unknown MediaTransformOutput: ' . get_class( $thumb )
                );
                $label = $thumb->toText();
            } elseif ( !$thumb ) {
                $label = wfMessage( 'thumbnail_error', '' )->text();
            } else {
                $label = '';
            }
            $s .= self::makeBrokenImageLinkObj(
                $title, $label, '', '', '', (bool)$time, $handlerParams, true
            );
            $zoomIcon = '';
        } else {
            if ( !$noscale && !$manualthumb ) {
                self::processResponsiveImages( $file, $thumb, $handlerParams );
            }
            $params = [];
            // An empty alt indicates an image is not a key part of the content
            // and that non-visual browsers may omit it from rendering.  Only
            // set the parameter if it's explicitly requested.
            if ( isset( $frameParams['alt'] ) ) {
                $params['alt'] = $frameParams['alt'];
            }
            $params += [
                'img-class' => 'mw-file-element',
            ];
            // Only thumbs gets the magnify link
            if ( $rdfaType === 'mw:File/Thumb' ) {
                $params['magnify-resource'] = $url;
            }
            $params = self::getImageLinkMTOParams( $frameParams, $query, $parser ) + $params;
            $s .= $thumb->toHtml( $params );
            if ( isset( $frameParams['framed'] ) ) {
                $zoomIcon = '';
            } else {
                $zoomIcon = Html::rawElement( 'div', [ 'class' => 'magnify' ],
                    Html::rawElement( 'a', [
                        'href' => $url,
                        'class' => 'internal',
                        'title' => wfMessage( 'thumbnail-more' )->text(),
                    ] )
                );
            }
        }
 
        $s .= Html::rawElement(
            'figcaption', [], $frameParams['caption'] ?? ''
        );
 
        $attribs = [
            'class' => $classes,
            'typeof' => $rdfaType,
        ];
 
        $s = Html::rawElement( 'figure', $attribs, $s );
 
        return str_replace( "\n", ' ', $s );
    }
 
    public static function processResponsiveImages( $file, $thumb, $hp ) {
        $responsiveImages = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::ResponsiveImages );
        if ( $responsiveImages && $thumb && !$thumb->isError() ) {
            $hp15 = $hp;
            $hp15['width'] = round( $hp['width'] * 1.5 );
            $hp20 = $hp;
            $hp20['width'] = $hp['width'] * 2;
            if ( isset( $hp['height'] ) ) {
                $hp15['height'] = round( $hp['height'] * 1.5 );
                $hp20['height'] = $hp['height'] * 2;
            }
 
            $thumb15 = $file->transform( $hp15 );
            $thumb20 = $file->transform( $hp20 );
            if ( $thumb15 && !$thumb15->isError() && $thumb15->getUrl() !== $thumb->getUrl() ) {
                $thumb->responsiveUrls['1.5'] = $thumb15->getUrl();
            }
            if ( $thumb20 && !$thumb20->isError() && $thumb20->getUrl() !== $thumb->getUrl() ) {
                $thumb->responsiveUrls['2'] = $thumb20->getUrl();
            }
        }
    }
 
    public static function makeBrokenImageLinkObj(
        $title, $label = '', $query = '', $unused1 = '', $unused2 = '',
        $time = false, array $handlerParams = [], bool $currentExists = false
    ) {
        if ( !$title instanceof LinkTarget ) {
            wfWarn( __METHOD__ . ': Requires $title to be a LinkTarget object.' );
            return "<!-- ERROR -->" . htmlspecialchars( $label );
        }
 
        $title = Title::newFromLinkTarget( $title );
        $services = MediaWikiServices::getInstance();
        $mainConfig = $services->getMainConfig();
        $enableUploads = $mainConfig->get( MainConfigNames::EnableUploads );
        $uploadMissingFileUrl = $mainConfig->get( MainConfigNames::UploadMissingFileUrl );
        $uploadNavigationUrl = $mainConfig->get( MainConfigNames::UploadNavigationUrl );
        if ( $label == '' ) {
            $label = $title->getPrefixedText();
        }
 
        $html = Html::element( 'span', [
            'class' => 'mw-file-element mw-broken-media',
            // These data attributes are used to dynamically size the span, see T273013
            'data-width' => $handlerParams['width'] ?? null,
            'data-height' => $handlerParams['height'] ?? null,
        ], $label );
 
        $repoGroup = $services->getRepoGroup();
        $currentExists = $currentExists ||
            ( $time && $repoGroup->findFile( $title ) !== false );
 
        if ( ( $uploadMissingFileUrl || $uploadNavigationUrl || $enableUploads )
            && !$currentExists
        ) {
            if (
                $title->inNamespace( NS_FILE ) &&
                $repoGroup->getLocalRepo()->checkRedirect( $title )
            ) {
                // We already know it's a redirect, so mark it accordingly
                return self::link(
                    $title,
                    $html,
                    [ 'class' => 'mw-redirect' ],
                    wfCgiToArray( $query ),
                    [ 'known', 'noclasses' ]
                );
            }
            return Html::rawElement( 'a', [
                    'href' => self::getUploadUrl( $title, $query ),
                    'class' => 'new',
                    'title' => $title->getPrefixedText()
                ], $html );
        }
        return self::link(
            $title,
            $html,
            [],
            wfCgiToArray( $query ),
            [ 'known', 'noclasses' ]
        );
    }
 
    public static function getUploadUrl( $destFile, $query = '' ) {
        $mainConfig = MediaWikiServices::getInstance()->getMainConfig();
        $uploadMissingFileUrl = $mainConfig->get( MainConfigNames::UploadMissingFileUrl );
        $uploadNavigationUrl = $mainConfig->get( MainConfigNames::UploadNavigationUrl );
        $q = 'wpDestFile=' . Title::newFromLinkTarget( $destFile )->getPartialURL();
        if ( $query != '' ) {
            $q .= '&' . $query;
        }
 
        if ( $uploadMissingFileUrl ) {
            return wfAppendQuery( $uploadMissingFileUrl, $q );
        }
 
        if ( $uploadNavigationUrl ) {
            return wfAppendQuery( $uploadNavigationUrl, $q );
        }
 
        $upload = SpecialPage::getTitleFor( 'Upload' );
 
        return $upload->getLocalURL( $q );
    }
 
    public static function makeMediaLinkObj( $title, $html = '', $time = false ) {
        $img = MediaWikiServices::getInstance()->getRepoGroup()->findFile(
            $title, [ 'time' => $time ]
        );
        return self::makeMediaLinkFile( $title, $img, $html );
    }
 
    public static function makeMediaLinkFile( LinkTarget $title, $file, $html = '' ) {
        if ( $file && $file->exists() ) {
            $url = $file->getUrl();
            $class = 'internal';
        } else {
            $url = self::getUploadUrl( $title );
            $class = 'new';
        }
 
        $alt = $title->getText();
        if ( $html == '' ) {
            $html = $alt;
        }
 
        $ret = '';
        $attribs = [
            'href' => $url,
            'class' => $class,
            'title' => $alt
        ];
 
        if ( !( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )->onLinkerMakeMediaLinkFile(
            Title::newFromLinkTarget( $title ), $file, $html, $attribs, $ret )
        ) {
            wfDebug( "Hook LinkerMakeMediaLinkFile changed the output of link "
                . "with url {$url} and text {$html} to {$ret}" );
            return $ret;
        }
 
        return Html::rawElement( 'a', $attribs, $html );
    }
 
    public static function specialLink( $name, $key = '' ) {
        $queryPos = strpos( $name, '?' );
        if ( $queryPos !== false ) {
            $getParams = wfCgiToArray( substr( $name, $queryPos + 1 ) );
            $name = substr( $name, 0, $queryPos );
        } else {
            $getParams = [];
        }
 
        $slashPos = strpos( $name, '/' );
        if ( $slashPos !== false ) {
            $subpage = substr( $name, $slashPos + 1 );
            $name = substr( $name, 0, $slashPos );
        } else {
            $subpage = false;
        }
 
        if ( $key == '' ) {
            $key = strtolower( $name );
        }
 
        return self::linkKnown(
            SpecialPage::getTitleFor( $name, $subpage ),
            wfMessage( $key )->escaped(),
            [],
            $getParams
        );
    }
 
    public static function makeExternalLink( $url, $text, $escape = true,
        $linktype = '', $attribs = [], $title = null
    ) {
        // phpcs:ignore MediaWiki.Usage.DeprecatedGlobalVariables.Deprecated$wgTitle
        global $wgTitle;
        return self::getLinkRenderer()->makeExternalLink(
            $url,
            $escape ? $text : new HtmlArmor( $text ),
            $title ?? $wgTitle ?? SpecialPage::getTitleFor( 'Badtitle' ),
            $linktype,
            $attribs
        );
    }
 
    public static function userLink(
        $userId,
        $userName,
        $altUserName = false,
        $attributes = []
    ) {
        if ( $userName === '' || $userName === false || $userName === null ) {
            wfDebug( __METHOD__ . ' received an empty username. Are there database errors ' .
                'that need to be fixed?' );
            return wfMessage( 'empty-username' )->parse();
        }
 
        return self::getLinkRenderer()->makeUserLink(
            new UserIdentityValue( $userId, (string)$userName ),
            RequestContext::getMain(),
            $altUserName === false ? null : (string)$altUserName,
            $attributes
        );
    }
 
    public static function userToolLinkArray(
        $userId, $userText, $redContribsWhenNoEdits = false, $flags = 0, $edits = null
    ): array {
        $services = MediaWikiServices::getInstance();
        $disableAnonTalk = $services->getMainConfig()->get( MainConfigNames::DisableAnonTalk );
        $talkable = !( $disableAnonTalk && $userId == 0 );
        $blockable = !( $flags & self::TOOL_LINKS_NOBLOCK );
        $addEmailLink = $flags & self::TOOL_LINKS_EMAIL && $userId;
 
        if ( $userId == 0 && ExternalUserNames::isExternal( $userText ) ) {
            // No tools for an external user
            return [];
        }
 
        $items = [];
        if ( $talkable ) {
            $items[] = self::userTalkLink( $userId, $userText );
        }
 
        // (T412013) Do not link to Special:Contributions for temp accounts
        // since the target for the link in the username itself already links to
        // Special:Contributions.
        if ( $userId && !$services->getTempUserConfig()->isTempName( $userText ) ) {
            $attribs = [];
            $attribs['class'] = 'mw-usertoollinks-contribs';
 
            // check if the user has edits
            if ( $redContribsWhenNoEdits ) {
                if ( $edits === null ) {
                    $user = UserIdentityValue::newRegistered( $userId, $userText );
                    $edits = $services->getUserEditTracker()->getUserEditCount( $user );
                }
                if ( $edits === 0 ) {
                    // Note: "new" class is inappropriate here, as "new" class
                    // should only be used for pages that do not exist.
                    $attribs['class'] .= ' mw-usertoollinks-contribs-no-edits';
                }
            }
            $contribsPage = SpecialPage::getTitleFor( 'Contributions', $userText );
 
            $items[] = self::link( $contribsPage, wfMessage( 'contribslink' )->escaped(), $attribs );
        }
        $userCanBlock = RequestContext::getMain()->getAuthority()->isAllowed( 'block' );
        if ( $blockable && $userCanBlock ) {
            $items[] = self::blockLink( $userId, $userText );
        }
 
        if (
            $addEmailLink
            && MediaWikiServices::getInstance()->getEmailUserFactory()
                ->newEmailUser( RequestContext::getMain()->getAuthority() )
                ->canSend()
                ->isGood()
        ) {
            $items[] = self::emailLink( $userId, $userText );
        }
 
        ( new HookRunner( $services->getHookContainer() ) )->onUserToolLinksEdit( $userId, $userText, $items );
 
        return $items;
    }
 
    public static function renderUserToolLinksArray( array $items, bool $useParentheses ): string {
        global $wgLang;
 
        if ( !$items ) {
            return '';
        }
 
        if ( $useParentheses ) {
            return wfMessage( 'word-separator' )->escaped()
                . '<span class="mw-usertoollinks">'
                . wfMessage( 'parentheses' )->rawParams( $wgLang->pipeList( $items ) )->escaped()
                . '</span>';
        }
 
        $tools = [];
        foreach ( $items as $tool ) {
            $tools[] = Html::rawElement( 'span', [], $tool );
        }
        return ' <span class="mw-usertoollinks mw-changeslist-links">' .
            implode( ' ', $tools ) . '</span>';
    }
 
    public static function userToolLinks(
        $userId, $userText, $redContribsWhenNoEdits = false, $flags = 0, $edits = null,
        $useParentheses = true
    ) {
        if ( $userText === '' ) {
            wfDebug( __METHOD__ . ' received an empty username. Are there database errors ' .
                'that need to be fixed?' );
            return ' ' . wfMessage( 'empty-username' )->parse();
        }
 
        $items = self::userToolLinkArray( $userId, $userText, $redContribsWhenNoEdits, $flags, $edits );
        return self::renderUserToolLinksArray( $items, $useParentheses );
    }
 
    public static function userToolLinksRedContribs(
        $userId, $userText, $edits = null, $useParentheses = true
    ) {
        return self::userToolLinks( $userId, $userText, true, 0, $edits, $useParentheses );
    }
 
    public static function userTalkLink( $userId, $userText ) {
        if ( $userText === '' ) {
            wfDebug( __METHOD__ . ' received an empty username. Are there database errors ' .
                'that need to be fixed?' );
            return wfMessage( 'empty-username' )->parse();
        }
 
        $userTalkPage = TitleValue::tryNew( NS_USER_TALK, strtr( $userText, ' ', '_' ) );
        $moreLinkAttribs = [ 'class' => 'mw-usertoollinks-talk' ];
        $linkText = wfMessage( 'talkpagelinktext' )->escaped();
 
        return $userTalkPage
            ? self::link( $userTalkPage, $linkText, $moreLinkAttribs )
            : Html::rawElement( 'span', $moreLinkAttribs, $linkText );
    }
 
    public static function blockLink( $userId, $userText ) {
        if ( $userText === '' ) {
            wfDebug( __METHOD__ . ' received an empty username. Are there database errors ' .
                'that need to be fixed?' );
            return wfMessage( 'empty-username' )->parse();
        }
 
        $blockPage = SpecialPage::getTitleFor( 'Block', $userText );
        $moreLinkAttribs = [ 'class' => 'mw-usertoollinks-block' ];
 
        return self::link( $blockPage,
            wfMessage( 'blocklink' )->escaped(),
            $moreLinkAttribs
        );
    }
 
    public static function emailLink( $userId, $userText ) {
        if ( $userText === '' ) {
            wfLogWarning( __METHOD__ . ' received an empty username. Are there database errors ' .
                'that need to be fixed?' );
            return wfMessage( 'empty-username' )->parse();
        }
 
        $emailPage = SpecialPage::getTitleFor( 'Emailuser', $userText );
        $moreLinkAttribs = [ 'class' => 'mw-usertoollinks-mail' ];
        return self::link( $emailPage,
            wfMessage( 'emaillink' )->escaped(),
            $moreLinkAttribs
        );
    }
 
    public static function revUserLink( RevisionRecord $revRecord, $isPublic = false ) {
        // TODO inject authority
        $authority = RequestContext::getMain()->getAuthority();
 
        $revUser = $revRecord->getUser(
            $isPublic ? RevisionRecord::FOR_PUBLIC : RevisionRecord::FOR_THIS_USER,
            $authority
        );
        if ( $revUser ) {
            $link = self::userLink( $revUser->getId(), $revUser->getName() );
        } else {
            // User is deleted and we can't (or don't want to) view it
            $link = wfMessage( 'rev-deleted-user' )->escaped();
        }
 
        if ( $revRecord->isDeleted( RevisionRecord::DELETED_USER ) ) {
            $class = self::getRevisionDeletedClass( $revRecord );
            return '<span class="' . $class . '">' . $link . '</span>';
        }
        return $link;
    }
 
    public static function getRevisionDeletedClass( RevisionRecord $revisionRecord ): string {
        $class = 'history-deleted';
        if ( $revisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ) {
            $class .= ' mw-history-suppressed';
        }
        return $class;
    }
 
    public static function revUserTools(
        RevisionRecord $revRecord,
        $isPublic = false,
        $useParentheses = true
    ) {
        // TODO inject authority
        $authority = RequestContext::getMain()->getAuthority();
 
        $revUser = $revRecord->getUser(
            $isPublic ? RevisionRecord::FOR_PUBLIC : RevisionRecord::FOR_THIS_USER,
            $authority
        );
        if ( $revUser ) {
            $link = self::userLink(
                $revUser->getId(),
                $revUser->getName(),
                false,
                [ 'data-mw-revid' => $revRecord->getId() ]
            ) . self::userToolLinks(
                $revUser->getId(),
                $revUser->getName(),
                false,
                0,
                null,
                $useParentheses
            );
        } else {
            // User is deleted and we can't (or don't want to) view it
            $link = wfMessage( 'rev-deleted-user' )->escaped();
        }
 
        if ( $revRecord->isDeleted( RevisionRecord::DELETED_USER ) ) {
            $class = self::getRevisionDeletedClass( $revRecord );
            return ' <span class="' . $class . ' mw-userlink">' . $link . '</span>';
        }
        return $link;
    }
 
    public static function expandLocalLinks( string $html ) {
        return HtmlHelper::modifyElements(
            $html,
            static function ( SerializerNode $node ): bool {
                return $node->name === 'a' && isset( $node->attrs['href'] );
            },
            static function ( SerializerNode $node ): SerializerNode {
                $urlUtils = MediaWikiServices::getInstance()->getUrlUtils();
                $node->attrs['href'] =
                    $urlUtils->expand( $node->attrs['href'], PROTO_RELATIVE ) ?? false;
                return $node;
            }
        );
    }
 
    public static function normalizeSubpageLink( $contextTitle, $target, &$text ) {
        # Valid link forms:
        # Foobar -- normal
        # :Foobar -- override special treatment of prefix (images, language links)
        # /Foobar -- convert to CurrentPage/Foobar
        # /Foobar/ -- convert to CurrentPage/Foobar, strip the initial and final / from text
        # ../ -- convert to CurrentPage, from CurrentPage/CurrentSubPage
        # ../Foobar -- convert to CurrentPage/Foobar,
        #              (from CurrentPage/CurrentSubPage)
        # ../Foobar/ -- convert to CurrentPage/Foobar, use 'Foobar' as text
        #              (from CurrentPage/CurrentSubPage)
 
        $ret = $target; # default return value is no change
 
        # Some namespaces don't allow subpages,
        # so only perform processing if subpages are allowed
        if (
            $contextTitle && MediaWikiServices::getInstance()->getNamespaceInfo()->
            hasSubpages( $contextTitle->getNamespace() )
        ) {
            $hash = strpos( $target, '#' );
            if ( $hash !== false ) {
                $suffix = substr( $target, $hash );
                $target = substr( $target, 0, $hash );
            } else {
                $suffix = '';
            }
            # T9425
            $target = trim( $target );
            $contextPrefixedText = MediaWikiServices::getInstance()->getTitleFormatter()->
                getPrefixedText( $contextTitle );
            # Look at the first character
            if ( $target != '' && $target[0] === '/' ) {
                # / at end means we don't want the slash to be shown
                $m = [];
                $trailingSlashes = preg_match_all( '%(/+)$%', $target, $m );
                if ( $trailingSlashes ) {
                    $noslash = $target = substr( $target, 1, -strlen( $m[0][0] ) );
                } else {
                    $noslash = substr( $target, 1 );
                }
 
                $ret = $contextPrefixedText . '/' . trim( $noslash ) . $suffix;
                if ( $text === '' ) {
                    $text = $target . $suffix;
                } # this might be changed for ugliness reasons
            } else {
                # check for .. subpage backlinks
                $dotdotcount = 0;
                $nodotdot = $target;
                while ( str_starts_with( $nodotdot, '../' ) ) {
                    ++$dotdotcount;
                    $nodotdot = substr( $nodotdot, 3 );
                }
                if ( $dotdotcount > 0 ) {
                    $exploded = explode( '/', $contextPrefixedText );
                    if ( count( $exploded ) > $dotdotcount ) { # not allowed to go below top level page
                        $ret = implode( '/', array_slice( $exploded, 0, -$dotdotcount ) );
                        # / at the end means don't show full path
                        if ( substr( $nodotdot, -1, 1 ) === '/' ) {
                            $nodotdot = rtrim( $nodotdot, '/' );
                            if ( $text === '' ) {
                                $text = $nodotdot . $suffix;
                            }
                        }
                        $nodotdot = trim( $nodotdot );
                        if ( $nodotdot != '' ) {
                            $ret .= '/' . $nodotdot;
                        }
                        $ret .= $suffix;
                    }
                }
            }
        }
 
        return $ret;
    }
 
    public static function formatRevisionSize( $size ) {
        if ( $size == 0 ) {
            $stxt = wfMessage( 'historyempty' )->escaped();
        } else {
            $stxt = wfMessage( 'nbytes' )->numParams( $size )->escaped();
        }
        return "<span class=\"history-size mw-diff-bytes\" data-mw-bytes=\"$size\">$stxt</span>";
    }
 
    public static function splitTrail( $trail ) {
        $regex = MediaWikiServices::getInstance()->getContentLanguage()->linkTrail();
        $inside = '';
        if ( $trail !== '' && preg_match( $regex, $trail, $m ) ) {
            [ , $inside, $trail ] = $m;
        }
        return [ $inside, $trail ];
    }
 
    public static function generateRollback(
        RevisionRecord $revRecord,
        ?IContextSource $context = null,
        $options = []
    ) {
        $context ??= RequestContext::getMain();
 
        $editCount = self::getRollbackEditCount( $revRecord );
        if ( $editCount === false ) {
            return '';
        }
 
        $inner = self::buildRollbackLink( $revRecord, $context, $editCount );
 
        $services = MediaWikiServices::getInstance();
        // Allow extensions to modify the rollback link.
        // Abort further execution if the extension wants full control over the link.
        if ( !( new HookRunner( $services->getHookContainer() ) )->onLinkerGenerateRollbackLink(
            $revRecord, $context, $options, $inner ) ) {
            return $inner;
        }
 
        if ( !in_array( 'noBrackets', $options, true ) ) {
            $inner = $context->msg( 'brackets' )->rawParams( $inner )->escaped();
        }
 
        if ( $services->getUserOptionsLookup()
            ->getBoolOption( $context->getUser(), 'showrollbackconfirmation' )
        ) {
            $context->getOutput()->addModules( 'mediawiki.misc-authed-curate' );
        }
 
        return '<span class="mw-rollback-link">' . $inner . '</span>';
    }
 
    public static function getRollbackEditCount( RevisionRecord $revRecord, $verify = true ) {
        if ( func_num_args() > 1 ) {
            wfDeprecated( __METHOD__ . ' with $verify parameter', '1.40' );
        }
        $showRollbackEditCount = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::ShowRollbackEditCount );
 
        if ( !is_int( $showRollbackEditCount ) || !$showRollbackEditCount > 0 ) {
            // Nothing has happened, indicate this by returning 'null'
            return null;
        }
 
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
 
        // Up to the value of $wgShowRollbackEditCount revisions are counted
        $queryBuilder = MediaWikiServices::getInstance()->getRevisionStore()->newSelectQueryBuilder( $dbr );
        $res = $queryBuilder->where( [ 'rev_page' => $revRecord->getPageId() ] )
            ->useIndex( [ 'revision' => 'rev_page_timestamp' ] )
            ->orderBy( [ 'rev_timestamp', 'rev_id' ], SelectQueryBuilder::SORT_DESC )
            ->limit( $showRollbackEditCount + 1 )
            ->caller( __METHOD__ )->fetchResultSet();
 
        $revUser = $revRecord->getUser( RevisionRecord::RAW );
        $revUserText = $revUser ? $revUser->getName() : '';
 
        $editCount = 0;
        $moreRevs = false;
        foreach ( $res as $row ) {
            if ( $row->rev_user_text != $revUserText ) {
                if ( $row->rev_deleted & RevisionRecord::DELETED_TEXT
                    || $row->rev_deleted & RevisionRecord::DELETED_USER
                ) {
                    // If the user or the text of the revision we might rollback
                    // to is deleted in some way we can't rollback. Similar to
                    // the checks in WikiPage::commitRollback.
                    return false;
                }
                $moreRevs = true;
                break;
            }
            $editCount++;
        }
 
        if ( $editCount <= $showRollbackEditCount && !$moreRevs ) {
            // We didn't find at least $wgShowRollbackEditCount revisions made by the current user
            // and there weren't any other revisions. That means that the current user is the only
            // editor, so we can't rollback
            return false;
        }
        return $editCount;
    }
 
    public static function buildRollbackLink(
        RevisionRecord $revRecord,
        ?IContextSource $context = null,
        $editCount = false
    ) {
        $config = MediaWikiServices::getInstance()->getMainConfig();
        $showRollbackEditCount = $config->get( MainConfigNames::ShowRollbackEditCount );
        $miserMode = $config->get( MainConfigNames::MiserMode );
        // To config which pages are affected by miser mode
        $disableRollbackEditCountSpecialPage = [ 'Recentchanges', 'Watchlist' ];
 
        $context ??= RequestContext::getMain();
 
        $title = $revRecord->getPageAsLinkTarget();
        $revUser = $revRecord->getUser();
        $revUserText = $revUser ? $revUser->getName() : '';
 
        $query = [
            'action' => 'rollback',
            'from' => $revUserText,
            'token' => $context->getUser()->getEditToken( 'rollback' ),
        ];
 
        $attrs = [
            'data-mw-interface' => '',
            'title' => $context->msg( 'tooltip-rollback' )->text()
        ];
 
        $options = [ 'known', 'noclasses' ];
 
        if ( $context->getRequest()->getBool( 'bot' ) ) {
            // T17999
            $query['hidediff'] = '1';
            $query['bot'] = '1';
        }
 
        if ( $miserMode ) {
            foreach ( $disableRollbackEditCountSpecialPage as $specialPage ) {
                if ( $context->getTitle()->isSpecial( $specialPage ) ) {
                    $showRollbackEditCount = false;
                    break;
                }
            }
        }
 
        // The edit count can be 0 on replica lag, fall back to the generic rollbacklink message
        $msg = [ 'rollbacklink' ];
        if ( is_int( $showRollbackEditCount ) && $showRollbackEditCount > 0 ) {
            if ( !is_numeric( $editCount ) ) {
                $editCount = self::getRollbackEditCount( $revRecord );
            }
 
            if ( $editCount > $showRollbackEditCount ) {
                $msg = [ 'rollbacklinkcount-morethan', Message::numParam( $showRollbackEditCount ) ];
            } elseif ( $editCount ) {
                $msg = [ 'rollbacklinkcount', Message::numParam( $editCount ) ];
            }
        }
 
        $html = $context->msg( ...$msg )->parse();
        return self::link( $title, $html, $attrs, $query, $options );
    }
 
    public static function formatHiddenCategories( $hiddencats ) {
        $outText = '';
        if ( count( $hiddencats ) > 0 ) {
            # Construct the HTML
            $outText = '<div class="mw-hiddenCategoriesExplanation">';
            $outText .= wfMessage( 'hiddencategories' )->numParams( count( $hiddencats ) )->parseAsBlock();
            $outText .= "</div><ul>\n";
 
            foreach ( $hiddencats as $titleObj ) {
                # If it's hidden, it must exist - no need to check with a LinkBatch
                $outText .= '<li>'
                    . self::link( $titleObj, null, [], [], 'known' )
                    . "</li>\n";
            }
            $outText .= '</ul>';
        }
        return $outText;
    }
 
    private static function getContextFromMain() {
        $context = RequestContext::getMain();
        $context = new DerivativeContext( $context );
        return $context;
    }
 
    public static function titleAttrib( $name, $options = null, array $msgParams = [], $localizer = null ) {
        if ( !$localizer ) {
            $localizer = self::getContextFromMain();
        }
        $message = $localizer->msg( "tooltip-$name", $msgParams );
        // Set a default tooltip for subject namespace tabs if that hasn't
        // been defined. See T22126
        if ( !$message->exists() && str_starts_with( $name, 'ca-nstab-' ) ) {
            $message = $localizer->msg( 'tooltip-ca-nstab' );
        }
 
        if ( $message->isDisabled() ) {
            $tooltip = false;
        } else {
            $tooltip = $message->text();
            # Compatibility: formerly some tooltips had [alt-.] hardcoded
            $tooltip = preg_replace( "/ ?\[alt-.\]$/", '', $tooltip );
        }
 
        $options = (array)$options;
 
        if ( in_array( 'nonexisting', $options ) ) {
            $tooltip = $localizer->msg( 'red-link-title', $tooltip ?: '' )->text();
        }
        if ( in_array( 'withaccess', $options ) ) {
            $accesskey = self::accesskey( $name, $localizer );
            if ( $accesskey !== false ) {
                // Should be build the same as in jquery.accessKeyLabel.js
                if ( $tooltip === false || $tooltip === '' ) {
                    $tooltip = $localizer->msg( 'brackets', $accesskey )->text();
                } else {
                    $tooltip .= $localizer->msg( 'word-separator' )->text();
                    $tooltip .= $localizer->msg( 'brackets', $accesskey )->text();
                }
            }
        }
 
        return $tooltip;
    }
 
    public static $accesskeycache;
 
    public static function accesskey( $name, $localizer = null ) {
        if ( !isset( self::$accesskeycache[$name] ) ) {
            if ( !$localizer ) {
                $localizer = self::getContextFromMain();
            }
            $msg = $localizer->msg( "accesskey-$name" );
            // Set a default accesskey for subject namespace tabs if an
            // accesskey has not been defined. See T22126
            if ( !$msg->exists() && str_starts_with( $name, 'ca-nstab-' ) ) {
                $msg = $localizer->msg( 'accesskey-ca-nstab' );
            }
            self::$accesskeycache[$name] = $msg->isDisabled() ? false : $msg->plain();
        }
        return self::$accesskeycache[$name];
    }
 
    public static function getRevDeleteLink(
        Authority $performer,
        RevisionRecord $revRecord,
        LinkTarget $title
    ) {
        $canHide = $performer->isAllowed( 'deleterevision' );
        $canHideHistory = $performer->isAllowed( 'deletedhistory' );
        if ( !$canHide && !( $revRecord->getVisibility() && $canHideHistory ) ) {
            return '';
        }
 
        if ( !$revRecord->userCan( RevisionRecord::DELETED_RESTRICTED, $performer ) ) {
            return self::revDeleteLinkDisabled( $canHide ); // revision was hidden from sysops
        }
        $prefixedDbKey = MediaWikiServices::getInstance()->getTitleFormatter()->
            getPrefixedDBkey( $title );
        if ( $revRecord->getId() ) {
            // RevDelete links using revision ID are stable across
            // page deletion and undeletion; use when possible.
            $query = [
                'type' => 'revision',
                'target' => $prefixedDbKey,
                'ids' => $revRecord->getId()
            ];
        } else {
            // Older deleted entries didn't save a revision ID.
            // We have to refer to these by timestamp, ick!
            $query = [
                'type' => 'archive',
                'target' => $prefixedDbKey,
                'ids' => $revRecord->getTimestamp()
            ];
        }
        return self::revDeleteLink(
            $query,
            $revRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ),
            $canHide
        );
    }
 
    public static function revDeleteLink( $query = [], $restricted = false, $delete = true ) {
        $sp = SpecialPage::getTitleFor( 'Revisiondelete' );
        $msgKey = $delete ? 'rev-delundel' : 'rev-showdeleted';
        $html = wfMessage( $msgKey )->escaped();
        $tag = $restricted ? 'strong' : 'span';
        $link = self::link( $sp, $html, [], $query, [ 'known', 'noclasses' ] );
        return Html::rawElement(
            $tag,
            [ 'class' => 'mw-revdelundel-link' ],
            wfMessage( 'parentheses' )->rawParams( $link )->escaped()
        );
    }
 
    public static function revDeleteLinkDisabled( $delete = true ) {
        $msgKey = $delete ? 'rev-delundel' : 'rev-showdeleted';
        $html = wfMessage( $msgKey )->escaped();
        $htmlParentheses = wfMessage( 'parentheses' )->rawParams( $html )->escaped();
        return Html::rawElement( 'span', [ 'class' => 'mw-revdelundel-link' ], $htmlParentheses );
    }
 
    public static function tooltipAndAccesskeyAttribs(
        $name,
        array $msgParams = [],
        $options = null,
        $localizer = null
    ) {
        $options = (array)$options;
        $options[] = 'withaccess';
 
        // Get optional parameters from global context if any missing.
        if ( !$localizer ) {
            $localizer = self::getContextFromMain();
        }
 
        $attribs = [
            'title' => self::titleAttrib( $name, $options, $msgParams, $localizer ),
            'accesskey' => self::accesskey( $name, $localizer )
        ];
        if ( $attribs['title'] === false ) {
            unset( $attribs['title'] );
        }
        if ( $attribs['accesskey'] === false ) {
            unset( $attribs['accesskey'] );
        }
        return $attribs;
    }
 
    public static function tooltip( $name, $options = null ) {
        $tooltip = self::titleAttrib( $name, $options );
        if ( $tooltip === false ) {
            return '';
        }
        return Html::expandAttributes( [
            'title' => $tooltip
        ] );
    }
 
    private static function getLinkRenderer(
        array $legacyOptions = []
    ): LinkRenderer {
        $services = MediaWikiServices::getInstance();
 
        if ( count( $legacyOptions ) > 0 ) {
            return $services->getLinkRendererFactory()->createFromLegacyOptions(
                $legacyOptions
            );
        }
 
        return $services->getLinkRenderer();
    }
 
}