OutputPage.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MediaWikiServices;
use MediaWiki\Session\SessionManager;
use Wikimedia\Rdbms\IResultWrapper;
use Wikimedia\RelPath;
use Wikimedia\WrappedString;
use Wikimedia\WrappedStringList;
 
class OutputPage extends ContextSource {
    use ProtectedHookAccessorTrait;
 
    protected $mMetatags = [];
 
    protected $mLinktags = [];
 
    protected $mCanonicalUrl = false;
 
    private $mPageTitle = '';
 
    private $displayTitle;
 
    private $cacheIsFinal = false;
 
    public $mBodytext = '';
 
    private $mHTMLtitle = '';
 
    private $mIsArticle = false;
 
    private $mIsArticleRelated = true;
 
    private $mHasCopyright = false;
 
    private $mPrintable = false;
 
    private $mSubtitle = [];
 
    public $mRedirect = '';
 
    protected $mStatusCode;
 
    protected $mLastModified = '';
 
    protected $mCategoryLinks = [];
 
    protected $mCategories = [
        'hidden' => [],
        'normal' => [],
    ];
 
    protected $mIndicators = [];
 
    private $mLanguageLinks = [];
 
    private $mScripts = '';
 
    protected $mInlineStyles = '';
 
    public $mPageLinkTitle = '';
 
    protected $mAdditionalHtmlClasses = [];
 
    protected $mHeadItems = [];
 
    protected $mAdditionalBodyClasses = [];
 
    protected $mModules = [];
 
    protected $mModuleStyles = [];
 
    protected $mResourceLoader;
 
    private $rlClient;
 
    private $rlClientContext;
 
    private $rlExemptStyleModules;
 
    protected $mJsConfigVars = [];
 
    protected $mTemplateIds = [];
 
    protected $mImageTimeKeys = [];
 
    public $mRedirectCode = '';
 
    protected $mFeedLinksAppendQuery = null;
 
    protected $mAllowedModules = [
        ResourceLoaderModule::TYPE_COMBINED => ResourceLoaderModule::ORIGIN_ALL,
    ];
 
    protected $mDoNothing = false;
 
    // Parser related.
 
    protected $mContainsNewMagic = 0;
 
    protected $mParserOptions = null;
 
    private $mFeedLinks = [];
 
    // Gwicke work on squid caching? Roughly from 2003.
    protected $mEnableClientCache = true;
 
    private $mArticleBodyOnly = false;
 
    protected $mNewSectionLink = false;
 
    protected $mHideNewSectionLink = false;
 
    public $mNoGallery = false;
 
    protected $mCdnMaxage = 0;
    protected $mCdnMaxageLimit = INF;
 
    protected $mPreventClickjacking = true;
 
    private $mRevisionId = null;
 
    private $mRevisionTimestamp = null;
 
    protected $mFileVersion = null;
 
    protected $styles = [];
 
    private $mIndexPolicy = 'index';
    private $mFollowPolicy = 'follow';
 
    private $mVaryHeader = [
        'Accept-Encoding' => null,
    ];
 
    private $mRedirectedFrom = null;
 
    private $mProperties = [];
 
    private $mTarget = null;
 
    private $mEnableTOC = false;
 
    private $copyrightUrl;
 
    private $limitReportJSData = [];
 
    private $contentOverrides = [];
 
    private $contentOverrideCallbacks = [];
 
    private $mLinkHeader = [];
 
    private $CSP;
 
    private static $cacheVaryCookies = null;
 
    public function __construct( IContextSource $context ) {
        $this->setContext( $context );
        $this->CSP = new ContentSecurityPolicy(
            $context->getRequest()->response(),
            $context->getConfig(),
            $this->getHookContainer()
        );
    }
 
    public function redirect( $url, $responsecode = '302' ) {
        # Strip newlines as a paranoia check for header injection in PHP<5.1.2
        $this->mRedirect = str_replace( "\n", '', $url );
        $this->mRedirectCode = (string)$responsecode;
    }
 
    public function getRedirect() {
        return $this->mRedirect;
    }
 
    public function setCopyrightUrl( $url ) {
        $this->copyrightUrl = $url;
    }
 
    public function setStatusCode( $statusCode ) {
        $this->mStatusCode = $statusCode;
    }
 
    public function addMeta( $name, $val ) {
        $this->mMetatags[] = [ $name, $val ];
    }
 
    public function getMetaTags() {
        return $this->mMetatags;
    }
 
    public function addLink( array $linkarr ) {
        $this->mLinktags[] = $linkarr;
    }
 
    public function getLinkTags() {
        return $this->mLinktags;
    }
 
    public function setCanonicalUrl( $url ) {
        $this->mCanonicalUrl = $url;
    }
 
    public function getCanonicalUrl() {
        return $this->mCanonicalUrl;
    }
 
    public function addScript( $script ) {
        $this->mScripts .= $script;
    }
 
    public function addScriptFile( $file, $unused = null ) {
        $this->addScript( Html::linkedScript( $file, $this->CSP->getNonce() ) );
    }
 
    public function addInlineScript( $script ) {
        $this->mScripts .= Html::inlineScript( "\n$script\n", $this->CSP->getNonce() ) . "\n";
    }
 
    protected function filterModules( array $modules, $position = null,
        $type = ResourceLoaderModule::TYPE_COMBINED
    ) {
        $resourceLoader = $this->getResourceLoader();
        $filteredModules = [];
        foreach ( $modules as $val ) {
            $module = $resourceLoader->getModule( $val );
            if ( $module instanceof ResourceLoaderModule
                && $module->getOrigin() <= $this->getAllowedModules( $type )
            ) {
                if ( $this->mTarget && !in_array( $this->mTarget, $module->getTargets() ) ) {
                    $this->warnModuleTargetFilter( $module->getName() );
                    continue;
                }
                $filteredModules[] = $val;
            }
        }
        return $filteredModules;
    }
 
    private function warnModuleTargetFilter( $moduleName ) {
        static $warnings = [];
        if ( isset( $warnings[$this->mTarget][$moduleName] ) ) {
            return;
        }
        $warnings[$this->mTarget][$moduleName] = true;
        $this->getResourceLoader()->getLogger()->debug(
            'Module "{module}" not loadable on target "{target}".',
            [
                'module' => $moduleName,
                'target' => $this->mTarget,
            ]
        );
    }
 
    public function getModules( $filter = false, $position = null, $param = 'mModules',
        $type = ResourceLoaderModule::TYPE_COMBINED
    ) {
        $modules = array_values( array_unique( $this->$param ) );
        return $filter
            ? $this->filterModules( $modules, null, $type )
            : $modules;
    }
 
    public function addModules( $modules ) {
        $this->mModules = array_merge( $this->mModules, (array)$modules );
    }
 
    public function getModuleStyles( $filter = false, $position = null ) {
        return $this->getModules( $filter, null, 'mModuleStyles',
            ResourceLoaderModule::TYPE_STYLES
        );
    }
 
    public function addModuleStyles( $modules ) {
        $this->mModuleStyles = array_merge( $this->mModuleStyles, (array)$modules );
    }
 
    public function getTarget() {
        return $this->mTarget;
    }
 
    public function setTarget( $target ) {
        $this->mTarget = $target;
    }
 
    public function addContentOverride( LinkTarget $target, Content $content ) {
        if ( !$this->contentOverrides ) {
            // Register a callback for $this->contentOverrides on the first call
            $this->addContentOverrideCallback( function ( LinkTarget $target ) {
                $key = $target->getNamespace() . ':' . $target->getDBkey();
                return $this->contentOverrides[$key] ?? null;
            } );
        }
 
        $key = $target->getNamespace() . ':' . $target->getDBkey();
        $this->contentOverrides[$key] = $content;
    }
 
    public function addContentOverrideCallback( callable $callback ) {
        $this->contentOverrideCallbacks[] = $callback;
    }
 
    public function addHtmlClasses( $classes ) {
        $this->mAdditionalHtmlClasses = array_merge( $this->mAdditionalHtmlClasses, (array)$classes );
    }
 
    public function getHeadItemsArray() {
        return $this->mHeadItems;
    }
 
    public function addHeadItem( $name, $value ) {
        $this->mHeadItems[$name] = $value;
    }
 
    public function addHeadItems( $values ) {
        $this->mHeadItems = array_merge( $this->mHeadItems, (array)$values );
    }
 
    public function hasHeadItem( $name ) {
        return isset( $this->mHeadItems[$name] );
    }
 
    public function addBodyClasses( $classes ) {
        $this->mAdditionalBodyClasses = array_merge( $this->mAdditionalBodyClasses, (array)$classes );
    }
 
    public function setArticleBodyOnly( $only ) {
        $this->mArticleBodyOnly = $only;
    }
 
    public function getArticleBodyOnly() {
        return $this->mArticleBodyOnly;
    }
 
    public function setProperty( $name, $value ) {
        $this->mProperties[$name] = $value;
    }
 
    public function getProperty( $name ) {
        return $this->mProperties[$name] ?? null;
    }
 
    public function checkLastModified( $timestamp ) {
        if ( !$timestamp || $timestamp == '19700101000000' ) {
            wfDebug( __METHOD__ . ": CACHE DISABLED, NO TIMESTAMP" );
            return false;
        }
        $config = $this->getConfig();
        if ( !$config->get( 'CachePages' ) ) {
            wfDebug( __METHOD__ . ": CACHE DISABLED" );
            return false;
        }
 
        $timestamp = wfTimestamp( TS_MW, $timestamp );
        $modifiedTimes = [
            'page' => $timestamp,
            'user' => $this->getUser()->getTouched(),
            'epoch' => $config->get( 'CacheEpoch' )
        ];
        if ( $config->get( 'UseCdn' ) ) {
            $modifiedTimes['sepoch'] = wfTimestamp( TS_MW, $this->getCdnCacheEpoch(
                time(),
                $config->get( 'CdnMaxAge' )
            ) );
        }
        $this->getHookRunner()->onOutputPageCheckLastModified( $modifiedTimes, $this );
 
        $maxModified = max( $modifiedTimes );
        $this->mLastModified = wfTimestamp( TS_RFC2822, $maxModified );
 
        $clientHeader = $this->getRequest()->getHeader( 'If-Modified-Since' );
        if ( $clientHeader === false ) {
            wfDebug( __METHOD__ . ": client did not send If-Modified-Since header", 'private' );
            return false;
        }
 
        # IE sends sizes after the date like this:
        # Wed, 20 Aug 2003 06:51:19 GMT; length=5202
        # this breaks strtotime().
        $clientHeader = preg_replace( '/;.*$/', '', $clientHeader );
 
        Wikimedia\suppressWarnings(); // E_STRICT system time warnings
        $clientHeaderTime = strtotime( $clientHeader );
        Wikimedia\restoreWarnings();
        if ( !$clientHeaderTime ) {
            wfDebug( __METHOD__
                . ": unable to parse the client's If-Modified-Since header: $clientHeader" );
            return false;
        }
        $clientHeaderTime = wfTimestamp( TS_MW, $clientHeaderTime );
 
        # Make debug info
        $info = '';
        foreach ( $modifiedTimes as $name => $value ) {
            if ( $info !== '' ) {
                $info .= ', ';
            }
            $info .= "$name=" . wfTimestamp( TS_ISO_8601, $value );
        }
 
        wfDebug( __METHOD__ . ": client sent If-Modified-Since: " .
            wfTimestamp( TS_ISO_8601, $clientHeaderTime ), 'private' );
        wfDebug( __METHOD__ . ": effective Last-Modified: " .
            wfTimestamp( TS_ISO_8601, $maxModified ), 'private' );
        if ( $clientHeaderTime < $maxModified ) {
            wfDebug( __METHOD__ . ": STALE, $info", 'private' );
            return false;
        }
 
        # Not modified
        # Give a 304 Not Modified response code and disable body output
        wfDebug( __METHOD__ . ": NOT MODIFIED, $info", 'private' );
        ini_set( 'zlib.output_compression', 0 );
        $this->getRequest()->response()->statusHeader( 304 );
        $this->sendCacheControl();
        $this->disable();
 
        // Don't output a compressed blob when using ob_gzhandler;
        // it's technically against HTTP spec and seems to confuse
        // Firefox when the response gets split over two packets.
        wfClearOutputBuffers();
 
        return true;
    }
 
    private function getCdnCacheEpoch( $reqTime, $maxAge ) {
        // Ensure Last-Modified is never more than $wgCdnMaxAge in the past,
        // because even if the wiki page content hasn't changed since, static
        // resources may have changed (skin HTML, interface messages, urls, etc.)
        // and must roll-over in a timely manner (T46570)
        return $reqTime - $maxAge;
    }
 
    public function setLastModified( $timestamp ) {
        $this->mLastModified = wfTimestamp( TS_RFC2822, $timestamp );
    }
 
    public function setRobotPolicy( $policy ) {
        $policy = Article::formatRobotPolicy( $policy );
 
        if ( isset( $policy['index'] ) ) {
            $this->setIndexPolicy( $policy['index'] );
        }
        if ( isset( $policy['follow'] ) ) {
            $this->setFollowPolicy( $policy['follow'] );
        }
    }
 
    public function getRobotPolicy() {
        return "{$this->mIndexPolicy},{$this->mFollowPolicy}";
    }
 
    public function setIndexPolicy( $policy ) {
        $policy = trim( $policy );
        if ( in_array( $policy, [ 'index', 'noindex' ] ) ) {
            $this->mIndexPolicy = $policy;
        }
    }
 
    public function getIndexPolicy() {
        return $this->mIndexPolicy;
    }
 
    public function setFollowPolicy( $policy ) {
        $policy = trim( $policy );
        if ( in_array( $policy, [ 'follow', 'nofollow' ] ) ) {
            $this->mFollowPolicy = $policy;
        }
    }
 
    public function getFollowPolicy() {
        return $this->mFollowPolicy;
    }
 
    public function setHTMLTitle( $name ) {
        if ( $name instanceof Message ) {
            $this->mHTMLtitle = $name->setContext( $this->getContext() )->text();
        } else {
            $this->mHTMLtitle = $name;
        }
    }
 
    public function getHTMLTitle() {
        return $this->mHTMLtitle;
    }
 
    public function setRedirectedFrom( $t ) {
        $this->mRedirectedFrom = $t;
    }
 
    public function setPageTitle( $name ) {
        if ( $name instanceof Message ) {
            $name = $name->setContext( $this->getContext() )->text();
        }
 
        # change "<script>foo&bar</script>" to "&lt;script&gt;foo&amp;bar&lt;/script&gt;"
        # but leave "<i>foobar</i>" alone
        $nameWithTags = Sanitizer::normalizeCharReferences( Sanitizer::removeHTMLtags( $name ) );
        $this->mPageTitle = $nameWithTags;
 
        # change "<i>foo&amp;bar</i>" to "foo&bar"
        $this->setHTMLTitle(
            $this->msg( 'pagetitle' )->plaintextParams( Sanitizer::stripAllTags( $nameWithTags ) )
                ->inContentLanguage()
        );
    }
 
    public function getPageTitle() {
        return $this->mPageTitle;
    }
 
    public function setDisplayTitle( $html ) {
        $this->displayTitle = $html;
    }
 
    public function getDisplayTitle() {
        $html = $this->displayTitle;
        if ( $html === null ) {
            $html = $this->getTitle()->getPrefixedText();
        }
 
        return Sanitizer::normalizeCharReferences( Sanitizer::removeHTMLtags( $html ) );
    }
 
    public function getUnprefixedDisplayTitle() {
        $text = $this->getDisplayTitle();
        $nsPrefix = $this->getTitle()->getNsText() . ':';
        $prefix = preg_quote( $nsPrefix, '/' );
 
        return preg_replace( "/^$prefix/i", '', $text );
    }
 
    public function setTitle( Title $t ) {
        // @phan-suppress-next-next-line PhanUndeclaredMethod
        // @fixme Not all implementations of IContextSource have this method!
        $this->getContext()->setTitle( $t );
    }
 
    public function setSubtitle( $str ) {
        $this->clearSubtitle();
        $this->addSubtitle( $str );
    }
 
    public function addSubtitle( $str ) {
        if ( $str instanceof Message ) {
            $this->mSubtitle[] = $str->setContext( $this->getContext() )->parse();
        } else {
            $this->mSubtitle[] = $str;
        }
    }
 
    public static function buildBacklinkSubtitle( Title $title, $query = [] ) {
        if ( $title->isRedirect() ) {
            $query['redirect'] = 'no';
        }
        $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
        return wfMessage( 'backlinksubtitle' )
            ->rawParams( $linkRenderer->makeLink( $title, null, [], $query ) );
    }
 
    public function addBacklinkSubtitle( Title $title, $query = [] ) {
        $this->addSubtitle( self::buildBacklinkSubtitle( $title, $query ) );
    }
 
    public function clearSubtitle() {
        $this->mSubtitle = [];
    }
 
    public function getSubtitle() {
        return implode( "<br />\n\t\t\t\t", $this->mSubtitle );
    }
 
    public function setPrintable() {
        $this->mPrintable = true;
    }
 
    public function isPrintable() {
        return $this->mPrintable;
    }
 
    public function disable() {
        $this->mDoNothing = true;
    }
 
    public function isDisabled() {
        return $this->mDoNothing;
    }
 
    public function showNewSectionLink() {
        return $this->mNewSectionLink;
    }
 
    public function forceHideNewSectionLink() {
        return $this->mHideNewSectionLink;
    }
 
    public function setSyndicated( $show = true ) {
        if ( $show ) {
            $this->setFeedAppendQuery( false );
        } else {
            $this->mFeedLinks = [];
        }
    }
 
    protected function getAdvertisedFeedTypes() {
        if ( $this->getConfig()->get( 'Feed' ) ) {
            return $this->getConfig()->get( 'AdvertisedFeedTypes' );
        } else {
            return [];
        }
    }
 
    public function setFeedAppendQuery( $val ) {
        $this->mFeedLinks = [];
 
        foreach ( $this->getAdvertisedFeedTypes() as $type ) {
            $query = "feed=$type";
            if ( is_string( $val ) ) {
                $query .= '&' . $val;
            }
            $this->mFeedLinks[$type] = $this->getTitle()->getLocalURL( $query );
        }
    }
 
    public function addFeedLink( $format, $href ) {
        if ( in_array( $format, $this->getAdvertisedFeedTypes() ) ) {
            $this->mFeedLinks[$format] = $href;
        }
    }
 
    public function isSyndicated() {
        return count( $this->mFeedLinks ) > 0;
    }
 
    public function getSyndicationLinks() {
        return $this->mFeedLinks;
    }
 
    public function getFeedAppendQuery() {
        return $this->mFeedLinksAppendQuery;
    }
 
    public function setArticleFlag( $newVal ) {
        $this->mIsArticle = $newVal;
        if ( $newVal ) {
            $this->mIsArticleRelated = $newVal;
        }
    }
 
    public function isArticle() {
        return $this->mIsArticle;
    }
 
    public function setArticleRelated( $newVal ) {
        $this->mIsArticleRelated = $newVal;
        if ( !$newVal ) {
            $this->mIsArticle = false;
        }
    }
 
    public function isArticleRelated() {
        return $this->mIsArticleRelated;
    }
 
    public function setCopyright( $hasCopyright ) {
        $this->mHasCopyright = $hasCopyright;
    }
 
    public function showsCopyright() {
        return $this->isArticle() || $this->mHasCopyright;
    }
 
    public function addLanguageLinks( array $newLinkArray ) {
        $this->mLanguageLinks = array_merge( $this->mLanguageLinks, $newLinkArray );
    }
 
    public function setLanguageLinks( array $newLinkArray ) {
        $this->mLanguageLinks = $newLinkArray;
    }
 
    public function getLanguageLinks() {
        return $this->mLanguageLinks;
    }
 
    public function addCategoryLinks( array $categories ) {
        if ( !$categories ) {
            return;
        }
 
        $res = $this->addCategoryLinksToLBAndGetResult( $categories );
 
        # Set all the values to 'normal'.
        $categories = array_fill_keys( array_keys( $categories ), 'normal' );
 
        # Mark hidden categories
        foreach ( $res as $row ) {
            if ( isset( $row->pp_value ) ) {
                $categories[$row->page_title] = 'hidden';
            }
        }
 
        # Add the remaining categories to the skin
        if ( $this->getHookRunner()->onOutputPageMakeCategoryLinks(
            $this, $categories, $this->mCategoryLinks )
        ) {
            $services = MediaWikiServices::getInstance();
            $linkRenderer = $services->getLinkRenderer();
            foreach ( $categories as $category => $type ) {
                // array keys will cast numeric category names to ints, so cast back to string
                $category = (string)$category;
                $origcategory = $category;
                $title = Title::makeTitleSafe( NS_CATEGORY, $category );
                if ( !$title ) {
                    continue;
                }
                $services->getContentLanguage()->findVariantLink( $category, $title, true );
                if ( $category != $origcategory && array_key_exists( $category, $categories ) ) {
                    continue;
                }
                $text = $services->getContentLanguage()->convertHtml( $title->getText() );
                $this->mCategories[$type][] = $title->getText();
                $this->mCategoryLinks[$type][] = $linkRenderer->makeLink( $title, new HtmlArmor( $text ) );
            }
        }
    }
 
    protected function addCategoryLinksToLBAndGetResult( array $categories ) {
        # Add the links to a LinkBatch
        $arr = [ NS_CATEGORY => $categories ];
        $lb = new LinkBatch;
        $lb->setArray( $arr );
 
        # Fetch existence plus the hiddencat property
        $dbr = wfGetDB( DB_REPLICA );
        $fields = array_merge(
            LinkCache::getSelectFields(),
            [ 'page_namespace', 'page_title', 'pp_value' ]
        );
 
        $res = $dbr->select( [ 'page', 'page_props' ],
            $fields,
            $lb->constructSet( 'page', $dbr ),
            __METHOD__,
            [],
            [ 'page_props' => [ 'LEFT JOIN', [
                'pp_propname' => 'hiddencat',
                'pp_page = page_id'
            ] ] ]
        );
 
        # Add the results to the link cache
        $linkCache = MediaWikiServices::getInstance()->getLinkCache();
        $lb->addResultToCache( $linkCache, $res );
 
        return $res;
    }
 
    public function setCategoryLinks( array $categories ) {
        $this->mCategoryLinks = [];
        $this->addCategoryLinks( $categories );
    }
 
    public function getCategoryLinks() {
        return $this->mCategoryLinks;
    }
 
    public function getCategories( $type = 'all' ) {
        if ( $type === 'all' ) {
            $allCategories = [];
            foreach ( $this->mCategories as $categories ) {
                $allCategories = array_merge( $allCategories, $categories );
            }
            return $allCategories;
        }
        if ( !isset( $this->mCategories[$type] ) ) {
            throw new InvalidArgumentException( 'Invalid category type given: ' . $type );
        }
        return $this->mCategories[$type];
    }
 
    public function setIndicators( array $indicators ) {
        $this->mIndicators = $indicators + $this->mIndicators;
        // Keep ordered by key
        ksort( $this->mIndicators );
    }
 
    public function getIndicators() {
        return $this->mIndicators;
    }
 
    public function addHelpLink( $to, $overrideBaseUrl = false ) {
        $this->addModuleStyles( 'mediawiki.helplink' );
        $text = $this->msg( 'helppage-top-gethelp' )->escaped();
 
        if ( $overrideBaseUrl ) {
            $helpUrl = $to;
        } else {
            $toUrlencoded = wfUrlencode( str_replace( ' ', '_', $to ) );
            $helpUrl = "https://www.mediawiki.org/wiki/Special:MyLanguage/$toUrlencoded";
        }
 
        $link = Html::rawElement(
            'a',
            [
                'href' => $helpUrl,
                'target' => '_blank',
                'class' => 'mw-helplink',
            ],
            $text
        );
 
        $this->setIndicators( [ 'mw-helplink' => $link ] );
    }
 
    public function disallowUserJs() {
        $this->reduceAllowedModules(
            ResourceLoaderModule::TYPE_SCRIPTS,
            ResourceLoaderModule::ORIGIN_CORE_INDIVIDUAL
        );
 
        // Site-wide styles are controlled by a config setting, see T73621
        // for background on why. User styles are never allowed.
        if ( $this->getConfig()->get( 'AllowSiteCSSOnRestrictedPages' ) ) {
            $styleOrigin = ResourceLoaderModule::ORIGIN_USER_SITEWIDE;
        } else {
            $styleOrigin = ResourceLoaderModule::ORIGIN_CORE_INDIVIDUAL;
        }
        $this->reduceAllowedModules(
            ResourceLoaderModule::TYPE_STYLES,
            $styleOrigin
        );
    }
 
    public function getAllowedModules( $type ) {
        if ( $type == ResourceLoaderModule::TYPE_COMBINED ) {
            return min( array_values( $this->mAllowedModules ) );
        } else {
            return $this->mAllowedModules[$type] ?? ResourceLoaderModule::ORIGIN_ALL;
        }
    }
 
    public function reduceAllowedModules( $type, $level ) {
        $this->mAllowedModules[$type] = min( $this->getAllowedModules( $type ), $level );
    }
 
    public function prependHTML( $text ) {
        $this->mBodytext = $text . $this->mBodytext;
    }
 
    public function addHTML( $text ) {
        $this->mBodytext .= $text;
    }
 
    public function addElement( $element, array $attribs = [], $contents = '' ) {
        $this->addHTML( Html::element( $element, $attribs, $contents ) );
    }
 
    public function clearHTML() {
        $this->mBodytext = '';
    }
 
    public function getHTML() {
        return $this->mBodytext;
    }
 
    public function parserOptions() {
        if ( !$this->mParserOptions ) {
            if ( !$this->getUser()->isSafeToLoad() ) {
                // $wgUser isn't unstubbable yet, so don't try to get a
                // ParserOptions for it. And don't cache this ParserOptions
                // either.
                $po = ParserOptions::newFromAnon();
                $po->setAllowUnsafeRawHtml( false );
                $po->isBogus = true;
                return $po;
            }
 
            $this->mParserOptions = ParserOptions::newFromContext( $this->getContext() );
            $this->mParserOptions->setAllowUnsafeRawHtml( false );
        }
 
        return $this->mParserOptions;
    }
 
    public function setRevisionId( $revid ) {
        $val = $revid === null ? null : intval( $revid );
        return wfSetVar( $this->mRevisionId, $val, true );
    }
 
    public function getRevisionId() {
        return $this->mRevisionId;
    }
 
    public function isRevisionCurrent() {
        return $this->mRevisionId == 0 || $this->mRevisionId == $this->getTitle()->getLatestRevID();
    }
 
    public function setRevisionTimestamp( $timestamp ) {
        return wfSetVar( $this->mRevisionTimestamp, $timestamp, true );
    }
 
    public function getRevisionTimestamp() {
        return $this->mRevisionTimestamp;
    }
 
    public function setFileVersion( $file ) {
        $val = null;
        if ( $file instanceof File && $file->exists() ) {
            $val = [ 'time' => $file->getTimestamp(), 'sha1' => $file->getSha1() ];
        }
        return wfSetVar( $this->mFileVersion, $val, true );
    }
 
    public function getFileVersion() {
        return $this->mFileVersion;
    }
 
    public function getTemplateIds() {
        return $this->mTemplateIds;
    }
 
    public function getFileSearchOptions() {
        return $this->mImageTimeKeys;
    }
 
    public function addWikiTextAsInterface(
        $text, $linestart = true, Title $title = null
    ) {
        if ( $title === null ) {
            $title = $this->getTitle();
        }
        if ( !$title ) {
            throw new MWException( 'Title is null' );
        }
        $this->addWikiTextTitleInternal( $text, $title, $linestart, /*interface*/true );
    }
 
    public function wrapWikiTextAsInterface(
        $wrapperClass, $text
    ) {
        $this->addWikiTextTitleInternal(
            $text, $this->getTitle(),
            /*linestart*/true, /*interface*/true,
            $wrapperClass
        );
    }
 
    public function addWikiTextAsContent(
        $text, $linestart = true, Title $title = null
    ) {
        if ( $title === null ) {
            $title = $this->getTitle();
        }
        if ( !$title ) {
            throw new MWException( 'Title is null' );
        }
        $this->addWikiTextTitleInternal( $text, $title, $linestart, /*interface*/false );
    }
 
    private function addWikiTextTitleInternal(
        $text, Title $title, $linestart, $interface, $wrapperClass = null
    ) {
        $parserOutput = $this->parseInternal(
            $text, $title, $linestart, $interface
        );
 
        $this->addParserOutput( $parserOutput, [
            'enableSectionEditLinks' => false,
            'wrapperDivClass' => $wrapperClass ?? '',
        ] );
    }
 
    public function addParserOutputMetadata( ParserOutput $parserOutput ) {
        $this->mLanguageLinks =
            array_merge( $this->mLanguageLinks, $parserOutput->getLanguageLinks() );
        $this->addCategoryLinks( $parserOutput->getCategories() );
        $this->setIndicators( $parserOutput->getIndicators() );
        $this->mNewSectionLink = $parserOutput->getNewSection();
        $this->mHideNewSectionLink = $parserOutput->getHideNewSection();
 
        if ( !$parserOutput->isCacheable() ) {
            $this->enableClientCache( false );
        }
        $this->mNoGallery = $parserOutput->getNoGallery();
        $this->mHeadItems = array_merge( $this->mHeadItems, $parserOutput->getHeadItems() );
        $this->addModules( $parserOutput->getModules() );
        $this->addModuleStyles( $parserOutput->getModuleStyles() );
        $this->addJsConfigVars( $parserOutput->getJsConfigVars() );
        $this->mPreventClickjacking = $this->mPreventClickjacking
            || $parserOutput->preventClickjacking();
        $scriptSrcs = $parserOutput->getExtraCSPScriptSrcs();
        foreach ( $scriptSrcs as $src ) {
            $this->getCSP()->addScriptSrc( $src );
        }
        $defaultSrcs = $parserOutput->getExtraCSPDefaultSrcs();
        foreach ( $defaultSrcs as $src ) {
            $this->getCSP()->addDefaultSrc( $src );
        }
        $styleSrcs = $parserOutput->getExtraCSPStyleSrcs();
        foreach ( $styleSrcs as $src ) {
            $this->getCSP()->addStyleSrc( $src );
        }
 
        // If $wgImagePreconnect is true, and if the output contains
        // images, give the user-agent a hint about foreign repos from
        // which those images may be served.  See T123582.
        //
        // TODO: We don't have an easy way to know from which remote(s)
        // the image(s) will be served.  For now, we only hint the first
        // valid one.
        if ( $this->getConfig()->get( 'ImagePreconnect' ) && count( $parserOutput->getImages() ) ) {
            $preconnect = [];
            $repoGroup = MediaWikiServices::getInstance()->getRepoGroup();
            $repoGroup->forEachForeignRepo( function ( $repo ) use ( &$preconnect ) {
                $preconnect[] = wfParseUrl( $repo->getZoneUrl( 'thumb' ) )['host'];
            } );
            $preconnect[] = wfParseUrl( $repoGroup->getLocalRepo()->getZoneUrl( 'thumb' ) )['host'];
            foreach ( $preconnect as $host ) {
                if ( $host ) {
                    $this->addLink( [ 'rel' => 'preconnect', 'href' => '//' . $host ] );
                    break;
                }
            }
        }
 
        // Template versioning...
        foreach ( (array)$parserOutput->getTemplateIds() as $ns => $dbks ) {
            if ( isset( $this->mTemplateIds[$ns] ) ) {
                $this->mTemplateIds[$ns] = $dbks + $this->mTemplateIds[$ns];
            } else {
                $this->mTemplateIds[$ns] = $dbks;
            }
        }
        // File versioning...
        foreach ( (array)$parserOutput->getFileSearchOptions() as $dbk => $data ) {
            $this->mImageTimeKeys[$dbk] = $data;
        }
 
        // Hooks registered in the object
        $parserOutputHooks = $this->getConfig()->get( 'ParserOutputHooks' );
        foreach ( $parserOutput->getOutputHooks() as $hookInfo ) {
            list( $hookName, $data ) = $hookInfo;
            if ( isset( $parserOutputHooks[$hookName] ) ) {
                $parserOutputHooks[$hookName]( $this, $parserOutput, $data );
            }
        }
 
        // Enable OOUI if requested via ParserOutput
        if ( $parserOutput->getEnableOOUI() ) {
            $this->enableOOUI();
        }
 
        // Include parser limit report
        if ( !$this->limitReportJSData ) {
            $this->limitReportJSData = $parserOutput->getLimitReportJSData();
        }
 
        // Link flags are ignored for now, but may in the future be
        // used to mark individual language links.
        $linkFlags = [];
        $this->getHookRunner()->onLanguageLinks( $this->getTitle(), $this->mLanguageLinks, $linkFlags );
        $this->getHookRunner()->onOutputPageParserOutput( $this, $parserOutput );
 
        // This check must be after 'OutputPageParserOutput' runs in addParserOutputMetadata
        // so that extensions may modify ParserOutput to toggle TOC.
        // This cannot be moved to addParserOutputText because that is not
        // called by EditPage for Preview.
        if ( $parserOutput->getTOCHTML() ) {
            $this->mEnableTOC = true;
        }
    }
 
    public function addParserOutputContent( ParserOutput $parserOutput, $poOptions = [] ) {
        $this->addParserOutputText( $parserOutput, $poOptions );
 
        $this->addModules( $parserOutput->getModules() );
        $this->addModuleStyles( $parserOutput->getModuleStyles() );
 
        $this->addJsConfigVars( $parserOutput->getJsConfigVars() );
    }
 
    public function addParserOutputText( ParserOutput $parserOutput, $poOptions = [] ) {
        $text = $parserOutput->getText( $poOptions );
        $this->getHookRunner()->onOutputPageBeforeHTML( $this, $text );
        $this->addHTML( $text );
    }
 
    public function addParserOutput( ParserOutput $parserOutput, $poOptions = [] ) {
        $this->addParserOutputMetadata( $parserOutput );
        $this->addParserOutputText( $parserOutput, $poOptions );
    }
 
    public function addTemplate( &$template ) {
        $this->addHTML( $template->getHTML() );
    }
 
    public function parseAsContent( $text, $linestart = true ) {
        return $this->parseInternal(
            $text, $this->getTitle(), $linestart, /*interface*/false
        )->getText( [
            'enableSectionEditLinks' => false,
            'wrapperDivClass' => ''
        ] );
    }
 
    public function parseAsInterface( $text, $linestart = true ) {
        return $this->parseInternal(
            $text, $this->getTitle(), $linestart, /*interface*/true
        )->getText( [
            'enableSectionEditLinks' => false,
            'wrapperDivClass' => ''
        ] );
    }
 
    public function parseInlineAsInterface( $text, $linestart = true ) {
        return Parser::stripOuterParagraph(
            $this->parseAsInterface( $text, $linestart )
        );
    }
 
    private function parseInternal( $text, $title, $linestart, $interface ) {
        if ( $title === null ) {
            throw new MWException( 'Empty $mTitle in ' . __METHOD__ );
        }
 
        $popts = $this->parserOptions();
 
        $oldInterface = $popts->setInterfaceMessage( (bool)$interface );
 
        $parserOutput = MediaWikiServices::getInstance()->getParser()->getFreshParser()->parse(
            $text, $title, $popts,
            $linestart, true, $this->mRevisionId
        );
 
        $popts->setInterfaceMessage( $oldInterface );
 
        return $parserOutput;
    }
 
    public function setCdnMaxage( $maxage ) {
        $this->mCdnMaxage = min( $maxage, $this->mCdnMaxageLimit );
    }
 
    public function lowerCdnMaxage( $maxage ) {
        $this->mCdnMaxageLimit = min( $maxage, $this->mCdnMaxageLimit );
        $this->setCdnMaxage( $this->mCdnMaxage );
    }
 
    public function adaptCdnTTL( $mtime, $minTTL = 0, $maxTTL = 0 ) {
        $minTTL = $minTTL ?: IExpiringStore::TTL_MINUTE;
        $maxTTL = $maxTTL ?: $this->getConfig()->get( 'CdnMaxAge' );
 
        if ( $mtime === null || $mtime === false ) {
            return; // entity does not exist
        }
 
        $age = MWTimestamp::time() - (int)wfTimestamp( TS_UNIX, $mtime );
        $adaptiveTTL = max( 0.9 * $age, $minTTL );
        $adaptiveTTL = min( $adaptiveTTL, $maxTTL );
 
        $this->lowerCdnMaxage( (int)$adaptiveTTL );
    }
 
    public function enableClientCache( $state ) {
        return wfSetVar( $this->mEnableClientCache, $state );
    }
 
    public function couldBePublicCached() {
        if ( !$this->cacheIsFinal ) {
            // - The entry point handles its own caching and/or doesn't use OutputPage.
            //   (such as load.php, AjaxDispatcher, or MediaWiki\Rest\EntryPoint).
            //
            // - Or, we haven't finished processing the main part of the request yet
            //   (e.g. Action::show, SpecialPage::execute), and the state may still
            //   change via enableClientCache().
            return true;
        }
        // e.g. various error-type pages disable all client caching
        return $this->mEnableClientCache;
    }
 
    public function considerCacheSettingsFinal() {
        $this->cacheIsFinal = true;
    }
 
    public function getCacheVaryCookies() {
        if ( self::$cacheVaryCookies === null ) {
            $config = $this->getConfig();
            self::$cacheVaryCookies = array_values( array_unique( array_merge(
                SessionManager::singleton()->getVaryCookies(),
                [
                    'forceHTTPS',
                ],
                $config->get( 'CacheVaryCookies' )
            ) ) );
            $this->getHookRunner()->onGetCacheVaryCookies( $this, self::$cacheVaryCookies );
        }
        return self::$cacheVaryCookies;
    }
 
    public function haveCacheVaryCookies() {
        $request = $this->getRequest();
        foreach ( $this->getCacheVaryCookies() as $cookieName ) {
            if ( $request->getCookie( $cookieName, '', '' ) !== '' ) {
                wfDebug( __METHOD__ . ": found $cookieName" );
                return true;
            }
        }
        wfDebug( __METHOD__ . ": no cache-varying cookies found" );
        return false;
    }
 
    public function addVaryHeader( $header, array $option = null ) {
        if ( $option !== null && count( $option ) > 0 ) {
            wfDeprecatedMsg(
                'The $option parameter to addVaryHeader is ignored since MediaWiki 1.34',
                '1.34' );
        }
        if ( !array_key_exists( $header, $this->mVaryHeader ) ) {
            $this->mVaryHeader[$header] = null;
        }
    }
 
    public function getVaryHeader() {
        // If we vary on cookies, let's make sure it's always included here too.
        if ( $this->getCacheVaryCookies() ) {
            $this->addVaryHeader( 'Cookie' );
        }
 
        foreach ( SessionManager::singleton()->getVaryHeaders() as $header => $options ) {
            $this->addVaryHeader( $header, $options );
        }
        return 'Vary: ' . implode( ', ', array_keys( $this->mVaryHeader ) );
    }
 
    public function addLinkHeader( $header ) {
        $this->mLinkHeader[] = $header;
    }
 
    public function getLinkHeader() {
        if ( !$this->mLinkHeader ) {
            return false;
        }
 
        return 'Link: ' . implode( ',', $this->mLinkHeader );
    }
 
    private function addAcceptLanguage() {
        $title = $this->getTitle();
        if ( !$title instanceof Title ) {
            return;
        }
 
        $lang = $title->getPageLanguage();
        if ( !$this->getRequest()->getCheck( 'variant' ) && $lang->hasVariants() ) {
            $this->addVaryHeader( 'Accept-Language' );
        }
    }
 
    public function preventClickjacking( $enable = true ) {
        $this->mPreventClickjacking = $enable;
    }
 
    public function allowClickjacking() {
        $this->mPreventClickjacking = false;
    }
 
    public function getPreventClickjacking() {
        return $this->mPreventClickjacking;
    }
 
    public function getFrameOptions() {
        $config = $this->getConfig();
        if ( $config->get( 'BreakFrames' ) ) {
            return 'DENY';
        } elseif ( $this->mPreventClickjacking && $config->get( 'EditPageFrameOptions' ) ) {
            return $config->get( 'EditPageFrameOptions' );
        }
        return false;
    }
 
    private function getOriginTrials() {
        $config = $this->getConfig();
 
        return $config->get( 'OriginTrials' );
    }
 
    private function getReportTo() {
        $config = $this->getConfig();
 
        $expiry = $config->get( 'ReportToExpiry' );
 
        if ( !$expiry ) {
            return false;
        }
 
        $endpoints = $config->get( 'ReportToEndpoints' );
 
        if ( !$endpoints ) {
            return false;
        }
 
        $output = [ 'max_age' => $expiry, 'endpoints' => [] ];
 
        foreach ( $endpoints as $endpoint ) {
            $output['endpoints'][] = [ 'url' => $endpoint ];
        }
 
        return json_encode( $output, JSON_UNESCAPED_SLASHES );
    }
 
    private function getFeaturePolicyReportOnly() {
        $config = $this->getConfig();
 
        $features = $config->get( 'FeaturePolicyReportOnly' );
        return implode( ';', $features );
    }
 
    public function sendCacheControl() {
        $response = $this->getRequest()->response();
        $config = $this->getConfig();
 
        $this->addVaryHeader( 'Cookie' );
        $this->addAcceptLanguage();
 
        # don't serve compressed data to clients who can't handle it
        # maintain different caches for logged-in users and non-logged in ones
        $response->header( $this->getVaryHeader() );
 
        if ( $this->mEnableClientCache ) {
            if (
                $config->get( 'UseCdn' ) &&
                !$response->hasCookies() &&
                // The client might use methods other than cookies to appear logged-in.
                // E.g. HTTP headers, or query parameter tokens, OAuth, etc.
                !SessionManager::getGlobalSession()->isPersistent() &&
                !$this->isPrintable() &&
                $this->mCdnMaxage != 0 &&
                !$this->haveCacheVaryCookies()
            ) {
                # We'll purge the proxy cache for anons explicitly, but require end user agents
                # to revalidate against the proxy on each visit.
                # IMPORTANT! The CDN needs to replace the Cache-Control header with
                # Cache-Control: s-maxage=0, must-revalidate, max-age=0
                wfDebug( __METHOD__ .
                    ": local proxy caching; {$this->mLastModified} **", 'private' );
                # start with a shorter timeout for initial testing
                # header( "Cache-Control: s-maxage=2678400, must-revalidate, max-age=0" );
                $response->header( "Cache-Control: " .
                    "s-maxage={$this->mCdnMaxage}, must-revalidate, max-age=0" );
            } else {
                # We do want clients to cache if they can, but they *must* check for updates
                # on revisiting the page, after the max-age period.
                wfDebug( __METHOD__ . ": private caching; {$this->mLastModified} **", 'private' );
 
                if ( $response->hasCookies() || SessionManager::getGlobalSession()->isPersistent() ) {
                    $response->header( 'Expires: ' . gmdate( 'D, d M Y H:i:s', 0 ) . ' GMT' );
                    $response->header( "Cache-Control: private, must-revalidate, max-age=0" );
                } else {
                    $response->header(
                        'Expires: ' . gmdate( 'D, d M Y H:i:s', time() + $config->get( 'LoggedOutMaxAge' ) ) . ' GMT'
                    );
                    $response->header(
                        "Cache-Control: private, must-revalidate, max-age={$config->get( 'LoggedOutMaxAge' )}"
                    );
                }
            }
            if ( $this->mLastModified ) {
                $response->header( "Last-Modified: {$this->mLastModified}" );
            }
        } else {
            wfDebug( __METHOD__ . ": no caching **", 'private' );
 
            # In general, the absence of a last modified header should be enough to prevent
            # the client from using its cache. We send a few other things just to make sure.
            $response->header( 'Expires: ' . gmdate( 'D, d M Y H:i:s', 0 ) . ' GMT' );
            $response->header( 'Cache-Control: no-cache, no-store, max-age=0, must-revalidate' );
            $response->header( 'Pragma: no-cache' );
        }
    }
 
    public function loadSkinModules( $sk ) {
        foreach ( $sk->getDefaultModules() as $group => $modules ) {
            if ( $group === 'styles' ) {
                foreach ( $modules as $key => $moduleMembers ) {
                    $this->addModuleStyles( $moduleMembers );
                }
            } else {
                $this->addModules( $modules );
            }
        }
    }
 
    public function output( $return = false ) {
        if ( $this->mDoNothing ) {
            return $return ? '' : null;
        }
 
        $response = $this->getRequest()->response();
        $config = $this->getConfig();
 
        if ( $this->mRedirect != '' ) {
            # Standards require redirect URLs to be absolute
            $this->mRedirect = wfExpandUrl( $this->mRedirect, PROTO_CURRENT );
 
            $redirect = $this->mRedirect;
            $code = $this->mRedirectCode;
 
            if ( $this->getHookRunner()->onBeforePageRedirect( $this, $redirect, $code ) ) {
                if ( $code == '301' || $code == '303' ) {
                    if ( !$config->get( 'DebugRedirects' ) ) {
                        $response->statusHeader( $code );
                    }
                    $this->mLastModified = wfTimestamp( TS_RFC2822 );
                }
                if ( $config->get( 'VaryOnXFP' ) ) {
                    $this->addVaryHeader( 'X-Forwarded-Proto' );
                }
                $this->sendCacheControl();
 
                $response->header( "Content-Type: text/html; charset=utf-8" );
                if ( $config->get( 'DebugRedirects' ) ) {
                    $url = htmlspecialchars( $redirect );
                    print "<!DOCTYPE html>\n<html>\n<head>\n<title>Redirect</title>\n</head>\n<body>\n";
                    print "<p>Location: <a href=\"$url\">$url</a></p>\n";
                    print "</body>\n</html>\n";
                } else {
                    $response->header( 'Location: ' . $redirect );
                }
            }
 
            return $return ? '' : null;
        } elseif ( $this->mStatusCode ) {
            $response->statusHeader( $this->mStatusCode );
        }
 
        # Buffer output; final headers may depend on later processing
        ob_start();
 
        $response->header( 'Content-type: ' . $config->get( 'MimeType' ) . '; charset=UTF-8' );
        $response->header( 'Content-language: ' .
            MediaWikiServices::getInstance()->getContentLanguage()->getHtmlCode() );
 
        $linkHeader = $this->getLinkHeader();
        if ( $linkHeader ) {
            $response->header( $linkHeader );
        }
 
        // Prevent framing, if requested
        $frameOptions = $this->getFrameOptions();
        if ( $frameOptions ) {
            $response->header( "X-Frame-Options: $frameOptions" );
        }
 
        $originTrials = $this->getOriginTrials();
        foreach ( $originTrials as $originTrial ) {
            $response->header( "Origin-Trial: $originTrial", false );
        }
 
        $reportTo = $this->getReportTo();
        if ( $reportTo ) {
            $response->header( "Report-To: $reportTo" );
        }
 
        $featurePolicyReportOnly = $this->getFeaturePolicyReportOnly();
        if ( $featurePolicyReportOnly ) {
            $response->header( "Feature-Policy-Report-Only: $featurePolicyReportOnly" );
        }
 
        if ( $this->mArticleBodyOnly ) {
            $this->CSP->sendHeaders();
            echo $this->mBodytext;
        } else {
            // Enable safe mode if requested (T152169)
            if ( $this->getRequest()->getBool( 'safemode' ) ) {
                $this->disallowUserJs();
            }
 
            $sk = $this->getSkin();
            $this->loadSkinModules( $sk );
 
            MWDebug::addModules( $this );
 
            // Hook that allows last minute changes to the output page, e.g.
            // adding of CSS or Javascript by extensions, adding CSP sources.
            $this->getHookRunner()->onBeforePageDisplay( $this, $sk );
 
            $this->CSP->sendHeaders();
 
            try {
                $sk->outputPage();
            } catch ( Exception $e ) {
                ob_end_clean(); // bug T129657
                throw $e;
            }
        }
 
        try {
            // This hook allows last minute changes to final overall output by modifying output buffer
            $this->getHookRunner()->onAfterFinalPageOutput( $this );
        } catch ( Exception $e ) {
            ob_end_clean(); // bug T129657
            throw $e;
        }
 
        $this->sendCacheControl();
 
        if ( $return ) {
            return ob_get_clean();
        } else {
            ob_end_flush();
            return null;
        }
    }
 
    public function prepareErrorPage( $pageTitle, $htmlTitle = false ) {
        $this->setPageTitle( $pageTitle );
        if ( $htmlTitle !== false ) {
            $this->setHTMLTitle( $htmlTitle );
        }
        $this->setRobotPolicy( 'noindex,nofollow' );
        $this->setArticleRelated( false );
        $this->enableClientCache( false );
        $this->mRedirect = '';
        $this->clearSubtitle();
        $this->clearHTML();
    }
 
    public function showErrorPage( $title, $msg, $params = [] ) {
        if ( !$title instanceof Message ) {
            $title = $this->msg( $title );
        }
 
        $this->prepareErrorPage( $title );
 
        if ( $msg instanceof Message ) {
            if ( $params !== [] ) {
                trigger_error( 'Argument ignored: $params. The message parameters argument '
                    . 'is discarded when the $msg argument is a Message object instead of '
                    . 'a string.', E_USER_NOTICE );
            }
            $this->addHTML( $msg->parseAsBlock() );
        } else {
            $this->addWikiMsgArray( $msg, $params );
        }
 
        $this->returnToMain();
    }
 
    public function showPermissionsErrorPage( array $errors, $action = null ) {
        $services = MediaWikiServices::getInstance();
        $permissionManager = $services->getPermissionManager();
        foreach ( $errors as $key => $error ) {
            $errors[$key] = (array)$error;
        }
 
        // For some action (read, edit, create and upload), display a "login to do this action"
        // error if all of the following conditions are met:
        // 1. the user is not logged in
        // 2. the only error is insufficient permissions (i.e. no block or something else)
        // 3. the error can be avoided simply by logging in
 
        if ( in_array( $action, [ 'read', 'edit', 'createpage', 'createtalk', 'upload' ] )
            && $this->getUser()->isAnon() && count( $errors ) == 1 && isset( $errors[0][0] )
            && ( $errors[0][0] == 'badaccess-groups' || $errors[0][0] == 'badaccess-group0' )
            && ( $permissionManager->groupHasPermission( 'user', $action )
                || $permissionManager->groupHasPermission( 'autoconfirmed', $action ) )
        ) {
            $displayReturnto = null;
 
            # Due to T34276, if a user does not have read permissions,
            # $this->getTitle() will just give Special:Badtitle, which is
            # not especially useful as a returnto parameter. Use the title
            # from the request instead, if there was one.
            $request = $this->getRequest();
            $returnto = Title::newFromText( $request->getVal( 'title', '' ) );
            if ( $action == 'edit' ) {
                $msg = 'whitelistedittext';
                $displayReturnto = $returnto;
            } elseif ( $action == 'createpage' || $action == 'createtalk' ) {
                $msg = 'nocreatetext';
            } elseif ( $action == 'upload' ) {
                $msg = 'uploadnologintext';
            } else { # Read
                $msg = 'loginreqpagetext';
                $displayReturnto = Title::newMainPage();
            }
 
            $query = [];
 
            if ( $returnto ) {
                $query['returnto'] = $returnto->getPrefixedText();
 
                if ( !$request->wasPosted() ) {
                    $returntoquery = $request->getValues();
                    unset( $returntoquery['title'] );
                    unset( $returntoquery['returnto'] );
                    unset( $returntoquery['returntoquery'] );
                    $query['returntoquery'] = wfArrayToCgi( $returntoquery );
                }
            }
 
            $title = SpecialPage::getTitleFor( 'Userlogin' );
            $linkRenderer = $services->getLinkRenderer();
            $loginUrl = $title->getLinkURL( $query, false, PROTO_RELATIVE );
            $loginLink = $linkRenderer->makeKnownLink(
                $title,
                $this->msg( 'loginreqlink' )->text(),
                [],
                $query
            );
 
            $this->prepareErrorPage( $this->msg( 'loginreqtitle' ) );
            $this->addHTML( $this->msg( $msg )->rawParams( $loginLink )->params( $loginUrl )->parse() );
 
            # Don't return to a page the user can't read otherwise
            # we'll end up in a pointless loop
            if ( $displayReturnto && $permissionManager->userCan(
                'read', $this->getUser(), $displayReturnto
            ) ) {
                $this->returnToMain( null, $displayReturnto );
            }
        } else {
            $this->prepareErrorPage( $this->msg( 'permissionserrors' ) );
            $this->addWikiTextAsInterface( $this->formatPermissionsErrorMessage( $errors, $action ) );
        }
    }
 
    public function versionRequired( $version ) {
        $this->prepareErrorPage( $this->msg( 'versionrequired', $version ) );
 
        $this->addWikiMsg( 'versionrequiredtext', $version );
        $this->returnToMain();
    }
 
    public function formatPermissionsErrorMessage( array $errors, $action = null ) {
        if ( $action == null ) {
            $text = $this->msg( 'permissionserrorstext', count( $errors ) )->plain() . "\n\n";
        } else {
            $action_desc = $this->msg( "action-$action" )->plain();
            $text = $this->msg(
                'permissionserrorstext-withaction',
                count( $errors ),
                $action_desc
            )->plain() . "\n\n";
        }
 
        if ( count( $errors ) > 1 ) {
            $text .= '<ul class="permissions-errors">' . "\n";
 
            foreach ( $errors as $error ) {
                $text .= '<li>';
                $text .= $this->msg( ...$error )->plain();
                $text .= "</li>\n";
            }
            $text .= '</ul>';
        } else {
            $text .= "<div class=\"permissions-errors\">\n" .
                    $this->msg( ...reset( $errors ) )->plain() .
                    "\n</div>";
        }
 
        return $text;
    }
 
    public function showLagWarning( $lag ) {
        $config = $this->getConfig();
        if ( $lag >= $config->get( 'SlaveLagWarning' ) ) {
            $lag = floor( $lag ); // floor to avoid nano seconds to display
            $message = $lag < $config->get( 'SlaveLagCritical' )
                ? 'lag-warn-normal'
                : 'lag-warn-high';
            // For grep: mw-lag-warn-normal, mw-lag-warn-high
            $wrap = Html::rawElement( 'div', [ 'class' => "mw-{$message}" ], "\n$1\n" );
            $this->wrapWikiMsg( "$wrap\n", [ $message, $this->getLanguage()->formatNum( $lag ) ] );
        }
    }
 
    public function showFatalError( $message ) {
        $this->prepareErrorPage( $this->msg( 'internalerror' ) );
 
        $this->addHTML( $message );
    }
 
    public function addReturnTo( $title, array $query = [], $text = null, $options = [] ) {
        $linkRenderer = MediaWikiServices::getInstance()
            ->getLinkRendererFactory()->createFromLegacyOptions( $options );
        $link = $this->msg( 'returnto' )->rawParams(
            $linkRenderer->makeLink( $title, $text, [], $query ) )->escaped();
        $this->addHTML( "<p id=\"mw-returnto\">{$link}</p>\n" );
    }
 
    public function returnToMain( $unused = null, $returnto = null, $returntoquery = null ) {
        if ( $returnto == null ) {
            $returnto = $this->getRequest()->getText( 'returnto' );
        }
 
        if ( $returntoquery == null ) {
            $returntoquery = $this->getRequest()->getText( 'returntoquery' );
        }
 
        if ( $returnto === '' ) {
            $returnto = Title::newMainPage();
        }
 
        if ( is_object( $returnto ) ) {
            $titleObj = $returnto;
        } else {
            $titleObj = Title::newFromText( $returnto );
        }
        // We don't want people to return to external interwiki. That
        // might potentially be used as part of a phishing scheme
        if ( !is_object( $titleObj ) || $titleObj->isExternal() ) {
            $titleObj = Title::newMainPage();
        }
 
        $this->addReturnTo( $titleObj, wfCgiToArray( $returntoquery ) );
    }
 
    private function getRlClientContext() {
        if ( !$this->rlClientContext ) {
            $query = ResourceLoader::makeLoaderQuery(
                [], // modules; not relevant
                $this->getLanguage()->getCode(),
                $this->getSkin()->getSkinName(),
                $this->getUser()->isLoggedIn() ? $this->getUser()->getName() : null,
                null, // version; not relevant
                ResourceLoader::inDebugMode(),
                null, // only; not relevant
                $this->isPrintable(),
                $this->getRequest()->getBool( 'handheld' )
            );
            $this->rlClientContext = new ResourceLoaderContext(
                $this->getResourceLoader(),
                new FauxRequest( $query )
            );
            if ( $this->contentOverrideCallbacks ) {
                $this->rlClientContext = new DerivativeResourceLoaderContext( $this->rlClientContext );
                $this->rlClientContext->setContentOverrideCallback( function ( Title $title ) {
                    foreach ( $this->contentOverrideCallbacks as $callback ) {
                        $content = $callback( $title );
                        if ( $content !== null ) {
                            $text = ContentHandler::getContentText( $content );
                            if ( strpos( $text, '</script>' ) !== false ) {
                                // Proactively replace this so that we can display a message
                                // to the user, instead of letting it go to Html::inlineScript(),
                                // where it would be considered a server-side issue.
                                $titleFormatted = $title->getPrefixedText();
                                $content = new JavaScriptContent(
                                    Xml::encodeJsCall( 'mw.log.error', [
                                        "Cannot preview $titleFormatted due to script-closing tag."
                                    ] )
                                );
                            }
                            return $content;
                        }
                    }
                    return null;
                } );
            }
        }
        return $this->rlClientContext;
    }
 
    public function getRlClient() {
        if ( !$this->rlClient ) {
            $context = $this->getRlClientContext();
            $rl = $this->getResourceLoader();
            $this->addModules( [
                'user',
                'user.options',
            ] );
            $this->addModuleStyles( [
                'site.styles',
                'noscript',
                'user.styles',
            ] );
 
            // Prepare exempt modules for buildExemptModules()
            $exemptGroups = [ 'site' => [], 'noscript' => [], 'private' => [], 'user' => [] ];
            $exemptStates = [];
            $moduleStyles = $this->getModuleStyles( /*filter*/ true );
 
            // Preload getTitleInfo for isKnownEmpty calls below and in ResourceLoaderClientHtml
            // Separate user-specific batch for improved cache-hit ratio.
            $userBatch = [ 'user.styles', 'user' ];
            $siteBatch = array_diff( $moduleStyles, $userBatch );
            $dbr = wfGetDB( DB_REPLICA );
            ResourceLoaderWikiModule::preloadTitleInfo( $context, $dbr, $siteBatch );
            ResourceLoaderWikiModule::preloadTitleInfo( $context, $dbr, $userBatch );
 
            // Filter out modules handled by buildExemptModules()
            $moduleStyles = array_filter( $moduleStyles,
                function ( $name ) use ( $rl, $context, &$exemptGroups, &$exemptStates ) {
                    $module = $rl->getModule( $name );
                    if ( $module ) {
                        $group = $module->getGroup();
                        if ( isset( $exemptGroups[$group] ) ) {
                            $exemptStates[$name] = 'ready';
                            if ( !$module->isKnownEmpty( $context ) ) {
                                // E.g. Don't output empty <styles>
                                $exemptGroups[$group][] = $name;
                            }
                            return false;
                        }
                    }
                    return true;
                }
            );
            $this->rlExemptStyleModules = $exemptGroups;
 
            $rlClient = new ResourceLoaderClientHtml( $context, [
                'target' => $this->getTarget(),
                'nonce' => $this->CSP->getNonce(),
                // When 'safemode', disallowUserJs(), or reduceAllowedModules() is used
                // to only restrict modules to ORIGIN_CORE (ie. disallow ORIGIN_USER), the list of
                // modules enqueud for loading on this page is filtered to just those.
                // However, to make sure we also apply the restriction to dynamic dependencies and
                // lazy-loaded modules at run-time on the client-side, pass 'safemode' down to the
                // StartupModule so that the client-side registry will not contain any restricted
                // modules either. (T152169, T185303)
                'safemode' => ( $this->getAllowedModules( ResourceLoaderModule::TYPE_COMBINED )
                    <= ResourceLoaderModule::ORIGIN_CORE_INDIVIDUAL
                ) ? '1' : null,
            ] );
            $rlClient->setConfig( $this->getJSVars() );
            $rlClient->setModules( $this->getModules( /*filter*/ true ) );
            $rlClient->setModuleStyles( $moduleStyles );
            $rlClient->setExemptStates( $exemptStates );
            $this->rlClient = $rlClient;
        }
        return $this->rlClient;
    }
 
    public function headElement( Skin $sk, $includeStyle = true ) {
        $config = $this->getConfig();
        $userdir = $this->getLanguage()->getDir();
        $sitedir = MediaWikiServices::getInstance()->getContentLanguage()->getDir();
 
        $pieces = [];
        $htmlAttribs = Sanitizer::mergeAttributes( Sanitizer::mergeAttributes(
            $this->getRlClient()->getDocumentAttributes(),
            $sk->getHtmlElementAttributes()
        ), [ 'class' => implode( ' ', $this->mAdditionalHtmlClasses ) ] );
        $pieces[] = Html::htmlHeader( $htmlAttribs );
        $pieces[] = Html::openElement( 'head' );
 
        if ( $this->getHTMLTitle() == '' ) {
            $this->setHTMLTitle( $this->msg( 'pagetitle', $this->getPageTitle() )->inContentLanguage() );
        }
 
        if ( !Html::isXmlMimeType( $config->get( 'MimeType' ) ) ) {
            // Add <meta charset="UTF-8">
            // This should be before <title> since it defines the charset used by
            // text including the text inside <title>.
            // The spec recommends defining XHTML5's charset using the XML declaration
            // instead of meta.
            // Our XML declaration is output by Html::htmlHeader.
            // https://html.spec.whatwg.org/multipage/semantics.html#attr-meta-http-equiv-content-type
            // https://html.spec.whatwg.org/multipage/semantics.html#charset
            $pieces[] = Html::element( 'meta', [ 'charset' => 'UTF-8' ] );
        }
 
        $pieces[] = Html::element( 'title', null, $this->getHTMLTitle() );
        $pieces[] = $this->getRlClient()->getHeadHtml( $htmlAttribs['class'] ?? null );
        $pieces[] = $this->buildExemptModules();
        $pieces = array_merge( $pieces, array_values( $this->getHeadLinksArray() ) );
        $pieces = array_merge( $pieces, array_values( $this->mHeadItems ) );
 
        $pieces[] = Html::closeElement( 'head' );
 
        $bodyClasses = $this->mAdditionalBodyClasses;
        $bodyClasses[] = 'mediawiki';
 
        # Classes for LTR/RTL directionality support
        $bodyClasses[] = $userdir;
        $bodyClasses[] = "sitedir-$sitedir";
 
        $underline = $this->getUser()->getOption( 'underline' );
        if ( $underline < 2 ) {
            // The following classes can be used here:
            // * mw-underline-always
            // * mw-underline-never
            $bodyClasses[] = 'mw-underline-' . ( $underline ? 'always' : 'never' );
        }
 
        if ( $this->getLanguage()->capitalizeAllNouns() ) {
            # A <body> class is probably not the best way to do this . . .
            $bodyClasses[] = 'capitalize-all-nouns';
        }
 
        // Parser feature migration class
        // The idea is that this will eventually be removed, after the wikitext
        // which requires it is cleaned up.
        $bodyClasses[] = 'mw-hide-empty-elt';
 
        $bodyClasses[] = $sk->getPageClasses( $this->getTitle() );
        $bodyClasses[] = 'skin-' . Sanitizer::escapeClass( $sk->getSkinName() );
        $bodyClasses[] =
            'action-' . Sanitizer::escapeClass( Action::getActionName( $this->getContext() ) );
 
        if ( $sk->isResponsive() ) {
            $bodyClasses[] = 'skin--responsive';
        }
 
        $bodyAttrs = [];
        // While the implode() is not strictly needed, it's used for backwards compatibility
        // (this used to be built as a string and hooks likely still expect that).
        $bodyAttrs['class'] = implode( ' ', $bodyClasses );
 
        // Allow skins and extensions to add body attributes they need
        // Get ones from deprecated method
        if ( method_exists( $sk, 'addToBodyAttributes' ) ) {
            $sk->addToBodyAttributes( $this, $bodyAttrs );
            wfDeprecated( 'Skin::addToBodyAttributes method to add body attributes', '1.35' );
        }
 
        // Then run the hook, the recommended way of adding body attributes now
        $this->getHookRunner()->onOutputPageBodyAttributes( $this, $sk, $bodyAttrs );
 
        $pieces[] = Html::openElement( 'body', $bodyAttrs );
 
        return self::combineWrappedStrings( $pieces );
    }
 
    public function getResourceLoader() {
        if ( $this->mResourceLoader === null ) {
            // Lazy-initialise as needed
            $this->mResourceLoader = MediaWikiServices::getInstance()->getResourceLoader();
        }
        return $this->mResourceLoader;
    }
 
    public function makeResourceLoaderLink( $modules, $only, array $extraQuery = [] ) {
        // Apply 'target' and 'origin' filters
        $modules = $this->filterModules( (array)$modules, null, $only );
 
        return ResourceLoaderClientHtml::makeLoad(
            $this->getRlClientContext(),
            $modules,
            $only,
            $extraQuery,
            $this->CSP->getNonce()
        );
    }
 
    protected static function combineWrappedStrings( array $chunks ) {
        // Filter out empty values
        $chunks = array_filter( $chunks, 'strlen' );
        return WrappedString::join( "\n", $chunks );
    }
 
    public function getBottomScripts() {
        $chunks = [];
        $chunks[] = $this->getRlClient()->getBodyHtml();
 
        // Legacy non-ResourceLoader scripts
        $chunks[] = $this->mScripts;
 
        if ( $this->limitReportJSData ) {
            $chunks[] = ResourceLoader::makeInlineScript(
                ResourceLoader::makeConfigSetScript(
                    [ 'wgPageParseReport' => $this->limitReportJSData ]
                ),
                $this->CSP->getNonce()
            );
        }
 
        return self::combineWrappedStrings( $chunks );
    }
 
    public function getJsConfigVars() {
        return $this->mJsConfigVars;
    }
 
    public function addJsConfigVars( $keys, $value = null ) {
        if ( is_array( $keys ) ) {
            foreach ( $keys as $key => $value ) {
                $this->mJsConfigVars[$key] = $value;
            }
            return;
        }
 
        $this->mJsConfigVars[$keys] = $value;
    }
 
    public function getJSVars() {
        $curRevisionId = 0;
        $articleId = 0;
        $canonicalSpecialPageName = false; # T23115
        $services = MediaWikiServices::getInstance();
 
        $title = $this->getTitle();
        $ns = $title->getNamespace();
        $nsInfo = $services->getNamespaceInfo();
        $canonicalNamespace = $nsInfo->exists( $ns )
            ? $nsInfo->getCanonicalName( $ns )
            : $title->getNsText();
 
        $sk = $this->getSkin();
        // Get the relevant title so that AJAX features can use the correct page name
        // when making API requests from certain special pages (T36972).
        $relevantTitle = $sk->getRelevantTitle();
        $relevantUser = $sk->getRelevantUser();
 
        if ( $ns === NS_SPECIAL ) {
            list( $canonicalSpecialPageName, /*...*/ ) =
                $services->getSpecialPageFactory()->
                    resolveAlias( $title->getDBkey() );
        } elseif ( $this->canUseWikiPage() ) {
            $wikiPage = $this->getWikiPage();
            $curRevisionId = $wikiPage->getLatest();
            $articleId = $wikiPage->getId();
        }
 
        $lang = $title->getPageViewLanguage();
 
        // Pre-process information
        $separatorTransTable = $lang->separatorTransformTable();
        $separatorTransTable = $separatorTransTable ?: [];
        $compactSeparatorTransTable = [
            implode( "\t", array_keys( $separatorTransTable ) ),
            implode( "\t", $separatorTransTable ),
        ];
        $digitTransTable = $lang->digitTransformTable();
        $digitTransTable = $digitTransTable ?: [];
        $compactDigitTransTable = [
            implode( "\t", array_keys( $digitTransTable ) ),
            implode( "\t", $digitTransTable ),
        ];
 
        $user = $this->getUser();
 
        // Internal variables for MediaWiki core
        $vars = [
            // @internal For mediawiki.page.ready
            'wgBreakFrames' => $this->getFrameOptions() == 'DENY',
 
            // @internal For jquery.tablesorter
            'wgSeparatorTransformTable' => $compactSeparatorTransTable,
            'wgDigitTransformTable' => $compactDigitTransTable,
            'wgDefaultDateFormat' => $lang->getDefaultDateFormat(),
            'wgMonthNames' => $lang->getMonthNamesArray(),
 
            // @internal For debugging purposes
            'wgRequestId' => WebRequest::getRequestId(),
 
            // @internal For mw.loader
            'wgCSPNonce' => $this->CSP->getNonce(),
        ];
 
        // Start of supported and stable config vars (for use by extensions/gadgets).
        $vars += [
            'wgCanonicalNamespace' => $canonicalNamespace,
            'wgCanonicalSpecialPageName' => $canonicalSpecialPageName,
            'wgNamespaceNumber' => $title->getNamespace(),
            'wgPageName' => $title->getPrefixedDBkey(),
            'wgTitle' => $title->getText(),
            'wgCurRevisionId' => $curRevisionId,
            'wgRevisionId' => (int)$this->getRevisionId(),
            'wgArticleId' => $articleId,
            'wgIsArticle' => $this->isArticle(),
            'wgIsRedirect' => $title->isRedirect(),
            'wgAction' => Action::getActionName( $this->getContext() ),
            'wgUserName' => $user->isAnon() ? null : $user->getName(),
            'wgUserGroups' => $user->getEffectiveGroups(),
            'wgCategories' => $this->getCategories(),
            'wgPageContentLanguage' => $lang->getCode(),
            'wgPageContentModel' => $title->getContentModel(),
            'wgRelevantPageName' => $relevantTitle->getPrefixedDBkey(),
            'wgRelevantArticleId' => $relevantTitle->getArticleID(),
        ];
        if ( $user->isLoggedIn() ) {
            $vars['wgUserId'] = $user->getId();
            $vars['wgUserEditCount'] = $user->getEditCount();
            $userReg = $user->getRegistration();
            $vars['wgUserRegistration'] = $userReg ? (int)wfTimestamp( TS_UNIX, $userReg ) * 1000 : null;
            // Get the revision ID of the oldest new message on the user's talk
            // page. This can be used for constructing new message alerts on
            // the client side.
            $userNewMsgRevId = $this->getLastSeenUserTalkRevId();
            // Only occupy precious space in the <head> when it is non-null (T53640)
            // mw.config.get returns null by default.
            if ( $userNewMsgRevId ) {
                $vars['wgUserNewMsgRevisionId'] = $userNewMsgRevId;
            }
        }
        $contLang = $services->getContentLanguage();
        if ( $contLang->hasVariants() ) {
            $vars['wgUserVariant'] = $contLang->getPreferredVariant();
        }
        // Same test as SkinTemplate
        $vars['wgIsProbablyEditable'] = $this->userCanEditOrCreate( $user, $title );
        $vars['wgRelevantPageIsProbablyEditable'] = $relevantTitle &&
            $this->userCanEditOrCreate( $user, $relevantTitle );
        foreach ( $title->getRestrictionTypes() as $type ) {
            // Following keys are set in $vars:
            // wgRestrictionCreate, wgRestrictionEdit, wgRestrictionMove, wgRestrictionUpload
            $vars['wgRestriction' . ucfirst( $type )] = $title->getRestrictions( $type );
        }
        if ( $title->isMainPage() ) {
            $vars['wgIsMainPage'] = true;
        }
        if ( $relevantUser ) {
            $vars['wgRelevantUserName'] = $relevantUser->getName();
        }
        // End of stable config vars
 
        if ( $this->mRedirectedFrom ) {
            // @internal For skin JS
            $vars['wgRedirectedFrom'] = $this->mRedirectedFrom->getPrefixedDBkey();
        }
 
        // Allow extensions to add their custom variables to the mw.config map.
        // Use the 'ResourceLoaderGetConfigVars' hook if the variable is not
        // page-dependant but site-wide (without state).
        // Alternatively, you may want to use OutputPage->addJsConfigVars() instead.
        $this->getHookRunner()->onMakeGlobalVariablesScript( $vars, $this );
 
        // Merge in variables from addJsConfigVars last
        return array_merge( $vars, $this->getJsConfigVars() );
    }
 
    private function getLastSeenUserTalkRevId() {
        $services = MediaWikiServices::getInstance();
        $user = $this->getUser();
        $userHasNewMessages = $services
            ->getTalkPageNotificationManager()
            ->userHasNewMessages( $user );
        if ( !$userHasNewMessages ) {
            return null;
        }
 
        $timestamp = $services
            ->getTalkPageNotificationManager()
            ->getLatestSeenMessageTimestamp( $user );
 
        if ( !$timestamp ) {
            return null;
        }
 
        $revRecord = $services->getRevisionLookup()->getRevisionByTimestamp(
            $user->getTalkPage(),
            $timestamp
        );
 
        if ( !$revRecord ) {
            return null;
        }
 
        return $revRecord->getId();
    }
 
    public function userCanPreview() {
        $request = $this->getRequest();
        if (
            $request->getVal( 'action' ) !== 'submit' ||
            !$request->wasPosted()
        ) {
            return false;
        }
 
        $user = $this->getUser();
 
        if ( !$user->isLoggedIn() ) {
            // Anons have predictable edit tokens
            return false;
        }
        if ( !$user->matchEditToken( $request->getVal( 'wpEditToken' ) ) ) {
            return false;
        }
 
        $title = $this->getTitle();
        $errors = MediaWikiServices::getInstance()->getPermissionManager()
            ->getPermissionErrors( 'edit', $user, $title );
        if ( count( $errors ) !== 0 ) {
            return false;
        }
 
        return true;
    }
 
    private function userCanEditOrCreate(
        User $user,
        LinkTarget $title
    ) {
        $pm = MediaWikiServices::getInstance()->getPermissionManager();
        return $pm->quickUserCan( 'edit', $user, $title )
        && ( $this->getTitle()->exists() ||
             $pm->quickUserCan( 'create', $user, $title ) );
    }
 
    public function getHeadLinksArray() {
        $tags = [];
        $config = $this->getConfig();
 
        $canonicalUrl = $this->mCanonicalUrl;
 
        $tags['meta-generator'] = Html::element( 'meta', [
            'name' => 'generator',
            'content' => 'MediaWiki ' . MW_VERSION,
        ] );
 
        if ( $config->get( 'ReferrerPolicy' ) !== false ) {
            // Per https://w3c.github.io/webappsec-referrer-policy/#unknown-policy-values
            // fallbacks should come before the primary value so we need to reverse the array.
            foreach ( array_reverse( (array)$config->get( 'ReferrerPolicy' ) ) as $i => $policy ) {
                $tags["meta-referrer-$i"] = Html::element( 'meta', [
                    'name' => 'referrer',
                    'content' => $policy,
                ] );
            }
        }
 
        $p = "{$this->mIndexPolicy},{$this->mFollowPolicy}";
        if ( $p !== 'index,follow' ) {
            // http://www.robotstxt.org/wc/meta-user.html
            // Only show if it's different from the default robots policy
            $tags['meta-robots'] = Html::element( 'meta', [
                'name' => 'robots',
                'content' => $p,
            ] );
        }
 
        foreach ( $this->mMetatags as $tag ) {
            if ( strncasecmp( $tag[0], 'http:', 5 ) === 0 ) {
                $a = 'http-equiv';
                $tag[0] = substr( $tag[0], 5 );
            } elseif ( strncasecmp( $tag[0], 'og:', 3 ) === 0 ) {
                $a = 'property';
            } else {
                $a = 'name';
            }
            $tagName = "meta-{$tag[0]}";
            if ( isset( $tags[$tagName] ) ) {
                $tagName .= $tag[1];
            }
            $tags[$tagName] = Html::element( 'meta',
                [
                    $a => $tag[0],
                    'content' => $tag[1]
                ]
            );
        }
 
        foreach ( $this->mLinktags as $tag ) {
            $tags[] = Html::element( 'link', $tag );
        }
 
        # Universal edit button
        if ( $config->get( 'UniversalEditButton' ) && $this->isArticleRelated() ) {
            if ( $this->userCanEditOrCreate( $this->getUser(), $this->getTitle() ) ) {
                // Original UniversalEditButton
                $msg = $this->msg( 'edit' )->text();
                $tags['universal-edit-button'] = Html::element( 'link', [
                    'rel' => 'alternate',
                    'type' => 'application/x-wiki',
                    'title' => $msg,
                    'href' => $this->getTitle()->getEditURL(),
                ] );
                // Alternate edit link
                $tags['alternative-edit'] = Html::element( 'link', [
                    'rel' => 'edit',
                    'title' => $msg,
                    'href' => $this->getTitle()->getEditURL(),
                ] );
            }
        }
 
        # Generally the order of the favicon and apple-touch-icon links
        # should not matter, but Konqueror (3.5.9 at least) incorrectly
        # uses whichever one appears later in the HTML source. Make sure
        # apple-touch-icon is specified first to avoid this.
        if ( $config->get( 'AppleTouchIcon' ) !== false ) {
            $tags['apple-touch-icon'] = Html::element( 'link', [
                'rel' => 'apple-touch-icon',
                'href' => $config->get( 'AppleTouchIcon' )
            ] );
        }
 
        if ( $config->get( 'Favicon' ) !== false ) {
            $tags['favicon'] = Html::element( 'link', [
                'rel' => 'shortcut icon',
                'href' => $config->get( 'Favicon' )
            ] );
        }
 
        # OpenSearch description link
        $tags['opensearch'] = Html::element( 'link', [
            'rel' => 'search',
            'type' => 'application/opensearchdescription+xml',
            'href' => wfScript( 'opensearch_desc' ),
            'title' => $this->msg( 'opensearch-desc' )->inContentLanguage()->text(),
        ] );
 
        # Real Simple Discovery link, provides auto-discovery information
        # for the MediaWiki API (and potentially additional custom API
        # support such as WordPress or Twitter-compatible APIs for a
        # blogging extension, etc)
        $tags['rsd'] = Html::element( 'link', [
            'rel' => 'EditURI',
            'type' => 'application/rsd+xml',
            // Output a protocol-relative URL here if $wgServer is protocol-relative.
            // Whether RSD accepts relative or protocol-relative URLs is completely
            // undocumented, though.
            'href' => wfExpandUrl( wfAppendQuery(
                wfScript( 'api' ),
                [ 'action' => 'rsd' ] ),
                PROTO_RELATIVE
            ),
        ] );
 
        # Language variants
        if ( !$config->get( 'DisableLangConversion' ) ) {
            $lang = $this->getTitle()->getPageLanguage();
            if ( $lang->hasVariants() ) {
                $variants = $lang->getVariants();
                foreach ( $variants as $variant ) {
                    $tags["variant-$variant"] = Html::element( 'link', [
                        'rel' => 'alternate',
                        'hreflang' => LanguageCode::bcp47( $variant ),
                        'href' => $this->getTitle()->getLocalURL(
                            [ 'variant' => $variant ] )
                        ]
                    );
                }
                # x-default link per https://support.google.com/webmasters/answer/189077?hl=en
                $tags["variant-x-default"] = Html::element( 'link', [
                    'rel' => 'alternate',
                    'hreflang' => 'x-default',
                    'href' => $this->getTitle()->getLocalURL() ] );
            }
        }
 
        # Copyright
        if ( $this->copyrightUrl !== null ) {
            $copyright = $this->copyrightUrl;
        } else {
            $copyright = '';
            if ( $config->get( 'RightsPage' ) ) {
                $copy = Title::newFromText( $config->get( 'RightsPage' ) );
 
                if ( $copy ) {
                    $copyright = $copy->getLocalURL();
                }
            }
 
            if ( !$copyright && $config->get( 'RightsUrl' ) ) {
                $copyright = $config->get( 'RightsUrl' );
            }
        }
 
        if ( $copyright ) {
            $tags['copyright'] = Html::element( 'link', [
                'rel' => 'license',
                'href' => $copyright ]
            );
        }
 
        # Feeds
        if ( $config->get( 'Feed' ) ) {
            $feedLinks = [];
 
            foreach ( $this->getSyndicationLinks() as $format => $link ) {
                # Use the page name for the title.  In principle, this could
                # lead to issues with having the same name for different feeds
                # corresponding to the same page, but we can't avoid that at
                # this low a level.
 
                $feedLinks[] = $this->feedLink(
                    $format,
                    $link,
                    # Used messages: 'page-rss-feed' and 'page-atom-feed' (for an easier grep)
                    $this->msg(
                        "page-{$format}-feed", $this->getTitle()->getPrefixedText()
                    )->text()
                );
            }
 
            # Recent changes feed should appear on every page (except recentchanges,
            # that would be redundant). Put it after the per-page feed to avoid
            # changing existing behavior. It's still available, probably via a
            # menu in your browser. Some sites might have a different feed they'd
            # like to promote instead of the RC feed (maybe like a "Recent New Articles"
            # or "Breaking news" one). For this, we see if $wgOverrideSiteFeed is defined.
            # If so, use it instead.
            $sitename = $config->get( 'Sitename' );
            $overrideSiteFeed = $config->get( 'OverrideSiteFeed' );
            if ( $overrideSiteFeed ) {
                foreach ( $overrideSiteFeed as $type => $feedUrl ) {
                    // Note, this->feedLink escapes the url.
                    $feedLinks[] = $this->feedLink(
                        $type,
                        $feedUrl,
                        $this->msg( "site-{$type}-feed", $sitename )->text()
                    );
                }
            } elseif ( !$this->getTitle()->isSpecial( 'Recentchanges' ) ) {
                $rctitle = SpecialPage::getTitleFor( 'Recentchanges' );
                foreach ( $this->getAdvertisedFeedTypes() as $format ) {
                    $feedLinks[] = $this->feedLink(
                        $format,
                        $rctitle->getLocalURL( [ 'feed' => $format ] ),
                        # For grep: 'site-rss-feed', 'site-atom-feed'
                        $this->msg( "site-{$format}-feed", $sitename )->text()
                    );
                }
            }
 
            # Allow extensions to change the list pf feeds. This hook is primarily for changing,
            # manipulating or removing existing feed tags. If you want to add new feeds, you should
            # use OutputPage::addFeedLink() instead.
            $this->getHookRunner()->onAfterBuildFeedLinks( $feedLinks );
 
            $tags += $feedLinks;
        }
 
        # Canonical URL
        if ( $config->get( 'EnableCanonicalServerLink' ) ) {
            if ( $canonicalUrl !== false ) {
                $canonicalUrl = wfExpandUrl( $canonicalUrl, PROTO_CANONICAL );
            } elseif ( $this->isArticleRelated() ) {
                // This affects all requests where "setArticleRelated" is true. This is
                // typically all requests that show content (query title, curid, oldid, diff),
                // and all wikipage actions (edit, delete, purge, info, history etc.).
                // It does not apply to File pages and Special pages.
                // 'history' and 'info' actions address page metadata rather than the page
                // content itself, so they may not be canonicalized to the view page url.
                // TODO: this ought to be better encapsulated in the Action class.
                $action = Action::getActionName( $this->getContext() );
                if ( in_array( $action, [ 'history', 'info' ] ) ) {
                    $query = "action={$action}";
                } else {
                    $query = '';
                }
                $canonicalUrl = $this->getTitle()->getCanonicalURL( $query );
            } else {
                $reqUrl = $this->getRequest()->getRequestURL();
                $canonicalUrl = wfExpandUrl( $reqUrl, PROTO_CANONICAL );
            }
        }
        if ( $canonicalUrl !== false ) {
            $tags[] = Html::element( 'link', [
                'rel' => 'canonical',
                'href' => $canonicalUrl
            ] );
        }
 
        // Allow extensions to add, remove and/or otherwise manipulate these links
        // If you want only to *add* <head> links, please use the addHeadItem()
        // (or addHeadItems() for multiple items) method instead.
        // This hook is provided as a last resort for extensions to modify these
        // links before the output is sent to client.
        $this->getHookRunner()->onOutputPageAfterGetHeadLinksArray( $tags, $this );
 
        return $tags;
    }
 
    private function feedLink( $type, $url, $text ) {
        return Html::element( 'link', [
            'rel' => 'alternate',
            'type' => "application/$type+xml",
            'title' => $text,
            'href' => $url ]
        );
    }
 
    public function addStyle( $style, $media = '', $condition = '', $dir = '' ) {
        $options = [];
        if ( $media ) {
            $options['media'] = $media;
        }
        if ( $condition ) {
            $options['condition'] = $condition;
        }
        if ( $dir ) {
            $options['dir'] = $dir;
        }
        $this->styles[$style] = $options;
    }
 
    public function addInlineStyle( $style_css, $flip = 'noflip' ) {
        if ( $flip === 'flip' && $this->getLanguage()->isRTL() ) {
            # If wanted, and the interface is right-to-left, flip the CSS
            $style_css = CSSJanus::transform( $style_css, true, false );
        }
        $this->mInlineStyles .= Html::inlineStyle( $style_css );
    }
 
    protected function buildExemptModules() {
        $chunks = [];
 
        // Requirements:
        // - Within modules provided by the software (core, skin, extensions),
        //   styles from skin stylesheets should be overridden by styles
        //   from modules dynamically loaded with JavaScript.
        // - Styles from site-specific, private, and user modules should override
        //   both of the above.
        //
        // The effective order for stylesheets must thus be:
        // 1. Page style modules, formatted server-side by ResourceLoaderClientHtml.
        // 2. Dynamically-loaded styles, inserted client-side by mw.loader.
        // 3. Styles that are site-specific, private or from the user, formatted
        //    server-side by this function.
        //
        // The 'ResourceLoaderDynamicStyles' marker helps JavaScript know where
        // point #2 is.
 
        // Add legacy styles added through addStyle()/addInlineStyle() here
        $chunks[] = implode( '', $this->buildCssLinksArray() ) . $this->mInlineStyles;
 
        // Things that go after the ResourceLoaderDynamicStyles marker
        $append = [];
        $separateReq = [ 'site.styles', 'user.styles' ];
        foreach ( $this->rlExemptStyleModules as $group => $moduleNames ) {
            if ( $moduleNames ) {
                $append[] = $this->makeResourceLoaderLink(
                    array_diff( $moduleNames, $separateReq ),
                    ResourceLoaderModule::TYPE_STYLES
                );
 
                foreach ( array_intersect( $moduleNames, $separateReq ) as $name ) {
                    // These require their own dedicated request in order to support "@import"
                    // syntax, which is incompatible with concatenation. (T147667, T37562)
                    $append[] = $this->makeResourceLoaderLink( $name,
                        ResourceLoaderModule::TYPE_STYLES
                    );
                }
            }
        }
        if ( $append ) {
            $chunks[] = Html::element(
                'meta',
                [ 'name' => 'ResourceLoaderDynamicStyles', 'content' => '' ]
            );
            $chunks = array_merge( $chunks, $append );
        }
 
        return self::combineWrappedStrings( $chunks );
    }
 
    public function buildCssLinksArray() {
        $links = [];
 
        foreach ( $this->styles as $file => $options ) {
            $link = $this->styleLink( $file, $options );
            if ( $link ) {
                $links[$file] = $link;
            }
        }
        return $links;
    }
 
    protected function styleLink( $style, array $options ) {
        if ( isset( $options['dir'] ) && $this->getLanguage()->getDir() != $options['dir'] ) {
            return '';
        }
 
        if ( isset( $options['media'] ) ) {
            $media = self::transformCssMedia( $options['media'] );
            if ( $media === null ) {
                return '';
            }
        } else {
            $media = 'all';
        }
 
        if ( substr( $style, 0, 1 ) == '/' ||
            substr( $style, 0, 5 ) == 'http:' ||
            substr( $style, 0, 6 ) == 'https:' ) {
            $url = $style;
        } else {
            $config = $this->getConfig();
            // Append file hash as query parameter
            $url = self::transformResourcePath(
                $config,
                $config->get( 'StylePath' ) . '/' . $style
            );
        }
 
        $link = Html::linkedStyle( $url, $media );
 
        if ( isset( $options['condition'] ) ) {
            $condition = htmlspecialchars( $options['condition'] );
            $link = "<!--[if $condition]>$link<![endif]-->";
        }
        return $link;
    }
 
    public static function transformResourcePath( Config $config, $path ) {
        global $IP;
 
        $localDir = $IP;
        $remotePathPrefix = $config->get( 'ResourceBasePath' );
        if ( $remotePathPrefix === '' ) {
            // The configured base path is required to be empty string for
            // wikis in the domain root
            $remotePath = '/';
        } else {
            $remotePath = $remotePathPrefix;
        }
        if ( strpos( $path, $remotePath ) !== 0 || substr( $path, 0, 2 ) === '//' ) {
            // - Path is outside wgResourceBasePath, ignore.
            // - Path is protocol-relative. Fixes T155310. Not supported by RelPath lib.
            return $path;
        }
        // For files in resources, extensions/ or skins/, ResourceBasePath is preferred here.
        // For other misc files in $IP, we'll fallback to that as well. There is, however, a fourth
        // supported dir/path pair in the configuration (wgUploadDirectory, wgUploadPath)
        // which is not expected to be in wgResourceBasePath on CDNs. (T155146)
        $uploadPath = $config->get( 'UploadPath' );
        if ( strpos( $path, $uploadPath ) === 0 ) {
            $localDir = $config->get( 'UploadDirectory' );
            $remotePathPrefix = $remotePath = $uploadPath;
        }
 
        $path = RelPath::getRelativePath( $path, $remotePath );
        return self::transformFilePath( $remotePathPrefix, $localDir, $path );
    }
 
    public static function transformFilePath( $remotePathPrefix, $localPath, $file ) {
        $hash = md5_file( "$localPath/$file" );
        if ( $hash === false ) {
            wfLogWarning( __METHOD__ . ": Failed to hash $localPath/$file" );
            $hash = '';
        }
        return "$remotePathPrefix/$file?" . substr( $hash, 0, 5 );
    }
 
    public static function transformCssMedia( $media ) {
        global $wgRequest;
 
        // https://www.w3.org/TR/css3-mediaqueries/#syntax
        $screenMediaQueryRegex = '/^(?:only\s+)?screen\b/i';
 
        // Switch in on-screen display for media testing
        $switches = [
            'printable' => 'print',
            'handheld' => 'handheld',
        ];
        foreach ( $switches as $switch => $targetMedia ) {
            if ( $wgRequest->getBool( $switch ) ) {
                if ( $media == $targetMedia ) {
                    $media = '';
                } elseif ( preg_match( $screenMediaQueryRegex, $media ) === 1 ) {
                    /* This regex will not attempt to understand a comma-separated media_query_list
                     *
                     * Example supported values for $media:
                     * 'screen', 'only screen', 'screen and (min-width: 982px)' ),
                     * Example NOT supported value for $media:
                     * '3d-glasses, screen, print and resolution > 90dpi'
                     *
                     * If it's a print request, we never want any kind of screen stylesheets
                     * If it's a handheld request (currently the only other choice with a switch),
                     * we don't want simple 'screen' but we might want screen queries that
                     * have a max-width or something, so we'll pass all others on and let the
                     * client do the query.
                     */
                    if ( $targetMedia == 'print' || $media == 'screen' ) {
                        return null;
                    }
                }
            }
        }
 
        return $media;
    }
 
    public function addWikiMsg( ...$args ) {
        $name = array_shift( $args );
        $this->addWikiMsgArray( $name, $args );
    }
 
    public function addWikiMsgArray( $name, $args ) {
        $this->addHTML( $this->msg( $name, $args )->parseAsBlock() );
    }
 
    public function wrapWikiMsg( $wrap, ...$msgSpecs ) {
        $s = $wrap;
        foreach ( $msgSpecs as $n => $spec ) {
            if ( is_array( $spec ) ) {
                $args = $spec;
                $name = array_shift( $args );
            } else {
                $args = [];
                $name = $spec;
            }
            $s = str_replace( '$' . ( $n + 1 ), $this->msg( $name, $args )->plain(), $s );
        }
        $this->addWikiTextAsInterface( $s );
    }
 
    public function isTOCEnabled() {
        return $this->mEnableTOC;
    }
 
    public static function setupOOUI( $skinName = 'default', $dir = 'ltr' ) {
        $themes = ResourceLoaderOOUIModule::getSkinThemeMap();
        $theme = $themes[$skinName] ?? $themes['default'];
        // For example, 'OOUI\WikimediaUITheme'.
        $themeClass = "OOUI\\{$theme}Theme";
        OOUI\Theme::setSingleton( new $themeClass() );
        OOUI\Element::setDefaultDir( $dir );
    }
 
    public function enableOOUI() {
        self::setupOOUI(
            strtolower( $this->getSkin()->getSkinName() ),
            $this->getLanguage()->getDir()
        );
        $this->addModuleStyles( [
            'oojs-ui-core.styles',
            'oojs-ui.styles.indicators',
            'mediawiki.widgets.styles',
            'oojs-ui-core.icons',
        ] );
    }
 
    public function getCSPNonce() {
        return $this->CSP->getNonce();
    }
 
    public function getCSP() {
        return $this->CSP;
    }
}