ResourceLoader.php

Go to the documentation of this file.

<?php
use MediaWiki\HeaderCallback;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\MediaWikiServices;
use MediaWiki\ResourceLoader\HookRunner;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Wikimedia\DependencyStore\DependencyStore;
use Wikimedia\DependencyStore\KeyValueDependencyStore;
use Wikimedia\Rdbms\DBConnectionError;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\WrappedString;
 
class ResourceLoader implements LoggerAwareInterface {
    protected $config;
    protected $blobStore;
    protected $depStore;
 
    private $logger;
 
    private $hookContainer;
 
    private $hookRunner;
 
    protected $modules = [];
    protected $moduleInfos = [];
    protected $testModuleNames = [];
    protected $testSuiteModuleNames = [];
    protected $sources = [];
    protected $errors = [];
    protected $extraHeaders = [];
 
    private $depStoreUpdateBuffer = [];
 
    private $moduleSkinStyles = [];
 
    protected static $debugMode = null;
 
    public const CACHE_VERSION = 8;
 
    private const RL_DEP_STORE_PREFIX = 'ResourceLoaderModule';
    private const RL_MODULE_DEP_TTL = BagOStuff::TTL_WEEK;
 
    public const FILTER_NOMIN = '/*@nomin*/';
 
    public function preloadModuleInfo( array $moduleNames, ResourceLoaderContext $context ) {
        // Load all tracked indirect file dependencies for the modules
        $vary = ResourceLoaderModule::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 = ResourceLoaderModule::expandRelativePaths( $deps['paths'] );
                $module->setFileDependencies( $context, $paths );
            }
        }
 
        // Batched version of ResourceLoaderWikiModule::getTitleInfo
        $dbr = wfGetDB( DB_REPLICA );
        ResourceLoaderWikiModule::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 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 )
        );
 
        $result = $cache->get( $key );
        if ( $result === false ) {
            $stats->increment( "resourceloader_cache.$filter.miss" );
            $result = self::applyFilter( $filter, $data );
            $cache->set( $key, $result, 24 * 3600 );
        } else {
            $stats->increment( "resourceloader_cache.$filter.hit" );
        }
        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 ( Exception $e ) {
                MWExceptionHandler::logException( $e );
                return null;
            }
        }
        return $data;
    }
 
    public function __construct(
        Config $config = null,
        LoggerInterface $logger = null,
        DependencyStore $tracker = null
    ) {
        $this->logger = $logger ?: new NullLogger();
        $services = MediaWikiServices::getInstance();
 
        if ( !$config ) {
            wfDeprecated( __METHOD__ . ' without a Config instance', '1.34' );
            $config = $services->getMainConfig();
        }
        $this->config = $config;
 
        $this->hookContainer = $services->getHookContainer();
        $this->hookRunner = new HookRunner( $this->hookContainer );
 
        // Add 'local' source first
        $this->addSource( 'local', $config->get( 'LoadScript' ) );
 
        // Special module that always exists
        $this->register( 'startup', [ 'class' => ResourceLoaderStartUpModule::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;
 
            // Last-minute changes
            // Apply custom skin-defined styles to existing modules.
            if ( $this->isFileModule( $name ) ) {
                foreach ( $this->moduleSkinStyles as $skinName => $skinStyles ) {
                    // If this module already defines skinStyles for this skin, ignore ResourceModuleSkinStyles.
                    if ( isset( $this->moduleInfos[$name]['skinStyles'][$skinName] ) ) {
                        continue;
                    }
 
                    // If $name is preceded with a '+', the defined style files will be added to 'default'
                    // skinStyles, otherwise 'default' will be ignored as it normally would be.
                    if ( isset( $skinStyles[$name] ) ) {
                        $paths = (array)$skinStyles[$name];
                        $styleFiles = [];
                    } elseif ( isset( $skinStyles['+' . $name] ) ) {
                        $paths = (array)$skinStyles['+' . $name];
                        $styleFiles = isset( $this->moduleInfos[$name]['skinStyles']['default'] ) ?
                            (array)$this->moduleInfos[$name]['skinStyles']['default'] :
                            [];
                    } else {
                        continue;
                    }
 
                    // Add new file paths, remapping them to refer to our directories and not use settings
                    // from the module we're modifying, which come from the base definition.
                    list( $localBasePath, $remoteBasePath ) =
                        ResourceLoaderFileModule::extractBasePaths( $skinStyles );
 
                    foreach ( $paths as $path ) {
                        $styleFiles[] = new ResourceLoaderFilePath( $path, $localBasePath, $remoteBasePath );
                    }
 
                    $this->moduleInfos[$name]['skinStyles'][$skinName] = $styleFiles;
                }
            }
        }
    }
 
    public function registerTestModules() : void {
        global $IP;
 
        if ( $this->config->get( 'EnableJavaScriptTest' ) !== true ) {
            throw new MWException( 'Attempt to register JavaScript test modules '
                . 'but <code>$wgEnableJavaScriptTest</code> is false. '
                . 'Edit your <code>LocalSettings.php</code> to enable it.' );
        }
 
        // This has a 'qunit' key for compat with the below hook.
        $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' );
 
        $testSuiteModuleNames = [];
        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 test suites
            $module['dependencies'][] = 'mediawiki.qunit-testrunner';
 
            // Keep track of the test suites to load on SpecialJavaScriptTest
            $testSuiteModuleNames[] = $name;
        }
 
        // Core test suites (their names have further precedence).
        $testModules = ( include "$IP/tests/qunit/QUnitTestResources.php" ) + $testModules;
        $testSuiteModuleNames[] = 'test.MediaWiki';
 
        $this->register( $testModules );
        $this->testSuiteModuleNames = $testSuiteModuleNames;
    }
 
    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->testSuiteModuleNames;
    }
 
    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'] ?? ResourceLoaderFileModule::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' ]
            );
            $this->modules[$name] = $object;
        }
 
        return $this->modules[$name];
    }
 
    public function loadModuleDependenciesInternal( $moduleName, $variant ) {
        $deps = $this->depStore->retrieve( self::RL_DEP_STORE_PREFIX, "$moduleName|$variant" );
 
        return ResourceLoaderModule::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;
            }
        } elseif ( $priorPaths ) {
            // Dependency store needs to store the existing path list for longer
            $this->depStoreUpdateBuffer[$entity] = '*';
        }
 
        // Use a DeferrableUpdate to flush the buffered dependency updates...
        if ( !$hasPendingUpdate ) {
            DeferredUpdates::addCallableUpdate( function () {
                $updatesByEntity = $this->depStoreUpdateBuffer;
                $this->depStoreUpdateBuffer = []; // consume
                $cache = ObjectCache::getLocalClusterInstance();
 
                $scopeLocks = [];
                $depsByEntity = [];
                $entitiesUnreg = [];
                $entitiesRenew = [];
                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;
                    } elseif ( $update === null ) {
                        $entitiesUnreg[] = $entity;
                    } elseif ( $update === '*' ) {
                        $entitiesRenew[] = $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 );
                $this->depStore->renew( self::RL_DEP_STORE_PREFIX, $entitiesRenew, $ttl );
            } );
        }
    }
 
    protected function isFileModule( $name ) {
        if ( !isset( $this->moduleInfos[$name] ) ) {
            return false;
        }
        $info = $this->moduleInfos[$name];
        return !isset( $info['factory'] ) && (
            // The implied default for 'class' is ResourceLoaderFileModule
            !isset( $info['class'] ) ||
            // Explicit default
            $info['class'] === ResourceLoaderFileModule::class ||
            is_subclass_of( $info['class'], ResourceLoaderFileModule::class )
        );
    }
 
    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( ResourceLoaderContext $context, array $moduleNames ) {
        if ( !$moduleNames ) {
            return '';
        }
        $hashes = array_map( function ( $module ) use ( $context ) {
            try {
                return $this->getModule( $module )->getVersionHash( $context );
            } 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( ResourceLoaderContext $context, array $modules = null ) {
        if ( $modules === null ) {
            wfDeprecated( __METHOD__ . ' without $modules', '1.34' );
            $modules = $context->getModules();
        }
        // 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( ResourceLoaderContext $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();
 
        $this->measureResponseTime( RequestContext::getMain()->getTiming() );
 
        // 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() === '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 ( Exception $e ) {
            $this->outputErrorAndLog( $e, 'Preloading module info failed: {exception}' );
        }
 
        // Combine versions to propagate cache invalidation
        $versionHash = '';
        try {
            $versionHash = $this->getCombinedVersion( $context, array_keys( $modules ) );
        } catch ( Exception $e ) {
            $this->outputErrorAndLog( $e, 'Calculating version hash failed: {exception}' );
        }
 
        // 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->config->get( '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 = [];
        echo $response;
    }
 
    protected function measureResponseTime( Timing $timing ) {
        DeferredUpdates::addCallableUpdate( function () use ( $timing ) {
            $measure = $timing->measure( 'responseTime', 'requestStart', 'requestShutdown' );
            if ( $measure !== false ) {
                $stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
                $stats->timing( 'resourceloader.responseTime', $measure['duration'] * 1000 );
            }
        } );
    }
 
    protected function sendResponseHeaders(
        ResourceLoaderContext $context, $etag, $errors, array $extra = []
    ) : void {
        HeaderCallback::warnIfHeadersSent();
        $rlMaxage = $this->config->get( 'ResourceLoaderMaxage' );
        // Use a short cache expiry so that updates propagate to clients quickly, if:
        // - No version specified (shared resources, e.g. stylesheets)
        // - There were errors (recover quickly)
        // - Version mismatch (T117587, T47877)
        if ( $context->getVersion() === null
            || $errors
            || $context->getVersion() !== $this->makeVersionQuery( $context, $context->getModules() )
        ) {
            $maxage = $rlMaxage['unversioned'];
        // If a version was specified we can use a longer expiry time since changing
        // version numbers causes cache misses
        } else {
            $maxage = $rlMaxage['versioned'];
        }
        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( ResourceLoaderContext $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,
        ResourceLoaderContext $context,
        $etag
    ) {
        $rlMaxage = $this->config->get( 'ResourceLoaderMaxage' );
        // Buffer output to catch warnings.
        ob_start();
        // Get the maximum age the cache can be
        $maxage = $context->getVersion() === null
            ? $rlMaxage['unversioned']
            : $rlMaxage['versioned'];
        // 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 ) {
        global $wgShowExceptionDetails;
 
        if ( !$wgShowExceptionDetails ) {
            return MWExceptionHandler::getPublicLogMessage( $e );
        }
 
        return MWExceptionHandler::getLogMessage( $e ) .
            "\nBacktrace:\n" .
            MWExceptionHandler::getRedactedTraceAsString( $e );
    }
 
    public function makeModuleResponse( ResourceLoaderContext $context,
        array $modules, array $missing = []
    ) {
        $out = '';
        $states = [];
 
        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;
        }
 
        foreach ( $missing as $name ) {
            $states[$name] = 'missing';
        }
 
        $filter = $context->getOnly() === 'styles' ? 'minify-css' : 'minify-js';
 
        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 ( $context->getOnly() ) {
                    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 globalEval 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 ( !$context->getDebug() ) {
                                    $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 ( !$context->getDebug() ) {
                    $strContent = self::filter( $filter, $strContent );
                } else {
                    // In debug mode, separate each response by a new line.
                    // For example, between 'mw.loader.implement();' statements.
                    $strContent = $this->ensureNewline( $strContent );
                }
 
                if ( $context->getOnly() === 'scripts' ) {
                    // Use a linebreak between module scripts (T162719)
                    $out .= $this->ensureNewline( $strContent );
                } else {
                    $out .= $strContent;
                }
 
            } 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 && $context->getOnly() === '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 ( !$context->getDebug() ) {
                    $stateScript = self::filter( 'minify-js', $stateScript );
                }
                // Use a linebreak between module script and state script (T162719)
                $out = $this->ensureNewline( $out ) . $stateScript;
            }
        } elseif ( $states ) {
            $this->errors[] = 'Problematic modules: '
                . $context->encodeJson( $states );
        }
 
        return $out;
    }
 
    private 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(
        ResourceLoaderContext $context, $name, $scripts, $styles, $messages, $templates
    ) {
        if ( $scripts instanceof XmlJsCode ) {
            if ( $scripts->value === '' ) {
                $scripts = null;
            } elseif ( $context->getDebug() ) {
                $scripts = new XmlJsCode( "function ( $, jQuery, require, module ) {\n{$scripts->value}\n}" );
            } else {
                $scripts = new XmlJsCode( 'function($,jQuery,require,module){' . $scripts->value . '}' );
            }
        } 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' ) {
                    // Multi-file modules only get two parameters ($ and jQuery are being phased out)
                    if ( $context->getDebug() ) {
                        $file = new XmlJsCode( "function ( require, module ) {\n{$file['content']}\n}" );
                    } else {
                        $file = new XmlJsCode( 'function(require,module){' . $file['content'] . '}' );
                    }
                } else {
                    $file = $file['content'];
                }
            }
            $scripts = XmlJsCode::encodeObject( [
                'main' => $scripts['main'],
                'files' => XmlJsCode::encodeObject( $files, $context->getDebug() )
            ], $context->getDebug() );
        } 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 );
 
        return Xml::encodeJsCall( 'mw.loader.implement', $module, $context->getDebug() );
    }
 
    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 ) {
            // ResourceLoaderFileModule::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 !== '' ) {
                    // 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(
        ResourceLoaderContext $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(
        ResourceLoaderContext $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 using resolveIndexedDependencies().
        $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(
        ResourceLoaderContext $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;
            } else {
                // 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 ) );
                } else {
                    // 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, $wgResourceLoaderDebug;
            self::$debugMode = $wgRequest->getFuzzyBool( 'debug',
                $wgRequest->getCookie( 'resourceLoaderDebug', '', $wgResourceLoaderDebug )
            );
        }
        return self::$debugMode;
    }
 
    public static function clearCache() {
        self::$debugMode = null;
    }
 
    public function createLoaderURL( $source, ResourceLoaderContext $context,
        array $extraQuery = []
    ) {
        $query = self::createLoaderQuery( $context, $extraQuery );
        $script = $this->getLoadScript( $source );
 
        return wfAppendQuery( $script, $query );
    }
 
    protected static function createLoaderQuery(
        ResourceLoaderContext $context, array $extraQuery = []
    ) {
        return self::makeLoaderQuery(
            $context->getModules(),
            $context->getLanguage(),
            $context->getSkin(),
            $context->getUser(),
            $context->getVersion(),
            $context->getDebug(),
            $context->getOnly(),
            $context->getRequest()->getBool( 'printable' ),
            $context->getRequest()->getBool( 'handheld' ),
            $extraQuery
        );
    }
 
    public static function makeLoaderQuery( array $modules, $lang, $skin, $user = null,
        $version = null, $debug = false, $only = null, $printable = false,
        $handheld = false, array $extraQuery = []
    ) {
        $query = [
            'modules' => self::makePackedModulesString( $modules ),
        ];
        // Keep urls short by omitting query parameters that
        // match the defaults assumed by ResourceLoaderContext.
        // 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 !== ResourceLoaderContext::DEFAULT_LANG ) {
            $query['lang'] = $lang;
        }
        if ( $skin !== ResourceLoaderContext::DEFAULT_SKIN ) {
            $query['skin'] = $skin;
        }
        if ( $debug === true ) {
            $query['debug'] = 'true';
        }
        if ( $user !== null ) {
            $query['user'] = $user;
        }
        if ( $version !== null ) {
            $query['version'] = $version;
        }
        if ( $only !== null ) {
            $query['only'] = $only;
        }
        if ( $printable ) {
            $query['printable'] = 1;
        }
        if ( $handheld ) {
            $query['handheld'] = 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( $vars = [] ) {
        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' ) ) {
            throw new MWException( 'MediaWiki requires the less.php parser' );
        }
 
        $parser = new Less_Parser;
        $parser->ModifyVars( $vars );
        $parser->SetImportDirs( [
            "$IP/resources/src/mediawiki.less/" => '',
        ] );
        $parser->SetOption( 'relativeUrls', false );
 
        return $parser;
    }
 
    public static function getSiteConfigSettings(
        ResourceLoaderContext $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( '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( 'StylePath' ),
            'wgArticlePath' => $conf->get( 'ArticlePath' ),
            'wgScriptPath' => $conf->get( 'ScriptPath' ),
            'wgScript' => $conf->get( 'Script' ),
            'wgSearchType' => $conf->get( 'SearchType' ),
            'wgVariantArticlePath' => $conf->get( 'VariantArticlePath' ),
            'wgServer' => $conf->get( 'Server' ),
            'wgServerName' => $conf->get( 'ServerName' ),
            'wgUserLanguage' => $context->getLanguage(),
            'wgContentLanguage' => $contLang->getCode(),
            'wgVersion' => MW_VERSION,
            'wgFormattedNamespaces' => $contLang->getFormattedNamespaces(),
            'wgNamespaceIds' => $namespaceIds,
            'wgContentNamespaces' => $nsInfo->getContentNamespaces(),
            'wgSiteName' => $conf->get( 'Sitename' ),
            'wgDBname' => $conf->get( 'DBname' ),
            'wgWikiID' => WikiMap::getCurrentWikiId(),
            'wgCaseSensitiveNamespaces' => $caseSensitiveNamespaces,
            'wgCommentByteLimit' => null,
            'wgCommentCodePointLimit' => CommentStore::COMMENT_CHARACTER_LIMIT,
            'wgExtensionAssetsPath' => $conf->get( '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( 'ActionPaths' ),
            // @internal For mediawiki.language
            'wgTranslateNumerals' => $conf->get( 'TranslateNumerals' ),
            // @internal For mediawiki.Title
            'wgExtraSignatureNamespaces' => $conf->get( 'ExtraSignatureNamespaces' ),
            // @internal For mediawiki.cookie
            'wgCookiePrefix' => $conf->get( 'CookiePrefix' ),
            'wgCookieDomain' => $conf->get( 'CookieDomain' ),
            'wgCookiePath' => $conf->get( 'CookiePath' ),
            'wgCookieExpiration' => $conf->get( 'CookieExpiration' ),
            // @internal For mediawiki.Title
            'wgLegalTitleChars' => Title::convertByteClassToUnicodeClass( Title::legalChars() ),
            'wgIllegalFileChars' => Title::convertByteClassToUnicodeClass( $illegalFileChars ),
            // @internal For mediawiki.ForeignUpload
            'wgForeignUploadTargets' => $conf->get( 'ForeignUploadTargets' ),
            'wgEnableUploads' => $conf->get( 'EnableUploads' ),
        ];
 
        Hooks::runner()->onResourceLoaderGetConfigVars( $vars, $skin, $conf );
 
        return $vars;
    }
}