ParserOutput.php

Go to the documentation of this file.

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Parser;
 
use DateTimeImmutable;
use DateTimeZone;
use InvalidArgumentException;
use LogicException;
use MediaWiki\DAO\WikiAwareEntity;
use MediaWiki\Edit\ParsoidRenderID;
use MediaWiki\Json\JsonDeserializable;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Output\OutputPage;
use MediaWiki\Page\PageReference;
use MediaWiki\Title\TitleValue;
use MediaWiki\Utils\MWTimestamp;
use UnhandledMatchError;
use Wikimedia\Assert\Assert;
use Wikimedia\Bcp47Code\Bcp47Code;
use Wikimedia\Bcp47Code\Bcp47CodeValue;
use Wikimedia\HtmlArmor\HtmlArmor;
use Wikimedia\JsonCodec\Hint;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\Message\MessageValue;
use Wikimedia\Parsoid\Core\ContentMetadataCollector;
use Wikimedia\Parsoid\Core\ContentMetadataCollectorCompat;
use Wikimedia\Parsoid\Core\HtmlPageBundle;
use Wikimedia\Parsoid\Core\LinkTarget as ParsoidLinkTarget;
use Wikimedia\Parsoid\Core\MergeStrategy;
use Wikimedia\Parsoid\Core\TOCData;
use Wikimedia\Parsoid\DOM\DocumentFragment;
 
class ParserOutput extends CacheTime implements ContentMetadataCollector {
    // 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 PARSOID_PAGE_BUNDLE_KEY = 'parsoid-page-bundle';
 
    public const MW_MERGE_STRATEGY_KEY = '_mw-strategy';
 
    public const MW_MERGE_STRATEGY_UNION = MergeStrategy::UNION;
 
    private ContentHolder $contentHolder;
 
    private array $mLanguageLinkMap = [];
 
    private array $mCategories = [];
 
    private array $mIndicatorIds = [];
 
    private string $mTitleText;
 
    private ?array $mDisplayTitleParts = null;
 
    private array $mLinks = [];
 
    private array $mLinksSpecial = [];
 
    private array $mTemplates = [];
 
    private array $mTemplateIds = [];
 
    private array $mImages = [];
 
    private array $mFileSearchOptions = [];
 
    private array $mExternalLinks = [];
 
    private array $mInterwikiLinks = [];
 
    private array $existenceLinks = [];
 
    private array $mHeadItems = [];
 
    private array $mModuleSet = [];
 
    private array $mModuleStyleSet = [];
 
    private array $mJsConfigVars = [];
 
    private array $mWarnings = [];
 
    private array $mWarningMsgs = [];
 
    private ?TOCData $mTOCData = null;
 
    private array $mProperties = [];
 
    private ?string $mTimestamp = null;
 
    private array $mExtensionData = [];
 
    private array $mLimitReportData = [];
 
    private array $mLimitReportJSData = [];
 
    private string $mCacheMessage = '';
 
    private array $mParseStartTime = [];
 
    private array $mTimeProfile = [];
 
    private array $mExtraScriptSrcs = [];
 
    private array $mExtraDefaultSrcs = [];
 
    private array $mExtraStyleSrcs = [];
 
    private $mFlags = [];
 
    private const SPECULATIVE_FIELDS = [
        'speculativePageIdUsed',
        'mSpeculativeRevId',
        'revisionTimestampUsed',
    ];
 
    private ?int $mSpeculativeRevId = null;
    private ?int $speculativePageIdUsed = null;
    private ?string $revisionTimestampUsed = null;
 
    private ?string $revisionUsedSha1Base36 = null;
 
    private array $mWrapperDivClasses = [];
 
    private ?int $mMaxAdaptiveExpiry = null;
 
    // 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( ?string $text = null, array $languageLinks = [], array $categoryLinks = [],
        $unused = false, string $titletext = ''
    ) {
        if ( $text === null ) {
            $this->contentHolder = ContentHolder::createEmpty();
        } else {
            $this->contentHolder = ContentHolder::createFromLegacyString( $text );
        }
        $this->mCategories = $categoryLinks;
        $this->mTitleText = $titletext;
        foreach ( $languageLinks as $ll ) {
            $this->addLanguageLink( $ll );
        }
        // If the content handler does not specify an alternative (by
        // calling ::resetParseStartTime() at a later point) then use
        // the creation of the ParserOutput as the "start of parse" time.
        $this->resetParseStartTime();
    }
 
    public function getContentHolder(): ContentHolder {
        return $this->contentHolder;
    }
 
    public function setContentHolder( ContentHolder $contentHolder ) {
        $this->contentHolder = $contentHolder;
    }
 
    public function hasText(): bool {
        return $this->contentHolder->has( ContentHolder::BODY_FRAGMENT );
    }
 
    /*
     * @unstable This method is transitional and will be replaced by a method
     * in another class, maybe ContentRenderer.  It allows us to break our
     * porting work into two steps; in the first we bring ParserOptions to
     * to each callsite to ensure it is made available to the
     * postprocessing pipeline.  In the second we move this functionality
     * into the Content hierarchy and out of ParserOutput, which should become
     * a pure value object.
     *
     * @param ParserOptions $popts
     * @param array $options (since 1.31) Transformations to apply to the HTML
     *   - allowClone: (bool) Whether to clone the ParserOutput before
     *     applying transformations. Default is true.
     *  - allowTOC: (bool) Show the TOC, assuming there were enough headings
     *     to generate one and `__NOTOC__` wasn't used. Default is true,
     *     but might be statefully overridden.
     *  - injectTOC: (bool) Replace the TOC_PLACEHOLDER with TOC contents;
     *     otherwise the marker will be left in the article (and the skin
     *     will be responsible for replacing or removing it).  Default is
     *     true.
     *  - enableSectionEditLinks: (bool) Include section edit links, assuming
     *     section edit link tokens are present in the HTML. Default is true,
     *     but might be statefully overridden.
     *  - userLang: (Language) Language object used for localizing UX messages,
     *    for example the heading of the table of contents. If omitted, will
     *    use the language of the main request context.
     *  - skin: (Skin) Skin object used for transforming section edit links.
     *  - unwrap: (bool) Return text without a wrapper div. Default is false,
     *    meaning a wrapper div will be added if getWrapperDivClass() returns
     *    a non-empty string.
     *  - wrapperDivClass: (string) Wrap the output in a div and apply the given
     *    CSS class to that div. This overrides the output of getWrapperDivClass().
     *    Setting this to an empty string has the same effect as 'unwrap' => true.
     *  - deduplicateStyles: (bool) When true, which is the default, `<style>`
     *    tags with the `data-mw-deduplicate` attribute set are deduplicated by
     *    value of the attribute: all but the first will be replaced by `<link
     *    rel="mw-deduplicated-inline-style" href="mw-data:..."/>` tags, where
     *    the scheme-specific-part of the href is the (percent-encoded) value
     *    of the `data-mw-deduplicate` attribute.
     *  - absoluteURLs: (bool) use absolute URLs in all links. Default: false
     *  - includeDebugInfo: (bool) render PP limit report in HTML. Default: false
     *  It is planned to eventually deprecate this $options array and to be able to
     *  pass its content in the $popts ParserOptions.
     * @return ParserOutput
     */
    public function runOutputPipeline( ParserOptions $popts, array $options = [] ): ParserOutput {
        $pipeline = MediaWikiServices::getInstance()->getDefaultOutputPipeline();
        $options += [
            'allowClone' => true,
            'allowTOC' => true,
            'injectTOC' => true,
            'enableSectionEditLinks' => true,
            'userLang' => null,
            'skin' => null,
            'unwrap' => false,
            'wrapperDivClass' => $this->getWrapperDivClass(),
            'deduplicateStyles' => true,
            'absoluteURLs' => false,
            'includeDebugInfo' => false,
        ];
        return $pipeline->run( $this, $popts, $options );
    }
 
    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;
    }
 
    private function getLanguageLinksInternal(): array {
        $result = [];
        foreach ( $this->mLanguageLinkMap as $lang => $title ) {
            $result[] = "$lang:$title";
        }
        return $result;
    }
 
    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 {
        $result = [];
        foreach ( $this->mIndicatorIds as $id ) {
            $fragmentName = "indicator:{$id}";
            $contents = $this->contentHolder->getAsHtmlString( $fragmentName );
            Assert::invariant( $contents !== null, "fragments should exist" );
            $result[$id] = $contents;
        }
        return $result;
    }
 
    public function getTitleText(): string {
        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 getLinkList( string|ParserOutputLinkTypes $linkType, ?int $onlyNamespace = null ): array {
        if ( is_string( $linkType ) ) {
            $linkType = ParserOutputLinkTypes::from( $linkType );
        }
        # Note that fragments are dropped for everything except language links
        $result = [];
        switch ( $linkType ) {
            case ParserOutputLinkTypes::CATEGORY:
                if ( $onlyNamespace !== null && $onlyNamespace !== NS_CATEGORY ) {
                    return [];
                }
                foreach ( $this->mCategories as $dbkey => $sort ) {
                    $result[] = [
                        'link' => new TitleValue( NS_CATEGORY, (string)$dbkey ),
                        'sort' => $sort,
                    ];
                }
                break;
 
            case ParserOutputLinkTypes::EXISTENCE:
                $links = $onlyNamespace === null ? $this->existenceLinks : [
                    $onlyNamespace => $this->existenceLinks[$onlyNamespace] ?? [],
                ];
                foreach ( $links as $ns => $titles ) {
                    foreach ( $titles as $dbkey => $unused ) {
                        $result[] = [
                            'link' => new TitleValue( $ns, (string)$dbkey )
                        ];
                    }
                }
                break;
 
            case ParserOutputLinkTypes::INTERWIKI:
                // By convention interwiki links belong to NS_MAIN
                if ( $onlyNamespace !== null && $onlyNamespace !== NS_MAIN ) {
                    return [];
                }
                foreach ( $this->mInterwikiLinks as $prefix => $arr ) {
                    foreach ( $arr as $dbkey => $ignore ) {
                        $result[] = [
                            'link' => new TitleValue( NS_MAIN, (string)$dbkey, '', (string)$prefix ),
                        ];
                    }
                }
                break;
 
            case ParserOutputLinkTypes::LANGUAGE:
                // By convention language links belong to NS_MAIN
                if ( $onlyNamespace !== null && $onlyNamespace !== NS_MAIN ) {
                    return [];
                }
                foreach ( $this->mLanguageLinkMap as $lang => $title ) {
                    # language links can have fragments!
                    [ $title, $frag ] = array_pad( explode( '#', $title, 2 ), 2, '' );
                    $result[]  = [
                        'link' => new TitleValue( NS_MAIN, $title, $frag, (string)$lang ),
                    ];
                }
                break;
 
            case ParserOutputLinkTypes::LOCAL:
                $links = $onlyNamespace === null ? $this->mLinks : [
                    $onlyNamespace => $this->mLinks[$onlyNamespace] ?? [],
                ];
                foreach ( $links as $ns => $arr ) {
                    foreach ( $arr as $dbkey => $id ) {
                        $result[] = [
                            'link' => new TitleValue( $ns, (string)$dbkey ),
                            'pageid' => $id,
                        ];
                    }
                }
                break;
 
            case ParserOutputLinkTypes::MEDIA:
                if ( $onlyNamespace !== null && $onlyNamespace !== NS_FILE ) {
                    return [];
                }
                foreach ( $this->mImages as $dbkey => $ignore ) {
                    $extra = $this->mFileSearchOptions[$dbkey] ?? [];
                    $extra['link'] = new TitleValue( NS_FILE, (string)$dbkey );
                    $result[] = $extra;
                }
                break;
 
            case ParserOutputLinkTypes::SPECIAL:
                if ( $onlyNamespace !== null && $onlyNamespace !== NS_SPECIAL ) {
                    return [];
                }
                foreach ( $this->mLinksSpecial as $dbkey => $ignore ) {
                    $result[] = [
                        'link' => new TitleValue( NS_SPECIAL, (string)$dbkey ),
                    ];
                }
                break;
 
            case ParserOutputLinkTypes::TEMPLATE:
                $links = $onlyNamespace === null ? $this->mTemplates : [
                    $onlyNamespace => $this->mTemplates[$onlyNamespace] ?? [],
                ];
                foreach ( $links as $ns => $arr ) {
                    foreach ( $arr as $dbkey => $pageid ) {
                        $result[] = [
                            'link' => new TitleValue( $ns, (string)$dbkey ),
                            'pageid' => $pageid,
                            // default to invalid/broken revision if this is not present
                            'revid' => $this->mTemplateIds[$ns][$dbkey] ?? 0,
                        ];
                    }
                }
                break;
 
            default:
                throw new UnhandledMatchError( "Unknown link type " . $linkType->value );
        }
        return $result;
    }
 
    public function appendLinkList( string|ParserOutputLinkTypes $linkType, array $linkItem ): void {
        if ( is_string( $linkType ) ) {
            $linkType = ParserOutputLinkTypes::from( $linkType );
        }
        $link = $linkItem['link'];
        match ( $linkType ) {
            ParserOutputLinkTypes::CATEGORY =>
                $this->addCategory( $link, $linkItem['sort'] ?? '' ),
            ParserOutputLinkTypes::EXISTENCE =>
                $this->addExistenceDependency( $link ),
            ParserOutputLinkTypes::INTERWIKI =>
                $this->addInterwikiLink( $link ),
            ParserOutputLinkTypes::LANGUAGE =>
                $this->addLanguageLink( $link ),
            ParserOutputLinkTypes::LOCAL =>
                $this->addLink( $link, $linkItem['pageid'] ?? null ),
            ParserOutputLinkTypes::MEDIA =>
                $this->addImage( $link, $linkItem['time'] ?? null, $linkItem['sha1'] ?? null ),
            ParserOutputLinkTypes::SPECIAL =>
                $this->addLink( $link ),
            ParserOutputLinkTypes::TEMPLATE =>
                // @phan-suppress-next-line PhanTypePossiblyInvalidDimOffset
                $this->addTemplate( $link, $linkItem['pageid'], $linkItem['revid'] ),
        };
    }
 
    public function hasLinks(): bool {
        foreach ( $this->mLinks as $ns => $arr ) {
            foreach ( $arr as $dbkey => $id ) {
                return true;
            }
        }
        return false;
    }
 
    public function hasImages(): bool {
        return $this->mImages !== [];
    }
 
    public function getExternalLinks(): array {
        return $this->mExternalLinks;
    }
 
    public function setNoGallery( $value ): void {
        $this->setOutputFlag( ParserOutputFlags::NO_GALLERY, (bool)$value );
    }
 
    public function getNoGallery() {
        return $this->getOutputFlag( ParserOutputFlags::NO_GALLERY );
    }
 
    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 ) {
                if ( ( $value[self::MW_MERGE_STRATEGY_KEY] ?? null ) === MergeStrategy::SUM->value ) {
                    $value = $value['value'];
                    continue;
                }
                unset( $value[self::MW_MERGE_STRATEGY_KEY] );
            }
        }
        return $result;
    }
 
    public function getWarnings(): array {
        // T343048: Don't emit deprecation warnings here until the
        // compatibility fallback in ApiParse is removed.
        return array_keys( $this->mWarnings );
    }
 
    public function getWarningMsgs(): array {
        return array_values( $this->mWarningMsgs );
    }
 
    public function getIndexPolicy(): string {
        // 'noindex' wins if both are set. (T16899)
        if ( $this->getOutputFlag( ParserOutputFlags::NO_INDEX_POLICY ) ) {
            return 'noindex';
        } elseif ( $this->getOutputFlag( ParserOutputFlags::INDEX_POLICY ) ) {
            return 'index';
        }
        return '';
    }
 
    public function getRevisionTimestamp(): ?string {
        return $this->mTimestamp;
    }
 
    public function getLimitReportData() {
        return $this->mLimitReportData;
    }
 
    public function getLimitReportJSData() {
        return $this->mLimitReportJSData;
    }
 
    public function getEnableOOUI() {
        return $this->getOutputFlag( ParserOutputFlags::ENABLE_OOUI );
    }
 
    public function getExtraCSPDefaultSrcs() {
        return $this->mExtraDefaultSrcs;
    }
 
    public function getExtraCSPScriptSrcs() {
        return $this->mExtraScriptSrcs;
    }
 
    public function getExtraCSPStyleSrcs() {
        return $this->mExtraStyleSrcs;
    }
 
    public function clearLanguageLinks(): void {
        $this->mLanguageLinkMap = [];
    }
 
    public function setTitleText( string $t ) {
        $this->mDisplayTitleParts = null;
        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->setOutputFlag( ParserOutputFlags::NO_INDEX_POLICY );
        } elseif ( $policy === 'index' ) {
            $this->setOutputFlag( ParserOutputFlags::INDEX_POLICY );
        }
        return $old;
    }
 
    public function setRevisionTimestamp( ?string $timestamp ): void {
        $this->mTimestamp = $timestamp;
    }
 
    public function addCategory( $c, $sort = '' ): void {
        if ( $c instanceof ParsoidLinkTarget ) {
            $c = $c->getDBkey();
        }
        if ( ( $this->mCategories[$c] ?? $sort ) !== $sort ) {
            // Overwriting a category sort key prevents selective update
            // [[mw:Parsoid/Internals/Handling_resource_limits]]
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        }
        $this->mCategories[$c] = $sort;
    }
 
    public function setCategories( array $c ): void {
        if ( ( $this->mCategories ?: $c ) !== $c ) {
            // Overwriting categories prevents selective update
            // [[mw:Parsoid/Internals/Handling_resource_limits]]
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        }
        $this->mCategories = $c;
    }
 
    public function setIndicator( $id, $content ): void {
        Assert::parameterType( 'string', $content, 'content' );
        $fragmentName = "indicator:{$id}";
        if ( $this->contentHolder->has( $fragmentName ) ) {
            // Overwriting an indicator prevents selective update
            // [[mw:Parsoid/Internals/Handling_resource_limits]]
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        } else {
            $this->mIndicatorIds[] = $id;
        }
        $this->getContentHolder()->setAsHtmlString( $fragmentName, $content );
    }
 
    public function setIndicatorDom( string $id, DocumentFragment $content ): void {
        $fragmentName = "indicator:{$id}";
        if ( $this->contentHolder->has( $fragmentName ) ) {
            // Overwriting an indicator prevents selective update
            // [[mw:Parsoid/Internals/Handling_resource_limits]]
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        } else {
            $this->mIndicatorIds[] = $id;
        }
        $this->getContentHolder()->setAsDom( $fragmentName, $content );
    }
 
    public function setEnableOOUI( bool $enable = false ): void {
        $this->setOutputFlag( ParserOutputFlags::ENABLE_OOUI, $enable );
    }
 
    public function addLanguageLink( $t ): void {
        # Note that fragments are preserved
        if ( $t instanceof ParsoidLinkTarget ) {
            // Language links are unusual in using 'text' rather than 'db key'
            // Note that fragments are preserved.
            $lang = $t->getInterwiki();
            $title = $t->getText();
            if ( $t->hasFragment() ) {
                $title .= '#' . $t->getFragment();
            }
        } else {
            [ $lang, $title ] = array_pad( explode( ':', $t, 2 ), -2, '' );
        }
        if ( $lang === '' ) {
            throw new InvalidArgumentException( __METHOD__ . ' without prefix' );
        }
        if ( ( $this->mLanguageLinkMap[$lang] ?? $title ) !== $title ) {
            // Overwriting a language link prevents selective update
            // [[mw:Parsoid/Internals/Handling_resource_limits]]
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        }
        $this->mLanguageLinkMap[$lang] ??= $title;
    }
 
    public function addWarningMsgVal( MessageSpecifier $mv, ?string $key = null ) {
        $mv = MessageValue::newFromSpecifier( $mv );
        $key ??= $mv->getKey();
        if ( array_key_exists( $key, $this->mWarningMsgs ) ) {
            // Overwriting a warning message prevents selective update
            // [[mw:Parsoid/Internals/Handling_resource_limits]]
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        }
        $this->mWarningMsgs[$key] = $mv;
        // Ensure callers aren't passing nonserializable arguments: T343048.
        $jsonCodec = MediaWikiServices::getInstance()->getJsonCodec();
        $path = $jsonCodec->detectNonSerializableData( $mv, true );
        if ( $path !== null ) {
            throw new InvalidArgumentException( __METHOD__ . ": nonserializable" );
        }
        // For backward compatibility with callers of ::getWarnings()
        // and rollback compatibility for ParserCache; don't remove
        // until we no longer need rollback compatibility with MW 1.43.
        $s = Message::newFromSpecifier( $mv )
            // some callers set the title here?
            ->inContentLanguage() // because this ends up in cache
            ->text();
        $this->mWarnings[$s] = 1;
    }
 
    public function addWarningMsg( string $msg, ...$args ): void {
        // T227447: Once MessageSpecifier is moved to a library, Parsoid would
        // be able to use ::addWarningMsgVal() directly and this method
        // could be deprecated and removed.
        $this->addWarningMsgVal( MessageValue::new( $msg, $args ) );
    }
 
    public function setNewSection( $value ): void {
        $this->setOutputFlag( ParserOutputFlags::NEW_SECTION, (bool)$value );
    }
 
    public function setHideNewSection( bool $value ): void {
        $this->setOutputFlag( ParserOutputFlags::HIDE_NEW_SECTION, $value );
    }
 
    public function getHideNewSection(): bool {
        return $this->getOutputFlag( ParserOutputFlags::HIDE_NEW_SECTION );
    }
 
    public function getNewSection(): bool {
        return $this->getOutputFlag( ParserOutputFlags::NEW_SECTION );
    }
 
    public static function isLinkInternal( $internal, $url ): bool {
        return (bool)preg_match( '/^' .
            # If server is proto relative, check also for http/https links
            ( str_starts_with( $internal, '//' ) ? '(?: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 );
        $ignoreDomains = $config->get( MainConfigNames::ExternalLinksIgnoreDomains );
 
        # 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 (
            MediaWikiServices::getInstance()->getUrlUtils()->matchesDomainList( $url, $ignoreDomains )
        ) {
            $registerExternalLink = false;
        }
        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.
            throw new InvalidArgumentException( __METHOD__ . " with interwiki link" );
        }
        $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 addExistenceDependency( ParsoidLinkTarget $link ) {
        $ns = $link->getNamespace();
        $dbk = $link->getDBkey();
        // Ignore some kinds of links, as in addLink()
        if ( $link->isExternal() || $ns === NS_SPECIAL || $dbk === '' ) {
            return;
        }
        if ( $ns === NS_MEDIA ) {
            $ns = NS_FILE;
        }
        $this->existenceLinks[$ns][$dbk] = true;
    }
 
    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 {
        wfDeprecated( __METHOD__, '1.38' );
        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,
        $value,
        MergeStrategy|string $strategy = MergeStrategy::UNION
    ): void {
        if ( is_string( $strategy ) ) {
            $strategy = MergeStrategy::from( $strategy );
        }
        $this->mJsConfigVars = self::mergeMapStrategy(
            $this->mJsConfigVars,
            [ $key => self::makeMapStrategy( $value, $strategy ) ]
        );
    }
 
    public function addOutputPageMetadata( OutputPage $out ): void {
        // This should eventually use the same merge mechanism used
        // internally to merge ParserOutputs together.
        // (ie: $this->mergeHtmlMetaDataFrom( $out->getMetadata() )
        // once preventClickjacking, moduleStyles, modules, jsconfigvars,
        // and head items are moved to OutputPage::$metadata)
 
        // 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->setOutputFlag(
            ParserOutputFlags::PREVENT_CLICKJACKING,
            $this->getOutputFlag( ParserOutputFlags::PREVENT_CLICKJACKING ) ||
            $out->getOutputFlag( ParserOutputFlags::PREVENT_CLICKJACKING )
        );
 
        $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( string $text ): void {
        $this->setTitleText( $text );
        $this->setPageProperty( 'displaytitle', $text );
    }
 
    public function setDisplayTitleParts(
        string|HtmlArmor $nsText,
        string|HtmlArmor $nsSeparator,
        string|HtmlArmor $mainText,
        string|HtmlArmor|null $combinedText = null
    ): void {
        $parts = [
            HtmlArmor::getHtml( $nsText ) ?? '',
            HtmlArmor::getHtml( $nsSeparator ) ?? '',
            HtmlArmor::getHtml( $mainText ) ?? '',
        ];
        if ( $combinedText !== null ) {
            $combinedText = HtmlArmor::getHtml( $combinedText );
        }
        $combinedText ??= $parts[0] ? implode( '', $parts ) : $parts[2];
        $this->mDisplayTitleParts = $parts;
        $this->mTitleText = $combinedText;
    }
 
    public function setDisplayTitlePartsHtml(
        string $nsTextHtml,
        string $nsSeparatorHtml,
        string $mainTextHtml,
        ?string $combinedTextHtml = null
    ): void {
        $this->setDisplayTitleParts(
            new HtmlArmor( $nsTextHtml ),
            new HtmlArmor( $nsSeparatorHtml ),
            new HtmlArmor( $mainTextHtml ),
            // HtmlArmor can wrap `null`
            new HtmlArmor( $combinedTextHtml ),
        );
    }
 
    public function getDisplayTitleParts(): ?array {
        if ( $this->mDisplayTitleParts === null ) {
            return null;
        }
        return [
            new HtmlArmor( $this->mDisplayTitleParts[0] ),
            new HtmlArmor( $this->mDisplayTitleParts[1] ),
            new HtmlArmor( $this->mDisplayTitleParts[2] ),
        ];
    }
 
    public function getDisplayTitle(): string|false {
        $t = $this->getTitleText();
        if ( $t === '' ) {
            return false;
        }
        return $t;
    }
 
    public function getTitle(): ?ParsoidLinkTarget {
        $ns = $this->getExtensionData( 'core:title-ns' );
        $dbkey = $this->getExtensionData( 'core:title-dbkey' );
        if ( $dbkey !== null ) {
            return new TitleValue( $ns ?? NS_MAIN, $dbkey );
        }
        // Backward-compatibility with cache contents generated by MW < 1.46
        $dbkey = $this->getExtensionData( 'parsoid:title-dbkey' );
        if ( $dbkey !== null ) {
            // This is a prefixed DB key w/ localized namespace
            $titleFactory = MediaWikiServices::getInstance()->getTitleFactory();
            return $titleFactory->newFromDBkey( $dbkey );
        }
        return null;
    }
 
    public function setTitle( ParsoidLinkTarget|PageReference $title ): void {
        if ( $title instanceof PageReference ) {
            $title->assertWiki( WikiAwareEntity::LOCAL );
        } else {
            Assert::invariant( !$title->isExternal(), "title should be local" );
        }
        $this->setExtensionData( 'core:title-ns', $title->getNamespace() );
        $this->setExtensionData( 'core:title-dbkey', $title->getDBkey() );
    }
 
    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 {
        // Before MW 1.46 this did not include NO_GALLERY, ENABLE_OOUI,
        // INDEX_POLICY, NO_INDEX_POLICY, NEW_SECTION, HIDE_NEW_SECTION,
        // and PREVENT_CLICKJACKING, but this method is only used internally.
        // See WikitextContentHandler::preSaveTransform() where this method
        // is used to transfer PST flags to the WikitextContent object, and
        // OutputPage::addParserOutputMetadata() where this method is used
        // to transfer ParserOutput flags to OutputPage::$mOutputFlags
        return array_keys( $this->mFlags );
    }
 
    public function setPageProperty( string $name, string $value ): void {
        $this->setUnsortedPageProperty( $name, $value );
    }
 
    public function setNumericPageProperty( string $propName, $numericValue ): void {
        if ( !is_numeric( $numericValue ) ) {
            throw new InvalidArgumentException( __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 {
        return $this->mProperties;
    }
 
    public function setOutputFlag( ParserOutputFlags|string $name, bool $val = true ): void {
        if ( is_string( $name ) ) {
            $flag = ParserOutputFlags::tryFrom( $name );
            if ( $flag === null ) {
                wfDeprecated(
                    __METHOD__ . ' with non-standard flag', '1.45'
                );
            }
        } else {
            $flag = $name;
            $name = $flag->value;
        }
        if ( $val ) {
            $this->mFlags[$name] = true;
        } else {
            unset( $this->mFlags[$name] );
        }
    }
 
    public function getOutputFlag( ParserOutputFlags|string $flag ): bool {
        // In the future we will return false if $flag doesn't correspond to a
        // valid ParserOutputFlag; see deprecation notice in ::setOutputFlag().
        $name = $flag instanceof ParserOutputFlags ? $flag->value : $flag;
        return $this->mFlags[$name] ?? false;
    }
 
    public function appendOutputStrings( string|ParserOutputStringSets $name, array $value ): void {
        if ( is_string( $name ) ) {
            $name = ParserOutputStringSets::from( $name );
        }
        match ( $name ) {
            ParserOutputStringSets::MODULE =>
                $this->addModules( $value ),
            ParserOutputStringSets::MODULE_STYLE =>
                $this->addModuleStyles( $value ),
            ParserOutputStringSets::EXTRA_CSP_DEFAULT_SRC =>
                array_walk( $value, fn ( $v, $i ) =>
                    $this->addExtraCSPDefaultSrc( $v )
                ),
            ParserOutputStringSets::EXTRA_CSP_SCRIPT_SRC =>
                array_walk( $value, fn ( $v, $i ) =>
                    $this->addExtraCSPScriptSrc( $v )
                ),
            ParserOutputStringSets::EXTRA_CSP_STYLE_SRC =>
                array_walk( $value, fn ( $v, $i ) =>
                    $this->addExtraCSPStyleSrc( $v )
                ),
        };
    }
 
    public function getOutputStrings( string|ParserOutputStringSets $name ): array {
        if ( is_string( $name ) ) {
            $name = ParserOutputStringSets::from( $name );
        }
        return match ( $name ) {
            ParserOutputStringSets::MODULE =>
                $this->getModules(),
            ParserOutputStringSets::MODULE_STYLE =>
                $this->getModuleStyles(),
            ParserOutputStringSets::EXTRA_CSP_DEFAULT_SRC =>
                $this->getExtraCSPDefaultSrcs(),
            ParserOutputStringSets::EXTRA_CSP_SCRIPT_SRC =>
                $this->getExtraCSPScriptSrcs(),
            ParserOutputStringSets::EXTRA_CSP_STYLE_SRC =>
                $this->getExtraCSPStyleSrcs(),
        };
    }
 
    public function setExtensionData( $key, $value ): void {
        if (
            array_key_exists( $key, $this->mExtensionData ) &&
            $this->mExtensionData[$key] !== $value
        ) {
            // This is discouraged, as it prevents selective update,
            // and was deprecated in 1.38.
            $this->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
        }
        if ( $value === null ) {
            unset( $this->mExtensionData[$key] );
        } else {
            $this->mExtensionData[$key] = $value;
        }
    }
 
    public function appendExtensionData(
        string $key,
        $value,
        MergeStrategy|string $strategy = MergeStrategy::UNION
    ): void {
        if ( is_string( $strategy ) ) {
            $strategy = MergeStrategy::from( $strategy );
        }
        $this->mExtensionData = self::mergeMapStrategy(
            $this->mExtensionData,
            [ $key => self::makeMapStrategy( $value, $strategy ) ]
        );
    }
 
    public function getExtensionData( $key ) {
        $value = $this->mExtensionData[$key] ?? null;
        if ( is_array( $value ) ) {
            if ( ( $value[self::MW_MERGE_STRATEGY_KEY] ?? null ) === MergeStrategy::SUM->value ) {
                return $value['value'];
            }
            // Don't expose our internal merge strategy key.
            unset( $value[self::MW_MERGE_STRATEGY_KEY] );
        }
        return $value;
    }
 
    private static function getTimes( ?string $clock = null ): array {
        $ret = [];
        if ( !$clock || $clock === 'wall' ) {
            $ret['wall'] = hrtime( true ) / 10 ** 9;
        }
        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 clearParseStartTime(): void {
        $this->mParseStartTime = [];
    }
 
    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 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 {
        if ( $this->getOutputFlag( ParserOutputFlags::HAS_ASYNC_CONTENT ) ) {
            // If this page has async content, then we should re-run
            // RefreshLinksJob whenever we regenerate the page.
            return true;
        }
        $parserCacheExpireTime = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ParserCacheExpireTime );
 
        // Deliberately not using ::getCacheExpiry() here, which can get
        // quantized in MiserMode.
        return ( $this->mCacheExpiry ?? $parserCacheExpireTime ) < $parserCacheExpireTime;
    }
 
    public function getCacheExpiry(): int {
        $expiry = parent::getCacheExpiry();
        if ( $expiry <= 0 ) {
            // Uncacheable.
            // Note that this function should return 0 if and only if
            // ::isCacheable() returns false.
            return 0;
        }
        // Raise the minimum to ~24 hrs for content pages on large
        // wiki farms when MiserMode is enabled. (T416616)
        // Implemented as expiring around the next midnight.  We take
        // both UTC midnight and midnight in a wiki-configured
        // timezone into account.  On English-language and
        // multilingual wikis we get 24 hours (given UTC is the
        // timezone), and other wikis split as 1h/23h or down to
        // 12h/12h.
        $services = MediaWikiServices::getInstance();
        $config = $services->getMainConfig();
        if (
            $config->get( MainConfigNames::MiserMode ) &&
            $services->getNamespaceInfo()->isContent(
                $this->getTitle()?->getNamespace() ?? NS_MAIN
            )
        ) {
            $date = DateTimeImmutable::createFromInterface(
                MWTimestamp::fromMW( $this->getCacheTime() )->timestamp
            );
            // T419439: the deadline, skew, and stagger here should probably
            // be configurable.
            $utcMidnight = $date
                ->modify( 'next day midnight' )
                ->getTimestamp();
            $localMidnight = $date
                ->setTimeZone( new DateTimeZone(
                    $config->get( MainConfigNames::Localtimezone )
                ) )
                ->modify( 'next day midnight' )
                ->getTimestamp();
            // Whichever comes first: UTC midnight, local midnight, or expiry
            $timeToNextMidnight = min( $utcMidnight, $localMidnight ) - $date->getTimestamp();
            // "Randomly" stagger expiry across a window to avoid cache
            // stampedes.
            $stagger = 60 * 60; // 1 hour
            if ( $timeToNextMidnight < ( $stagger / 2 ) ) {
                // Account for clock skew and unlucky parses just before
                // midnight by ensuring our "midnight" deadline is at least
                // half-a-stagger away (but halve the stagger in that case
                // so we never spread the expiry past midnight+stagger).
                $stagger /= 2;
                $timeToNextMidnight = $stagger;
            }
            // Stagger is a function of parse time, which should be random-ish.
            $timeToNextMidnight += ( $date->getTimestamp() % $stagger );
            $expiry = max( $expiry, $timeToNextMidnight );
        }
 
        if ( $this->getOutputFlag( ParserOutputFlags::ASYNC_NOT_READY ) ) {
            $asyncExpireTime = $config->get(
                MainConfigNames::ParserCacheAsyncExpireTime
            );
            $expiry = max( 1, min( $expiry, $asyncExpireTime ) );
        }
        return $expiry;
    }
 
    public function setPreventClickjacking( bool $flag ): void {
        $this->setOutputFlag( ParserOutputFlags::PREVENT_CLICKJACKING, $flag );
    }
 
    public function getPreventClickjacking(): bool {
        return $this->getOutputFlag( ParserOutputFlags::PREVENT_CLICKJACKING );
    }
 
    public function updateRuntimeAdaptiveExpiry( int $ttl, ?string $source = null ): void {
        $this->mMaxAdaptiveExpiry ??= $ttl;
        $this->mMaxAdaptiveExpiry = min( $ttl, $this->mMaxAdaptiveExpiry );
        $this->updateCacheExpiry( $ttl, $source );
    }
 
    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 ( $this->mMaxAdaptiveExpiry === null ) {
            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 = intval( $slope * $runtime + $point );
            $adaptiveTTL = max( $adaptiveTTL, self::MIN_AR_TTL );
            $adaptiveTTL = min( $adaptiveTTL, $this->mMaxAdaptiveExpiry );
            $this->updateCacheExpiry( $adaptiveTTL, 'adaptive-ttl' );
        }
    }
 
    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->isMessage() ) {
            $this->addWrapperDivClass( $class );
        }
 
        // 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, 'preview' );
        }
 
        // Record whether this was parsed with the legacy parser
        // (Unlike some other options here, this does/should fork the cache.)
        if ( $parserOptions->getUseParsoid() ) {
            $this->setOutputFlag( ParserOutputFlags::USE_PARSOID, true );
        }
    }
 
    public function mergeInternalMetaDataFrom( ParserOutput $source ): void {
        $this->mWarnings = self::mergeMap( $this->mWarnings, $source->mWarnings ); // don't use getter
        $this->mWarningMsgs = self::mergeMap( $this->mWarningMsgs, $source->mWarningMsgs );
        $this->mTimestamp = self::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"
                );
            }
        }
        if ( $source->mCacheExpiry !== null ) {
            $this->updateCacheExpiry( $source->mCacheExpiry );
        }
 
        foreach ( self::SPECULATIVE_FIELDS as $field ) {
            if ( $this->$field && $source->$field && $this->$field !== $source->$field ) {
                wfLogWarning( __METHOD__ . ": inconsistent '$field' properties!" );
            }
            $this->$field = self::useMaxValue( $this->$field, $source->$field );
        }
 
        $this->mParseStartTime = self::useEachMinValue(
            $this->mParseStartTime,
            $source->mParseStartTime
        );
 
        $this->mTimeProfile = self::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 );
        if ( $source->mMaxAdaptiveExpiry !== null ) {
            $this->updateRuntimeAdaptiveExpiry( $source->mMaxAdaptiveExpiry, $source->getCacheExpirySource() );
        }
        if ( $source->mCacheExpiry !== null ) {
            // Deliberately not using ::getCacheExpiry() here, which can get
            // quantized in MiserMode.
            $this->updateCacheExpiry( $source->mCacheExpiry, $source->getCacheExpirySource() );
        }
        $this->mExtraStyleSrcs = self::mergeList(
            $this->mExtraStyleSrcs,
            $source->getExtraCSPStyleSrcs()
        );
        $this->mExtraScriptSrcs = self::mergeList(
            $this->mExtraScriptSrcs,
            $source->getExtraCSPScriptSrcs()
        );
        $this->mExtraDefaultSrcs = self::mergeList(
            $this->mExtraDefaultSrcs,
            $source->getExtraCSPDefaultSrcs()
        );
 
        foreach ( [
            // "noindex" always wins!
            ParserOutputFlags::INDEX_POLICY,
            ParserOutputFlags::NO_INDEX_POLICY,
            // Skin control
            ParserOutputFlags::NEW_SECTION,
            ParserOutputFlags::HIDE_NEW_SECTION,
            ParserOutputFlags::NO_GALLERY,
            ParserOutputFlags::ENABLE_OOUI,
            ParserOutputFlags::PREVENT_CLICKJACKING,
            // Selective update
            ParserOutputFlags::PREVENT_SELECTIVE_UPDATE,
        ] as $flag ) {
            // logical OR of $this and $source
            if ( $source->getOutputFlag( $flag ) ) {
                $this->setOutputFlag( $flag );
            }
        }
 
        $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 === '' ) {
            $this->mTitleText = $source->mTitleText;
            $this->mDisplayTitleParts = $source->mDisplayTitleParts;
        }
 
        // class names are stored in array keys
        $this->mWrapperDivClasses = self::mergeMap(
            $this->mWrapperDivClasses,
            $source->mWrapperDivClasses
        );
 
        // NOTE: last write wins, same as within one ParserOutput
        foreach ( $source->getIndicators() as $id => $content ) {
            $this->setIndicator( $id, $content );
        }
 
        // 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 {
        foreach ( ParserOutputLinkTypes::cases() as $linkType ) {
            foreach ( $source->getLinkList( $linkType ) as $linkItem ) {
                $this->appendLinkList( $linkType, $linkItem );
            }
        }
        $this->mExternalLinks = self::mergeMap( $this->mExternalLinks, $source->getExternalLinks() );
 
        // 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::values() )
        );
        foreach ( $flags as $name ) {
            $name = (string)$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::values() 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->mLinks as $ns => $arr ) {
            foreach ( $arr as $dbk => $id ) {
                // Numeric titles are going to come out of the
                // `mLinks` array as ints; cast back to string.
                $lt = TitleValue::tryNew( $ns, (string)$dbk );
                $metadata->addLink( $lt, $id );
            }
        }
 
        foreach ( $this->mInterwikiLinks as $prefix => $arr ) {
            foreach ( $arr as $dbk => $ignore ) {
                $lt = TitleValue::tryNew( NS_MAIN, (string)$dbk, '', $prefix );
                $metadata->addLink( $lt );
            }
        }
 
        foreach ( $this->mLinksSpecial as $dbk => $ignore ) {
            // Numeric titles are going to come out of the
            // `mLinksSpecial` array as ints; cast back to string.
            $lt = TitleValue::tryNew( NS_SPECIAL, (string)$dbk );
            $metadata->addLink( $lt );
        }
 
        foreach ( $this->mImages as $name => $ignore ) {
            // Numeric titles come out of mImages as ints.
            $lt = TitleValue::tryNew( NS_FILE, (string)$name );
            $props = $this->mFileSearchOptions[$name] ?? [];
            $metadata->addImage( $lt, $props['time'] ?? null, $props['sha1'] ?? null );
        }
 
        foreach ( $this->mLanguageLinkMap as $lang => $title ) {
            # language links can have fragments!
            [ $title, $frag ] = array_pad( explode( '#', $title, 2 ), 2, '' );
            $lt = TitleValue::tryNew( NS_MAIN, $title, $frag, (string)$lang );
            $metadata->addLanguageLink( $lt );
        }
 
        foreach ( $this->mJsConfigVars as $key => $value ) {
            // Numeric keys and items are going to come out of the
            // `mJsConfigVars` array as ints; cast back to string.
            $key = (string)$key;
            if ( is_array( $value ) && isset( $value[self::MW_MERGE_STRATEGY_KEY] ) ) {
                self::collectMapStrategy( $value, static fn ( $v, $s ) =>
                    $metadata->appendJsConfigVar( $key, $v, $s )
                );
            } 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;
                $metadata->setOutputFlag( ParserOutputFlags::PREVENT_SELECTIVE_UPDATE );
            } else {
                $metadata->setJsConfigVar( $key, $value );
            }
        }
        foreach ( $this->mExtensionData as $key => $value ) {
            // Numeric keys and items are going to come out of the array as
            // ints, cast back to string.
            $key = (string)$key;
            if ( is_array( $value ) && isset( $value[self::MW_MERGE_STRATEGY_KEY] ) ) {
                self::collectMapStrategy( $value, static fn ( $v, $s ) =>
                    $metadata->appendExtensionData( $key, $v, $s )
                );
            } 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( (string)$url );
        }
        foreach ( $this->mProperties as $prop => $value ) {
            // Numeric properties are going to come out of the array as ints
            $prop = (string)$prop;
            if ( is_string( $value ) ) {
                $metadata->setUnsortedPageProperty( $prop, $value );
            } elseif ( is_numeric( $value ) ) {
                $metadata->setNumericPageProperty( $prop, $value );
            } else {
                // Deprecated, but there are still sites which call
                // ::setPageProperty() with "unusual" values (T374046)
                wfDeprecated( __METHOD__ . ' with unusual page property', '1.45' );
            }
        }
        foreach ( $this->mLimitReportData as $key => $value ) {
            $metadata->setLimitReportData( (string)$key, $value );
        }
        foreach ( $this->getIndicators() as $id => $content ) {
            $metadata->setIndicator( (string)$id, $content );
        }
 
        // 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 );
            }
            $metadata->mHeadItems = self::mergeMixedList(
                $metadata->mHeadItems, $this->mHeadItems
            );
            if ( $this->mMaxAdaptiveExpiry !== null ) {
                $metadata->updateRuntimeAdaptiveExpiry( $this->mMaxAdaptiveExpiry, $this->getCacheExpirySource() );
            }
            if ( $this->mCacheExpiry !== null ) {
                // Deliberately not using ::getCacheExpiry() here, which can get
                // quantized in MiserMode.
                $metadata->updateCacheExpiry( $this->mCacheExpiry, $this->getCacheExpirySource() );
            }
            if ( $this->mTimestamp !== null ) {
                $metadata->setRevisionTimestamp(
                    self::useMaxValue(
                        $this->mTimestamp, $metadata->getRevisionTimestamp()
                    )
                );
            }
            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 === '' ) {
                $metadata->mTitleText = $this->mTitleText;
                $metadata->mDisplayTitleParts = $this->mDisplayTitleParts;
            }
            // class names are stored in array keys
            $metadata->mWrapperDivClasses = self::mergeMap(
                $metadata->mWrapperDivClasses,
                $this->mWrapperDivClasses
            );
            // 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.
            $tocData = $this->getTOCData();
            $otherTocData = $metadata->getTOCData();
            if ( $otherTocData !== null ) {
                if ( $tocData !== null ) {
                    foreach ( $tocData->getSections() as $s ) {
                        $otherTocData->addSection( clone $s );
                    }
                }
            } elseif ( $tocData !== null ) {
                $metadata->setTOCData( clone $tocData );
            }
            foreach (
                [
                    ParserOutputLinkTypes::TEMPLATE,
                    ParserOutputLinkTypes::EXISTENCE,
                ] as $linkType ) {
                foreach ( $this->getLinkList( $linkType ) as $linkItem ) {
                    $metadata->appendLinkList( $linkType, $linkItem );
                }
            }
            foreach ( $this->mWarningMsgs as $key => $msg ) {
                $metadata->addWarningMsgVal( $msg, (string)$key );
            }
            // mWarnings is deprecated, but keep it around
            foreach ( $this->mWarnings as $str => $ignore ) {
                $metadata->mWarnings[$str] = 1;
            }
            // Final render ID should be a function of all component POs.
            // In order to make this symmetric w/r/t source and target,
            // use the lexicographically first one first.
            if ( $this->getRenderId() !== null ) {
                $renderIds = [
                    $this->getRenderId(), $metadata->getRenderId() ?? ''
                ];
                sort( $renderIds, SORT_STRING );
                $metadata->setRenderId( implode( '', $renderIds ) );
            }
 
            foreach ( self::SPECULATIVE_FIELDS as $field ) {
                if ( $this->$field && $metadata->$field && $this->$field !== $metadata->$field ) {
                    wfLogWarning( __METHOD__ . ": inconsistent '$field' properties!" );
                }
                $metadata->$field = self::useMaxValue( $this->$field, $metadata->$field );
            }
 
            $metadata->mParseStartTime = self::useEachMinValue(
                $this->mParseStartTime,
                $metadata->mParseStartTime
            );
 
            $metadata->mTimeProfile = self::useEachTotalValue(
                $this->mTimeProfile,
                $metadata->mTimeProfile
            );
            // TODO: maintain per-slot limit reports!
            if ( !$metadata->mLimitReportData ) {
                $metadata->mLimitReportData = $this->mLimitReportData;
            }
            if ( !$metadata->mLimitReportJSData ) {
                $metadata->mLimitReportJSData = $this->mLimitReportJSData;
            }
        }
    }
 
    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 makeMapStrategy( string|int $value, MergeStrategy $strategy ): array {
        $base = [ self::MW_MERGE_STRATEGY_KEY => $strategy->value ];
        switch ( $strategy ) {
            case MergeStrategy::UNION:
                return [ $value => true, ...$base ];
            case MergeStrategy::SUM:
                Assert::parameterType( 'integer', $value, '$value' );
                return [ 'value' => $value, ...$base ];
            default:
                throw new InvalidArgumentException( "Unknown merge strategy {$strategy->value}" );
        }
    }
 
    private static function collectMapStrategy( array $map, callable $f ): void {
        $strategy = MergeStrategy::from(
            $map[self::MW_MERGE_STRATEGY_KEY]
        );
        foreach ( $map as $key => $value ) {
            if ( $key === self::MW_MERGE_STRATEGY_KEY ) {
                continue;
            }
            switch ( $strategy ) {
                case MergeStrategy::UNION:
                    $f( $key, $strategy ); // ignore value
                    break;
                case MergeStrategy::SUM:
                    $f( $value, $strategy ); // ignore key
                    break;
            }
        }
    }
 
    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" );
                }
                $strategy = MergeStrategy::from( $strategy );
                switch ( $strategy ) {
                    case MergeStrategy::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 );
                        break;
                    case MergeStrategy::SUM:
                        $a[$key]['value'] += $b[$key]['value'];
                        break;
                    default:
                        throw new InvalidArgumentException( "Unknown merge strategy {$strategy->value}" );
                }
            } else {
                $valuesSame = ( $a[$key] === $bValue );
                if ( ( !$valuesSame ) &&
                    is_object( $a[$key] ) &&
                    is_object( $bValue )
                ) {
                    $jsonCodec = MediaWikiServices::getInstance()->getJsonCodec();
                    $valuesSame = ( $jsonCodec->toJsonArray( $a[$key] ) === $jsonCodec->toJsonArray( $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 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 );
    }
 
    public 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 = [
            'LanguageLinks' => $this->getLanguageLinksInternal(),
            'Categories' => $this->mCategories,
            'IndicatorIds' => $this->mIndicatorIds,
            '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,
            'ExistenceLinks' => $this->existenceLinks,
            'HeadItems' => $this->mHeadItems,
            'Modules' => array_keys( $this->mModuleSet ),
            'ModuleStyles' => array_keys( $this->mModuleStyleSet ),
            'JsConfigVars' => $this->mJsConfigVars,
            'Warnings' => $this->mWarnings,
            'WarningMsgs' => $this->mWarningMsgs,
            'TOCData' => $this->mTOCData,
            'Properties' => self::detectAndEncodeBinary( $this->mProperties ),
            'Timestamp' => $this->mTimestamp,
            // may contain arbitrary structures!
            'ExtensionData' => $this->mExtensionData,
            'LimitReportData' => $this->mLimitReportData,
            'LimitReportJSData' => $this->mLimitReportJSData,
            'CacheMessage' => $this->mCacheMessage,
            'TimeProfile' => $this->mTimeProfile,
            'ParseStartTime' => [], // don't serialize this
            'ExtraScriptSrcs' => $this->mExtraScriptSrcs,
            'ExtraDefaultSrcs' => $this->mExtraDefaultSrcs,
            'ExtraStyleSrcs' => $this->mExtraStyleSrcs,
            'SpeculativeRevId' => $this->mSpeculativeRevId,
            'SpeculativePageIdUsed' => $this->speculativePageIdUsed,
            'RevisionTimestampUsed' => $this->revisionTimestampUsed,
            'RevisionUsedSha1Base36' => $this->revisionUsedSha1Base36,
            'WrapperDivClasses' => $this->mWrapperDivClasses,
            'OutputFlags' => array_keys( $this->mFlags ),
        ];
        if ( $this->getContentHolder()->hasContent() ) {
            $data[ 'ContentHolder' ] = $this->getContentHolder();
        }
 
        // Fill in missing fields from parents. Array addition does not override existing fields.
        $data += parent::toJsonArray();
 
        // TODO: make more fields optional!
 
        if ( $this->mDisplayTitleParts !== null ) {
            $data['DisplayTitleParts'] = $this->mDisplayTitleParts;
        }
 
        if ( $this->mMaxAdaptiveExpiry !== null ) {
            $data['MaxAdaptiveExpiry'] = $this->mMaxAdaptiveExpiry;
        }
 
        return $data;
    }
 
    public static function newFromJsonArray( array $json ): ParserOutput {
        $parserOutput = new ParserOutput();
        $parserOutput->initFromJson( $json );
        return $parserOutput;
    }
 
    public static function jsonClassHintFor( string $keyName ) {
        return match ( $keyName ) {
            'TOCData' => Hint::build( TOCData::class, Hint::ONLY_FOR_DECODE ),
            'WarningMsgs' => Hint::build( MessageValue::class, Hint::LIST, Hint::ONLY_FOR_DECODE ),
            'ContentHolder' => Hint::build( ContentHolder::class ),
            default => null,
        };
    }
 
    protected function initFromJson( array $jsonData ): void {
        parent::initFromJson( $jsonData );
 
        // WARNING: When changing how this class is serialized, follow the instructions
        // at <https://www.mediawiki.org/wiki/Manual:Parser_cache/Serialization_compatibility>!
        // (This includes changing default values when fields are missing.)
        if ( isset( $jsonData['ContentHolder'] ) ) {
            $this->contentHolder = $jsonData['ContentHolder'];
        } else {
            // mostly backward compatibility T423701
            $pageBundleData = $jsonData['ExtensionData'][self::PARSOID_PAGE_BUNDLE_KEY] ?? null;
            if ( $pageBundleData ) {
                unset( $jsonData['ExtensionData'][self::PARSOID_PAGE_BUNDLE_KEY] );
                $pb = HtmlPageBundle::newFromJsonArray(
                    $pageBundleData + [ 'html' => $jsonData['Text'] ?? '' ]
                );
                $siteConfig = MediaWikiServices::getInstance()->getParsoidSiteConfig();
                $this->contentHolder = ContentHolder::createFromParsoidPageBundle( $pb, $siteConfig );
            } else {
                $this->contentHolder = ContentHolder::createFromLegacyString( $jsonData['Text'] ?? '' );
            }
            if ( !isset( $jsonData['Text'] ) ) {
                // Make the content holder empty if 'no content holder and 'Text' was null.
                $this->contentHolder->setAsHtmlString( ContentHolder::BODY_FRAGMENT, null );
            }
        }
        $this->mLanguageLinkMap = [];
        foreach ( ( $jsonData['LanguageLinks'] ?? [] ) as $l ) {
            // T374736: old serialized parser cache entries may
            // contain invalid language links; drop them quietly.
            // (This code can be removed two LTS releases past 1.45.)
            if ( str_contains( $l, ':' ) ) {
                $this->addLanguageLink( $l );
            }
        }
        // Default values should match the property default values.
        $this->mCategories = $jsonData['Categories'] ?? [];
        $this->mIndicatorIds = $jsonData['IndicatorIds'] ?? [];
        // backwards compatibility T427622
        foreach ( ( $jsonData['Indicators'] ?? [] ) as $id => $value ) {
            $this->setIndicator( $id, $value );
        }
        $this->mTitleText = $jsonData['TitleText'] ?? '';
        $this->mDisplayTitleParts = $jsonData['DisplayTitleParts'] ?? null;
        $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->existenceLinks = $jsonData['ExistenceLinks'] ?? [];
        $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->mWarningMsgs = $jsonData['WarningMsgs'] ?? [];
 
        // Set flags stored as properties (backward compatibility with MW<1.45)
        $this->mFlags = $jsonData['Flags'] ?? [];
        if ( $jsonData['NoGallery'] ?? false ) {
            $this->setOutputFlag( ParserOutputFlags::NO_GALLERY );
        }
        if ( $jsonData['EnableOOUI'] ?? false ) {
            $this->setOutputFlag( ParserOutputFlags::ENABLE_OOUI );
        }
        $this->setIndexPolicy( $jsonData['IndexPolicy'] ?? '' );
        if ( $jsonData['NewSection'] ?? false ) {
            $this->setOutputFlag( ParserOutputFlags::NEW_SECTION );
        }
        if ( $jsonData['HideNewSection'] ?? false ) {
            $this->setOutputFlag( ParserOutputFlags::HIDE_NEW_SECTION );
        }
        if ( $jsonData['PreventClickjacking'] ?? false ) {
            $this->setOutputFlag( ParserOutputFlags::PREVENT_CLICKJACKING );
        }
        // Set all generic output flags (whether stored as properties or not)
        // (This is effectively a logical-OR if these are also serialized
        // above.)
        foreach ( $jsonData['OutputFlags'] ?? [] as $flagName ) {
            $flag = ParserOutputFlags::tryFrom( $flagName );
            if ( $flag !== null ) {
                $this->setOutputFlag( $flag );
            } else {
                // T417819: We *should* backport new ParserOutputFlags values
                // to avoid reaching this case, but it ought to be safe to drop
                // the unknown flags on the floor.
                wfDeprecated(
                    __METHOD__ . " of flag $flagName without forward compatibility",
                    '1.46'
                );
                // Preserve non-standard flags for now since they are used in
                // serialization test cases.
                $this->setOutputFlag( $flagName );
            }
        }
 
        if ( isset( $jsonData['TOCData'] ) ) {
            $this->mTOCData = $jsonData['TOCData'];
        // Backward-compatibility with old TOCData encoding (T327439)
        // emitted in MW < 1.45
        } elseif (
            ( $jsonData['Sections'] ?? [] ) !== [] ||
            // distinguish "no sections" from "sections not set"
            $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( (string)$key, $value );
                }
            }
        }
        // backward-compatibility: convert page properties to their
        // 'database representation'.  We haven't permitted non-string
        // non-numeric values since 1.45.
        $this->mProperties = [];
        foreach (
            self::detectAndDecodeBinary( $jsonData['Properties'] ?? [] )
            as $k => $v
        ) {
            if ( is_int( $v ) || is_float( $v ) || is_string( $v ) ) {
                $this->mProperties[$k] = $v;
            } elseif ( is_bool( $v ) ) {
                $this->mProperties[$k] = (int)$v;
            } elseif ( $v === null ) {
                $this->mProperties[$k] = '';
            } elseif ( is_array( $v ) ) {
                $this->mProperties[$k] = 'Array';
            } else {
                $this->mProperties[$k] = strval( $v );
            }
        }
        $this->mTimestamp = $jsonData['Timestamp'] ?? null;
        $this->mExtensionData = $jsonData['ExtensionData'] ?? [];
        $this->mLimitReportData = $jsonData['LimitReportData'] ?? [];
        $this->mLimitReportJSData = $jsonData['LimitReportJSData'] ?? [];
        $this->mCacheMessage = $jsonData['CacheMessage'] ?? '';
        $this->mParseStartTime = []; // invalid after reloading
        $this->mTimeProfile = $jsonData['TimeProfile'] ?? [];
        $this->mExtraScriptSrcs = $jsonData['ExtraScriptSrcs'] ?? [];
        $this->mExtraDefaultSrcs = $jsonData['ExtraDefaultSrcs'] ?? [];
        $this->mExtraStyleSrcs = $jsonData['ExtraStyleSrcs'] ?? [];
        $this->mSpeculativeRevId = $jsonData['SpeculativeRevId'] ?? null;
        $this->speculativePageIdUsed = $jsonData['SpeculativePageIdUsed'] ?? null;
        $this->revisionTimestampUsed = $jsonData['RevisionTimestampUsed'] ?? null;
        $this->revisionUsedSha1Base36 = $jsonData['RevisionUsedSha1Base36'] ?? null;
        $this->mWrapperDivClasses = $jsonData['WrapperDivClasses'] ?? [];
        $this->mMaxAdaptiveExpiry = $jsonData['MaxAdaptiveExpiry'] ?? null;
    }
 
    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 __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;
        }
        $this->contentHolder = clone $this->contentHolder;
    }
 
    public function getContentHolderText(): string {
        $html = $this->contentHolder->getAsHtmlString( ContentHolder::BODY_FRAGMENT );
        if ( $html === null ) {
            throw new LogicException( 'This ParserOutput contains no text!' );
        }
        return $html;
    }
 
    public function setContentHolderText( ?string $text ): void {
        $this->contentHolder->setAsHtmlString( ContentHolder::BODY_FRAGMENT, $text );
    }
 
    private static function normalizeForObjectEquality(): array {
        return [
            'mFlags' => static function ( $v ) {
                ksort( $v );
                return $v;
            },
        ];
    }
}
 
class_alias( ParserOutput::class, 'ParserOutput' );