ParserOutput.php

Go to the documentation of this file.

<?php
 
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Html\Html;
use MediaWiki\Json\JsonUnserializable;
use MediaWiki\Json\JsonUnserializableTrait;
use MediaWiki\Json\JsonUnserializer;
use MediaWiki\Language\RawMessage;
use MediaWiki\Linker\Linker;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageReference;
use MediaWiki\Parser\ParserOutputFlags;
use MediaWiki\Parser\Parsoid\PageBundleParserOutputConverter;
use MediaWiki\Title\Title;
use Wikimedia\Bcp47Code\Bcp47Code;
use Wikimedia\Bcp47Code\Bcp47CodeValue;
use Wikimedia\Parsoid\Core\ContentMetadataCollector;
use Wikimedia\Parsoid\Core\ContentMetadataCollectorCompat;
use Wikimedia\Parsoid\Core\TOCData;
use Wikimedia\Reflection\GhostFieldAccessTrait;
 
class ParserOutput extends CacheTime implements ContentMetadataCollector {
    use GhostFieldAccessTrait;
    use JsonUnserializableTrait;
    // This is used to break cyclic dependencies and allow a measure
    // of compatibility when new methods are added to ContentMetadataCollector
    // by Parsoid.
    use ContentMetadataCollectorCompat;
 
    public const SUPPORTS_STATELESS_TRANSFORMS = 1;
 
    public const SUPPORTS_UNWRAP_TRANSFORM = 1;
 
    public const MW_MERGE_STRATEGY_KEY = '_mw-strategy';
 
    public const MW_MERGE_STRATEGY_UNION = 'union';
 
    private $mText = null;
 
    private $mLanguageLinks;
 
    private $mCategories;
 
    private $mIndicators = [];
 
    private $mTitleText;
 
    private $mLinks = [];
 
    private $mLinksSpecial = [];
 
    private $mTemplates = [];
 
    private $mTemplateIds = [];
 
    private $mImages = [];
 
    private $mFileSearchOptions = [];
 
    private $mExternalLinks = [];
 
    private $mInterwikiLinks = [];
 
    private $mNewSection = false;
 
    private $mHideNewSection = false;
 
    private $mNoGallery = false;
 
    private $mHeadItems = [];
 
    private $mModules = [];
 
    private $mModuleStyles = [];
 
    private $mJsConfigVars = [];
 
    private $mOutputHooks = [];
 
    private $mWarnings = [];
 
    private $mWarningMsgs = [];
 
    private $mTOCData;
 
    private $mProperties = [];
 
    private $mTOCHTML = '';
 
    private $mTimestamp;
 
    private $mEnableOOUI = false;
 
    private $mIndexSet = false;
 
    private $mNoIndexSet = false;
 
    private $mExtensionData = [];
 
    private $mLimitReportData = [];
 
    private $mLimitReportJSData = [];
 
    private $mCacheMessage = '';
 
    private $mParseStartTime = [];
 
    private $mPreventClickjacking = false;
 
    private $mExtraScriptSrcs = [];
 
    private $mExtraDefaultSrcs = [];
 
    private $mExtraStyleSrcs = [];
 
    private $mFlags = [];
 
    private const SPECULATIVE_FIELDS = [
        'speculativePageIdUsed',
        'mSpeculativeRevId',
        'revisionTimestampUsed',
    ];
 
    private $mSpeculativeRevId;
    private $speculativePageIdUsed;
    private $revisionTimestampUsed;
 
    private $revisionUsedSha1Base36;
 
    private $mWrapperDivClasses = [];
 
    private $mMaxAdaptiveExpiry = INF;
 
    private const EDITSECTION_REGEX =
        '#<mw:editsection page="(.*?)" section="(.*?)">(.*?)</mw:editsection>#s';
 
    // finalizeAdaptiveCacheExpiry() uses TTL = MAX( m * PARSE_TIME + b, MIN_AR_TTL)
    // Current values imply that m=3933.333333 and b=-333.333333
    // See https://www.nngroup.com/articles/website-response-times/
    private const PARSE_FAST_SEC = 0.100; // perceived "fast" page parse
    private const PARSE_SLOW_SEC = 1.0; // perceived "slow" page parse
    private const FAST_AR_TTL = 60; // adaptive TTL for "fast" pages
    private const SLOW_AR_TTL = 3600; // adaptive TTL for "slow" pages
    private const MIN_AR_TTL = 15; // min adaptive TTL (for pool counter, and edit stashing)
 
    public function __construct( $text = null, $languageLinks = [], $categoryLinks = [],
        $unused = false, $titletext = ''
    ) {
        $this->mText = $text;
        $this->mLanguageLinks = $languageLinks;
        $this->mCategories = $categoryLinks;
        $this->mTitleText = $titletext;
    }
 
    public function hasText(): bool {
        return ( $this->mText !== null );
    }
 
    public function getRawText() {
        if ( $this->mText === null ) {
            throw new LogicException( 'This ParserOutput contains no text!' );
        }
 
        return $this->mText;
    }
 
    public function getText( $options = [] ) {
        $options += [
            'allowTOC' => true,
            'injectTOC' => true,
            'enableSectionEditLinks' => true,
            'skin' => null,
            'userLang' => null,
            'unwrap' => false,
            'deduplicateStyles' => true,
            'wrapperDivClass' => $this->getWrapperDivClass(),
            'includeDebugInfo' => false,
            'bodyOnly' => true,
        ];
        $text = $this->getRawText();
        if (
            $options['bodyOnly'] &&
            PageBundleParserOutputConverter::hasPageBundle( $this )
        ) {
            // This is a full HTML document, generated by Parsoid.
            // Strip everything but the <body>
            // Probably would be better to process this as a DOM.
            $text = preg_replace( '/^.*?<body[^>]*>/s', '', $text, 1 );
            $text = preg_replace( '(</body>\s*</html>\s*$)', '', $text, 1 );
        }
 
        if ( $options['includeDebugInfo'] ) {
            $text .= $this->renderDebugInfo();
        }
 
        ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
            ->onParserOutputPostCacheTransform( $this, $text, $options );
 
        if ( $options['wrapperDivClass'] !== '' && !$options['unwrap'] ) {
            $text = Html::rawElement( 'div', [ 'class' => $options['wrapperDivClass'] ], $text );
        }
 
        if ( $options['enableSectionEditLinks'] ) {
            // TODO: Skin should not be required.
            // It would be better to define one or more narrow interfaces to use here,
            // so this code doesn't have to depend on all of Skin.
            // See OutputPage::addParserOutputText()
            $skin = $options['skin'] ?: RequestContext::getMain()->getSkin();
 
            $text = preg_replace_callback(
                self::EDITSECTION_REGEX,
                function ( $m ) use ( $skin ) {
                    $editsectionPage = Title::newFromText( htmlspecialchars_decode( $m[1] ) );
                    $editsectionSection = htmlspecialchars_decode( $m[2] );
                    $editsectionContent = Sanitizer::decodeCharReferences( $m[3] );
 
                    if ( !is_object( $editsectionPage ) ) {
                        LoggerFactory::getInstance( 'Parser' )
                            ->error(
                                'ParserOutput::getText(): bad title in editsection placeholder',
                                [
                                    'placeholder' => $m[0],
                                    'editsectionPage' => $m[1],
                                    'titletext' => $this->getTitleText(),
                                    'phab' => 'T261347',
                                ]
                            );
                        return '';
                    }
 
                    return $skin->doEditSectionLink(
                        $editsectionPage,
                        $editsectionSection,
                        $editsectionContent,
                        $skin->getLanguage()
                    );
                },
                $text
            );
        } else {
            $text = preg_replace( self::EDITSECTION_REGEX, '', $text );
        }
 
        if ( $options['allowTOC'] ) {
            if ( $options['injectTOC'] ) {
                if ( count( $this->getSections() ) === 0 ) {
                    $toc = '';
                } else {
                    $userLang = $options['userLang'];
                    $skin = $options['skin'];
                    if ( ( !$userLang ) && $skin ) {
                        // TODO: See above comment about replacing the use
                        // of 'skin' here.
                        $userLang = $skin->getLanguage();
                    }
                    if ( !$userLang ) {
                        $userLang = RequestContext::getMain()->getLanguage();
                    }
                    $toc = Linker::generateTOC( $this->getTOCData(), $userLang );
 
                    // XXX Use DI to inject this once ::getText() is moved out of ParserOutput.
                    $services = MediaWikiServices::getInstance();
                    $toc = $services->getTidy()->tidy( $toc, [ Sanitizer::class, 'armorFrenchSpaces' ] );
                }
                $this->mTOCHTML = $toc;
                $text = Parser::replaceTableOfContentsMarker( $text, $toc );
            }
        } else {
            $text = Parser::replaceTableOfContentsMarker( $text, '' );
        }
 
        if ( $options['deduplicateStyles'] ) {
            $seen = [];
            $text = preg_replace_callback(
                '#<style\s+([^>]*data-mw-deduplicate\s*=[^>]*)>.*?</style>#s',
                static function ( $m ) use ( &$seen ) {
                    $attr = Sanitizer::decodeTagAttributes( $m[1] );
                    if ( !isset( $attr['data-mw-deduplicate'] ) ) {
                        return $m[0];
                    }
 
                    $key = $attr['data-mw-deduplicate'];
                    if ( !isset( $seen[$key] ) ) {
                        $seen[$key] = true;
                        return $m[0];
                    }
 
                    // We were going to use an empty <style> here, but there
                    // was concern that would be too much overhead for browsers.
                    // So let's hope a <link> with a non-standard rel and href isn't
                    // going to be misinterpreted or mangled by any subsequent processing.
                    return Html::element( 'link', [
                        'rel' => 'mw-deduplicated-inline-style',
                        'href' => "mw-data:" . wfUrlencode( $key ),
                    ] );
                },
                $text
            );
        }
 
        // Expand all relative URLs
        if ( ( $options['absoluteURLs'] ?? false ) && $text ) {
            $text = Linker::expandLocalLinks( $text );
        }
 
        // Hydrate slot section header placeholders generated by RevisionRenderer.
        $text = preg_replace_callback(
            '#<mw:slotheader>(.*?)</mw:slotheader>#',
            static function ( $m ) {
                $role = htmlspecialchars_decode( $m[1] );
                // TODO: map to message, using the interface language. Set lang="xyz" accordingly.
                $headerText = $role;
                return $headerText;
            },
            $text
        );
        return $text;
    }
 
    public function addCacheMessage( string $msg ): void {
        $this->mCacheMessage .= $msg;
    }
 
    public function addWrapperDivClass( $class ): void {
        $this->mWrapperDivClasses[$class] = true;
    }
 
    public function clearWrapperDivClass(): void {
        $this->mWrapperDivClasses = [];
    }
 
    public function getWrapperDivClass(): string {
        return implode( ' ', array_keys( $this->mWrapperDivClasses ) );
    }
 
    public function setSpeculativeRevIdUsed( $id ): void {
        $this->mSpeculativeRevId = $id;
    }
 
    public function getSpeculativeRevIdUsed(): ?int {
        return $this->mSpeculativeRevId;
    }
 
    public function setSpeculativePageIdUsed( $id ): void {
        $this->speculativePageIdUsed = $id;
    }
 
    public function getSpeculativePageIdUsed() {
        return $this->speculativePageIdUsed;
    }
 
    public function setRevisionTimestampUsed( $timestamp ): void {
        $this->revisionTimestampUsed = $timestamp;
    }
 
    public function getRevisionTimestampUsed() {
        return $this->revisionTimestampUsed;
    }
 
    public function setRevisionUsedSha1Base36( $hash ): void {
        if ( $hash === null ) {
            return; // e.g. RevisionRecord::getSha1() returned null
        }
 
        if (
            $this->revisionUsedSha1Base36 !== null &&
            $this->revisionUsedSha1Base36 !== $hash
        ) {
            $this->revisionUsedSha1Base36 = ''; // mismatched
        } else {
            $this->revisionUsedSha1Base36 = $hash;
        }
    }
 
    public function getRevisionUsedSha1Base36() {
        return $this->revisionUsedSha1Base36;
    }
 
    public function &getLanguageLinks() {
        return $this->mLanguageLinks;
    }
 
    public function getInterwikiLinks() {
        return $this->mInterwikiLinks;
    }
 
    public function getCategoryLinks() {
        wfDeprecated( __METHOD__, '1.38' );
        return $this->getCategoryNames();
    }
 
    public function getCategoryNames(): array {
        # Note that numeric category names get converted to 'int' when
        # stored as array keys; stringify the keys to ensure they
        # return to original string form so as not to confuse callers.
        return array_map( 'strval', array_keys( $this->mCategories ) );
    }
 
    public function &getCategories() {
        return $this->mCategories;
    }
 
    public function getCategorySortKey( string $name ): ?string {
        // This API avoids exposing the fact that numeric string category
        // names are going to be converted to 'int' when used as array
        // keys for the `mCategories` field.
        return $this->mCategories[$name] ?? null;
    }
 
    public function getIndicators(): array {
        return $this->mIndicators;
    }
 
    public function getTitleText() {
        return $this->mTitleText;
    }
 
    public function getTOCData(): ?TOCData {
        return $this->mTOCData;
    }
 
    public function getSections(): array {
        if ( $this->mTOCData !== null ) {
            return $this->mTOCData->toLegacy();
        }
        // For compatibility
        return [];
    }
 
    public function &getLinks() {
        return $this->mLinks;
    }
 
    public function &getLinksSpecial() {
        return $this->mLinksSpecial;
    }
 
    public function &getTemplates() {
        return $this->mTemplates;
    }
 
    public function &getTemplateIds() {
        return $this->mTemplateIds;
    }
 
    public function &getImages() {
        return $this->mImages;
    }
 
    public function &getFileSearchOptions() {
        return $this->mFileSearchOptions;
    }
 
    public function &getExternalLinks() {
        return $this->mExternalLinks;
    }
 
    public function setNoGallery( $value ): void {
        $this->mNoGallery = (bool)$value;
    }
 
    public function getNoGallery() {
        return $this->mNoGallery;
    }
 
    public function getHeadItems() {
        return $this->mHeadItems;
    }
 
    public function getModules() {
        return $this->mModules;
    }
 
    public function getModuleStyles() {
        return $this->mModuleStyles;
    }
 
    public function getJsConfigVars( bool $showStrategyKeys = false ) {
        $result = $this->mJsConfigVars;
        // Don't expose the internal strategy key
        foreach ( $result as &$value ) {
            if ( is_array( $value ) && !$showStrategyKeys ) {
                unset( $value[self::MW_MERGE_STRATEGY_KEY] );
            }
        }
        return $result;
    }
 
    public function getOutputHooks(): array {
        return (array)$this->mOutputHooks;
    }
 
    public function getWarnings(): array {
        return array_keys( $this->mWarnings );
    }
 
    public function getIndexPolicy(): string {
        // 'noindex' wins if both are set. (T16899)
        if ( $this->mNoIndexSet ) {
            return 'noindex';
        } elseif ( $this->mIndexSet ) {
            return 'index';
        }
        return '';
    }
 
    public function getTOCHTML() {
        wfDeprecated( __METHOD__, '1.40' );
        return $this->mTOCHTML;
    }
 
    public function hasTOCHTML() {
        return (bool)$this->mTOCHTML;
    }
 
    public function getTimestamp() {
        return $this->mTimestamp;
    }
 
    public function getLimitReportData() {
        return $this->mLimitReportData;
    }
 
    public function getLimitReportJSData() {
        return $this->mLimitReportJSData;
    }
 
    public function getEnableOOUI() {
        return $this->mEnableOOUI;
    }
 
    public function getExtraCSPDefaultSrcs() {
        return $this->mExtraDefaultSrcs;
    }
 
    public function getExtraCSPScriptSrcs() {
        return $this->mExtraScriptSrcs;
    }
 
    public function getExtraCSPStyleSrcs() {
        return $this->mExtraStyleSrcs;
    }
 
    public function setText( $text ) {
        return wfSetVar( $this->mText, $text, true );
    }
 
    public function setLanguageLinks( $ll ) {
        return wfSetVar( $this->mLanguageLinks, $ll );
    }
 
    public function setCategoryLinks( $cl ) {
        wfDeprecated( __METHOD__, '1.38' );
        return wfSetVar( $this->mCategories, $cl );
    }
 
    public function setTitleText( $t ) {
        return wfSetVar( $this->mTitleText, $t );
    }
 
    public function setTOCData( TOCData $tocData ): void {
        $this->mTOCData = $tocData;
    }
 
    public function setSections( array $sectionArray ) {
        $oldValue = $this->getSections();
        $this->setTOCData( TOCData::fromLegacy( $sectionArray ) );
        return $oldValue;
    }
 
    public function setIndexPolicy( $policy ): string {
        $old = $this->getIndexPolicy();
        if ( $policy === 'noindex' ) {
            $this->mNoIndexSet = true;
        } elseif ( $policy === 'index' ) {
            $this->mIndexSet = true;
        }
        return $old;
    }
 
    public function setTOCHTML( $tochtml ) {
        wfDeprecated( __METHOD__, '1.40' );
        return wfSetVar( $this->mTOCHTML, $tochtml );
    }
 
    public function setTimestamp( $timestamp ) {
        return wfSetVar( $this->mTimestamp, $timestamp );
    }
 
    public function addCategory( $c, $sort = '' ): void {
        $this->mCategories[$c] = $sort;
    }
 
    public function setCategories( array $c ): void {
        $this->mCategories = $c;
    }
 
    public function setIndicator( $id, $content ): void {
        $this->mIndicators[$id] = $content;
    }
 
    public function setEnableOOUI( bool $enable = false ): void {
        $this->mEnableOOUI = $enable;
    }
 
    public function addLanguageLink( $t ): void {
        $this->mLanguageLinks[] = $t;
    }
 
    public function addWarning( $s ): void {
        wfDeprecated( __METHOD__, '1.38' );
        $this->mWarnings[$s] = 1;
    }
 
    public function addWarningMsg( string $msg, ...$args ): void {
        // preserve original arguments in $mWarningMsgs to allow merge
        // @todo: these aren't serialized/unserialized
        $this->mWarningMsgs[$msg] = $args;
        $s = wfMessage( $msg, ...$args )
            // some callers set the title here?
            ->inContentLanguage() // because this ends up in cache
            ->text();
        $this->mWarnings[$s] = 1;
    }
 
    public function addOutputHook( $hook, $data = false ): void {
        wfDeprecated( __METHOD__, '1.38' );
        $this->mOutputHooks[] = [ $hook, $data ];
    }
 
    public function setNewSection( $value ): void {
        $this->mNewSection = (bool)$value;
    }
 
    public function setHideNewSection( bool $value ): void {
        $this->mHideNewSection = $value;
    }
 
    public function hideNewSection( $value ): void {
        wfDeprecated( __METHOD__, '1.38' );
        $this->setHideNewSection( (bool)$value );
    }
 
    public function getHideNewSection(): bool {
        return (bool)$this->mHideNewSection;
    }
 
    public function getNewSection(): bool {
        return (bool)$this->mNewSection;
    }
 
    public static function isLinkInternal( $internal, $url ): bool {
        return (bool)preg_match( '/^' .
            # If server is proto relative, check also for http/https links
            ( substr( $internal, 0, 2 ) === '//' ? '(?:https?:)?' : '' ) .
            preg_quote( $internal, '/' ) .
            # check for query/path/anchor or end of link in each case
            '(?:[\?\/\#]|$)/i',
            $url
        );
    }
 
    public function addExternalLink( $url ): void {
        # We don't register links pointing to our own server, unless... :-)
        $config = MediaWikiServices::getInstance()->getMainConfig();
        $server = $config->get( MainConfigNames::Server );
        $registerInternalExternals = $config->get( MainConfigNames::RegisterInternalExternals );
        # Replace unnecessary URL escape codes with the referenced character
        # This prevents spammers from hiding links from the filters
        $url = Parser::normalizeLinkUrl( $url );
 
        $registerExternalLink = true;
        if ( !$registerInternalExternals ) {
            $registerExternalLink = !self::isLinkInternal( $server, $url );
        }
        if ( $registerExternalLink ) {
            $this->mExternalLinks[$url] = 1;
        }
    }
 
    public function addLink( LinkTarget $link, $id = null ): void {
        if ( $link->isExternal() ) {
            // Don't record interwikis in pagelinks
            $this->addInterwikiLink( $link );
            return;
        }
        $ns = $link->getNamespace();
        $dbk = $link->getDBkey();
        if ( $ns === NS_MEDIA ) {
            // Normalize this pseudo-alias if it makes it down here...
            $ns = NS_FILE;
        } elseif ( $ns === NS_SPECIAL ) {
            // We don't want to record Special: links in the database, so put them in a separate place.
            // It might actually be wise to, but we'd need to do some normalization.
            $this->mLinksSpecial[$dbk] = 1;
            return;
        } elseif ( $dbk === '' ) {
            // Don't record self links -  [[#Foo]]
            return;
        }
        if ( $id === null ) {
            $page = MediaWikiServices::getInstance()->getPageStore()->getPageForLink( $link );
            $id = $page->getId();
        }
        $this->mLinks[$ns][$dbk] = $id;
    }
 
    public function addImage( $name, $timestamp = null, $sha1 = null ): void {
        $this->mImages[$name] = 1;
        if ( $timestamp !== null && $sha1 !== null ) {
            $this->mFileSearchOptions[$name] = [ 'time' => $timestamp, 'sha1' => $sha1 ];
        }
    }
 
    public function addTemplate( $link, $page_id, $rev_id ): void {
        $ns = $link->getNamespace();
        $dbk = $link->getDBkey();
        $this->mTemplates[$ns][$dbk] = $page_id;
        $this->mTemplateIds[$ns][$dbk] = $rev_id; // For versioning
    }
 
    public function addInterwikiLink( $link ): void {
        if ( !$link->isExternal() ) {
            throw new MWException( 'Non-interwiki link passed, internal parser error.' );
        }
        $prefix = $link->getInterwiki();
        $this->mInterwikiLinks[$prefix][$link->getDBkey()] = 1;
    }
 
    public function addHeadItem( $section, $tag = false ): void {
        if ( $tag !== false ) {
            $this->mHeadItems[$tag] = $section;
        } else {
            $this->mHeadItems[] = $section;
        }
    }
 
    public function addModules( $modules ): void {
        if ( !is_array( $modules ) ) {
            // This method used to take string|array as an argument, but
            // we're trying to simplify the API.
            wfDeprecated( __METHOD__ . ' with non-array argument', '1.38' );
        }
        $this->mModules = array_merge( $this->mModules, (array)$modules );
    }
 
    public function addModuleStyles( $modules ): void {
        if ( !is_array( $modules ) ) {
            // This method used to take string|array as an argument, but
            // we're trying to simplify the API.
            wfDeprecated( __METHOD__ . ' with non-array argument', '1.38' );
        }
        $this->mModuleStyles = array_merge( $this->mModuleStyles, (array)$modules );
    }
 
    public function addJsConfigVars( $keys, $value = null ): void {
        if ( is_array( $keys ) ) {
            foreach ( $keys as $key => $value ) {
                $this->mJsConfigVars[$key] = $value;
            }
            return;
        }
 
        $this->mJsConfigVars[$keys] = $value;
    }
 
    public function setJsConfigVar( string $key, $value ): void {
        if (
            array_key_exists( $key, $this->mJsConfigVars ) &&
            $this->mJsConfigVars[$key] !== $value
        ) {
            // Ensure that a key is mapped to only a single value in order
            // to prevent the resulting array from varying if content
            // is parsed in a different order.
            throw new InvalidArgumentException( "Multiple conflicting values given for $key" );
        }
        $this->mJsConfigVars[$key] = $value;
    }
 
    public function appendJsConfigVar(
        string $key,
        string $value,
        string $strategy = self::MW_MERGE_STRATEGY_UNION
    ): void {
        if ( $strategy !== self::MW_MERGE_STRATEGY_UNION ) {
            throw new InvalidArgumentException( "Unknown merge strategy $strategy." );
        }
        if ( !array_key_exists( $key, $this->mJsConfigVars ) ) {
            $this->mJsConfigVars[$key] = [
                // Indicate how these values are to be merged.
                self::MW_MERGE_STRATEGY_KEY => $strategy,
            ];
        } elseif ( !is_array( $this->mJsConfigVars[$key] ) ) {
            throw new InvalidArgumentException( "Mixing set and append for $key" );
        } elseif ( ( $this->mJsConfigVars[$key][self::MW_MERGE_STRATEGY_KEY] ?? null ) !== $strategy ) {
            throw new InvalidArgumentException( "Conflicting merge strategies for $key" );
        }
        $this->mJsConfigVars[$key][$value] = true;
    }
 
    public function addOutputPageMetadata( OutputPage $out ): void {
        // This should eventually use the same merge mechanism used
        // internally to merge ParserOutputs together.
 
        // Take the strictest click-jacking policy. This is to ensure any one-click features
        // such as patrol or rollback on the transcluded special page will result in the wiki page
        // disallowing embedding in cross-origin iframes. Articles are generally allowed to be
        // embedded. Pages that transclude special pages are expected to be user pages or
        // other non-content pages that content re-users won't discover or care about.
        $this->mPreventClickjacking = $this->mPreventClickjacking || $out->getPreventClickjacking();
 
        $this->addModuleStyles( $out->getModuleStyles() );
 
        // TODO: Figure out if style modules suffice, or whether the below is needed as well.
        // Are there special pages that permit transcluding/including and also have JS modules
        // that should be activate on the host page?
        $this->addModules( $out->getModules() );
        $this->mJsConfigVars = self::mergeMapStrategy(
            $this->mJsConfigVars, $out->getJsConfigVars()
        );
        $this->mHeadItems = array_merge( $this->mHeadItems, $out->getHeadItemsArray() );
    }
 
    public function addTrackingCategory( $msg, PageReference $page ): bool {
        wfDeprecated( __METHOD__, '1.38' );
        $trackingCategories = MediaWikiServices::getInstance()->getTrackingCategories();
        return $trackingCategories->addTrackingCategory( $this, $msg, $page );
    }
 
    public function setDisplayTitle( $text ): void {
        $this->setTitleText( $text );
        $this->setPageProperty( 'displaytitle', $text );
    }
 
    public function getDisplayTitle() {
        $t = $this->getTitleText();
        if ( $t === '' ) {
            return false;
        }
        return $t;
    }
 
    public function getLanguage(): ?Bcp47Code {
        // This information is temporarily stored in extension data (T303329)
        $code = $this->getExtensionData( 'core:target-lang-variant' );
        return $code === null ? null : new Bcp47CodeValue( $code );
    }
 
    public function setLanguage( Bcp47Code $lang ): void {
        $this->setExtensionData( 'core:target-lang-variant', $lang->toBcp47Code() );
    }
 
    public function setFlag( $flag ): void {
        $this->mFlags[$flag] = true;
    }
 
    public function getFlag( $flag ): bool {
        return isset( $this->mFlags[$flag] );
    }
 
    public function getAllFlags(): array {
        return array_keys( $this->mFlags );
    }
 
    public function setProperty( $name, $value ): void {
        wfDeprecated( __METHOD__, '1.38' );
        $this->setPageProperty( $name, $value );
    }
 
    public function getProperty( $name ) {
        wfDeprecated( __METHOD__, '1.38' );
        return $this->getPageProperty( $name ) ?? false;
    }
 
    public function unsetProperty( $name ): void {
        wfDeprecated( __METHOD__, '1.38' );
        $this->unsetPageProperty( $name );
    }
 
    public function getProperties() {
        wfDeprecated( __METHOD__, '1.38' );
        return $this->getPageProperties();
    }
 
    public function setPageProperty( string $name, $value ): void {
        $this->mProperties[$name] = $value;
    }
 
    public function getPageProperty( string $name ) {
        return $this->mProperties[$name] ?? null;
    }
 
    public function unsetPageProperty( string $name ): void {
        unset( $this->mProperties[$name] );
    }
 
    public function getPageProperties(): array {
        if ( !isset( $this->mProperties ) ) {
            $this->mProperties = [];
        }
        return $this->mProperties;
    }
 
    public function setOutputFlag( string $name, bool $val = true ): void {
        switch ( $name ) {
        case ParserOutputFlags::NO_GALLERY:
            $this->setNoGallery( $val );
            break;
 
        case ParserOutputFlags::ENABLE_OOUI:
            $this->setEnableOOUI( $val );
            break;
 
        case ParserOutputFlags::NO_INDEX_POLICY:
            $this->mNoIndexSet = $val;
            break;
 
        case ParserOutputFlags::INDEX_POLICY:
            $this->mIndexSet = $val;
            break;
 
        case ParserOutputFlags::NEW_SECTION:
            $this->setNewSection( $val );
            break;
 
        case ParserOutputFlags::HIDE_NEW_SECTION:
            $this->setHideNewSection( $val );
            break;
 
        case ParserOutputFlags::PREVENT_CLICKJACKING:
            $this->setPreventClickjacking( $val );
            break;
 
        default:
            if ( $val ) {
                $this->mFlags[$name] = true;
            } else {
                unset( $this->mFlags[$name] );
            }
            break;
        }
    }
 
    public function getOutputFlag( string $name ): bool {
        switch ( $name ) {
        case ParserOutputFlags::NO_GALLERY:
            return $this->getNoGallery();
 
        case ParserOutputFlags::ENABLE_OOUI:
            return $this->getEnableOOUI();
 
        case ParserOutputFlags::INDEX_POLICY:
            return $this->mIndexSet;
 
        case ParserOutputFlags::NO_INDEX_POLICY:
            return $this->mNoIndexSet;
 
        case ParserOutputFlags::NEW_SECTION:
            return $this->getNewSection();
 
        case ParserOutputFlags::HIDE_NEW_SECTION:
            return $this->getHideNewSection();
 
        case ParserOutputFlags::PREVENT_CLICKJACKING:
            return $this->getPreventClickjacking();
 
        default:
            return $this->getFlag( $name );
 
        }
    }
 
    public function setExtensionData( $key, $value ): void {
        if (
            array_key_exists( $key, $this->mExtensionData ) &&
            $this->mExtensionData[$key] !== $value
        ) {
            // This behavior was deprecated in 1.38.  We will eventually
            // emit a warning here, then throw an exception.
        }
        if ( $value === null ) {
            unset( $this->mExtensionData[$key] );
        } else {
            $this->mExtensionData[$key] = $value;
        }
    }
 
    public function appendExtensionData(
        string $key,
        $value,
        string $strategy = self::MW_MERGE_STRATEGY_UNION
    ): void {
        if ( $strategy !== self::MW_MERGE_STRATEGY_UNION ) {
            throw new InvalidArgumentException( "Unknown merge strategy $strategy." );
        }
        if ( !array_key_exists( $key, $this->mExtensionData ) ) {
            $this->mExtensionData[$key] = [
                // Indicate how these values are to be merged.
                self::MW_MERGE_STRATEGY_KEY => $strategy,
            ];
        } elseif ( !is_array( $this->mExtensionData[$key] ) ) {
            throw new InvalidArgumentException( "Mixing set and append for $key" );
        } elseif ( ( $this->mExtensionData[$key][self::MW_MERGE_STRATEGY_KEY] ?? null ) !== $strategy ) {
            throw new InvalidArgumentException( "Conflicting merge strategies for $key" );
        }
        $this->mExtensionData[$key][$value] = true;
    }
 
    public function getExtensionData( $key ) {
        $value = $this->mExtensionData[$key] ?? null;
        if ( is_array( $value ) ) {
            // Don't expose our internal merge strategy key.
            unset( $value[self::MW_MERGE_STRATEGY_KEY] );
        }
        return $value;
    }
 
    private static function getTimes( $clock = null ): array {
        $ret = [];
        if ( !$clock || $clock === 'wall' ) {
            $ret['wall'] = microtime( true );
        }
        if ( !$clock || $clock === 'cpu' ) {
            $ru = getrusage( 0 /* RUSAGE_SELF */ );
            $ret['cpu'] = $ru['ru_utime.tv_sec'] + $ru['ru_utime.tv_usec'] / 1e6;
            $ret['cpu'] += $ru['ru_stime.tv_sec'] + $ru['ru_stime.tv_usec'] / 1e6;
        }
        return $ret;
    }
 
    public function resetParseStartTime(): void {
        $this->mParseStartTime = self::getTimes();
    }
 
    public function getTimeSinceStart( $clock ) {
        if ( !isset( $this->mParseStartTime[$clock] ) ) {
            return null;
        }
 
        $end = self::getTimes( $clock );
        return $end[$clock] - $this->mParseStartTime[$clock];
    }
 
    public function setLimitReportData( $key, $value ): void {
        $this->mLimitReportData[$key] = $value;
 
        if ( is_array( $value ) ) {
            if ( array_keys( $value ) === [ 0, 1 ]
                && is_numeric( $value[0] )
                && is_numeric( $value[1] )
            ) {
                $data = [ 'value' => $value[0], 'limit' => $value[1] ];
            } else {
                $data = $value;
            }
        } else {
            $data = $value;
        }
 
        if ( strpos( $key, '-' ) ) {
            [ $ns, $name ] = explode( '-', $key, 2 );
            $this->mLimitReportJSData[$ns][$name] = $data;
        } else {
            $this->mLimitReportJSData[$key] = $data;
        }
    }
 
    private function renderDebugInfo(): string {
        $text = '';
 
        $limitReportData = $this->getLimitReportData();
        // If nothing set it, we can't get it.
        if ( $limitReportData ) {
            $limitReport = "NewPP limit report\n";
 
            if ( array_key_exists( 'cachereport-origin', $limitReportData ) ) {
                $limitReport .= "Parsed by {$limitReportData['cachereport-origin']}\n";
            }
 
            if ( array_key_exists( 'cachereport-timestamp', $limitReportData ) ) {
                $limitReport .= "Cached time: {$limitReportData['cachereport-timestamp']}\n";
            }
 
            if ( array_key_exists( 'cachereport-ttl', $limitReportData ) ) {
                $limitReport .= "Cache expiry: {$limitReportData['cachereport-ttl']}\n";
            }
 
            if ( array_key_exists( 'cachereport-transientcontent', $limitReportData ) ) {
                $transient = $limitReportData['cachereport-transientcontent'] ? 'true' : 'false';
                $limitReport .= "Reduced expiry: $transient\n";
            }
 
            // TODO: flags should go into limit report too.
            $limitReport .= 'Complications: [' . implode( ', ', $this->getAllFlags() ) . "]\n";
 
            $hookRunner = new HookRunner( MediaWikiServices::getInstance()->getHookContainer() );
            foreach ( $limitReportData as $key => $value ) {
                if ( in_array( $key, [
                    'cachereport-origin',
                    'cachereport-timestamp',
                    'cachereport-ttl',
                    'cachereport-transientcontent',
                    'limitreport-timingprofile',
                ] ) ) {
                    // These keys are processed separately.
                    continue;
                }
                if ( $hookRunner->onParserLimitReportFormat(
                    $key, $value, $limitReport, false, false )
                ) {
                    $keyMsg = wfMessage( $key )->inLanguage( 'en' )->useDatabase( false );
                    $valueMsg = wfMessage( [ "$key-value-text", "$key-value" ] )
                        ->inLanguage( 'en' )->useDatabase( false );
                    if ( !$valueMsg->exists() ) {
                        $valueMsg = new RawMessage( '$1' );
                    }
                    if ( !$keyMsg->isDisabled() && !$valueMsg->isDisabled() ) {
                        $valueMsg->params( $value );
                        $limitReport .= "{$keyMsg->text()}: {$valueMsg->text()}\n";
                    }
                }
            }
            // Since we're not really outputting HTML, decode the entities and
            // then re-encode the things that need hiding inside HTML comments.
            $limitReport = htmlspecialchars_decode( $limitReport );
 
            // Sanitize for comment. Note '‐' in the replacement is U+2010,
            // which looks much like the problematic '-'.
            $limitReport = str_replace( [ '-', '&' ], [ '‐', '&amp;' ], $limitReport );
            $text = "\n<!-- \n$limitReport-->\n";
 
            $profileReport = $limitReportData['limitreport-timingprofile'] ?? null;
            if ( $profileReport ) {
                $text .= "<!--\nTransclusion expansion time report (%,ms,calls,template)\n";
                $text .= implode( "\n", $profileReport ) . "\n-->\n";
            }
        }
 
        if ( $this->mCacheMessage ) {
            $text .= "\n<!-- $this->mCacheMessage\n -->\n";
        }
 
        return $text;
    }
 
    public function hasReducedExpiry(): bool {
        $parserCacheExpireTime = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ParserCacheExpireTime );
 
        return $this->getCacheExpiry() < $parserCacheExpireTime;
    }
 
    public function hasDynamicContent(): bool {
        wfDeprecated( __METHOD__, '1.38' );
        return $this->hasReducedExpiry();
    }
 
    public function setPreventClickjacking( bool $flag ) {
        $this->mPreventClickjacking = $flag;
    }
 
    public function getPreventClickjacking(): bool {
        return $this->mPreventClickjacking;
    }
 
    public function preventClickjacking( $flag ): bool {
        wfDeprecated( __METHOD__, '1.38' );
        $old = $this->getPreventClickjacking();
        if ( $flag !== null ) {
            $this->setPreventClickjacking( $flag );
        }
        return $old;
    }
 
    public function updateRuntimeAdaptiveExpiry( $ttl ): void {
        $this->mMaxAdaptiveExpiry = min( $ttl, $this->mMaxAdaptiveExpiry );
        $this->updateCacheExpiry( $ttl );
    }
 
    public function addExtraCSPDefaultSrc( $src ): void {
        $this->mExtraDefaultSrcs[] = $src;
    }
 
    public function addExtraCSPStyleSrc( $src ): void {
        $this->mExtraStyleSrcs[] = $src;
    }
 
    public function addExtraCSPScriptSrc( $src ): void {
        $this->mExtraScriptSrcs[] = $src;
    }
 
    public function finalizeAdaptiveCacheExpiry(): void {
        if ( is_infinite( $this->mMaxAdaptiveExpiry ) ) {
            return; // not set
        }
 
        $runtime = $this->getTimeSinceStart( 'wall' );
        if ( is_float( $runtime ) ) {
            $slope = ( self::SLOW_AR_TTL - self::FAST_AR_TTL )
                / ( self::PARSE_SLOW_SEC - self::PARSE_FAST_SEC );
            // SLOW_AR_TTL = PARSE_SLOW_SEC * $slope + $point
            $point = self::SLOW_AR_TTL - self::PARSE_SLOW_SEC * $slope;
 
            $adaptiveTTL = min(
                max( $slope * $runtime + $point, self::MIN_AR_TTL ),
                $this->mMaxAdaptiveExpiry
            );
            $this->updateCacheExpiry( $adaptiveTTL );
        }
    }
 
    public function __sleep() {
        return array_filter( array_keys( get_object_vars( $this ) ),
            static function ( $field ) {
                if ( $field === 'mParseStartTime' || $field === 'mWarningMsgs' ) {
                    return false;
                }
                // Unserializing unknown private fields in HHVM causes
                // member variables with nulls in their names (T229366)
                return strpos( $field, "\0" ) === false;
            }
        );
    }
 
    public function mergeInternalMetaDataFrom( ParserOutput $source ): void {
        $this->mOutputHooks = self::mergeList( $this->mOutputHooks, $source->getOutputHooks() );
        $this->mWarnings = self::mergeMap( $this->mWarnings, $source->mWarnings ); // don't use getter
        $this->mTimestamp = $this->useMaxValue( $this->mTimestamp, $source->getTimestamp() );
 
        foreach ( self::SPECULATIVE_FIELDS as $field ) {
            if ( $this->$field && $source->$field && $this->$field !== $source->$field ) {
                wfLogWarning( __METHOD__ . ": inconsistent '$field' properties!" );
            }
            $this->$field = $this->useMaxValue( $this->$field, $source->$field );
        }
 
        $this->mParseStartTime = $this->useEachMinValue(
            $this->mParseStartTime,
            $source->mParseStartTime
        );
 
        $this->mFlags = self::mergeMap( $this->mFlags, $source->mFlags );
        $this->mParseUsedOptions = self::mergeMap( $this->mParseUsedOptions, $source->mParseUsedOptions );
 
        // TODO: maintain per-slot limit reports!
        if ( empty( $this->mLimitReportData ) ) {
            $this->mLimitReportData = $source->mLimitReportData;
        }
        if ( empty( $this->mLimitReportJSData ) ) {
            $this->mLimitReportJSData = $source->mLimitReportJSData;
        }
    }
 
    public function mergeHtmlMetaDataFrom( ParserOutput $source ): void {
        // HTML and HTTP
        $this->mHeadItems = self::mergeMixedList( $this->mHeadItems, $source->getHeadItems() );
        $this->mModules = self::mergeList( $this->mModules, $source->getModules() );
        $this->mModuleStyles = self::mergeList( $this->mModuleStyles, $source->getModuleStyles() );
        $this->mJsConfigVars = self::mergeMapStrategy( $this->mJsConfigVars, $source->mJsConfigVars );
        $this->mMaxAdaptiveExpiry = min( $this->mMaxAdaptiveExpiry, $source->mMaxAdaptiveExpiry );
        $this->mExtraStyleSrcs = self::mergeList(
            $this->mExtraStyleSrcs,
            $source->getExtraCSPStyleSrcs()
        );
        $this->mExtraScriptSrcs = self::mergeList(
            $this->mExtraScriptSrcs,
            $source->getExtraCSPScriptSrcs()
        );
        $this->mExtraDefaultSrcs = self::mergeList(
            $this->mExtraDefaultSrcs,
            $source->getExtraCSPDefaultSrcs()
        );
 
        // "noindex" always wins!
        $this->mIndexSet = $this->mIndexSet || $source->mIndexSet;
        $this->mNoIndexSet = $this->mNoIndexSet || $source->mNoIndexSet;
 
        // Skin control
        $this->mNewSection = $this->mNewSection || $source->getNewSection();
        $this->mHideNewSection = $this->mHideNewSection || $source->getHideNewSection();
        $this->mNoGallery = $this->mNoGallery || $source->getNoGallery();
        $this->mEnableOOUI = $this->mEnableOOUI || $source->getEnableOOUI();
        $this->mPreventClickjacking = $this->mPreventClickjacking || $source->getPreventClickjacking();
 
        $tocData = $this->getTOCData();
        $sourceTocData = $source->getTOCData();
        if ( $tocData !== null ) {
            if ( $sourceTocData !== null ) {
                // T327429: Section merging is broken, since it doesn't respect
                // global numbering, but there are tests which expect section
                // metadata to be concatendated.
                // There should eventually be a deprecation warning here.
                foreach ( $sourceTocData->getSections() as $s ) {
                    $tocData->addSection( $s );
                }
            }
        } elseif ( $sourceTocData !== null ) {
            $this->setTOCData( $sourceTocData );
        }
        // T327429/T293513: This is also bogus.
        $this->mTOCHTML .= $source->mTOCHTML;
 
        // XXX: we don't want to concatenate title text, so first write wins.
        // We should use the first *modified* title text, but we don't have the original to check.
        if ( $this->mTitleText === null || $this->mTitleText === '' ) {
            $this->mTitleText = $source->mTitleText;
        }
 
        // class names are stored in array keys
        $this->mWrapperDivClasses = self::mergeMap(
            $this->mWrapperDivClasses,
            $source->mWrapperDivClasses
        );
 
        // NOTE: last write wins, same as within one ParserOutput
        $this->mIndicators = self::mergeMap( $this->mIndicators, $source->getIndicators() );
 
        // NOTE: include extension data in "tracking meta data" as well as "html meta data"!
        // TODO: add a $mergeStrategy parameter to setExtensionData to allow different
        // kinds of extension data to be merged in different ways.
        $this->mExtensionData = self::mergeMapStrategy(
            $this->mExtensionData,
            $source->mExtensionData
        );
    }
 
    public function mergeTrackingMetaDataFrom( ParserOutput $source ): void {
        $this->mLanguageLinks = self::mergeList( $this->mLanguageLinks, $source->getLanguageLinks() );
        $this->mCategories = self::mergeMap( $this->mCategories, $source->getCategories() );
        $this->mLinks = self::merge2D( $this->mLinks, $source->getLinks() );
        $this->mTemplates = self::merge2D( $this->mTemplates, $source->getTemplates() );
        $this->mTemplateIds = self::merge2D( $this->mTemplateIds, $source->getTemplateIds() );
        $this->mImages = self::mergeMap( $this->mImages, $source->getImages() );
        $this->mFileSearchOptions = self::mergeMap(
            $this->mFileSearchOptions,
            $source->getFileSearchOptions()
        );
        $this->mExternalLinks = self::mergeMap( $this->mExternalLinks, $source->getExternalLinks() );
        $this->mInterwikiLinks = self::merge2D(
            $this->mInterwikiLinks,
            $source->getInterwikiLinks()
        );
 
        // TODO: add a $mergeStrategy parameter to setPageProperty to allow different
        // kinds of properties to be merged in different ways.
        // (Model this after ::appendJsConfigVar(); use ::mergeMapStrategy here)
        $this->mProperties = self::mergeMap( $this->mProperties, $source->getPageProperties() );
 
        // NOTE: include extension data in "tracking meta data" as well as "html meta data"!
        $this->mExtensionData = self::mergeMapStrategy(
            $this->mExtensionData,
            $source->mExtensionData
        );
    }
 
    public function collectMetadata( ContentMetadataCollector $metadata ): void {
        // Uniform handling of all boolean flags: they are OR'ed together.
        $flags = array_keys(
            $this->mFlags + array_flip( ParserOutputFlags::cases() )
        );
        foreach ( $flags as $name ) {
            if ( $this->getOutputFlag( $name ) ) {
                $metadata->setOutputFlag( $name );
            }
        }
        // @todo: Accumulators should also be handled uniformly
        foreach ( $this->mCategories as $cat => $key ) {
            // Numeric category strings are going to come out of the
            // `mCategories` array as ints; cast back to string.
            $metadata->addCategory( (string)$cat, $key );
        }
        $metadata->addModules( $this->mModules );
        $metadata->addModuleStyles( $this->mModuleStyles );
        foreach ( $this->mJsConfigVars as $key => $value ) {
            if ( is_array( $value ) && isset( $value[self::MW_MERGE_STRATEGY_KEY] ) ) {
                $strategy = $value[self::MW_MERGE_STRATEGY_KEY];
                foreach ( $value as $item => $ignore ) {
                    if ( $item !== self::MW_MERGE_STRATEGY_KEY ) {
                        $metadata->appendJsConfigVar( $key, $item, $strategy );
                    }
                }
            } elseif ( $metadata instanceof ParserOutput &&
                array_key_exists( $key, $metadata->mJsConfigVars )
            ) {
                // This behavior is deprecated, will likely result in
                // incorrect output, and we'll eventually emit a
                // warning here---but at the moment this is usually
                // caused by limitations in Parsoid and/or use of
                // the ParserAfterParse hook: T303015#7770480
                $metadata->mJsConfigVars[$key] = $value;
            } else {
                $metadata->setJsConfigVar( $key, $value );
            }
        }
        foreach ( $this->mExtensionData as $key => $value ) {
            if ( is_array( $value ) && isset( $value[self::MW_MERGE_STRATEGY_KEY] ) ) {
                $strategy = $value[self::MW_MERGE_STRATEGY_KEY];
                foreach ( $value as $item => $ignore ) {
                    if ( $item !== self::MW_MERGE_STRATEGY_KEY ) {
                        $metadata->appendExtensionData( $key, $item, $strategy );
                    }
                }
            } elseif ( $metadata instanceof ParserOutput &&
                array_key_exists( $key, $metadata->mExtensionData )
            ) {
                // This behavior is deprecated, will likely result in
                // incorrect output, and we'll eventually emit a
                // warning here---but at the moment this is usually
                // caused by limitations in Parsoid and/or use of
                // the ParserAfterParse hook: T303015#7770480
                $metadata->mExtensionData[$key] = $value;
            } else {
                $metadata->setExtensionData( $key, $value );
            }
        }
        foreach ( $this->mExternalLinks as $url => $ignore ) {
            $metadata->addExternalLink( $url );
        }
        foreach ( $this->mProperties as $prop => $value ) {
            $metadata->setPageProperty( $prop, $value );
        }
        foreach ( $this->mWarningMsgs as $msg => $args ) {
            $metadata->addWarningMsg( $msg, ...$args );
        }
        foreach ( $this->mLimitReportData as $key => $value ) {
            $metadata->setLimitReportData( $key, $value );
        }
 
        // ParserOutput-only fields; maintained "behind the curtain"
        // since Parsoid doesn't have to know about them.
        //
        // In production use, the $metadata supplied to this method
        // will almost always be an instance of ParserOutput, passed to
        // Parsoid by core when parsing begins and returned to core by
        // Parsoid as a ContentMetadataCollector (Parsoid's name for
        // ParserOutput) when DataAccess::parseWikitext() is called.
        //
        // We may use still Parsoid's StubMetadataCollector for testing or
        // when running Parsoid in standalone mode, so forcing a downcast
        // here would lose some flexibility.
 
        if ( $metadata instanceof ParserOutput ) {
            foreach ( $this->getUsedOptions() as $opt ) {
                $metadata->recordOption( $opt );
            }
            if ( $this->mCacheExpiry !== null ) {
                $metadata->updateCacheExpiry( $this->mCacheExpiry );
            }
            if ( $this->mCacheTime !== '' ) {
                $metadata->setCacheTime( $this->mCacheTime );
            }
            if ( $this->mCacheRevisionId !== null ) {
                $metadata->setCacheRevisionId( $this->mCacheRevisionId );
            }
            // T293514: We should use the first *modified* title text, but
            // we don't have the original to check.
            $otherTitle = $metadata->getTitleText();
            if ( $otherTitle === null || $otherTitle === '' ) {
                $metadata->setTitleText( $this->getTitleText() );
            }
        }
    }
 
    private static function mergeMixedList( array $a, array $b ): array {
        return array_unique( array_merge( $a, $b ), SORT_REGULAR );
    }
 
    private static function mergeList( array $a, array $b ): array {
        return array_values( array_unique( array_merge( $a, $b ), SORT_REGULAR ) );
    }
 
    private static function mergeMap( array $a, array $b ): array {
        return array_replace( $a, $b );
    }
 
    private static function mergeMapStrategy( array $a, array $b ): array {
        foreach ( $b as $key => $bValue ) {
            if ( !array_key_exists( $key, $a ) ) {
                $a[$key] = $bValue;
            } elseif (
                is_array( $a[$key] ) &&
                isset( $a[$key][self::MW_MERGE_STRATEGY_KEY] ) &&
                isset( $bValue[self::MW_MERGE_STRATEGY_KEY] )
            ) {
                $strategy = $bValue[self::MW_MERGE_STRATEGY_KEY];
                if ( $strategy !== $a[$key][self::MW_MERGE_STRATEGY_KEY] ) {
                    throw new InvalidArgumentException( "Conflicting merge strategy for $key" );
                }
                if ( $strategy === self::MW_MERGE_STRATEGY_UNION ) {
                    // Note the array_merge is *not* safe to use here, because
                    // the $bValue is expected to be a map from items to `true`.
                    // If the item is a numeric string like '1' then array_merge
                    // will convert it to an integer and renumber the array!
                    $a[$key] = array_replace( $a[$key], $bValue );
                } else {
                    throw new InvalidArgumentException( "Unknown merge strategy $strategy" );
                }
            } else {
                $valuesSame = ( $a[$key] === $bValue );
                if ( ( !$valuesSame ) &&
                     is_object( $a[$key] ) &&
                     is_object( $bValue )
                ) {
                    $jsonCodec = MediaWikiServices::getInstance()->getJsonCodec();
                    $valuesSame = ( $jsonCodec->serialize( $a[$key] ) === $jsonCodec->serialize( $bValue ) );
                }
                if ( !$valuesSame ) {
                    // Silently replace for now; in the future will first emit
                    // a deprecation warning, and then (later) throw.
                    $a[$key] = $bValue;
                }
            }
        }
        return $a;
    }
 
    private static function merge2D( array $a, array $b ): array {
        $values = [];
        $keys = array_merge( array_keys( $a ), array_keys( $b ) );
 
        foreach ( $keys as $k ) {
            if ( empty( $a[$k] ) ) {
                $values[$k] = $b[$k];
            } elseif ( empty( $b[$k] ) ) {
                $values[$k] = $a[$k];
            } elseif ( is_array( $a[$k] ) && is_array( $b[$k] ) ) {
                $values[$k] = array_replace( $a[$k], $b[$k] );
            } else {
                $values[$k] = $b[$k];
            }
        }
 
        return $values;
    }
 
    private static function useEachMinValue( array $a, array $b ): array {
        $values = [];
        $keys = array_merge( array_keys( $a ), array_keys( $b ) );
 
        foreach ( $keys as $k ) {
            if ( is_array( $a[$k] ?? null ) && is_array( $b[$k] ?? null ) ) {
                $values[$k] = self::useEachMinValue( $a[$k], $b[$k] );
            } else {
                $values[$k] = self::useMinValue( $a[$k] ?? null, $b[$k] ?? null );
            }
        }
 
        return $values;
    }
 
    private static function useMinValue( $a, $b ) {
        if ( $a === null ) {
            return $b;
        }
 
        if ( $b === null ) {
            return $a;
        }
 
        return min( $a, $b );
    }
 
    private static function useMaxValue( $a, $b ) {
        if ( $a === null ) {
            return $b;
        }
 
        if ( $b === null ) {
            return $a;
        }
 
        return max( $a, $b );
    }
 
    protected function toJsonArray(): array {
        // WARNING: When changing how this class is serialized, follow the instructions
        // at <https://www.mediawiki.org/wiki/Manual:Parser_cache/Serialization_compatibility>!
 
        $data = [
            'Text' => $this->mText,
            'LanguageLinks' => $this->mLanguageLinks,
            'Categories' => $this->mCategories,
            'Indicators' => $this->mIndicators,
            'TitleText' => $this->mTitleText,
            'Links' => $this->mLinks,
            'LinksSpecial' => $this->mLinksSpecial,
            'Templates' => $this->mTemplates,
            'TemplateIds' => $this->mTemplateIds,
            'Images' => $this->mImages,
            'FileSearchOptions' => $this->mFileSearchOptions,
            'ExternalLinks' => $this->mExternalLinks,
            'InterwikiLinks' => $this->mInterwikiLinks,
            'NewSection' => $this->mNewSection,
            'HideNewSection' => $this->mHideNewSection,
            'NoGallery' => $this->mNoGallery,
            'HeadItems' => $this->mHeadItems,
            'Modules' => $this->mModules,
            'ModuleStyles' => $this->mModuleStyles,
            'JsConfigVars' => $this->mJsConfigVars,
            'OutputHooks' => $this->mOutputHooks,
            'Warnings' => $this->mWarnings,
            'Sections' => $this->getSections(),
            'Properties' => self::detectAndEncodeBinary( $this->mProperties ),
            'TOCHTML' => $this->mTOCHTML,
            'Timestamp' => $this->mTimestamp,
            'EnableOOUI' => $this->mEnableOOUI,
            'IndexPolicy' => $this->getIndexPolicy(),
            // may contain arbitrary structures!
            'ExtensionData' => $this->mExtensionData,
            'LimitReportData' => $this->mLimitReportData,
            'LimitReportJSData' => $this->mLimitReportJSData,
            'CacheMessage' => $this->mCacheMessage,
            'ParseStartTime' => $this->mParseStartTime,
            'PreventClickjacking' => $this->mPreventClickjacking,
            'ExtraScriptSrcs' => $this->mExtraScriptSrcs,
            'ExtraDefaultSrcs' => $this->mExtraDefaultSrcs,
            'ExtraStyleSrcs' => $this->mExtraStyleSrcs,
            'Flags' => $this->mFlags + (
                // backward-compatibility: distinguish "no sections" from
                // "sections not set" (Will be unnecessary after T327439.)
                $this->mTOCData === null ? [] : [ 'mw:toc-set' => true ]
            ),
            'SpeculativeRevId' => $this->mSpeculativeRevId,
            'SpeculativePageIdUsed' => $this->speculativePageIdUsed,
            'RevisionTimestampUsed' => $this->revisionTimestampUsed,
            'RevisionUsedSha1Base36' => $this->revisionUsedSha1Base36,
            'WrapperDivClasses' => $this->mWrapperDivClasses,
        ];
 
        // Fill in missing fields from parents. Array addition does not override existing fields.
        $data += parent::toJsonArray();
 
        // TODO: make more fields optional!
 
        if ( $this->mMaxAdaptiveExpiry !== INF ) {
            // NOTE: JSON can't encode infinity!
            $data['MaxAdaptiveExpiry'] = $this->mMaxAdaptiveExpiry;
        }
 
        if ( $this->mTOCData ) {
            // Temporarily add information from TOCData extension data
            // T327439: We should eventually make the entire mTOCData
            // serializable
            $toc = $this->mTOCData->jsonSerialize();
            if ( isset( $toc['extensionData'] ) ) {
                $data['TOCExtensionData'] = $toc['extensionData'];
            }
        }
 
        return $data;
    }
 
    public static function newFromJsonArray( JsonUnserializer $unserializer, array $json ): ParserOutput {
        $parserOutput = new ParserOutput();
        $parserOutput->initFromJson( $unserializer, $json );
        return $parserOutput;
    }
 
    protected function initFromJson( JsonUnserializer $unserializer, array $jsonData ): void {
        parent::initFromJson( $unserializer, $jsonData );
 
        // WARNING: When changing how this class is serialized, follow the instructions
        // at <https://www.mediawiki.org/wiki/Manual:Parser_cache/Serialization_compatibility>!
 
        $this->mText = $jsonData['Text'];
        $this->mLanguageLinks = $jsonData['LanguageLinks'];
        $this->mCategories = $jsonData['Categories'];
        $this->mIndicators = $jsonData['Indicators'];
        $this->mTitleText = $jsonData['TitleText'];
        $this->mLinks = $jsonData['Links'];
        $this->mLinksSpecial = $jsonData['LinksSpecial'];
        $this->mTemplates = $jsonData['Templates'];
        $this->mTemplateIds = $jsonData['TemplateIds'];
        $this->mImages = $jsonData['Images'];
        $this->mFileSearchOptions = $jsonData['FileSearchOptions'];
        $this->mExternalLinks = $jsonData['ExternalLinks'];
        $this->mInterwikiLinks = $jsonData['InterwikiLinks'];
        $this->mNewSection = $jsonData['NewSection'];
        $this->mHideNewSection = $jsonData['HideNewSection'];
        $this->mNoGallery = $jsonData['NoGallery'];
        $this->mHeadItems = $jsonData['HeadItems'];
        $this->mModules = $jsonData['Modules'];
        $this->mModuleStyles = $jsonData['ModuleStyles'];
        $this->mJsConfigVars = $jsonData['JsConfigVars'];
        $this->mOutputHooks = $jsonData['OutputHooks'];
        $this->mWarnings = $jsonData['Warnings'];
        $this->mFlags = $jsonData['Flags'];
        if (
            $jsonData['Sections'] !== [] ||
            // backward-compatibility: distinguish "no sections" from
            // "sections not set" (Will be unnecessary after T327439.)
            $this->getOutputFlag( 'mw:toc-set' )
        ) {
            $this->setSections( $jsonData['Sections'] );
            unset( $this->mFlags['mw:toc-set'] );
            if ( isset( $jsonData['TOCExtensionData'] ) ) {
                $tocData = $this->getTOCData(); // created by setSections() above
                foreach ( $jsonData['TOCExtensionData'] as $key => $value ) {
                    $tocData->setExtensionData( $key, $value );
                }
            }
        }
        $this->mProperties = self::detectAndDecodeBinary( $jsonData['Properties'] );
        $this->mTOCHTML = $jsonData['TOCHTML'];
        $this->mTimestamp = $jsonData['Timestamp'];
        $this->mEnableOOUI = $jsonData['EnableOOUI'];
        $this->setIndexPolicy( $jsonData['IndexPolicy'] );
        $this->mExtensionData = $jsonData['ExtensionData'] ?? [];
        $this->mLimitReportData = $jsonData['LimitReportData'];
        $this->mLimitReportJSData = $jsonData['LimitReportJSData'];
        $this->mCacheMessage = $jsonData['CacheMessage'] ?? '';
        $this->mParseStartTime = $jsonData['ParseStartTime'];
        $this->mPreventClickjacking = $jsonData['PreventClickjacking'];
        $this->mExtraScriptSrcs = $jsonData['ExtraScriptSrcs'];
        $this->mExtraDefaultSrcs = $jsonData['ExtraDefaultSrcs'];
        $this->mExtraStyleSrcs = $jsonData['ExtraStyleSrcs'];
        $this->mSpeculativeRevId = $jsonData['SpeculativeRevId'];
        $this->speculativePageIdUsed = $jsonData['SpeculativePageIdUsed'];
        $this->revisionTimestampUsed = $jsonData['RevisionTimestampUsed'];
        $this->revisionUsedSha1Base36 = $jsonData['RevisionUsedSha1Base36'];
        $this->mWrapperDivClasses = $jsonData['WrapperDivClasses'];
        $this->mMaxAdaptiveExpiry = $jsonData['MaxAdaptiveExpiry'] ?? INF;
    }
 
    private static function detectAndEncodeBinary( array $properties ) {
        foreach ( $properties as $key => $value ) {
            if ( is_string( $value ) ) {
                if ( !mb_detect_encoding( $value, 'UTF-8', true ) ) {
                    $properties[$key] = [
                        // T313818: This key name conflicts with JsonCodec
                        '_type_' => 'string',
                        '_encoding_' => 'base64',
                        '_data_' => base64_encode( $value ),
                    ];
                }
            }
        }
 
        return $properties;
    }
 
    private static function detectAndDecodeBinary( array $properties ) {
        foreach ( $properties as $key => $value ) {
            if ( is_array( $value ) && isset( $value['_encoding_'] ) ) {
                if ( $value['_encoding_'] === 'base64' ) {
                    $properties[$key] = base64_decode( $value['_data_'] );
                }
            }
        }
 
        return $properties;
    }
 
    public function __wakeup() {
        // Backwards compatibility, pre 1.36
        $priorAccessedOptions = $this->getGhostFieldValue( 'mAccessedOptions' );
        if ( $priorAccessedOptions ) {
            $this->mParseUsedOptions = $priorAccessedOptions;
        }
        // Backwards compatibility, pre 1.39
        $priorIndexPolicy = $this->getGhostFieldValue( 'mIndexPolicy' );
        if ( $priorIndexPolicy ) {
            $this->setIndexPolicy( $priorIndexPolicy );
        }
        // Backwards compatibility, pre 1.40
        $mSections = $this->getGhostFieldValue( 'mSections' );
        if ( $mSections !== null && $mSections !== [] ) {
            $this->setSections( $mSections );
        }
    }
 
    public function __get( $name ) {
        if ( property_exists( get_called_class(), $name ) ) {
            // Direct access to a public property, deprecated.
            wfDeprecatedMsg( "ParserOutput::{$name} public read access deprecated", '1.38' );
            return $this->$name;
        } elseif ( property_exists( $this, $name ) ) {
            // Dynamic property access, deprecated.
            wfDeprecatedMsg( "ParserOutput::{$name} dynamic property read access deprecated", '1.38' );
            return $this->$name;
        } else {
            trigger_error( "Inaccessible property via __get(): $name" );
            return null;
        }
    }
 
    public function __set( $name, $value ) {
        if ( property_exists( get_called_class(), $name ) ) {
            // Direct access to a public property, deprecated.
            wfDeprecatedMsg( "ParserOutput::$name public write access deprecated", '1.38' );
            $this->$name = $value;
        } else {
            // Dynamic property access, deprecated.
            wfDeprecatedMsg( "ParserOutput::$name dynamic property write access deprecated", '1.38' );
            $this->$name = $value;
        }
    }
}