ParserOutput.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use CacheTime;
use InvalidArgumentException;
use LogicException;
use MediaWiki\Edit\ParsoidRenderID;
use MediaWiki\Json\JsonUnserializable;
use MediaWiki\Json\JsonUnserializableTrait;
use MediaWiki\Json\JsonUnserializer;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Output\OutputPage;
use MediaWiki\Parser\Parsoid\PageBundleParserOutputConverter;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleValue;
use ParserOptions;
use UnexpectedValueException;
use Wikimedia\Bcp47Code\Bcp47Code;
use Wikimedia\Bcp47Code\Bcp47CodeValue;
use Wikimedia\Parsoid\Core\ContentMetadataCollector;
use Wikimedia\Parsoid\Core\ContentMetadataCollectorCompat;
use Wikimedia\Parsoid\Core\LinkTarget as ParsoidLinkTarget;
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 $mRawText = 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 $mModuleSet = [];
 
    private $mModuleStyleSet = [];
 
    private $mJsConfigVars = [];
 
    private $mWarnings = [];
 
    private $mWarningMsgs = [];
 
    private $mTOCData;
 
    private $mProperties = [];
 
    private $mTimestamp;
 
    private $mEnableOOUI = false;
 
    private $mIndexSet = false;
 
    private $mNoIndexSet = false;
 
    private $mExtensionData = [];
 
    private $mLimitReportData = [];
 
    private $mLimitReportJSData = [];
 
    private $mCacheMessage = '';
 
    private $mParseStartTime = [];
 
    private $mTimeProfile = [];
 
    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;
 
    // 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->mRawText = $text;
        $this->mLanguageLinks = $languageLinks;
        $this->mCategories = $categoryLinks;
        $this->mTitleText = $titletext;
    }
 
    public function hasText(): bool {
        return ( $this->mRawText !== null );
    }
 
    public function getRawText() {
        if ( $this->mRawText === null ) {
            throw new LogicException( 'This ParserOutput contains no text!' );
        }
 
        return $this->mRawText;
    }
 
    public function getText( $options = [] ) {
        $pipeline = MediaWikiServices::getInstance()->getDefaultOutputPipeline();
        $oldText = $this->mRawText; // T353257
        $options += [
            'suppressClone' => true, // T353257
            'allowTOC' => true,
            'injectTOC' => true,
            'enableSectionEditLinks' => !$this->getOutputFlag( ParserOutputFlags::NO_SECTION_EDIT_LINKS ),
            'userLang' => null,
            'skin' => null,
            'unwrap' => false,
            'wrapperDivClass' => $this->getWrapperDivClass(),
            'deduplicateStyles' => true,
            'absoluteURLs' => false,
            'includeDebugInfo' => false,
            'isParsoidContent' => PageBundleParserOutputConverter::hasPageBundle( $this ),
        ];
        $po = $pipeline->run( $this, null, $options );
        $newText = $po->getContentHolderText();
        // T353257: for back-compat only mutations to metadata performed by
        // the pipeline should be preserved; mutations to $mText should be
        // discarded.
        $this->setRawText( $oldText );
        return $newText;
    }
 
    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 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 getCategoryMap(): array {
        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 getCacheMessage(): string {
        return $this->mCacheMessage;
    }
 
    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 array_keys( $this->mModuleSet );
    }
 
    public function getModuleStyles() {
        return array_keys( $this->mModuleStyleSet );
    }
 
    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 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 getRevisionTimestamp(): ?string {
        return $this->mTimestamp;
    }
 
    public function getTimestamp() {
        return $this->getRevisionTimestamp();
    }
 
    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 setRawText( ?string $text ): void {
        $this->mRawText = $text;
    }
 
    public function setText( $text ) {
        return wfSetVar( $this->mRawText, $text, true );
    }
 
    public function setLanguageLinks( $ll ) {
        return wfSetVar( $this->mLanguageLinks, $ll );
    }
 
    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 setRevisionTimestamp( ?string $timestamp ): void {
        $this->mTimestamp = $timestamp;
    }
 
    public function setTimestamp( $timestamp ) {
        return wfSetVar( $this->mTimestamp, $timestamp );
    }
 
    public function addCategory( $c, $sort = '' ): void {
        if ( $c instanceof ParsoidLinkTarget ) {
            $c = $c->getDBkey();
        }
        $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 {
        if ( $t instanceof ParsoidLinkTarget ) {
            // language links are unusual in using 'text' rather than 'db key'
            // T296019: This should be made more efficient so we don't need
            // a full title lookup.
            $t = Title::newfromLinkTarget( $t )->getFullText();
        }
        $this->mLanguageLinks[] = $t;
    }
 
    public function addWarningMsg( string $msg, ...$args ): void {
        // preserve original arguments in $mWarningMsgs to allow merge
        // @todo: these aren't serialized/unserialized yet -- before we
        // turn on serialization of $this->mWarningMsgs we need to ensure
        // callers aren't passing nonserializable arguments: T343048.
        $jsonCodec = MediaWikiServices::getInstance()->getJsonCodec();
        $path = $jsonCodec->detectNonSerializableData( $args, true );
        if ( $path !== null ) {
            wfDeprecatedMsg(
                "ParserOutput::addWarningMsg() called with nonserializable arguments: $path",
                '1.41'
            );
        }
        $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 setNewSection( $value ): void {
        $this->mNewSection = (bool)$value;
    }
 
    public function setHideNewSection( bool $value ): void {
        $this->mHideNewSection = $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( ParsoidLinkTarget $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 ) {
            // T357048: This actually kills performance; we should batch these.
            $page = MediaWikiServices::getInstance()->getPageStore()->getPageForLink( $link );
            $id = $page->getId();
        }
        $this->mLinks[$ns][$dbk] = $id;
    }
 
    public function addImage( $name, $timestamp = null, $sha1 = null ): void {
        if ( $name instanceof ParsoidLinkTarget ) {
            $name = $name->getDBkey();
        }
        $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 {
        if ( $link->isExternal() ) {
            // Will throw an InvalidArgumentException in a future release.
            wfDeprecated( __METHOD__ . " with interwiki link", '1.42' );
            return;
        }
        $ns = $link->getNamespace();
        $dbk = $link->getDBkey();
        // T357048: Parsoid doesn't have page_id
        $this->mTemplates[$ns][$dbk] = $page_id;
        $this->mTemplateIds[$ns][$dbk] = $rev_id; // For versioning
    }
 
    public function addInterwikiLink( $link ): void {
        if ( !$link->isExternal() ) {
            throw new InvalidArgumentException( '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( array $modules ): void {
        $modules = array_fill_keys( $modules, true );
        $this->mModuleSet = array_merge( $this->mModuleSet, $modules );
    }
 
    public function addModuleStyles( array $modules ): void {
        $modules = array_fill_keys( $modules, true );
        $this->mModuleStyleSet = array_merge( $this->mModuleStyleSet, $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 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' );
        // This is null if the ParserOutput was cached by MW 1.40 or earlier,
        // or not constructed by Parser/ParserCache.
        return $code === null ? null : new Bcp47CodeValue( $code );
    }
 
    public function setLanguage( Bcp47Code $lang ): void {
        $this->setExtensionData( 'core:target-lang-variant', $lang->toBcp47Code() );
    }
 
    public function getRedirectHeader(): ?string {
        return $this->getExtensionData( 'core:redirect-header' );
    }
 
    public function setRedirectHeader( string $html ): void {
        $this->setExtensionData( 'core:redirect-header', $html );
    }
 
    public function setRenderId( string $renderId ): void {
        $this->setExtensionData( 'core:render-id', $renderId );
    }
 
    public function getRenderId(): ?string {
        // Backward-compatibility with old cache contents
        // Can be removed after parser cache contents have expired
        $old = $this->getExtensionData( 'parsoid-render-id' );
        if ( $old !== null ) {
            return ParsoidRenderId::newFromKey( $old )->getUniqueID();
        }
        return $this->getExtensionData( 'core:render-id' );
    }
 
    public function getAllFlags(): array {
        return array_keys( $this->mFlags );
    }
 
    public function setPageProperty( string $name, $value ): void {
        if ( !is_scalar( $value ) ) {
            wfDeprecated( __METHOD__ . " with non-scalar value for $name" );
        }
        $this->mProperties[$name] = $value;
    }
 
    public function setNumericPageProperty( string $propName, $numericValue ): void {
        if ( !is_numeric( $numericValue ) ) {
            throw new \TypeError( __METHOD__ . " with non-numeric value" );
        }
        // Coerce numeric sort key to a number.
        $this->mProperties[$propName] = 0 + $numericValue;
    }
 
    public function setUnsortedPageProperty( string $propName, string $value = '' ): void {
        $this->mProperties[$propName] = $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 isset( $this->mFlags[$name] );
 
        }
    }
 
    public function appendOutputStrings( string $name, array $value ): void {
        switch ( $name ) {
            case ParserOutputStringSets::MODULE:
                $this->addModules( $value );
                break;
            case ParserOutputStringSets::MODULE_STYLE:
                $this->addModuleStyles( $value );
                break;
            case ParserOutputStringSets::EXTRA_CSP_DEFAULT_SRC:
                foreach ( $value as $v ) {
                    $this->addExtraCSPDefaultSrc( $v );
                }
                break;
            case ParserOutputStringSets::EXTRA_CSP_SCRIPT_SRC:
                foreach ( $value as $v ) {
                    $this->addExtraCSPScriptSrc( $v );
                }
                break;
            case ParserOutputStringSets::EXTRA_CSP_STYLE_SRC:
                foreach ( $value as $v ) {
                    $this->addExtraCSPStyleSrc( $v );
                }
                break;
            default:
                throw new UnexpectedValueException( "Unknown output string set name $name" );
        }
    }
 
    public function getOutputStrings( string $name ): array {
        switch ( $name ) {
            case ParserOutputStringSets::MODULE:
                return $this->getModules();
            case ParserOutputStringSets::MODULE_STYLE:
                return $this->getModuleStyles();
            case ParserOutputStringSets::EXTRA_CSP_DEFAULT_SRC:
                return $this->getExtraCSPDefaultSrcs();
            case ParserOutputStringSets::EXTRA_CSP_SCRIPT_SRC:
                return $this->getExtraCSPScriptSrcs();
            case ParserOutputStringSets::EXTRA_CSP_STYLE_SRC:
                return $this->getExtraCSPStyleSrcs();
            default:
                throw new UnexpectedValueException( "Unknown output string set name $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();
        $this->mTimeProfile = [];
    }
 
    public function recordTimeProfile() {
        if ( !$this->mParseStartTime ) {
            // If resetParseStartTime was never called, there is nothing to record
            return;
        }
 
        if ( $this->mTimeProfile !== [] ) {
            // Don't override the times recorded by the previous call to recordTimeProfile().
            return;
        }
 
        $now = self::getTimes();
        $this->mTimeProfile = [
            'wall' => $now['wall'] - $this->mParseStartTime['wall'],
            'cpu' => $now['cpu'] - $this->mParseStartTime['cpu'],
        ];
    }
 
    public function getTimeProfile( string $clock ) {
        return $this->mTimeProfile[ $clock ] ?? null;
    }
 
    public function getTimeSinceStart( $clock ) {
        wfDeprecated( __METHOD__, '1.42' );
 
        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;
        }
    }
 
    public function hasReducedExpiry(): bool {
        $parserCacheExpireTime = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ParserCacheExpireTime );
 
        return $this->getCacheExpiry() < $parserCacheExpireTime;
    }
 
    public function setPreventClickjacking( bool $flag ) {
        $this->mPreventClickjacking = $flag;
    }
 
    public function getPreventClickjacking(): bool {
        return $this->mPreventClickjacking;
    }
 
    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->getTimeProfile( '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 setFromParserOptions( ParserOptions $parserOptions ) {
        // Copied from Parser.php::parse and should probably be abstracted
        // into the parent base class (probably as part of T236809)
        // Wrap non-interface parser output in a <div> so it can be targeted
        // with CSS (T37247)
        $class = $parserOptions->getWrapOutputClass();
        if ( $class !== false && !$parserOptions->getInterfaceMessage() ) {
            $this->addWrapperDivClass( $class );
        }
 
        // Record whether we should suppress section edit links
        if ( $parserOptions->getSuppressSectionEditLinks() ) {
            $this->setOutputFlag( ParserOutputFlags::NO_SECTION_EDIT_LINKS );
        }
 
        // Record whether this is a preview parse in the output (T341010)
        if ( $parserOptions->getIsPreview() ) {
            $this->setOutputFlag( ParserOutputFlags::IS_PREVIEW, true );
            // Ensure that previews aren't cacheable, just to be safe.
            $this->updateCacheExpiry( 0 );
        }
    }
 
    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->mWarnings = self::mergeMap( $this->mWarnings, $source->mWarnings ); // don't use getter
        $this->mTimestamp = $this->useMaxValue( $this->mTimestamp, $source->getRevisionTimestamp() );
        if ( $source->hasCacheTime() ) {
            $sourceCacheTime = $source->getCacheTime();
            if (
                !$this->hasCacheTime() ||
                // "undocumented use of -1 to mean not cacheable"
                // deprecated, but still supported by ::setCacheTime()
                strval( $sourceCacheTime ) === '-1' ||
                (
                    strval( $this->getCacheTime() ) !== '-1' &&
                    // use newer of the two times
                    $this->getCacheTime() < $sourceCacheTime
                )
            ) {
                $this->setCacheTime( $sourceCacheTime );
            }
        }
        if ( $source->getRenderId() !== null ) {
            // Final render ID should be a function of all component POs
            $rid = ( $this->getRenderId() ?? '' ) . $source->getRenderId();
            $this->setRenderId( $rid );
        }
        if ( $source->getCacheRevisionId() !== null ) {
            $sourceCacheRevisionId = $source->getCacheRevisionId();
            $thisCacheRevisionId = $this->getCacheRevisionId();
            if ( $thisCacheRevisionId === null ) {
                $this->setCacheRevisionId( $sourceCacheRevisionId );
            } elseif ( $sourceCacheRevisionId !== $thisCacheRevisionId ) {
                // May throw an exception here in the future
                wfDeprecated(
                    __METHOD__ . ": conflicting revision IDs " .
                    "$thisCacheRevisionId and $sourceCacheRevisionId"
                );
            }
        }
 
        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->mTimeProfile = $this->useEachTotalValue(
            $this->mTimeProfile,
            $source->mTimeProfile
        );
 
        $this->mFlags = self::mergeMap( $this->mFlags, $source->mFlags );
        $this->mParseUsedOptions = self::mergeMap( $this->mParseUsedOptions, $source->mParseUsedOptions );
 
        // TODO: maintain per-slot limit reports!
        if ( !$this->mLimitReportData ) {
            $this->mLimitReportData = $source->mLimitReportData;
        }
        if ( !$this->mLimitReportJSData ) {
            $this->mLimitReportJSData = $source->mLimitReportJSData;
        }
    }
 
    public function mergeHtmlMetaDataFrom( ParserOutput $source ): void {
        // HTML and HTTP
        $this->mHeadItems = self::mergeMixedList( $this->mHeadItems, $source->getHeadItems() );
        $this->addModules( $source->getModules() );
        $this->addModuleStyles( $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 concatenated.
                // There should eventually be a deprecation warning here.
                foreach ( $sourceTocData->getSections() as $s ) {
                    $tocData->addSection( $s );
                }
            }
        } elseif ( $sourceTocData !== null ) {
            $this->setTOCData( $sourceTocData );
        }
 
        // 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->getCategoryMap() );
        $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 );
            }
        }
 
        // Uniform handling of string sets: they are unioned.
        // (This includes modules, style modes, and CSP src.)
        foreach ( ParserOutputStringSets::cases() as $name ) {
            $metadata->appendOutputStrings(
                $name, $this->getOutputStrings( $name )
            );
        }
 
        foreach ( $this->mCategories as $cat => $key ) {
            // Numeric category strings are going to come out of the
            // `mCategories` array as ints; cast back to string.
            // Also convert back to a LinkTarget!
            $lt = TitleValue::tryNew( NS_CATEGORY, (string)$cat );
            $metadata->addCategory( $lt, $key );
        }
 
        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 ) {
            $values[$k] = min( $a[$k] ?? INF, $b[$k] ?? INF );
        }
 
        return $values;
    }
 
    private static function useEachTotalValue( array $a, array $b ): array {
        $values = [];
        $keys = array_merge( array_keys( $a ), array_keys( $b ) );
 
        foreach ( $keys as $k ) {
            $values[$k] = ( $a[$k] ?? 0 ) + ( $b[$k] ?? 0 );
        }
 
        return $values;
    }
 
    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->mRawText,
            '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' => array_keys( $this->mModuleSet ),
            'ModuleStyles' => array_keys( $this->mModuleStyleSet ),
            'JsConfigVars' => $this->mJsConfigVars,
            'Warnings' => $this->mWarnings,
            'Sections' => $this->getSections(),
            'Properties' => self::detectAndEncodeBinary( $this->mProperties ),
            'TOCHTML' => '', // T363107: this is temporary
            '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,
            'TimeProfile' => $this->mTimeProfile,
            'ParseStartTime' => $this->mParseStartTime, // useless
            '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->mRawText = $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->mModuleSet = array_fill_keys( $jsonData['Modules'], true );
        $this->mModuleStyleSet = array_fill_keys( $jsonData['ModuleStyles'], true );
        $this->mJsConfigVars = $jsonData['JsConfigVars'];
        $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->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']; // useless!
        $this->mTimeProfile = $jsonData['TimeProfile'] ?? [];
        $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() {
        $oldAliases = [
            // This was the pre-namespace name of the class, which is still
            // used in pre-1.42 serialized objects.
            'ParserOutput',
        ];
        // Backwards compatibility, pre 1.36
        $priorAccessedOptions = $this->getGhostFieldValue( 'mAccessedOptions', ...$oldAliases );
        if ( $priorAccessedOptions ) {
            $this->mParseUsedOptions = $priorAccessedOptions;
        }
        // Backwards compatibility, pre 1.39
        $priorIndexPolicy = $this->getGhostFieldValue( 'mIndexPolicy', ...$oldAliases );
        if ( $priorIndexPolicy ) {
            $this->setIndexPolicy( $priorIndexPolicy );
        }
        // Backwards compatibility, pre 1.40
        $mSections = $this->getGhostFieldValue( 'mSections', ...$oldAliases );
        if ( $mSections !== null && $mSections !== [] ) {
            $this->setSections( $mSections );
        }
        // Backwards compatibility, pre 1.42
        $mModules = $this->getGhostFieldValue( 'mModules', ...$oldAliases );
        if ( $mModules !== null && $mModules !== [] ) {
            $this->addModules( $mModules );
        }
        // Backwards compatibility, pre 1.42
        $mModuleStyles = $this->getGhostFieldValue( 'mModuleStyles', ...$oldAliases );
        if ( $mModuleStyles !== null && $mModuleStyles !== [] ) {
            $this->addModuleStyles( $mModuleStyles );
        }
        // Backwards compatibility, pre 1.42
        $mText = $this->getGhostFieldValue( 'mText', ...$oldAliases );
        if ( $mText !== null ) {
            $this->setRawText( $mText );
        }
        // Backward compatibility with private fields, pre 1.42
        $oldPrivateFields = [
            'mRawText',
            'mLanguageLinks',
            'mCategories',
            'mIndicators',
            'mTitleText',
            'mLinks',
            'mLinksSpecial',
            'mTemplates',
            'mTemplateIds',
            'mImages',
            'mFileSearchOptions',
            'mExternalLinks',
            'mInterwikiLinks',
            'mNewSection',
            'mHideNewSection',
            'mNoGallery',
            'mHeadItems',
            'mModuleSet',
            'mModuleStyleSet',
            'mJsConfigVars',
            'mWarnings',
            'mWarningMsgs',
            'mTOCData',
            'mProperties',
            'mTimestamp',
            'mEnableOOUI',
            'mIndexSet',
            'mNoIndexSet',
            'mExtensionData',
            'mLimitReportData',
            'mLimitReportJSData',
            'mCacheMessage',
            'mParseStartTime',
            'mTimeProfile',
            'mPreventClickjacking',
            'mExtraScriptSrcs',
            'mExtraDefaultSrcs',
            'mExtraStyleSrcs',
            'mFlags',
            'mSpeculativeRevId',
            'speculativePageIdUsed',
            'revisionTimestampUsed',
            'revisionUsedSha1Base36',
            'mWrapperDivClasses',
            'mMaxAdaptiveExpiry',
        ];
        foreach ( $oldPrivateFields as $f ) {
            $this->restoreAliasedGhostField( $f, ...$oldAliases );
        }
    }
 
    public function __clone() {
        // It seems that very little of this object needs to be explicitly deep-cloned
        // while keeping copies reasonably separated.
        // Most of the non-scalar properties of this object are either
        // - (potentially multi-nested) arrays of scalars (which get deep-cloned), or
        // - arrays that may contain arbitrary elements (which don't necessarily get
        //   deep-cloned), but for which no particular care elsewhere is given to
        //   copying their references around (e.g. mJsConfigVars).
        // Hence, we are not going out of our way to ensure that the references to innermost
        // objects that may appear in a ParserOutput are unique. If that becomes the
        // expectation at any point, this method will require updating as well.
        // The exception is TOCData (which is an object), which we clone explicitly.
        if ( $this->mTOCData ) {
            $this->mTOCData = clone $this->mTOCData;
        }
    }
 
    public function getContentHolderText(): string {
        return $this->getRawText();
    }
 
    public function setContentHolderText( string $s ): void {
        $this->setRawText( $s );
    }
 
    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;
        }
    }
}
 
class_alias( ParserOutput::class, 'ParserOutput' );