code: def __init__(self) -> None:
      #: special attrgetter for autodoc; class object -> attrgetter
      self.autodoc_attrgettrs: dict[
          type, Callable[[Any, str, Any], Any]
      ] = {}
  
      #: builders; a dict of builder name -> builder class
      self.builders: dict[str, type[Builder]] = {}
  
      #: autodoc documenters; a dict of documenter name -> documenter class
      self.documenters: dict[str, type[Documenter]] = {}
  
      #: css_files; a list of tuple of filename and attributes
      self.css_files: list[tuple[str, dict[str, Any]]] = []
  
      #: domains; a dict of domain name -> domain class
      self.domains: dict[str, type[Domain]] = {}
  
      #: additional directives for domains
      #: a dict of domain name -> dict of directive name -> directive
      self.domain_directives: dict[str, dict[str, type[Directive]]] = {}
  
      #: additional indices for domains
      #: a dict of domain name -> list of index class
      self.domain_indices: dict[str, list[type[Index]]] = {}
  
      #: additional object types for domains
      #: a dict of domain name -> dict of objtype name -> objtype
      self.domain_object_types: dict[str, dict[str, ObjType]] = {}
  
      #: additional roles for domains
      #: a dict of domain name -> dict of role name -> role impl.
      self.domain_roles: dict[
          str, dict[str, RoleFunction | XRefRole]
      ] = {}
  
      #: additional enumerable nodes
      #: a dict of node class -> tuple of figtype and title_getter function
      self.enumerable_nodes: dict[
          type[Node], tuple[str, TitleGetter | None]
      ] = {}
  
      #: HTML inline and block math renderers
      #: a dict of name -> tuple of visit function and depart function
      self.html_inline_math_renderers: dict[
          str, tuple[Callable, Callable | None]
      ] = {}
      self.html_block_math_renderers: dict[
          str, tuple[Callable, Callable | None]
      ] = {}
  
      #: HTML assets
      self.html_assets_policy: str = "per_page"
  
      #: HTML themes
      self.html_themes: dict[str, str] = {}
  
      #: js_files; list of JS paths or URLs
      self.js_files: list[tuple[str | None, dict[str, Any]]] = []
  
      #: LaTeX packages; list of package names and its options
      self.latex_packages: list[tuple[str, str | None]] = []
  
      self.latex_packages_after_hyperref: list[
          tuple[str, str | None]
      ] = []
  
      #: post transforms; list of transforms
      self.post_transforms: list[type[Transform]] = []
  
      #: source paresrs; file type -> parser class
      self.source_parsers: dict[str, type[Parser]] = {}
  
      #: source suffix: suffix -> file type
      self.source_suffix: dict[str, str] = {}
  
      #: custom translators; builder name -> translator class
      self.translators: dict[str, type[nodes.NodeVisitor]] = {}
  
      #: custom handlers for translators
      #: a dict of builder name -> dict of node name -> visitor and departure functions
      self.translation_handlers: dict[
          str, dict[str, tuple[Callable, Callable | None]]
      ] = {}
  
      #: additional transforms; list of transforms
      self.transforms: list[type[Transform]] = []
  
      # private cache of Docutils Publishers (file type -> publisher object)
      self.publishers: dict[str, Publisher] = {}
  
imports: from __future__ import annotations
  import sys
  import traceback
  from importlib import import_module
  from types import MethodType
  from typing import TYPE_CHECKING, Any, Callable
  from sphinx.domains import Domain, Index, ObjType
  from sphinx.domains.std import GenericObject, Target
  from sphinx.errors import ExtensionError, SphinxError, VersionRequirementError
  from sphinx.extension import Extension
  from sphinx.io import create_publisher
  from sphinx.locale import __
  from sphinx.parsers import Parser
  from sphinx.roles import XRefRole
  from sphinx.util import logging
  from sphinx.util.logging import prefixed_warnings
label_desc: Use image node_id 1 to create a new SphinxComponentRegistry object  with example: obj = SphinxComponentRegistry()