ResourceLoader.php

Go to the documentation of this file.

<?php
namespace MediaWiki\ResourceLoader;
 
use BagOStuff;
use CommentStore;
use Config;
use DeferredUpdates;
use Exception;
use ExtensionRegistry;
use HashBagOStuff;
use Hooks;
use Html;
use HttpStatus;
use InvalidArgumentException;
use Less_Parser;
use MediaWiki\HeaderCallback;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\User\UserOptionsLookup;
use MWException;
use MWExceptionHandler;
use MWExceptionRenderer;
use Net_URL2;
use ObjectCache;
use OutputPage;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use ResourceFileCache;
use RuntimeException;
use stdClass;
use Throwable;
use Title;
use UnexpectedValueException;
use WebRequest;
use WikiMap;
use Wikimedia\DependencyStore\DependencyStore;
use Wikimedia\DependencyStore\KeyValueDependencyStore;
use Wikimedia\Minify\CSSMin;
use Wikimedia\Minify\JavaScriptMinifier;
use Wikimedia\Rdbms\DBConnectionError;
use Wikimedia\RequestTimeout\TimeoutException;
use Wikimedia\ScopedCallback;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\WrappedString;
use Xml;
use XmlJsCode;
 
class Context72Hack extends Context {
}
 
class ResourceLoader implements LoggerAwareInterface {
    public const CACHE_VERSION = 9;
    public const FILTER_NOMIN = '/*@nomin*/';
 
    private const RL_DEP_STORE_PREFIX = 'ResourceLoaderModule';
    private const RL_MODULE_DEP_TTL = BagOStuff::TTL_YEAR;
    private const MAXAGE_RECOVER = 60;
 
    protected static $debugMode = null;
 
    private $config;
    private $blobStore;
    private $depStore;
    private $logger;
    private $hookContainer;
    private $hookRunner;
    private $loadScript;
    private $maxageVersioned;
    private $maxageUnversioned;
    private $useFileCache;
 
    private $modules = [];
    private $moduleInfos = [];
    private $testModuleNames = [];
    private $sources = [];
    protected $errors = [];
    protected $extraHeaders = [];
    private $depStoreUpdateBuffer = [];
    private $moduleSkinStyles = [];
 
    public function __construct(
        Config $config,
        LoggerInterface $logger = null,
        DependencyStore $tracker = null,
        array $params = []
    ) {
        $this->loadScript = $params['loadScript'] ?? '/load.php';
        $this->maxageVersioned = $params['maxageVersioned'] ?? 30 * 24 * 60 * 60;
        $this->maxageUnversioned = $params['maxageUnversioned'] ?? 5 * 60;
        $this->useFileCache = $params['useFileCache'] ?? false;
 
        $this->config = $config;
        $this->logger = $logger ?: new NullLogger();
 
        $services = MediaWikiServices::getInstance();
        $this->hookContainer = $services->getHookContainer();
        $this->hookRunner = new HookRunner( $this->hookContainer );
 
        // Add 'local' source first
        $this->addSource( 'local', $this->loadScript );
 
        // Special module that always exists
        $this->register( 'startup', [ 'class' => StartUpModule::class ] );
 
        $this->setMessageBlobStore(
            new MessageBlobStore( $this, $this->logger, $services->getMainWANObjectCache() )
        );
 
        $tracker = $tracker ?: new KeyValueDependencyStore( new HashBagOStuff() );
        $this->setDependencyStore( $tracker );
    }
 
    public function getConfig() {
        return $this->config;
    }
 
    public function setLogger( LoggerInterface $logger ) {
        $this->logger = $logger;
    }
 
    public function getLogger() {
        return $this->logger;
    }
 
    public function getMessageBlobStore() {
        return $this->blobStore;
    }
 
    public function setMessageBlobStore( MessageBlobStore $blobStore ) {
        $this->blobStore = $blobStore;
    }
 
    public function setDependencyStore( DependencyStore $tracker ) {
        $this->depStore = $tracker;
    }
 
    public function setModuleSkinStyles( array $moduleSkinStyles ) {
        $this->moduleSkinStyles = $moduleSkinStyles;
    }
 
    public function register( $name, array $info = null ) {
        // Allow multiple modules to be registered in one call
        $registrations = is_array( $name ) ? $name : [ $name => $info ];
        foreach ( $registrations as $name => $info ) {
            // Warn on duplicate registrations
            if ( isset( $this->moduleInfos[$name] ) ) {
                // A module has already been registered by this name
                $this->logger->warning(
                    'ResourceLoader duplicate registration warning. ' .
                    'Another module has already been registered as ' . $name
                );
            }
 
            // Check validity
            if ( !self::isValidModuleName( $name ) ) {
                throw new InvalidArgumentException( "ResourceLoader module name '$name' is invalid, "
                    . "see ResourceLoader::isValidModuleName()" );
            }
            if ( !is_array( $info ) ) {
                throw new InvalidArgumentException(
                    'Invalid module info for "' . $name . '": expected array, got ' . gettype( $info )
                );
            }
 
            // Attach module
            $this->moduleInfos[$name] = $info;
        }
    }
 
    public function registerTestModules(): void {
        $testModulesMeta = [ 'qunit' => [] ];
        $this->hookRunner->onResourceLoaderTestModules( $testModulesMeta, $this );
 
        $extRegistry = ExtensionRegistry::getInstance();
        // In case of conflict, the deprecated hook has precedence.
        $testModules = $testModulesMeta['qunit']
            + $extRegistry->getAttribute( 'QUnitTestModules' );
 
        $testModuleNames = [];
        foreach ( $testModules as $name => &$module ) {
            // Turn any single-module dependency into an array
            if ( isset( $module['dependencies'] ) && is_string( $module['dependencies'] ) ) {
                $module['dependencies'] = [ $module['dependencies'] ];
            }
 
            // Ensure the testrunner loads before any tests
            $module['dependencies'][] = 'mediawiki.qunit-testrunner';
 
            // Keep track of the modules to load on SpecialJavaScriptTest
            $testModuleNames[] = $name;
        }
 
        // Core test modules (their names have further precedence).
        $testModules = ( include MW_INSTALL_PATH . '/tests/qunit/QUnitTestResources.php' ) + $testModules;
        $testModuleNames[] = 'test.MediaWiki';
 
        $this->register( $testModules );
        $this->testModuleNames = $testModuleNames;
    }
 
    public function addSource( $sources, $loadUrl = null ) {
        if ( !is_array( $sources ) ) {
            $sources = [ $sources => $loadUrl ];
        }
        foreach ( $sources as $id => $source ) {
            // Disallow duplicates
            if ( isset( $this->sources[$id] ) ) {
                throw new RuntimeException( 'Cannot register source ' . $id . ' twice' );
            }
 
            // Support: MediaWiki 1.24 and earlier
            if ( is_array( $source ) ) {
                if ( !isset( $source['loadScript'] ) ) {
                    throw new InvalidArgumentException( 'Each source must have a "loadScript" key' );
                }
                $source = $source['loadScript'];
            }
 
            $this->sources[$id] = $source;
        }
    }
 
    public function getModuleNames() {
        return array_keys( $this->moduleInfos );
    }
 
    public function getTestSuiteModuleNames() {
        return $this->testModuleNames;
    }
 
    public function isModuleRegistered( $name ) {
        return isset( $this->moduleInfos[$name] );
    }
 
    public function getModule( $name ) {
        if ( !isset( $this->modules[$name] ) ) {
            if ( !isset( $this->moduleInfos[$name] ) ) {
                // No such module
                return null;
            }
            // Construct the requested module object
            $info = $this->moduleInfos[$name];
            if ( isset( $info['factory'] ) ) {
                $object = call_user_func( $info['factory'], $info );
            } else {
                $class = $info['class'] ?? FileModule::class;
                $object = new $class( $info );
            }
            $object->setConfig( $this->getConfig() );
            $object->setLogger( $this->logger );
            $object->setHookContainer( $this->hookContainer );
            $object->setName( $name );
            $object->setDependencyAccessCallbacks(
                [ $this, 'loadModuleDependenciesInternal' ],
                [ $this, 'saveModuleDependenciesInternal' ]
            );
            $object->setSkinStylesOverride( $this->moduleSkinStyles );
            $this->modules[$name] = $object;
        }
 
        return $this->modules[$name];
    }
 
    public function preloadModuleInfo( array $moduleNames, Context $context ) {
        // Load all tracked indirect file dependencies for the modules
        $vary = Module::getVary( $context );
        $entitiesByModule = [];
        foreach ( $moduleNames as $moduleName ) {
            $entitiesByModule[$moduleName] = "$moduleName|$vary";
        }
        $depsByEntity = $this->depStore->retrieveMulti(
            self::RL_DEP_STORE_PREFIX,
            $entitiesByModule
        );
        // Inject the indirect file dependencies for all the modules
        foreach ( $moduleNames as $moduleName ) {
            $module = $this->getModule( $moduleName );
            if ( $module ) {
                $entity = $entitiesByModule[$moduleName];
                $deps = $depsByEntity[$entity];
                $paths = Module::expandRelativePaths( $deps['paths'] );
                $module->setFileDependencies( $context, $paths );
            }
        }
 
        // Batched version of WikiModule::getTitleInfo
        $dbr = wfGetDB( DB_REPLICA );
        WikiModule::preloadTitleInfo( $context, $dbr, $moduleNames );
 
        // Prime in-object cache for message blobs for modules with messages
        $modulesWithMessages = [];
        foreach ( $moduleNames as $moduleName ) {
            $module = $this->getModule( $moduleName );
            if ( $module && $module->getMessages() ) {
                $modulesWithMessages[$moduleName] = $module;
            }
        }
        // Prime in-object cache for message blobs for modules with messages
        $lang = $context->getLanguage();
        $store = $this->getMessageBlobStore();
        $blobs = $store->getBlobs( $modulesWithMessages, $lang );
        foreach ( $blobs as $moduleName => $blob ) {
            $modulesWithMessages[$moduleName]->setMessageBlob( $blob, $lang );
        }
    }
 
    public function loadModuleDependenciesInternal( $moduleName, $variant ) {
        $deps = $this->depStore->retrieve( self::RL_DEP_STORE_PREFIX, "$moduleName|$variant" );
 
        return Module::expandRelativePaths( $deps['paths'] );
    }
 
    public function saveModuleDependenciesInternal( $moduleName, $variant, $paths, $priorPaths ) {
        $hasPendingUpdate = (bool)$this->depStoreUpdateBuffer;
        $entity = "$moduleName|$variant";
 
        if ( array_diff( $paths, $priorPaths ) || array_diff( $priorPaths, $paths ) ) {
            // Dependency store needs to be updated with the new path list
            if ( $paths ) {
                $deps = $this->depStore->newEntityDependencies( $paths, time() );
                $this->depStoreUpdateBuffer[$entity] = $deps;
            } else {
                $this->depStoreUpdateBuffer[$entity] = null;
            }
        }
 
        // If paths were unchanged, leave the dependency store unchanged also.
        // The entry will eventually expire, after which we will briefly issue an incomplete
        // version hash for a 5-min startup window, the module then recomputes and rediscovers
        // the paths and arrive at the same module version hash once again. It will churn
        // part of the browser cache once, for clients connecting during that window.
 
        if ( !$hasPendingUpdate ) {
            DeferredUpdates::addCallableUpdate( function () {
                $updatesByEntity = $this->depStoreUpdateBuffer;
                $this->depStoreUpdateBuffer = [];
                $cache = ObjectCache::getLocalClusterInstance();
 
                $scopeLocks = [];
                $depsByEntity = [];
                $entitiesUnreg = [];
                foreach ( $updatesByEntity as $entity => $update ) {
                    $lockKey = $cache->makeKey( 'rl-deps', $entity );
                    $scopeLocks[$entity] = $cache->getScopedLock( $lockKey, 0 );
                    if ( !$scopeLocks[$entity] ) {
                        // avoid duplicate write request slams (T124649)
                        // the lock must be specific to the current wiki (T247028)
                        continue;
                    }
                    if ( $update === null ) {
                        $entitiesUnreg[] = $entity;
                    } else {
                        $depsByEntity[$entity] = $update;
                    }
                }
 
                $ttl = self::RL_MODULE_DEP_TTL;
                $this->depStore->storeMulti( self::RL_DEP_STORE_PREFIX, $depsByEntity, $ttl );
                $this->depStore->remove( self::RL_DEP_STORE_PREFIX, $entitiesUnreg );
            } );
        }
    }
 
    public function getSources() {
        return $this->sources;
    }
 
    public function getLoadScript( $source ) {
        if ( !isset( $this->sources[$source] ) ) {
            throw new UnexpectedValueException( "Unknown source '$source'" );
        }
        return $this->sources[$source];
    }
 
    public const HASH_LENGTH = 5;
 
    public static function makeHash( $value ) {
        $hash = hash( 'fnv132', $value );
        // The base_convert will pad it (if too short),
        // then substr() will trim it (if too long).
        return substr(
            \Wikimedia\base_convert( $hash, 16, 36, self::HASH_LENGTH ),
            0,
            self::HASH_LENGTH
        );
    }
 
    public function outputErrorAndLog( Exception $e, $msg, array $context = [] ) {
        MWExceptionHandler::logException( $e );
        $this->logger->warning(
            $msg,
            $context + [ 'exception' => $e ]
        );
        $this->errors[] = self::formatExceptionNoComment( $e );
    }
 
    public function getCombinedVersion( Context $context, array $moduleNames ) {
        if ( !$moduleNames ) {
            return '';
        }
        $hashes = array_map( function ( $module ) use ( $context ) {
            try {
                return $this->getModule( $module )->getVersionHash( $context );
            } catch ( TimeoutException $e ) {
                throw $e;
            } catch ( Exception $e ) {
                // If modules fail to compute a version, don't fail the request (T152266)
                // and still compute versions of other modules.
                $this->outputErrorAndLog( $e,
                    'Calculating version for "{module}" failed: {exception}',
                    [
                        'module' => $module,
                    ]
                );
                return '';
            }
        }, $moduleNames );
        return self::makeHash( implode( '', $hashes ) );
    }
 
    public function makeVersionQuery( Context $context, array $modules ) {
        // As of MediaWiki 1.28, the server and client use the same algorithm for combining
        // version hashes. There is no technical reason for this to be same, and for years the
        // implementations differed. If getCombinedVersion in PHP (used for StartupModule and
        // E-Tag headers) differs in the future from getCombinedVersion in JS (used for 'version'
        // query parameter), then this method must continue to match the JS one.
        $filtered = [];
        foreach ( $modules as $name ) {
            if ( !$this->getModule( $name ) ) {
                // If a versioned request contains a missing module, the version is a mismatch
                // as the client considered a module (and version) we don't have.
                return '';
            }
            $filtered[] = $name;
        }
        return $this->getCombinedVersion( $context, $filtered );
    }
 
    public function respond( Context $context ) {
        // Buffer output to catch warnings. Normally we'd use ob_clean() on the
        // top-level output buffer to clear warnings, but that breaks when ob_gzhandler
        // is used: ob_clean() will clear the GZIP header in that case and it won't come
        // back for subsequent output, resulting in invalid GZIP. So we have to wrap
        // the whole thing in our own output buffer to be sure the active buffer
        // doesn't use ob_gzhandler.
        // See https://bugs.php.net/bug.php?id=36514
        ob_start();
 
        $responseTime = $this->measureResponseTime();
 
        // Find out which modules are missing and instantiate the others
        $modules = [];
        $missing = [];
        foreach ( $context->getModules() as $name ) {
            $module = $this->getModule( $name );
            if ( $module ) {
                // Do not allow private modules to be loaded from the web.
                // This is a security issue, see T36907.
                if ( $module->getGroup() === Module::GROUP_PRIVATE ) {
                    // Not a serious error, just means something is trying to access it (T101806)
                    $this->logger->debug( "Request for private module '$name' denied" );
                    $this->errors[] = "Cannot build private module \"$name\"";
                    continue;
                }
                $modules[$name] = $module;
            } else {
                $missing[] = $name;
            }
        }
 
        try {
            // Preload for getCombinedVersion() and for batch makeModuleResponse()
            $this->preloadModuleInfo( array_keys( $modules ), $context );
        } catch ( TimeoutException $e ) {
            throw $e;
        } catch ( Exception $e ) {
            $this->outputErrorAndLog( $e, 'Preloading module info failed: {exception}' );
        }
 
        // Combine versions to propagate cache invalidation
        $versionHash = $this->getCombinedVersion( $context, array_keys( $modules ) );
 
        // See RFC 2616 § 3.11 Entity Tags
        // https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.11
        $etag = 'W/"' . $versionHash . '"';
 
        // Try the client-side cache first
        if ( $this->tryRespondNotModified( $context, $etag ) ) {
            return; // output handled (buffers cleared)
        }
 
        // Use file cache if enabled and available...
        if ( $this->useFileCache ) {
            $fileCache = ResourceFileCache::newFromContext( $context );
            if ( $this->tryRespondFromFileCache( $fileCache, $context, $etag ) ) {
                return; // output handled
            }
        } else {
            $fileCache = null;
        }
 
        // Generate a response
        $response = $this->makeModuleResponse( $context, $modules, $missing );
 
        // Capture any PHP warnings from the output buffer and append them to the
        // error list if we're in debug mode.
        if ( $context->getDebug() ) {
            $warnings = ob_get_contents();
            if ( strlen( $warnings ) ) {
                $this->errors[] = $warnings;
            }
        }
 
        // Consider saving the response to file cache (unless there are errors).
        if ( $fileCache && !$this->errors && $missing === [] &&
            ResourceFileCache::useFileCache( $context ) ) {
            if ( $fileCache->isCacheWorthy() ) {
                // There were enough hits, save the response to the cache
                $fileCache->saveText( $response );
            } else {
                $fileCache->incrMissesRecent( $context->getRequest() );
            }
        }
 
        $this->sendResponseHeaders( $context, $etag, (bool)$this->errors, $this->extraHeaders );
 
        // Remove the output buffer and output the response
        ob_end_clean();
 
        if ( $context->getImageObj() && $this->errors ) {
            // We can't show both the error messages and the response when it's an image.
            $response = implode( "\n\n", $this->errors );
        } elseif ( $this->errors ) {
            $errorText = implode( "\n\n", $this->errors );
            $errorResponse = self::makeComment( $errorText );
            if ( $context->shouldIncludeScripts() ) {
                $errorResponse .= 'if (window.console && console.error) { console.error('
                    . $context->encodeJson( $errorText )
                    . "); }\n";
            }
 
            // Prepend error info to the response
            $response = $errorResponse . $response;
        }
 
        $this->errors = [];
        // @phan-suppress-next-line SecurityCheck-XSS
        echo $response;
    }
 
    protected function measureResponseTime() {
        $statStart = $_SERVER['REQUEST_TIME_FLOAT'];
        return new ScopedCallback( static function () use ( $statStart ) {
            $statTiming = microtime( true ) - $statStart;
            $stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
            $stats->timing( 'resourceloader.responseTime', $statTiming * 1000 );
        } );
    }
 
    protected function sendResponseHeaders(
        Context $context, $etag, $errors, array $extra = []
    ): void {
        HeaderCallback::warnIfHeadersSent();
 
        if ( $errors
            || (
                $context->getVersion() !== null
                    && $context->getVersion() !== $this->makeVersionQuery( $context, $context->getModules() )
            )
        ) {
            // If we need to self-correct, set a very short cache expiry
            // to basically just debounce CDN traffic. This applies to:
            // - Internal errors, e.g. due to misconfiguration.
            // - Version mismatch, e.g. due to deployment race (T117587, T47877).
            $maxage = self::MAXAGE_RECOVER;
        } elseif ( $context->getVersion() === null ) {
            // Resources that can't set a version, should have their updates propagate to
            // clients quickly. This applies to shared resources linked from HTML, such as
            // the startup module and stylesheets.
            $maxage = $this->maxageUnversioned;
        } else {
            // When a version is set, use a long expiry because changes
            // will naturally miss the cache by using a differente URL.
            $maxage = $this->maxageVersioned;
        }
        if ( $context->getImageObj() ) {
            // Output different headers if we're outputting textual errors.
            if ( $errors ) {
                header( 'Content-Type: text/plain; charset=utf-8' );
            } else {
                $context->getImageObj()->sendResponseHeaders( $context );
            }
        } elseif ( $context->getOnly() === 'styles' ) {
            header( 'Content-Type: text/css; charset=utf-8' );
            header( 'Access-Control-Allow-Origin: *' );
        } else {
            header( 'Content-Type: text/javascript; charset=utf-8' );
        }
        // See RFC 2616 § 14.19 ETag
        // https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.19
        header( 'ETag: ' . $etag );
        if ( $context->getDebug() ) {
            // Do not cache debug responses
            header( 'Cache-Control: private, no-cache, must-revalidate' );
            header( 'Pragma: no-cache' );
        } else {
            header( "Cache-Control: public, max-age=$maxage, s-maxage=$maxage" );
            header( 'Expires: ' . ConvertibleTimestamp::convert( TS_RFC2822, time() + $maxage ) );
        }
        foreach ( $extra as $header ) {
            header( $header );
        }
    }
 
    protected function tryRespondNotModified( Context $context, $etag ) {
        // See RFC 2616 § 14.26 If-None-Match
        // https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.26
        $clientKeys = $context->getRequest()->getHeader( 'If-None-Match', WebRequest::GETHEADER_LIST );
        // Never send 304s in debug mode
        if ( $clientKeys !== false && !$context->getDebug() && in_array( $etag, $clientKeys ) ) {
            // There's another bug in ob_gzhandler (see also the comment at
            // the top of this function) that causes it to gzip even empty
            // responses, meaning it's impossible to produce a truly empty
            // response (because the gzip header is always there). This is
            // a problem because 304 responses have to be completely empty
            // per the HTTP spec, and Firefox behaves buggily when they're not.
            // See also https://bugs.php.net/bug.php?id=51579
            // To work around this, we tear down all output buffering before
            // sending the 304.
            wfResetOutputBuffers( /* $resetGzipEncoding = */ true );
 
            HttpStatus::header( 304 );
 
            $this->sendResponseHeaders( $context, $etag, false );
            return true;
        }
        return false;
    }
 
    protected function tryRespondFromFileCache(
        ResourceFileCache $fileCache,
        Context $context,
        $etag
    ) {
        // Buffer output to catch warnings.
        ob_start();
        // Get the maximum age the cache can be
        $maxage = $context->getVersion() === null
            ? $this->maxageUnversioned
            : $this->maxageVersioned;
        // Minimum timestamp the cache file must have
        $minTime = time() - $maxage;
        $good = $fileCache->isCacheGood( ConvertibleTimestamp::convert( TS_MW, $minTime ) );
        if ( !$good ) {
            try { // RL always hits the DB on file cache miss...
                wfGetDB( DB_REPLICA );
            } catch ( DBConnectionError $e ) { // ...check if we need to fallback to cache
                $good = $fileCache->isCacheGood(); // cache existence check
            }
        }
        if ( $good ) {
            $ts = $fileCache->cacheTimestamp();
            // Send content type and cache headers
            $this->sendResponseHeaders( $context, $etag, false );
            $response = $fileCache->fetchText();
            // Capture any PHP warnings from the output buffer and append them to the
            // response in a comment if we're in debug mode.
            if ( $context->getDebug() ) {
                $warnings = ob_get_contents();
                if ( strlen( $warnings ) ) {
                    $response = self::makeComment( $warnings ) . $response;
                }
            }
            // Remove the output buffer and output the response
            ob_end_clean();
            echo $response . "\n/* Cached {$ts} */";
            return true; // cache hit
        }
        // Clear buffer
        ob_end_clean();
 
        return false; // cache miss
    }
 
    public static function makeComment( $text ) {
        $encText = str_replace( '*/', '* /', $text );
        return "/*\n$encText\n*/\n";
    }
 
    public static function formatException( Throwable $e ) {
        return self::makeComment( self::formatExceptionNoComment( $e ) );
    }
 
    protected static function formatExceptionNoComment( Throwable $e ) {
        if ( !MWExceptionRenderer::shouldShowExceptionDetails() ) {
            return MWExceptionHandler::getPublicLogMessage( $e );
        }
 
        return MWExceptionHandler::getLogMessage( $e ) .
            "\nBacktrace:\n" .
            MWExceptionHandler::getRedactedTraceAsString( $e );
    }
 
    public function makeModuleResponse( Context $context,
        array $modules, array $missing = []
    ) {
        if ( $modules === [] && $missing === [] ) {
            return <<<MESSAGE
/* This file is the Web entry point for MediaWiki's ResourceLoader:
   <https://www.mediawiki.org/wiki/ResourceLoader>. In this request,
   no modules were requested. Max made me put this here. */
MESSAGE;
        }
 
        $image = $context->getImageObj();
        if ( $image ) {
            $data = $image->getImageData( $context );
            if ( $data === false ) {
                $data = '';
                $this->errors[] = 'Image generation failed';
            }
            return $data;
        }
 
        $states = [];
        foreach ( $missing as $name ) {
            $states[$name] = 'missing';
        }
 
        $only = $context->getOnly();
        $filter = $only === 'styles' ? 'minify-css' : 'minify-js';
        $debug = (bool)$context->getDebug();
 
        $out = '';
        foreach ( $modules as $name => $module ) {
            try {
                $content = $module->getModuleContent( $context );
                $implementKey = $name . '@' . $module->getVersionHash( $context );
                $strContent = '';
 
                if ( isset( $content['headers'] ) ) {
                    $this->extraHeaders = array_merge( $this->extraHeaders, $content['headers'] );
                }
 
                // Append output
                switch ( $only ) {
                    case 'scripts':
                        $scripts = $content['scripts'];
                        if ( is_string( $scripts ) ) {
                            // Load scripts raw...
                            $strContent = $scripts;
                        } elseif ( is_array( $scripts ) ) {
                            // ...except when $scripts is an array of URLs or an associative array
                            $strContent = self::makeLoaderImplementScript(
                                $context,
                                $implementKey,
                                $scripts,
                                [],
                                [],
                                []
                            );
                        }
                        break;
                    case 'styles':
                        $styles = $content['styles'];
                        // We no longer separate into media, they are all combined now with
                        // custom media type groups into @media .. {} sections as part of the css string.
                        // Module returns either an empty array or a numerical array with css strings.
                        $strContent = isset( $styles['css'] ) ? implode( '', $styles['css'] ) : '';
                        break;
                    default:
                        $scripts = $content['scripts'] ?? '';
                        if ( is_string( $scripts ) ) {
                            if ( $name === 'site' || $name === 'user' ) {
                                // Legacy scripts that run in the global scope without a closure.
                                // mw.loader.implement will use eval if scripts is a string.
                                // Minify manually here, because general response minification is
                                // not effective due it being a string literal, not a function.
                                if ( !$debug ) {
                                    $scripts = self::filter( 'minify-js', $scripts ); // T107377
                                }
                            } else {
                                $scripts = new XmlJsCode( $scripts );
                            }
                        }
                        $strContent = self::makeLoaderImplementScript(
                            $context,
                            $implementKey,
                            $scripts,
                            $content['styles'] ?? [],
                            isset( $content['messagesBlob'] ) ? new XmlJsCode( $content['messagesBlob'] ) : [],
                            $content['templates'] ?? []
                        );
                        break;
                }
 
                if ( $debug ) {
                    // In debug mode, separate each response by a new line.
                    // For example, between 'mw.loader.implement();' statements.
                    $strContent = self::ensureNewline( $strContent );
                } else {
                    $strContent = self::filter( $filter, $strContent, [
                        // Important: Do not cache minifications of embedded modules
                        // This is especially for the private 'user.options' module,
                        // which varies on every pageview and would explode the cache (T84960)
                        'cache' => !$module->shouldEmbedModule( $context )
                    ] );
                }
 
                if ( $only === 'scripts' ) {
                    // Use a linebreak between module scripts (T162719)
                    $out .= self::ensureNewline( $strContent );
                } else {
                    $out .= $strContent;
                }
            } catch ( TimeoutException $e ) {
                throw $e;
            } catch ( Exception $e ) {
                $this->outputErrorAndLog( $e, 'Generating module package failed: {exception}' );
 
                // Respond to client with error-state instead of module implementation
                $states[$name] = 'error';
                unset( $modules[$name] );
            }
        }
 
        // Update module states
        if ( $context->shouldIncludeScripts() && !$context->getRaw() ) {
            if ( $modules && $only === 'scripts' ) {
                // Set the state of modules loaded as only scripts to ready as
                // they don't have an mw.loader.implement wrapper that sets the state
                foreach ( $modules as $name => $module ) {
                    $states[$name] = 'ready';
                }
            }
 
            // Set the state of modules we didn't respond to with mw.loader.implement
            if ( $states ) {
                $stateScript = self::makeLoaderStateScript( $context, $states );
                if ( !$debug ) {
                    $stateScript = self::filter( 'minify-js', $stateScript );
                }
                // Use a linebreak between module script and state script (T162719)
                $out = self::ensureNewline( $out ) . $stateScript;
            }
        } elseif ( $states ) {
            $this->errors[] = 'Problematic modules: '
                . $context->encodeJson( $states );
        }
 
        return $out;
    }
 
    public static function ensureNewline( $str ) {
        $end = substr( $str, -1 );
        if ( $end === false || $end === '' || $end === "\n" ) {
            return $str;
        }
        return $str . "\n";
    }
 
    public function getModulesByMessage( $messageKey ) {
        $moduleNames = [];
        foreach ( $this->getModuleNames() as $moduleName ) {
            $module = $this->getModule( $moduleName );
            if ( in_array( $messageKey, $module->getMessages() ) ) {
                $moduleNames[] = $moduleName;
            }
        }
        return $moduleNames;
    }
 
    private static function makeLoaderImplementScript(
        Context $context, $name, $scripts, $styles, $messages, $templates
    ) {
        if ( $scripts instanceof XmlJsCode ) {
            if ( $scripts->value === '' ) {
                $scripts = null;
            } else {
                $scripts = new XmlJsCode( "function ( $, jQuery, require, module ) {\n{$scripts->value}\n}" );
            }
        } elseif ( is_array( $scripts ) && isset( $scripts['files'] ) ) {
            $files = $scripts['files'];
            foreach ( $files as $path => &$file ) {
                // $file is changed (by reference) from a descriptor array to the content of the file
                // All of these essentially do $file = $file['content'];, some just have wrapping around it
                if ( $file['type'] === 'script' ) {
                    // Ensure that the script has a newline at the end to close any comment in the
                    // last line.
                    $content = self::ensureNewline( $file['content'] );
                    // Provide CJS `exports` (in addition to CJS2 `module.exports`) to package modules (T284511).
                    // $/jQuery are simply used as globals instead.
                    // TODO: Remove $/jQuery param from traditional module closure too (and bump caching)
                    $file = new XmlJsCode( "function ( require, module, exports ) {\n$content}" );
                } else {
                    $file = $file['content'];
                }
            }
            $scripts = XmlJsCode::encodeObject( [
                'main' => $scripts['main'],
                'files' => XmlJsCode::encodeObject( $files, true )
            ], true );
        } elseif ( !is_string( $scripts ) && !is_array( $scripts ) ) {
            throw new InvalidArgumentException( 'Script must be a string or an array of URLs' );
        }
 
        // mw.loader.implement requires 'styles', 'messages' and 'templates' to be objects (not
        // arrays). json_encode considers empty arrays to be numerical and outputs "[]" instead
        // of "{}". Force them to objects.
        $module = [
            $name,
            $scripts,
            (object)$styles,
            (object)$messages,
            (object)$templates
        ];
        self::trimArray( $module );
 
        // We use pretty output unconditionally to make this method simpler.
        // Minification is taken care of closer to the output.
        return Xml::encodeJsCall( 'mw.loader.implement', $module, true );
    }
 
    public static function makeMessageSetScript( $messages ) {
        return 'mw.messages.set('
            . self::encodeJsonForScript( (object)$messages )
            . ');';
    }
 
    public static function makeCombinedStyles( array $stylePairs ) {
        $out = [];
        foreach ( $stylePairs as $media => $styles ) {
            // FileModule::getStyle can return the styles as a string or an
            // array of strings. This is to allow separation in the front-end.
            $styles = (array)$styles;
            foreach ( $styles as $style ) {
                $style = trim( $style );
                // Don't output an empty "@media print { }" block (T42498)
                if ( $style === '' ) {
                    continue;
                }
                // Transform the media type based on request params and config
                // The way that this relies on $wgRequest to propagate request params is slightly evil
                $media = OutputPage::transformCssMedia( $media );
 
                if ( $media === '' || $media == 'all' ) {
                    $out[] = $style;
                } elseif ( is_string( $media ) ) {
                    $out[] = "@media $media {\n" . str_replace( "\n", "\n\t", "\t" . $style ) . "}";
                }
                // else: skip
            }
        }
        return $out;
    }
 
    public static function encodeJsonForScript( $data ) {
        // Keep output as small as possible by disabling needless escape modes
        // that PHP uses by default.
        // However, while most module scripts are only served on HTTP responses
        // for JavaScript, some modules can also be embedded in the HTML as inline
        // scripts. This, and the fact that we sometimes need to export strings
        // containing user-generated content and labels that may genuinely contain
        // a sequences like "</script>", we need to encode either '/' or '<'.
        // By default PHP escapes '/'. Let's escape '<' instead which is less common
        // and allows URLs to mostly remain readable.
        $jsonFlags = JSON_UNESCAPED_SLASHES |
            JSON_UNESCAPED_UNICODE |
            JSON_HEX_TAG |
            JSON_HEX_AMP;
        if ( self::inDebugMode() ) {
            $jsonFlags |= JSON_PRETTY_PRINT;
        }
        return json_encode( $data, $jsonFlags );
    }
 
    public static function makeLoaderStateScript(
        Context $context, array $states
    ) {
        return 'mw.loader.state('
            . $context->encodeJson( $states )
            . ');';
    }
 
    private static function isEmptyObject( stdClass $obj ) {
        foreach ( $obj as $key => $value ) {
            return false;
        }
        return true;
    }
 
    private static function trimArray( array &$array ): void {
        $i = count( $array );
        while ( $i-- ) {
            if ( $array[$i] === null
                || $array[$i] === []
                || ( $array[$i] instanceof XmlJsCode && $array[$i]->value === '{}' )
                || ( $array[$i] instanceof stdClass && self::isEmptyObject( $array[$i] ) )
            ) {
                unset( $array[$i] );
            } else {
                break;
            }
        }
    }
 
    public static function makeLoaderRegisterScript(
        Context $context, array $modules
    ) {
        // Optimisation: Transform dependency names into indexes when possible
        // to produce smaller output. They are expanded by mw.loader.register on
        // the other end.
        $index = [];
        foreach ( $modules as $i => &$module ) {
            // Build module name index
            $index[$module[0]] = $i;
        }
        foreach ( $modules as &$module ) {
            if ( isset( $module[2] ) ) {
                foreach ( $module[2] as &$dependency ) {
                    if ( isset( $index[$dependency] ) ) {
                        // Replace module name in dependency list with index
                        $dependency = $index[$dependency];
                    }
                }
            }
        }
 
        array_walk( $modules, [ self::class, 'trimArray' ] );
 
        return 'mw.loader.register('
            . $context->encodeJson( $modules )
            . ');';
    }
 
    public static function makeLoaderSourcesScript(
        Context $context, array $sources
    ) {
        return 'mw.loader.addSource('
            . $context->encodeJson( $sources )
            . ');';
    }
 
    public static function makeLoaderConditionalScript( $script ) {
        // Adds a function to lazy-created RLQ
        return '(RLQ=window.RLQ||[]).push(function(){' .
            trim( $script ) . '});';
    }
 
    public static function makeInlineCodeWithModule( $modules, $script ) {
        // Adds an array to lazy-created RLQ
        return '(RLQ=window.RLQ||[]).push(['
            . self::encodeJsonForScript( $modules ) . ','
            . 'function(){' . trim( $script ) . '}'
            . ']);';
    }
 
    public static function makeInlineScript( $script, $nonce = null ) {
        $js = self::makeLoaderConditionalScript( $script );
        $escNonce = '';
        if ( $nonce === null ) {
            wfWarn( __METHOD__ . " did not get nonce. Will break CSP" );
        } elseif ( $nonce !== false ) {
            // If it was false, CSP is disabled, so no nonce attribute.
            // Nonce should be only base64 characters, so should be safe,
            // but better to be safely escaped than sorry.
            $escNonce = ' nonce="' . htmlspecialchars( $nonce ) . '"';
        }
 
        return new WrappedString(
            Html::inlineScript( $js, $nonce ),
            "<script$escNonce>(RLQ=window.RLQ||[]).push(function(){",
            '});</script>'
        );
    }
 
    public static function makeConfigSetScript( array $configuration ) {
        $json = self::encodeJsonForScript( $configuration );
        if ( $json === false ) {
            $e = new Exception(
                'JSON serialization of config data failed. ' .
                'This usually means the config data is not valid UTF-8.'
            );
            MWExceptionHandler::logException( $e );
            return 'mw.log.error(' . self::encodeJsonForScript( $e->__toString() ) . ');';
        }
        return "mw.config.set($json);";
    }
 
    public static function makePackedModulesString( array $modules ) {
        $moduleMap = []; // [ prefix => [ suffixes ] ]
        foreach ( $modules as $module ) {
            $pos = strrpos( $module, '.' );
            $prefix = $pos === false ? '' : substr( $module, 0, $pos );
            $suffix = $pos === false ? $module : substr( $module, $pos + 1 );
            $moduleMap[$prefix][] = $suffix;
        }
 
        $arr = [];
        foreach ( $moduleMap as $prefix => $suffixes ) {
            $p = $prefix === '' ? '' : $prefix . '.';
            $arr[] = $p . implode( ',', $suffixes );
        }
        return implode( '|', $arr );
    }
 
    public static function expandModuleNames( $modules ) {
        $retval = [];
        $exploded = explode( '|', $modules );
        foreach ( $exploded as $group ) {
            if ( strpos( $group, ',' ) === false ) {
                // This is not a set of modules in foo.bar,baz notation
                // but a single module
                $retval[] = $group;
                continue;
            }
            // This is a set of modules in foo.bar,baz notation
            $pos = strrpos( $group, '.' );
            if ( $pos === false ) {
                // Prefixless modules, i.e. without dots
                $retval = array_merge( $retval, explode( ',', $group ) );
                continue;
            }
            // We have a prefix and a bunch of suffixes
            $prefix = substr( $group, 0, $pos ); // 'foo'
            $suffixes = explode( ',', substr( $group, $pos + 1 ) ); // [ 'bar', 'baz' ]
            foreach ( $suffixes as $suffix ) {
                $retval[] = "$prefix.$suffix";
            }
        }
        return $retval;
    }
 
    public static function inDebugMode() {
        if ( self::$debugMode === null ) {
            global $wgRequest;
            $resourceLoaderDebug = MediaWikiServices::getInstance()->getMainConfig()->get(
                MainConfigNames::ResourceLoaderDebug );
            $str = $wgRequest->getRawVal( 'debug',
                $wgRequest->getCookie( 'resourceLoaderDebug', '', $resourceLoaderDebug ? 'true' : '' )
            );
            self::$debugMode = Context::debugFromString( $str );
        }
        return self::$debugMode;
    }
 
    public static function clearCache() {
        self::$debugMode = null;
    }
 
    public function createLoaderURL( $source, Context $context,
        array $extraQuery = []
    ) {
        $query = self::createLoaderQuery( $context, $extraQuery );
        $script = $this->getLoadScript( $source );
 
        return wfAppendQuery( $script, $query );
    }
 
    protected static function createLoaderQuery(
        Context $context, array $extraQuery = []
    ) {
        return self::makeLoaderQuery(
            $context->getModules(),
            $context->getLanguage(),
            $context->getSkin(),
            $context->getUser(),
            $context->getVersion(),
            $context->getDebug(),
            $context->getOnly(),
            $context->getRequest()->getBool( 'printable' ),
            null,
            $extraQuery
        );
    }
 
    public static function makeLoaderQuery( array $modules, $lang, $skin, $user = null,
        $version = null, $debug = Context::DEBUG_OFF, $only = null,
        $printable = false, $handheld = null, array $extraQuery = []
    ) {
        $query = [
            'modules' => self::makePackedModulesString( $modules ),
        ];
        // Keep urls short by omitting query parameters that
        // match the defaults assumed by Context.
        // Note: This relies on the defaults either being insignificant or forever constant,
        // as otherwise cached urls could change in meaning when the defaults change.
        if ( $lang !== Context::DEFAULT_LANG ) {
            $query['lang'] = $lang;
        }
        if ( $skin !== Context::DEFAULT_SKIN ) {
            $query['skin'] = $skin;
        }
        if ( $debug !== Context::DEBUG_OFF ) {
            $query['debug'] = strval( $debug );
        }
        if ( $user !== null ) {
            $query['user'] = $user;
        }
        if ( $version !== null ) {
            $query['version'] = $version;
        }
        if ( $only !== null ) {
            $query['only'] = $only;
        }
        if ( $printable ) {
            $query['printable'] = 1;
        }
        $query += $extraQuery;
 
        // Make queries uniform in order
        ksort( $query );
        return $query;
    }
 
    public static function isValidModuleName( $moduleName ) {
        $len = strlen( $moduleName );
        return $len <= 255 && strcspn( $moduleName, '!,|', 0, $len ) === $len;
    }
 
    public function getLessCompiler( array $vars = [], array $importDirs = [] ) {
        global $IP;
        // When called from the installer, it is possible that a required PHP extension
        // is missing (at least for now; see T49564). If this is the case, throw an
        // exception (caught by the installer) to prevent a fatal error later on.
        if ( !class_exists( Less_Parser::class ) ) {
            throw new MWException( 'MediaWiki requires the less.php parser' );
        }
 
        $importDirs[] = "$IP/resources/src/mediawiki.less";
 
        $parser = new Less_Parser;
        $parser->ModifyVars( $vars );
        // SetImportDirs expects an array like [ 'path1' => '', 'path2' => '' ]
        $parser->SetImportDirs( array_fill_keys( $importDirs, '' ) );
        $parser->SetOption( 'relativeUrls', false );
 
        return $parser;
    }
 
    public function expandUrl( string $base, string $url ): string {
        // Net_URL2::resolve() doesn't allow protocol-relative URLs, but we do.
        $isProtoRelative = strpos( $base, '//' ) === 0;
        if ( $isProtoRelative ) {
            $base = "https:$base";
        }
        // Net_URL2::resolve() takes care of throwing if $base doesn't have a server.
        $baseUrl = new Net_URL2( $base );
        $ret = $baseUrl->resolve( $url );
        if ( $isProtoRelative ) {
            $ret->setScheme( false );
        }
        return $ret->getURL();
    }
 
    public static function filter( $filter, $data, array $options = [] ) {
        if ( strpos( $data, self::FILTER_NOMIN ) !== false ) {
            return $data;
        }
 
        if ( isset( $options['cache'] ) && $options['cache'] === false ) {
            return self::applyFilter( $filter, $data ) ?? $data;
        }
 
        $stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
        $cache = ObjectCache::getLocalServerInstance( CACHE_ANYTHING );
 
        $key = $cache->makeGlobalKey(
            'resourceloader-filter',
            $filter,
            self::CACHE_VERSION,
            md5( $data )
        );
 
        $incKey = "resourceloader_cache.$filter.hit";
        $result = $cache->getWithSetCallback(
            $key,
            BagOStuff::TTL_DAY,
            function () use ( $filter, $data, &$incKey ) {
                $incKey = "resourceloader_cache.$filter.miss";
                return self::applyFilter( $filter, $data );
            }
        );
        $stats->increment( $incKey );
        if ( $result === null ) {
            // Cached failure
            $result = $data;
        }
 
        return $result;
    }
 
    private static function applyFilter( $filter, $data ) {
        $data = trim( $data );
        if ( $data ) {
            try {
                $data = ( $filter === 'minify-css' )
                    ? CSSMin::minify( $data )
                    : JavaScriptMinifier::minify( $data );
            } catch ( TimeoutException $e ) {
                throw $e;
            } catch ( Exception $e ) {
                MWExceptionHandler::logException( $e );
                return null;
            }
        }
        return $data;
    }
 
    public static function getUserDefaults(
        Context $context,
        HookContainer $hookContainer,
        UserOptionsLookup $userOptionsLookup
    ): array {
        $defaultOptions = $userOptionsLookup->getDefaultOptions();
        $keysToExclude = [];
        $hookRunner = new HookRunner( $hookContainer );
        $hookRunner->onResourceLoaderExcludeUserOptions( $keysToExclude, $context );
        foreach ( $keysToExclude as $excludedKey ) {
            unset( $defaultOptions[ $excludedKey ] );
        }
        return $defaultOptions;
    }
 
    public static function getSiteConfigSettings(
        Context $context, Config $conf
    ): array {
        // Namespace related preparation
        // - wgNamespaceIds: Key-value pairs of all localized, canonical and aliases for namespaces.
        // - wgCaseSensitiveNamespaces: Array of namespaces that are case-sensitive.
        $contLang = MediaWikiServices::getInstance()->getContentLanguage();
        $namespaceIds = $contLang->getNamespaceIds();
        $caseSensitiveNamespaces = [];
        $nsInfo = MediaWikiServices::getInstance()->getNamespaceInfo();
        foreach ( $nsInfo->getCanonicalNamespaces() as $index => $name ) {
            $namespaceIds[$contLang->lc( $name )] = $index;
            if ( !$nsInfo->isCapitalized( $index ) ) {
                $caseSensitiveNamespaces[] = $index;
            }
        }
 
        $illegalFileChars = $conf->get( MainConfigNames::IllegalFileChars );
 
        // Build list of variables
        $skin = $context->getSkin();
 
        // Start of supported and stable config vars (for use by extensions/gadgets).
        $vars = [
            'debug' => $context->getDebug(),
            'skin' => $skin,
            'stylepath' => $conf->get( MainConfigNames::StylePath ),
            'wgArticlePath' => $conf->get( MainConfigNames::ArticlePath ),
            'wgScriptPath' => $conf->get( MainConfigNames::ScriptPath ),
            'wgScript' => $conf->get( MainConfigNames::Script ),
            'wgSearchType' => $conf->get( MainConfigNames::SearchType ),
            'wgVariantArticlePath' => $conf->get( MainConfigNames::VariantArticlePath ),
            'wgServer' => $conf->get( MainConfigNames::Server ),
            'wgServerName' => $conf->get( MainConfigNames::ServerName ),
            'wgUserLanguage' => $context->getLanguage(),
            'wgContentLanguage' => $contLang->getCode(),
            'wgVersion' => MW_VERSION,
            'wgFormattedNamespaces' => $contLang->getFormattedNamespaces(),
            'wgNamespaceIds' => $namespaceIds,
            'wgContentNamespaces' => $nsInfo->getContentNamespaces(),
            'wgSiteName' => $conf->get( MainConfigNames::Sitename ),
            'wgDBname' => $conf->get( MainConfigNames::DBname ),
            'wgWikiID' => WikiMap::getCurrentWikiId(),
            'wgCaseSensitiveNamespaces' => $caseSensitiveNamespaces,
            'wgCommentCodePointLimit' => CommentStore::COMMENT_CHARACTER_LIMIT,
            'wgExtensionAssetsPath' => $conf->get( MainConfigNames::ExtensionAssetsPath ),
        ];
        // End of stable config vars.
 
        // Internal variables for use by MediaWiki core and/or ResourceLoader.
        $vars += [
            // @internal For mediawiki.widgets
            'wgUrlProtocols' => wfUrlProtocols(),
            // @internal For mediawiki.page.watch
            // Force object to avoid "empty" associative array from
            // becoming [] instead of {} in JS (T36604)
            'wgActionPaths' => (object)$conf->get( MainConfigNames::ActionPaths ),
            // @internal For mediawiki.language
            'wgTranslateNumerals' => $conf->get( MainConfigNames::TranslateNumerals ),
            // @internal For mediawiki.Title
            'wgExtraSignatureNamespaces' => $conf->get( MainConfigNames::ExtraSignatureNamespaces ),
            'wgLegalTitleChars' => Title::convertByteClassToUnicodeClass( Title::legalChars() ),
            'wgIllegalFileChars' => Title::convertByteClassToUnicodeClass( $illegalFileChars ),
        ];
 
        Hooks::runner()->onResourceLoaderGetConfigVars( $vars, $skin, $conf );
 
        return $vars;
    }
}
 
class_alias( ResourceLoader::class, 'ResourceLoader' );