ResourceLoader.php

Go to the documentation of this file.

<?php
namespace MediaWiki\ResourceLoader;
 
use Exception;
use ExtensionRegistry;
use HttpStatus;
use InvalidArgumentException;
use Less_Environment;
use Less_Parser;
use LogicException;
use MediaWiki\CommentStore\CommentStore;
use MediaWiki\Config\Config;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\Html\Html;
use MediaWiki\Html\HtmlJsCode;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Output\OutputPage;
use MediaWiki\Profiler\ProfilingContext;
use MediaWiki\Request\HeaderCallback;
use MediaWiki\Request\WebRequest;
use MediaWiki\Title\Title;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\WikiMap\WikiMap;
use MWExceptionHandler;
use MWExceptionRenderer;
use Net_URL2;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use RuntimeException;
use stdClass;
use Throwable;
use UnexpectedValueException;
use Wikimedia\DependencyStore\DependencyStore;
use Wikimedia\DependencyStore\KeyValueDependencyStore;
use Wikimedia\Minify\CSSMin;
use Wikimedia\Minify\IdentityMinifierState;
use Wikimedia\Minify\IndexMap;
use Wikimedia\Minify\IndexMapOffset;
use Wikimedia\Minify\JavaScriptMapperState;
use Wikimedia\Minify\JavaScriptMinifier;
use Wikimedia\Minify\JavaScriptMinifierState;
use Wikimedia\Minify\MinifierState;
use Wikimedia\ObjectCache\BagOStuff;
use Wikimedia\ObjectCache\HashBagOStuff;
use Wikimedia\RequestTimeout\TimeoutException;
use Wikimedia\ScopedCallback;
use Wikimedia\Stats\StatsFactory;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\WrappedString;
 
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 $srvCache;
    private $statsFactory;
    private $maxageVersioned;
    private $maxageUnversioned;
 
    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->maxageVersioned = $params['maxageVersioned'] ?? 30 * 24 * 60 * 60;
        $this->maxageUnversioned = $params['maxageUnversioned'] ?? 5 * 60;
 
        $this->config = $config;
        $this->logger = $logger ?: new NullLogger();
 
        $services = MediaWikiServices::getInstance();
        $this->hookContainer = $services->getHookContainer();
 
        $this->srvCache = $services->getLocalServerObjectCache();
        $this->statsFactory = $services->getStatsFactory();
 
        // Add 'local' source first
        $this->addSource( 'local', $params['loadScript'] ?? '/load.php' );
 
        // 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 {
        $extRegistry = ExtensionRegistry::getInstance();
        $testModules = $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 );
            }
        }
 
        WikiModule::preloadTitleInfo( $context, $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 = MediaWikiServices::getInstance()
                    ->getObjectCacheFactory()->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 = [];
        foreach ( $moduleNames as $module ) {
            try {
                $hash = $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,
                    ]
                );
                $hash = '';
            }
            $hashes[] = $hash;
        }
        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();
 
        $this->errors = [];
        $responseTime = $this->measureResponseTime();
        ProfilingContext::singleton()->init( MW_ENTRY_POINT, 'respond' );
 
        // 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)
        }
 
        if ( $context->isSourceMap() ) {
            // In source map mode, a version mismatch should be a 404
            if ( $context->getVersion() !== null && $versionHash !== $context->getVersion() ) {
                ob_end_clean();
                $this->sendSourceMapVersionMismatch( $versionHash );
                return;
            }
            // No source maps for images, only=styles requests, or debug mode
            if ( $context->getImage()
                || $context->getOnly() === 'styles'
                || $context->getDebug()
            ) {
                ob_end_clean();
                $this->sendSourceMapTypeNotImplemented();
                return;
            }
        }
        // Emit source map header if supported (inverse of the above check)
        if ( $this->config->get( MainConfigNames::ResourceLoaderEnableSourceMapLinks )
            && !$context->getImageObj()
            && !$context->isSourceMap()
            && $context->shouldIncludeScripts()
            && !$context->getDebug()
        ) {
            $this->extraHeaders[] = 'SourceMap: ' . $this->getSourceMapUrl( $context, $versionHash );
        }
 
        // 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;
            }
        }
 
        $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";
                // Append the error info to the response
                // We used to prepend it, but that would corrupt the source map
                $response .= $errorResponse;
            } else {
                // For styles we can still prepend
                $response = $errorResponse . $response;
            }
        }
 
        echo $response;
    }
 
    protected function measureResponseTime() {
        $statStart = $_SERVER['REQUEST_TIME_FLOAT'];
        return new ScopedCallback( function () use ( $statStart ) {
            $statTiming = microtime( true ) - $statStart;
 
            $this->statsFactory->getTiming( 'resourceloader_response_time_seconds' )
                ->copyToStatsdAt( 'resourceloader.responseTime' )
                ->observe( 1000 * $statTiming );
        } );
    }
 
    protected function sendResponseHeaders(
        Context $context, $etag, $errors, array $extra = []
    ): void {
        HeaderCallback::warnIfHeadersSent();
 
        if ( $errors ) {
            $maxage = self::MAXAGE_RECOVER;
        } elseif (
            $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).
            $this->logger->debug( 'Client and server registry version out of sync' );
            $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 different 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->isSourceMap() ) {
            header( 'Content-Type: application/json' );
        } 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' );
        } else {
            // T132418: When a resource expires mid-way a browsing session, prefer to renew it in
            // the background instead of blocking the next page load (eg. startup module, or CSS).
            $staleDirective = ( $maxage > self::MAXAGE_RECOVER
                ? ", stale-while-revalidate=" . min( 60, intval( $maxage / 2 ) )
                : ''
            );
            header( "Cache-Control: public, max-age=$maxage, s-maxage=$maxage" . $staleDirective );
            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;
    }
 
    private function getSourceMapUrl( Context $context, $version ) {
        return $this->createLoaderURL( 'local', $context, [
            'sourcemap' => '1',
            'version' => $version
        ] );
    }
 
    private function sendSourceMapVersionMismatch( $currentVersion ) {
        HttpStatus::header( 404 );
        header( 'Content-Type: text/plain; charset=utf-8' );
        header( 'X-Content-Type-Options: nosniff' );
        echo "Can't deliver a source map for the requested version " .
            "since the version is now '$currentVersion'\n";
    }
 
    private function sendSourceMapTypeNotImplemented() {
        HttpStatus::header( 404 );
        header( 'Content-Type: text/plain; charset=utf-8' );
        header( 'X-Content-Type-Options: nosniff' );
        echo "Can't make a source map for this content type\n";
    }
 
    public static function makeComment( $text ) {
        $encText = str_replace( '*/', '* /', $text );
        return "/*\n$encText\n*/\n";
    }
 
    protected static function formatExceptionNoComment( Throwable $e ) {
        if ( !MWExceptionRenderer::shouldShowExceptionDetails() ) {
            return MWExceptionHandler::getPublicLogMessage( $e );
        }
 
        // Like MWExceptionHandler::getLogMessage but without $url and $id.
        // - Long load.php URL would push the actual error message off-screen into
        //   scroll overflow in browser devtools.
        // - reqId is redundant with X-Request-Id header, plus usually no need to
        //   correlate the reqId since the backtrace is already included below.
        $type = get_class( $e );
        $message = $e->getMessage();
 
        return "$type: $message" .
            "\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();
        $debug = (bool)$context->getDebug();
        if ( $context->isSourceMap() && count( $modules ) > 1 ) {
            $indexMap = new IndexMap;
        } else {
            $indexMap = null;
        }
 
        $out = '';
        foreach ( $modules as $name => $module ) {
            try {
                [ $response, $offset ] = $this->getOneModuleResponse( $context, $name, $module );
                if ( $indexMap ) {
                    $indexMap->addEncodedMap( $response, $offset );
                } else {
                    $out .= $response;
                }
            } 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.impl 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.impl
            if ( $states && !$context->isSourceMap() ) {
                $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: '
                // Silently ignore invalid UTF-8 injected via 'modules' query
                // Don't issue server-side warnings for client errors. (T331641)
                // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
                . @$context->encodeJson( $states );
        }
 
        if ( $indexMap ) {
            return $indexMap->getMap();
        } else {
            return $out;
        }
    }
 
    private function getOneModuleResponse( Context $context, $name, Module $module ) {
        $only = $context->getOnly();
        // 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)
        $shouldCache = !$module->shouldEmbedModule( $context );
        if ( $only === 'styles' ) {
            $minifier = new IdentityMinifierState;
            $this->addOneModuleResponse( $context, $minifier, $name, $module, $this->extraHeaders );
            // NOTE: This is not actually "minified". IdentityMinifierState is a no-op wrapper
            // to ease code reuse. The filter() call below performs CSS minification.
            $styles = $minifier->getMinifiedOutput();
            if ( $context->getDebug() ) {
                return [ $styles, null ];
            }
            return [
                self::filter( 'minify-css', $styles,
                    [ 'cache' => $shouldCache ] ),
                null
            ];
        }
 
        $minifier = new IdentityMinifierState;
        $this->addOneModuleResponse( $context, $minifier, $name, $module, $this->extraHeaders );
        $plainContent = $minifier->getMinifiedOutput();
        if ( $context->getDebug() ) {
            return [ $plainContent, null ];
        }
 
        $isHit = true;
        $callback = function () use ( $context, $name, $module, &$isHit ) {
            $isHit = false;
            if ( $context->isSourceMap() ) {
                $minifier = ( new JavaScriptMapperState )
                    ->outputFile( $this->createLoaderURL( 'local', $context, [
                        'modules' => self::makePackedModulesString( $context->getModules() ),
                        'only' => $context->getOnly()
                    ] ) );
            } else {
                $minifier = new JavaScriptMinifierState;
            }
            // We only need to add one set of headers, and we did that for the identity response
            $discardedHeaders = null;
            $this->addOneModuleResponse( $context, $minifier, $name, $module, $discardedHeaders );
            if ( $context->isSourceMap() ) {
                $sourceMap = $minifier->getRawSourceMap();
                $generated = $minifier->getMinifiedOutput();
                $offset = IndexMapOffset::newFromText( $generated );
                return [ $sourceMap, $offset->toArray() ];
            } else {
                return [ $minifier->getMinifiedOutput(), null ];
            }
        };
 
        if ( $shouldCache ) {
            [ $response, $offsetArray ] = $this->srvCache->getWithSetCallback(
                $this->srvCache->makeGlobalKey(
                    'resourceloader-mapped',
                    self::CACHE_VERSION,
                    $name,
                    $context->isSourceMap() ? '1' : '0',
                    md5( $plainContent )
                ),
                BagOStuff::TTL_DAY,
                $callback
            );
 
            $mapType = $context->isSourceMap() ? 'map-js' : 'minify-js';
            $statsdNamespace = implode( '.', [
                "resourceloader_cache", $mapType, $isHit ? 'hit' : 'miss'
            ] );
            $this->statsFactory->getCounter( 'resourceloader_cache_total' )
                ->setLabel( 'type', $mapType )
                ->setLabel( 'status', $isHit ? 'hit' : 'miss' )
                ->copyToStatsdAt( [ $statsdNamespace ] )
                ->increment();
        } else {
            [ $response, $offsetArray ] = $callback();
        }
        $offset = $offsetArray ? IndexMapOffset::newFromArray( $offsetArray ) : null;
 
        return [ $response, $offset ];
    }
 
    private function addOneModuleResponse(
        Context $context, MinifierState $minifier, $name, Module $module, &$headers
    ) {
        $only = $context->getOnly();
        $debug = (bool)$context->getDebug();
        $content = $module->getModuleContent( $context );
        $version = $module->getVersionHash( $context );
 
        if ( $headers !== null && isset( $content['headers'] ) ) {
            $headers = array_merge( $headers, $content['headers'] );
        }
 
        // Append output
        switch ( $only ) {
            case 'scripts':
                $scripts = $content['scripts'];
                if ( !is_array( $scripts ) ) {
                    // Formerly scripts was usually a string, but now it is
                    // normalized to an array by buildContent().
                    throw new InvalidArgumentException( 'scripts must be an array' );
                }
                if ( isset( $scripts['plainScripts'] ) ) {
                    // Add plain scripts
                    $this->addPlainScripts( $minifier, $name, $scripts['plainScripts'] );
                } elseif ( isset( $scripts['files'] ) ) {
                    // Add implement call if any
                    $this->addImplementScript(
                        $minifier,
                        $name,
                        $version,
                        $scripts,
                        [],
                        null,
                        [],
                        $content['deprecationWarning'] ?? null
                    );
                }
                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.
                if ( isset( $styles['css'] ) ) {
                    $minifier->addOutput( implode( '', $styles['css'] ) );
                }
                break;
            default:
                $scripts = $content['scripts'] ?? '';
                if ( ( $name === 'site' || $name === 'user' )
                    && isset( $scripts['plainScripts'] )
                ) {
                    // Legacy scripts that run in the global scope without a closure.
                    // mw.loader.impl 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.
                    $scripts = self::concatenatePlainScripts( $scripts['plainScripts'] );
                    if ( !$debug ) {
                        $scripts = self::filter( 'minify-js', $scripts ); // T107377
                    }
                }
                $this->addImplementScript(
                    $minifier,
                    $name,
                    $version,
                    $scripts,
                    $content['styles'] ?? [],
                    isset( $content['messagesBlob'] ) ? new HtmlJsCode( $content['messagesBlob'] ) : null,
                    $content['templates'] ?? [],
                    $content['deprecationWarning'] ?? null
                );
                break;
        }
        $minifier->ensureNewline();
    }
 
    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 function addImplementScript( MinifierState $minifier,
        $moduleName, $version, $scripts, $styles, $messages, $templates, $deprecationWarning
    ) {
        $implementKey = "$moduleName@$version";
        // Plain functions are used instead of arrow functions to avoid
        // defeating lazy compilation on Chrome. (T343407)
        $minifier->addOutput( "mw.loader.impl(function(){return[" .
            Html::encodeJsVar( $implementKey ) . "," );
 
        // Scripts
        if ( is_string( $scripts ) ) {
            // user/site script
            $minifier->addOutput( Html::encodeJsVar( $scripts ) );
        } elseif ( is_array( $scripts ) ) {
            if ( isset( $scripts['files'] ) ) {
                $minifier->addOutput(
                    "{\"main\":" .
                    Html::encodeJsVar( $scripts['main'] ) .
                    ",\"files\":" );
                $this->addFiles( $minifier, $moduleName, $scripts['files'] );
                $minifier->addOutput( "}" );
            } elseif ( isset( $scripts['plainScripts'] ) ) {
                if ( $this->isEmptyFileInfos( $scripts['plainScripts'] ) ) {
                    $minifier->addOutput( 'null' );
                } else {
                    $minifier->addOutput( "function($,jQuery,require,module){" );
                    $this->addPlainScripts( $minifier, $moduleName, $scripts['plainScripts'] );
                    $minifier->addOutput( "}" );
                }
            } elseif ( $scripts === [] || isset( $scripts[0] ) ) {
                // Array of URLs
                $minifier->addOutput( Html::encodeJsVar( $scripts ) );
            } else {
                throw new InvalidArgumentException( 'Invalid script array: ' .
                    'must contain files, plainScripts or be an array of URLs' );
            }
        } else {
            throw new InvalidArgumentException( 'Script must be a string or array' );
        }
 
        // mw.loader.impl 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.
        $extraArgs = [
            (object)$styles,
            $messages ?? (object)[],
            (object)$templates,
            $deprecationWarning
        ];
        self::trimArray( $extraArgs );
        foreach ( $extraArgs as $arg ) {
            $minifier->addOutput( ',' . Html::encodeJsVar( $arg ) );
        }
        $minifier->addOutput( "];});" );
    }
 
    private function addFiles( MinifierState $minifier, $moduleName, $files ) {
        $first = true;
        $minifier->addOutput( "{" );
        foreach ( $files as $fileName => $file ) {
            if ( $first ) {
                $first = false;
            } else {
                $minifier->addOutput( "," );
            }
            $minifier->addOutput( Html::encodeJsVar( $fileName ) . ':' );
            $this->addFileContent( $minifier, $moduleName, 'packageFile', $fileName, $file );
        }
        $minifier->addOutput( "}" );
    }
 
    private function addFileContent( MinifierState $minifier,
        $moduleName, $sourceType, $sourceIndex, array $file
    ) {
        $isScript = ( $file['type'] ?? 'script' ) === 'script';
        $filePath = $file['filePath'] ?? $file['virtualFilePath'] ?? null;
        if ( $filePath !== null && $filePath->getRemoteBasePath() !== null ) {
            $url = $filePath->getRemotePath();
        } else {
            $ext = $isScript ? 'js' : 'json';
            $scriptPath = $this->config->has( MainConfigNames::ScriptPath )
                ? $this->config->get( MainConfigNames::ScriptPath ) : '';
            $url = "$scriptPath/virtual-resource/$moduleName-$sourceType-$sourceIndex.$ext";
        }
        $content = $file['content'];
        if ( $isScript ) {
            if ( $sourceType === 'packageFile' ) {
                // 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)
                $minifier->addOutput( "function(require,module,exports){" );
                $minifier->addSourceFile( $url, $content, true );
                $minifier->ensureNewline();
                $minifier->addOutput( "}" );
            } else {
                $minifier->addSourceFile( $url, $content, true );
                $minifier->ensureNewline();
            }
        } else {
            $content = Html::encodeJsVar( $content, true );
            $minifier->addSourceFile( $url, $content, true );
        }
    }
 
    private static function concatenatePlainScripts( $plainScripts ) {
        $s = '';
        foreach ( $plainScripts as $script ) {
            // Make the script safe to concatenate by making sure there is at least one
            // trailing new line at the end of the content (T29054, T162719)
            $s .= self::ensureNewline( $script['content'] );
        }
        return $s;
    }
 
    private function addPlainScripts( MinifierState $minifier, $moduleName, $plainScripts ) {
        foreach ( $plainScripts as $index => $file ) {
            $this->addFileContent( $minifier, $moduleName, 'script', $index, $file );
        }
    }
 
    private function isEmptyFileInfos( $infos ) {
        $len = 0;
        foreach ( $infos as $info ) {
            $len += strlen( $info['content'] ?? '' );
        }
        return $len === 0;
    }
 
    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;
    }
 
    private 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('
            // Silently ignore invalid UTF-8 injected via 'modules' query
            // Don't issue server-side warnings for client errors. (T331641)
            // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
            . @$context->encodeJson( $states )
            . ');';
    }
 
    private static function isEmptyObject( stdClass $obj ) {
        foreach ( $obj as $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 HtmlJsCode && $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];
                    }
                }
            }
            self::trimArray( $module );
        }
 
        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 );
        return new WrappedString(
            Html::inlineScript( $js ),
            "<script>(RLQ=window.RLQ||[]).push(function(){",
            '});</script>'
        );
    }
 
    public static function makeConfigSetScript( array $configuration ) {
        $json = self::encodeJsonForScript( $configuration );
        if ( $json === false ) {
            $e = new LogicException(
                '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;
        }
        foreach ( $extraQuery as $name => $value ) {
            $query[$name] = $value;
        }
 
        // 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 RuntimeException( 'MediaWiki requires the less.php parser' );
        }
 
        $importDirs[] = "$IP/resources/src/mediawiki.less";
 
        $parser = new Less_Parser;
        $parser->ModifyVars( $vars );
        $parser->SetOption( 'relativeUrls', false );
        $parser->SetOption( 'math', 'always' );
 
        // SetImportDirs expects an array like [ 'path1' => '', 'path2' => '' ]
        $formattedImportDirs = array_fill_keys( $importDirs, '' );
        // Add a callback to the import dirs array for path remapping
        $formattedImportDirs[] = static function ( $path ) {
            global $IP;
            $importMap = [
                '@wikimedia/codex-icons/' => "$IP/resources/lib/codex-icons/",
                'mediawiki.skin.codex-design-tokens/' => "$IP/resources/lib/codex-design-tokens/",
                '@wikimedia/codex-design-tokens/' =>  static function ( $unused_path ) {
                    throw new RuntimeException(
                        'Importing from @wikimedia/codex-design-tokens is not supported. ' .
                        "To use the Codex tokens, use `@import 'mediawiki.skin.variables.less';` instead."
                    );
                }
            ];
            foreach ( $importMap as $importPath => $substPath ) {
                if ( str_starts_with( $path, $importPath ) ) {
                    $restOfPath = substr( $path, strlen( $importPath ) );
                    if ( is_callable( $substPath ) ) {
                        $resolvedPath = call_user_func( $substPath, $restOfPath );
                    } else {
                        $filePath = $substPath . $restOfPath;
 
                        $resolvedPath = null;
                        if ( file_exists( $filePath ) ) {
                            $resolvedPath = $filePath;
                        } elseif ( file_exists( "$filePath.less" ) ) {
                            $resolvedPath = "$filePath.less";
                        }
                    }
 
                    if ( $resolvedPath !== null ) {
                        return [
                            Less_Environment::normalizePath( $resolvedPath ),
                            Less_Environment::normalizePath( dirname( $path ) )
                        ];
                    } else {
                        break;
                    }
                }
            }
            return [ null, null ];
        };
        $parser->SetImportDirs( $formattedImportDirs );
 
        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;
        }
 
        $statsFactory = MediaWikiServices::getInstance()->getStatsFactory();
        $cache = MediaWikiServices::getInstance()->getObjectCacheFactory()
            ->getLocalServerInstance( CACHE_ANYTHING );
 
        $key = $cache->makeGlobalKey(
            'resourceloader-filter',
            $filter,
            self::CACHE_VERSION,
            md5( $data )
        );
 
        $status = 'hit';
        $incKey = "resourceloader_cache.$filter.$status";
        $result = $cache->getWithSetCallback(
            $key,
            BagOStuff::TTL_DAY,
            static function () use ( $filter, $data, &$incKey, &$status ) {
                $status = 'miss';
                $incKey = "resourceloader_cache.$filter.$status";
                return self::applyFilter( $filter, $data );
            }
        );
        $statsFactory->getCounter( 'resourceloader_cache_total' )
            ->setLabel( 'type', $filter )
            ->setLabel( 'status', $status )
            ->copyToStatsdAt( [ $incKey ] )
            ->increment();
 
        // Use $data on cache failure
        return $result ?? $data;
    }
 
    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 {
        $services = MediaWikiServices::getInstance();
        // Namespace related preparation
        // - wgNamespaceIds: Key-value pairs of all localized, canonical and aliases for namespaces.
        // - wgCaseSensitiveNamespaces: Array of namespaces that are case-sensitive.
        $contLang = $services->getContentLanguage();
        $namespaceIds = $contLang->getNamespaceIds();
        $caseSensitiveNamespaces = [];
        $nsInfo = $services->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 ),
        ];
 
        ( new HookRunner( $services->getHookContainer() ) )
            ->onResourceLoaderGetConfigVars( $vars, $skin, $conf );
 
        return $vars;
    }
 
    public function getErrors() {
        return $this->errors;
    }
}