master/php/ServiceWiring_8php_source.html

<?php

use GuzzleHttp\Client;

use GuzzleHttp\Psr7\HttpFactory;

use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;

use MediaWiki\Actions\ActionFactory;

use MediaWiki\Auth\AuthManager;

use MediaWiki\Auth\Throttler;

use MediaWiki\Block\AutoblockExemptionList;

use MediaWiki\Block\BlockActionInfo;

use MediaWiki\Block\BlockErrorFormatter;

use MediaWiki\Block\BlockManager;

use MediaWiki\Block\BlockPermissionCheckerFactory;

use MediaWiki\Block\BlockRestrictionStore;

use MediaWiki\Block\BlockRestrictionStoreFactory;

use MediaWiki\Block\BlockTargetFactory;

use MediaWiki\Block\BlockUserFactory;

use MediaWiki\Block\BlockUtils;

use MediaWiki\Block\BlockUtilsFactory;

use MediaWiki\Block\CrossWikiBlockTargetFactory;

use MediaWiki\Block\DatabaseBlock;

use MediaWiki\Block\DatabaseBlockStore;

use MediaWiki\Block\DatabaseBlockStoreFactory;

use MediaWiki\Block\HideUserUtils;

use MediaWiki\Block\UnblockUserFactory;

use MediaWiki\Block\UserBlockCommandFactory;

use MediaWiki\Cache\BacklinkCache;

use MediaWiki\Cache\BacklinkCacheFactory;

use MediaWiki\Cache\GenderCache;

use MediaWiki\Cache\HTMLCacheUpdater;

use MediaWiki\Cache\UserCache;

use MediaWiki\Category\TrackingCategories;

use MediaWiki\ChangeTags\ChangeTagsFormatter;

use MediaWiki\ChangeTags\ChangeTagsStore;

use MediaWiki\ChangeTags\ChangeTagsStoreFactory;

use MediaWiki\Collation\CollationFactory;

use MediaWiki\CommentFormatter\CommentFormatter;

use MediaWiki\CommentFormatter\CommentParserFactory;

use MediaWiki\CommentFormatter\RowCommentFormatter;

use MediaWiki\CommentStore\CommentStore;

use MediaWiki\Config\Config;

use MediaWiki\Config\ConfigException;

use MediaWiki\Config\ConfigFactory;

use MediaWiki\Config\ConfigRepository;

use MediaWiki\Config\ServiceOptions;

use MediaWiki\Content\CodeHighlighter;

use MediaWiki\Content\ContentHandlerFactory;

use MediaWiki\Content\ContentJsonCodec;

use MediaWiki\Content\IContentHandlerFactory;

use MediaWiki\Content\Renderer\ContentRenderer;

use MediaWiki\Content\Transform\ContentTransformer;

use MediaWiki\Context\RequestContext;

use MediaWiki\DAO\WikiAwareEntity;

use MediaWiki\DB\MWLBConfig;

use MediaWiki\DB\MWLBFactory;

use MediaWiki\DB\WriteDuplicator;

use MediaWiki\Deferred\DeferredUpdates;

use MediaWiki\Deferred\LinksUpdate\ExternalLinksTable;

use MediaWiki\DomainEvent\DomainEventDispatcher;

use MediaWiki\DomainEvent\DomainEventSource;

use MediaWiki\DomainEvent\EventDispatchEngine;

use MediaWiki\Edit\ParsoidOutputStash;

use MediaWiki\Edit\SimpleParsoidOutputStash;

use MediaWiki\EditPage\Constraint\EditConstraintFactory;

use MediaWiki\EditPage\IntroMessageBuilder;

use MediaWiki\EditPage\PageEditingHelper;

use MediaWiki\EditPage\PreloadedContentBuilder;

use MediaWiki\EditPage\SpamChecker;

use MediaWiki\EditPage\TextboxBuilder;

use MediaWiki\Export\WikiExporterFactory;

use MediaWiki\ExternalStore\ExternalStoreAccess;

use MediaWiki\ExternalStore\ExternalStoreFactory;

use MediaWiki\FeatureShutdown;

use MediaWiki\FileBackend\FileBackendGroup;

use MediaWiki\FileBackend\LockManager\LockManagerGroupFactory;

use MediaWiki\FileRepo\RepoGroup;

use MediaWiki\HookContainer\HookContainer;

use MediaWiki\HookContainer\HookRunner;

use MediaWiki\HookContainer\StaticHookRegistry;

use MediaWiki\Http\HttpRequestFactory;

use MediaWiki\Http\Telemetry;

use MediaWiki\Import\ImportableOldRevisionImporter;

use MediaWiki\Import\ImportableUploadRevisionImporter;

use MediaWiki\Import\OldRevisionImporter;

use MediaWiki\Import\UploadRevisionImporter;

use MediaWiki\Import\WikiImporterFactory;

use MediaWiki\Installer\Pingback;

use MediaWiki\Interwiki\ClassicInterwikiLookup;

use MediaWiki\Interwiki\InterwikiLookup;

use MediaWiki\JobQueue\JobFactory;

use MediaWiki\JobQueue\JobQueueGroup;

use MediaWiki\JobQueue\JobQueueGroupFactory;

use MediaWiki\JobQueue\JobRunner;

use MediaWiki\Json\JsonCodec;

use MediaWiki\Json\JwtCodec;

use MediaWiki\Json\RsaJwtCodec;

use MediaWiki\Language\FormatterFactory;

use MediaWiki\Language\Language;

use MediaWiki\Language\LanguageCode;

use MediaWiki\Language\LanguageConverterFactory;

use MediaWiki\Language\LanguageEventIngress;

use MediaWiki\Language\LanguageFactory;

use MediaWiki\Language\LanguageFallback;

use MediaWiki\Language\LanguageNameSearch;

use MediaWiki\Language\LanguageNameUtils;

use MediaWiki\Language\LazyLocalizationContext;

use MediaWiki\Language\LeximorphFactory;

use MediaWiki\Language\LocalisationCache;

use MediaWiki\Language\MessageCache;

use MediaWiki\Language\MessageParser;

use MediaWiki\Linker\LinkRenderer;

use MediaWiki\Linker\LinkRendererFactory;

use MediaWiki\Linker\LinksMigration;

use MediaWiki\Linker\LinkTargetLookup;

use MediaWiki\Linker\LinkTargetStore;

use MediaWiki\Linker\UserLinkRenderer;

use MediaWiki\Logger\LoggerFactory;

use MediaWiki\Logging\LogFormatterFactory;

use MediaWiki\Mail\ConfirmEmail\ConfirmEmailBuilderFactory;

use MediaWiki\Mail\ConfirmEmail\ConfirmEmailSender;

use MediaWiki\Mail\ConfirmEmail\EmailConfirmationBannerHandler;

use MediaWiki\Mail\Emailer;

use MediaWiki\Mail\EmailUser;

use MediaWiki\Mail\EmailUserFactory;

use MediaWiki\Mail\IEmailer;

use MediaWiki\Mail\NotificationEmail\NotificationEmailSender;

use MediaWiki\MainConfigNames;

use MediaWiki\Media\DjVuImage;

use MediaWiki\Media\MediaHandlerFactory;

use MediaWiki\MediaWikiServices;

use MediaWiki\Message\Message;

use MediaWiki\Message\MessageFormatterFactory;

use MediaWiki\Notification\MiddlewareChain;

use MediaWiki\Notification\NotificationService;

use MediaWiki\ObjectCache\ObjectCacheFactory;

use MediaWiki\OutputTransform\DefaultOutputPipelineFactory;

use MediaWiki\OutputTransform\OutputTransformPipeline;

use MediaWiki\Page\ContentModelChangeFactory;

use MediaWiki\Page\DeletePageFactory;

use MediaWiki\Page\File\BadFileLookup;

use MediaWiki\Page\LinkBatchFactory;

use MediaWiki\Page\LinkCache;

use MediaWiki\Page\MergeHistoryFactory;

use MediaWiki\Page\MovePageFactory;

use MediaWiki\Page\PageCommandFactory;

use MediaWiki\Page\PageProps;

use MediaWiki\Page\PageStore;

use MediaWiki\Page\PageStoreFactory;

use MediaWiki\Page\ParserOutputAccess;

use MediaWiki\Page\RedirectLookup;

use MediaWiki\Page\RedirectStore;

use MediaWiki\Page\RollbackPageFactory;

use MediaWiki\Page\UndeletePageFactory;

use MediaWiki\Page\WikiPageFactory;

use MediaWiki\PageEdit\PageEditFactory;

use MediaWiki\Parser\DateFormatterFactory;

use MediaWiki\Parser\MagicWordFactory;

use MediaWiki\Parser\Parser;

use MediaWiki\Parser\ParserCache;

use MediaWiki\Parser\ParserCacheFactory;

use MediaWiki\Parser\ParserCoreTagHooks;

use MediaWiki\Parser\ParserFactory;

use MediaWiki\Parser\ParserObserver;

use MediaWiki\Parser\Parsoid\Config\DataAccess as MWDataAccess;

use MediaWiki\Parser\Parsoid\Config\PageConfigFactory as MWPageConfigFactory;

use MediaWiki\Parser\Parsoid\Config\SiteConfig as MWSiteConfig;

use MediaWiki\Parser\Parsoid\HtmlTransformFactory;

use MediaWiki\Parser\Parsoid\LintErrorChecker;

use MediaWiki\Parser\Parsoid\ParsoidParserFactory;

use MediaWiki\Password\PasswordFactory;

use MediaWiki\Permissions\GrantsInfo;

use MediaWiki\Permissions\GrantsLocalization;

use MediaWiki\Permissions\GroupPermissionsLookup;

use MediaWiki\Permissions\PermissionManager;

use MediaWiki\Permissions\RateLimiter;

use MediaWiki\Permissions\RestrictionStore;

use MediaWiki\PoolCounter\PoolCounterFactory;

use MediaWiki\Preferences\DefaultPreferencesFactory;

use MediaWiki\Preferences\PreferencesFactory;

use MediaWiki\Preferences\SignatureValidator;

use MediaWiki\Preferences\SignatureValidatorFactory;

use MediaWiki\RecentChanges\ChangesListQuery\ChangesListQueryFactory;

use MediaWiki\RecentChanges\ChangeTools\ChangeToolsFactory;

use MediaWiki\RecentChanges\ChangeTrackingEventIngress;

use MediaWiki\RecentChanges\PatrolManager;

use MediaWiki\RecentChanges\RecentChangeFactory;

use MediaWiki\RecentChanges\RecentChangeLookup;

use MediaWiki\RecentChanges\RecentChangeRCFeedNotifier;

use MediaWiki\RecentChanges\RecentChangeStore;

use MediaWiki\Registration\ExtensionRegistry;

use MediaWiki\RenameUser\RenameUserFactory;

use MediaWiki\Request\ProxyLookup;

use MediaWiki\Request\WebRequest;

use MediaWiki\ResourceLoader\DependencyStore;

use MediaWiki\ResourceLoader\MessageBlobStore;

use MediaWiki\ResourceLoader\ResourceLoader;

use MediaWiki\Rest\Handler\Helper\PageRestHelperFactory;

use MediaWiki\Revision\ArchivedRevisionLookup;

use MediaWiki\Revision\MainSlotRoleHandler;

use MediaWiki\Revision\RevisionFactory;

use MediaWiki\Revision\RevisionLookup;

use MediaWiki\Revision\RevisionRenderer;

use MediaWiki\Revision\RevisionStore;

use MediaWiki\Revision\RevisionStoreFactory;

use MediaWiki\Revision\SlotRecord;

use MediaWiki\Revision\SlotRoleRegistry;

use MediaWiki\Search\SearchEngineConfig;

use MediaWiki\Search\SearchEngineFactory;

use MediaWiki\Search\SearchEventIngress;

use MediaWiki\Search\SearchResultThumbnailProvider;

use MediaWiki\Search\TitleMatcher;

use MediaWiki\Session\MultiBackendSessionStore;

use MediaWiki\Session\SessionManager;

use MediaWiki\Session\SessionManagerInterface;

use MediaWiki\Session\SessionStore;

use MediaWiki\Session\SingleBackendSessionStore;

use MediaWiki\Settings\Config\ConfigSchema;

use MediaWiki\Settings\SettingsBuilder;

use MediaWiki\ShadowPage\ShadowPageLoader;

use MediaWiki\Shell\CommandFactory;

use MediaWiki\Shell\ShellboxClientFactory;

use MediaWiki\Site\CachingSiteStore;

use MediaWiki\Site\DBSiteStore;

use MediaWiki\Site\SiteLookup;

use MediaWiki\Site\SiteStore;

use MediaWiki\Skin\SkinApi;

use MediaWiki\Skin\SkinAuthenticationPopup;

use MediaWiki\Skin\SkinFactory;

use MediaWiki\Skin\SkinFallback;

use MediaWiki\SpecialPage\SpecialPageFactory;

use MediaWiki\Storage\BlobStore;

use MediaWiki\Storage\BlobStoreFactory;

use MediaWiki\Storage\EditResultCache;

use MediaWiki\Storage\NameTableStore;

use MediaWiki\Storage\NameTableStoreFactory;

use MediaWiki\Storage\PageEditStash;

use MediaWiki\Storage\PageUpdaterFactory;

use MediaWiki\Storage\RevertedTagUpdateManager;

use MediaWiki\Storage\SqlBlobStore;

use MediaWiki\Telemetry\MediaWikiPropagator;

use MediaWiki\Tidy\RemexDriver;

use MediaWiki\Tidy\TidyDriverBase;

use MediaWiki\Title\NamespaceInfo;

use MediaWiki\Title\TitleFactory;

use MediaWiki\Title\TitleFormatter;

use MediaWiki\Title\TitleParser;

use MediaWiki\Upload\SVGCSSChecker;

use MediaWiki\Upload\UploadVerification;

use MediaWiki\User\ActorMigration;

use MediaWiki\User\ActorNormalization;

use MediaWiki\User\ActorStore;

use MediaWiki\User\ActorStoreFactory;

use MediaWiki\User\BotPasswordStore;

use MediaWiki\User\CentralId\CentralIdLookup;

use MediaWiki\User\CentralId\CentralIdLookupFactory;

use MediaWiki\User\MultiFormatUserIdentityLookup;

use MediaWiki\User\Options\ConditionalDefaultsLookup;

use MediaWiki\User\Options\DefaultOptionsLookup;

use MediaWiki\User\Options\StaticUserOptionsLookup;

use MediaWiki\User\Options\UserOptionsLookup;

use MediaWiki\User\Options\UserOptionsManager;

use MediaWiki\User\PasswordReset;

use MediaWiki\User\Registration\LocalUserRegistrationProvider;

use MediaWiki\User\Registration\UserRegistrationLookup;

use MediaWiki\User\RestrictedUserGroupCheckerFactory;

use MediaWiki\User\RestrictedUserGroupConfigReader;

use MediaWiki\User\TalkPageNotificationManager;

use MediaWiki\User\TempUser\RealTempUserConfig;

use MediaWiki\User\TempUser\TempUserCreator;

use MediaWiki\User\TempUser\TempUserDetailsLookup;

use MediaWiki\User\UserEditTracker;

use MediaWiki\User\UserFactory;

use MediaWiki\User\UserGroupAssignmentService;

use MediaWiki\User\UserGroupManager;

use MediaWiki\User\UserGroupManagerFactory;

use MediaWiki\User\UserIdentity;

use MediaWiki\User\UserIdentityLookup;

use MediaWiki\User\UserIdentityUtils;

use MediaWiki\User\UserNamePrefixSearch;

use MediaWiki\User\UserNameUtils;

use MediaWiki\User\UserRequirementsConditionChecker;

use MediaWiki\User\UserRequirementsConditionCheckerFactory;

use MediaWiki\User\UserRequirementsConditionValidator;

use MediaWiki\Utils\SBOMGenerator;

use MediaWiki\Utils\UrlUtils;

use MediaWiki\Watchlist\NoWriteWatchedItemStore;

use MediaWiki\Watchlist\WatchedItemQueryService;

use MediaWiki\Watchlist\WatchedItemStore;

use MediaWiki\Watchlist\WatchlistLabelStore;

use MediaWiki\Watchlist\WatchlistManager;

use MediaWiki\WikiMap\WikiMap;

use Psr\Http\Client\ClientInterface;

use Wikimedia\EventRelayer\EventRelayerGroup;

use Wikimedia\FileBackend\FSFile\TempFSFileFactory;

use Wikimedia\LockManager\DatabaseLockManager;

use Wikimedia\Message\IMessageFormatterFactory;

use Wikimedia\Mime\MimeAnalyzer;

use Wikimedia\ObjectCache\BagOStuff;

use Wikimedia\ObjectCache\EmptyBagOStuff;

use Wikimedia\ObjectCache\HashBagOStuff;

use Wikimedia\ObjectCache\WANObjectCache;

use Wikimedia\ObjectFactory\ObjectFactory;

use Wikimedia\Parsoid\Config\DataAccess;

use Wikimedia\Parsoid\Parsoid;

use Wikimedia\Rdbms\ChronologyProtector;

use Wikimedia\Rdbms\ConfiguredReadOnlyMode;

use Wikimedia\Rdbms\DatabaseFactory;

use Wikimedia\Rdbms\IConnectionProvider;

use Wikimedia\Rdbms\ReadOnlyMode;

use Wikimedia\RequestTimeout\CriticalSectionProvider;

use Wikimedia\RequestTimeout\RequestTimeout;

use Wikimedia\Stats\IBufferingStatsdDataFactory;

use Wikimedia\Stats\NullStatsdDataFactory;

use Wikimedia\Stats\OutputFormats;

use Wikimedia\Stats\PrefixingStatsdDataFactoryProxy;

use Wikimedia\Stats\StatsCache;

use Wikimedia\Stats\StatsFactory;

use Wikimedia\Telemetry\Clock;

use Wikimedia\Telemetry\CompositePropagator;

use Wikimedia\Telemetry\NoopTracer;

use Wikimedia\Telemetry\OtlpHttpExporter;

use Wikimedia\Telemetry\ProbabilisticSampler;

use Wikimedia\Telemetry\Tracer;

use Wikimedia\Telemetry\TracerInterface;

use Wikimedia\Telemetry\TracerState;

use Wikimedia\Telemetry\W3CTraceContextPropagator;

use Wikimedia\UUID\GlobalIdGenerator;

use Wikimedia\WRStats\BagOStuffStatsStore;

use Wikimedia\WRStats\WRStatsFactory;


// PHP unit does not understand code coverage for this file

// as the @covers annotation cannot cover a specific file

// This is tested in MediaWikiServicesTest::testGetService

// @codeCoverageIgnoreStart


return [

    // NOTE: When adding a service here, don't forget to add a getter function

    // in the MediaWikiServices class. The convenience getter should just call

    // $this->getService( 'FooBarService' ).


    'ActionFactory' => static function ( MediaWikiServices $services ): ActionFactory {

        return new ActionFactory(

            $services->getMainConfig()->get( MainConfigNames::Actions ),

            LoggerFactory::getInstance( 'ActionFactory' ),

            $services->getObjectFactory(),

            $services->getHookContainer(),

            $services->getContentHandlerFactory()

        );

    },


    'ActorMigration' => static function ( MediaWikiServices $services ): ActorMigration {

        return new ActorMigration(

            $services->getActorStoreFactory()

        );

    },


    'ActorNormalization' => static function ( MediaWikiServices $services ): ActorNormalization {

        return $services->getActorStoreFactory()->getActorNormalization();

    },


    'ActorStore' => static function ( MediaWikiServices $services ): ActorStore {

        return $services->getActorStoreFactory()->getActorStore();

    },


    'ActorStoreFactory' => static function ( MediaWikiServices $services ): ActorStoreFactory {

        return new ActorStoreFactory(

            new ServiceOptions( ActorStoreFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getDBLoadBalancerFactory(),

            $services->getUserNameUtils(),

            $services->getTempUserConfig(),

            LoggerFactory::getInstance( 'ActorStore' ),

            $services->getHideUserUtils()

        );

    },


    'ArchivedRevisionLookup' => static function ( MediaWikiServices $services ): ArchivedRevisionLookup {

        return new ArchivedRevisionLookup(

            $services->getConnectionProvider(),

            $services->getRevisionStore()

        );

    },


    'AuthManager' => static function ( MediaWikiServices $services ): AuthManager {

        $authManager = new AuthManager(

            RequestContext::getMain()->getRequest(),

            $services->getMainConfig(),

            $services->getChangeTagsStore(),

            $services->getObjectFactory(),

            $services->getObjectCacheFactory(),

            $services->getHookContainer(),

            $services->getReadOnlyMode(),

            $services->getUserNameUtils(),

            $services->getBlockManager(),

            $services->getWatchlistManager(),

            $services->getDBLoadBalancer(),

            $services->getContentLanguage(),

            $services->getLanguageConverterFactory(),

            $services->getBotPasswordStore(),

            $services->getUserFactory(),

            $services->getUserIdentityLookup(),

            $services->getUserIdentityUtils(),

            $services->getUserOptionsManager(),

            $services->getNotificationService(),

            $services->getSessionManager()

        );

        $authManager->setLogger( LoggerFactory::getInstance( 'authentication' ) );

        $authManager->setAuthEventsLogger( LoggerFactory::getInstance( 'authevents' ) );

        return $authManager;

    },


    'AutoblockExemptionList' => static function ( MediaWikiServices $services ): AutoblockExemptionList {

        $messageFormatterFactory = new MessageFormatterFactory( Message::FORMAT_PLAIN );

        return new AutoblockExemptionList(

            new ServiceOptions(

                AutoblockExemptionList::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig(),

            ),

            LoggerFactory::getInstance( 'AutoblockExemptionList' ),

            $messageFormatterFactory->getTextFormatter(

                $services->getContentLanguageCode()->toString()

            )

        );

    },


    'BacklinkCacheFactory' => static function ( MediaWikiServices $services ): BacklinkCacheFactory {

        return new BacklinkCacheFactory(

            new ServiceOptions(

                BacklinkCache::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getLinksMigration(),

            $services->getMainWANObjectCache(),

            $services->getHookContainer(),

            $services->getConnectionProvider(),

            $services->getRestrictionStore(),

            LoggerFactory::getInstance( 'BacklinkCache' )

        );

    },


    'BadFileLookup' => static function ( MediaWikiServices $services ): BadFileLookup {

        return new BadFileLookup(

            static function () {

                return wfMessage( 'bad_image_list' )->inContentLanguage()->plain();

            },

            $services->getLocalServerObjectCache(),

            $services->getRepoGroup(),

            $services->getTitleParser(),

            $services->getHookContainer()

        );

    },


    'BlobStore' => static function ( MediaWikiServices $services ): BlobStore {

        return $services->getService( '_SqlBlobStore' );

    },


    'BlobStoreFactory' => static function ( MediaWikiServices $services ): BlobStoreFactory {

        return new BlobStoreFactory(

            $services->getDBLoadBalancerFactory(),

            $services->getExternalStoreAccess(),

            $services->getMainWANObjectCache(),

            new ServiceOptions( BlobStoreFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig() )

        );

    },


    'BlockActionInfo' => static function ( MediaWikiServices $services ): BlockActionInfo {

        return new BlockActionInfo( $services->getHookContainer() );

    },


    'BlockErrorFormatter' => static function ( MediaWikiServices $services ): BlockErrorFormatter {

        return $services->getFormatterFactory()->getBlockErrorFormatter(

            new LazyLocalizationContext( RequestContext::getMain( ... ) )

        );

    },


    'BlockManager' => static function ( MediaWikiServices $services ): BlockManager {

        return new BlockManager(

            new ServiceOptions(

                BlockManager::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getUserFactory(),

            $services->getUserIdentityUtils(),

            LoggerFactory::getInstance( 'BlockManager' ),

            $services->getHookContainer(),

            $services->getDatabaseBlockStore(),

            $services->getBlockTargetFactory(),

            $services->getProxyLookup()

        );

    },


    'BlockPermissionCheckerFactory' => static function (

        MediaWikiServices $services

    ): BlockPermissionCheckerFactory {

        return new BlockPermissionCheckerFactory(

            new ServiceOptions(

                BlockPermissionCheckerFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getBlockTargetFactory()

        );

    },


    'BlockRestrictionStore' => static function ( MediaWikiServices $services ): BlockRestrictionStore {

        return $services->getBlockRestrictionStoreFactory()->getBlockRestrictionStore( WikiAwareEntity::LOCAL );

    },


    'BlockRestrictionStoreFactory' => static function ( MediaWikiServices $services ): BlockRestrictionStoreFactory {

        return new BlockRestrictionStoreFactory(

            $services->getDBLoadBalancerFactory()

        );

    },


    'BlockTargetFactory' => static function ( MediaWikiServices $services ): BlockTargetFactory {

        return $services->getCrossWikiBlockTargetFactory()->getFactory();

    },


    'BlockUserFactory' => static function ( MediaWikiServices $services ): BlockUserFactory {

        return $services->getService( '_UserBlockCommandFactory' );

    },


    'BlockUtils' => static function ( MediaWikiServices $services ): BlockUtils {

        return $services->getBlockUtilsFactory()->getBlockUtils();

    },


    'BlockUtilsFactory' => static function ( MediaWikiServices $services ): BlockUtilsFactory {

        return new BlockUtilsFactory(

            $services->getCrossWikiBlockTargetFactory()

        );

    },


    'BotPasswordStore' => static function ( MediaWikiServices $services ): BotPasswordStore {

        return new BotPasswordStore(

            new ServiceOptions(

                BotPasswordStore::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getCentralIdLookup(),

            $services->getDBLoadBalancerFactory()

        );

    },


    'CentralIdLookup' => static function ( MediaWikiServices $services ): CentralIdLookup {

        return $services->getCentralIdLookupFactory()->getLookup();

    },


    'CentralIdLookupFactory' => static function ( MediaWikiServices $services ): CentralIdLookupFactory {

        return new CentralIdLookupFactory(

            new ServiceOptions( CentralIdLookupFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getObjectFactory(),

            $services->getUserIdentityLookup(),

            $services->getUserFactory()

        );

    },


    'ChangesListQueryFactory' => static function ( MediaWikiServices $services ): ChangesListQueryFactory {

        return new ChangesListQueryFactory(

            new ServiceOptions( ChangesListQueryFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getRecentChangeLookup(),

            $services->getWatchedItemStore(),

            $services->getTempUserConfig(),

            $services->getUserFactory(),

            $services->getLinkTargetLookup(),

            $services->getChangeTagsStore(),

            $services->getStatsFactory(),

            $services->getSlotRoleStore(),

            LoggerFactory::getInstance( 'ChangesListQuery' ),

            $services->getConnectionProvider(),

        );

    },


    'ChangeTagDefStore' => static function ( MediaWikiServices $services ): NameTableStore {

        return $services->getNameTableStoreFactory()->getChangeTagDef();

    },


    'ChangeTagsFormatter' => static function ( MediaWikiServices $services ): ChangeTagsFormatter {

        return new ChangeTagsFormatter(

            new ServiceOptions( ChangeTagsFormatter::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getChangeTagsStore(),

            $services->getMainWANObjectCache(),

            $services->getLanguageFactory(),

        );

    },


    'ChangeTagsStore' => static function ( MediaWikiServices $services ): ChangeTagsStore {

        return $services->getChangeTagsStoreFactory()->getChangeTagsStore();

    },


    'ChangeTagsStoreFactory' => static function ( MediaWikiServices $services ): ChangeTagsStoreFactory {

        return new ChangeTagsStoreFactory(

            $services->getConnectionProvider(),

            $services->getNameTableStoreFactory(),

            $services->getMainWANObjectCache(),

            $services->getHookContainer(),

            LoggerFactory::getInstance( 'ChangeTags' ),

            $services->getUserFactory(),

            new ServiceOptions(

                ChangeTagsStore::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            )

        );

    },


    'ChangeToolsFactory' => static function ( MediaWikiServices $services ): ChangeToolsFactory {

        return new ChangeToolsFactory(

            new HookRunner( $services->getHookContainer() ),

            $services->getLinkRenderer(),

        );

    },


    'ChronologyProtector' => static function ( MediaWikiServices $services ): ChronologyProtector {

        $mainConfig = $services->getMainConfig();

        $microStashIsDatabase = $services->getObjectCacheFactory()->isDatabaseId(

            $mainConfig->get( MainConfigNames::MicroStashType )

        );

        $cpStash = $microStashIsDatabase

            ? new EmptyBagOStuff()

            : $services->getMicroStash();


        $chronologyProtector = new ChronologyProtector(

            $cpStash,

            $mainConfig->get( MainConfigNames::ChronologyProtectorSecret ),

            MW_ENTRY_POINT === 'cli',

            LoggerFactory::getInstance( 'rdbms' )

        );


        // Use the global WebRequest singleton. The main reason for using this

        // is to call WebRequest::getIP() which is non-trivial to reproduce statically

        // because it needs $wgUsePrivateIPs, as well as ProxyLookup and HookRunner services.

        // TODO: Create a static version of WebRequest::getIP that accepts these three

        // as dependencies, and then call that here. The other uses of $req below can

        // trivially use $_COOKIES, $_GET and $_SERVER instead.

        $req = RequestContext::getMain()->getRequest();


        // Set user IP/agent information for agent session consistency purposes

        $reqStart = (int)( $_SERVER['REQUEST_TIME_FLOAT'] ?? time() );

        $cpPosInfo = ChronologyProtector::getCPInfoFromCookieValue(

        // The cookie has no prefix and is set by MediaWiki::preOutputCommit()

            $req->getCookie( 'cpPosIndex', '' ),

            // Mitigate broken client-side cookie expiration handling (T190082)

            $reqStart - ChronologyProtector::POSITION_COOKIE_TTL

        );

        $chronologyProtector->setRequestInfo( [

            'IPAddress' => $req->getIP(),

            'UserAgent' => $req->getHeader( 'User-Agent' ),

            'ChronologyPositionIndex' => $req->getInt( 'cpPosIndex', $cpPosInfo['index'] ),

            'ChronologyClientId' => $cpPosInfo['clientId'] ?? null,

        ] );

        return $chronologyProtector;

    },


    'CodeHighlighter' => static function ( MediaWikiServices $services ): CodeHighlighter {

        return new CodeHighlighter(

            $services->getObjectFactory(),

            ExtensionRegistry::getInstance()->getAttribute( 'CodeHighlightProviders' ),

        );

    },


    'CollationFactory' => static function ( MediaWikiServices $services ): CollationFactory {

        return new CollationFactory(

            new ServiceOptions(

                CollationFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getObjectFactory(),

            $services->getHookContainer()

        );

    },


    'CommentFormatter' => static function ( MediaWikiServices $services ): CommentFormatter {

        return new CommentFormatter(

            $services->getCommentParserFactory()

        );

    },


    'CommentParserFactory' => static function ( MediaWikiServices $services ): CommentParserFactory {

        return new CommentParserFactory(

            $services->getLinkRendererFactory()->create( [ 'renderForComment' => true ] ),

            $services->getLinkBatchFactory(),

            $services->getLinkCache(),

            $services->getRepoGroup(),

            $services->getContentLanguage(),

            $services->getTitleParser(),

            $services->getNamespaceInfo(),

            $services->getHookContainer()

        );

    },


    'CommentStore' => static function ( MediaWikiServices $services ): CommentStore {

        return new CommentStore( $services->getContentLanguage() );

    },


    'ConfigFactory' => static function ( MediaWikiServices $services ): ConfigFactory {

        // Use the bootstrap config to initialize the ConfigFactory.

        $registry = $services->getBootstrapConfig()->get( MainConfigNames::ConfigRegistry );

        $factory = new ConfigFactory();


        foreach ( $registry as $name => $callback ) {

            $factory->register( $name, $callback );

        }

        return $factory;

    },


    'ConfigRepository' => static function ( MediaWikiServices $services ): ConfigRepository {

        return new ConfigRepository( $services->getConfigFactory() );

    },


    'ConfigSchema' => static function ( MediaWikiServices $services ): ConfigSchema {

        $settings = $services->get( '_SettingsBuilder' );

        return $settings->getConfigSchema();

    },


    'ConfiguredReadOnlyMode' => static function ( MediaWikiServices $services ): ConfiguredReadOnlyMode {

        $config = $services->getMainConfig();

        return new ConfiguredReadOnlyMode(

            $config->get( MainConfigNames::ReadOnly ),

            $config->get( MainConfigNames::ReadOnlyFile )

        );

    },


    'ConfirmEmailBuilderFactory' => static function ( MediaWikiServices $services ): ConfirmEmailBuilderFactory {

        return new ConfirmEmailBuilderFactory(

            $services->getLocalServerObjectCache(),

            $services->getUrlUtils()

        );

    },


    'ConfirmEmailSender' => static function ( MediaWikiServices $services ): ConfirmEmailSender {

        return new ConfirmEmailSender(

            new ServiceOptions(

                ConfirmEmailSender::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            new HookRunner( $services->getHookContainer() ),

            $services->getUserFactory(),

            $services->getEmailer(),

            $services->getConfirmEmailBuilderFactory(),

            LoggerFactory::getInstance( 'confirmemail' )

        );

    },


    'ConnectionProvider' => static function ( MediaWikiServices $services ): IConnectionProvider {

        return $services->getDBLoadBalancerFactory();

    },


    'ContentHandlerFactory' => static function ( MediaWikiServices $services ): IContentHandlerFactory {

        $contentHandlerConfig = $services->getMainConfig()->get( MainConfigNames::ContentHandlers );


        return new ContentHandlerFactory(

            $contentHandlerConfig,

            $services->getObjectFactory(),

            $services->getHookContainer(),

            LoggerFactory::getInstance( 'ContentHandler' )

        );

    },


    'ContentJsonCodec' => static function ( MediaWikiServices $services ): ContentJsonCodec {

        return new ContentJsonCodec(

            $services->getContentHandlerFactory(),

        );

    },


    'ContentLanguage' => static function ( MediaWikiServices $services ): Language {

        return $services->getLanguageFactory()->getLanguage(

            $services->getMainConfig()->get( MainConfigNames::LanguageCode ) );

    },


    'ContentLanguageCode' => static function ( MediaWikiServices $services ): LanguageCode {

        return $services->getLanguageFactory()->getLanguageCode(

            $services->getMainConfig()->get( MainConfigNames::LanguageCode ) );

    },


    'ContentModelChangeFactory' => static function ( MediaWikiServices $services ): ContentModelChangeFactory {

        return $services->getService( '_PageCommandFactory' );

    },


    'ContentModelStore' => static function ( MediaWikiServices $services ): NameTableStore {

        return $services->getNameTableStoreFactory()->getContentModels();

    },


    'ContentRenderer' => static function ( MediaWikiServices $services ): ContentRenderer {

        return new ContentRenderer(

            $services->getContentHandlerFactory(),

            $services->getGlobalIdGenerator()

        );

    },


    'ContentTransformer' => static function ( MediaWikiServices $services ): ContentTransformer {

        return new ContentTransformer( $services->getContentHandlerFactory() );

    },


    'CriticalSectionProvider' => static function ( MediaWikiServices $services ): CriticalSectionProvider {

        $config = $services->getMainConfig();

        $limit = MW_ENTRY_POINT === 'cli' ? INF : $config->get( MainConfigNames::CriticalSectionTimeLimit );

        return RequestTimeout::singleton()->createCriticalSectionProvider( $limit );

    },


    'CrossWikiBlockTargetFactory' => static function ( MediaWikiServices $services ): CrossWikiBlockTargetFactory {

        return new CrossWikiBlockTargetFactory(

            new ServiceOptions( CrossWikiBlockTargetFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getActorStoreFactory(),

            $services->getUserNameUtils()

        );

    },


    'DatabaseBlockStore' => static function ( MediaWikiServices $services ): DatabaseBlockStore {

        return $services->getDatabaseBlockStoreFactory()->getDatabaseBlockStore( DatabaseBlock::LOCAL );

    },


    'DatabaseBlockStoreFactory' => static function ( MediaWikiServices $services ): DatabaseBlockStoreFactory {

        return new DatabaseBlockStoreFactory(

            new ServiceOptions(

                DatabaseBlockStoreFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            LoggerFactory::getInstance( 'DatabaseBlockStore' ),

            $services->getActorStoreFactory(),

            $services->getBlockRestrictionStoreFactory(),

            $services->getCommentStore(),

            $services->getHookContainer(),

            $services->getDBLoadBalancerFactory(),

            $services->getReadOnlyMode(),

            $services->getUserFactory(),

            $services->getTempUserConfig(),

            $services->getCrossWikiBlockTargetFactory(),

            $services->getAutoblockExemptionList(),

            $services->getSessionManager()

        );

    },


    'DatabaseFactory' => static function ( MediaWikiServices $services ): DatabaseFactory {

        return new DatabaseFactory(

            [

                'debugSql' => $services->getMainConfig()->get( MainConfigNames::DebugDumpSql ),

                'tracer' => $services->getTracer(),

            ]

        );

    },


    'DateFormatterFactory' => static function ( MediaWikiServices $services ): DateFormatterFactory {

        return new DateFormatterFactory();

    },


    'DBLoadBalancer' => static function ( MediaWikiServices $services ): Wikimedia\Rdbms\ILoadBalancer {

        // just return the default LB from the DBLoadBalancerFactory service

        return $services->getDBLoadBalancerFactory()->getMainLB();

    },


    'DBLoadBalancerFactory' => static function ( MediaWikiServices $services ): Wikimedia\Rdbms\LBFactory {

        $lbConf = $services->getDBLoadBalancerFactoryConfig()->getConfig();


        $mainConfig = $services->getMainConfig();

        if ( $services->getObjectCacheFactory()->isDatabaseId(

            $mainConfig->get( MainConfigNames::MainCacheType )

        ) ) {

            $wanCache = WANObjectCache::newEmpty();

        } else {

            $wanCache = $services->getMainWANObjectCache();

        }

        $srvCache = $services->getLocalServerObjectCache();

        if ( $srvCache instanceof EmptyBagOStuff ) {

            // Use process cache if no APCU or other local-server cache (e.g. on CLI)

            $srvCache = new HashBagOStuff( [ 'maxKeys' => 100 ] );

        }


        $lbFactoryConfigBuilder = new MWLBFactory(

            new ConfiguredReadOnlyMode(

                $mainConfig->get( MainConfigNames::ReadOnly ),

                $mainConfig->get( MainConfigNames::ReadOnlyFile )

            ),

            $services->getChronologyProtector(),

            $srvCache,

            $wanCache,

            $services->getCriticalSectionProvider(),

            $services->getStatsFactory(),

            $services->getTracer(),

            RequestContext::getMain()->getRequest()->getIP()

        );

        $lbConf = $lbFactoryConfigBuilder->applyServices( $lbConf );


        $class = $lbFactoryConfigBuilder->getLBFactoryClass( $lbConf );

        $instance = new $class( $lbConf );


        $lbFactoryConfigBuilder->setDomainAliases( $instance );


        return $instance;

    },


    'DBLoadBalancerFactoryConfig' => static function ( MediaWikiServices $services ): MWLBConfig {

        return new MWLBConfig(

            new ServiceOptions( MWLBConfig::APPLY_DEFAULT_CONFIG_OPTIONS, $services->getMainConfig() ),

            ExtensionRegistry::getInstance()->getAttribute( 'DatabaseVirtualDomains' ),

            $services->getMainConfig()->get( MainConfigNames::LBFactoryConf )

        );

    },


    'DefaultOutputPipeline' => static function ( MediaWikiServices $services ): OutputTransformPipeline {

        return $services->getDefaultOutputPipelineFactory()

            ->buildDefaultOutputPipeline();

    },


    'DefaultOutputPipelineFactory' => static function ( MediaWikiServices $services ): DefaultOutputPipelineFactory {

        return new DefaultOutputPipelineFactory(

            new ServiceOptions(

                DefaultOutputPipelineFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getMainConfig(),

            LoggerFactory::getInstance( 'Parser' ),

            $services->getObjectFactory()

        );

    },


    'DeletePageFactory' => static function ( MediaWikiServices $services ): DeletePageFactory {

        return $services->getService( '_PageCommandFactory' );

    },


    'DomainEventDispatcher' => static function ( MediaWikiServices $services ): DomainEventDispatcher {

        return $services->getService( '_DomainEventDispatcher' );

    },


    'DomainEventSource' => static function ( MediaWikiServices $services ): DomainEventSource {

        return $services->getService( '_DomainEventDispatcher' );

    },


    'EmailConfirmationBannerHandler' =>

        static function ( MediaWikiServices $services ): EmailConfirmationBannerHandler {

            return new EmailConfirmationBannerHandler(

                new ServiceOptions(

                    EmailConfirmationBannerHandler::CONSTRUCTOR_OPTIONS,

                    $services->getMainConfig()

                )

            );

        },


    'Emailer' => static function ( MediaWikiServices $services ): IEmailer {

        return new Emailer();

    },


    'EmailUserFactory' => static function ( MediaWikiServices $services ): EmailUserFactory {

        return new EmailUserFactory(

            new ServiceOptions( EmailUser::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getHookContainer(),

            $services->getUserOptionsLookup(),

            $services->getCentralIdLookup(),

            $services->getUserFactory(),

            $services->getEmailer(),

            $services->getMessageFormatterFactory(),

            $services->getMessageFormatterFactory()->getTextFormatter(

                $services->getContentLanguageCode()->toString()

            )

        );

    },


    'EventRelayerGroup' => static function ( MediaWikiServices $services ): EventRelayerGroup {

        return new EventRelayerGroup( $services->getMainConfig()->get( MainConfigNames::EventRelayerConfig ) );

    },


    'ExtensionRegistry' => static function ( MediaWikiServices $services ): ExtensionRegistry {

        return ExtensionRegistry::getInstance();

    },


    'ExternalStoreAccess' => static function ( MediaWikiServices $services ): ExternalStoreAccess {

        return new ExternalStoreAccess(

            $services->getExternalStoreFactory(),

            LoggerFactory::getInstance( 'ExternalStore' )

        );

    },


    'ExternalStoreFactory' => static function ( MediaWikiServices $services ): ExternalStoreFactory {

        $config = $services->getMainConfig();

        $writeStores = $config->get( MainConfigNames::DefaultExternalStore );


        return new ExternalStoreFactory(

            $config->get( MainConfigNames::ExternalStores ),

            ( $writeStores !== false ) ? (array)$writeStores : [],

            $services->getDBLoadBalancer()->getLocalDomainID(),

            LoggerFactory::getInstance( 'ExternalStore' )

        );

    },


    'FeatureShutdown' => static function ( MediaWikiServices $services ): FeatureShutdown {

        return new FeatureShutdown(

            new ServiceOptions(

                FeatureShutdown::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            )

        );

    },


    'FileBackendGroup' => static function ( MediaWikiServices $services ): FileBackendGroup {

        $mainConfig = $services->getMainConfig();


        $ld = WikiMap::getCurrentWikiDbDomain();

        $fallbackWikiId = WikiMap::getWikiIdFromDbDomain( $ld );

        // If the local wiki ID and local domain ID do not match, probably due to a non-default

        // schema, issue a warning. A non-default schema indicates that it might be used to

        // disambiguate different wikis.

        $legacyDomainId = strlen( $ld->getTablePrefix() )

            ? "{$ld->getDatabase()}-{$ld->getTablePrefix()}"

            : $ld->getDatabase();

        if ( $ld->getSchema() !== null && $legacyDomainId !== $fallbackWikiId ) {

            wfWarn(

                "Legacy default 'domainId' is '$legacyDomainId' but wiki ID is '$fallbackWikiId'."

            );

        }


        $cache = $services->getLocalServerObjectCache();

        if ( $cache instanceof EmptyBagOStuff ) {

            $cache = new HashBagOStuff();

        }


        return new FileBackendGroup(

            new ServiceOptions( FileBackendGroup::CONSTRUCTOR_OPTIONS, $mainConfig,

                [ 'fallbackWikiId' => $fallbackWikiId ] ),

            $services->getReadOnlyMode(),

            $cache,

            $services->getMainWANObjectCache(),

            $services->getMimeAnalyzer(),

            $services->getLockManagerGroupFactory(),

            $services->getTempFSFileFactory(),

            $services->getTracer()

        );

    },


    'FormatterFactory' => static function ( MediaWikiServices $services ): FormatterFactory {

        return new FormatterFactory(

            $services->getMessageParser(),

            $services->getTitleFormatter(),

            $services->getHookContainer(),

            $services->getUserIdentityUtils(),

            $services->getLanguageFactory(),

            LoggerFactory::getInstance( 'status' )

        );

    },


    'GenderCache' => static function ( MediaWikiServices $services ): GenderCache {

        $nsInfo = $services->getNamespaceInfo();

        // If there is no database, use defaults

        if ( $services->isServiceDisabled( 'DBLoadBalancer' ) ) {

            $userOptionsLookup = new StaticUserOptionsLookup(

                [],

                $services->getMainConfig()->get( MainConfigNames::DefaultUserOptions )

            );

        } else {

            $userOptionsLookup = $services->getUserOptionsLookup();

        }

        return new GenderCache( $nsInfo, $userOptionsLookup );

    },


    'GlobalIdGenerator' => static function ( MediaWikiServices $services ): GlobalIdGenerator {

        $mainConfig = $services->getMainConfig();


        return new GlobalIdGenerator(

            $mainConfig->get( MainConfigNames::TmpDirectory ),

            static function ( $command ) {

                return wfShellExec( $command );

            }

        );

    },


    'GrantsInfo' => static function ( MediaWikiServices $services ): GrantsInfo {

        return new GrantsInfo(

            new ServiceOptions(

                GrantsInfo::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            )

        );

    },


    'GrantsLocalization' => static function ( MediaWikiServices $services ): GrantsLocalization {

        return new GrantsLocalization(

            $services->getGrantsInfo(),

            $services->getLinkRenderer(),

            $services->getLanguageFactory(),

            $services->getContentLanguage()

        );

    },


    'GroupPermissionsLookup' => static function ( MediaWikiServices $services ): GroupPermissionsLookup {

        return new GroupPermissionsLookup(

            new ServiceOptions( GroupPermissionsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() )

        );

    },


    'HideUserUtils' => static function ( MediaWikiServices $services ): HideUserUtils {

        return new HideUserUtils();

    },


    'HookContainer' => static function ( MediaWikiServices $services ): HookContainer {

        // NOTE: This is called while $services is being initialized, in order to call the

        //       MediaWikiServices hook.


        $configHooks = $services->getBootstrapConfig()->get( MainConfigNames::Hooks );


        $extRegistry = ExtensionRegistry::getInstance();

        $extHooks = $extRegistry->getAttribute( 'Hooks' );

        $extDeprecatedHooks = $extRegistry->getAttribute( 'DeprecatedHooks' );


        return new HookContainer(

            new StaticHookRegistry( $configHooks, $extHooks, $extDeprecatedHooks ),

            $services->getObjectFactory()

        );

    },


    'HTMLCacheUpdater' => static function ( MediaWikiServices $services ): HTMLCacheUpdater {

        $config = $services->getMainConfig();


        return new HTMLCacheUpdater(

            $services->getHookContainer(),

            $services->getTitleFactory(),

            $config->get( MainConfigNames::CdnReboundPurgeDelay ),

            $config->get( MainConfigNames::UseFileCache ),

            $config->get( MainConfigNames::CdnMaxAge )

        );

    },


    'HtmlTransformFactory' => static function ( MediaWikiServices $services ): HtmlTransformFactory {

        return new HtmlTransformFactory(

            $services->getService( '_Parsoid' ),

            $services->getMainConfig()->get( MainConfigNames::ParsoidSettings ),

            $services->getParsoidPageConfigFactory(),

            $services->getContentHandlerFactory(),

            $services->getParsoidSiteConfig(),

            $services->getTitleFactory(),

            $services->getLanguageConverterPipeline(),

            $services->getLanguageFactory()

        );

    },


    'HttpRequestFactory' => static function ( MediaWikiServices $services ): HttpRequestFactory {

        return new HttpRequestFactory(

            new ServiceOptions(

                HttpRequestFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            LoggerFactory::getInstance( 'http' ),

            $services->getTracer()

        );

    },


    'InterwikiLookup' => static function ( MediaWikiServices $services ): InterwikiLookup {

        return new ClassicInterwikiLookup(

            new ServiceOptions(

                ClassicInterwikiLookup::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig(),

                [ 'wikiId' => WikiMap::getCurrentWikiId() ]

            ),

            $services->getContentLanguage(),

            $services->getMainWANObjectCache(),

            $services->getHookContainer(),

            $services->getConnectionProvider(),

            $services->getLanguageNameUtils()

        );

    },


    'IntroMessageBuilder' => static function ( MediaWikiServices $services ): IntroMessageBuilder {

        return new IntroMessageBuilder(

            $services->getMainConfig(),

            $services->getLinkRenderer(),

            $services->getPermissionManager(),

            $services->getUserNameUtils(),

            $services->getTempUserCreator(),

            $services->getUserFactory(),

            $services->getRestrictionStore(),

            $services->getDatabaseBlockStore(),

            $services->getReadOnlyMode(),

            $services->getSpecialPageFactory(),

            $services->getRepoGroup(),

            $services->getNamespaceInfo(),

            $services->getSkinFactory(),

            $services->getConnectionProvider(),

            $services->getUrlUtils(),

            $services->getShadowPageLoader(),

        );

    },


    'JobFactory' => static function ( MediaWikiServices $services ): JobFactory {

        return new JobFactory(

            $services->getObjectFactory(),

            $services->getMainConfig()->get( MainConfigNames::JobClasses )

        );

    },


    'JobQueueGroup' => static function ( MediaWikiServices $services ): JobQueueGroup {

        return $services->getJobQueueGroupFactory()->makeJobQueueGroup();

    },


    'JobQueueGroupFactory' => static function ( MediaWikiServices $services ): JobQueueGroupFactory {

        return new JobQueueGroupFactory(

            new ServiceOptions( JobQueueGroupFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getReadOnlyMode(),

            $services->getStatsFactory(),

            $services->getObjectCacheFactory()->getLocalClusterInstance(),

            $services->getGlobalIdGenerator()

        );

    },


    'JobRunner' => static function ( MediaWikiServices $services ): JobRunner {

        return new JobRunner(

            new ServiceOptions( JobRunner::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getDBLoadBalancerFactory(),

            $services->getJobQueueGroup(),

            $services->getReadOnlyMode(),

            $services->getLinkCache(),

            $services->getStatsFactory(),

            LoggerFactory::getInstance( 'runJobs' )

        );

    },


    'JsonCodec' => static function ( MediaWikiServices $services ): JsonCodec {

        return new JsonCodec( $services );

    },


    'JwtCodec' => static function ( MediaWikiServices $services ): JwtCodec {

        return new RsaJwtCodec(

            new ServiceOptions( RsaJwtCodec::CONSTRUCTOR_OPTIONS, $services->getMainConfig() )

        );

    },


    'LanguageConverterFactory' => static function ( MediaWikiServices $services ): LanguageConverterFactory {

        return new LanguageConverterFactory(

            new ServiceOptions( LanguageConverterFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getObjectFactory(),

            static function () use ( $services ) {

                return $services->getContentLanguage();

            }

        );

    },


    'LanguageConverterPipeline' => static function ( MediaWikiServices $services ): OutputTransformPipeline {

        return $services->getDefaultOutputPipelineFactory()

            ->buildLanguageConverterPipeline();

    },


    'LanguageFactory' => static function ( MediaWikiServices $services ): LanguageFactory {

        return new LanguageFactory(

            new ServiceOptions( LanguageFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getNamespaceInfo(),

            $services->getLocalisationCache(),

            $services->getLanguageNameUtils(),

            $services->getLanguageFallback(),

            $services->getLanguageConverterFactory(),

            $services->getHookContainer(),

            $services->getMainConfig(),

            $services->getLeximorphFactory()

        );

    },


    'LanguageFallback' => static function ( MediaWikiServices $services ): LanguageFallback {

        return new LanguageFallback(

            $services->getMainConfig()->get( MainConfigNames::LanguageCode ),

            $services->getLocalisationCache(),

            $services->getLanguageNameUtils()

        );

    },


    'LanguageNameSearch' => static function ( MediaWikiServices $services ): LanguageNameSearch {

        return new LanguageNameSearch(

            $services->getLanguageNameUtils()

        );

    },


    'LanguageNameUtils' => static function ( MediaWikiServices $services ): LanguageNameUtils {

        return new LanguageNameUtils(

            new ServiceOptions(

                LanguageNameUtils::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getHookContainer()

        );

    },


    'LeximorphFactory' => static function ( MediaWikiServices $services ): LeximorphFactory {

        return new LeximorphFactory(

            new MediaWiki\Config\ServiceOptions(

                MediaWiki\Language\LeximorphFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            LoggerFactory::getInstance( 'leximorph' )

        );

    },


    'LinkBatchFactory' => static function ( MediaWikiServices $services ): LinkBatchFactory {

        return new LinkBatchFactory(

            $services->getLinkCache(),

            $services->getTitleFormatter(),

            $services->getContentLanguage(),

            $services->getGenderCache(),

            $services->getConnectionProvider(),

            $services->getLinksMigration(),

            $services->getTempUserDetailsLookup(),

            LoggerFactory::getInstance( 'LinkBatch' )

        );

    },


    'LinkCache' => static function ( MediaWikiServices $services ): LinkCache {

        // Database layer may be disabled, so processing without database connection

        $dbLoadBalancer = $services->isServiceDisabled( 'DBLoadBalancer' )

            ? null

            : $services->getDBLoadBalancer();

        $linkCache = new LinkCache(

            $services->getTitleFormatter(),

            $services->getMainWANObjectCache(),

            $services->getNamespaceInfo(),

            $dbLoadBalancer

        );

        $linkCache->setLogger( LoggerFactory::getInstance( 'LinkCache' ) );

        return $linkCache;

    },


    'LinkRenderer' => static function ( MediaWikiServices $services ): LinkRenderer {

        return $services->getLinkRendererFactory()->create();

    },


    'LinkRendererFactory' => static function ( MediaWikiServices $services ): LinkRendererFactory {

        return new LinkRendererFactory(

            $services->getTitleFormatter(),

            $services->getLinkCache(),

            $services->getSpecialPageFactory(),

            $services->getHookContainer(),

            $services->getTempUserConfig(),

            $services->getTempUserDetailsLookup(),

            $services->getUserIdentityLookup(),

            $services->getUserNameUtils(),

            $services->getUrlUtils(),

            new ServiceOptions(

                LinkRendererFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            )

        );

    },


    'LinksMigration' => static function ( MediaWikiServices $services ): LinksMigration {

        return new LinksMigration(

            $services->getMainConfig(),

            $services->getLinkTargetLookup()

        );

    },


    'LinkTargetLookup' => static function ( MediaWikiServices $services ): LinkTargetLookup {

        return new LinkTargetStore(

            $services->getConnectionProvider(),

            $services->getLocalServerObjectCache(),

            $services->getMainWANObjectCache()

        );

    },


    'LinkWriteDuplicator' => static function ( MediaWikiServices $services ): WriteDuplicator {

        return new WriteDuplicator(

            $services->getConnectionProvider(),

            ExternalLinksTable::VIRTUAL_DOMAIN,

            array_key_exists(

                ExternalLinksTable::VIRTUAL_DOMAIN,

                $services->getMainConfig()->get( MainConfigNames::VirtualDomainsMapping )

            )

        );

    },


    'LintErrorChecker' => static function ( MediaWikiServices $services ): LintErrorChecker {

        return new LintErrorChecker(

            $services->get( '_Parsoid' ),

            $services->getParsoidPageConfigFactory(),

            $services->getTitleFactory(),

            ExtensionRegistry::getInstance(),

            $services->getMainConfig(),

         );

    },


    'LocalisationCache' => static function ( MediaWikiServices $services ): LocalisationCache {

        $conf = $services->getMainConfig()->get( MainConfigNames::LocalisationCacheConf );


        $logger = LoggerFactory::getInstance( 'localisation' );


        $store = LocalisationCache::getStoreFromConf(

            $conf, $services->getMainConfig()->get( MainConfigNames::CacheDirectory ) );

        $logger->debug( 'LocalisationCache using store ' . get_class( $store ) );


        return new $conf['class'](

            new ServiceOptions(

                LocalisationCache::CONSTRUCTOR_OPTIONS,

                // Two of the options are stored in $wgLocalisationCacheConf

                $conf,

                // In case someone set that config variable and didn't reset all keys, set defaults.

                [

                    'forceRecache' => false,

                    'manualRecache' => false,

                ],

                // Some other options come from config itself

                $services->getMainConfig()

            ),

            $store,

            $logger,

            [ static function () use ( $services ) {

                // NOTE: Make sure we use the same cache object that is assigned in the

                // constructor of the MessageBlobStore class used by ResourceLoader.

                // T231866: Avoid circular dependency via ResourceLoader.

                MessageBlobStore::clearGlobalCacheEntry( $services->getMainWANObjectCache() );

            } ],

            $services->getLanguageNameUtils(),

            $services->getHookContainer()

        );

    },


    'LocalServerObjectCache' => static function ( MediaWikiServices $services ): BagOStuff {

        return $services->getObjectCacheFactory()->getInstance( CACHE_ACCEL );

    },


    'LockManager' => static function ( MediaWikiServices $services ): LockManager {

        // TODO: This probably should move to a dedicated factory but the current state

        // of lock manager factories needs refactoring first.

        if ( defined( 'MW_PHPUNIT_TEST' ) ) {

            return new NullLockManager( [] );

        }

        $lockManager = $services->getMainConfig()->get( MainConfigNames::DefaultLockManager );

        if ( !$lockManager ) {

            return new DatabaseLockManager(

                [

                    'domain' => WikiMap::getCurrentWikiDbDomain()->getId(),

                    'dbProvider' => $services->getConnectionProvider(),

                    'logger' => LoggerFactory::getInstance( 'lockManager' )

                ]

            );

        }

        return $services->getLockManagerGroupFactory()

            ->getLockManagerGroup( WikiMap::getCurrentWikiDbDomain()->getId() )

            ->get( $lockManager );

    },


    'LockManagerGroupFactory' => static function ( MediaWikiServices $services ): LockManagerGroupFactory {

        return new LockManagerGroupFactory(

            WikiMap::getCurrentWikiDbDomain()->getId(),

            $services->getMainConfig()->get( MainConfigNames::LockManagers )

        );

    },


    'LogFormatterFactory' => static function ( MediaWikiServices $services ): LogFormatterFactory {

        return new LogFormatterFactory(

            new ServiceOptions( LogFormatterFactory::SERVICE_OPTIONS, $services->getMainConfig() ),

            $services->getObjectFactory(),

            $services->getHookContainer(),

            $services->getLinkRenderer(),

            $services->getContentLanguage(),

            $services->getCommentFormatter(),

            $services->getUserEditTracker()

        );

    },


    'MagicWordFactory' => static function ( MediaWikiServices $services ): MagicWordFactory {

        return new MagicWordFactory(

            $services->getContentLanguage(),

            $services->getHookContainer()

        );

    },


    'MainConfig' => static function ( MediaWikiServices $services ): Config {

        // Use the 'main' config from the ConfigFactory service.

        return $services->getConfigFactory()->makeConfig( 'main' );

    },


    'MainObjectStash' => static function ( MediaWikiServices $services ): BagOStuff {

        $mainConfig = $services->getMainConfig();


        $id = $mainConfig->get( MainConfigNames::MainStash );

        $store = $services->getObjectCacheFactory()->getInstance( $id );

        $store->getLogger()->debug( 'MainObjectStash using store {class}', [

            'class' => get_class( $store )

        ] );


        return $store;

    },


    'MainWANObjectCache' => static function ( MediaWikiServices $services ): WANObjectCache {

        $mainConfig = $services->getMainConfig();


        $store = $services->getObjectCacheFactory()->getLocalClusterInstance();

        $logger = $store->getLogger();

        $logger->debug( 'MainWANObjectCache using store {class}', [

            'class' => get_class( $store )

        ] );


        $wanParams = $mainConfig->get( MainConfigNames::WANObjectCache ) + [

            'cache' => $store,

            'logger' => $logger,

            'tracer' => $services->getTracer(),

        ];

        if ( MW_ENTRY_POINT !== 'cli' ) {

            // Send the statsd data post-send on HTTP requests; avoid in CLI mode (T181385)

            $wanParams['stats'] = $services->getStatsFactory();

            // Let pre-emptive refreshes happen post-send on HTTP requests

            $wanParams['asyncHandler'] = DeferredUpdates::addCallableUpdate( ... );

        }


        // Only the callback only if it's a simple one-database setup.

        $lbConf = $services->getDBLoadBalancerFactoryConfig()->getConfig();

        if (

            isset( $lbConf['servers'] ) &&

            count( $lbConf['servers'] ) === 1 &&

            !defined( 'MW_PHPUNIT_TEST' )

        ) {

            $wanParams['pendingCallback'] = static function () use ( $services ) {

                return $services->getDBLoadBalancer()->hasOrMadeRecentPrimaryChanges();

            };

        }

        return new WANObjectCache( $wanParams );

    },


    'MediaHandlerFactory' => static function ( MediaWikiServices $services ): MediaHandlerFactory {

        return new MediaHandlerFactory(

            $services->getLanguageFactory(),

            LoggerFactory::getInstance( 'MediaHandlerFactory' ),

            $services->getMainConfig()->get( MainConfigNames::MediaHandlers )

        );

    },


    'MergeHistoryFactory' => static function ( MediaWikiServices $services ): MergeHistoryFactory {

        return $services->getService( '_PageCommandFactory' );

    },


    'MessageCache' => static function ( MediaWikiServices $services ): MessageCache {

        $mainConfig = $services->getMainConfig();

        $mainCache = $services->getObjectCacheFactory()

            ->getInstance( $mainConfig->get( MainConfigNames::MessageCacheType ) );

        $srvCache = $mainConfig->get( MainConfigNames::UseLocalMessageCache )

            ? $services->getLocalServerObjectCache()

            : new EmptyBagOStuff();


        $logger = LoggerFactory::getInstance( 'MessageCache' );

        $logger->debug( 'MessageCache using store {class}', [

            'class' => get_class( $mainCache )

        ] );


        $options = new ServiceOptions( MessageCache::CONSTRUCTOR_OPTIONS, $mainConfig );


        return new MessageCache(

            $services->getMainWANObjectCache(),

            $mainCache,

            $srvCache,

            $services->getContentLanguage(),

            $services->getLanguageConverterFactory(),

            $logger,

            $options,

            $services->getLocalisationCache(),

            $services->getLanguageNameUtils(),

            $services->getLanguageFallback(),

            $services->getHookContainer(),

            $services->getMessageParser()

        );

    },


    'MessageFormatterFactory' => static function ( MediaWikiServices $services ): IMessageFormatterFactory {

        return new MessageFormatterFactory();

    },


    'MessageParser' => static function ( MediaWikiServices $services ): MessageParser {

        return new MessageParser(

            $services->getParserFactory(),

            $services->getDefaultOutputPipeline(),

            $services->getLanguageFactory(),

            LoggerFactory::getInstance( 'MessageParser' )

        );

    },


    'MicroStash' => static function ( MediaWikiServices $services ): BagOStuff {

        $mainConfig = $services->getMainConfig();


        $id = $mainConfig->get( MainConfigNames::MicroStashType );

        $store = $services->getObjectCacheFactory()->getInstance( $id );


        $store->getLogger()->debug( 'MicroStash using store {class}', [

            'class' => get_class( $store )

        ] );


        return $store;

    },


    'MimeAnalyzer' => static function ( MediaWikiServices $services ): MimeAnalyzer {

        $logger = LoggerFactory::getInstance( 'Mime' );

        $mainConfig = $services->getMainConfig();

        $hookRunner = new HookRunner( $services->getHookContainer() );

        $params = [

            'typeFile' => $mainConfig->get( MainConfigNames::MimeTypeFile ),

            'infoFile' => $mainConfig->get( MainConfigNames::MimeInfoFile ),

            'xmlTypes' => $mainConfig->get( MainConfigNames::XMLMimeTypes ),

            'guessCallback' => static function (

                $mimeAnalyzer, &$head, &$tail, $file, &$mime

            ) use ( $logger, $hookRunner ) {

                // Also test DjVu

                $deja = new DjVuImage( $file );

                if ( $deja->isValid() ) {

                    $logger->info( "Detected $file as image/vnd.djvu\n" );

                    $mime = 'image/vnd.djvu';


                    return;

                }

                // Some strings by reference for performance - assuming well-behaved hooks

                $hookRunner->onMimeMagicGuessFromContent(

                    $mimeAnalyzer, $head, $tail, $file, $mime );

            },

            'extCallback' => static function ( $mimeAnalyzer, $ext, &$mime ) use ( $hookRunner ) {

                // Media handling extensions can improve the MIME detected

                $hookRunner->onMimeMagicImproveFromExtension( $mimeAnalyzer, $ext, $mime );

            },

            'initCallback' => static function ( $mimeAnalyzer ) use ( $hookRunner ) {

                // Allow media handling extensions adding MIME-types and MIME-info

                $hookRunner->onMimeMagicInit( $mimeAnalyzer );

            },

            'logger' => $logger

        ];


        if ( $params['infoFile'] === 'includes/mime.info' ) {

            $params['infoFile'] = MimeAnalyzer::USE_INTERNAL;

        }


        if ( $params['typeFile'] === 'includes/mime.types' ) {

            $params['typeFile'] = MimeAnalyzer::USE_INTERNAL;

        }


        $detectorCmd = $mainConfig->get( MainConfigNames::MimeDetectorCommand );

        if ( $detectorCmd ) {

            $factory = $services->getShellCommandFactory();

            $params['detectCallback'] = static function ( $file ) use ( $detectorCmd, $factory ) {

                $result = $factory->create()

                    // $wgMimeDetectorCommand can contain commands with parameters

                    ->unsafeParams( $detectorCmd )

                    ->params( $file )

                    ->execute();

                return $result->getStdout();

            };

        }


        return new MimeAnalyzer( $params );

    },


    'MovePageFactory' => static function ( MediaWikiServices $services ): MovePageFactory {

        return $services->getService( '_PageCommandFactory' );

    },


    'MultiFormatUserIdentityLookup' => static function ( MediaWikiServices $services ): MultiFormatUserIdentityLookup {

        return new MultiFormatUserIdentityLookup(

            $services->getActorStoreFactory(),

            $services->getUserFactory(),

            new ServiceOptions( MultiFormatUserIdentityLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() )

        );

    },


    'NamespaceInfo' => static function ( MediaWikiServices $services ): NamespaceInfo {

        return new NamespaceInfo(

            new ServiceOptions( NamespaceInfo::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getHookContainer(),

            ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' ),

            ExtensionRegistry::getInstance()->getAttribute( 'ImmovableNamespaces' )

        );

    },


    'NameTableStoreFactory' => static function ( MediaWikiServices $services ): NameTableStoreFactory {

        return new NameTableStoreFactory(

            $services->getDBLoadBalancerFactory(),

            $services->getMainWANObjectCache(),

            LoggerFactory::getInstance( 'NameTableSqlStore' )

        );

    },


    'NotificationEmailSender' => static function ( MediaWikiServices $services ): NotificationEmailSender {

        return new NotificationEmailSender(

            new ServiceOptions(

                NotificationEmailSender::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getEmailer(),

            $services->getLocalServerObjectCache(),

            $services->getUrlUtils()

        );

    },


    'NotificationService' => static function ( MediaWikiServices $services ): NotificationService {

        $handlers = ExtensionRegistry::getInstance()->getAttribute( 'NotificationHandlers' );

        // Inject default MediaWiki handlers

        $handlers[] = NotificationService::RECENT_CHANGE_HANDLER_SPEC;


        return new NotificationService(

            LoggerFactory::getInstance( 'Notification' ),

            $services->getObjectFactory(),

            $services->getService( '_NotificationMiddlewareChain' ),

            $handlers

        );

    },


    'ObjectCacheFactory' => static function ( MediaWikiServices $services ): ObjectCacheFactory {

        return new ObjectCacheFactory(

            new ServiceOptions(

                ObjectCacheFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getStatsFactory(),

            LoggerFactory::getProvider(),

            // Prevent a recursive service instantiation on DBLoadBalancerFactory

            // and ensure the service keeps working when DB storage is disabled.

            static function () use ( $services ) {

                return $services->getDBLoadBalancerFactory();

            },

            WikiMap::getCurrentWikiDbDomain()->getId(),

            $services->getTracer()

        );

    },


    'ObjectFactory' => static function ( MediaWikiServices $services ): ObjectFactory {

        return new ObjectFactory( $services );

    },


    'OldRevisionImporter' => static function ( MediaWikiServices $services ): OldRevisionImporter {

        return new ImportableOldRevisionImporter(

            true,

            LoggerFactory::getInstance( 'OldRevisionImporter' ),

            $services->getConnectionProvider(),

            $services->getRevisionStoreFactory()->getRevisionStoreForImport(),

            $services->getSlotRoleRegistry(),

            $services->getWikiPageFactory(),

            $services->getPageUpdaterFactory(),

            $services->getUserFactory()

        );

    },


    'PageEditStash' => static function ( MediaWikiServices $services ): PageEditStash {

        return new PageEditStash(

            $services->getObjectCacheFactory()->getLocalClusterInstance(),

            $services->getConnectionProvider(),

            LoggerFactory::getInstance( 'StashEdit' ),

            $services->getStatsFactory(),

            $services->getUserEditTracker(),

            $services->getUserFactory(),

            $services->getWikiPageFactory(),

            $services->getJsonCodec(),

            $services->getLockManager(),

            $services->getHookContainer(),

            defined( 'MEDIAWIKI_JOB_RUNNER' ) || MW_ENTRY_POINT === 'cli'

                ? PageEditStash::INITIATOR_JOB_OR_CLI

                : PageEditStash::INITIATOR_USER

        );

    },


    'PageProps' => static function ( MediaWikiServices $services ): PageProps {

        return new PageProps(

            $services->getLinkBatchFactory(),

            $services->getConnectionProvider()

        );

    },


    'PageRestHelperFactory' => static function ( MediaWikiServices $services ): PageRestHelperFactory {

        return new PageRestHelperFactory(

            new ServiceOptions( PageRestHelperFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getRevisionLookup(),

            $services->getRevisionRenderer(),

            $services->getTitleFormatter(),

            $services->getPageStore(),

            $services->getParsoidOutputStash(),

            $services->getParserOutputAccess(),

            $services->getParsoidSiteConfig(),

            $services->getHtmlTransformFactory(),

            $services->getContentHandlerFactory(),

            $services->getLanguageFactory(),

            $services->getRedirectStore(),

            $services->getLanguageConverterFactory(),

            $services->getTitleFactory(),

            $services->getConnectionProvider(),

            $services->getChangeTagsStore(),

            $services->getStatsFactory(),

            $services->getShadowPageLoader(),

        );

    },


    'PageStore' => static function ( MediaWikiServices $services ): PageStore {

        return $services->getPageStoreFactory()->getPageStore();

    },


    'PageStoreFactory' => static function ( MediaWikiServices $services ): PageStoreFactory {

        $options = new ServiceOptions(

            PageStoreFactory::CONSTRUCTOR_OPTIONS,

            $services->getMainConfig()

        );


        return new PageStoreFactory(

            $options,

            $services->getDBLoadBalancerFactory(),

            $services->getNamespaceInfo(),

            $services->getTitleParser(),

            $services->getLinkCache(),

            $services->getStatsFactory()

        );

    },


    'PageUpdaterFactory' => static function (

        MediaWikiServices $services

    ): PageUpdaterFactory {

        $editResultCache = new EditResultCache(

            $services->getMainObjectStash(),

            $services->getConnectionProvider(),

            new ServiceOptions(

                EditResultCache::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            )

        );


        return new PageUpdaterFactory(

            $services->getRevisionStore(),

            $services->getRevisionRenderer(),

            $services->getSlotRoleRegistry(),

            $services->getParserCache(),

            $services->getJobQueueGroup(),

            $services->getContentLanguage(),

            $services->getDBLoadBalancerFactory(),

            $services->getContentHandlerFactory(),

            $services->getDomainEventDispatcher(),

            $services->getHookContainer(),

            $editResultCache,

            LoggerFactory::getInstance( 'SavePage' ),

            new ServiceOptions(

                PageUpdaterFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getUserGroupManager(),

            $services->getTitleFormatter(),

            $services->getContentTransformer(),

            $services->getPageEditStash(),

            $services->getMainWANObjectCache(),

            $services->getWikiPageFactory(),

            $services->getChangeTagsStore(),

            $services->getChangeTagsStore()->getSoftwareTags()

        );

    },


    'Parser' => static function ( MediaWikiServices $services ): Parser {

        // This service exists as convenience function to get the global parser in global code.

        // Do not use this service for dependency injection or in service wiring (T343070).

        // Use the 'ParserFactory' service instead.

        return $services->getParserFactory()->getMainInstance();

    },


    'ParserCache' => static function ( MediaWikiServices $services ): ParserCache {

        return $services->getParserCacheFactory()

            ->getParserCache( ParserCacheFactory::DEFAULT_NAME );

    },


    'ParserCacheFactory' => static function ( MediaWikiServices $services ): ParserCacheFactory {

        $config = $services->getMainConfig();

        $cache = $services->getObjectCacheFactory()->getInstance( $config->get( MainConfigNames::ParserCacheType ) );

        $wanCache = $services->getMainWANObjectCache();


        $options = new ServiceOptions( ParserCacheFactory::CONSTRUCTOR_OPTIONS, $config );


        return new ParserCacheFactory(

            $cache,

            $wanCache,

            $services->getHookContainer(),

            $services->getJsonCodec(),

            $services->getStatsFactory(),

            LoggerFactory::getInstance( 'ParserCache' ),

            $options,

            $services->getTitleFactory(),

            $services->getWikiPageFactory(),

            $services->getGlobalIdGenerator()

        );

    },


    'ParserCoreTagHooks' => static function ( MediaWikiServices $services ): ParserCoreTagHooks {

        $options = new ServiceOptions( ParserCoreTagHooks::CONSTRUCTOR_OPTIONS,

            $services->getMainConfig()

        );

        return new ParserCoreTagHooks(

            $options,

            $services->getLanguageFactory(),

            $services->getLanguageConverterFactory(),

        );

    },


    'ParserFactory' => static function ( MediaWikiServices $services ): ParserFactory {

        $options = new ServiceOptions( Parser::CONSTRUCTOR_OPTIONS,

            $services->getMainConfig()

        );


        return new ParserFactory(

            $options,

            $services->getParserCoreTagHooks(),

            $services->getMagicWordFactory(),

            $services->getContentLanguage(),

            $services->getUrlUtils(),

            $services->getSpecialPageFactory(),

            $services->getLinkRendererFactory(),

            $services->getNamespaceInfo(),

            LoggerFactory::getInstance( 'Parser' ),

            $services->getBadFileLookup(),

            $services->getRepoGroup(),

            $services->getLanguageFactory(),

            $services->getLanguageConverterFactory(),

            $services->getLanguageNameUtils(),

            $services->getHookContainer(),

            $services->getTidy(),

            $services->getMainWANObjectCache(),

            $services->getUserOptionsLookup(),

            $services->getUserFactory(),

            $services->getTitleFormatter(),

            $services->getHttpRequestFactory(),

            $services->getTrackingCategories(),

            $services->getSignatureValidatorFactory(),

            $services->getUserNameUtils()

        );

    },


    'ParserOutputAccess' => static function ( MediaWikiServices $services ): ParserOutputAccess {

        $poa = new ParserOutputAccess(

            $services->getMainConfig(),

            $services->getDefaultOutputPipeline(),

            $services->getParserCacheFactory(),

            $services->getRevisionLookup(),

            $services->getRevisionRenderer(),

            $services->getStatsFactory(),

            $services->getChronologyProtector(),

            $services->getWikiPageFactory(),

            $services->getTitleFormatter(),

            $services->getTracer(),

            $services->getPoolCounterFactory()

        );


        $poa->setLogger( LoggerFactory::getInstance( 'ParserOutputAccess' ) );

        return $poa;

    },


    'ParsoidDataAccess' => static function ( MediaWikiServices $services ): DataAccess {

        $mainConfig = $services->getMainConfig();

        return new MWDataAccess(

            new ServiceOptions( MWDataAccess::CONSTRUCTOR_OPTIONS, $mainConfig ),

            $services->getRepoGroup(),

            $services->getBadFileLookup(),

            $services->getHookContainer(),

            $services->getContentTransformer(),

            $services->getTrackingCategories(),

            $services->getReadOnlyMode(),

            $services->getParserFactory(), // *legacy* parser factory

            $services->getLinkBatchFactory(),

            $services->getLinkRenderer()

        );

    },


    'ParsoidOutputStash' => static function ( MediaWikiServices $services ): ParsoidOutputStash {

        // TODO: Determine storage requirements and config options for stashing parsoid

        //       output for VE edits (T309016).

        $config = $services->getMainConfig()->get( MainConfigNames::ParsoidCacheConfig );

        $backend = $config['StashType']

            ? $services->getObjectCacheFactory()->getInstance( $config['StashType'] )

            : $services->getMainObjectStash();


        return new SimpleParsoidOutputStash(

            $services->getJsonCodec(),

            $backend,

            $config['StashDuration']

        );

    },


    'ParsoidPageConfigFactory' => static function ( MediaWikiServices $services ): MWPageConfigFactory {

        return new MWPageConfigFactory(

            $services->getRevisionStore(),

            $services->getSlotRoleRegistry(),

            $services->getLanguageFactory()

        );

    },


    'ParsoidParserFactory' => static function ( MediaWikiServices $services ): ParsoidParserFactory {

        return new ParsoidParserFactory(

            $services->getParsoidSiteConfig(),

            $services->getParsoidDataAccess(),

            $services->getParsoidPageConfigFactory(),

            $services->getLanguageConverterFactory(),

            $services->getNamespaceInfo(),

            $services->getTrackingCategories(),

            $services->getParserFactory(),

        );

    },


    'ParsoidSiteConfig' => static function ( MediaWikiServices $services ): MWSiteConfig {

        $mainConfig = $services->getMainConfig();

        $parsoidSettings = $mainConfig->get( MainConfigNames::ParsoidSettings );

        return new MWSiteConfig(

            new ServiceOptions( MWSiteConfig::CONSTRUCTOR_OPTIONS, $mainConfig ),

            $parsoidSettings,

            $services->getObjectFactory(),

            $services->getContentLanguage(),

            $services->getStatsdDataFactory(),

            $services->getStatsFactory(),

            $services->getMagicWordFactory(),

            $services->getNamespaceInfo(),

            $services->getSpecialPageFactory(),

            $services->getInterwikiLookup(),

            $services->getUserOptionsLookup(),

            $services->getLanguageFactory(),

            $services->getLanguageConverterFactory(),

            $services->getLanguageNameUtils(),

            $services->getUrlUtils(),

            $services->getContentHandlerFactory(),

            ExtensionRegistry::getInstance()->getAttribute( 'ParsoidModules' ),

            // These arguments are temporary and will be removed once

            // better solutions are found.

            $services->getParserFactory(), // T268776

            $mainConfig, // T268777

            ExtensionRegistry::getInstance()->isLoaded( 'TimedMediaHandler' )

        );

    },


    'PasswordFactory' => static function ( MediaWikiServices $services ): PasswordFactory {

        $config = $services->getMainConfig();

        return new PasswordFactory(

            $config->get( MainConfigNames::PasswordConfig ),

            $config->get( MainConfigNames::PasswordDefault )

        );

    },


    'PasswordReset' => static function ( MediaWikiServices $services ): PasswordReset {

        $options = new ServiceOptions( PasswordReset::CONSTRUCTOR_OPTIONS, $services->getMainConfig() );

        return new PasswordReset(

            $options,

            LoggerFactory::getInstance( 'authentication' ),

            $services->getAuthManager(),

            $services->getHookContainer(),

            $services->getUserIdentityLookup(),

            $services->getUserFactory(),

            $services->getUserNameUtils(),

            $services->getUserOptionsLookup()

        );

    },


    'PatrolManager' => static function ( MediaWikiServices $services ): PatrolManager {

        return new PatrolManager(

            new ServiceOptions( PatrolManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getConnectionProvider(),

            $services->getUserFactory(),

            $services->getHookContainer(),

            $services->getRevertedTagUpdateManager()

        );

    },


    'PerDbNameStatsdDataFactory' => static function ( MediaWikiServices $services ): StatsdDataFactoryInterface {

        $config = $services->getMainConfig();

        $wiki = $config->get( MainConfigNames::DBname );

        return new PrefixingStatsdDataFactoryProxy(

            $services->getStatsdDataFactory(),

            $wiki

        );

    },


    'PermissionManager' => static function ( MediaWikiServices $services ): PermissionManager {

        return new PermissionManager(

            new ServiceOptions(

                PermissionManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getSpecialPageFactory(),

            $services->getNamespaceInfo(),

            $services->getGroupPermissionsLookup(),

            $services->getUserGroupManager(),

            $services->getBlockManager(),

            $services->getFormatterFactory()->getBlockErrorFormatter(

                new LazyLocalizationContext( RequestContext::getMain( ... ) )

            ),

            $services->getHookContainer(),

            $services->getUserIdentityLookup(),

            $services->getRedirectLookup(),

            $services->getRestrictionStore(),

            $services->getTitleFormatter(),

            $services->getTempUserConfig(),

            $services->getUserFactory(),

            $services->getActionFactory()

        );

    },


    'Pingback' => static function ( MediaWikiServices $services ): Pingback {

        return new Pingback(

            $services->getMainConfig(),

            $services->getConnectionProvider(),

            $services->getObjectCacheFactory()->getLocalClusterInstance(),

            $services->getHttpRequestFactory(),

            LoggerFactory::getInstance( 'Pingback' )

        );

    },


    'PoolCounterFactory' => static function ( MediaWikiServices $services ): PoolCounterFactory {

        $mainConfig = $services->getMainConfig();

        return new PoolCounterFactory(

            $mainConfig->get( MainConfigNames::PoolCounterConf ),

            $mainConfig->get( MainConfigNames::PoolCountClientConf ),

            LoggerFactory::getInstance( 'poolcounter' ),

            $services->getTracer()

        );

    },


    'PreferencesFactory' => static function ( MediaWikiServices $services ): PreferencesFactory {

        $factory = new DefaultPreferencesFactory(

            new ServiceOptions(

                DefaultPreferencesFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getContentLanguage(),

            $services->getAuthManager(),

            $services->getLinkRendererFactory()->create(),

            $services->getNamespaceInfo(),

            $services->getPermissionManager(),

            $services->getLanguageConverterFactory()->getLanguageConverter(),

            $services->getLanguageNameUtils(),

            $services->getHookContainer(),

            $services->getUserOptionsManager(),

            $services->getLanguageConverterFactory(),

            $services->getParserFactory(),

            $services->getSkinFactory(),

            $services->getUserGroupManager(),

            $services->getSignatureValidatorFactory()

        );

        $factory->setLogger( LoggerFactory::getInstance( 'preferences' ) );


        return $factory;

    },


    'PreloadedContentBuilder' => static function ( MediaWikiServices $services ): PreloadedContentBuilder {

        return new PreloadedContentBuilder(

            $services->getContentHandlerFactory(),

            $services->getWikiPageFactory(),

            $services->getRedirectLookup(),

            $services->getSpecialPageFactory(),

            $services->getContentTransformer(),

            $services->getHookContainer(),

            $services->getShadowPageLoader(),

        );

    },


    'ProxyLookup' => static function ( MediaWikiServices $services ): ProxyLookup {

        $mainConfig = $services->getMainConfig();

        return new ProxyLookup(

            $mainConfig->get( MainConfigNames::CdnServers ),

            $mainConfig->get( MainConfigNames::CdnServersNoPurge ),

            $services->getHookContainer(),

            $services->getLocalServerObjectCache()

        );

    },


    'RateLimiter' => static function ( MediaWikiServices $services ): RateLimiter {

        $rateLimiter = new RateLimiter(

            new ServiceOptions( RateLimiter::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getWRStatsFactory(),

            $services->getCentralIdLookupFactory()->getNonLocalLookup(),

            $services->getUserFactory(),

            $services->getUserGroupManager(),

            $services->getHookContainer()

        );


        $rateLimiter->setStats( $services->getStatsFactory() );


        return $rateLimiter;

    },


    'ReadOnlyMode' => static function ( MediaWikiServices $services ): ReadOnlyMode {

        return new ReadOnlyMode(

            new ConfiguredReadOnlyMode(

                $services->getMainConfig()->get( MainConfigNames::ReadOnly ),

                $services->getMainConfig()->get( MainConfigNames::ReadOnlyFile )

            ),

            $services->getDBLoadBalancerFactory()

        );

    },


    'RecentChangeFactory' => static function ( MediaWikiServices $services ): RecentChangeFactory {

        return $services->getRecentChangeStore();

    },


    'RecentChangeLookup' => static function ( MediaWikiServices $services ): RecentChangeLookup {

        return $services->getRecentChangeStore();

    },


    'RecentChangeRCFeedNotifier' => static function ( MediaWikiServices $services ): RecentChangeRCFeedNotifier {

        return new RecentChangeRCFeedNotifier(

            $services->getHookContainer(),

            new ServiceOptions( RecentChangeRCFeedNotifier::CONSTRUCTOR_OPTIONS, $services->getMainConfig() )

        );

    },


    'RecentChangeStore' => static function ( MediaWikiServices $services ): RecentChangeStore {

        $extRegistry = ExtensionRegistry::getInstance();

        return new RecentChangeStore(

            $services->getActorStoreFactory(),

            $services->getChangeTagsStore(),

            $services->getConnectionProvider(),

            $services->getCommentStore(),

            $services->getHookContainer(),

            $services->getJobQueueGroup(),

            $services->getPermissionManager(),

            $services->getRecentChangeRCFeedNotifier(),

            new ServiceOptions( RecentChangeStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getTitleFormatter(),

            $services->getWikiPageFactory(),

            $services->getUserFactory(),

            $extRegistry->getAttribute( 'RecentChangeSources' )

        );

    },


    'RedirectLookup' => static function ( MediaWikiServices $services ): RedirectLookup {

        return $services->getRedirectStore();

    },


    'RedirectStore' => static function ( MediaWikiServices $services ): RedirectStore {

        return new RedirectStore(

            $services->getConnectionProvider(),

            $services->getPageStore(),

            $services->getTitleParser(),

            $services->getRepoGroup(),

            LoggerFactory::getInstance( 'RedirectStore' ),

            $services->getLinkWriteDuplicator()

        );

    },


    'RenameUserFactory' => static function ( MediaWikiServices $services ): RenameUserFactory {

        return new RenameUserFactory(

            new ServiceOptions( RenameUserFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getCentralIdLookupFactory(),

            $services->getConnectionProvider(),

            $services->getJobQueueGroupFactory(),

            $services->getMovePageFactory(),

            $services->getUserFactory(),

            $services->getUserNameUtils(),

            $services->getPermissionManager(),

            $services->getTitleFactory(),

        );

    },


    'RepoGroup' => static function ( MediaWikiServices $services ): RepoGroup {

        $config = $services->getMainConfig();

        return new RepoGroup(

            $config->get( MainConfigNames::LocalFileRepo ),

            $config->get( MainConfigNames::ForeignFileRepos ),

            $services->getMainWANObjectCache(),

            $services->getMimeAnalyzer()

        );

    },


    'ResourceLoader' => static function ( MediaWikiServices $services ): ResourceLoader {

        $config = $services->getMainConfig();


        $maxage = $config->get( MainConfigNames::ResourceLoaderMaxage );

        $rl = new ResourceLoader(

            $config,

            LoggerFactory::getInstance( 'resourceloader' ),

            new DependencyStore( $services->getMainObjectStash() ),

            [

                'loadScript' => $config->get( MainConfigNames::LoadScript ),

                'maxageVersioned' => $maxage['versioned'] ?? null,

                'maxageUnversioned' => $maxage['unversioned'] ?? null,

            ]

        );


        $extRegistry = ExtensionRegistry::getInstance();

        // Attribute has precedence over config

        $modules = $extRegistry->getAttribute( 'ResourceModules' )

            + $config->get( MainConfigNames::ResourceModules );

        $moduleSkinStyles = $extRegistry->getAttribute( 'ResourceModuleSkinStyles' )

            + $config->get( MainConfigNames::ResourceModuleSkinStyles );


        $rl->setModuleSkinStyles( $moduleSkinStyles );

        $rl->addSource( $config->get( MainConfigNames::ResourceLoaderSources ) );


        // Core modules, then extension/skin modules

        $rl->register( include MW_INSTALL_PATH . '/resources/Resources.php' );

        $rl->register( $modules );

        $hookRunner = new \MediaWiki\ResourceLoader\HookRunner( $services->getHookContainer() );

        $hookRunner->onResourceLoaderRegisterModules( $rl );


        $msgPosterAttrib = $extRegistry->getAttribute( 'MessagePosterModule' );

        $rl->register( 'mediawiki.messagePoster', [

            'localBasePath' => MW_INSTALL_PATH,

            'debugRaw' => false,

            'scripts' => [

                'resources/src/mediawiki.messagePoster/factory.js',

                'resources/src/mediawiki.messagePoster/MessagePoster.js',

                'resources/src/mediawiki.messagePoster/WikitextMessagePoster.js',

                ...$msgPosterAttrib['scripts'] ?? [],

            ],

            'dependencies' => [

                'oojs',

                'mediawiki.api',

                'mediawiki.ForeignApi',

                ...$msgPosterAttrib['dependencies'] ?? [],

            ],

        ] );


        if ( $config->get( MainConfigNames::EnableJavaScriptTest ) === true ) {

            $rl->registerTestModules();

        }


        return $rl;

    },


    'RestrictedUserGroupCheckerFactory' =>

        static function ( MediaWikiServices $services ): RestrictedUserGroupCheckerFactory {

            return new RestrictedUserGroupCheckerFactory(

                $services->getRestrictedUserGroupConfigReader(),

                $services->getUserRequirementsConditionChecker()

            );

        },


    'RestrictedUserGroupConfigReader' =>

        static function ( MediaWikiServices $services ): RestrictedUserGroupConfigReader {

            return new RestrictedUserGroupConfigReader(

                new ServiceOptions(

                    RestrictedUserGroupConfigReader::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

                ),

                $services->getUserRequirementsConditionValidator()

            );

        },


    'RestrictionStore' => static function ( MediaWikiServices $services ): RestrictionStore {

        return new RestrictionStore(

            new ServiceOptions(

                RestrictionStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getMainWANObjectCache(),

            $services->getDBLoadBalancerFactory(),

            $services->getLinkCache(),

            $services->getLinksMigration(),

            $services->getCommentStore(),

            $services->getHookContainer(),

            $services->getPageStore()

        );

    },


    'RevertedTagUpdateManager' => static function ( MediaWikiServices $services ): RevertedTagUpdateManager {

        $editResultCache = new EditResultCache(

            $services->getMainObjectStash(),

            $services->getConnectionProvider(),

            new ServiceOptions(

                EditResultCache::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            )

        );


        return new RevertedTagUpdateManager(

            $editResultCache,

            $services->getJobQueueGroup()

        );

    },


    'RevisionFactory' => static function ( MediaWikiServices $services ): RevisionFactory {

        return $services->getRevisionStore();

    },


    'RevisionLookup' => static function ( MediaWikiServices $services ): RevisionLookup {

        return $services->getRevisionStore();

    },


    'RevisionRenderer' => static function ( MediaWikiServices $services ): RevisionRenderer {

        $renderer = new RevisionRenderer(

            $services->getDBLoadBalancer(),

            $services->getSlotRoleRegistry(),

            $services->getContentRenderer()

        );


        $renderer->setLogger( LoggerFactory::getInstance( 'SaveParse' ) );

        return $renderer;

    },


    'RevisionStore' => static function ( MediaWikiServices $services ): RevisionStore {

        return $services->getRevisionStoreFactory()->getRevisionStore();

    },


    'RevisionStoreFactory' => static function ( MediaWikiServices $services ): RevisionStoreFactory {

        return new RevisionStoreFactory(

            $services->getDBLoadBalancerFactory(),

            $services->getBlobStoreFactory(),

            $services->getNameTableStoreFactory(),

            $services->getSlotRoleRegistry(),

            $services->getMainWANObjectCache(),

            $services->getLocalServerObjectCache(),

            $services->getCommentStore(),

            $services->getActorStoreFactory(),

            LoggerFactory::getInstance( 'RevisionStore' ),

            $services->getContentHandlerFactory(),

            $services->getPageStoreFactory(),

            $services->getTitleFactory(),

            $services->getHookContainer(),

            $services->getRecentChangeLookup()

        );

    },


    'RollbackPageFactory' => static function ( MediaWikiServices $services ): RollbackPageFactory {

        return $services->get( '_PageCommandFactory' );

    },


    'RowCommentFormatter' => static function ( MediaWikiServices $services ): RowCommentFormatter {

        return new RowCommentFormatter(

            $services->getCommentParserFactory(),

            $services->getCommentStore()

        );

    },


    'SBOMGenerator' => static function ( MediaWikiServices $services ): SBOMGenerator {

        return new SBOMGenerator(

            $services->getConnectionProvider(),

            $services->getExtensionRegistry(),

            $services->getGlobalIdGenerator(),

        );

    },


    'SearchEngineConfig' => static function ( MediaWikiServices $services ): SearchEngineConfig {

        return new SearchEngineConfig(

            new ServiceOptions(

                SearchEngineConfig::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getContentLanguage(),

            $services->getHookContainer(),

            ExtensionRegistry::getInstance()->getAttribute( 'SearchMappings' ),

            $services->getUserOptionsLookup()

        );

    },


    'SearchEngineFactory' => static function ( MediaWikiServices $services ): SearchEngineFactory {

        return new SearchEngineFactory(

            $services->getSearchEngineConfig(),

            $services->getHookContainer(),

            $services->getConnectionProvider()

        );

    },


    'SearchResultThumbnailProvider' => static function ( MediaWikiServices $services ): SearchResultThumbnailProvider {

        return new SearchResultThumbnailProvider(

            $services->getRepoGroup(),

            $services->getHookContainer()

        );

    },


    'SessionManager' => static function ( MediaWikiServices $services ): SessionManagerInterface {

        return new SessionManager(

            $services->getMainConfig(),

            LoggerFactory::getInstance( 'session' ),

            $services->getCentralIdLookup(),

            $services->getHookContainer(),

            $services->getObjectFactory(),

            $services->getProxyLookup(),

            $services->getUrlUtils(),

            $services->getUserNameUtils(),

            $services->getSessionStore()

        );

    },


    'SessionStore' => static function ( MediaWikiServices $services ): SessionStore {

        $objectCacheFactory = $services->getObjectCacheFactory();

        $mainConfig = $services->getMainConfig();

        $logger = LoggerFactory::getInstance( 'session' );


        $anonCacheType = $mainConfig->get( MainConfigNames::AnonSessionCacheType );

        $authCacheType = $mainConfig->get( MainConfigNames::SessionCacheType );


        if ( $anonCacheType !== false ) {

            return new MultiBackendSessionStore(

                $objectCacheFactory->getInstance( $anonCacheType ),

                $objectCacheFactory->getInstance( $authCacheType ),

                $logger,

                $services->getStatsFactory()

            );

        }


        return new SingleBackendSessionStore(

            $objectCacheFactory->getInstance( $authCacheType ),

            $logger,

            $services->getStatsFactory()

        );

    },


    'ShadowPageLoader' => static function ( MediaWikiServices $services ): ShadowPageLoader {

        return new ShadowPageLoader(

            $services->getObjectFactory(),

            ShadowPageLoader::CORE_SPECS,

            ExtensionRegistry::getInstance()->getAttribute( 'ShadowPageProviders' )

        );

    },


    'ShellboxClientFactory' => static function ( MediaWikiServices $services ): ShellboxClientFactory {

        $urls = $services->getMainConfig()->get( MainConfigNames::ShellboxUrls );


        return new ShellboxClientFactory(

            $services->getHttpRequestFactory(),

            $urls,

            $services->getMainConfig()->get( MainConfigNames::ShellboxSecretKey )

        );

    },


    'ShellCommandFactory' => static function ( MediaWikiServices $services ): CommandFactory {

        $config = $services->getMainConfig();


        $limits = [

            'time' => $config->get( MainConfigNames::MaxShellTime ),

            'walltime' => $config->get( MainConfigNames::MaxShellWallClockTime ),

            'memory' => $config->get( MainConfigNames::MaxShellMemory ),

            'filesize' => $config->get( MainConfigNames::MaxShellFileSize ),

        ];

        $cgroup = $config->get( MainConfigNames::ShellCgroup );

        $restrictionMethod = $config->get( MainConfigNames::ShellRestrictionMethod );


        $factory = new CommandFactory( $services->getShellboxClientFactory(),

            $limits, $cgroup, $restrictionMethod );

        $factory->setLogger( LoggerFactory::getInstance( 'exec' ) );

        $factory->logStderr();


        return $factory;

    },


    'SignatureValidatorFactory' => static function ( MediaWikiServices $services ): SignatureValidatorFactory {

        return new SignatureValidatorFactory(

            new ServiceOptions(

                SignatureValidator::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            // Use closures for these to avoid a circular dependency on Parser

            static function () use ( $services ) {

                return $services->getParserFactory();

            },

            static function () use ( $services ) {

                return $services->getLintErrorChecker();

            },

            $services->getSpecialPageFactory(),

            $services->getTitleFactory(),

        );

    },


    'SiteLookup' => static function ( MediaWikiServices $services ): SiteLookup {

        // Use SiteStore as the SiteLookup as well. This was originally separated

        // to allow for a cacheable read-only interface, but this was never used.

        // SiteStore has caching (see below).

        return $services->getSiteStore();

    },


    'SiteStore' => static function ( MediaWikiServices $services ): SiteStore {

        $rawSiteStore = new DBSiteStore( $services->getConnectionProvider() );


        // If php-apcu is not installed, then CachingSiteStore still avoids

        // repeat DB queries in the same request through an in-process cache.

        $cache = $services->getLocalServerObjectCache();


        return new CachingSiteStore( $rawSiteStore, $cache );

    },


    'SkinFactory' => static function ( MediaWikiServices $services ): SkinFactory {

        $factory = new SkinFactory(

            $services->getObjectFactory(),

            (array)$services->getMainConfig()->get( MainConfigNames::SkipSkins )

        );


        $names = $services->getMainConfig()->get( MainConfigNames::ValidSkinNames );


        foreach ( $names as $name => $skin ) {

            if ( is_array( $skin ) ) {

                $spec = $skin;

                $displayName = $skin['displayname'] ?? $name;

                $skippable = $skin['skippable'] ?? false;

            } else {

                $displayName = $skin;

                $skippable = false;

                $spec = [

                    'name' => $name,

                    'class' => "Skin$skin"

                ];

            }

            $factory->register( $name, $displayName, $spec, $skippable );

        }


        // Register a hidden "fallback" skin

        $factory->register( 'fallback', 'Fallback', [

            'class' => SkinFallback::class,

            'args' => [

                [

                    'name' => 'fallback',

                    'menus' => [],

                    'styles' => [ 'mediawiki.skinning.interface', 'mediawiki.codex.messagebox.styles' ],

                    'templateDirectory' => dirname( __DIR__ ) . '/resources/templates/skins/fallback',

                ]

            ]

        ], true );

        // Register a hidden skin for api output

        $factory->register( 'apioutput', 'ApiOutput', [

            'class' => SkinApi::class,

            'args' => [

                [

                    'name' => 'apioutput',

                    'menus' => [],

                    'styles' => [ 'mediawiki.skinning.interface' ],

                    'templateDirectory' => dirname( __DIR__ ) . '/resources/templates/skins/apioutput',

                ]

            ]

        ], true );

        // Register a hidden skin for Special:UserLogin and Special:CreateAccount

        $factory->register( 'authentication-popup', 'Authentication popup', [

            'class' => SkinAuthenticationPopup::class,

            'args' => [

                [

                    'name' => 'authentication-popup',

                    'menus' => [],

                    'styles' => [

                        'mediawiki.skinning.interface',

                        'mediawiki.special.userlogin.authentication-popup',

                    ],

                    'bodyClasses' => [ 'mw-authentication-popup' ],

                    'responsive' => true,

                    'messages' => [

                        'sitesubtitle',

                        'sitetitle',

                    ],

                    'templateDirectory' => dirname( __DIR__ ) . '/resources/templates/skins/authentication-popup',

                ]

            ]

        ], true );

        // Register a hidden skin for outputting skin json

        $factory->register( 'json', 'SkinJSON', [

            'class' => SkinApi::class,

            'args' => [

                [

                    'name' => 'json',

                    'menus' => [],

                    'styles' => [],

                    'format' => 'json',

                    'templateDirectory' => dirname( __DIR__ ) . '/resources/templates/skins/apioutput',

                ]

            ]

        ], true );


        return $factory;

    },


    'SlotRoleRegistry' => static function ( MediaWikiServices $services ): SlotRoleRegistry {

        $registry = new SlotRoleRegistry(

            $services->getSlotRoleStore()

        );


        $config = $services->getMainConfig();

        $contentHandlerFactory = $services->getContentHandlerFactory();

        $hookContainer = $services->getHookContainer();

        $titleFactory = $services->getTitleFactory();

        $registry->defineRole(

            SlotRecord::MAIN,

            static function () use ( $config, $contentHandlerFactory, $hookContainer, $titleFactory ) {

                return new MainSlotRoleHandler(

                    $config->get( MainConfigNames::NamespaceContentModels ),

                    $contentHandlerFactory,

                    $hookContainer,

                    $titleFactory

                );

            }

        );


        return $registry;

    },


    'SlotRoleStore' => static function ( MediaWikiServices $services ): NameTableStore {

        return $services->getNameTableStoreFactory()->getSlotRoles();

    },


    'SpamChecker' => static function ( MediaWikiServices $services ): SpamChecker {

        return new SpamChecker(

            (array)$services->getMainConfig()->get( MainConfigNames::SpamRegex ),

            (array)$services->getMainConfig()->get( MainConfigNames::SummarySpamRegex )

        );

    },


    'SpecialPageFactory' => static function ( MediaWikiServices $services ): SpecialPageFactory {

        return new SpecialPageFactory(

            new ServiceOptions(

                SpecialPageFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getContentLanguage(),

            $services->getObjectFactory(),

            $services->getTitleFactory(),

            $services->getHookContainer(),

            $services->getStatsFactory(),

        );

    },


    'StatsdDataFactory' => static function ( MediaWikiServices $services ): IBufferingStatsdDataFactory {

        return new NullStatsdDataFactory();

    },


    'StatsFactory' => static function ( MediaWikiServices $services ): StatsFactory {

        $config = $services->getMainConfig();

        $format = OutputFormats::getFormatFromString(

            $config->get( MainConfigNames::StatsFormat ) ?? 'null'

        );

        $cache = new StatsCache;

        $emitter = OutputFormats::getNewEmitter(

            $config->get( MainConfigNames::StatsPrefix ),

            $cache,

            OutputFormats::getNewFormatter( $format ),

            $config->get( MainConfigNames::StatsTarget )

        );

        return new StatsFactory( $cache, $emitter, LoggerFactory::getInstance( 'Stats' ) );

    },


    'TalkPageNotificationManager' => static function (

        MediaWikiServices $services

    ): TalkPageNotificationManager {

        return new TalkPageNotificationManager(

            new ServiceOptions(

                TalkPageNotificationManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getConnectionProvider(),

            $services->getReadOnlyMode(),

            $services->getRevisionLookup(),

            $services->getHookContainer(),

            $services->getUserFactory()

        );

    },


    'TempFSFileFactory' => static function ( MediaWikiServices $services ): TempFSFileFactory {

        return new TempFSFileFactory( $services->getMainConfig()->get( MainConfigNames::TmpDirectory ) );

    },


    'TempUserConfig' => static function ( MediaWikiServices $services ): RealTempUserConfig {

        return new RealTempUserConfig(

            $services->getMainConfig()->get( MainConfigNames::AutoCreateTempUser )

        );

    },


    'TempUserCreator' => static function ( MediaWikiServices $services ): TempUserCreator {

        return new TempUserCreator(

            $services->getTempUserConfig(),

            $services->getObjectFactory(),

            $services->getUserFactory(),

            $services->getAuthManager(),

            $services->getCentralIdLookup(),

            // This should match ThrottlePreAuthenticationProvider's daily limit

            // and also implements its own short-term throttling limit (See T405565).

            new Throttler(

                $services->getMainConfig()->get( MainConfigNames::TempAccountCreationThrottle ),

                [

                    'type' => 'tempacctcreate',

                    'cache' => $services->getObjectCacheFactory()->getLocalClusterInstance(),

                ]

            ),

            new Throttler(

                $services->getMainConfig()->get( MainConfigNames::TempAccountNameAcquisitionThrottle ),

                [

                    'type' => 'tempacctnameacquisition',

                    'cache' => $services->getObjectCacheFactory()->getLocalClusterInstance(),

                ]

            )

        );

    },


    'TempUserDetailsLookup' => static function ( MediaWikiServices $services ): TempUserDetailsLookup {

        return new TempUserDetailsLookup(

            $services->getTempUserConfig(),

            $services->getUserRegistrationLookup()

        );

    },


    'TextboxBuilder' => static function ( MediaWikiServices $services ): TextboxBuilder {

        return new TextboxBuilder(

            $services->getPermissionManager(),

            $services->getRestrictionStore(),

            $services->getUserOptionsLookup(),

        );

    },


    'Tidy' => static function ( MediaWikiServices $services ): TidyDriverBase {

        return new RemexDriver(

            new ServiceOptions(

                RemexDriver::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            )

        );

    },


    'TitleFactory' => static function ( MediaWikiServices $services ): TitleFactory {

        return new TitleFactory();

    },


    'TitleFormatter' => static function ( MediaWikiServices $services ): TitleFormatter {

        return new TitleFormatter(

            $services->getContentLanguage(),

            $services->getGenderCache(),

            $services->getNamespaceInfo()

        );

    },


    'TitleMatcher' => static function ( MediaWikiServices $services ): TitleMatcher {

        return new TitleMatcher(

            $services->getContentLanguage(),

            $services->getLanguageConverterFactory(),

            $services->getHookContainer(),

            $services->getWikiPageFactory(),

            $services->getRepoGroup(),

            $services->getTitleFactory()

        );

    },


    'TitleParser' => static function ( MediaWikiServices $services ): TitleParser {

        return new TitleParser(

            $services->getContentLanguage(),

            $services->getInterwikiLookup(),

            $services->getNamespaceInfo(),

            $services->getMainConfig()->get( MainConfigNames::LocalInterwikis )

        );

    },


    'Tracer' => static function ( MediaWikiServices $services ): TracerInterface {

        $xReqIdPropagator = new MediaWikiPropagator( Telemetry::getInstance() );

        $otelConfig = $services->getMainConfig()->get( MainConfigNames::OpenTelemetryConfig );

        if ( $otelConfig === null || ( wfIsCLI() && !defined( 'MW_PHPUNIT_TEST' ) ) ) {

            if ( $services->getMainConfig()->get( MainConfigNames::GenerateReqIDFormat ) === 'uuid4' ) {

                Telemetry::getInstance()->overrideRequestId( $services->getGlobalIdGenerator()->newUUIDv4() );

            }

            return new NoopTracer( $xReqIdPropagator );

        }


        $tracerState = TracerState::getInstance();

        $exporter = new OtlpHttpExporter(

            $services->getService( '_TracerHTTPClient' ),

            new HttpFactory(),

            LoggerFactory::getInstance( 'tracing' ),

            $otelConfig['endpoint'],

            $otelConfig['serviceName'],

            wfHostname()

        );


        return new Tracer(

            new Clock(),

            new ProbabilisticSampler( $otelConfig['samplingProbability'] ),

            $exporter,

            $tracerState,

            new CompositePropagator( [ $xReqIdPropagator, new W3CTraceContextPropagator() ] )

        );

    },


    'TrackingCategories' => static function ( MediaWikiServices $services ): TrackingCategories {

        return new TrackingCategories(

            new ServiceOptions(

                TrackingCategories::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getExtensionRegistry(),

            $services->getNamespaceInfo(),

            $services->getTitleParser(),

            LoggerFactory::getInstance( 'TrackingCategories' )

        );

    },


    'UnblockUserFactory' => static function ( MediaWikiServices $services ): UnblockUserFactory {

        return $services->getService( '_UserBlockCommandFactory' );

    },


    'UndeletePageFactory' => static function ( MediaWikiServices $services ): UndeletePageFactory {

        return $services->getService( '_PageCommandFactory' );

    },


    'UploadRevisionImporter' => static function ( MediaWikiServices $services ): UploadRevisionImporter {

        return new ImportableUploadRevisionImporter(

            $services->getMainConfig()->get( MainConfigNames::EnableUploads ),

            LoggerFactory::getInstance( 'UploadRevisionImporter' )

        );

    },


    'UploadVerification' => static function ( MediaWikiServices $services ): UploadVerification {

        return new UploadVerification(

            new ServiceOptions(

                UploadVerification::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getMimeAnalyzer(),

            new SVGCSSChecker

        );

    },


    'UrlUtils' => static function ( MediaWikiServices $services ): UrlUtils {

        $config = $services->getMainConfig();

        return new UrlUtils( [

            UrlUtils::SERVER => $config->get( MainConfigNames::Server ),

            UrlUtils::CANONICAL_SERVER => $config->get( MainConfigNames::CanonicalServer ),

            UrlUtils::INTERNAL_SERVER => $config->get( MainConfigNames::InternalServer ),

            UrlUtils::FALLBACK_PROTOCOL => RequestContext::getMain()->getRequest()->getProtocol(),

            UrlUtils::HTTPS_PORT => $config->get( MainConfigNames::HttpsPort ),

            UrlUtils::VALID_PROTOCOLS => $config->get( MainConfigNames::UrlProtocols ),

        ] );

    },


    'UserCache' => static function ( MediaWikiServices $services ): UserCache {

        return new UserCache(

            LoggerFactory::getInstance( 'UserCache' ),

            $services->getConnectionProvider(),

            $services->getLinkBatchFactory()

        );

    },


    'UserEditTracker' => static function ( MediaWikiServices $services ): UserEditTracker {

        return new UserEditTracker(

            $services->getActorStoreFactory(),

            $services->getConnectionProvider(),

            $services->getJobQueueGroup(),

            $services->getMainWANObjectCache()

        );

    },


    'UserFactory' => static function ( MediaWikiServices $services ): UserFactory {

        return new UserFactory(

            new ServiceOptions(

                UserFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getDBLoadBalancerFactory(),

            $services->getUserNameUtils(),

            $services->getTempUserConfig()

        );

    },


    'UserGroupAssignmentService' => static function ( MediaWikiServices $services ): UserGroupAssignmentService {

        return new UserGroupAssignmentService(

            $services->getUserGroupManagerFactory(),

            $services->getUserNameUtils(),

            $services->getUserFactory(),

            $services->getRestrictedUserGroupCheckerFactory(),

            new HookRunner( $services->getHookContainer() ),

            new ServiceOptions(

                UserGroupAssignmentService::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getTempUserConfig(),

            $services->getConnectionProvider(),

            $services->getPageStoreFactory(),

        );

    },


    'UserGroupManager' => static function ( MediaWikiServices $services ): UserGroupManager {

        return $services->getUserGroupManagerFactory()->getUserGroupManager();

    },


    'UserGroupManagerFactory' => static function ( MediaWikiServices $services ): UserGroupManagerFactory {

        return new UserGroupManagerFactory(

            new ServiceOptions(

                UserGroupManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getReadOnlyMode(),

            $services->getDBLoadBalancerFactory(),

            $services->getHookContainer(),

            $services->getJobQueueGroupFactory(),

            $services->getTempUserConfig(),

            $services->getUserFactory(),

            $services->getUserRequirementsConditionCheckerFactory(),

            $services->getRestrictedUserGroupConfigReader(),

            [ static function ( UserIdentity $user ) use ( $services ) {

                if ( $user->getWikiId() === UserIdentity::LOCAL ) {

                    $services->getPermissionManager()->invalidateUsersRightsCache( $user );

                }

                $services->getUserFactory()->invalidateCache( $user );

            } ]

        );

    },


    'UserIdentityLookup' => static function ( MediaWikiServices $services ): UserIdentityLookup {

        return $services->getActorStoreFactory()->getUserIdentityLookup();

    },


    'UserIdentityUtils' => static function ( MediaWikiServices $services ): UserIdentityUtils {

        return new UserIdentityUtils(

            $services->getTempUserConfig()

        );

    },


    'UserLinkRenderer' => static function ( MediaWikiServices $services ): UserLinkRenderer {

        return new UserLinkRenderer(

            $services->getHookContainer(),

            $services->getTempUserConfig(),

            $services->getSpecialPageFactory(),

            $services->getLinkRenderer(),

            $services->getTempUserDetailsLookup(),

            $services->getUserIdentityLookup(),

            $services->getUserNameUtils()

        );

    },


    'UserNamePrefixSearch' => static function ( MediaWikiServices $services ): UserNamePrefixSearch {

        return new UserNamePrefixSearch(

            $services->getConnectionProvider(),

            $services->getUserNameUtils(),

            $services->getHideUserUtils()

        );

    },


    'UserNameUtils' => static function ( MediaWikiServices $services ): UserNameUtils {

        $messageFormatterFactory = new MessageFormatterFactory( Message::FORMAT_PLAIN );

        return new UserNameUtils(

            new ServiceOptions(

                UserNameUtils::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getContentLanguage(),

            LoggerFactory::getInstance( 'UserNameUtils' ),

            $services->getTitleParser(),

            $messageFormatterFactory->getTextFormatter(

                $services->getContentLanguageCode()->toString()

            ),

            $services->getHookContainer(),

            $services->getTempUserConfig()

        );

    },


    'UserOptionsLookup' => static function ( MediaWikiServices $services ): UserOptionsLookup {

        return $services->getUserOptionsManager();

    },


    'UserOptionsManager' => static function ( MediaWikiServices $services ): UserOptionsManager {

        return new UserOptionsManager(

            new ServiceOptions( UserOptionsManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->get( '_DefaultOptionsLookup' ),

            $services->getLanguageConverterFactory(),

            $services->getConnectionProvider(),

            LoggerFactory::getInstance( 'UserOptionsManager' ),

            $services->getHookContainer(),

            $services->getUserFactory(),

            $services->getUserNameUtils(),

            $services->getObjectFactory(),

            ExtensionRegistry::getInstance()->getAttribute( 'UserOptionsStoreProviders' )

        );

    },


    'UserRegistrationLookup' => static function ( MediaWikiServices $services ): UserRegistrationLookup {

        $lookup = new UserRegistrationLookup(

            new ServiceOptions( UserRegistrationLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getObjectFactory()

        );

        if ( !$lookup->isRegistered( LocalUserRegistrationProvider::TYPE ) ) {

            throw new ConfigException( 'UserRegistrationLookup: Local provider is required' );

        }

        return $lookup;

    },


    'UserRequirementsConditionChecker' => static function (

        MediaWikiServices $services

    ): UserRequirementsConditionChecker

    {

        return $services->getUserRequirementsConditionCheckerFactory()

            ->getUserRequirementsConditionChecker( $services->getUserGroupManager() );

    },


    'UserRequirementsConditionCheckerFactory' => static function (

        MediaWikiServices $services

    ): UserRequirementsConditionCheckerFactory

    {

        return new UserRequirementsConditionCheckerFactory(

            new ServiceOptions(

                UserRequirementsConditionCheckerFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),

            $services->getGroupPermissionsLookup(),

            $services->getHookContainer(),

            $services->getUserEditTracker(),

            $services->getUserRegistrationLookup(),

            $services->getUserFactory(),

            RequestContext::getMain(),

            $services->getUserRequirementsConditionValidator(),

        );

    },


    'UserRequirementsConditionValidator' => static function (): UserRequirementsConditionValidator {

        return new UserRequirementsConditionValidator(

            LoggerFactory::getInstance( 'UserGroupManager' ),

        );

    },


    'WatchedItemQueryService' => static function ( MediaWikiServices $services ): WatchedItemQueryService {

        return new WatchedItemQueryService(

            $services->getConnectionProvider(),

            $services->getWatchedItemStore(),

            $services->getMainConfig()->get( MainConfigNames::WatchlistExpiry ),

            $services->getMainConfig()->get( MainConfigNames::MaxExecutionTimeForExpensiveQueries )

        );

    },


    'WatchedItemStore' => static function ( MediaWikiServices $services ): WatchedItemStore {

        $store = new WatchedItemStore(

            new ServiceOptions( WatchedItemStore::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig() ),

            $services->getDBLoadBalancerFactory(),

            $services->getJobQueueGroup(),

            $services->getMainObjectStash(),

            new HashBagOStuff( [ 'maxKeys' => 100 ] ),

            $services->getReadOnlyMode(),

            $services->getNamespaceInfo(),

            $services->getRevisionLookup(),

            $services->getLinkBatchFactory(),

            $services->getWatchlistLabelStore()

        );


        if ( $services->getMainConfig()->get( MainConfigNames::ReadOnlyWatchedItemStore ) ) {

            $store = new NoWriteWatchedItemStore( $store );

        }


        return $store;

    },


    'WatchlistLabelStore' => static function ( MediaWikiServices $services ): WatchlistLabelStore {

        return new WatchlistLabelStore(

            $services->getConnectionProvider(),

            LoggerFactory::getInstance( 'WatchlistLabels' ),

            $services->getMainConfig()

        );

    },


    'WatchlistManager' => static function ( MediaWikiServices $services ): WatchlistManager {

        return new WatchlistManager(

            [

                WatchlistManager::OPTION_ENOTIF => RecentChangeStore::isEnotifEnabled(

                    new ServiceOptions( RecentChangeStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig() )

                ),

            ],

            $services->getHookContainer(),

            $services->getReadOnlyMode(),

            $services->getRevisionLookup(),

            $services->getTalkPageNotificationManager(),

            $services->getWatchedItemStore(),

            $services->getWatchlistLabelStore(),

            $services->getUserFactory(),

            $services->getNamespaceInfo(),

            $services->getWikiPageFactory()

        );

    },


    'WikiExporterFactory' => static function ( MediaWikiServices $services ): WikiExporterFactory {

        return new WikiExporterFactory(

            $services->getHookContainer(),

            $services->getRevisionStore(),

            $services->getTitleParser(),

            $services->getCommentStore()

        );

    },


    'WikiImporterFactory' => static function ( MediaWikiServices $services ): WikiImporterFactory {

        return new WikiImporterFactory(

            $services->getMainConfig(),

            $services->getHookContainer(),

            $services->getContentLanguage(),

            $services->getNamespaceInfo(),

            $services->getTitleFactory(),

            $services->getWikiPageFactory(),

            $services->getWikiRevisionUploadImporter(),

            $services->getContentHandlerFactory(),

            $services->getSlotRoleRegistry()

        );

    },


    'WikiPageFactory' => static function ( MediaWikiServices $services ): WikiPageFactory {

        return new WikiPageFactory(

            $services->getTitleFactory(),

            new HookRunner( $services->getHookContainer() ),

            $services->getDBLoadBalancerFactory()

        );

    },


    'WikiRevisionOldRevisionImporterNoUpdates' => static function (

        MediaWikiServices $services

    ): ImportableOldRevisionImporter {

        return new ImportableOldRevisionImporter(

            false,

            LoggerFactory::getInstance( 'OldRevisionImporter' ),

            $services->getConnectionProvider(),

            $services->getRevisionStoreFactory()->getRevisionStoreForImport(),

            $services->getSlotRoleRegistry(),

            $services->getWikiPageFactory(),

            $services->getPageUpdaterFactory(),

            $services->getUserFactory()

        );

    },


    'WRStatsFactory' => static function ( MediaWikiServices $services ): WRStatsFactory {

        return new WRStatsFactory(

            new BagOStuffStatsStore( $services->getMicroStash() )

        );

    },


    '_ConditionalDefaultsLookup' => static function (

        MediaWikiServices $services

    ): ConditionalDefaultsLookup {

        return new ConditionalDefaultsLookup(

            new ServiceOptions(

                ConditionalDefaultsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()

            ),

            $services->getUserRegistrationLookup(),

            $services->getUserIdentityUtils(),

            LoggerFactory::getInstance( 'preferences' ),

            static function () use ( $services ) {

                return $services->getUserGroupManager();

            }

        );

    },


    '_DefaultOptionsLookup' => static function ( MediaWikiServices $services ): DefaultOptionsLookup {

        return new DefaultOptionsLookup(

            new ServiceOptions( DefaultOptionsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getContentLanguageCode(),

            $services->getHookContainer(),

            $services->getNamespaceInfo(),

            $services->get( '_ConditionalDefaultsLookup' ),

            $services->getUserIdentityLookup(),

            $services->getUserNameUtils()

        );

    },


    '_DomainEventDispatcher' => static function ( MediaWikiServices $services ): EventDispatchEngine {

        $dispatcher = new EventDispatchEngine(

            $services->getObjectFactory()

        );


        // Core event wiring.

        // TODO: move this to a more prominent location? A separate file?


        // Establish the propagation of events to various components

        $dispatcher->registerSubscriber( ChangeTrackingEventIngress::OBJECT_SPEC );

        $dispatcher->registerSubscriber( SearchEventIngress::OBJECT_SPEC );

        $dispatcher->registerSubscriber( LanguageEventIngress::OBJECT_SPEC );


        $extensionRegistry = $services->getExtensionRegistry();

        $dispatcher->registerSubscriber( $extensionRegistry );


        return $dispatcher;

    },


    '_EditConstraintFactory' => static function ( MediaWikiServices $services ): EditConstraintFactory {

        // This service is internal and currently only exists because a significant number

        // of dependencies will be needed by different constraints. It is not part of

        // the public interface and has no corresponding method in MediaWikiServices

        return new EditConstraintFactory(

            // Multiple

            new ServiceOptions(

                EditConstraintFactory::CONSTRUCTOR_OPTIONS,

                $services->getMainConfig()

            ),


            // EditFilterMergedContentHookConstraint

            $services->getHookContainer(),


            // ReadOnlyConstraint

            $services->getReadOnlyMode(),


            // SpamRegexConstraint

            $services->getSpamChecker(),

            // The wpAntispam check in EditPage::internalAttemptSave uses the 'SimpleAntiSpam' channel, but

            // SpamRegexConstraint uses 'SpamRegex'.

            // TODO can they be combined into the same channel?

            LoggerFactory::getProvider()->getLogger( 'SpamRegex' ),


            // LinkPurgeRateLimitConstraint

            $services->getRateLimiter(),


            // RedirectConstraint

            $services->getRedirectLookup(),


            // AccidentalRecreationConstraint

            $services->getConnectionProvider(),

            $services->getLogFormatterFactory(),


            // EditFilterMergedContentHookConstraint

            $services->getUserFactory(),

        );

    },


    '_NotificationMiddlewareChain' => static function ( MediaWikiServices $services ): MiddlewareChain {

        return new MiddlewareChain(

            $services->getObjectFactory(),

            ExtensionRegistry::getInstance()->getAttribute( 'NotificationMiddleware' )

        );

    },


    '_PageCommandFactory' => static function ( MediaWikiServices $services ): PageCommandFactory {

        return new PageCommandFactory(

            $services->getMainConfig(),

            $services->getDBLoadBalancerFactory(),

            $services->getNamespaceInfo(),

            $services->getWatchedItemStore(),

            $services->getRepoGroup(),

            $services->getReadOnlyMode(),

            $services->getContentHandlerFactory(),

            $services->getRevisionStoreFactory(),

            $services->getSpamChecker(),

            $services->getTitleFormatter(),

            $services->getHookContainer(),

            $services->getDomainEventDispatcher(),

            $services->getWikiPageFactory(),

            $services->getUserFactory(),

            $services->getActorMigration(),

            $services->getActorNormalization(),

            $services->getTitleFactory(),

            $services->getUserEditTracker(),

            $services->getCollationFactory(),

            $services->getJobQueueGroup(),

            $services->getCommentStore(),

            $services->getMainObjectStash(),

            WikiMap::getCurrentWikiDbDomain()->getId(),

            WebRequest::getRequestId(),

            $services->getBacklinkCacheFactory(),

            LoggerFactory::getInstance( 'UndeletePage' ),

            $services->getPageUpdaterFactory(),

            $services->getMessageFormatterFactory()->getTextFormatter(

                $services->getContentLanguageCode()->toString()

            ),

            $services->getArchivedRevisionLookup(),

            $services->getRestrictionStore(),

            $services->getLinkTargetLookup(),

            $services->getRedirectStore(),

            $services->getLogFormatterFactory(),

            $services->getLinkWriteDuplicator()

        );

    },


    '_PageEditFactory' => static function ( MediaWikiServices $services ): PageEditFactory {

        return new PageEditFactory(

            new ServiceOptions( PageEditFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getContentHandlerFactory(),

            $services->getService( '_EditConstraintFactory' ),

            $services->getConnectionProvider(),

            $services->getContentLanguage(),

            $services->getContentTransformer(),

            LoggerFactory::getInstance( 'EditConflict' ),

            $services->getService( '_PageEditingHelper' ),

            $services->getRateLimiter(),

            $services->getRevisionStore(),

            $services->getShadowPageLoader(),

            $services->getTitleFormatter(),

            $services->getUserOptionsLookup(),

            $services->getWatchlistManager(),

            $services->getWatchedItemStore(),

            $services->getWikiPageFactory(),

        );

    },


    '_PageEditingHelper' => static function ( MediaWikiServices $services ): PageEditingHelper {

        return new PageEditingHelper(

            new ServiceOptions( PageEditingHelper::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getContentHandlerFactory(),

            $services->getParserFactory(),

            $services->getRevisionStore(),

        );

    },


    '_ParserObserver' => static function ( MediaWikiServices $services ): ParserObserver {

        return new ParserObserver( LoggerFactory::getInstance( 'DuplicateParse' ) );

    },


    '_Parsoid' => static function ( MediaWikiServices $services ): Parsoid {

        return new Parsoid(

            $services->getParsoidSiteConfig(),

            $services->getParsoidDataAccess()

        );

    },


    '_SettingsBuilder' => static function ( MediaWikiServices $services ): SettingsBuilder {

        return SettingsBuilder::getInstance();

    },


    '_SqlBlobStore' => static function ( MediaWikiServices $services ): SqlBlobStore {

        return $services->getBlobStoreFactory()->newSqlBlobStore();

    },


    '_TracerHTTPClient' => static function (): ClientInterface {

        return new Client( [ 'http_errors' => false ] );

    },


    '_UserBlockCommandFactory' => static function ( MediaWikiServices $services ): UserBlockCommandFactory {

        return new UserBlockCommandFactory(

            new ServiceOptions( UserBlockCommandFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),

            $services->getHookContainer(),

            $services->getBlockPermissionCheckerFactory(),

            $services->getBlockTargetFactory(),

            $services->getDatabaseBlockStore(),

            $services->getBlockRestrictionStore(),

            $services->getUserFactory(),

            $services->getUserEditTracker(),

            LoggerFactory::getInstance( 'BlockManager' ),

            $services->getTitleFactory(),

            $services->getBlockActionInfo()

        );

    }


];


// @codeCoverageIgnoreEnd

wfIsCLI
wfIsCLI()
Check if we are running from the commandline.
Definition BootstrapHelperFunctions.php:93

CACHE_ACCEL
const CACHE_ACCEL
Definition Defines.php:76

wfWarn
wfWarn( $msg, $callerOffset=1, $level=E_USER_NOTICE)
Send a warning either to the debug log or in a PHP error depending on $wgDevelopmentWarnings.
Definition GlobalFunctions.php:563

wfShellExec
wfShellExec( $cmd, &$retval=null, $environ=[], $limits=[], $options=[])
Execute a shell command, with time and memory limits mirrored from the PHP configuration if supported...
Definition GlobalFunctions.php:1301

wfHostname
wfHostname()
Get host name of the current machine, for use in error reporting.
Definition GlobalFunctions.php:670

wfMessage
wfMessage( $key,... $params)
This is the function for getting translated interface messages.
Definition GlobalFunctions.php:602

return
return['ActionFactory'=> static function(MediaWikiServices $services):ActionFactory { return new ActionFactory($services->getMainConfig() ->get(MainConfigNames::Actions), LoggerFactory::getInstance( 'ActionFactory'), $services->getObjectFactory(), $services->getHookContainer(), $services->getContentHandlerFactory());}, 'ActorMigration'=> static function(MediaWikiServices $services):ActorMigration { return new ActorMigration($services->getActorStoreFactory());}, 'ActorNormalization'=> static function(MediaWikiServices $services):ActorNormalization { return $services->getActorStoreFactory() ->getActorNormalization();}, 'ActorStore'=> static function(MediaWikiServices $services):ActorStore { return $services->getActorStoreFactory() ->getActorStore();}, 'ActorStoreFactory'=> static function(MediaWikiServices $services):ActorStoreFactory { return new ActorStoreFactory(new ServiceOptions(ActorStoreFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getDBLoadBalancerFactory(), $services->getUserNameUtils(), $services->getTempUserConfig(), LoggerFactory::getInstance( 'ActorStore'), $services->getHideUserUtils());}, 'ArchivedRevisionLookup'=> static function(MediaWikiServices $services):ArchivedRevisionLookup { return new ArchivedRevisionLookup($services->getConnectionProvider(), $services->getRevisionStore());}, 'AuthManager'=> static function(MediaWikiServices $services):AuthManager { $authManager=new AuthManager(RequestContext::getMain() ->getRequest(), $services->getMainConfig(), $services->getChangeTagsStore(), $services->getObjectFactory(), $services->getObjectCacheFactory(), $services->getHookContainer(), $services->getReadOnlyMode(), $services->getUserNameUtils(), $services->getBlockManager(), $services->getWatchlistManager(), $services->getDBLoadBalancer(), $services->getContentLanguage(), $services->getLanguageConverterFactory(), $services->getBotPasswordStore(), $services->getUserFactory(), $services->getUserIdentityLookup(), $services->getUserIdentityUtils(), $services->getUserOptionsManager(), $services->getNotificationService(), $services->getSessionManager());$authManager->setLogger(LoggerFactory::getInstance( 'authentication'));$authManager->setAuthEventsLogger(LoggerFactory::getInstance( 'authevents'));return $authManager;}, 'AutoblockExemptionList'=> static function(MediaWikiServices $services):AutoblockExemptionList { $messageFormatterFactory=new MessageFormatterFactory(Message::FORMAT_PLAIN);return new AutoblockExemptionList(new ServiceOptions(AutoblockExemptionList::CONSTRUCTOR_OPTIONS, $services->getMainConfig(),), LoggerFactory::getInstance( 'AutoblockExemptionList'), $messageFormatterFactory->getTextFormatter($services->getContentLanguageCode() ->toString()));}, 'BacklinkCacheFactory'=> static function(MediaWikiServices $services):BacklinkCacheFactory { return new BacklinkCacheFactory(new ServiceOptions(BacklinkCache::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getLinksMigration(), $services->getMainWANObjectCache(), $services->getHookContainer(), $services->getConnectionProvider(), $services->getRestrictionStore(), LoggerFactory::getInstance( 'BacklinkCache'));}, 'BadFileLookup'=> static function(MediaWikiServices $services):BadFileLookup { return new BadFileLookup(static function() { return wfMessage( 'bad_image_list') ->inContentLanguage() ->plain();}, $services->getLocalServerObjectCache(), $services->getRepoGroup(), $services->getTitleParser(), $services->getHookContainer());}, 'BlobStore'=> static function(MediaWikiServices $services):BlobStore { return $services->getService( '_SqlBlobStore');}, 'BlobStoreFactory'=> static function(MediaWikiServices $services):BlobStoreFactory { return new BlobStoreFactory($services->getDBLoadBalancerFactory(), $services->getExternalStoreAccess(), $services->getMainWANObjectCache(), new ServiceOptions(BlobStoreFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'BlockActionInfo'=> static function(MediaWikiServices $services):BlockActionInfo { return new BlockActionInfo( $services->getHookContainer());}, 'BlockErrorFormatter'=> static function(MediaWikiServices $services):BlockErrorFormatter { return $services->getFormatterFactory() ->getBlockErrorFormatter(new LazyLocalizationContext(RequestContext::getMain(...)));}, 'BlockManager'=> static function(MediaWikiServices $services):BlockManager { return new BlockManager(new ServiceOptions(BlockManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getUserFactory(), $services->getUserIdentityUtils(), LoggerFactory::getInstance( 'BlockManager'), $services->getHookContainer(), $services->getDatabaseBlockStore(), $services->getBlockTargetFactory(), $services->getProxyLookup());}, 'BlockPermissionCheckerFactory'=> static function(MediaWikiServices $services):BlockPermissionCheckerFactory { return new BlockPermissionCheckerFactory(new ServiceOptions(BlockPermissionCheckerFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getBlockTargetFactory());}, 'BlockRestrictionStore'=> static function(MediaWikiServices $services):BlockRestrictionStore { return $services->getBlockRestrictionStoreFactory() ->getBlockRestrictionStore(WikiAwareEntity::LOCAL);}, 'BlockRestrictionStoreFactory'=> static function(MediaWikiServices $services):BlockRestrictionStoreFactory { return new BlockRestrictionStoreFactory($services->getDBLoadBalancerFactory());}, 'BlockTargetFactory'=> static function(MediaWikiServices $services):BlockTargetFactory { return $services->getCrossWikiBlockTargetFactory() ->getFactory();}, 'BlockUserFactory'=> static function(MediaWikiServices $services):BlockUserFactory { return $services->getService( '_UserBlockCommandFactory');}, 'BlockUtils'=> static function(MediaWikiServices $services):BlockUtils { return $services->getBlockUtilsFactory() ->getBlockUtils();}, 'BlockUtilsFactory'=> static function(MediaWikiServices $services):BlockUtilsFactory { return new BlockUtilsFactory($services->getCrossWikiBlockTargetFactory());}, 'BotPasswordStore'=> static function(MediaWikiServices $services):BotPasswordStore { return new BotPasswordStore(new ServiceOptions(BotPasswordStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getCentralIdLookup(), $services->getDBLoadBalancerFactory());}, 'CentralIdLookup'=> static function(MediaWikiServices $services):CentralIdLookup { return $services->getCentralIdLookupFactory() ->getLookup();}, 'CentralIdLookupFactory'=> static function(MediaWikiServices $services):CentralIdLookupFactory { return new CentralIdLookupFactory(new ServiceOptions(CentralIdLookupFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getObjectFactory(), $services->getUserIdentityLookup(), $services->getUserFactory());}, 'ChangesListQueryFactory'=> static function(MediaWikiServices $services):ChangesListQueryFactory { return new ChangesListQueryFactory(new ServiceOptions(ChangesListQueryFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getRecentChangeLookup(), $services->getWatchedItemStore(), $services->getTempUserConfig(), $services->getUserFactory(), $services->getLinkTargetLookup(), $services->getChangeTagsStore(), $services->getStatsFactory(), $services->getSlotRoleStore(), LoggerFactory::getInstance( 'ChangesListQuery'), $services->getConnectionProvider(),);}, 'ChangeTagDefStore'=> static function(MediaWikiServices $services):NameTableStore { return $services->getNameTableStoreFactory() ->getChangeTagDef();}, 'ChangeTagsFormatter'=> static function(MediaWikiServices $services):ChangeTagsFormatter { return new ChangeTagsFormatter(new ServiceOptions(ChangeTagsFormatter::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getChangeTagsStore(), $services->getMainWANObjectCache(), $services->getLanguageFactory(),);}, 'ChangeTagsStore'=> static function(MediaWikiServices $services):ChangeTagsStore { return $services->getChangeTagsStoreFactory() ->getChangeTagsStore();}, 'ChangeTagsStoreFactory'=> static function(MediaWikiServices $services):ChangeTagsStoreFactory { return new ChangeTagsStoreFactory($services->getConnectionProvider(), $services->getNameTableStoreFactory(), $services->getMainWANObjectCache(), $services->getHookContainer(), LoggerFactory::getInstance( 'ChangeTags'), $services->getUserFactory(), new ServiceOptions(ChangeTagsStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'ChangeToolsFactory'=> static function(MediaWikiServices $services):ChangeToolsFactory { return new ChangeToolsFactory(new HookRunner( $services->getHookContainer()), $services->getLinkRenderer(),);}, 'ChronologyProtector'=> static function(MediaWikiServices $services):ChronologyProtector { $mainConfig=$services->getMainConfig();$microStashIsDatabase=$services->getObjectCacheFactory() ->isDatabaseId($mainConfig->get(MainConfigNames::MicroStashType));$cpStash=$microStashIsDatabase ? new EmptyBagOStuff() :$services->getMicroStash();$chronologyProtector=new ChronologyProtector($cpStash, $mainConfig->get(MainConfigNames::ChronologyProtectorSecret), MW_ENTRY_POINT==='cli', LoggerFactory::getInstance( 'rdbms'));$req=RequestContext::getMain() ->getRequest();$reqStart=(int)( $_SERVER['REQUEST_TIME_FLOAT'] ?? time());$cpPosInfo=ChronologyProtector::getCPInfoFromCookieValue($req->getCookie( 'cpPosIndex', ''), $reqStart - ChronologyProtector::POSITION_COOKIE_TTL);$chronologyProtector->setRequestInfo(['IPAddress'=> $req->getIP(), 'UserAgent'=> $req->getHeader( 'User-Agent'), 'ChronologyPositionIndex'=> $req->getInt( 'cpPosIndex', $cpPosInfo['index']), 'ChronologyClientId'=> $cpPosInfo['clientId'] ?? null,]);return $chronologyProtector;}, 'CodeHighlighter'=> static function(MediaWikiServices $services):CodeHighlighter { return new CodeHighlighter($services->getObjectFactory(), ExtensionRegistry::getInstance() ->getAttribute( 'CodeHighlightProviders'),);}, 'CollationFactory'=> static function(MediaWikiServices $services):CollationFactory { return new CollationFactory(new ServiceOptions(CollationFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getObjectFactory(), $services->getHookContainer());}, 'CommentFormatter'=> static function(MediaWikiServices $services):CommentFormatter { return new CommentFormatter($services->getCommentParserFactory());}, 'CommentParserFactory'=> static function(MediaWikiServices $services):CommentParserFactory { return new CommentParserFactory($services->getLinkRendererFactory() ->create([ 'renderForComment'=> true]), $services->getLinkBatchFactory(), $services->getLinkCache(), $services->getRepoGroup(), $services->getContentLanguage(), $services->getTitleParser(), $services->getNamespaceInfo(), $services->getHookContainer());}, 'CommentStore'=> static function(MediaWikiServices $services):CommentStore { return new CommentStore( $services->getContentLanguage());}, 'ConfigFactory'=> static function(MediaWikiServices $services):ConfigFactory { $registry=$services->getBootstrapConfig() ->get(MainConfigNames::ConfigRegistry);$factory=new ConfigFactory();foreach( $registry as $name=> $callback) { $factory->register( $name, $callback);} return $factory;}, 'ConfigRepository'=> static function(MediaWikiServices $services):ConfigRepository { return new ConfigRepository( $services->getConfigFactory());}, 'ConfigSchema'=> static function(MediaWikiServices $services):ConfigSchema { $settings=$services->get( '_SettingsBuilder');return $settings->getConfigSchema();}, 'ConfiguredReadOnlyMode'=> static function(MediaWikiServices $services):ConfiguredReadOnlyMode { $config=$services->getMainConfig();return new ConfiguredReadOnlyMode($config->get(MainConfigNames::ReadOnly), $config->get(MainConfigNames::ReadOnlyFile));}, 'ConfirmEmailBuilderFactory'=> static function(MediaWikiServices $services):ConfirmEmailBuilderFactory { return new ConfirmEmailBuilderFactory($services->getLocalServerObjectCache(), $services->getUrlUtils());}, 'ConfirmEmailSender'=> static function(MediaWikiServices $services):ConfirmEmailSender { return new ConfirmEmailSender(new ServiceOptions(ConfirmEmailSender::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), new HookRunner( $services->getHookContainer()), $services->getUserFactory(), $services->getEmailer(), $services->getConfirmEmailBuilderFactory(), LoggerFactory::getInstance( 'confirmemail'));}, 'ConnectionProvider'=> static function(MediaWikiServices $services):IConnectionProvider { return $services->getDBLoadBalancerFactory();}, 'ContentHandlerFactory'=> static function(MediaWikiServices $services):IContentHandlerFactory { $contentHandlerConfig=$services->getMainConfig() ->get(MainConfigNames::ContentHandlers);return new ContentHandlerFactory($contentHandlerConfig, $services->getObjectFactory(), $services->getHookContainer(), LoggerFactory::getInstance( 'ContentHandler'));}, 'ContentJsonCodec'=> static function(MediaWikiServices $services):ContentJsonCodec { return new ContentJsonCodec($services->getContentHandlerFactory(),);}, 'ContentLanguage'=> static function(MediaWikiServices $services):Language { return $services->getLanguageFactory() ->getLanguage($services->getMainConfig() ->get(MainConfigNames::LanguageCode));}, 'ContentLanguageCode'=> static function(MediaWikiServices $services):LanguageCode { return $services->getLanguageFactory() ->getLanguageCode($services->getMainConfig() ->get(MainConfigNames::LanguageCode));}, 'ContentModelChangeFactory'=> static function(MediaWikiServices $services):ContentModelChangeFactory { return $services->getService( '_PageCommandFactory');}, 'ContentModelStore'=> static function(MediaWikiServices $services):NameTableStore { return $services->getNameTableStoreFactory() ->getContentModels();}, 'ContentRenderer'=> static function(MediaWikiServices $services):ContentRenderer { return new ContentRenderer($services->getContentHandlerFactory(), $services->getGlobalIdGenerator());}, 'ContentTransformer'=> static function(MediaWikiServices $services):ContentTransformer { return new ContentTransformer( $services->getContentHandlerFactory());}, 'CriticalSectionProvider'=> static function(MediaWikiServices $services):CriticalSectionProvider { $config=$services->getMainConfig();$limit=MW_ENTRY_POINT==='cli' ? INF :$config->get(MainConfigNames::CriticalSectionTimeLimit);return RequestTimeout::singleton() ->createCriticalSectionProvider( $limit);}, 'CrossWikiBlockTargetFactory'=> static function(MediaWikiServices $services):CrossWikiBlockTargetFactory { return new CrossWikiBlockTargetFactory(new ServiceOptions(CrossWikiBlockTargetFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getActorStoreFactory(), $services->getUserNameUtils());}, 'DatabaseBlockStore'=> static function(MediaWikiServices $services):DatabaseBlockStore { return $services->getDatabaseBlockStoreFactory() ->getDatabaseBlockStore(DatabaseBlock::LOCAL);}, 'DatabaseBlockStoreFactory'=> static function(MediaWikiServices $services):DatabaseBlockStoreFactory { return new DatabaseBlockStoreFactory(new ServiceOptions(DatabaseBlockStoreFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), LoggerFactory::getInstance( 'DatabaseBlockStore'), $services->getActorStoreFactory(), $services->getBlockRestrictionStoreFactory(), $services->getCommentStore(), $services->getHookContainer(), $services->getDBLoadBalancerFactory(), $services->getReadOnlyMode(), $services->getUserFactory(), $services->getTempUserConfig(), $services->getCrossWikiBlockTargetFactory(), $services->getAutoblockExemptionList(), $services->getSessionManager());}, 'DatabaseFactory'=> static function(MediaWikiServices $services):DatabaseFactory { return new DatabaseFactory(['debugSql'=> $services->getMainConfig() ->get(MainConfigNames::DebugDumpSql), 'tracer'=> $services->getTracer(),]);}, 'DateFormatterFactory'=> static function(MediaWikiServices $services):DateFormatterFactory { return new DateFormatterFactory();}, 'DBLoadBalancer'=> static function(MediaWikiServices $services):Wikimedia\Rdbms\ILoadBalancer { return $services->getDBLoadBalancerFactory() ->getMainLB();}, 'DBLoadBalancerFactory'=> static function(MediaWikiServices $services):Wikimedia\Rdbms\LBFactory { $lbConf=$services->getDBLoadBalancerFactoryConfig() ->getConfig();$mainConfig=$services->getMainConfig();if( $services->getObjectCacheFactory() ->isDatabaseId($mainConfig->get(MainConfigNames::MainCacheType))) { $wanCache=WANObjectCache::newEmpty();} else { $wanCache=$services->getMainWANObjectCache();} $srvCache=$services->getLocalServerObjectCache();if( $srvCache instanceof EmptyBagOStuff) { $srvCache=new HashBagOStuff([ 'maxKeys'=> 100]);} $lbFactoryConfigBuilder=new MWLBFactory(new ConfiguredReadOnlyMode($mainConfig->get(MainConfigNames::ReadOnly), $mainConfig->get(MainConfigNames::ReadOnlyFile)), $services->getChronologyProtector(), $srvCache, $wanCache, $services->getCriticalSectionProvider(), $services->getStatsFactory(), $services->getTracer(), RequestContext::getMain() ->getRequest() ->getIP());$lbConf=$lbFactoryConfigBuilder->applyServices( $lbConf);$class=$lbFactoryConfigBuilder->getLBFactoryClass( $lbConf);$instance=new $class( $lbConf);$lbFactoryConfigBuilder->setDomainAliases( $instance);return $instance;}, 'DBLoadBalancerFactoryConfig'=> static function(MediaWikiServices $services):MWLBConfig { return new MWLBConfig(new ServiceOptions(MWLBConfig::APPLY_DEFAULT_CONFIG_OPTIONS, $services->getMainConfig()), ExtensionRegistry::getInstance() ->getAttribute( 'DatabaseVirtualDomains'), $services->getMainConfig() ->get(MainConfigNames::LBFactoryConf));}, 'DefaultOutputPipeline'=> static function(MediaWikiServices $services):OutputTransformPipeline { return $services->getDefaultOutputPipelineFactory() ->buildDefaultOutputPipeline();}, 'DefaultOutputPipelineFactory'=> static function(MediaWikiServices $services):DefaultOutputPipelineFactory { return new DefaultOutputPipelineFactory(new ServiceOptions(DefaultOutputPipelineFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getMainConfig(), LoggerFactory::getInstance( 'Parser'), $services->getObjectFactory());}, 'DeletePageFactory'=> static function(MediaWikiServices $services):DeletePageFactory { return $services->getService( '_PageCommandFactory');}, 'DomainEventDispatcher'=> static function(MediaWikiServices $services):DomainEventDispatcher { return $services->getService( '_DomainEventDispatcher');}, 'DomainEventSource'=> static function(MediaWikiServices $services):DomainEventSource { return $services->getService( '_DomainEventDispatcher');}, 'EmailConfirmationBannerHandler'=> static function(MediaWikiServices $services):EmailConfirmationBannerHandler { return new EmailConfirmationBannerHandler(new ServiceOptions(EmailConfirmationBannerHandler::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'Emailer'=> static function(MediaWikiServices $services):IEmailer { return new Emailer();}, 'EmailUserFactory'=> static function(MediaWikiServices $services):EmailUserFactory { return new EmailUserFactory(new ServiceOptions(EmailUser::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getHookContainer(), $services->getUserOptionsLookup(), $services->getCentralIdLookup(), $services->getUserFactory(), $services->getEmailer(), $services->getMessageFormatterFactory(), $services->getMessageFormatterFactory() ->getTextFormatter($services->getContentLanguageCode() ->toString()));}, 'EventRelayerGroup'=> static function(MediaWikiServices $services):EventRelayerGroup { return new EventRelayerGroup( $services->getMainConfig() ->get(MainConfigNames::EventRelayerConfig));}, 'ExtensionRegistry'=> static function(MediaWikiServices $services):ExtensionRegistry { return ExtensionRegistry::getInstance();}, 'ExternalStoreAccess'=> static function(MediaWikiServices $services):ExternalStoreAccess { return new ExternalStoreAccess($services->getExternalStoreFactory(), LoggerFactory::getInstance( 'ExternalStore'));}, 'ExternalStoreFactory'=> static function(MediaWikiServices $services):ExternalStoreFactory { $config=$services->getMainConfig();$writeStores=$config->get(MainConfigNames::DefaultExternalStore);return new ExternalStoreFactory($config->get(MainConfigNames::ExternalStores),( $writeStores !==false) ?(array) $writeStores :[], $services->getDBLoadBalancer() ->getLocalDomainID(), LoggerFactory::getInstance( 'ExternalStore'));}, 'FeatureShutdown'=> static function(MediaWikiServices $services):FeatureShutdown { return new FeatureShutdown(new ServiceOptions(FeatureShutdown::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'FileBackendGroup'=> static function(MediaWikiServices $services):FileBackendGroup { $mainConfig=$services->getMainConfig();$ld=WikiMap::getCurrentWikiDbDomain();$fallbackWikiId=WikiMap::getWikiIdFromDbDomain( $ld);$legacyDomainId=strlen( $ld->getTablePrefix()) ? "{$ld->getDatabase()}-{$ld->getTablePrefix()}" :$ld->getDatabase();if( $ld->getSchema() !==null && $legacyDomainId !==$fallbackWikiId) { wfWarn("Legacy default 'domainId' is '$legacyDomainId' but wiki ID is '$fallbackWikiId'.");} $cache=$services->getLocalServerObjectCache();if( $cache instanceof EmptyBagOStuff) { $cache=new HashBagOStuff();} return new FileBackendGroup(new ServiceOptions(FileBackendGroup::CONSTRUCTOR_OPTIONS, $mainConfig, [ 'fallbackWikiId'=> $fallbackWikiId]), $services->getReadOnlyMode(), $cache, $services->getMainWANObjectCache(), $services->getMimeAnalyzer(), $services->getLockManagerGroupFactory(), $services->getTempFSFileFactory(), $services->getTracer());}, 'FormatterFactory'=> static function(MediaWikiServices $services):FormatterFactory { return new FormatterFactory($services->getMessageParser(), $services->getTitleFormatter(), $services->getHookContainer(), $services->getUserIdentityUtils(), $services->getLanguageFactory(), LoggerFactory::getInstance( 'status'));}, 'GenderCache'=> static function(MediaWikiServices $services):GenderCache { $nsInfo=$services->getNamespaceInfo();if( $services->isServiceDisabled( 'DBLoadBalancer')) { $userOptionsLookup=new StaticUserOptionsLookup([], $services->getMainConfig() ->get(MainConfigNames::DefaultUserOptions));} else { $userOptionsLookup=$services->getUserOptionsLookup();} return new GenderCache( $nsInfo, $userOptionsLookup);}, 'GlobalIdGenerator'=> static function(MediaWikiServices $services):GlobalIdGenerator { $mainConfig=$services->getMainConfig();return new GlobalIdGenerator($mainConfig->get(MainConfigNames::TmpDirectory), static function( $command) { return wfShellExec( $command);});}, 'GrantsInfo'=> static function(MediaWikiServices $services):GrantsInfo { return new GrantsInfo(new ServiceOptions(GrantsInfo::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'GrantsLocalization'=> static function(MediaWikiServices $services):GrantsLocalization { return new GrantsLocalization($services->getGrantsInfo(), $services->getLinkRenderer(), $services->getLanguageFactory(), $services->getContentLanguage());}, 'GroupPermissionsLookup'=> static function(MediaWikiServices $services):GroupPermissionsLookup { return new GroupPermissionsLookup(new ServiceOptions(GroupPermissionsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'HideUserUtils'=> static function(MediaWikiServices $services):HideUserUtils { return new HideUserUtils();}, 'HookContainer'=> static function(MediaWikiServices $services):HookContainer { $configHooks=$services->getBootstrapConfig() ->get(MainConfigNames::Hooks);$extRegistry=ExtensionRegistry::getInstance();$extHooks=$extRegistry->getAttribute( 'Hooks');$extDeprecatedHooks=$extRegistry->getAttribute( 'DeprecatedHooks');return new HookContainer(new StaticHookRegistry( $configHooks, $extHooks, $extDeprecatedHooks), $services->getObjectFactory());}, 'HTMLCacheUpdater'=> static function(MediaWikiServices $services):HTMLCacheUpdater { $config=$services->getMainConfig();return new HTMLCacheUpdater($services->getHookContainer(), $services->getTitleFactory(), $config->get(MainConfigNames::CdnReboundPurgeDelay), $config->get(MainConfigNames::UseFileCache), $config->get(MainConfigNames::CdnMaxAge));}, 'HtmlTransformFactory'=> static function(MediaWikiServices $services):HtmlTransformFactory { return new HtmlTransformFactory($services->getService( '_Parsoid'), $services->getMainConfig() ->get(MainConfigNames::ParsoidSettings), $services->getParsoidPageConfigFactory(), $services->getContentHandlerFactory(), $services->getParsoidSiteConfig(), $services->getTitleFactory(), $services->getLanguageConverterPipeline(), $services->getLanguageFactory());}, 'HttpRequestFactory'=> static function(MediaWikiServices $services):HttpRequestFactory { return new HttpRequestFactory(new ServiceOptions(HttpRequestFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), LoggerFactory::getInstance( 'http'), $services->getTracer());}, 'InterwikiLookup'=> static function(MediaWikiServices $services):InterwikiLookup { return new ClassicInterwikiLookup(new ServiceOptions(ClassicInterwikiLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig(), [ 'wikiId'=> WikiMap::getCurrentWikiId()]), $services->getContentLanguage(), $services->getMainWANObjectCache(), $services->getHookContainer(), $services->getConnectionProvider(), $services->getLanguageNameUtils());}, 'IntroMessageBuilder'=> static function(MediaWikiServices $services):IntroMessageBuilder { return new IntroMessageBuilder($services->getMainConfig(), $services->getLinkRenderer(), $services->getPermissionManager(), $services->getUserNameUtils(), $services->getTempUserCreator(), $services->getUserFactory(), $services->getRestrictionStore(), $services->getDatabaseBlockStore(), $services->getReadOnlyMode(), $services->getSpecialPageFactory(), $services->getRepoGroup(), $services->getNamespaceInfo(), $services->getSkinFactory(), $services->getConnectionProvider(), $services->getUrlUtils(), $services->getShadowPageLoader(),);}, 'JobFactory'=> static function(MediaWikiServices $services):JobFactory { return new JobFactory($services->getObjectFactory(), $services->getMainConfig() ->get(MainConfigNames::JobClasses));}, 'JobQueueGroup'=> static function(MediaWikiServices $services):JobQueueGroup { return $services->getJobQueueGroupFactory() ->makeJobQueueGroup();}, 'JobQueueGroupFactory'=> static function(MediaWikiServices $services):JobQueueGroupFactory { return new JobQueueGroupFactory(new ServiceOptions(JobQueueGroupFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getReadOnlyMode(), $services->getStatsFactory(), $services->getObjectCacheFactory() ->getLocalClusterInstance(), $services->getGlobalIdGenerator());}, 'JobRunner'=> static function(MediaWikiServices $services):JobRunner { return new JobRunner(new ServiceOptions(JobRunner::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getDBLoadBalancerFactory(), $services->getJobQueueGroup(), $services->getReadOnlyMode(), $services->getLinkCache(), $services->getStatsFactory(), LoggerFactory::getInstance( 'runJobs'));}, 'JsonCodec'=> static function(MediaWikiServices $services):JsonCodec { return new JsonCodec( $services);}, 'JwtCodec'=> static function(MediaWikiServices $services):JwtCodec { return new RsaJwtCodec(new ServiceOptions(RsaJwtCodec::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'LanguageConverterFactory'=> static function(MediaWikiServices $services):LanguageConverterFactory { return new LanguageConverterFactory(new ServiceOptions(LanguageConverterFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getObjectFactory(), static function() use( $services) { return $services->getContentLanguage();});}, 'LanguageConverterPipeline'=> static function(MediaWikiServices $services):OutputTransformPipeline { return $services->getDefaultOutputPipelineFactory() ->buildLanguageConverterPipeline();}, 'LanguageFactory'=> static function(MediaWikiServices $services):LanguageFactory { return new LanguageFactory(new ServiceOptions(LanguageFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getNamespaceInfo(), $services->getLocalisationCache(), $services->getLanguageNameUtils(), $services->getLanguageFallback(), $services->getLanguageConverterFactory(), $services->getHookContainer(), $services->getMainConfig(), $services->getLeximorphFactory());}, 'LanguageFallback'=> static function(MediaWikiServices $services):LanguageFallback { return new LanguageFallback($services->getMainConfig() ->get(MainConfigNames::LanguageCode), $services->getLocalisationCache(), $services->getLanguageNameUtils());}, 'LanguageNameSearch'=> static function(MediaWikiServices $services):LanguageNameSearch { return new LanguageNameSearch($services->getLanguageNameUtils());}, 'LanguageNameUtils'=> static function(MediaWikiServices $services):LanguageNameUtils { return new LanguageNameUtils(new ServiceOptions(LanguageNameUtils::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getHookContainer());}, 'LeximorphFactory'=> static function(MediaWikiServices $services):LeximorphFactory { return new LeximorphFactory(new MediaWiki\Config\ServiceOptions(MediaWiki\Language\LeximorphFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), LoggerFactory::getInstance( 'leximorph'));}, 'LinkBatchFactory'=> static function(MediaWikiServices $services):LinkBatchFactory { return new LinkBatchFactory($services->getLinkCache(), $services->getTitleFormatter(), $services->getContentLanguage(), $services->getGenderCache(), $services->getConnectionProvider(), $services->getLinksMigration(), $services->getTempUserDetailsLookup(), LoggerFactory::getInstance( 'LinkBatch'));}, 'LinkCache'=> static function(MediaWikiServices $services):LinkCache { $dbLoadBalancer=$services->isServiceDisabled( 'DBLoadBalancer') ? null :$services->getDBLoadBalancer();$linkCache=new LinkCache($services->getTitleFormatter(), $services->getMainWANObjectCache(), $services->getNamespaceInfo(), $dbLoadBalancer);$linkCache->setLogger(LoggerFactory::getInstance( 'LinkCache'));return $linkCache;}, 'LinkRenderer'=> static function(MediaWikiServices $services):LinkRenderer { return $services->getLinkRendererFactory() ->create();}, 'LinkRendererFactory'=> static function(MediaWikiServices $services):LinkRendererFactory { return new LinkRendererFactory($services->getTitleFormatter(), $services->getLinkCache(), $services->getSpecialPageFactory(), $services->getHookContainer(), $services->getTempUserConfig(), $services->getTempUserDetailsLookup(), $services->getUserIdentityLookup(), $services->getUserNameUtils(), $services->getUrlUtils(), new ServiceOptions(LinkRendererFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'LinksMigration'=> static function(MediaWikiServices $services):LinksMigration { return new LinksMigration($services->getMainConfig(), $services->getLinkTargetLookup());}, 'LinkTargetLookup'=> static function(MediaWikiServices $services):LinkTargetLookup { return new LinkTargetStore($services->getConnectionProvider(), $services->getLocalServerObjectCache(), $services->getMainWANObjectCache());}, 'LinkWriteDuplicator'=> static function(MediaWikiServices $services):WriteDuplicator { return new WriteDuplicator($services->getConnectionProvider(), ExternalLinksTable::VIRTUAL_DOMAIN, array_key_exists(ExternalLinksTable::VIRTUAL_DOMAIN, $services->getMainConfig() ->get(MainConfigNames::VirtualDomainsMapping)));}, 'LintErrorChecker'=> static function(MediaWikiServices $services):LintErrorChecker { return new LintErrorChecker($services->get( '_Parsoid'), $services->getParsoidPageConfigFactory(), $services->getTitleFactory(), ExtensionRegistry::getInstance(), $services->getMainConfig(),);}, 'LocalisationCache'=> static function(MediaWikiServices $services):LocalisationCache { $conf=$services->getMainConfig() ->get(MainConfigNames::LocalisationCacheConf);$logger=LoggerFactory::getInstance( 'localisation');$store=LocalisationCache::getStoreFromConf($conf, $services->getMainConfig() ->get(MainConfigNames::CacheDirectory));$logger->debug( 'LocalisationCache using store ' . get_class( $store));return new $conf['class'](new ServiceOptions(LocalisationCache::CONSTRUCTOR_OPTIONS, $conf, ['forceRecache'=> false, 'manualRecache'=> false,], $services->getMainConfig()), $store, $logger, [static function() use( $services) { MessageBlobStore::clearGlobalCacheEntry( $services->getMainWANObjectCache());}], $services->getLanguageNameUtils(), $services->getHookContainer());}, 'LocalServerObjectCache'=> static function(MediaWikiServices $services):BagOStuff { return $services->getObjectCacheFactory() ->getInstance(CACHE_ACCEL);}, 'LockManager'=> static function(MediaWikiServices $services):LockManager { if(defined( 'MW_PHPUNIT_TEST')) { return new NullLockManager([]);} $lockManager=$services->getMainConfig() ->get(MainConfigNames::DefaultLockManager);if(! $lockManager) { return new DatabaseLockManager(['domain'=> WikiMap::getCurrentWikiDbDomain() ->getId(), 'dbProvider'=> $services->getConnectionProvider(), 'logger'=> LoggerFactory::getInstance( 'lockManager')]);} return $services->getLockManagerGroupFactory() ->getLockManagerGroup(WikiMap::getCurrentWikiDbDomain() ->getId()) ->get( $lockManager);}, 'LockManagerGroupFactory'=> static function(MediaWikiServices $services):LockManagerGroupFactory { return new LockManagerGroupFactory(WikiMap::getCurrentWikiDbDomain() ->getId(), $services->getMainConfig() ->get(MainConfigNames::LockManagers));}, 'LogFormatterFactory'=> static function(MediaWikiServices $services):LogFormatterFactory { return new LogFormatterFactory(new ServiceOptions(LogFormatterFactory::SERVICE_OPTIONS, $services->getMainConfig()), $services->getObjectFactory(), $services->getHookContainer(), $services->getLinkRenderer(), $services->getContentLanguage(), $services->getCommentFormatter(), $services->getUserEditTracker());}, 'MagicWordFactory'=> static function(MediaWikiServices $services):MagicWordFactory { return new MagicWordFactory($services->getContentLanguage(), $services->getHookContainer());}, 'MainConfig'=> static function(MediaWikiServices $services):Config { return $services->getConfigFactory() ->makeConfig( 'main');}, 'MainObjectStash'=> static function(MediaWikiServices $services):BagOStuff { $mainConfig=$services->getMainConfig();$id=$mainConfig->get(MainConfigNames::MainStash);$store=$services->getObjectCacheFactory() ->getInstance( $id);$store->getLogger() ->debug( 'MainObjectStash using store {class}', ['class'=> get_class( $store)]);return $store;}, 'MainWANObjectCache'=> static function(MediaWikiServices $services):WANObjectCache { $mainConfig=$services->getMainConfig();$store=$services->getObjectCacheFactory() ->getLocalClusterInstance();$logger=$store->getLogger();$logger->debug( 'MainWANObjectCache using store {class}', ['class'=> get_class( $store)]);$wanParams=$mainConfig->get(MainConfigNames::WANObjectCache)+['cache'=> $store, 'logger'=> $logger, 'tracer'=> $services->getTracer(),];if(MW_ENTRY_POINT !=='cli') { $wanParams['stats']=$services->getStatsFactory();$wanParams['asyncHandler']=DeferredUpdates::addCallableUpdate(...);} $lbConf=$services->getDBLoadBalancerFactoryConfig() ->getConfig();if(isset( $lbConf['servers']) &&count( $lbConf['servers'])===1 &&!defined( 'MW_PHPUNIT_TEST')) { $wanParams['pendingCallback']=static function() use( $services) { return $services->getDBLoadBalancer() ->hasOrMadeRecentPrimaryChanges();};} return new WANObjectCache( $wanParams);}, 'MediaHandlerFactory'=> static function(MediaWikiServices $services):MediaHandlerFactory { return new MediaHandlerFactory($services->getLanguageFactory(), LoggerFactory::getInstance( 'MediaHandlerFactory'), $services->getMainConfig() ->get(MainConfigNames::MediaHandlers));}, 'MergeHistoryFactory'=> static function(MediaWikiServices $services):MergeHistoryFactory { return $services->getService( '_PageCommandFactory');}, 'MessageCache'=> static function(MediaWikiServices $services):MessageCache { $mainConfig=$services->getMainConfig();$mainCache=$services->getObjectCacheFactory() ->getInstance( $mainConfig->get(MainConfigNames::MessageCacheType));$srvCache=$mainConfig->get(MainConfigNames::UseLocalMessageCache) ? $services->getLocalServerObjectCache() :new EmptyBagOStuff();$logger=LoggerFactory::getInstance( 'MessageCache');$logger->debug( 'MessageCache using store {class}', ['class'=> get_class( $mainCache)]);$options=new ServiceOptions(MessageCache::CONSTRUCTOR_OPTIONS, $mainConfig);return new MessageCache($services->getMainWANObjectCache(), $mainCache, $srvCache, $services->getContentLanguage(), $services->getLanguageConverterFactory(), $logger, $options, $services->getLocalisationCache(), $services->getLanguageNameUtils(), $services->getLanguageFallback(), $services->getHookContainer(), $services->getMessageParser());}, 'MessageFormatterFactory'=> static function(MediaWikiServices $services):IMessageFormatterFactory { return new MessageFormatterFactory();}, 'MessageParser'=> static function(MediaWikiServices $services):MessageParser { return new MessageParser($services->getParserFactory(), $services->getDefaultOutputPipeline(), $services->getLanguageFactory(), LoggerFactory::getInstance( 'MessageParser'));}, 'MicroStash'=> static function(MediaWikiServices $services):BagOStuff { $mainConfig=$services->getMainConfig();$id=$mainConfig->get(MainConfigNames::MicroStashType);$store=$services->getObjectCacheFactory() ->getInstance( $id);$store->getLogger() ->debug( 'MicroStash using store {class}', ['class'=> get_class( $store)]);return $store;}, 'MimeAnalyzer'=> static function(MediaWikiServices $services):MimeAnalyzer { $logger=LoggerFactory::getInstance( 'Mime');$mainConfig=$services->getMainConfig();$hookRunner=new HookRunner( $services->getHookContainer());$params=['typeFile'=> $mainConfig->get(MainConfigNames::MimeTypeFile), 'infoFile'=> $mainConfig->get(MainConfigNames::MimeInfoFile), 'xmlTypes'=> $mainConfig->get(MainConfigNames::XMLMimeTypes), 'guessCallback'=> static function($mimeAnalyzer, &$head, &$tail, $file, &$mime) use( $logger, $hookRunner) { $deja=new DjVuImage( $file);if( $deja->isValid()) { $logger->info("Detected $file as image/vnd.djvu\n");$mime='image/vnd.djvu';return;} $hookRunner->onMimeMagicGuessFromContent($mimeAnalyzer, $head, $tail, $file, $mime);}, 'extCallback'=> static function( $mimeAnalyzer, $ext, &$mime) use( $hookRunner) { $hookRunner->onMimeMagicImproveFromExtension( $mimeAnalyzer, $ext, $mime);}, 'initCallback'=> static function( $mimeAnalyzer) use( $hookRunner) { $hookRunner->onMimeMagicInit( $mimeAnalyzer);}, 'logger'=> $logger];if( $params['infoFile']==='includes/mime.info') { $params['infoFile']=MimeAnalyzer::USE_INTERNAL;} if( $params['typeFile']==='includes/mime.types') { $params['typeFile']=MimeAnalyzer::USE_INTERNAL;} $detectorCmd=$mainConfig->get(MainConfigNames::MimeDetectorCommand);if( $detectorCmd) { $factory=$services->getShellCommandFactory();$params['detectCallback']=static function( $file) use( $detectorCmd, $factory) { $result=$factory->create() ->unsafeParams( $detectorCmd) ->params( $file) ->execute();return $result->getStdout();};} return new MimeAnalyzer( $params);}, 'MovePageFactory'=> static function(MediaWikiServices $services):MovePageFactory { return $services->getService( '_PageCommandFactory');}, 'MultiFormatUserIdentityLookup'=> static function(MediaWikiServices $services):MultiFormatUserIdentityLookup { return new MultiFormatUserIdentityLookup($services->getActorStoreFactory(), $services->getUserFactory(), new ServiceOptions(MultiFormatUserIdentityLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'NamespaceInfo'=> static function(MediaWikiServices $services):NamespaceInfo { return new NamespaceInfo(new ServiceOptions(NamespaceInfo::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getHookContainer(), ExtensionRegistry::getInstance() ->getAttribute( 'ExtensionNamespaces'), ExtensionRegistry::getInstance() ->getAttribute( 'ImmovableNamespaces'));}, 'NameTableStoreFactory'=> static function(MediaWikiServices $services):NameTableStoreFactory { return new NameTableStoreFactory($services->getDBLoadBalancerFactory(), $services->getMainWANObjectCache(), LoggerFactory::getInstance( 'NameTableSqlStore'));}, 'NotificationEmailSender'=> static function(MediaWikiServices $services):NotificationEmailSender { return new NotificationEmailSender(new ServiceOptions(NotificationEmailSender::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getEmailer(), $services->getLocalServerObjectCache(), $services->getUrlUtils());}, 'NotificationService'=> static function(MediaWikiServices $services):NotificationService { $handlers=ExtensionRegistry::getInstance() ->getAttribute( 'NotificationHandlers');$handlers[]=NotificationService::RECENT_CHANGE_HANDLER_SPEC;return new NotificationService(LoggerFactory::getInstance( 'Notification'), $services->getObjectFactory(), $services->getService( '_NotificationMiddlewareChain'), $handlers);}, 'ObjectCacheFactory'=> static function(MediaWikiServices $services):ObjectCacheFactory { return new ObjectCacheFactory(new ServiceOptions(ObjectCacheFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getStatsFactory(), LoggerFactory::getProvider(), static function() use( $services) { return $services->getDBLoadBalancerFactory();}, WikiMap::getCurrentWikiDbDomain() ->getId(), $services->getTracer());}, 'ObjectFactory'=> static function(MediaWikiServices $services):ObjectFactory { return new ObjectFactory( $services);}, 'OldRevisionImporter'=> static function(MediaWikiServices $services):OldRevisionImporter { return new ImportableOldRevisionImporter(true, LoggerFactory::getInstance( 'OldRevisionImporter'), $services->getConnectionProvider(), $services->getRevisionStoreFactory() ->getRevisionStoreForImport(), $services->getSlotRoleRegistry(), $services->getWikiPageFactory(), $services->getPageUpdaterFactory(), $services->getUserFactory());}, 'PageEditStash'=> static function(MediaWikiServices $services):PageEditStash { return new PageEditStash($services->getObjectCacheFactory() ->getLocalClusterInstance(), $services->getConnectionProvider(), LoggerFactory::getInstance( 'StashEdit'), $services->getStatsFactory(), $services->getUserEditTracker(), $services->getUserFactory(), $services->getWikiPageFactory(), $services->getJsonCodec(), $services->getLockManager(), $services->getHookContainer(), defined( 'MEDIAWIKI_JOB_RUNNER')||MW_ENTRY_POINT==='cli' ? PageEditStash::INITIATOR_JOB_OR_CLI :PageEditStash::INITIATOR_USER);}, 'PageProps'=> static function(MediaWikiServices $services):PageProps { return new PageProps($services->getLinkBatchFactory(), $services->getConnectionProvider());}, 'PageRestHelperFactory'=> static function(MediaWikiServices $services):PageRestHelperFactory { return new PageRestHelperFactory(new ServiceOptions(PageRestHelperFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getRevisionLookup(), $services->getRevisionRenderer(), $services->getTitleFormatter(), $services->getPageStore(), $services->getParsoidOutputStash(), $services->getParserOutputAccess(), $services->getParsoidSiteConfig(), $services->getHtmlTransformFactory(), $services->getContentHandlerFactory(), $services->getLanguageFactory(), $services->getRedirectStore(), $services->getLanguageConverterFactory(), $services->getTitleFactory(), $services->getConnectionProvider(), $services->getChangeTagsStore(), $services->getStatsFactory(), $services->getShadowPageLoader(),);}, 'PageStore'=> static function(MediaWikiServices $services):PageStore { return $services->getPageStoreFactory() ->getPageStore();}, 'PageStoreFactory'=> static function(MediaWikiServices $services):PageStoreFactory { $options=new ServiceOptions(PageStoreFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig());return new PageStoreFactory($options, $services->getDBLoadBalancerFactory(), $services->getNamespaceInfo(), $services->getTitleParser(), $services->getLinkCache(), $services->getStatsFactory());}, 'PageUpdaterFactory'=> static function(MediaWikiServices $services):PageUpdaterFactory { $editResultCache=new EditResultCache($services->getMainObjectStash(), $services->getConnectionProvider(), new ServiceOptions(EditResultCache::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));return new PageUpdaterFactory($services->getRevisionStore(), $services->getRevisionRenderer(), $services->getSlotRoleRegistry(), $services->getParserCache(), $services->getJobQueueGroup(), $services->getContentLanguage(), $services->getDBLoadBalancerFactory(), $services->getContentHandlerFactory(), $services->getDomainEventDispatcher(), $services->getHookContainer(), $editResultCache, LoggerFactory::getInstance( 'SavePage'), new ServiceOptions(PageUpdaterFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getUserGroupManager(), $services->getTitleFormatter(), $services->getContentTransformer(), $services->getPageEditStash(), $services->getMainWANObjectCache(), $services->getWikiPageFactory(), $services->getChangeTagsStore(), $services->getChangeTagsStore() ->getSoftwareTags());}, 'Parser'=> static function(MediaWikiServices $services):Parser { return $services->getParserFactory() ->getMainInstance();}, 'ParserCache'=> static function(MediaWikiServices $services):ParserCache { return $services->getParserCacheFactory() ->getParserCache(ParserCacheFactory::DEFAULT_NAME);}, 'ParserCacheFactory'=> static function(MediaWikiServices $services):ParserCacheFactory { $config=$services->getMainConfig();$cache=$services->getObjectCacheFactory() ->getInstance( $config->get(MainConfigNames::ParserCacheType));$wanCache=$services->getMainWANObjectCache();$options=new ServiceOptions(ParserCacheFactory::CONSTRUCTOR_OPTIONS, $config);return new ParserCacheFactory($cache, $wanCache, $services->getHookContainer(), $services->getJsonCodec(), $services->getStatsFactory(), LoggerFactory::getInstance( 'ParserCache'), $options, $services->getTitleFactory(), $services->getWikiPageFactory(), $services->getGlobalIdGenerator());}, 'ParserCoreTagHooks'=> static function(MediaWikiServices $services):ParserCoreTagHooks { $options=new ServiceOptions(ParserCoreTagHooks::CONSTRUCTOR_OPTIONS, $services->getMainConfig());return new ParserCoreTagHooks($options, $services->getLanguageFactory(), $services->getLanguageConverterFactory(),);}, 'ParserFactory'=> static function(MediaWikiServices $services):ParserFactory { $options=new ServiceOptions(Parser::CONSTRUCTOR_OPTIONS, $services->getMainConfig());return new ParserFactory($options, $services->getParserCoreTagHooks(), $services->getMagicWordFactory(), $services->getContentLanguage(), $services->getUrlUtils(), $services->getSpecialPageFactory(), $services->getLinkRendererFactory(), $services->getNamespaceInfo(), LoggerFactory::getInstance( 'Parser'), $services->getBadFileLookup(), $services->getRepoGroup(), $services->getLanguageFactory(), $services->getLanguageConverterFactory(), $services->getLanguageNameUtils(), $services->getHookContainer(), $services->getTidy(), $services->getMainWANObjectCache(), $services->getUserOptionsLookup(), $services->getUserFactory(), $services->getTitleFormatter(), $services->getHttpRequestFactory(), $services->getTrackingCategories(), $services->getSignatureValidatorFactory(), $services->getUserNameUtils());}, 'ParserOutputAccess'=> static function(MediaWikiServices $services):ParserOutputAccess { $poa=new ParserOutputAccess($services->getMainConfig(), $services->getDefaultOutputPipeline(), $services->getParserCacheFactory(), $services->getRevisionLookup(), $services->getRevisionRenderer(), $services->getStatsFactory(), $services->getChronologyProtector(), $services->getWikiPageFactory(), $services->getTitleFormatter(), $services->getTracer(), $services->getPoolCounterFactory());$poa->setLogger(LoggerFactory::getInstance( 'ParserOutputAccess'));return $poa;}, 'ParsoidDataAccess'=> static function(MediaWikiServices $services):DataAccess { $mainConfig=$services->getMainConfig();return new MWDataAccess(new ServiceOptions(MWDataAccess::CONSTRUCTOR_OPTIONS, $mainConfig), $services->getRepoGroup(), $services->getBadFileLookup(), $services->getHookContainer(), $services->getContentTransformer(), $services->getTrackingCategories(), $services->getReadOnlyMode(), $services->getParserFactory(), $services->getLinkBatchFactory(), $services->getLinkRenderer());}, 'ParsoidOutputStash'=> static function(MediaWikiServices $services):ParsoidOutputStash { $config=$services->getMainConfig() ->get(MainConfigNames::ParsoidCacheConfig);$backend=$config['StashType'] ? $services->getObjectCacheFactory() ->getInstance( $config['StashType']) :$services->getMainObjectStash();return new SimpleParsoidOutputStash($services->getJsonCodec(), $backend, $config['StashDuration']);}, 'ParsoidPageConfigFactory'=> static function(MediaWikiServices $services):MWPageConfigFactory { return new MWPageConfigFactory($services->getRevisionStore(), $services->getSlotRoleRegistry(), $services->getLanguageFactory());}, 'ParsoidParserFactory'=> static function(MediaWikiServices $services):ParsoidParserFactory { return new ParsoidParserFactory($services->getParsoidSiteConfig(), $services->getParsoidDataAccess(), $services->getParsoidPageConfigFactory(), $services->getLanguageConverterFactory(), $services->getNamespaceInfo(), $services->getTrackingCategories(), $services->getParserFactory(),);}, 'ParsoidSiteConfig'=> static function(MediaWikiServices $services):MWSiteConfig { $mainConfig=$services->getMainConfig();$parsoidSettings=$mainConfig->get(MainConfigNames::ParsoidSettings);return new MWSiteConfig(new ServiceOptions(MWSiteConfig::CONSTRUCTOR_OPTIONS, $mainConfig), $parsoidSettings, $services->getObjectFactory(), $services->getContentLanguage(), $services->getStatsdDataFactory(), $services->getStatsFactory(), $services->getMagicWordFactory(), $services->getNamespaceInfo(), $services->getSpecialPageFactory(), $services->getInterwikiLookup(), $services->getUserOptionsLookup(), $services->getLanguageFactory(), $services->getLanguageConverterFactory(), $services->getLanguageNameUtils(), $services->getUrlUtils(), $services->getContentHandlerFactory(), ExtensionRegistry::getInstance() ->getAttribute( 'ParsoidModules'), $services->getParserFactory(), $mainConfig, ExtensionRegistry::getInstance() ->isLoaded( 'TimedMediaHandler'));}, 'PasswordFactory'=> static function(MediaWikiServices $services):PasswordFactory { $config=$services->getMainConfig();return new PasswordFactory($config->get(MainConfigNames::PasswordConfig), $config->get(MainConfigNames::PasswordDefault));}, 'PasswordReset'=> static function(MediaWikiServices $services):PasswordReset { $options=new ServiceOptions(PasswordReset::CONSTRUCTOR_OPTIONS, $services->getMainConfig());return new PasswordReset($options, LoggerFactory::getInstance( 'authentication'), $services->getAuthManager(), $services->getHookContainer(), $services->getUserIdentityLookup(), $services->getUserFactory(), $services->getUserNameUtils(), $services->getUserOptionsLookup());}, 'PatrolManager'=> static function(MediaWikiServices $services):PatrolManager { return new PatrolManager(new ServiceOptions(PatrolManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getConnectionProvider(), $services->getUserFactory(), $services->getHookContainer(), $services->getRevertedTagUpdateManager());}, 'PerDbNameStatsdDataFactory'=> static function(MediaWikiServices $services):StatsdDataFactoryInterface { $config=$services->getMainConfig();$wiki=$config->get(MainConfigNames::DBname);return new PrefixingStatsdDataFactoryProxy($services->getStatsdDataFactory(), $wiki);}, 'PermissionManager'=> static function(MediaWikiServices $services):PermissionManager { return new PermissionManager(new ServiceOptions(PermissionManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getSpecialPageFactory(), $services->getNamespaceInfo(), $services->getGroupPermissionsLookup(), $services->getUserGroupManager(), $services->getBlockManager(), $services->getFormatterFactory() ->getBlockErrorFormatter(new LazyLocalizationContext(RequestContext::getMain(...))), $services->getHookContainer(), $services->getUserIdentityLookup(), $services->getRedirectLookup(), $services->getRestrictionStore(), $services->getTitleFormatter(), $services->getTempUserConfig(), $services->getUserFactory(), $services->getActionFactory());}, 'Pingback'=> static function(MediaWikiServices $services):Pingback { return new Pingback($services->getMainConfig(), $services->getConnectionProvider(), $services->getObjectCacheFactory() ->getLocalClusterInstance(), $services->getHttpRequestFactory(), LoggerFactory::getInstance( 'Pingback'));}, 'PoolCounterFactory'=> static function(MediaWikiServices $services):PoolCounterFactory { $mainConfig=$services->getMainConfig();return new PoolCounterFactory($mainConfig->get(MainConfigNames::PoolCounterConf), $mainConfig->get(MainConfigNames::PoolCountClientConf), LoggerFactory::getInstance( 'poolcounter'), $services->getTracer());}, 'PreferencesFactory'=> static function(MediaWikiServices $services):PreferencesFactory { $factory=new DefaultPreferencesFactory(new ServiceOptions(DefaultPreferencesFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentLanguage(), $services->getAuthManager(), $services->getLinkRendererFactory() ->create(), $services->getNamespaceInfo(), $services->getPermissionManager(), $services->getLanguageConverterFactory() ->getLanguageConverter(), $services->getLanguageNameUtils(), $services->getHookContainer(), $services->getUserOptionsManager(), $services->getLanguageConverterFactory(), $services->getParserFactory(), $services->getSkinFactory(), $services->getUserGroupManager(), $services->getSignatureValidatorFactory());$factory->setLogger(LoggerFactory::getInstance( 'preferences'));return $factory;}, 'PreloadedContentBuilder'=> static function(MediaWikiServices $services):PreloadedContentBuilder { return new PreloadedContentBuilder($services->getContentHandlerFactory(), $services->getWikiPageFactory(), $services->getRedirectLookup(), $services->getSpecialPageFactory(), $services->getContentTransformer(), $services->getHookContainer(), $services->getShadowPageLoader(),);}, 'ProxyLookup'=> static function(MediaWikiServices $services):ProxyLookup { $mainConfig=$services->getMainConfig();return new ProxyLookup($mainConfig->get(MainConfigNames::CdnServers), $mainConfig->get(MainConfigNames::CdnServersNoPurge), $services->getHookContainer(), $services->getLocalServerObjectCache());}, 'RateLimiter'=> static function(MediaWikiServices $services):RateLimiter { $rateLimiter=new RateLimiter(new ServiceOptions(RateLimiter::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getWRStatsFactory(), $services->getCentralIdLookupFactory() ->getNonLocalLookup(), $services->getUserFactory(), $services->getUserGroupManager(), $services->getHookContainer());$rateLimiter->setStats( $services->getStatsFactory());return $rateLimiter;}, 'ReadOnlyMode'=> static function(MediaWikiServices $services):ReadOnlyMode { return new ReadOnlyMode(new ConfiguredReadOnlyMode($services->getMainConfig() ->get(MainConfigNames::ReadOnly), $services->getMainConfig() ->get(MainConfigNames::ReadOnlyFile)), $services->getDBLoadBalancerFactory());}, 'RecentChangeFactory'=> static function(MediaWikiServices $services):RecentChangeFactory { return $services->getRecentChangeStore();}, 'RecentChangeLookup'=> static function(MediaWikiServices $services):RecentChangeLookup { return $services->getRecentChangeStore();}, 'RecentChangeRCFeedNotifier'=> static function(MediaWikiServices $services):RecentChangeRCFeedNotifier { return new RecentChangeRCFeedNotifier($services->getHookContainer(), new ServiceOptions(RecentChangeRCFeedNotifier::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'RecentChangeStore'=> static function(MediaWikiServices $services):RecentChangeStore { $extRegistry=ExtensionRegistry::getInstance();return new RecentChangeStore($services->getActorStoreFactory(), $services->getChangeTagsStore(), $services->getConnectionProvider(), $services->getCommentStore(), $services->getHookContainer(), $services->getJobQueueGroup(), $services->getPermissionManager(), $services->getRecentChangeRCFeedNotifier(), new ServiceOptions(RecentChangeStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getTitleFormatter(), $services->getWikiPageFactory(), $services->getUserFactory(), $extRegistry->getAttribute( 'RecentChangeSources'));}, 'RedirectLookup'=> static function(MediaWikiServices $services):RedirectLookup { return $services->getRedirectStore();}, 'RedirectStore'=> static function(MediaWikiServices $services):RedirectStore { return new RedirectStore($services->getConnectionProvider(), $services->getPageStore(), $services->getTitleParser(), $services->getRepoGroup(), LoggerFactory::getInstance( 'RedirectStore'), $services->getLinkWriteDuplicator());}, 'RenameUserFactory'=> static function(MediaWikiServices $services):RenameUserFactory { return new RenameUserFactory(new ServiceOptions(RenameUserFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getCentralIdLookupFactory(), $services->getConnectionProvider(), $services->getJobQueueGroupFactory(), $services->getMovePageFactory(), $services->getUserFactory(), $services->getUserNameUtils(), $services->getPermissionManager(), $services->getTitleFactory(),);}, 'RepoGroup'=> static function(MediaWikiServices $services):RepoGroup { $config=$services->getMainConfig();return new RepoGroup($config->get(MainConfigNames::LocalFileRepo), $config->get(MainConfigNames::ForeignFileRepos), $services->getMainWANObjectCache(), $services->getMimeAnalyzer());}, 'ResourceLoader'=> static function(MediaWikiServices $services):ResourceLoader { $config=$services->getMainConfig();$maxage=$config->get(MainConfigNames::ResourceLoaderMaxage);$rl=new ResourceLoader($config, LoggerFactory::getInstance( 'resourceloader'), new DependencyStore( $services->getMainObjectStash()), ['loadScript'=> $config->get(MainConfigNames::LoadScript), 'maxageVersioned'=> $maxage['versioned'] ?? null, 'maxageUnversioned'=> $maxage['unversioned'] ?? null,]);$extRegistry=ExtensionRegistry::getInstance();$modules=$extRegistry->getAttribute( 'ResourceModules')+ $config->get(MainConfigNames::ResourceModules);$moduleSkinStyles=$extRegistry->getAttribute( 'ResourceModuleSkinStyles')+ $config->get(MainConfigNames::ResourceModuleSkinStyles);$rl->setModuleSkinStyles( $moduleSkinStyles);$rl->addSource( $config->get(MainConfigNames::ResourceLoaderSources));$rl->register(include MW_INSTALL_PATH . '/resources/Resources.php');$rl->register( $modules);$hookRunner=new \MediaWiki\ResourceLoader\HookRunner( $services->getHookContainer());$hookRunner->onResourceLoaderRegisterModules( $rl);$msgPosterAttrib=$extRegistry->getAttribute( 'MessagePosterModule');$rl->register( 'mediawiki.messagePoster', ['localBasePath'=> MW_INSTALL_PATH, 'debugRaw'=> false, 'scripts'=>['resources/src/mediawiki.messagePoster/factory.js', 'resources/src/mediawiki.messagePoster/MessagePoster.js', 'resources/src/mediawiki.messagePoster/WikitextMessagePoster.js',... $msgPosterAttrib['scripts'] ??[],], 'dependencies'=>['oojs', 'mediawiki.api', 'mediawiki.ForeignApi',... $msgPosterAttrib['dependencies'] ??[],],]);if( $config->get(MainConfigNames::EnableJavaScriptTest)===true) { $rl->registerTestModules();} return $rl;}, 'RestrictedUserGroupCheckerFactory'=> static function(MediaWikiServices $services):RestrictedUserGroupCheckerFactory { return new RestrictedUserGroupCheckerFactory($services->getRestrictedUserGroupConfigReader(), $services->getUserRequirementsConditionChecker());}, 'RestrictedUserGroupConfigReader'=> static function(MediaWikiServices $services):RestrictedUserGroupConfigReader { return new RestrictedUserGroupConfigReader(new ServiceOptions(RestrictedUserGroupConfigReader::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getUserRequirementsConditionValidator());}, 'RestrictionStore'=> static function(MediaWikiServices $services):RestrictionStore { return new RestrictionStore(new ServiceOptions(RestrictionStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getMainWANObjectCache(), $services->getDBLoadBalancerFactory(), $services->getLinkCache(), $services->getLinksMigration(), $services->getCommentStore(), $services->getHookContainer(), $services->getPageStore());}, 'RevertedTagUpdateManager'=> static function(MediaWikiServices $services):RevertedTagUpdateManager { $editResultCache=new EditResultCache($services->getMainObjectStash(), $services->getConnectionProvider(), new ServiceOptions(EditResultCache::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));return new RevertedTagUpdateManager($editResultCache, $services->getJobQueueGroup());}, 'RevisionFactory'=> static function(MediaWikiServices $services):RevisionFactory { return $services->getRevisionStore();}, 'RevisionLookup'=> static function(MediaWikiServices $services):RevisionLookup { return $services->getRevisionStore();}, 'RevisionRenderer'=> static function(MediaWikiServices $services):RevisionRenderer { $renderer=new RevisionRenderer($services->getDBLoadBalancer(), $services->getSlotRoleRegistry(), $services->getContentRenderer());$renderer->setLogger(LoggerFactory::getInstance( 'SaveParse'));return $renderer;}, 'RevisionStore'=> static function(MediaWikiServices $services):RevisionStore { return $services->getRevisionStoreFactory() ->getRevisionStore();}, 'RevisionStoreFactory'=> static function(MediaWikiServices $services):RevisionStoreFactory { return new RevisionStoreFactory($services->getDBLoadBalancerFactory(), $services->getBlobStoreFactory(), $services->getNameTableStoreFactory(), $services->getSlotRoleRegistry(), $services->getMainWANObjectCache(), $services->getLocalServerObjectCache(), $services->getCommentStore(), $services->getActorStoreFactory(), LoggerFactory::getInstance( 'RevisionStore'), $services->getContentHandlerFactory(), $services->getPageStoreFactory(), $services->getTitleFactory(), $services->getHookContainer(), $services->getRecentChangeLookup());}, 'RollbackPageFactory'=> static function(MediaWikiServices $services):RollbackPageFactory { return $services->get( '_PageCommandFactory');}, 'RowCommentFormatter'=> static function(MediaWikiServices $services):RowCommentFormatter { return new RowCommentFormatter($services->getCommentParserFactory(), $services->getCommentStore());}, 'SBOMGenerator'=> static function(MediaWikiServices $services):SBOMGenerator { return new SBOMGenerator($services->getConnectionProvider(), $services->getExtensionRegistry(), $services->getGlobalIdGenerator(),);}, 'SearchEngineConfig'=> static function(MediaWikiServices $services):SearchEngineConfig { return new SearchEngineConfig(new ServiceOptions(SearchEngineConfig::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentLanguage(), $services->getHookContainer(), ExtensionRegistry::getInstance() ->getAttribute( 'SearchMappings'), $services->getUserOptionsLookup());}, 'SearchEngineFactory'=> static function(MediaWikiServices $services):SearchEngineFactory { return new SearchEngineFactory($services->getSearchEngineConfig(), $services->getHookContainer(), $services->getConnectionProvider());}, 'SearchResultThumbnailProvider'=> static function(MediaWikiServices $services):SearchResultThumbnailProvider { return new SearchResultThumbnailProvider($services->getRepoGroup(), $services->getHookContainer());}, 'SessionManager'=> static function(MediaWikiServices $services):SessionManagerInterface { return new SessionManager($services->getMainConfig(), LoggerFactory::getInstance( 'session'), $services->getCentralIdLookup(), $services->getHookContainer(), $services->getObjectFactory(), $services->getProxyLookup(), $services->getUrlUtils(), $services->getUserNameUtils(), $services->getSessionStore());}, 'SessionStore'=> static function(MediaWikiServices $services):SessionStore { $objectCacheFactory=$services->getObjectCacheFactory();$mainConfig=$services->getMainConfig();$logger=LoggerFactory::getInstance( 'session');$anonCacheType=$mainConfig->get(MainConfigNames::AnonSessionCacheType);$authCacheType=$mainConfig->get(MainConfigNames::SessionCacheType);if( $anonCacheType !==false) { return new MultiBackendSessionStore($objectCacheFactory->getInstance( $anonCacheType), $objectCacheFactory->getInstance( $authCacheType), $logger, $services->getStatsFactory());} return new SingleBackendSessionStore($objectCacheFactory->getInstance( $authCacheType), $logger, $services->getStatsFactory());}, 'ShadowPageLoader'=> static function(MediaWikiServices $services):ShadowPageLoader { return new ShadowPageLoader($services->getObjectFactory(), ShadowPageLoader::CORE_SPECS, ExtensionRegistry::getInstance() ->getAttribute( 'ShadowPageProviders'));}, 'ShellboxClientFactory'=> static function(MediaWikiServices $services):ShellboxClientFactory { $urls=$services->getMainConfig() ->get(MainConfigNames::ShellboxUrls);return new ShellboxClientFactory($services->getHttpRequestFactory(), $urls, $services->getMainConfig() ->get(MainConfigNames::ShellboxSecretKey));}, 'ShellCommandFactory'=> static function(MediaWikiServices $services):CommandFactory { $config=$services->getMainConfig();$limits=['time'=> $config->get(MainConfigNames::MaxShellTime), 'walltime'=> $config->get(MainConfigNames::MaxShellWallClockTime), 'memory'=> $config->get(MainConfigNames::MaxShellMemory), 'filesize'=> $config->get(MainConfigNames::MaxShellFileSize),];$cgroup=$config->get(MainConfigNames::ShellCgroup);$restrictionMethod=$config->get(MainConfigNames::ShellRestrictionMethod);$factory=new CommandFactory( $services->getShellboxClientFactory(), $limits, $cgroup, $restrictionMethod);$factory->setLogger(LoggerFactory::getInstance( 'exec'));$factory->logStderr();return $factory;}, 'SignatureValidatorFactory'=> static function(MediaWikiServices $services):SignatureValidatorFactory { return new SignatureValidatorFactory(new ServiceOptions(SignatureValidator::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), static function() use( $services) { return $services->getParserFactory();}, static function() use( $services) { return $services->getLintErrorChecker();}, $services->getSpecialPageFactory(), $services->getTitleFactory(),);}, 'SiteLookup'=> static function(MediaWikiServices $services):SiteLookup { return $services->getSiteStore();}, 'SiteStore'=> static function(MediaWikiServices $services):SiteStore { $rawSiteStore=new DBSiteStore( $services->getConnectionProvider());$cache=$services->getLocalServerObjectCache();return new CachingSiteStore( $rawSiteStore, $cache);}, 'SkinFactory'=> static function(MediaWikiServices $services):SkinFactory { $factory=new SkinFactory($services->getObjectFactory(),(array) $services->getMainConfig() ->get(MainConfigNames::SkipSkins));$names=$services->getMainConfig() ->get(MainConfigNames::ValidSkinNames);foreach( $names as $name=> $skin) { if(is_array( $skin)) { $spec=$skin;$displayName=$skin['displayname'] ?? $name;$skippable=$skin['skippable'] ?? false;} else { $displayName=$skin;$skippable=false;$spec=['name'=> $name, 'class'=> "Skin$skin"];} $factory->register( $name, $displayName, $spec, $skippable);} $factory->register( 'fallback', 'Fallback', ['class'=> SkinFallback::class, 'args'=>[['name'=> 'fallback', 'menus'=>[], 'styles'=>[ 'mediawiki.skinning.interface', 'mediawiki.codex.messagebox.styles'], 'templateDirectory'=> dirname(__DIR__) . '/resources/templates/skins/fallback',]]], true);$factory->register( 'apioutput', 'ApiOutput', ['class'=> SkinApi::class, 'args'=>[['name'=> 'apioutput', 'menus'=>[], 'styles'=>[ 'mediawiki.skinning.interface'], 'templateDirectory'=> dirname(__DIR__) . '/resources/templates/skins/apioutput',]]], true);$factory->register( 'authentication-popup', 'Authentication popup', ['class'=> SkinAuthenticationPopup::class, 'args'=>[['name'=> 'authentication-popup', 'menus'=>[], 'styles'=>['mediawiki.skinning.interface', 'mediawiki.special.userlogin.authentication-popup',], 'bodyClasses'=>[ 'mw-authentication-popup'], 'responsive'=> true, 'messages'=>['sitesubtitle', 'sitetitle',], 'templateDirectory'=> dirname(__DIR__) . '/resources/templates/skins/authentication-popup',]]], true);$factory->register( 'json', 'SkinJSON', ['class'=> SkinApi::class, 'args'=>[['name'=> 'json', 'menus'=>[], 'styles'=>[], 'format'=> 'json', 'templateDirectory'=> dirname(__DIR__) . '/resources/templates/skins/apioutput',]]], true);return $factory;}, 'SlotRoleRegistry'=> static function(MediaWikiServices $services):SlotRoleRegistry { $registry=new SlotRoleRegistry($services->getSlotRoleStore());$config=$services->getMainConfig();$contentHandlerFactory=$services->getContentHandlerFactory();$hookContainer=$services->getHookContainer();$titleFactory=$services->getTitleFactory();$registry->defineRole(SlotRecord::MAIN, static function() use( $config, $contentHandlerFactory, $hookContainer, $titleFactory) { return new MainSlotRoleHandler($config->get(MainConfigNames::NamespaceContentModels), $contentHandlerFactory, $hookContainer, $titleFactory);});return $registry;}, 'SlotRoleStore'=> static function(MediaWikiServices $services):NameTableStore { return $services->getNameTableStoreFactory() ->getSlotRoles();}, 'SpamChecker'=> static function(MediaWikiServices $services):SpamChecker { return new SpamChecker((array) $services->getMainConfig() ->get(MainConfigNames::SpamRegex),(array) $services->getMainConfig() ->get(MainConfigNames::SummarySpamRegex));}, 'SpecialPageFactory'=> static function(MediaWikiServices $services):SpecialPageFactory { return new SpecialPageFactory(new ServiceOptions(SpecialPageFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentLanguage(), $services->getObjectFactory(), $services->getTitleFactory(), $services->getHookContainer(), $services->getStatsFactory(),);}, 'StatsdDataFactory'=> static function(MediaWikiServices $services):IBufferingStatsdDataFactory { return new NullStatsdDataFactory();}, 'StatsFactory'=> static function(MediaWikiServices $services):StatsFactory { $config=$services->getMainConfig();$format=OutputFormats::getFormatFromString($config->get(MainConfigNames::StatsFormat) ?? 'null');$cache=new StatsCache;$emitter=OutputFormats::getNewEmitter($config->get(MainConfigNames::StatsPrefix), $cache, OutputFormats::getNewFormatter( $format), $config->get(MainConfigNames::StatsTarget));return new StatsFactory( $cache, $emitter, LoggerFactory::getInstance( 'Stats'));}, 'TalkPageNotificationManager'=> static function(MediaWikiServices $services):TalkPageNotificationManager { return new TalkPageNotificationManager(new ServiceOptions(TalkPageNotificationManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getConnectionProvider(), $services->getReadOnlyMode(), $services->getRevisionLookup(), $services->getHookContainer(), $services->getUserFactory());}, 'TempFSFileFactory'=> static function(MediaWikiServices $services):TempFSFileFactory { return new TempFSFileFactory( $services->getMainConfig() ->get(MainConfigNames::TmpDirectory));}, 'TempUserConfig'=> static function(MediaWikiServices $services):RealTempUserConfig { return new RealTempUserConfig($services->getMainConfig() ->get(MainConfigNames::AutoCreateTempUser));}, 'TempUserCreator'=> static function(MediaWikiServices $services):TempUserCreator { return new TempUserCreator($services->getTempUserConfig(), $services->getObjectFactory(), $services->getUserFactory(), $services->getAuthManager(), $services->getCentralIdLookup(), new Throttler($services->getMainConfig() ->get(MainConfigNames::TempAccountCreationThrottle), ['type'=> 'tempacctcreate', 'cache'=> $services->getObjectCacheFactory() ->getLocalClusterInstance(),]), new Throttler($services->getMainConfig() ->get(MainConfigNames::TempAccountNameAcquisitionThrottle), ['type'=> 'tempacctnameacquisition', 'cache'=> $services->getObjectCacheFactory() ->getLocalClusterInstance(),]));}, 'TempUserDetailsLookup'=> static function(MediaWikiServices $services):TempUserDetailsLookup { return new TempUserDetailsLookup($services->getTempUserConfig(), $services->getUserRegistrationLookup());}, 'TextboxBuilder'=> static function(MediaWikiServices $services):TextboxBuilder { return new TextboxBuilder($services->getPermissionManager(), $services->getRestrictionStore(), $services->getUserOptionsLookup(),);}, 'Tidy'=> static function(MediaWikiServices $services):TidyDriverBase { return new RemexDriver(new ServiceOptions(RemexDriver::CONSTRUCTOR_OPTIONS, $services->getMainConfig()));}, 'TitleFactory'=> static function(MediaWikiServices $services):TitleFactory { return new TitleFactory();}, 'TitleFormatter'=> static function(MediaWikiServices $services):TitleFormatter { return new TitleFormatter($services->getContentLanguage(), $services->getGenderCache(), $services->getNamespaceInfo());}, 'TitleMatcher'=> static function(MediaWikiServices $services):TitleMatcher { return new TitleMatcher($services->getContentLanguage(), $services->getLanguageConverterFactory(), $services->getHookContainer(), $services->getWikiPageFactory(), $services->getRepoGroup(), $services->getTitleFactory());}, 'TitleParser'=> static function(MediaWikiServices $services):TitleParser { return new TitleParser($services->getContentLanguage(), $services->getInterwikiLookup(), $services->getNamespaceInfo(), $services->getMainConfig() ->get(MainConfigNames::LocalInterwikis));}, 'Tracer'=> static function(MediaWikiServices $services):TracerInterface { $xReqIdPropagator=new MediaWikiPropagator(Telemetry::getInstance());$otelConfig=$services->getMainConfig() ->get(MainConfigNames::OpenTelemetryConfig);if( $otelConfig===null||(wfIsCLI() &&!defined( 'MW_PHPUNIT_TEST'))) { if( $services->getMainConfig() ->get(MainConfigNames::GenerateReqIDFormat)==='uuid4') { Telemetry::getInstance() ->overrideRequestId( $services->getGlobalIdGenerator() ->newUUIDv4());} return new NoopTracer( $xReqIdPropagator);} $tracerState=TracerState::getInstance();$exporter=new OtlpHttpExporter($services->getService( '_TracerHTTPClient'), new HttpFactory(), LoggerFactory::getInstance( 'tracing'), $otelConfig['endpoint'], $otelConfig['serviceName'], wfHostname());return new Tracer(new Clock(), new ProbabilisticSampler( $otelConfig['samplingProbability']), $exporter, $tracerState, new CompositePropagator([ $xReqIdPropagator, new W3CTraceContextPropagator()]));}, 'TrackingCategories'=> static function(MediaWikiServices $services):TrackingCategories { return new TrackingCategories(new ServiceOptions(TrackingCategories::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getExtensionRegistry(), $services->getNamespaceInfo(), $services->getTitleParser(), LoggerFactory::getInstance( 'TrackingCategories'));}, 'UnblockUserFactory'=> static function(MediaWikiServices $services):UnblockUserFactory { return $services->getService( '_UserBlockCommandFactory');}, 'UndeletePageFactory'=> static function(MediaWikiServices $services):UndeletePageFactory { return $services->getService( '_PageCommandFactory');}, 'UploadRevisionImporter'=> static function(MediaWikiServices $services):UploadRevisionImporter { return new ImportableUploadRevisionImporter($services->getMainConfig() ->get(MainConfigNames::EnableUploads), LoggerFactory::getInstance( 'UploadRevisionImporter'));}, 'UploadVerification'=> static function(MediaWikiServices $services):UploadVerification { return new UploadVerification(new ServiceOptions(UploadVerification::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getMimeAnalyzer(), new SVGCSSChecker);}, 'UrlUtils'=> static function(MediaWikiServices $services):UrlUtils { $config=$services->getMainConfig();return new UrlUtils([UrlUtils::SERVER=> $config->get(MainConfigNames::Server), UrlUtils::CANONICAL_SERVER=> $config->get(MainConfigNames::CanonicalServer), UrlUtils::INTERNAL_SERVER=> $config->get(MainConfigNames::InternalServer), UrlUtils::FALLBACK_PROTOCOL=> RequestContext::getMain() ->getRequest() ->getProtocol(), UrlUtils::HTTPS_PORT=> $config->get(MainConfigNames::HttpsPort), UrlUtils::VALID_PROTOCOLS=> $config->get(MainConfigNames::UrlProtocols),]);}, 'UserCache'=> static function(MediaWikiServices $services):UserCache { return new UserCache(LoggerFactory::getInstance( 'UserCache'), $services->getConnectionProvider(), $services->getLinkBatchFactory());}, 'UserEditTracker'=> static function(MediaWikiServices $services):UserEditTracker { return new UserEditTracker($services->getActorStoreFactory(), $services->getConnectionProvider(), $services->getJobQueueGroup(), $services->getMainWANObjectCache());}, 'UserFactory'=> static function(MediaWikiServices $services):UserFactory { return new UserFactory(new ServiceOptions(UserFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getDBLoadBalancerFactory(), $services->getUserNameUtils(), $services->getTempUserConfig());}, 'UserGroupAssignmentService'=> static function(MediaWikiServices $services):UserGroupAssignmentService { return new UserGroupAssignmentService($services->getUserGroupManagerFactory(), $services->getUserNameUtils(), $services->getUserFactory(), $services->getRestrictedUserGroupCheckerFactory(), new HookRunner( $services->getHookContainer()), new ServiceOptions(UserGroupAssignmentService::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getTempUserConfig(), $services->getConnectionProvider(), $services->getPageStoreFactory(),);}, 'UserGroupManager'=> static function(MediaWikiServices $services):UserGroupManager { return $services->getUserGroupManagerFactory() ->getUserGroupManager();}, 'UserGroupManagerFactory'=> static function(MediaWikiServices $services):UserGroupManagerFactory { return new UserGroupManagerFactory(new ServiceOptions(UserGroupManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getReadOnlyMode(), $services->getDBLoadBalancerFactory(), $services->getHookContainer(), $services->getJobQueueGroupFactory(), $services->getTempUserConfig(), $services->getUserFactory(), $services->getUserRequirementsConditionCheckerFactory(), $services->getRestrictedUserGroupConfigReader(), [static function(UserIdentity $user) use( $services) { if( $user->getWikiId()===UserIdentity::LOCAL) { $services->getPermissionManager() ->invalidateUsersRightsCache( $user);} $services->getUserFactory() ->invalidateCache( $user);}]);}, 'UserIdentityLookup'=> static function(MediaWikiServices $services):UserIdentityLookup { return $services->getActorStoreFactory() ->getUserIdentityLookup();}, 'UserIdentityUtils'=> static function(MediaWikiServices $services):UserIdentityUtils { return new UserIdentityUtils($services->getTempUserConfig());}, 'UserLinkRenderer'=> static function(MediaWikiServices $services):UserLinkRenderer { return new UserLinkRenderer($services->getHookContainer(), $services->getTempUserConfig(), $services->getSpecialPageFactory(), $services->getLinkRenderer(), $services->getTempUserDetailsLookup(), $services->getUserIdentityLookup(), $services->getUserNameUtils());}, 'UserNamePrefixSearch'=> static function(MediaWikiServices $services):UserNamePrefixSearch { return new UserNamePrefixSearch($services->getConnectionProvider(), $services->getUserNameUtils(), $services->getHideUserUtils());}, 'UserNameUtils'=> static function(MediaWikiServices $services):UserNameUtils { $messageFormatterFactory=new MessageFormatterFactory(Message::FORMAT_PLAIN);return new UserNameUtils(new ServiceOptions(UserNameUtils::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentLanguage(), LoggerFactory::getInstance( 'UserNameUtils'), $services->getTitleParser(), $messageFormatterFactory->getTextFormatter($services->getContentLanguageCode() ->toString()), $services->getHookContainer(), $services->getTempUserConfig());}, 'UserOptionsLookup'=> static function(MediaWikiServices $services):UserOptionsLookup { return $services->getUserOptionsManager();}, 'UserOptionsManager'=> static function(MediaWikiServices $services):UserOptionsManager { return new UserOptionsManager(new ServiceOptions(UserOptionsManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->get( '_DefaultOptionsLookup'), $services->getLanguageConverterFactory(), $services->getConnectionProvider(), LoggerFactory::getInstance( 'UserOptionsManager'), $services->getHookContainer(), $services->getUserFactory(), $services->getUserNameUtils(), $services->getObjectFactory(), ExtensionRegistry::getInstance() ->getAttribute( 'UserOptionsStoreProviders'));}, 'UserRegistrationLookup'=> static function(MediaWikiServices $services):UserRegistrationLookup { $lookup=new UserRegistrationLookup(new ServiceOptions(UserRegistrationLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getObjectFactory());if(! $lookup->isRegistered(LocalUserRegistrationProvider::TYPE)) { throw new ConfigException( 'UserRegistrationLookup:Local provider is required');} return $lookup;}, 'UserRequirementsConditionChecker'=> static function(MediaWikiServices $services):UserRequirementsConditionChecker { return $services->getUserRequirementsConditionCheckerFactory() ->getUserRequirementsConditionChecker( $services->getUserGroupManager());}, 'UserRequirementsConditionCheckerFactory'=> static function(MediaWikiServices $services):UserRequirementsConditionCheckerFactory { return new UserRequirementsConditionCheckerFactory(new ServiceOptions(UserRequirementsConditionCheckerFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getGroupPermissionsLookup(), $services->getHookContainer(), $services->getUserEditTracker(), $services->getUserRegistrationLookup(), $services->getUserFactory(), RequestContext::getMain(), $services->getUserRequirementsConditionValidator(),);}, 'UserRequirementsConditionValidator'=> static function():UserRequirementsConditionValidator { return new UserRequirementsConditionValidator(LoggerFactory::getInstance( 'UserGroupManager'),);}, 'WatchedItemQueryService'=> static function(MediaWikiServices $services):WatchedItemQueryService { return new WatchedItemQueryService($services->getConnectionProvider(), $services->getWatchedItemStore(), $services->getMainConfig() ->get(MainConfigNames::WatchlistExpiry), $services->getMainConfig() ->get(MainConfigNames::MaxExecutionTimeForExpensiveQueries));}, 'WatchedItemStore'=> static function(MediaWikiServices $services):WatchedItemStore { $store=new WatchedItemStore(new ServiceOptions(WatchedItemStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getDBLoadBalancerFactory(), $services->getJobQueueGroup(), $services->getMainObjectStash(), new HashBagOStuff([ 'maxKeys'=> 100]), $services->getReadOnlyMode(), $services->getNamespaceInfo(), $services->getRevisionLookup(), $services->getLinkBatchFactory(), $services->getWatchlistLabelStore());if( $services->getMainConfig() ->get(MainConfigNames::ReadOnlyWatchedItemStore)) { $store=new NoWriteWatchedItemStore( $store);} return $store;}, 'WatchlistLabelStore'=> static function(MediaWikiServices $services):WatchlistLabelStore { return new WatchlistLabelStore($services->getConnectionProvider(), LoggerFactory::getInstance( 'WatchlistLabels'), $services->getMainConfig());}, 'WatchlistManager'=> static function(MediaWikiServices $services):WatchlistManager { return new WatchlistManager([WatchlistManager::OPTION_ENOTIF=> RecentChangeStore::isEnotifEnabled(new ServiceOptions(RecentChangeStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig())),], $services->getHookContainer(), $services->getReadOnlyMode(), $services->getRevisionLookup(), $services->getTalkPageNotificationManager(), $services->getWatchedItemStore(), $services->getWatchlistLabelStore(), $services->getUserFactory(), $services->getNamespaceInfo(), $services->getWikiPageFactory());}, 'WikiExporterFactory'=> static function(MediaWikiServices $services):WikiExporterFactory { return new WikiExporterFactory($services->getHookContainer(), $services->getRevisionStore(), $services->getTitleParser(), $services->getCommentStore());}, 'WikiImporterFactory'=> static function(MediaWikiServices $services):WikiImporterFactory { return new WikiImporterFactory($services->getMainConfig(), $services->getHookContainer(), $services->getContentLanguage(), $services->getNamespaceInfo(), $services->getTitleFactory(), $services->getWikiPageFactory(), $services->getWikiRevisionUploadImporter(), $services->getContentHandlerFactory(), $services->getSlotRoleRegistry());}, 'WikiPageFactory'=> static function(MediaWikiServices $services):WikiPageFactory { return new WikiPageFactory($services->getTitleFactory(), new HookRunner( $services->getHookContainer()), $services->getDBLoadBalancerFactory());}, 'WikiRevisionOldRevisionImporterNoUpdates'=> static function(MediaWikiServices $services):ImportableOldRevisionImporter { return new ImportableOldRevisionImporter(false, LoggerFactory::getInstance( 'OldRevisionImporter'), $services->getConnectionProvider(), $services->getRevisionStoreFactory() ->getRevisionStoreForImport(), $services->getSlotRoleRegistry(), $services->getWikiPageFactory(), $services->getPageUpdaterFactory(), $services->getUserFactory());}, 'WRStatsFactory'=> static function(MediaWikiServices $services):WRStatsFactory { return new WRStatsFactory(new BagOStuffStatsStore( $services->getMicroStash()));}, '_ConditionalDefaultsLookup'=> static function(MediaWikiServices $services):ConditionalDefaultsLookup { return new ConditionalDefaultsLookup(new ServiceOptions(ConditionalDefaultsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getUserRegistrationLookup(), $services->getUserIdentityUtils(), LoggerFactory::getInstance( 'preferences'), static function() use( $services) { return $services->getUserGroupManager();});}, '_DefaultOptionsLookup'=> static function(MediaWikiServices $services):DefaultOptionsLookup { return new DefaultOptionsLookup(new ServiceOptions(DefaultOptionsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentLanguageCode(), $services->getHookContainer(), $services->getNamespaceInfo(), $services->get( '_ConditionalDefaultsLookup'), $services->getUserIdentityLookup(), $services->getUserNameUtils());}, '_DomainEventDispatcher'=> static function(MediaWikiServices $services):EventDispatchEngine { $dispatcher=new EventDispatchEngine($services->getObjectFactory());$dispatcher->registerSubscriber(ChangeTrackingEventIngress::OBJECT_SPEC);$dispatcher->registerSubscriber(SearchEventIngress::OBJECT_SPEC);$dispatcher->registerSubscriber(LanguageEventIngress::OBJECT_SPEC);$extensionRegistry=$services->getExtensionRegistry();$dispatcher->registerSubscriber( $extensionRegistry);return $dispatcher;}, '_EditConstraintFactory'=> static function(MediaWikiServices $services):EditConstraintFactory { return new EditConstraintFactory(new ServiceOptions(EditConstraintFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getHookContainer(), $services->getReadOnlyMode(), $services->getSpamChecker(), LoggerFactory::getProvider() ->getLogger( 'SpamRegex'), $services->getRateLimiter(), $services->getRedirectLookup(), $services->getConnectionProvider(), $services->getLogFormatterFactory(), $services->getUserFactory(),);}, '_NotificationMiddlewareChain'=> static function(MediaWikiServices $services):MiddlewareChain { return new MiddlewareChain($services->getObjectFactory(), ExtensionRegistry::getInstance() ->getAttribute( 'NotificationMiddleware'));}, '_PageCommandFactory'=> static function(MediaWikiServices $services):PageCommandFactory { return new PageCommandFactory($services->getMainConfig(), $services->getDBLoadBalancerFactory(), $services->getNamespaceInfo(), $services->getWatchedItemStore(), $services->getRepoGroup(), $services->getReadOnlyMode(), $services->getContentHandlerFactory(), $services->getRevisionStoreFactory(), $services->getSpamChecker(), $services->getTitleFormatter(), $services->getHookContainer(), $services->getDomainEventDispatcher(), $services->getWikiPageFactory(), $services->getUserFactory(), $services->getActorMigration(), $services->getActorNormalization(), $services->getTitleFactory(), $services->getUserEditTracker(), $services->getCollationFactory(), $services->getJobQueueGroup(), $services->getCommentStore(), $services->getMainObjectStash(), WikiMap::getCurrentWikiDbDomain() ->getId(), WebRequest::getRequestId(), $services->getBacklinkCacheFactory(), LoggerFactory::getInstance( 'UndeletePage'), $services->getPageUpdaterFactory(), $services->getMessageFormatterFactory() ->getTextFormatter($services->getContentLanguageCode() ->toString()), $services->getArchivedRevisionLookup(), $services->getRestrictionStore(), $services->getLinkTargetLookup(), $services->getRedirectStore(), $services->getLogFormatterFactory(), $services->getLinkWriteDuplicator());}, '_PageEditFactory'=> static function(MediaWikiServices $services):PageEditFactory { return new PageEditFactory(new ServiceOptions(PageEditFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentHandlerFactory(), $services->getService( '_EditConstraintFactory'), $services->getConnectionProvider(), $services->getContentLanguage(), $services->getContentTransformer(), LoggerFactory::getInstance( 'EditConflict'), $services->getService( '_PageEditingHelper'), $services->getRateLimiter(), $services->getRevisionStore(), $services->getShadowPageLoader(), $services->getTitleFormatter(), $services->getUserOptionsLookup(), $services->getWatchlistManager(), $services->getWatchedItemStore(), $services->getWikiPageFactory(),);}, '_PageEditingHelper'=> static function(MediaWikiServices $services):PageEditingHelper { return new PageEditingHelper(new ServiceOptions(PageEditingHelper::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getContentHandlerFactory(), $services->getParserFactory(), $services->getRevisionStore(),);}, '_ParserObserver'=> static function(MediaWikiServices $services):ParserObserver { return new ParserObserver(LoggerFactory::getInstance( 'DuplicateParse'));}, '_Parsoid'=> static function(MediaWikiServices $services):Parsoid { return new Parsoid($services->getParsoidSiteConfig(), $services->getParsoidDataAccess());}, '_SettingsBuilder'=> static function(MediaWikiServices $services):SettingsBuilder { return SettingsBuilder::getInstance();}, '_SqlBlobStore'=> static function(MediaWikiServices $services):SqlBlobStore { return $services->getBlobStoreFactory() ->newSqlBlobStore();}, '_TracerHTTPClient'=> static function():ClientInterface { return new Client([ 'http_errors'=> false]);}, '_UserBlockCommandFactory'=> static function(MediaWikiServices $services):UserBlockCommandFactory { return new UserBlockCommandFactory(new ServiceOptions(UserBlockCommandFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()), $services->getHookContainer(), $services->getBlockPermissionCheckerFactory(), $services->getBlockTargetFactory(), $services->getDatabaseBlockStore(), $services->getBlockRestrictionStore(), $services->getUserFactory(), $services->getUserEditTracker(), LoggerFactory::getInstance( 'BlockManager'), $services->getTitleFactory(), $services->getBlockActionInfo());}]
Definition ServiceWiring.php:3401

if
if(!defined('MW_SETUP_CALLBACK'))
Definition WebStart.php:71

MW_ENTRY_POINT
const MW_ENTRY_POINT
Definition api.php:21

MediaWiki\Actions\ActionFactory
Definition ActionFactory.php:24

MediaWiki\Auth\AuthManager
AuthManager is the authentication system in MediaWiki and serves entry point for authentication.
Definition AuthManager.php:112

MediaWiki\Auth\AuthManager\setLogger
setLogger(LoggerInterface $logger)
Definition AuthManager.php:245

MediaWiki\Auth\Throttler
A helper class for throttling authentication attempts.
Definition Throttler.php:26

MediaWiki\Block\AutoblockExemptionList
Provides access to the wiki's autoblock exemption list.
Definition AutoblockExemptionList.php:17

MediaWiki\Block\BlockActionInfo
Defines the actions that can be blocked by a partial block.
Definition BlockActionInfo.php:26

MediaWiki\Block\BlockErrorFormatter
A service class for getting formatted information about a block.
Definition BlockErrorFormatter.php:29

MediaWiki\Block\BlockManager
A service class for checking blocks.
Definition BlockManager.php:35

MediaWiki\Block\BlockPermissionCheckerFactory
Factory class for BlockPermissionChecker.
Definition BlockPermissionCheckerFactory.php:19

MediaWiki\Block\BlockRestrictionStoreFactory
Definition BlockRestrictionStoreFactory.php:17

MediaWiki\Block\BlockRestrictionStore
Definition BlockRestrictionStore.php:20

MediaWiki\Block\BlockTargetFactory
Factory for BlockTarget objects.
Definition BlockTargetFactory.php:24

MediaWiki\Block\BlockUtilsFactory
Definition BlockUtilsFactory.php:16

MediaWiki\Block\BlockUtils
Backend class for blocking utils.
Definition BlockUtils.php:28

MediaWiki\Block\CrossWikiBlockTargetFactory
Factory for BlockTargetFactory objects.
Definition CrossWikiBlockTargetFactory.php:17

MediaWiki\Block\DatabaseBlockStoreFactory
Definition DatabaseBlockStoreFactory.php:25

MediaWiki\Block\DatabaseBlockStore
Definition DatabaseBlockStore.php:46

MediaWiki\Block\DatabaseBlock
A DatabaseBlock (unlike a SystemBlock) is stored in the database, may give rise to autoblocks and may...
Definition DatabaseBlock.php:31

MediaWiki\Block\HideUserUtils
Helpers for building queries that determine whether a user is hidden.
Definition HideUserUtils.php:12

MediaWiki\Block\UserBlockCommandFactory
Definition UserBlockCommandFactory.php:19

MediaWiki\Cache\BacklinkCacheFactory
Definition BacklinkCacheFactory.php:24

MediaWiki\Cache\BacklinkCache
Class for fetching backlink lists, approximate backlink counts and partitions.
Definition BacklinkCache.php:54

MediaWiki\Cache\GenderCache
Look up "gender" user preference.
Definition GenderCache.php:27

MediaWiki\Cache\HTMLCacheUpdater
Class to invalidate the CDN and HTMLFileCache entries associated with URLs/titles.
Definition HTMLCacheUpdater.php:25

MediaWiki\Cache\UserCache
Definition UserCache.php:20

MediaWiki\Category\TrackingCategories
This class performs some operations related to tracking categories, such as adding a tracking categor...
Definition TrackingCategories.php:28

MediaWiki\ChangeTags\ChangeTagsFormatter
Formats change tags for display in HTML and use filter dropdown menus.
Definition ChangeTagsFormatter.php:30

MediaWiki\ChangeTags\ChangeTagsStoreFactory
A factory for ChangeTagsStore instances.
Definition ChangeTagsStoreFactory.php:23

MediaWiki\ChangeTags\ChangeTagsStore
Read-write access to the change_tags table.
Definition ChangeTagsStore.php:40

MediaWiki\Collation\CollationFactory
Common factory to construct collation classes.
Definition CollationFactory.php:22

MediaWiki\CommentFormatter\CommentFormatter
This is the main service interface for converting single-line comments from various DB comment fields...
Definition CommentFormatter.php:17

MediaWiki\CommentFormatter\CommentParserFactory
Definition CommentParserFactory.php:18

MediaWiki\CommentFormatter\RowCommentFormatter
This is basically a CommentFormatter with a CommentStore dependency, allowing it to retrieve comment ...
Definition RowCommentFormatter.php:15

MediaWiki\CommentStore\CommentStore
Handle database storage of comments such as edit summaries and log reasons.
Definition CommentStore.php:37

MediaWiki\Config\ConfigException
Exceptions for config failures.
Definition ConfigException.php:19

MediaWiki\Config\ConfigFactory
Factory class to create Config objects.
Definition ConfigFactory.php:22

MediaWiki\Config\ConfigRepository
Object which holds currently registered configuration options.
Definition ConfigRepository.php:20

MediaWiki\Config\ServiceOptions
A class for passing options to services.
Definition ServiceOptions.php:27

MediaWiki\Content\CodeHighlighter
Service for syntax highlighting.
Definition CodeHighlighter.php:14

MediaWiki\Content\ContentHandlerFactory
Definition ContentHandlerFactory.php:20

MediaWiki\Content\ContentJsonCodec
ContentJsonCodec handles serialization of Content objects to/from JSON using methods of the appropria...
Definition ContentJsonCodec.php:19

MediaWiki\Content\Renderer\ContentRenderer
A service to render content.
Definition ContentRenderer.php:17

MediaWiki\Content\Transform\ContentTransformer
A service to transform content.
Definition ContentTransformer.php:15

MediaWiki\Context\RequestContext
Group all the pieces relevant to the context of a request into one instance.
Definition RequestContext.php:51

MediaWiki\DB\MWLBConfig
MediaWiki-specific class for generating configuration of load balancers.
Definition MWLBConfig.php:28

MediaWiki\DB\MWLBFactory
MediaWiki-specific class for generating database load balancers.
Definition MWLBFactory.php:38

MediaWiki\DB\WriteDuplicator
Definition WriteDuplicator.php:14

MediaWiki\Deferred\DeferredUpdates
Defer callable updates to run later in the PHP process.
Definition DeferredUpdates.php:85

MediaWiki\Deferred\LinksUpdate\ExternalLinksTable
externallinks
Definition ExternalLinksTable.php:15

MediaWiki\DomainEvent\EventDispatchEngine
Implementation of DomainEventDispatcher and DomainEventSource based on HookContainer and DeferredUpda...
Definition EventDispatchEngine.php:22

MediaWiki\DomainEvent\EventDispatchEngine\registerSubscriber
registerSubscriber( $subscriber)
Definition EventDispatchEngine.php:93

MediaWiki\EditPage\Constraint\EditConstraintFactory
Constraints reflect possible errors that need to be checked.
Definition EditConstraintFactory.php:37

MediaWiki\EditPage\IntroMessageBuilder
Provides the intro messages (edit notices and others) to be displayed before an edit form.
Definition IntroMessageBuilder.php:43

MediaWiki\EditPage\PageEditingHelper
Provides helper methods used by EditPage and a future editing backend (T157658).
Definition PageEditingHelper.php:26

MediaWiki\EditPage\PreloadedContentBuilder
Provides the initial content of the edit box displayed in an edit form when creating a new page or a ...
Definition PreloadedContentBuilder.php:30

MediaWiki\EditPage\SpamChecker
Service to check if text (either content or a summary) qualifies as spam.
Definition SpamChecker.php:14

MediaWiki\EditPage\TextboxBuilder
Helps EditPage build textboxes.
Definition TextboxBuilder.php:24

MediaWiki\Edit\SimpleParsoidOutputStash
Definition SimpleParsoidOutputStash.php:12

MediaWiki\Export\WikiExporterFactory
Factory service for WikiExporter instances.
Definition WikiExporterFactory.php:21

MediaWiki\ExternalStore\ExternalStoreAccess
This is the main interface for fetching or inserting objects with ExternalStore.
Definition ExternalStoreAccess.php:32

MediaWiki\ExternalStore\ExternalStoreFactory
Definition ExternalStoreFactory.php:16

MediaWiki\FeatureShutdown
Helper to check if certain features should be temporarily disabled.
Definition FeatureShutdown.php:17

MediaWiki\FileBackend\FileBackendGroup
Class to handle file backend registration.
Definition FileBackendGroup.php:37

MediaWiki\FileBackend\LockManager\LockManagerGroupFactory
Service to construct LockManagerGroups.
Definition LockManagerGroupFactory.php:8

MediaWiki\FileRepo\RepoGroup
Prioritized list of file repositories.
Definition RepoGroup.php:30

MediaWiki\HookContainer\HookContainer
HookContainer class.
Definition HookContainer.php:42

MediaWiki\HookContainer\HookRunner
This class provides an implementation of the core hook interfaces, forwarding hook calls to HookConta...
Definition HookRunner.php:600

MediaWiki\HookContainer\StaticHookRegistry
This is a simple immutable HookRegistry which can be used to set up a local HookContainer in tests an...
Definition StaticHookRegistry.php:9

MediaWiki\Http\HttpRequestFactory
Factory creating MWHttpRequest objects.
Definition HttpRequestFactory.php:22

MediaWiki\Http\Telemetry
Service for handling telemetry data.
Definition Telemetry.php:15

MediaWiki\Import\ImportableOldRevisionImporter
Definition ImportableOldRevisionImporter.php:27

MediaWiki\Import\ImportableUploadRevisionImporter
Definition ImportableUploadRevisionImporter.php:16

MediaWiki\Import\WikiImporterFactory
Factory service for WikiImporter instances.
Definition WikiImporterFactory.php:25

MediaWiki\Installer\Pingback
Send information about this MediaWiki instance to mediawiki.org.
Definition Pingback.php:34

MediaWiki\Interwiki\ClassicInterwikiLookup
InterwikiLookup backed by the interwiki database table or $wgInterwikiCache.
Definition ClassicInterwikiLookup.php:33

MediaWiki\JobQueue\JobFactory
Definition JobFactory.php:14

MediaWiki\JobQueue\JobQueueGroupFactory
Factory for JobQueueGroup objects.
Definition JobQueueGroupFactory.php:24

MediaWiki\JobQueue\JobQueueGroup
Handle enqueueing of background jobs.
Definition JobQueueGroup.php:31

MediaWiki\JobQueue\JobRunner
Job queue runner utility methods.
Definition JobRunner.php:36

MediaWiki\Json\JsonCodec
Definition JsonCodec.php:31

MediaWiki\Json\RsaJwtCodec
JwtCodec using lcobucci/jwt with an RSA key ($wgJwtPublicKey / $wgJwtPrivateKey).
Definition RsaJwtCodec.php:28

MediaWiki\Language\FormatterFactory
Factory for formatters of common complex objects.
Definition FormatterFactory.php:17

MediaWiki\Language\LanguageCode
Methods for dealing with language codes.
Definition LanguageCode.php:18

MediaWiki\Language\LanguageConverterFactory
An interface for creating language converters.
Definition LanguageConverterFactory.php:36

MediaWiki\Language\LanguageEventIngress
The ingress adapter for the language component.
Definition LanguageEventIngress.php:21

MediaWiki\Language\LanguageFactory
Internationalisation code See https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation for more...
Definition LanguageFactory.php:26

MediaWiki\Language\LanguageFallback
Definition LanguageFallback.php:13

MediaWiki\Language\LanguageNameSearch
Cross-Language Language name search.
Definition LanguageNameSearch.php:20

MediaWiki\Language\LanguageNameUtils
A service that provides utilities to do with language names and codes.
Definition LanguageNameUtils.php:27

MediaWiki\Language\Language
Base class for language-specific code.
Definition Language.php:65

MediaWiki\Language\LazyLocalizationContext
Wrapper for injecting a LocalizationContext with lazy initialization.
Definition LazyLocalizationContext.php:15

MediaWiki\Language\LeximorphFactory
Create and cache Manager and Provider instances.
Definition LeximorphFactory.php:44

MediaWiki\Language\LocalisationCache
Caching for the contents of localisation files.
Definition LocalisationCache.php:47

MediaWiki\Language\MessageCache
Cache messages that are defined by MediaWiki-namespace pages or by hooks.
Definition MessageCache.php:50

MediaWiki\Language\MessageCache\get
get( $key, $useDB=true, $language=null, $info=null)
Get a message from either the content language or the user language.
Definition MessageCache.php:982

MediaWiki\Language\MessageParser
Service for transformation of interface message text.
Definition MessageParser.php:23

MediaWiki\Linker\LinkRendererFactory
Factory to create LinkRender objects.
Definition LinkRendererFactory.php:24

MediaWiki\Linker\LinkRenderer
Class that generates HTML for internal links.
Definition LinkRenderer.php:41

MediaWiki\Linker\LinkTargetStore
Service for retrieving and storing link targets.
Definition LinkTargetStore.php:24

MediaWiki\Linker\LinksMigration
Service for compat reading of links tables.
Definition LinksMigration.php:17

MediaWiki\Linker\UserLinkRenderer
Service class that renders HTML for user-related links.
Definition UserLinkRenderer.php:31

MediaWiki\Logger\LoggerFactory
Create PSR-3 logger objects.
Definition LoggerFactory.php:32

MediaWiki\Logging\LogFormatterFactory
Definition LogFormatterFactory.php:15

MediaWiki\Mail\ConfirmEmail\ConfirmEmailBuilderFactory
Definition ConfirmEmailBuilderFactory.php:9

MediaWiki\Mail\ConfirmEmail\ConfirmEmailSender
Wrapper for IEmailer for sending confirm email sender.
Definition ConfirmEmailSender.php:21

MediaWiki\Mail\ConfirmEmail\EmailConfirmationBannerHandler
Decides whether to show the email confirmation banner to a given user.
Definition EmailConfirmationBannerHandler.php:13

MediaWiki\Mail\EmailUserFactory
Factory for EmailUser objects.
Definition EmailUserFactory.php:27

MediaWiki\Mail\EmailUser
Send email between two wiki users.
Definition EmailUser.php:37

MediaWiki\Mail\Emailer
Send arbitrary emails.
Definition Emailer.php:26

MediaWiki\Mail\NotificationEmail\NotificationEmailSender
Sends notification emails to the old address when a user changes or removes their email.
Definition NotificationEmailSender.php:21

MediaWiki\MainConfigNames
A class containing constants representing the names of configuration variables.
Definition MainConfigNames.php:22

MediaWiki\MediaWikiServices
Service locator for MediaWiki core services.
Definition MediaWikiServices.php:271

MediaWiki\Media\DjVuImage
Support for detecting/validating DjVu image files and getting some basic file metadata (resolution et...
Definition DjVuImage.php:28

MediaWiki\Media\MediaHandlerFactory
Class to construct MediaHandler objects.
Definition MediaHandlerFactory.php:21

MediaWiki\Message\MessageFormatterFactory
The MediaWiki-specific implementation of IMessageFormatterFactory.
Definition MessageFormatterFactory.php:15

MediaWiki\Message\Message
The Message class deals with fetching and processing of interface message into a variety of formats.
Definition Message.php:144

MediaWiki\Notification\MiddlewareChain
Definition MiddlewareChain.php:9

MediaWiki\Notification\NotificationService
Notify users about things occurring.
Definition NotificationService.php:17

MediaWiki\ObjectCache\ObjectCacheFactory
Factory for cache objects as configured in the ObjectCaches setting.
Definition ObjectCacheFactory.php:62

MediaWiki\OutputTransform\DefaultOutputPipelineFactory
This class contains the default output transformation pipeline factory for wikitext.
Definition DefaultOutputPipelineFactory.php:36

MediaWiki\OutputTransform\OutputTransformPipeline
Definition OutputTransformPipeline.php:12

MediaWiki\PageEdit\PageEditFactory
Definition PageEditFactory.php:26

MediaWiki\Page\File\BadFileLookup
Definition BadFileLookup.php:13

MediaWiki\Page\LinkBatchFactory
Factory for LinkBatch objects to batch query page metadata.
Definition LinkBatchFactory.php:29

MediaWiki\Page\LinkCache
Page existence and metadata cache.
Definition LinkCache.php:54

MediaWiki\Page\PageCommandFactory
Implementation of various page action services.
Definition PageCommandFactory.php:57

MediaWiki\Page\PageProps
Gives access to properties of a page.
Definition PageProps.php:20

MediaWiki\Page\PageStoreFactory
Definition PageStoreFactory.php:15

MediaWiki\Page\PageStore
Definition PageStore.php:26

MediaWiki\Page\ParserOutputAccess
Service for getting rendered output of a given page.
Definition ParserOutputAccess.php:47

MediaWiki\Page\ParserOutputAccess\setLogger
setLogger(LoggerInterface $logger)
Definition ParserOutputAccess.php:201

MediaWiki\Page\RedirectStore
Service for storing and retrieving page redirect information.
Definition RedirectStore.php:26

MediaWiki\Page\WikiPageFactory
Service for creating WikiPage objects.
Definition WikiPageFactory.php:18

MediaWiki\Parser\DateFormatterFactory
Definition DateFormatterFactory.php:7

MediaWiki\Parser\MagicWordFactory
Store information about magic words, and create/cache MagicWord objects.
Definition MagicWordFactory.php:25

MediaWiki\Parser\ParserCacheFactory
Definition ParserCacheFactory.php:27

MediaWiki\Parser\ParserCache
Cache for ParserOutput objects corresponding to the latest page revisions.
Definition ParserCache.php:59

MediaWiki\Parser\ParserCoreTagHooks
Various tag hooks, registered in every Parser.
Definition ParserCoreTagHooks.php:26

MediaWiki\Parser\ParserFactory
Definition ParserFactory.php:36

MediaWiki\Parser\ParserObserver
Definition ParserObserver.php:30

MediaWiki\Parser\Parser
PHP Parser - Processes wiki markup (which uses a more user-friendly syntax, such as "[[link]]" for ma...
Definition Parser.php:139

MediaWiki\Parser\Parsoid\Config\DataAccess
Implement Parsoid's abstract class for data access.
Definition DataAccess.php:51

MediaWiki\Parser\Parsoid\Config\DataAccess\CONSTRUCTOR_OPTIONS
const CONSTRUCTOR_OPTIONS
Definition DataAccess.php:52

MediaWiki\Parser\Parsoid\Config\PageConfigFactory
Helper class used by MediaWiki to create Parsoid PageConfig objects.
Definition PageConfigFactory.php:32

MediaWiki\Parser\Parsoid\Config\SiteConfig
Site-level configuration for Parsoid.
Definition SiteConfig.php:61

MediaWiki\Parser\Parsoid\Config\SiteConfig\CONSTRUCTOR_OPTIONS
const CONSTRUCTOR_OPTIONS
Definition SiteConfig.php:63

MediaWiki\Parser\Parsoid\HtmlTransformFactory
Definition HtmlTransformFactory.php:19

MediaWiki\Parser\Parsoid\LintErrorChecker
Check arbitrary wikitext for lint errors.
Definition LintErrorChecker.php:23

MediaWiki\Parser\Parsoid\ParsoidParserFactory
ParserFactory which uses a ParsoidParser.
Definition ParsoidParserFactory.php:29

MediaWiki\Password\PasswordFactory
Factory class for creating and checking Password objects.
Definition PasswordFactory.php:22

MediaWiki\Permissions\GrantsInfo
Users can authorize applications to use their account via OAuth.
Definition GrantsInfo.php:19

MediaWiki\Permissions\GrantsLocalization
This separate service is needed because the ::getGrantsLink method requires a LinkRenderer and if we ...
Definition GrantsLocalization.php:25

MediaWiki\Permissions\GroupPermissionsLookup
Definition GroupPermissionsLookup.php:26

MediaWiki\Permissions\PermissionManager
A service class for checking permissions To obtain an instance, use MediaWikiServices::getInstance()-...
Definition PermissionManager.php:56

MediaWiki\Permissions\RateLimiter
Provides rate limiting for a set of actions based on several counter buckets.
Definition RateLimiter.php:29

MediaWiki\Permissions\RateLimiter\setStats
setStats(StatsFactory $statsFactory)
Definition RateLimiter.php:94

MediaWiki\Permissions\RestrictionStore
Definition RestrictionStore.php:32

MediaWiki\PoolCounter\PoolCounterFactory
Definition PoolCounterFactory.php:10

MediaWiki\Preferences\DefaultPreferencesFactory
This is the default implementation of PreferencesFactory.
Definition DefaultPreferencesFactory.php:67

MediaWiki\Preferences\SignatureValidatorFactory
Definition SignatureValidatorFactory.php:20

MediaWiki\Preferences\SignatureValidator
Definition SignatureValidator.php:30

MediaWiki\RecentChanges\ChangeTools\ChangeToolsFactory
A factory for ChangeTools objects.
Definition ChangeToolsFactory.php:17

MediaWiki\RecentChanges\ChangeTrackingEventIngress
The ingress subscriber for the change tracking component.
Definition ChangeTrackingEventIngress.php:37

MediaWiki\RecentChanges\ChangesListQuery\ChangesListQueryFactory
Use via MediaWikiServices::getChangesListQueryFactory.
Definition ChangesListQueryFactory.php:23

MediaWiki\RecentChanges\PatrolManager
Definition PatrolManager.php:26

MediaWiki\RecentChanges\RecentChangeRCFeedNotifier
Definition RecentChangeRCFeedNotifier.php:19

MediaWiki\RecentChanges\RecentChangeStore
Definition RecentChangeStore.php:39

MediaWiki\Registration\ExtensionRegistry
Load JSON files, and uses a Processor to extract information.
Definition ExtensionRegistry.php:36

MediaWiki\RenameUser\RenameUserFactory
Definition RenameUserFactory.php:19

MediaWiki\Request\ProxyLookup
Definition ProxyLookup.php:18

MediaWiki\Request\WebRequest
The WebRequest class encapsulates getting at data passed in the URL or via a POSTed form,...
Definition WebRequest.php:40

MediaWiki\ResourceLoader\DependencyStore
Track per-module dependency file paths that are expensive to mass compute.
Definition DependencyStore.php:19

MediaWiki\ResourceLoader\MessageBlobStore
This class generates message blobs for use by ResourceLoader.
Definition MessageBlobStore.php:28

MediaWiki\ResourceLoader\ResourceLoader
ResourceLoader is a loading system for JavaScript and CSS resources.
Definition ResourceLoader.php:78

MediaWiki\Rest\Handler\Helper\PageRestHelperFactory
Definition PageRestHelperFactory.php:36

MediaWiki\Revision\ArchivedRevisionLookup
Definition ArchivedRevisionLookup.php:19

MediaWiki\Revision\MainSlotRoleHandler
A SlotRoleHandler for the main slot.
Definition MainSlotRoleHandler.php:31

MediaWiki\Revision\RevisionRenderer
The RevisionRenderer service provides access to rendered output for revisions.
Definition RevisionRenderer.php:33

MediaWiki\Revision\RevisionRenderer\setLogger
setLogger(LoggerInterface $saveParseLogger)
Definition RevisionRenderer.php:70

MediaWiki\Revision\RevisionStoreFactory
Factory service for RevisionStore instances.
Definition RevisionStoreFactory.php:44

MediaWiki\Revision\RevisionStore
Service for looking up page revisions.
Definition RevisionStore.php:80

MediaWiki\Revision\SlotRecord
Value object representing a content slot associated with a page revision.
Definition SlotRecord.php:26

MediaWiki\Revision\SlotRoleRegistry
A registry service for SlotRoleHandlers, used to define which slot roles are available on which page.
Definition SlotRoleRegistry.php:34

MediaWiki\Revision\SlotRoleRegistry\defineRole
defineRole(string $role, callable $instantiator)
Defines a slot role.
Definition SlotRoleRegistry.php:58

MediaWiki\Search\SearchEngineConfig
Configuration handling class for SearchEngine.
Definition SearchEngineConfig.php:20

MediaWiki\Search\SearchEngineFactory
Factory class for SearchEngine.
Definition SearchEngineFactory.php:13

MediaWiki\Search\SearchEventIngress
The ingress adapter for the search component.
Definition SearchEventIngress.php:22

MediaWiki\Search\SearchResultThumbnailProvider
Find thumbnails for search results.
Definition SearchResultThumbnailProvider.php:18

MediaWiki\Search\TitleMatcher
Service implementation of near match title search.
Definition TitleMatcher.php:18

MediaWiki\Session\MultiBackendSessionStore
An implementation of a session store with two backends for storing anonymous and authenticated sessio...
Definition MultiBackendSessionStore.php:46

MediaWiki\Session\SessionManager
This serves as the entry point to the MediaWiki session handling system.
Definition SessionManager.php:54

MediaWiki\Session\SingleBackendSessionStore
An implementation of a session store with a single backend for storing anonymous and authenticated se...
Definition SingleBackendSessionStore.php:24

MediaWiki\Settings\SettingsBuilder
Builder class for constructing a Config object from a set of sources during bootstrap.
Definition SettingsBuilder.php:55

MediaWiki\ShadowPage\ShadowPageLoader
A service which loads shadow content, which is content that is displayed on a nonexistent page with a...
Definition ShadowPageLoader.php:19

MediaWiki\Shell\CommandFactory
Factory facilitating dependency injection for Command.
Definition CommandFactory.php:21

MediaWiki\Shell\ShellboxClientFactory
This is a service which provides a configured client to access a remote Shellbox installation.
Definition ShellboxClientFactory.php:19

MediaWiki\Site\CachingSiteStore
Wrap SiteList with an in-process cache and (optionally) a local-server cache.
Definition CachingSiteStore.php:19

MediaWiki\Site\DBSiteStore
Holds a list of sites stored in the database.
Definition DBSiteStore.php:20

MediaWiki\Skin\SkinApi
SkinTemplate class for API output.
Definition SkinApi.php:19

MediaWiki\Skin\SkinAuthenticationPopup
SkinAuthenticationPopup is a "micro-skin" that omits most of the usual interface elements,...
Definition SkinAuthenticationPopup.php:20

MediaWiki\Skin\SkinFactory
Factory class to create Skin objects.
Definition SkinFactory.php:20

MediaWiki\Skin\SkinFallback
Skin implementation for the "Fallback" skin.
Definition SkinFallback.php:21

MediaWiki\SpecialPage\SpecialPageFactory
Factory for handling the special page list and generating SpecialPage objects.
Definition SpecialPageFactory.php:191

MediaWiki\Storage\BlobStoreFactory
Service for instantiating BlobStores.
Definition BlobStoreFactory.php:22

MediaWiki\Storage\EditResultCache
Class allowing easy storage and retrieval of EditResults associated with revisions.
Definition EditResultCache.php:27

MediaWiki\Storage\NameTableStoreFactory
Definition NameTableStoreFactory.php:14

MediaWiki\Storage\NameTableStore
Definition NameTableStore.php:22

MediaWiki\Storage\PageEditStash
Manage the pre-emptive page parsing for edits to wiki pages.
Definition PageEditStash.php:43

MediaWiki\Storage\PageUpdaterFactory
A factory for PageUpdater and DerivedPageDataUpdater instances.
Definition PageUpdaterFactory.php:37

MediaWiki\Storage\RevertedTagUpdateManager
Class for managing delayed RevertedTagUpdateJob waiting for user approval.
Definition RevertedTagUpdateManager.php:21

MediaWiki\Storage\SqlBlobStore
Service for storing and loading Content objects representing revision data blobs.
Definition SqlBlobStore.php:36

MediaWiki\Telemetry\MediaWikiPropagator
A ContextPropagatorInterface implementation that injects headers from MediaWiki's request context,...
Definition MediaWikiPropagator.php:14

MediaWiki\Tidy\RemexDriver
Definition RemexDriver.php:14

MediaWiki\Tidy\TidyDriverBase
Base class for HTML cleanup utilities.
Definition TidyDriverBase.php:8

MediaWiki\Title\NamespaceInfo
This is a utility class for dealing with namespaces that encodes all the "magic" behaviors of them ba...
Definition NamespaceInfo.php:24

MediaWiki\Title\TitleFactory
Creates Title objects.
Definition TitleFactory.php:26

MediaWiki\Title\TitleFormatter
A title formatter service for MediaWiki.
Definition TitleFormatter.php:32

MediaWiki\Title\TitleParser
A title parser service for MediaWiki.
Definition TitleParser.php:29

MediaWiki\Upload\SVGCSSChecker
Ensure SVG files cannot load external resources via URLs in CSS.
Definition SVGCSSChecker.php:18

MediaWiki\Upload\UploadVerification
Service to verify file uploads are safe.
Definition UploadVerification.php:33

MediaWiki\User\ActorMigration
This is not intended to be a long-term part of MediaWiki; it will be deprecated and removed once acto...
Definition ActorMigration.php:19

MediaWiki\User\ActorStoreFactory
ActorStore factory for any wiki domain.
Definition ActorStoreFactory.php:24

MediaWiki\User\ActorStore
Service to read or write data in the actor table.
Definition ActorStore.php:30

MediaWiki\User\BotPasswordStore
BotPassword interaction with databases.
Definition BotPasswordStore.php:29

MediaWiki\User\CentralId\CentralIdLookupFactory
Factory class for CentralIdLookup.
Definition CentralIdLookupFactory.php:26

MediaWiki\User\CentralId\CentralIdLookup
Find central user IDs associated with local user IDs, e.g.
Definition CentralIdLookup.php:27

MediaWiki\User\MultiFormatUserIdentityLookup
A service to look up user identities based on the user input.
Definition MultiFormatUserIdentityLookup.php:29

MediaWiki\User\Options\ConditionalDefaultsLookup
Definition ConditionalDefaultsLookup.php:16

MediaWiki\User\Options\DefaultOptionsLookup
A service class to control default user options.
Definition DefaultOptionsLookup.php:27

MediaWiki\User\Options\StaticUserOptionsLookup
A UserOptionsLookup that's just an array.
Definition StaticUserOptionsLookup.php:13

MediaWiki\User\Options\UserOptionsLookup
Provides access to user options.
Definition UserOptionsLookup.php:17

MediaWiki\User\Options\UserOptionsManager
A service class to control user options.
Definition UserOptionsManager.php:31

MediaWiki\User\PasswordReset
Password reset helper for functionality shared by the web UI and the API.
Definition PasswordReset.php:35

MediaWiki\User\Registration\LocalUserRegistrationProvider
Definition LocalUserRegistrationProvider.php:10

MediaWiki\User\Registration\UserRegistrationLookup
Definition UserRegistrationLookup.php:16

MediaWiki\User\RestrictedUserGroupCheckerFactory
A service that helps to create RestrictedUserGroupChecker instances, either for the local or remote w...
Definition RestrictedUserGroupCheckerFactory.php:14

MediaWiki\User\RestrictedUserGroupConfigReader
A helper class to read the restricted user groups configuration for a given wiki.
Definition RestrictedUserGroupConfigReader.php:18

MediaWiki\User\TalkPageNotificationManager
Manages user talk page notifications.
Definition TalkPageNotificationManager.php:27

MediaWiki\User\TempUser\RealTempUserConfig
The real TempUserConfig including internal methods used by TempUserCreator.
Definition RealTempUserConfig.php:17

MediaWiki\User\TempUser\TempUserCreator
Service for temporary user creation.
Definition TempUserCreator.php:31

MediaWiki\User\TempUser\TempUserDetailsLookup
Caching lookup service for metadata related to temporary accounts, such as expiration.
Definition TempUserDetailsLookup.php:18

MediaWiki\User\UserEditTracker
Track info about user edit counts and timings.
Definition UserEditTracker.php:26

MediaWiki\User\UserFactory
Create User objects.
Definition UserFactory.php:32

MediaWiki\User\UserGroupAssignmentService
This class represents a service that provides high-level operations on user groups.
Definition UserGroupAssignmentService.php:33

MediaWiki\User\UserGroupManagerFactory
Factory service for UserGroupManager instances.
Definition UserGroupManagerFactory.php:23

MediaWiki\User\UserGroupManager
Manage user group memberships.
Definition UserGroupManager.php:34

MediaWiki\User\UserIdentityUtils
Convenience functions for interpreting UserIdentity objects using additional services or config.
Definition UserIdentityUtils.php:13

MediaWiki\User\UserNamePrefixSearch
Handles searching prefixes of user names.
Definition UserNamePrefixSearch.php:23

MediaWiki\User\UserNameUtils
UserNameUtils service.
Definition UserNameUtils.php:30

MediaWiki\User\UserRequirementsConditionCheckerFactory
Definition UserRequirementsConditionCheckerFactory.php:18

MediaWiki\User\UserRequirementsConditionChecker
Definition UserRequirementsConditionChecker.php:21

MediaWiki\User\UserRequirementsConditionValidator
Definition UserRequirementsConditionValidator.php:11

MediaWiki\Utils\SBOMGenerator
Definition SBOMGenerator.php:17

MediaWiki\Utils\UrlUtils
A service to expand, parse, and otherwise manipulate URLs.
Definition UrlUtils.php:16

MediaWiki\Watchlist\NoWriteWatchedItemStore
Definition NoWriteWatchedItemStore.php:22

MediaWiki\Watchlist\WatchedItemQueryService
Class performing complex database queries related to WatchedItems.
Definition WatchedItemQueryService.php:25

MediaWiki\Watchlist\WatchedItemStore
Storage layer class for WatchedItems.
Definition WatchedItemStore.php:42

MediaWiki\Watchlist\WatchlistLabelStore
Service class for storage of watchlist labels.
Definition WatchlistLabelStore.php:19

MediaWiki\Watchlist\WatchlistManager
WatchlistManager service.
Definition WatchlistManager.php:37

MediaWiki\WikiMap\WikiMap
Tools for dealing with other locally-hosted wikis.
Definition WikiMap.php:19

Wikimedia\EventRelayer\EventRelayerGroup
Factory class for spawning EventRelayer objects using configuration.
Definition EventRelayerGroup.php:16

Wikimedia\FileBackend\FSFile\TempFSFileFactory
Definition TempFSFileFactory.php:8

Wikimedia\LockManager\DatabaseLockManager
A simplified Database Lock Manager.
Definition DatabaseLockManager.php:13

Wikimedia\ObjectCache\BagOStuff
Abstract class for any ephemeral data store.
Definition BagOStuff.php:73

Wikimedia\ObjectCache\BagOStuff\get
get( $key, $flags=0)
Get an item.

Wikimedia\ObjectCache\EmptyBagOStuff
No-op implementation that stores nothing.
Definition EmptyBagOStuff.php:17

Wikimedia\ObjectCache\HashBagOStuff
Store data in a memory for the current request/process only.
Definition HashBagOStuff.php:21

Wikimedia\ObjectCache\WANObjectCache
Multi-datacenter aware caching interface.
Definition WANObjectCache.php:152

Wikimedia\Rdbms\ChronologyProtector
Provide a given client with protection against visible database lag.
Definition ChronologyProtector.php:119

Wikimedia\Rdbms\ConfiguredReadOnlyMode
Determine whether a site is statically configured as read-only.
Definition ConfiguredReadOnlyMode.php:13

Wikimedia\Rdbms\DatabaseFactory
Constructs Database objects.
Definition DatabaseFactory.php:22

Wikimedia\Rdbms\ReadOnlyMode
Determine whether a site is currently in read-only mode.
Definition ReadOnlyMode.php:12

Wikimedia\Stats\NullStatsdDataFactory
Definition NullStatsdDataFactory.php:13

Wikimedia\Stats\OutputFormats
Metrics Format and Output Helpers.
Definition OutputFormats.php:26

Wikimedia\Stats\PrefixingStatsdDataFactoryProxy
Proxy to prefix metric keys sent to a StatsdDataFactoryInterface.
Definition PrefixingStatsdDataFactoryProxy.php:27

Wikimedia\Stats\StatsCache
Singleton cache for Metric instances.
Definition StatsCache.php:23

Wikimedia\Stats\StatsFactory
This is the primary interface for validating metrics definitions, caching defined metrics,...
Definition StatsFactory.php:33

Wikimedia\Telemetry\Clock
A click providing the current time in nanoseconds, backed by hrtime.
Definition Clock.php:12

Wikimedia\Telemetry\CompositePropagator
CompositePropagator accepts an array of other propagators.
Definition CompositePropagator.php:12

Wikimedia\Telemetry\NoopTracer
A no-op tracer that creates no-op spans and persists no data.
Definition NoopTracer.php:12

Wikimedia\Telemetry\OtlpHttpExporter
An ExporterInterface that exports collected data over HTTP, serialized in OTLP JSON format.
Definition OtlpHttpExporter.php:16

Wikimedia\Telemetry\ProbabilisticSampler
A SamplerInterface implementation that samples a given percentage of root spans, while respecting sam...
Definition ProbabilisticSampler.php:13

Wikimedia\Telemetry\TracerState
Holds shared telemetry state, such as finished span data buffered for export.
Definition TracerState.php:16

Wikimedia\Telemetry\Tracer
Definition Tracer.php:10

Wikimedia\Telemetry\W3CTraceContextPropagator
A ContextPropagatorInterface implementation for W3C Trace Context.
Definition W3CTraceContextPropagator.php:17

Wikimedia\UUID\GlobalIdGenerator
Class for getting statistically unique IDs without a central coordinator.
Definition GlobalIdGenerator.php:20

Wikimedia\WRStats\BagOStuffStatsStore
An adaptor allowing WRStats to store data in MediaWiki's BagOStuff.
Definition BagOStuffStatsStore.php:13

Wikimedia\WRStats\WRStatsFactory
The main entry point to WRStats, for creating readers and writers.
Definition WRStatsFactory.php:13

MediaWiki\Block\BlockUserFactory
Definition BlockUserFactory.php:16

MediaWiki\Block\UnblockUserFactory
Definition UnblockUserFactory.php:16

MediaWiki\Config\Config
Interface for configuration instances.
Definition Config.php:18

MediaWiki\Content\IContentHandlerFactory
Definition IContentHandlerFactory.php:8

MediaWiki\DAO\WikiAwareEntity
Marker interface for entities aware of the wiki they belong to.
Definition WikiAwareEntity.php:35

MediaWiki\DomainEvent\DomainEventDispatcher
Service for sending domain events to registered listeners.
Definition DomainEventDispatcher.php:14

MediaWiki\DomainEvent\DomainEventSource
Service object for registering listeners for domain events.
Definition DomainEventSource.php:12

MediaWiki\Edit\ParsoidOutputStash
Stash for Parsoid output and associated data as needed to perform selective serialization (aka "selse...
Definition ParsoidOutputStash.php:16

MediaWiki\Import\OldRevisionImporter
Definition OldRevisionImporter.php:8

MediaWiki\Import\UploadRevisionImporter
Definition UploadRevisionImporter.php:8

MediaWiki\Interwiki\InterwikiLookup
Service interface for looking up Interwiki records.
Definition InterwikiLookup.php:16

MediaWiki\Json\JwtCodec
A helper to read and write JWTs without having to depend on a specific library, and using central con...
Definition JwtCodec.php:12

MediaWiki\Linker\LinkTargetLookup
Definition LinkTargetLookup.php:15

MediaWiki\Mail\IEmailer
Interface for sending arbitrary emails.
Definition IEmailer.php:20

MediaWiki\Page\ContentModelChangeFactory
Service for changing the content model of wiki pages.
Definition ContentModelChangeFactory.php:20

MediaWiki\Page\DeletePageFactory
Service for page delete actions.
Definition DeletePageFactory.php:15

MediaWiki\Page\MergeHistoryFactory
Service for mergehistory actions.
Definition MergeHistoryFactory.php:17

MediaWiki\Page\MovePageFactory
Service for page rename actions.
Definition MovePageFactory.php:16

MediaWiki\Page\RedirectLookup
Service for resolving a wiki page redirect.
Definition RedirectLookup.php:20

MediaWiki\Page\RollbackPageFactory
Service for page rollback actions.
Definition RollbackPageFactory.php:19

MediaWiki\Page\UndeletePageFactory
Service for page undelete actions.
Definition UndeletePageFactory.php:14

MediaWiki\Preferences\PreferencesFactory
A PreferencesFactory is a MediaWiki service that provides the definitions of preferences for a given ...
Definition PreferencesFactory.php:40

MediaWiki\RecentChanges\RecentChangeFactory
Definition RecentChangeFactory.php:19

MediaWiki\RecentChanges\RecentChangeLookup
Definition RecentChangeLookup.php:13

MediaWiki\Revision\RevisionFactory
Service for constructing RevisionRecord objects.
Definition RevisionFactory.php:24

MediaWiki\Revision\RevisionLookup
Service for looking up page revisions.
Definition RevisionLookup.php:25

MediaWiki\Session\SessionManagerInterface
MediaWiki\Session entry point interface.
Definition SessionManagerInterface.php:22

MediaWiki\Session\SessionStore
This is a session store abstraction layer, which can be used to read and write sessions to configured...
Definition SessionStore.php:53

MediaWiki\Settings\Config\ConfigSchema
Represents a config schema.
Definition ConfigSchema.php:11

MediaWiki\Site\SiteLookup
Interface to retrieve Site objects, for implementation by service classes.
Definition SiteLookup.php:17

MediaWiki\Site\SiteStore
Interface for storing and retrieving Site objects.
Definition SiteStore.php:18

MediaWiki\Storage\BlobStore
Service for loading and storing data blobs.
Definition BlobStore.php:19

MediaWiki\User\ActorNormalization
Service for dealing with the actor table.
Definition ActorNormalization.php:19

MediaWiki\User\UserIdentityLookup
Service for looking up UserIdentity.
Definition UserIdentityLookup.php:20

MediaWiki\User\UserIdentity
Interface for objects representing user identity.
Definition UserIdentity.php:24

Wikimedia\Message\IMessageFormatterFactory
A simple factory providing a message formatter for a given language code.
Definition IMessageFormatterFactory.php:10

Wikimedia\Rdbms\IConnectionProvider
Provide primary and replica IDatabase connections.
Definition IConnectionProvider.php:21

Wikimedia\Stats\IBufferingStatsdDataFactory
MediaWiki adaptation of StatsdDataFactory that provides buffering functionality.
Definition IBufferingStatsdDataFactory.php:16

Wikimedia\Telemetry\TracerInterface
Base interface for an OpenTelemetry tracer responsible for creating spans.
Definition TracerInterface.php:11

MediaWiki\Api\getRequest
getRequest()

MediaWiki\HTMLForm\$modules
array null $modules
Definition HTMLFormElement.php:20

MediaWiki\JobQueue\Jobs\$params
array $params
The job parameters.
Definition UploadJobTrait.php:38

MediaWiki\Specials\Helpers\getLanguage
getLanguage()

MediaWiki\Specials\Helpers\getConfig
getConfig()

MediaWiki\Watchlist\getLinkRenderer
getLinkRenderer()

MediaWiki
Helper trait for implementations \DAO.

Wikimedia\Leximorph\Traits\$spec
if(!isset( $specs[$class])) $spec
Definition SpecBasedFactoryTrait.php:82

Wikimedia\Leximorph\Traits\$logger
LoggerInterface $logger
Definition SpecBasedFactoryTrait.php:30

Wikimedia\Leximorph\Traits\$instance
$instance
Definition SpecBasedFactoryTrait.php:95

Wikimedia