Sphinx 7.1.1__py3-none-any.whl → 7.2.0__py3-none-any.whl

sphinx/builders/html/__init__.py

@@ -2,16 +2,17 @@
 
 from __future__ import annotations
 
+import contextlib
+import hashlib
 import html
 import os
 import posixpath
 import re
 import sys
+import time
 import warnings
-import zlib
-from datetime import datetime, timezone
 from os import path
-from typing import IO, Any, Iterable, Iterator, List, Tuple, Type
+from typing import IO, TYPE_CHECKING, Any
 from urllib.parse import quote
 
 import docutils.readers.doctree
@@ -19,49 +20,56 @@ from docutils import nodes
 from docutils.core import Publisher
 from docutils.frontend import OptionParser
 from docutils.io import DocTreeInput, StringOutput
-from docutils.nodes import Node
 from docutils.utils import relative_path
 
 from sphinx import __display_version__, package_dir
 from sphinx import version_info as sphinx_version
-from sphinx.application import Sphinx
 from sphinx.builders import Builder
+from sphinx.builders.html._assets import _CascadingStyleSheet, _file_checksum, _JavaScript
 from sphinx.config import ENUM, Config
+from sphinx.deprecation import _deprecation_warning
 from sphinx.domains import Domain, Index, IndexEntry
-from sphinx.environment import BuildEnvironment
 from sphinx.environment.adapters.asset import ImageAdapter
 from sphinx.environment.adapters.indexentries import IndexEntries
-from sphinx.environment.adapters.toctree import TocTree
+from sphinx.environment.adapters.toctree import document_toc, global_toctree_for_doc
 from sphinx.errors import ConfigError, ThemeError
 from sphinx.highlighting import PygmentsBridge
 from sphinx.locale import _, __
 from sphinx.search import js_index
 from sphinx.theming import HTMLThemeFactory
-from sphinx.util import isurl, logging, md5
+from sphinx.util import isurl, logging
 from sphinx.util.display import progress_message, status_iterator
 from sphinx.util.docutils import new_document
 from sphinx.util.fileutil import copy_asset
 from sphinx.util.i18n import format_date
 from sphinx.util.inventory import InventoryFile
 from sphinx.util.matching import DOTFILES, Matcher, patmatch
-from sphinx.util.osutil import copyfile, ensuredir, os_path, relative_uri
-from sphinx.util.tags import Tags
+from sphinx.util.osutil import SEP, copyfile, ensuredir, os_path, relative_uri
 from sphinx.writers.html import HTMLWriter
 from sphinx.writers.html5 import HTML5Translator
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Sequence
+
+    from docutils.nodes import Node
+
+    from sphinx.application import Sphinx
+    from sphinx.environment import BuildEnvironment
+    from sphinx.util.tags import Tags
+
 #: the filename for the inventory of objects
 INVENTORY_FILENAME = 'objects.inv'
 
 logger = logging.getLogger(__name__)
 return_codes_re = re.compile('[\r\n]+')
 
-DOMAIN_INDEX_TYPE = Tuple[
+DOMAIN_INDEX_TYPE = tuple[
     # Index name (e.g. py-modindex)
     str,
     # Index class
-    Type[Index],
+    type[Index],
     # list of (heading string, list of index entries) pairs.
-    List[Tuple[str, List[IndexEntry]]],
+    list[tuple[str, list[IndexEntry]]],
     # whether sub-entries should start collapsed
     bool,
 ]
@@ -77,7 +85,7 @@ def get_stable_hash(obj: Any) -> str:
         return get_stable_hash(list(obj.items()))
     elif isinstance(obj, (list, tuple)):
         obj = sorted(get_stable_hash(o) for o in obj)
-    return md5(str(obj).encode()).hexdigest()
+    return hashlib.md5(str(obj).encode(), usedforsecurity=False).hexdigest()
 
 
 def convert_locale_to_language_tag(locale: str | None) -> str | None:
@@ -91,52 +99,6 @@ def convert_locale_to_language_tag(locale: str | None) -> str | None:
         return None
 
 
-class Stylesheet(str):
-    """A metadata of stylesheet.
-
-    To keep compatibility with old themes, an instance of stylesheet behaves as
-    its filename (str).
-    """
-
-    attributes: dict[str, str] = None
-    filename: str = None
-    priority: int = None
-
-    def __new__(cls, filename: str, *args: str, priority: int = 500, **attributes: Any,
-                ) -> Stylesheet:
-        self = str.__new__(cls, filename)
-        self.filename = filename
-        self.priority = priority
-        self.attributes = attributes
-        self.attributes.setdefault('rel', 'stylesheet')
-        self.attributes.setdefault('type', 'text/css')
-        if args:  # old style arguments (rel, title)
-            self.attributes['rel'] = args[0]
-            self.attributes['title'] = args[1]
-
-        return self
-
-
-class JavaScript(str):
-    """A metadata of javascript file.
-
-    To keep compatibility with old themes, an instance of javascript behaves as
-    its filename (str).
-    """
-
-    attributes: dict[str, str] = None
-    filename: str = None
-    priority: int = None
-
-    def __new__(cls, filename: str, priority: int = 500, **attributes: str) -> JavaScript:
-        self = str.__new__(cls, filename)
-        self.filename = filename
-        self.priority = priority
-        self.attributes = attributes
-
-        return self
-
-
 class BuildInfo:
     """buildinfo file manipulator.
 
@@ -163,7 +125,7 @@ class BuildInfo:
         self,
         config: Config | None = None,
         tags: Tags | None = None,
-        config_categories: list[str] = [],
+        config_categories: Sequence[str] = (),
     ) -> None:
         self.config_hash = ''
         self.tags_hash = ''
@@ -175,7 +137,7 @@ class BuildInfo:
         if tags:
             self.tags_hash = get_stable_hash(sorted(tags))
 
-    def __eq__(self, other: BuildInfo) -> bool:  # type: ignore
+    def __eq__(self, other: BuildInfo) -> bool:  # type: ignore[override]
         return (self.config_hash == other.config_hash and
                 self.tags_hash == other.tags_hash)
 
@@ -217,17 +179,17 @@ class StandaloneHTMLBuilder(Builder):
     use_index = False
     download_support = True  # enable download role
 
-    imgpath: str = None
+    imgpath: str = ''
     domain_indices: list[DOMAIN_INDEX_TYPE] = []
 
-    def __init__(self, app: Sphinx, env: BuildEnvironment | None = None) -> None:
+    def __init__(self, app: Sphinx, env: BuildEnvironment) -> None:
         super().__init__(app, env)
 
         # CSS files
-        self.css_files: list[Stylesheet] = []
+        self._css_files: list[_CascadingStyleSheet] = []
 
         # JS files
-        self.script_files: list[JavaScript] = []
+        self._js_files: list[_JavaScript] = []
 
         # Cached Publisher for writing doctrees to HTML
         reader = docutils.readers.doctree.Reader(parser_name='restructuredtext')
@@ -252,7 +214,7 @@ class StandaloneHTMLBuilder(Builder):
         # section numbers for headings in the currently visited document
         self.secnumbers: dict[str, tuple[int, ...]] = {}
         # currently written docname
-        self.current_docname: str = None
+        self.current_docname: str = ''
 
         self.init_templates()
         self.init_highlighter()
@@ -286,7 +248,7 @@ class StandaloneHTMLBuilder(Builder):
         for jsfile in candidates:
             if path.isfile(jsfile):
                 return jsfile
-        return None
+        return ''
 
     def _get_style_filenames(self) -> Iterator[str]:
         if isinstance(self.config.html_style, str):
@@ -325,6 +287,7 @@ class StandaloneHTMLBuilder(Builder):
         else:
             dark_style = None
 
+        self.dark_highlighter: PygmentsBridge | None
         if dark_style is not None:
             self.dark_highlighter = PygmentsBridge('html', dark_style)
             self.app.add_css_file('pygments_dark.css',
@@ -333,8 +296,14 @@ class StandaloneHTMLBuilder(Builder):
         else:
             self.dark_highlighter = None
 
+    @property
+    def css_files(self) -> list[_CascadingStyleSheet]:
+        _deprecation_warning(__name__, f'{self.__class__.__name__}.css_files', '',
+                             remove=(9, 0))
+        return self._css_files
+
     def init_css_files(self) -> None:
-        self.css_files = []
+        self._css_files = []
         self.add_css_file('pygments.css', priority=200)
 
         for filename in self._get_style_filenames():
@@ -351,21 +320,26 @@ class StandaloneHTMLBuilder(Builder):
         if '://' not in filename:
             filename = posixpath.join('_static', filename)
 
-        self.css_files.append(Stylesheet(filename, **kwargs))
+        self._css_files.append(_CascadingStyleSheet(filename, **kwargs))
+
+    @property
+    def script_files(self) -> list[_JavaScript]:
+        _deprecation_warning(__name__, f'{self.__class__.__name__}.script_files', '',
+                             remove=(9, 0))
+        return self._js_files
 
     def init_js_files(self) -> None:
-        self.script_files = []
-        self.add_js_file('documentation_options.js', id="documentation_options",
-                         data_url_root='', priority=200)
+        self._js_files = []
+        self.add_js_file('documentation_options.js', priority=200)
         self.add_js_file('doctools.js', priority=200)
         self.add_js_file('sphinx_highlight.js', priority=200)
 
         for filename, attrs in self.app.registry.js_files:
-            self.add_js_file(filename, **attrs)
+            self.add_js_file(filename or '', **attrs)
 
         for filename, attrs in self.get_builder_config('js_files', 'html'):
             attrs.setdefault('priority', 800)  # User's JSs are loaded after extensions'
-            self.add_js_file(filename, **attrs)
+            self.add_js_file(filename or '', **attrs)
 
         if self._get_translations_js():
             self.add_js_file('translations.js')
@@ -374,10 +348,10 @@ class StandaloneHTMLBuilder(Builder):
         if filename and '://' not in filename:
             filename = posixpath.join('_static', filename)
 
-        self.script_files.append(JavaScript(filename, **kwargs))
+        self._js_files.append(_JavaScript(filename, **kwargs))
 
     @property
-    def math_renderer_name(self) -> str:
+    def math_renderer_name(self) -> str | None:
         name = self.get_builder_config('math_renderer', 'html')
         if name is not None:
             # use given name
@@ -426,17 +400,15 @@ class StandaloneHTMLBuilder(Builder):
             except Exception:
                 targetmtime = 0
             try:
-                srcmtime = max(path.getmtime(self.env.doc2path(docname)),
-                               template_mtime)
+                srcmtime = max(path.getmtime(self.env.doc2path(docname)), template_mtime)
                 if srcmtime > targetmtime:
                     logger.debug(
                         '[build target] targetname %r(%s), template(%s), docname %r(%s)',
                         targetname,
-                        datetime.fromtimestamp(targetmtime, tz=timezone.utc),
-                        datetime.fromtimestamp(template_mtime, tz=timezone.utc),
+                        _format_modified_time(targetmtime),
+                        _format_modified_time(template_mtime),
                         docname,
-                        datetime.fromtimestamp(path.getmtime(self.env.doc2path(docname)),
-                                               tz=timezone.utc),
+                        _format_modified_time(path.getmtime(self.env.doc2path(docname))),
                     )
                     yield docname
             except OSError:
@@ -455,7 +427,7 @@ class StandaloneHTMLBuilder(Builder):
         doc.append(node)
         self._publisher.set_source(doc)
         self._publisher.publish()
-        return self._publisher.writer.parts
+        return self._publisher.writer.parts  # type: ignore[union-attr]
 
     def prepare_writing(self, docnames: set[str]) -> None:
         # create the search indexer
@@ -498,6 +470,7 @@ class StandaloneHTMLBuilder(Builder):
 
         # format the "last updated on" string, only once is enough since it
         # typically doesn't include the time of day
+        self.last_updated: str | None
         lufmt = self.config.html_last_updated_fmt
         if lufmt is not None:
             self.last_updated = format_date(lufmt or _('%b %d, %Y'),
@@ -526,9 +499,15 @@ class StandaloneHTMLBuilder(Builder):
                 rellinks.append((indexname, indexcls.localname,
                                  '', indexcls.shortname))
 
-        # back up script_files and css_files to allow adding JS/CSS files to a specific page.
-        self._script_files = list(self.script_files)
-        self._css_files = list(self.css_files)
+        # add assets registered after ``Builder.init()``.
+        for css_filename, attrs in self.app.registry.css_files:
+            self.add_css_file(css_filename, **attrs)
+        for js_filename, attrs in self.app.registry.js_files:
+            self.add_js_file(js_filename or '', **attrs)
+
+        # back up _css_files and _js_files to allow adding CSS/JS files to a specific page.
+        self._orig_css_files = list(dict.fromkeys(self._css_files))
+        self._orig_js_files = list(dict.fromkeys(self._js_files))
         styles = list(self._get_style_filenames())
 
         self.globalcontext = {
@@ -551,9 +530,9 @@ class StandaloneHTMLBuilder(Builder):
             'sourcelink_suffix': self.config.html_sourcelink_suffix,
             'file_suffix': self.out_suffix,
             'link_suffix': self.link_suffix,
-            'script_files': self.script_files,
+            'script_files': self._js_files,
             'language': convert_locale_to_language_tag(self.config.language),
-            'css_files': self.css_files,
+            'css_files': self._css_files,
             'sphinx_version': __display_version__,
             'sphinx_version_tuple': sphinx_version,
             'docutils_version_info': docutils.__version_info__[:5],
@@ -600,12 +579,11 @@ class StandaloneHTMLBuilder(Builder):
                 # that gracefully
                 prev = None
         while related and related[0]:
-            try:
+            with contextlib.suppress(KeyError):
                 parents.append(
                     {'link': self.get_relative_uri(docname, related[0]),
                      'title': self.render_partial(titles[related[0]])['title']})
-            except KeyError:
-                pass
+
             related = self.relations.get(related[0])
         if parents:
             # remove link to the master file; we have a generic
@@ -632,7 +610,7 @@ class StandaloneHTMLBuilder(Builder):
         meta = self.env.metadata.get(docname)
 
         # local TOC and global TOC tree
-        self_toc = TocTree(self.env).get_toc_for(docname, self)
+        self_toc = document_toc(self.env, docname, self.tags)
         toc = self.render_partial(self_toc)['fragment']
 
         return {
@@ -780,7 +758,7 @@ class StandaloneHTMLBuilder(Builder):
 
     def copy_download_files(self) -> None:
         def to_relpath(f: str) -> str:
-            return relative_path(self.srcdir, f)
+            return relative_path(self.srcdir, f)  # type: ignore[arg-type]
 
         # copy downloadable files
         if self.env.dlfiles:
@@ -820,9 +798,9 @@ class StandaloneHTMLBuilder(Builder):
                 for jsfile in self.indexer.get_js_stemmer_rawcodes():
                     copyfile(jsfile, path.join(self.outdir, '_static', path.basename(jsfile)))
             else:
-                jsfile = self.indexer.get_js_stemmer_rawcode()
-                if jsfile:
-                    copyfile(jsfile, path.join(self.outdir, '_static', '_stemmer.js'))
+                if js_stemmer_rawcode := self.indexer.get_js_stemmer_rawcode():
+                    copyfile(js_stemmer_rawcode,
+                             path.join(self.outdir, '_static', '_stemmer.js'))
 
     def copy_theme_static_files(self, context: dict[str, Any]) -> None:
         def onerror(filename: str, error: Exception) -> None:
@@ -930,6 +908,7 @@ class StandaloneHTMLBuilder(Builder):
                 reference.append(node)
 
     def load_indexer(self, docnames: Iterable[str]) -> None:
+        assert self.indexer is not None
         keep = set(self.env.all_docs) - set(docnames)
         try:
             searchindexfn = path.join(self.outdir, self.searchindex_filename)
@@ -950,7 +929,7 @@ class StandaloneHTMLBuilder(Builder):
     def index_page(self, pagename: str, doctree: nodes.document, title: str) -> None:
         # only index pages with title
         if self.indexer is not None and title:
-            filename = self.env.doc2path(pagename, base=None)
+            filename = self.env.doc2path(pagename, base=False)
             metadata = self.env.metadata.get(pagename, {})
             if 'nosearch' in metadata:
                 self.indexer.feed(pagename, filename, '', new_document(''))
@@ -962,8 +941,8 @@ class StandaloneHTMLBuilder(Builder):
             kwargs['includehidden'] = False
         if kwargs.get('maxdepth') == '':
             kwargs.pop('maxdepth')
-        return self.render_partial(TocTree(self.env).get_toctree_for(
-            docname, self, collapse, **kwargs))['fragment']
+        toctree = global_toctree_for_doc(self.env, docname, self, collapse=collapse, **kwargs)
+        return self.render_partial(toctree)['fragment']
 
     def get_outfilename(self, pagename: str) -> str:
         return path.join(self.outdir, os_path(pagename) + self.out_suffix)
@@ -1068,9 +1047,53 @@ class StandaloneHTMLBuilder(Builder):
         self.add_sidebars(pagename, ctx)
         ctx.update(addctx)
 
-        # revert script_files and css_files
-        self.script_files[:] = self._script_files
-        self.css_files[:] = self._css_files
+        # 'blah.html' should have content_root = './' not ''.
+        ctx['content_root'] = (f'..{SEP}' * default_baseuri.count(SEP)) or f'.{SEP}'
+
+        outdir = self.app.outdir
+
+        def css_tag(css: _CascadingStyleSheet) -> str:
+            attrs = []
+            for key, value in css.attributes.items():
+                if value is not None:
+                    attrs.append(f'{key}="{html.escape(value, quote=True)}"')
+            uri = pathto(os.fspath(css.filename), resource=True)
+            if checksum := _file_checksum(outdir, css.filename):
+                uri += f'?v={checksum}'
+            return f'<link {" ".join(sorted(attrs))} href="{uri}" />'
+
+        ctx['css_tag'] = css_tag
+
+        def js_tag(js: _JavaScript | str) -> str:
+            if not isinstance(js, _JavaScript):
+                # str value (old styled)
+                return f'<script src="{pathto(js, resource=True)}"></script>'
+
+            attrs = []
+            body = js.attributes.get('body', '')
+            for key, value in js.attributes.items():
+                if key == 'body':
+                    continue
+                if value is not None:
+                    attrs.append(f'{key}="{html.escape(value, quote=True)}"')
+
+            if not js.filename:
+                if attrs:
+                    return f'<script {" ".join(sorted(attrs))}>{body}</script>'
+                return f'<script>{body}</script>'
+
+            uri = pathto(os.fspath(js.filename), resource=True)
+            if checksum := _file_checksum(outdir, js.filename):
+                uri += f'?v={checksum}'
+            if attrs:
+                return f'<script {" ".join(sorted(attrs))} src="{uri}"></script>'
+            return f'<script src="{uri}"></script>'
+
+        ctx['js_tag'] = js_tag
+
+        # revert _css_files and _js_files
+        self._css_files[:] = self._orig_css_files
+        self._js_files[:] = self._orig_js_files
 
         self.update_page_context(pagename, templatename, ctx, event_arg)
         newtmpl = self.app.emit_firstresult('html-page-context', pagename,
@@ -1079,7 +1102,7 @@ class StandaloneHTMLBuilder(Builder):
             templatename = newtmpl
 
         # sort JS/CSS before rendering HTML
-        try:
+        try:  # NoQA: SIM105
             # Convert script_files to list to support non-list script_files (refs: #8889)
             ctx['script_files'] = sorted(ctx['script_files'], key=lambda js: js.priority)
         except AttributeError:
@@ -1089,10 +1112,8 @@ class StandaloneHTMLBuilder(Builder):
             # Note: priority sorting feature will not work in this case.
             pass
 
-        try:
+        with contextlib.suppress(AttributeError):
             ctx['css_files'] = sorted(ctx['css_files'], key=lambda css: css.priority)
-        except AttributeError:
-            pass
 
         try:
             output = self.templates.render(templatename, ctx)
@@ -1127,8 +1148,7 @@ class StandaloneHTMLBuilder(Builder):
         pass
 
     def handle_finish(self) -> None:
-        if self.indexer:
-            self.finish_tasks.add_task(self.dump_search_index)
+        self.finish_tasks.add_task(self.dump_search_index)
         self.finish_tasks.add_task(self.dump_inventory)
 
     @progress_message(__('dumping object inventory'))
@@ -1136,6 +1156,9 @@ class StandaloneHTMLBuilder(Builder):
         InventoryFile.dump(path.join(self.outdir, INVENTORY_FILENAME), self.env, self)
 
     def dump_search_index(self) -> None:
+        if self.indexer is None:
+            return
+
         with progress_message(__('dumping search index in %s') % self.indexer.label()):
             self.indexer.prune(self.env.all_docs)
             searchindexfn = path.join(self.outdir, self.searchindex_filename)
@@ -1164,7 +1187,13 @@ def convert_html_css_files(app: Sphinx, config: Config) -> None:
                 logger.warning(__('invalid css_file: %r, ignored'), entry)
                 continue
 
-    config.html_css_files = html_css_files  # type: ignore
+    config.html_css_files = html_css_files  # type: ignore[attr-defined]
+
+
+def _format_modified_time(timestamp: float) -> str:
+    """Return an RFC 3339 formatted string representing the given timestamp."""
+    seconds, fraction = divmod(timestamp, 1)
+    return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(seconds)) + f'.{fraction:.3f}'
 
 
 def convert_html_js_files(app: Sphinx, config: Config) -> None:
@@ -1181,89 +1210,13 @@ def convert_html_js_files(app: Sphinx, config: Config) -> None:
                 logger.warning(__('invalid js_file: %r, ignored'), entry)
                 continue
 
-    config.html_js_files = html_js_files  # type: ignore
-
-
-def setup_css_tag_helper(app: Sphinx, pagename: str, templatename: str,
-                         context: dict, doctree: Node) -> None:
-    """Set up css_tag() template helper.
-
-    .. note:: This set up function is added to keep compatibility with webhelper.
-    """
-    pathto = context.get('pathto')
-
-    def css_tag(css: Stylesheet) -> str:
-        attrs = []
-        for key in sorted(css.attributes):
-            value = css.attributes[key]
-            if value is not None:
-                attrs.append(f'{key}="{html.escape(value, True)}"')
-        uri = pathto(css.filename, resource=True)
-        if checksum := _file_checksum(app.outdir, css.filename):
-            uri += f'?v={checksum}'
-        attrs.append(f'href="{uri}"')
-        return f'<link {" ".join(attrs)} />'
-
-    context['css_tag'] = css_tag
-
-
-def setup_js_tag_helper(app: Sphinx, pagename: str, templatename: str,
-                        context: dict, doctree: Node) -> None:
-    """Set up js_tag() template helper.
-
-    .. note:: This set up function is added to keep compatibility with webhelper.
-    """
-    pathto = context.get('pathto')
-
-    def js_tag(js: JavaScript) -> str:
-        attrs = []
-        body = ''
-        if isinstance(js, JavaScript):
-            for key in sorted(js.attributes):
-                value = js.attributes[key]
-                if value is not None:
-                    if key == 'body':
-                        body = value
-                    elif key == 'data_url_root':
-                        attrs.append(f'data-url_root="{pathto("", resource=True)}"')
-                    else:
-                        attrs.append(f'{key}="{html.escape(value, True)}"')
-            if js.filename:
-                uri = pathto(js.filename, resource=True)
-                if checksum := _file_checksum(app.outdir, js.filename):
-                    uri += f'?v={checksum}'
-                attrs.append(f'src="{uri}"')
-        else:
-            # str value (old styled)
-            attrs.append(f'src="{pathto(js, resource=True)}"')
-
-        if attrs:
-            return f'<script {" ".join(attrs)}>{body}</script>'
-        else:
-            return f'<script>{body}</script>'
-
-    context['js_tag'] = js_tag
-
-
-def _file_checksum(outdir: str, filename: str) -> str:
-    # Don't generate checksums for HTTP URIs
-    if '://' in filename:
-        return ''
-    try:
-        # Ensure universal newline mode is used to avoid checksum differences
-        with open(path.join(outdir, filename), encoding='utf-8') as f:
-            content = f.read().encode(encoding='utf-8')
-    except FileNotFoundError:
-        return ''
-    if not content:
-        return ''
-    return f'{zlib.crc32(content):08x}'
+    config.html_js_files = html_js_files  # type: ignore[attr-defined]
 
 
 def setup_resource_paths(app: Sphinx, pagename: str, templatename: str,
                          context: dict, doctree: Node) -> None:
     """Set up relative resource paths."""
-    pathto = context.get('pathto')
+    pathto = context['pathto']
 
     # favicon_url
     favicon_url = context.get('favicon_url')
@@ -1280,7 +1233,7 @@ def validate_math_renderer(app: Sphinx) -> None:
     if app.builder.format != 'html':
         return
 
-    name = app.builder.math_renderer_name  # type: ignore
+    name = app.builder.math_renderer_name  # type: ignore[attr-defined]
     if name is None:
         raise ConfigError(__('Many math_renderers are registered. '
                              'But no math_renderer is selected.'))
@@ -1296,7 +1249,7 @@ def validate_html_extra_path(app: Sphinx, config: Config) -> None:
             logger.warning(__('html_extra_path entry %r does not exist'), entry)
             config.html_extra_path.remove(entry)
         elif (path.splitdrive(app.outdir)[0] == path.splitdrive(extra_path)[0] and
-              path.commonpath([app.outdir, extra_path]) == app.outdir):
+              path.commonpath((app.outdir, extra_path)) == path.normpath(app.outdir)):
             logger.warning(__('html_extra_path entry %r is placed inside outdir'), entry)
             config.html_extra_path.remove(entry)
 
@@ -1309,7 +1262,7 @@ def validate_html_static_path(app: Sphinx, config: Config) -> None:
             logger.warning(__('html_static_path entry %r does not exist'), entry)
             config.html_static_path.remove(entry)
         elif (path.splitdrive(app.outdir)[0] == path.splitdrive(static_path)[0] and
-              path.commonpath([app.outdir, static_path]) == app.outdir):
+              path.commonpath((app.outdir, static_path)) == path.normpath(app.outdir)):
             logger.warning(__('html_static_path entry %r is placed inside outdir'), entry)
             config.html_static_path.remove(entry)
 
@@ -1320,7 +1273,7 @@ def validate_html_logo(app: Sphinx, config: Config) -> None:
             not path.isfile(path.join(app.confdir, config.html_logo)) and
             not isurl(config.html_logo)):
         logger.warning(__('logo file %r does not exist'), config.html_logo)
-        config.html_logo = None  # type: ignore
+        config.html_logo = None  # type: ignore[attr-defined]
 
 
 def validate_html_favicon(app: Sphinx, config: Config) -> None:
@@ -1329,7 +1282,7 @@ def validate_html_favicon(app: Sphinx, config: Config) -> None:
             not path.isfile(path.join(app.confdir, config.html_favicon)) and
             not isurl(config.html_favicon)):
         logger.warning(__('favicon file %r does not exist'), config.html_favicon)
-        config.html_favicon = None  # type: ignore
+        config.html_favicon = None  # type: ignore[attr-defined]
 
 
 def error_on_html_4(_app: Sphinx, config: Config) -> None:
@@ -1383,7 +1336,7 @@ def setup(app: Sphinx) -> dict[str, Any]:
     app.add_config_value('html_secnumber_suffix', '. ', 'html')
     app.add_config_value('html_search_language', None, 'html', [str])
     app.add_config_value('html_search_options', {}, 'html')
-    app.add_config_value('html_search_scorer', '', None)
+    app.add_config_value('html_search_scorer', '', '')
     app.add_config_value('html_scaled_image_link', True, 'html')
     app.add_config_value('html_baseurl', '', 'html')
     app.add_config_value('html_codeblock_linenos_style', 'inline', 'html',  # RemovedInSphinx70Warning  # noqa: E501
@@ -1404,8 +1357,6 @@ def setup(app: Sphinx) -> dict[str, Any]:
     app.connect('config-inited', validate_html_favicon, priority=800)
     app.connect('config-inited', error_on_html_4, priority=800)
     app.connect('builder-inited', validate_math_renderer)
-    app.connect('html-page-context', setup_css_tag_helper)
-    app.connect('html-page-context', setup_js_tag_helper)
     app.connect('html-page-context', setup_resource_paths)
 
     # load default math renderer
@@ -1419,3 +1370,22 @@ def setup(app: Sphinx) -> dict[str, Any]:
         'parallel_read_safe': True,
         'parallel_write_safe': True,
     }
+
+
+# deprecated name -> (object to return, canonical path or empty string)
+_DEPRECATED_OBJECTS = {
+    'Stylesheet': (_CascadingStyleSheet, 'sphinx.builders.html._assets._CascadingStyleSheet', (9, 0)),  # NoQA: E501
+    'JavaScript': (_JavaScript, 'sphinx.builders.html._assets._JavaScript', (9, 0)),
+}
+
+
+def __getattr__(name):
+    if name not in _DEPRECATED_OBJECTS:
+        msg = f'module {__name__!r} has no attribute {name!r}'
+        raise AttributeError(msg)
+
+    from sphinx.deprecation import _deprecation_warning
+
+    deprecated_object, canonical_name, remove = _DEPRECATED_OBJECTS[name]
+    _deprecation_warning(__name__, name, canonical_name, remove=remove)
+    return deprecated_object