added podman, json and yaml

venv/lib/python3.11/site-packages/mkdocs/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+
+# For acceptable version formats, see https://www.python.org/dev/peps/pep-0440/
+__version__ = '1.4.2'

venv/lib/python3.11/site-packages/mkdocs/__main__.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import sys
+import textwrap
+import traceback
+import warnings
+
+import click
+
+from mkdocs import __version__, config, utils
+
+if sys.platform.startswith("win"):
+    try:
+        import colorama
+    except ImportError:
+        pass
+    else:
+        colorama.init()
+
+log = logging.getLogger(__name__)
+
+
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    try:
+        # Last stack frames:
+        # * ...
+        # * Location of call to deprecated function   <-- include this
+        # * Location of call to warn()                <-- include this
+        # * (stdlib) Location of call to showwarning function
+        # * (this function) Location of call to extract_stack()
+        stack = [frame for frame in traceback.extract_stack() if frame.line][-4:-2]
+        # Make sure the actual affected file's name is still present (the case of syntax warning):
+        if not any(frame.filename == filename for frame in stack):
+            stack = stack[-1:] + [traceback.FrameSummary(filename, lineno, '')]
+
+        tb = ''.join(traceback.format_list(stack))
+    except Exception:
+        tb = f'  File "{filename}", line {lineno}'
+
+    log.info(f'{category.__name__}: {message}\n{tb}')
+
+
+def _enable_warnings():
+    warnings.simplefilter('module', DeprecationWarning)
+    warnings.showwarning = _showwarning
+
+
+class ColorFormatter(logging.Formatter):
+    colors = {
+        'CRITICAL': 'red',
+        'ERROR': 'red',
+        'WARNING': 'yellow',
+        'DEBUG': 'blue',
+    }
+
+    text_wrapper = textwrap.TextWrapper(
+        width=shutil.get_terminal_size(fallback=(0, 0)).columns,
+        replace_whitespace=False,
+        break_long_words=False,
+        break_on_hyphens=False,
+        initial_indent=' ' * 12,
+        subsequent_indent=' ' * 12,
+    )
+
+    def format(self, record):
+        message = super().format(record)
+        prefix = f'{record.levelname:<8} -  '
+        if record.levelname in self.colors:
+            prefix = click.style(prefix, fg=self.colors[record.levelname])
+        if self.text_wrapper.width:
+            # Only wrap text if a terminal width was detected
+            msg = '\n'.join(self.text_wrapper.fill(line) for line in message.splitlines())
+            # Prepend prefix after wrapping so that color codes don't affect length
+            return prefix + msg[12:]
+        return prefix + message
+
+
+class State:
+    """Maintain logging level."""
+
+    def __init__(self, log_name='mkdocs', level=logging.INFO):
+        self.logger = logging.getLogger(log_name)
+        # Don't restrict level on logger; use handler
+        self.logger.setLevel(1)
+        self.logger.propagate = False
+
+        self.stream = logging.StreamHandler()
+        self.stream.setFormatter(ColorFormatter())
+        self.stream.setLevel(level)
+        self.stream.name = 'MkDocsStreamHandler'
+        self.logger.addHandler(self.stream)
+
+    def __del__(self):
+        self.logger.removeHandler(self.stream)
+
+
+pass_state = click.make_pass_decorator(State, ensure=True)
+
+clean_help = "Remove old files from the site_dir before building (the default)."
+config_help = "Provide a specific MkDocs config"
+dev_addr_help = "IP address and port to serve documentation locally (default: localhost:8000)"
+strict_help = "Enable strict mode. This will cause MkDocs to abort the build on any warnings."
+theme_help = "The theme to use when building your documentation."
+theme_choices = sorted(utils.get_theme_names())
+site_dir_help = "The directory to output the result of the documentation build."
+use_directory_urls_help = "Use directory URLs when building pages (the default)."
+reload_help = "Enable the live reloading in the development server (this is the default)"
+no_reload_help = "Disable the live reloading in the development server."
+dirty_reload_help = (
+    "Enable the live reloading in the development server, but only re-build files that have changed"
+)
+commit_message_help = (
+    "A commit message to use when committing to the "
+    "GitHub Pages remote branch. Commit {sha} and MkDocs {version} are available as expansions"
+)
+remote_branch_help = (
+    "The remote branch to commit to for GitHub Pages. This "
+    "overrides the value specified in config"
+)
+remote_name_help = (
+    "The remote name to commit to for GitHub Pages. This overrides the value specified in config"
+)
+force_help = "Force the push to the repository."
+no_history_help = "Replace the whole Git history with one new commit."
+ignore_version_help = (
+    "Ignore check that build is not being deployed with an older version of MkDocs."
+)
+watch_theme_help = (
+    "Include the theme in list of files to watch for live reloading. "
+    "Ignored when live reload is not used."
+)
+shell_help = "Use the shell when invoking Git."
+watch_help = "A directory or file to watch for live reloading. Can be supplied multiple times."
+
+
+def add_options(*opts):
+    def inner(f):
+        for i in reversed(opts):
+            f = i(f)
+        return f
+
+    return inner
+
+
+def verbose_option(f):
+    def callback(ctx, param, value):
+        state = ctx.ensure_object(State)
+        if value:
+            state.stream.setLevel(logging.DEBUG)
+
+    return click.option(
+        '-v',
+        '--verbose',
+        is_flag=True,
+        expose_value=False,
+        help='Enable verbose output',
+        callback=callback,
+    )(f)
+
+
+def quiet_option(f):
+    def callback(ctx, param, value):
+        state = ctx.ensure_object(State)
+        if value:
+            state.stream.setLevel(logging.ERROR)
+
+    return click.option(
+        '-q',
+        '--quiet',
+        is_flag=True,
+        expose_value=False,
+        help='Silence warnings',
+        callback=callback,
+    )(f)
+
+
+common_options = add_options(quiet_option, verbose_option)
+common_config_options = add_options(
+    click.option('-f', '--config-file', type=click.File('rb'), help=config_help),
+    # Don't override config value if user did not specify --strict flag
+    # Conveniently, load_config drops None values
+    click.option('-s', '--strict', is_flag=True, default=None, help=strict_help),
+    click.option('-t', '--theme', type=click.Choice(theme_choices), help=theme_help),
+    # As with --strict, set the default to None so that this doesn't incorrectly
+    # override the config file
+    click.option(
+        '--use-directory-urls/--no-directory-urls',
+        is_flag=True,
+        default=None,
+        help=use_directory_urls_help,
+    ),
+)
+
+PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+PKG_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+@click.group(context_settings={'help_option_names': ['-h', '--help']})
+@click.version_option(
+    __version__,
+    '-V',
+    '--version',
+    message=f'%(prog)s, version %(version)s from { PKG_DIR } (Python { PYTHON_VERSION })',
+)
+@common_options
+def cli():
+    """
+    MkDocs - Project documentation with Markdown.
+    """
+
+
+@cli.command(name="serve")
+@click.option('-a', '--dev-addr', help=dev_addr_help, metavar='<IP:PORT>')
+@click.option('--livereload', 'livereload', flag_value='livereload', help=reload_help, default=True)
+@click.option('--no-livereload', 'livereload', flag_value='no-livereload', help=no_reload_help)
+@click.option('--dirtyreload', 'livereload', flag_value='dirty', help=dirty_reload_help)
+@click.option('--watch-theme', help=watch_theme_help, is_flag=True)
+@click.option(
+    '-w', '--watch', help=watch_help, type=click.Path(exists=True), multiple=True, default=[]
+)
+@common_config_options
+@common_options
+def serve_command(dev_addr, livereload, watch, **kwargs):
+    """Run the builtin development server"""
+    from mkdocs.commands import serve
+
+    _enable_warnings()
+    serve.serve(dev_addr=dev_addr, livereload=livereload, watch=watch, **kwargs)
+
+
+@cli.command(name="build")
+@click.option('-c', '--clean/--dirty', is_flag=True, default=True, help=clean_help)
+@common_config_options
+@click.option('-d', '--site-dir', type=click.Path(), help=site_dir_help)
+@common_options
+def build_command(clean, **kwargs):
+    """Build the MkDocs documentation"""
+    from mkdocs.commands import build
+
+    _enable_warnings()
+    cfg = config.load_config(**kwargs)
+    cfg['plugins'].run_event('startup', command='build', dirty=not clean)
+    try:
+        build.build(cfg, dirty=not clean)
+    finally:
+        cfg['plugins'].run_event('shutdown')
+
+
+@cli.command(name="gh-deploy")
+@click.option('-c', '--clean/--dirty', is_flag=True, default=True, help=clean_help)
+@click.option('-m', '--message', help=commit_message_help)
+@click.option('-b', '--remote-branch', help=remote_branch_help)
+@click.option('-r', '--remote-name', help=remote_name_help)
+@click.option('--force', is_flag=True, help=force_help)
+@click.option('--no-history', is_flag=True, help=no_history_help)
+@click.option('--ignore-version', is_flag=True, help=ignore_version_help)
+@click.option('--shell', is_flag=True, help=shell_help)
+@common_config_options
+@click.option('-d', '--site-dir', type=click.Path(), help=site_dir_help)
+@common_options
+def gh_deploy_command(
+    clean, message, remote_branch, remote_name, force, no_history, ignore_version, shell, **kwargs
+):
+    """Deploy your documentation to GitHub Pages"""
+    from mkdocs.commands import build, gh_deploy
+
+    _enable_warnings()
+    cfg = config.load_config(remote_branch=remote_branch, remote_name=remote_name, **kwargs)
+    cfg['plugins'].run_event('startup', command='gh-deploy', dirty=not clean)
+    try:
+        build.build(cfg, dirty=not clean)
+    finally:
+        cfg['plugins'].run_event('shutdown')
+    gh_deploy.gh_deploy(
+        cfg,
+        message=message,
+        force=force,
+        no_history=no_history,
+        ignore_version=ignore_version,
+        shell=shell,
+    )
+
+
+@cli.command(name="new")
+@click.argument("project_directory")
+@common_options
+def new_command(project_directory):
+    """Create a new MkDocs project"""
+    from mkdocs.commands import new
+
+    new.new(project_directory)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    cli()

venv/lib/python3.11/site-packages/mkdocs/commands/babel.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import sys
+import warnings
+from distutils.errors import DistutilsOptionError
+from os import path
+
+from babel.messages import frontend as babel
+from pkg_resources import EntryPoint
+
+warnings.warn(
+    "mkdocs.commands.babel is never used in MkDocs and will be removed soon.", DeprecationWarning
+)
+
+DEFAULT_MAPPING_FILE = path.normpath(
+    path.join(path.abspath(path.dirname(__file__)), '../themes/babel.cfg')
+)
+
+
+class ThemeMixin:
+    def get_theme_dir(self):
+        """Validate theme option and return path to theme's root obtained from entry point."""
+        entry_points = EntryPoint.parse_map(self.distribution.entry_points, self.distribution)
+        if 'mkdocs.themes' not in entry_points:
+            raise DistutilsOptionError("no mkdocs.themes are defined in entry_points")
+        if self.theme is None and len(entry_points['mkdocs.themes']) == 1:
+            # Default to the only theme defined in entry_points as none specified.
+            self.theme = tuple(entry_points['mkdocs.themes'].keys())[0]
+        if self.theme not in entry_points['mkdocs.themes']:
+            raise DistutilsOptionError("you must specify a valid theme name to work on")
+        theme = entry_points['mkdocs.themes'][self.theme]
+        return path.dirname(theme.resolve().__file__)
+
+
+class compile_catalog(babel.compile_catalog, ThemeMixin):
+    user_options = babel.compile_catalog.user_options + [
+        ("theme=", "t", "theme name to work on"),
+    ]
+
+    def run(self):
+        # Possible bug in Babel - produces unused return value:
+        # https://github.com/python-babel/babel/blob/v2.10.3/babel/messages/frontend.py#L194
+        if super().run():
+            sys.exit(1)
+
+    def initialize_options(self):
+        super().initialize_options()
+        self.theme = None
+
+    def finalize_options(self):
+        if not self.directory:
+            theme_dir = self.get_theme_dir()
+            self.directory = f"{theme_dir}/locales"
+        super().finalize_options()
+
+
+class extract_messages(babel.extract_messages, ThemeMixin):
+    user_options = babel.extract_messages.user_options + [
+        ("domain=", "d", "domains of the POT output file"),
+        ("theme=", "t", "theme name to work on"),
+    ]
+
+    def initialize_options(self):
+        super().initialize_options()
+        self.domain = "messages"
+        self.theme = None
+
+    def finalize_options(self):
+        if not self.version:
+            version = self.distribution.get_version()
+            self.version = ".".join(i for i in version.split(".") if "dev" not in i)
+        if not self.mapping_file:
+            self.mapping_file = DEFAULT_MAPPING_FILE
+        if not self.input_paths or not self.output_file:
+            theme_dir = self.get_theme_dir()
+            if not self.input_paths:
+                self.input_paths = theme_dir
+            if not self.output_file:
+                self.output_file = f"{theme_dir}/{self.domain}.pot"
+        super().finalize_options()
+
+
+class init_catalog(babel.init_catalog, ThemeMixin):
+    user_options = babel.init_catalog.user_options + [
+        ("theme=", "t", "theme name to work on"),
+    ]
+
+    def initialize_options(self):
+        super().initialize_options()
+        self.theme = None
+
+    def finalize_options(self):
+        if not self.input_file or not self.output_dir:
+            theme_dir = self.get_theme_dir()
+            if not self.input_file:
+                self.input_file = f"{theme_dir}/{self.domain}.pot"
+            if not self.output_dir:
+                self.output_dir = f"{theme_dir}/locales"
+        super().finalize_options()
+
+
+class update_catalog(babel.update_catalog, ThemeMixin):
+    user_options = babel.update_catalog.user_options + [
+        ("theme=", "t", "theme name to work on"),
+    ]
+
+    def initialize_options(self):
+        super().initialize_options()
+        self.theme = None
+
+    def finalize_options(self):
+        if not self.input_file or not self.output_dir:
+            theme_dir = self.get_theme_dir()
+            if not self.input_file:
+                self.input_file = f"{theme_dir}/{self.domain}.pot"
+            if not self.output_dir:
+                self.output_dir = f"{theme_dir}/locales"
+        super().finalize_options()

venv/lib/python3.11/site-packages/mkdocs/commands/build.py

@@ -0,0 +1,356 @@
+from __future__ import annotations
+
+import gzip
+import logging
+import os
+import time
+from typing import Any, Dict, Optional, Sequence, Set, Union
+from urllib.parse import urlsplit
+
+import jinja2
+from jinja2.exceptions import TemplateNotFound
+
+import mkdocs
+from mkdocs import utils
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.exceptions import Abort, BuildError
+from mkdocs.structure.files import File, Files, get_files
+from mkdocs.structure.nav import Navigation, get_navigation
+from mkdocs.structure.pages import Page
+
+
+class DuplicateFilter:
+    """Avoid logging duplicate messages."""
+
+    def __init__(self) -> None:
+        self.msgs: Set[str] = set()
+
+    def __call__(self, record: logging.LogRecord) -> bool:
+        rv = record.msg not in self.msgs
+        self.msgs.add(record.msg)
+        return rv
+
+
+log = logging.getLogger(__name__)
+log.addFilter(DuplicateFilter())
+
+
+def get_context(
+    nav: Navigation,
+    files: Union[Sequence[File], Files],
+    config: MkDocsConfig,
+    page: Optional[Page] = None,
+    base_url: str = '',
+) -> Dict[str, Any]:
+    """
+    Return the template context for a given page or template.
+    """
+    if page is not None:
+        base_url = utils.get_relative_url('.', page.url)
+
+    extra_javascript = utils.create_media_urls(config.extra_javascript, page, base_url)
+
+    extra_css = utils.create_media_urls(config.extra_css, page, base_url)
+
+    if isinstance(files, Files):
+        files = files.documentation_pages()
+
+    return {
+        'nav': nav,
+        'pages': files,
+        'base_url': base_url,
+        'extra_css': extra_css,
+        'extra_javascript': extra_javascript,
+        'mkdocs_version': mkdocs.__version__,
+        'build_date_utc': utils.get_build_datetime(),
+        'config': config,
+        'page': page,
+    }
+
+
+def _build_template(
+    name: str, template: jinja2.Template, files: Files, config: MkDocsConfig, nav: Navigation
+) -> str:
+    """
+    Return rendered output for given template as a string.
+    """
+    # Run `pre_template` plugin events.
+    template = config.plugins.run_event('pre_template', template, template_name=name, config=config)
+
+    if utils.is_error_template(name):
+        # Force absolute URLs in the nav of error pages and account for the
+        # possibility that the docs root might be different than the server root.
+        # See https://github.com/mkdocs/mkdocs/issues/77.
+        # However, if site_url is not set, assume the docs root and server root
+        # are the same. See https://github.com/mkdocs/mkdocs/issues/1598.
+        base_url = urlsplit(config.site_url or '/').path
+    else:
+        base_url = utils.get_relative_url('.', name)
+
+    context = get_context(nav, files, config, base_url=base_url)
+
+    # Run `template_context` plugin events.
+    context = config.plugins.run_event(
+        'template_context', context, template_name=name, config=config
+    )
+
+    output = template.render(context)
+
+    # Run `post_template` plugin events.
+    output = config.plugins.run_event('post_template', output, template_name=name, config=config)
+
+    return output
+
+
+def _build_theme_template(
+    template_name: str, env: jinja2.Environment, files: Files, config: MkDocsConfig, nav: Navigation
+) -> None:
+    """Build a template using the theme environment."""
+
+    log.debug(f"Building theme template: {template_name}")
+
+    try:
+        template = env.get_template(template_name)
+    except TemplateNotFound:
+        log.warning(f"Template skipped: '{template_name}' not found in theme directories.")
+        return
+
+    output = _build_template(template_name, template, files, config, nav)
+
+    if output.strip():
+        output_path = os.path.join(config.site_dir, template_name)
+        utils.write_file(output.encode('utf-8'), output_path)
+
+        if template_name == 'sitemap.xml':
+            log.debug(f"Gzipping template: {template_name}")
+            gz_filename = f'{output_path}.gz'
+            with open(gz_filename, 'wb') as f:
+                timestamp = utils.get_build_timestamp()
+                with gzip.GzipFile(
+                    fileobj=f, filename=gz_filename, mode='wb', mtime=timestamp
+                ) as gz_buf:
+                    gz_buf.write(output.encode('utf-8'))
+    else:
+        log.info(f"Template skipped: '{template_name}' generated empty output.")
+
+
+def _build_extra_template(template_name: str, files: Files, config: MkDocsConfig, nav: Navigation):
+    """Build user templates which are not part of the theme."""
+
+    log.debug(f"Building extra template: {template_name}")
+
+    file = files.get_file_from_path(template_name)
+    if file is None:
+        log.warning(f"Template skipped: '{template_name}' not found in docs_dir.")
+        return
+
+    try:
+        with open(file.abs_src_path, encoding='utf-8', errors='strict') as f:
+            template = jinja2.Template(f.read())
+    except Exception as e:
+        log.warning(f"Error reading template '{template_name}': {e}")
+        return
+
+    output = _build_template(template_name, template, files, config, nav)
+
+    if output.strip():
+        utils.write_file(output.encode('utf-8'), file.abs_dest_path)
+    else:
+        log.info(f"Template skipped: '{template_name}' generated empty output.")
+
+
+def _populate_page(page: Page, config: MkDocsConfig, files: Files, dirty: bool = False) -> None:
+    """Read page content from docs_dir and render Markdown."""
+
+    try:
+        # When --dirty is used, only read the page if the file has been modified since the
+        # previous build of the output.
+        if dirty and not page.file.is_modified():
+            return
+
+        # Run the `pre_page` plugin event
+        page = config.plugins.run_event('pre_page', page, config=config, files=files)
+
+        page.read_source(config)
+
+        # Run `page_markdown` plugin events.
+        page.markdown = config.plugins.run_event(
+            'page_markdown', page.markdown, page=page, config=config, files=files
+        )
+
+        page.render(config, files)
+
+        # Run `page_content` plugin events.
+        page.content = config.plugins.run_event(
+            'page_content', page.content, page=page, config=config, files=files
+        )
+    except Exception as e:
+        message = f"Error reading page '{page.file.src_uri}':"
+        # Prevent duplicated the error message because it will be printed immediately afterwards.
+        if not isinstance(e, BuildError):
+            message += f" {e}"
+        log.error(message)
+        raise
+
+
+def _build_page(
+    page: Page,
+    config: MkDocsConfig,
+    doc_files: Sequence[File],
+    nav: Navigation,
+    env: jinja2.Environment,
+    dirty: bool = False,
+) -> None:
+    """Pass a Page to theme template and write output to site_dir."""
+
+    try:
+        # When --dirty is used, only build the page if the file has been modified since the
+        # previous build of the output.
+        if dirty and not page.file.is_modified():
+            return
+
+        log.debug(f"Building page {page.file.src_uri}")
+
+        # Activate page. Signals to theme that this is the current page.
+        page.active = True
+
+        context = get_context(nav, doc_files, config, page)
+
+        # Allow 'template:' override in md source files.
+        if 'template' in page.meta:
+            template = env.get_template(page.meta['template'])
+        else:
+            template = env.get_template('main.html')
+
+        # Run `page_context` plugin events.
+        context = config.plugins.run_event(
+            'page_context', context, page=page, config=config, nav=nav
+        )
+
+        # Render the template.
+        output = template.render(context)
+
+        # Run `post_page` plugin events.
+        output = config.plugins.run_event('post_page', output, page=page, config=config)
+
+        # Write the output file.
+        if output.strip():
+            utils.write_file(
+                output.encode('utf-8', errors='xmlcharrefreplace'), page.file.abs_dest_path
+            )
+        else:
+            log.info(f"Page skipped: '{page.file.src_uri}'. Generated empty output.")
+
+        # Deactivate page
+        page.active = False
+    except Exception as e:
+        message = f"Error building page '{page.file.src_uri}':"
+        # Prevent duplicated the error message because it will be printed immediately afterwards.
+        if not isinstance(e, BuildError):
+            message += f" {e}"
+        log.error(message)
+        raise
+
+
+def build(config: MkDocsConfig, live_server: bool = False, dirty: bool = False) -> None:
+    """Perform a full site build."""
+
+    logger = logging.getLogger('mkdocs')
+
+    # Add CountHandler for strict mode
+    warning_counter = utils.CountHandler()
+    warning_counter.setLevel(logging.WARNING)
+    if config.strict:
+        logging.getLogger('mkdocs').addHandler(warning_counter)
+
+    try:
+        start = time.monotonic()
+
+        # Run `config` plugin events.
+        config = config.plugins.run_event('config', config)
+
+        # Run `pre_build` plugin events.
+        config.plugins.run_event('pre_build', config=config)
+
+        if not dirty:
+            log.info("Cleaning site directory")
+            utils.clean_directory(config.site_dir)
+        else:  # pragma: no cover
+            # Warn user about problems that may occur with --dirty option
+            log.warning(
+                "A 'dirty' build is being performed, this will likely lead to inaccurate navigation and other"
+                " links within your site. This option is designed for site development purposes only."
+            )
+
+        if not live_server:  # pragma: no cover
+            log.info(f"Building documentation to directory: {config.site_dir}")
+            if dirty and site_directory_contains_stale_files(config.site_dir):
+                log.info("The directory contains stale files. Use --clean to remove them.")
+
+        # First gather all data from all files/pages to ensure all data is consistent across all pages.
+
+        files = get_files(config)
+        env = config.theme.get_env()
+        files.add_files_from_theme(env, config)
+
+        # Run `files` plugin events.
+        files = config.plugins.run_event('files', files, config=config)
+
+        nav = get_navigation(files, config)
+
+        # Run `nav` plugin events.
+        nav = config.plugins.run_event('nav', nav, config=config, files=files)
+
+        log.debug("Reading markdown pages.")
+        for file in files.documentation_pages():
+            log.debug(f"Reading: {file.src_uri}")
+            assert file.page is not None
+            _populate_page(file.page, config, files, dirty)
+
+        # Run `env` plugin events.
+        env = config.plugins.run_event('env', env, config=config, files=files)
+
+        # Start writing files to site_dir now that all data is gathered. Note that order matters. Files
+        # with lower precedence get written first so that files with higher precedence can overwrite them.
+
+        log.debug("Copying static assets.")
+        files.copy_static_files(dirty=dirty)
+
+        for template in config.theme.static_templates:
+            _build_theme_template(template, env, files, config, nav)
+
+        for template in config.extra_templates:
+            _build_extra_template(template, files, config, nav)
+
+        log.debug("Building markdown pages.")
+        doc_files = files.documentation_pages()
+        for file in doc_files:
+            assert file.page is not None
+            _build_page(file.page, config, doc_files, nav, env, dirty)
+
+        # Run `post_build` plugin events.
+        config.plugins.run_event('post_build', config=config)
+
+        counts = warning_counter.get_counts()
+        if counts:
+            msg = ', '.join(f'{v} {k.lower()}s' for k, v in counts)
+            raise Abort(f'\nAborted with {msg} in strict mode!')
+
+        log.info('Documentation built in %.2f seconds', time.monotonic() - start)
+
+    except Exception as e:
+        # Run `build_error` plugin events.
+        config.plugins.run_event('build_error', error=e)
+        if isinstance(e, BuildError):
+            log.error(str(e))
+            raise Abort('\nAborted with a BuildError!')
+        raise
+
+    finally:
+        logger.removeHandler(warning_counter)
+
+
+def site_directory_contains_stale_files(site_directory: str) -> bool:
+    """Check if the site directory contains stale files from a previous build."""
+
+    return True if os.path.exists(site_directory) and os.listdir(site_directory) else False

venv/lib/python3.11/site-packages/mkdocs/commands/gh_deploy.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import logging
+import os
+import re
+import subprocess
+from typing import Optional, Tuple, Union
+
+import ghp_import
+from packaging import version
+
+import mkdocs
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.exceptions import Abort
+
+log = logging.getLogger(__name__)
+
+default_message = """Deployed {sha} with MkDocs version: {version}"""
+
+
+def _is_cwd_git_repo() -> bool:
+    try:
+        proc = subprocess.Popen(
+            ['git', 'rev-parse', '--is-inside-work-tree'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+    except FileNotFoundError:
+        log.error("Could not find git - is it installed and on your path?")
+        raise Abort('Deployment Aborted!')
+    proc.communicate()
+    return proc.wait() == 0
+
+
+def _get_current_sha(repo_path) -> str:
+    proc = subprocess.Popen(
+        ['git', 'rev-parse', '--short', 'HEAD'],
+        cwd=repo_path or None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    stdout, _ = proc.communicate()
+    sha = stdout.decode('utf-8').strip()
+    return sha
+
+
+def _get_remote_url(remote_name: str) -> Union[Tuple[str, str], Tuple[None, None]]:
+    # No CNAME found.  We will use the origin URL to determine the GitHub
+    # pages location.
+    remote = f"remote.{remote_name}.url"
+    proc = subprocess.Popen(
+        ["git", "config", "--get", remote],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    stdout, _ = proc.communicate()
+    url = stdout.decode('utf-8').strip()
+
+    if 'github.com/' in url:
+        host, path = url.split('github.com/', 1)
+    elif 'github.com:' in url:
+        host, path = url.split('github.com:', 1)
+    else:
+        return None, None
+    return host, path
+
+
+def _check_version(branch: str) -> None:
+    proc = subprocess.Popen(
+        ['git', 'show', '-s', '--format=%s', f'refs/heads/{branch}'],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    stdout, _ = proc.communicate()
+    msg = stdout.decode('utf-8').strip()
+    m = re.search(r'\d+(\.\d+)+((a|b|rc)\d+)?(\.post\d+)?(\.dev\d+)?', msg, re.X | re.I)
+    previousv = version.parse(m.group()) if m else None
+    currentv = version.parse(mkdocs.__version__)
+    if not previousv:
+        log.warning('Version check skipped: No version specified in previous deployment.')
+    elif currentv > previousv:
+        log.info(
+            f'Previous deployment was done with MkDocs version {previousv}; '
+            f'you are deploying with a newer version ({currentv})'
+        )
+    elif currentv < previousv:
+        log.error(
+            f'Deployment terminated: Previous deployment was made with MkDocs version {previousv}; '
+            f'you are attempting to deploy with an older version ({currentv}). Use --ignore-version '
+            'to deploy anyway.'
+        )
+        raise Abort('Deployment Aborted!')
+
+
+def gh_deploy(
+    config: MkDocsConfig,
+    message: Optional[str] = None,
+    force=False,
+    no_history=False,
+    ignore_version=False,
+    shell=False,
+) -> None:
+    if not _is_cwd_git_repo():
+        log.error('Cannot deploy - this directory does not appear to be a git repository')
+
+    remote_branch = config.remote_branch
+    remote_name = config.remote_name
+
+    if not ignore_version:
+        _check_version(remote_branch)
+
+    if message is None:
+        message = default_message
+    sha = _get_current_sha(os.path.dirname(config.config_file_path))
+    message = message.format(version=mkdocs.__version__, sha=sha)
+
+    log.info(
+        "Copying '%s' to '%s' branch and pushing to GitHub.",
+        config.site_dir,
+        config.remote_branch,
+    )
+
+    try:
+        ghp_import.ghp_import(
+            config.site_dir,
+            mesg=message,
+            remote=remote_name,
+            branch=remote_branch,
+            push=True,
+            force=force,
+            use_shell=shell,
+            no_history=no_history,
+            nojekyll=True,
+        )
+    except ghp_import.GhpError as e:
+        log.error(f"Failed to deploy to GitHub with error: \n{e.message}")
+        raise Abort('Deployment Aborted!')
+
+    cname_file = os.path.join(config.site_dir, 'CNAME')
+    # Does this repository have a CNAME set for GitHub pages?
+    if os.path.isfile(cname_file):
+        # This GitHub pages repository has a CNAME configured.
+        with open(cname_file) as f:
+            cname_host = f.read().strip()
+        log.info(
+            f'Based on your CNAME file, your documentation should be '
+            f'available shortly at: http://{cname_host}'
+        )
+        log.info(
+            'NOTE: Your DNS records must be configured appropriately for your CNAME URL to work.'
+        )
+        return
+
+    host, path = _get_remote_url(remote_name)
+
+    if host is None or path is None:
+        # This could be a GitHub Enterprise deployment.
+        log.info('Your documentation should be available shortly.')
+    else:
+        username, repo = path.split('/', 1)
+        if repo.endswith('.git'):
+            repo = repo[: -len('.git')]
+        url = f'https://{username}.github.io/{repo}/'
+        log.info(f"Your documentation should shortly be available at: {url}")

venv/lib/python3.11/site-packages/mkdocs/commands/new.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import logging
+import os
+
+config_text = 'site_name: My Docs\n'
+index_text = """# Welcome to MkDocs
+
+For full documentation visit [mkdocs.org](https://www.mkdocs.org).
+
+## Commands
+
+* `mkdocs new [dir-name]` - Create a new project.
+* `mkdocs serve` - Start the live-reloading docs server.
+* `mkdocs build` - Build the documentation site.
+* `mkdocs -h` - Print help message and exit.
+
+## Project layout
+
+    mkdocs.yml    # The configuration file.
+    docs/
+        index.md  # The documentation homepage.
+        ...       # Other markdown pages, images and other files.
+"""
+
+log = logging.getLogger(__name__)
+
+
+def new(output_dir: str) -> None:
+    docs_dir = os.path.join(output_dir, 'docs')
+    config_path = os.path.join(output_dir, 'mkdocs.yml')
+    index_path = os.path.join(docs_dir, 'index.md')
+
+    if os.path.exists(config_path):
+        log.info('Project already exists.')
+        return
+
+    if not os.path.exists(output_dir):
+        log.info(f'Creating project directory: {output_dir}')
+        os.mkdir(output_dir)
+
+    log.info(f'Writing config file: {config_path}')
+    with open(config_path, 'w', encoding='utf-8') as f:
+        f.write(config_text)
+
+    if os.path.exists(index_path):
+        return
+
+    log.info(f'Writing initial docs: {index_path}')
+    if not os.path.exists(docs_dir):
+        os.mkdir(docs_dir)
+    with open(index_path, 'w', encoding='utf-8') as f:
+        f.write(index_text)

venv/lib/python3.11/site-packages/mkdocs/commands/serve.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import functools
+import logging
+import shutil
+import tempfile
+from os.path import isdir, isfile, join
+from typing import Optional
+from urllib.parse import urlsplit
+
+import jinja2.exceptions
+
+from mkdocs.commands.build import build
+from mkdocs.config import load_config
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.exceptions import Abort
+from mkdocs.livereload import LiveReloadServer
+
+log = logging.getLogger(__name__)
+
+
+def serve(
+    config_file=None,
+    dev_addr=None,
+    strict=None,
+    theme=None,
+    theme_dir=None,
+    livereload='livereload',
+    watch_theme=False,
+    watch=[],
+    **kwargs,
+):
+    """
+    Start the MkDocs development server
+
+    By default it will serve the documentation on http://localhost:8000/ and
+    it will rebuild the documentation and refresh the page automatically
+    whenever a file is edited.
+    """
+    # Create a temporary build directory, and set some options to serve it
+    # PY2 returns a byte string by default. The Unicode prefix ensures a Unicode
+    # string is returned. And it makes MkDocs temp dirs easier to identify.
+    site_dir = tempfile.mkdtemp(prefix='mkdocs_')
+
+    def mount_path(config: MkDocsConfig):
+        return urlsplit(config.site_url or '/').path
+
+    get_config = functools.partial(
+        load_config,
+        config_file=config_file,
+        dev_addr=dev_addr,
+        strict=strict,
+        theme=theme,
+        theme_dir=theme_dir,
+        site_dir=site_dir,
+        **kwargs,
+    )
+
+    live_server = livereload in ('dirty', 'livereload')
+    dirty = livereload == 'dirty'
+
+    def builder(config: Optional[MkDocsConfig] = None):
+        log.info("Building documentation...")
+        if config is None:
+            config = get_config()
+
+        # combine CLI watch arguments with config file values
+        if config.watch is None:
+            config.watch = watch
+        else:
+            config.watch.extend(watch)
+
+        # Override a few config settings after validation
+        config.site_url = f'http://{config.dev_addr}{mount_path(config)}'
+
+        build(config, live_server=live_server, dirty=dirty)
+
+    config = get_config()
+    config['plugins'].run_event('startup', command='serve', dirty=dirty)
+
+    try:
+        # Perform the initial build
+        builder(config)
+
+        host, port = config.dev_addr
+        server = LiveReloadServer(
+            builder=builder, host=host, port=port, root=site_dir, mount_path=mount_path(config)
+        )
+
+        def error_handler(code) -> Optional[bytes]:
+            if code in (404, 500):
+                error_page = join(site_dir, f'{code}.html')
+                if isfile(error_page):
+                    with open(error_page, 'rb') as f:
+                        return f.read()
+            return None
+
+        server.error_handler = error_handler
+
+        if live_server:
+            # Watch the documentation files, the config file and the theme files.
+            server.watch(config.docs_dir)
+            server.watch(config.config_file_path)
+
+            if watch_theme:
+                for d in config.theme.dirs:
+                    server.watch(d)
+
+            # Run `serve` plugin events.
+            server = config.plugins.run_event('serve', server, config=config, builder=builder)
+
+            for item in config.watch:
+                server.watch(item)
+
+        try:
+            server.serve()
+        except KeyboardInterrupt:
+            log.info("Shutting down...")
+        finally:
+            server.shutdown()
+    except jinja2.exceptions.TemplateError:
+        # This is a subclass of OSError, but shouldn't be suppressed.
+        raise
+    except OSError as e:  # pragma: no cover
+        # Avoid ugly, unhelpful traceback
+        raise Abort(f'{type(e).__name__}: {e}')
+    finally:
+        config['plugins'].run_event('shutdown')
+        if isdir(site_dir):
+            shutil.rmtree(site_dir)

venv/lib/python3.11/site-packages/mkdocs/commands/setup.py

@@ -0,0 +1,22 @@
+import warnings
+
+warnings.warn(
+    "mkdocs.commands.setup is never used in MkDocs and will be removed soon.", DeprecationWarning
+)
+
+try:
+    from mkdocs.commands.babel import (
+        compile_catalog,
+        extract_messages,
+        init_catalog,
+        update_catalog,
+    )
+
+    babel_cmdclass = {
+        'compile_catalog': compile_catalog,
+        'extract_messages': extract_messages,
+        'init_catalog': init_catalog,
+        'update_catalog': update_catalog,
+    }
+except ImportError:
+    babel_cmdclass = {}

venv/lib/python3.11/site-packages/mkdocs/config/__init__.py

@@ -0,0 +1,3 @@
+from mkdocs.config.base import Config, load_config
+
+__all__ = ['load_config', 'Config']

venv/lib/python3.11/site-packages/mkdocs/config/base.py

@@ -0,0 +1,381 @@
+from __future__ import annotations
+
+import functools
+import logging
+import os
+import sys
+from collections import UserDict
+from contextlib import contextmanager
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Generic,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from yaml import YAMLError
+
+from mkdocs import exceptions, utils
+
+if TYPE_CHECKING:
+    from mkdocs.config.defaults import MkDocsConfig
+
+
+log = logging.getLogger('mkdocs.config')
+
+
+T = TypeVar('T')
+
+
+class BaseConfigOption(Generic[T]):
+    def __init__(self):
+        self.warnings: List[str] = []
+        self.default = None
+
+    @property
+    def default(self):
+        try:
+            # ensure no mutable values are assigned
+            return self._default.copy()
+        except AttributeError:
+            return self._default
+
+    @default.setter
+    def default(self, value):
+        self._default = value
+
+    def validate(self, value: object) -> T:
+        return self.run_validation(value)
+
+    def reset_warnings(self) -> None:
+        self.warnings = []
+
+    def pre_validation(self, config: Config, key_name: str) -> None:
+        """
+        Before all options are validated, perform a pre-validation process.
+
+        The pre-validation process method should be implemented by subclasses.
+        """
+
+    def run_validation(self, value: object):
+        """
+        Perform validation for a value.
+
+        The run_validation method should be implemented by subclasses.
+        """
+        return value
+
+    def post_validation(self, config: Config, key_name: str) -> None:
+        """
+        After all options have passed validation, perform a post-validation
+        process to do any additional changes dependent on other config values.
+
+        The post-validation process method should be implemented by subclasses.
+        """
+
+    def __set_name__(self, owner, name):
+        self._name = name
+
+    @overload
+    def __get__(self, obj: Config, type=None) -> T:
+        ...
+
+    @overload
+    def __get__(self, obj, type=None) -> BaseConfigOption:
+        ...
+
+    def __get__(self, obj, type=None):
+        if not isinstance(obj, Config):
+            return self
+        return obj[self._name]
+
+    def __set__(self, obj, value: T):
+        if not isinstance(obj, Config):
+            raise AttributeError(
+                f"can't set attribute ({self._name}) because the parent is a {type(obj)} not a {Config}"
+            )
+        obj[self._name] = value
+
+
+class ValidationError(Exception):
+    """Raised during the validation process of the config on errors."""
+
+    def __eq__(self, other):
+        return type(self) is type(other) and str(self) == str(other)
+
+
+PlainConfigSchemaItem = Tuple[str, BaseConfigOption]
+PlainConfigSchema = Sequence[PlainConfigSchemaItem]
+
+ConfigErrors = List[Tuple[str, Exception]]
+ConfigWarnings = List[Tuple[str, str]]
+
+
+class Config(UserDict):
+    """
+    Base class for MkDocs configuration, plugin configuration (and sub-configuration) objects.
+
+    It should be subclassed and have `ConfigOption`s defined as attributes.
+    For examples, see mkdocs/contrib/search/__init__.py and mkdocs/config/defaults.py.
+
+    Behavior as it was prior to MkDocs 1.4 is now handled by LegacyConfig.
+    """
+
+    _schema: PlainConfigSchema
+    config_file_path: Optional[str]
+
+    def __init_subclass__(cls):
+        schema = dict(getattr(cls, '_schema', ()))
+        for attr_name, attr in cls.__dict__.items():
+            if isinstance(attr, BaseConfigOption):
+                schema[attr_name] = attr
+        cls._schema = tuple(schema.items())
+
+        for attr_name, attr in cls._schema:
+            attr.required = True
+            if getattr(attr, '_legacy_required', None) is not None:
+                raise TypeError(
+                    f"{cls.__name__}.{attr_name}: "
+                    "Setting 'required' is unsupported in class-based configs. "
+                    "All values are required, or can be wrapped into config_options.Optional"
+                )
+
+    def __new__(cls, *args, **kwargs) -> Config:
+        """Compatibility: allow referring to `LegacyConfig(...)` constructor as `Config(...)`."""
+        if cls is Config:
+            return LegacyConfig(*args, **kwargs)
+        return super().__new__(cls)
+
+    def __init__(self, config_file_path: Optional[Union[str, bytes]] = None):
+        super().__init__()
+        self.user_configs: List[dict] = []
+        self.set_defaults()
+
+        self._schema_keys = {k for k, v in self._schema}
+        # Ensure config_file_path is a Unicode string
+        if config_file_path is not None and not isinstance(config_file_path, str):
+            try:
+                # Assume config_file_path is encoded with the file system encoding.
+                config_file_path = config_file_path.decode(encoding=sys.getfilesystemencoding())
+            except UnicodeDecodeError:
+                raise ValidationError("config_file_path is not a Unicode string.")
+        self.config_file_path = config_file_path
+
+    def set_defaults(self) -> None:
+        """
+        Set the base config by going through each validator and getting the
+        default if it has one.
+        """
+        for key, config_option in self._schema:
+            self[key] = config_option.default
+
+    def _validate(self) -> Tuple[ConfigErrors, ConfigWarnings]:
+        failed: ConfigErrors = []
+        warnings: ConfigWarnings = []
+
+        for key, config_option in self._schema:
+            try:
+                value = self.get(key)
+                self[key] = config_option.validate(value)
+                warnings.extend((key, w) for w in config_option.warnings)
+                config_option.reset_warnings()
+            except ValidationError as e:
+                failed.append((key, e))
+
+        for key in set(self.keys()) - self._schema_keys:
+            warnings.append((key, f"Unrecognised configuration name: {key}"))
+
+        return failed, warnings
+
+    def _pre_validate(self) -> Tuple[ConfigErrors, ConfigWarnings]:
+        failed: ConfigErrors = []
+        warnings: ConfigWarnings = []
+
+        for key, config_option in self._schema:
+            try:
+                config_option.pre_validation(self, key_name=key)
+                warnings.extend((key, w) for w in config_option.warnings)
+                config_option.reset_warnings()
+            except ValidationError as e:
+                failed.append((key, e))
+
+        return failed, warnings
+
+    def _post_validate(self) -> Tuple[ConfigErrors, ConfigWarnings]:
+        failed: ConfigErrors = []
+        warnings: ConfigWarnings = []
+
+        for key, config_option in self._schema:
+            try:
+                config_option.post_validation(self, key_name=key)
+                warnings.extend((key, w) for w in config_option.warnings)
+                config_option.reset_warnings()
+            except ValidationError as e:
+                failed.append((key, e))
+
+        return failed, warnings
+
+    def validate(self) -> Tuple[ConfigErrors, ConfigWarnings]:
+        failed, warnings = self._pre_validate()
+
+        run_failed, run_warnings = self._validate()
+
+        failed.extend(run_failed)
+        warnings.extend(run_warnings)
+
+        # Only run the post validation steps if there are no failures, warnings
+        # are okay.
+        if len(failed) == 0:
+            post_failed, post_warnings = self._post_validate()
+            failed.extend(post_failed)
+            warnings.extend(post_warnings)
+
+        return failed, warnings
+
+    def load_dict(self, patch: Optional[dict]) -> None:
+        """Load config options from a dictionary."""
+
+        if not isinstance(patch, dict):
+            raise exceptions.ConfigurationError(
+                "The configuration is invalid. The expected type was a key "
+                "value mapping (a python dict) but we got an object of type: "
+                f"{type(patch)}"
+            )
+
+        self.user_configs.append(patch)
+        self.update(patch)
+
+    def load_file(self, config_file: IO) -> None:
+        """Load config options from the open file descriptor of a YAML file."""
+        try:
+            return self.load_dict(utils.yaml_load(config_file))
+        except YAMLError as e:
+            # MkDocs knows and understands ConfigurationErrors
+            raise exceptions.ConfigurationError(
+                f"MkDocs encountered an error parsing the configuration file: {e}"
+            )
+
+
+@functools.lru_cache(maxsize=None)
+def get_schema(cls: type) -> PlainConfigSchema:
+    """
+    Extract ConfigOptions defined in a class (used just as a container) and put them into a schema tuple.
+    """
+    if issubclass(cls, Config):
+        return cls._schema
+    return tuple((k, v) for k, v in cls.__dict__.items() if isinstance(v, BaseConfigOption))
+
+
+class LegacyConfig(Config):
+    """
+    A configuration object for plugins, as just a dict without type-safe attribute access.
+    """
+
+    def __init__(self, schema: PlainConfigSchema, config_file_path: Optional[str] = None):
+        self._schema = tuple((k, v) for k, v in schema)  # Re-create just for validation
+        super().__init__(config_file_path)
+
+
+@contextmanager
+def _open_config_file(config_file: Optional[Union[str, IO]]) -> Iterator[IO]:
+    """
+    A context manager which yields an open file descriptor ready to be read.
+
+    Accepts a filename as a string, an open or closed file descriptor, or None.
+    When None, it defaults to `mkdocs.yml` in the CWD. If a closed file descriptor
+    is received, a new file descriptor is opened for the same file.
+
+    The file descriptor is automatically closed when the context manager block is existed.
+    """
+    # Default to the standard config filename.
+    if config_file is None:
+        paths_to_try = ['mkdocs.yml', 'mkdocs.yaml']
+    # If it is a string, we can assume it is a path and attempt to open it.
+    elif isinstance(config_file, str):
+        paths_to_try = [config_file]
+    # If closed file descriptor, get file path to reopen later.
+    elif getattr(config_file, 'closed', False):
+        paths_to_try = [config_file.name]
+    else:
+        result_config_file = config_file
+        paths_to_try = None
+
+    if paths_to_try:
+        # config_file is not a file descriptor, so open it as a path.
+        for path in paths_to_try:
+            path = os.path.abspath(path)
+            log.debug(f"Loading configuration file: {path}")
+            try:
+                result_config_file = open(path, 'rb')
+                break
+            except FileNotFoundError:
+                continue
+        else:
+            raise exceptions.ConfigurationError(f"Config file '{paths_to_try[0]}' does not exist.")
+    else:
+        log.debug(f"Loading configuration file: {result_config_file}")
+        # Ensure file descriptor is at beginning
+        result_config_file.seek(0)
+
+    try:
+        yield result_config_file
+    finally:
+        if hasattr(result_config_file, 'close'):
+            result_config_file.close()
+
+
+def load_config(config_file: Optional[Union[str, IO]] = None, **kwargs) -> MkDocsConfig:
+    """
+    Load the configuration for a given file object or name
+
+    The config_file can either be a file object, string or None. If it is None
+    the default `mkdocs.yml` filename will loaded.
+
+    Extra kwargs are passed to the configuration to replace any default values
+    unless they themselves are None.
+    """
+    options = kwargs.copy()
+
+    # Filter None values from the options. This usually happens with optional
+    # parameters from Click.
+    for key, value in options.copy().items():
+        if value is None:
+            options.pop(key)
+
+    with _open_config_file(config_file) as fd:
+        # Initialize the config with the default schema.
+        from mkdocs.config.defaults import MkDocsConfig
+
+        cfg = MkDocsConfig(config_file_path=getattr(fd, 'name', ''))
+        # load the config file
+        cfg.load_file(fd)
+
+    # Then load the options to overwrite anything in the config.
+    cfg.load_dict(options)
+
+    errors, warnings = cfg.validate()
+
+    for config_name, warning in warnings:
+        log.warning(f"Config value '{config_name}': {warning}")
+
+    for config_name, error in errors:
+        log.error(f"Config value '{config_name}': {error}")
+
+    for key, value in cfg.items():
+        log.debug(f"Config value '{key}' = {value!r}")
+
+    if len(errors) > 0:
+        raise exceptions.Abort(f"Aborted with {len(errors)} Configuration Errors!")
+    elif cfg['strict'] and len(warnings) > 0:
+        raise exceptions.Abort(
+            f"Aborted with {len(warnings)} Configuration Warnings in 'strict' mode!"
+        )
+
+    return cfg

venv/lib/python3.11/site-packages/mkdocs/config/defaults.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from mkdocs.config import base
+from mkdocs.config import config_options as c
+
+
+def get_schema() -> base.PlainConfigSchema:
+    return MkDocsConfig._schema
+
+
+# NOTE: The order here is important. During validation some config options
+# depend on others. So, if config option A depends on B, then A should be
+# listed higher in the schema.
+class MkDocsConfig(base.Config):
+    """The configuration of MkDocs itself (the root object of mkdocs.yml)."""
+
+    config_file_path: str = c.Optional(c.Type(str))  # type: ignore[assignment]
+    """Reserved for internal use, stores the mkdocs.yml config file."""
+
+    site_name = c.Type(str)
+    """The title to use for the documentation."""
+
+    nav = c.Optional(c.Nav())
+    """Defines the structure of the navigation."""
+    pages = c.Deprecated(removed=True, moved_to='nav')
+
+    site_url = c.Optional(c.URL(is_dir=True))
+    """The full URL to where the documentation will be hosted."""
+
+    site_description = c.Optional(c.Type(str))
+    """A description for the documentation project that will be added to the
+    HTML meta tags."""
+    site_author = c.Optional(c.Type(str))
+    """The name of the author to add to the HTML meta tags."""
+
+    theme = c.Theme(default='mkdocs')
+    """The MkDocs theme for the documentation."""
+
+    docs_dir = c.DocsDir(default='docs', exists=True)
+    """The directory containing the documentation markdown."""
+
+    site_dir = c.SiteDir(default='site')
+    """The directory where the site will be built to"""
+
+    copyright = c.Optional(c.Type(str))
+    """A copyright notice to add to the footer of documentation."""
+
+    google_analytics = c.Deprecated(
+        message=(
+            'The configuration option {} has been deprecated and '
+            'will be removed in a future release of MkDocs. See the '
+            'options available on your theme for an alternative.'
+        ),
+        option_type=c.Type(list, length=2),
+    )
+    """set of values for Google analytics containing the account IO and domain
+    this should look like, ['UA-27795084-5', 'mkdocs.org']"""
+
+    dev_addr = c.IpAddress(default='127.0.0.1:8000')
+    """The address on which to serve the live reloading docs server."""
+
+    use_directory_urls = c.Type(bool, default=True)
+    """If `True`, use `<page_name>/index.hmtl` style files with hyperlinks to
+    the directory.If `False`, use `<page_name>.html style file with
+    hyperlinks to the file.
+    True generates nicer URLs, but False is useful if browsing the output on
+    a filesystem."""
+
+    repo_url = c.Optional(c.URL())
+    """Specify a link to the project source repo to be included
+    in the documentation pages."""
+
+    repo_name = c.Optional(c.RepoName('repo_url'))
+    """A name to use for the link to the project source repo.
+    Default, If repo_url is unset then None, otherwise
+    "GitHub", "Bitbucket" or "GitLab" for known url or Hostname
+    for unknown urls."""
+
+    edit_uri_template = c.Optional(c.EditURITemplate('edit_uri'))
+    edit_uri = c.Optional(c.EditURI('repo_url'))
+    """Specify a URI to the docs dir in the project source repo, relative to the
+    repo_url. When set, a link directly to the page in the source repo will
+    be added to the generated HTML. If repo_url is not set also, this option
+    is ignored."""
+
+    extra_css = c.Type(list, default=[])
+    extra_javascript = c.Type(list, default=[])
+    """Specify which css or javascript files from the docs directory should be
+    additionally included in the site."""
+
+    extra_templates = c.Type(list, default=[])
+    """Similar to the above, but each template (HTML or XML) will be build with
+    Jinja2 and the global context."""
+
+    markdown_extensions = c.MarkdownExtensions(
+        builtins=['toc', 'tables', 'fenced_code'], configkey='mdx_configs'
+    )
+    """PyMarkdown extension names."""
+
+    mdx_configs = c.Private()
+    """PyMarkdown Extension Configs. For internal use only."""
+
+    strict = c.Type(bool, default=False)
+    """Enabling strict mode causes MkDocs to stop the build when a problem is
+    encountered rather than display an error."""
+
+    remote_branch = c.Type(str, default='gh-pages')
+    """The remote branch to commit to when using gh-deploy."""
+
+    remote_name = c.Type(str, default='origin')
+    """The remote name to push to when using gh-deploy."""
+
+    extra = c.SubConfig()
+    """extra is a mapping/dictionary of data that is passed to the template.
+    This allows template authors to require extra configuration that not
+    relevant to all themes and doesn't need to be explicitly supported by
+    MkDocs itself. A good example here would be including the current
+    project version."""
+
+    plugins = c.Plugins(theme_key='theme', default=['search'])
+    """A list of plugins. Each item may contain a string name or a key value pair.
+    A key value pair should be the string name (as the key) and a dict of config
+    options (as the value)."""
+
+    hooks = c.Hooks('plugins')
+    """A list of filenames that will be imported as Python modules and used as
+    an instance of a plugin each."""
+
+    watch = c.ListOfPaths(default=[])
+    """A list of extra paths to watch while running `mkdocs serve`."""

venv/lib/python3.11/site-packages/mkdocs/contrib/search/__init__.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, List
+
+from mkdocs import utils
+from mkdocs.config import base
+from mkdocs.config import config_options as c
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.contrib.search.search_index import SearchIndex
+from mkdocs.plugins import BasePlugin
+
+log = logging.getLogger(__name__)
+base_path = os.path.dirname(os.path.abspath(__file__))
+
+
+class LangOption(c.OptionallyRequired[List[str]]):
+    """Validate Language(s) provided in config are known languages."""
+
+    def get_lunr_supported_lang(self, lang):
+        fallback = {'uk': 'ru'}
+        for lang_part in lang.split("_"):
+            lang_part = lang_part.lower()
+            lang_part = fallback.get(lang_part, lang_part)
+            if os.path.isfile(os.path.join(base_path, 'lunr-language', f'lunr.{lang_part}.js')):
+                return lang_part
+
+    def run_validation(self, value: object):
+        if isinstance(value, str):
+            value = [value]
+        if not isinstance(value, list):
+            raise c.ValidationError('Expected a list of language codes.')
+        for lang in list(value):
+            if lang != 'en':
+                lang_detected = self.get_lunr_supported_lang(lang)
+                if not lang_detected:
+                    log.info(f"Option search.lang '{lang}' is not supported, falling back to 'en'")
+                    value.remove(lang)
+                    if 'en' not in value:
+                        value.append('en')
+                elif lang_detected != lang:
+                    value.remove(lang)
+                    value.append(lang_detected)
+                    log.info(f"Option search.lang '{lang}' switched to '{lang_detected}'")
+        return value
+
+
+class _PluginConfig(base.Config):
+    lang = c.Optional(LangOption())
+    separator = c.Type(str, default=r'[\s\-]+')
+    min_search_length = c.Type(int, default=3)
+    prebuild_index = c.Choice((False, True, 'node', 'python'), default=False)
+    indexing = c.Choice(('full', 'sections', 'titles'), default='full')
+
+
+class SearchPlugin(BasePlugin[_PluginConfig]):
+    """Add a search feature to MkDocs."""
+
+    def on_config(self, config: MkDocsConfig, **kwargs) -> MkDocsConfig:
+        "Add plugin templates and scripts to config."
+        if 'include_search_page' in config.theme and config.theme['include_search_page']:
+            config.theme.static_templates.add('search.html')
+        if not ('search_index_only' in config.theme and config.theme['search_index_only']):
+            path = os.path.join(base_path, 'templates')
+            config.theme.dirs.append(path)
+            if 'search/main.js' not in config.extra_javascript:
+                config.extra_javascript.append('search/main.js')
+        if self.config.lang is None:
+            # lang setting undefined. Set default based on theme locale
+            validate = _PluginConfig.lang.run_validation
+            self.config.lang = validate(config.theme['locale'].language)
+        # The `python` method of `prebuild_index` is pending deprecation as of version 1.2.
+        # TODO: Raise a deprecation warning in a future release (1.3?).
+        if self.config.prebuild_index == 'python':
+            log.info(
+                "The 'python' method of the search plugin's 'prebuild_index' config option "
+                "is pending deprecation and will not be supported in a future release."
+            )
+        return config
+
+    def on_pre_build(self, config: MkDocsConfig, **kwargs) -> None:
+        "Create search index instance for later use."
+        self.search_index = SearchIndex(**self.config)
+
+    def on_page_context(self, context: Dict[str, Any], **kwargs) -> None:
+        "Add page to search index."
+        self.search_index.add_entry_from_context(context['page'])
+
+    def on_post_build(self, config: MkDocsConfig, **kwargs) -> None:
+        "Build search index."
+        output_base_path = os.path.join(config.site_dir, 'search')
+        search_index = self.search_index.generate_search_index()
+        json_output_path = os.path.join(output_base_path, 'search_index.json')
+        utils.write_file(search_index.encode('utf-8'), json_output_path)
+
+        assert self.config.lang is not None
+        if not ('search_index_only' in config.theme and config.theme['search_index_only']):
+            # Include language support files in output. Copy them directly
+            # so that only the needed files are included.
+            files = []
+            if len(self.config.lang) > 1 or 'en' not in self.config.lang:
+                files.append('lunr.stemmer.support.js')
+            if len(self.config.lang) > 1:
+                files.append('lunr.multi.js')
+            if 'ja' in self.config.lang or 'jp' in self.config.lang:
+                files.append('tinyseg.js')
+            for lang in self.config.lang:
+                if lang != 'en':
+                    files.append(f'lunr.{lang}.js')
+
+            for filename in files:
+                from_path = os.path.join(base_path, 'lunr-language', filename)
+                to_path = os.path.join(output_base_path, filename)
+                utils.copy_file(from_path, to_path)

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.ar.js

@@ -0,0 +1,381 @@
+/*!
+ * Lunr languages, `Arabic` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2018, Dalia Al-Shahrabi
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Kazem Taghva, Rania Elkhoury, and Jeffrey Coombs (2005)
+ * Meryeme Hadni, Abdelmonaime Lachkar, and S. Alaoui Ouatik (2012)
+ *
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.ar = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.ar.trimmer,
+        lunr.ar.stopWordFilter,
+        lunr.ar.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.ar.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.ar.wordCharacters = "\u0621-\u065b\u0671\u0640";
+    lunr.ar.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.ar.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.ar.trimmer, 'trimmer-ar');
+
+    /* lunr stemmer function */
+    lunr.ar.stemmer = (function() {
+      var self = this;
+      var word = '';
+      self.result = false;
+      self.preRemoved = false;
+      self.sufRemoved = false;
+
+      //prefix data
+      self.pre = {
+        pre1: 'ف ك ب و س ل ن ا ي ت',
+        pre2: 'ال لل',
+        pre3: 'بال وال فال تال كال ولل',
+        pre4: 'فبال كبال وبال وكال'
+      };
+
+      //suffix data
+      self.suf = {
+        suf1: 'ه ك ت ن ا ي',
+        suf2: 'نك نه ها وك يا اه ون ين تن تم نا وا ان كم كن ني نن ما هم هن تك ته ات يه',
+        suf3: 'تين كهم نيه نهم ونه وها يهم ونا ونك وني وهم تكم تنا تها تني تهم كما كها ناه نكم هنا تان يها',
+        suf4: 'كموه ناها ونني ونهم تكما تموه تكاه كماه ناكم ناهم نيها وننا'
+      }
+
+      //arabic language patterns and alternative mapping for patterns
+      self.patterns = JSON.parse('{"pt43":[{"pt":[{"c":"ا","l":1}]},{"pt":[{"c":"ا,ت,ن,ي","l":0}],"mPt":[{"c":"ف","l":0,"m":1},{"c":"ع","l":1,"m":2},{"c":"ل","l":2,"m":3}]},{"pt":[{"c":"و","l":2}],"mPt":[{"c":"ف","l":0,"m":0},{"c":"ع","l":1,"m":1},{"c":"ل","l":2,"m":3}]},{"pt":[{"c":"ا","l":2}]},{"pt":[{"c":"ي","l":2}],"mPt":[{"c":"ف","l":0,"m":0},{"c":"ع","l":1,"m":1},{"c":"ا","l":2},{"c":"ل","l":3,"m":3}]},{"pt":[{"c":"م","l":0}]}],"pt53":[{"pt":[{"c":"ت","l":0},{"c":"ا","l":2}]},{"pt":[{"c":"ا,ن,ت,ي","l":0},{"c":"ت","l":2}],"mPt":[{"c":"ا","l":0},{"c":"ف","l":1,"m":1},{"c":"ت","l":2},{"c":"ع","l":3,"m":3},{"c":"ا","l":4},{"c":"ل","l":5,"m":4}]},{"pt":[{"c":"ا","l":0},{"c":"ا","l":2}],"mPt":[{"c":"ا","l":0},{"c":"ف","l":1,"m":1},{"c":"ع","l":2,"m":3},{"c":"ل","l":3,"m":4},{"c":"ا","l":4},{"c":"ل","l":5,"m":4}]},{"pt":[{"c":"ا","l":0},{"c":"ا","l":3}],"mPt":[{"c":"ف","l":0,"m":1},{"c":"ع","l":1,"m":2},{"c":"ل","l":2,"m":4}]},{"pt":[{"c":"ا","l":3},{"c":"ن","l":4}]},{"pt":[{"c":"ت","l":0},{"c":"ي","l":3}]},{"pt":[{"c":"م","l":0},{"c":"و","l":3}]},{"pt":[{"c":"ا","l":1},{"c":"و","l":3}]},{"pt":[{"c":"و","l":1},{"c":"ا","l":2}]},{"pt":[{"c":"م","l":0},{"c":"ا","l":3}]},{"pt":[{"c":"م","l":0},{"c":"ي","l":3}]},{"pt":[{"c":"ا","l":2},{"c":"ن","l":3}]},{"pt":[{"c":"م","l":0},{"c":"ن","l":1}],"mPt":[{"c":"ا","l":0},{"c":"ن","l":1},{"c":"ف","l":2,"m":2},{"c":"ع","l":3,"m":3},{"c":"ا","l":4},{"c":"ل","l":5,"m":4}]},{"pt":[{"c":"م","l":0},{"c":"ت","l":2}],"mPt":[{"c":"ا","l":0},{"c":"ف","l":1,"m":1},{"c":"ت","l":2},{"c":"ع","l":3,"m":3},{"c":"ا","l":4},{"c":"ل","l":5,"m":4}]},{"pt":[{"c":"م","l":0},{"c":"ا","l":2}]},{"pt":[{"c":"م","l":1},{"c":"ا","l":3}]},{"pt":[{"c":"ي,ت,ا,ن","l":0},{"c":"ت","l":1}],"mPt":[{"c":"ف","l":0,"m":2},{"c":"ع","l":1,"m":3},{"c":"ا","l":2},{"c":"ل","l":3,"m":4}]},{"pt":[{"c":"ت,ي,ا,ن","l":0},{"c":"ت","l":2}],"mPt":[{"c":"ا","l":0},{"c":"ف","l":1,"m":1},{"c":"ت","l":2},{"c":"ع","l":3,"m":3},{"c":"ا","l":4},{"c":"ل","l":5,"m":4}]},{"pt":[{"c":"ا","l":2},{"c":"ي","l":3}]},{"pt":[{"c":"ا,ي,ت,ن","l":0},{"c":"ن","l":1}],"mPt":[{"c":"ا","l":0},{"c":"ن","l":1},{"c":"ف","l":2,"m":2},{"c":"ع","l":3,"m":3},{"c":"ا","l":4},{"c":"ل","l":5,"m":4}]},{"pt":[{"c":"ا","l":3},{"c":"ء","l":4}]}],"pt63":[{"pt":[{"c":"ا","l":0},{"c":"ت","l":2},{"c":"ا","l":4}]},{"pt":[{"c":"ا,ت,ن,ي","l":0},{"c":"س","l":1},{"c":"ت","l":2}],"mPt":[{"c":"ا","l":0},{"c":"س","l":1},{"c":"ت","l":2},{"c":"ف","l":3,"m":3},{"c":"ع","l":4,"m":4},{"c":"ا","l":5},{"c":"ل","l":6,"m":5}]},{"pt":[{"c":"ا,ن,ت,ي","l":0},{"c":"و","l":3}]},{"pt":[{"c":"م","l":0},{"c":"س","l":1},{"c":"ت","l":2}],"mPt":[{"c":"ا","l":0},{"c":"س","l":1},{"c":"ت","l":2},{"c":"ف","l":3,"m":3},{"c":"ع","l":4,"m":4},{"c":"ا","l":5},{"c":"ل","l":6,"m":5}]},{"pt":[{"c":"ي","l":1},{"c":"ي","l":3},{"c":"ا","l":4},{"c":"ء","l":5}]},{"pt":[{"c":"ا","l":0},{"c":"ن","l":1},{"c":"ا","l":4}]}],"pt54":[{"pt":[{"c":"ت","l":0}]},{"pt":[{"c":"ا,ي,ت,ن","l":0}],"mPt":[{"c":"ا","l":0},{"c":"ف","l":1,"m":1},{"c":"ع","l":2,"m":2},{"c":"ل","l":3,"m":3},{"c":"ر","l":4,"m":4},{"c":"ا","l":5},{"c":"ر","l":6,"m":4}]},{"pt":[{"c":"م","l":0}],"mPt":[{"c":"ا","l":0},{"c":"ف","l":1,"m":1},{"c":"ع","l":2,"m":2},{"c":"ل","l":3,"m":3},{"c":"ر","l":4,"m":4},{"c":"ا","l":5},{"c":"ر","l":6,"m":4}]},{"pt":[{"c":"ا","l":2}]},{"pt":[{"c":"ا","l":0},{"c":"ن","l":2}]}],"pt64":[{"pt":[{"c":"ا","l":0},{"c":"ا","l":4}]},{"pt":[{"c":"م","l":0},{"c":"ت","l":1}]}],"pt73":[{"pt":[{"c":"ا","l":0},{"c":"س","l":1},{"c":"ت","l":2},{"c":"ا","l":5}]}],"pt75":[{"pt":[{"c":"ا","l":0},{"c":"ا","l":5}]}]}');
+
+      self.execArray = [
+        'cleanWord',
+        'removeDiacritics',
+        'cleanAlef',
+        'removeStopWords',
+        'normalizeHamzaAndAlef',
+        'removeStartWaw',
+        'removePre432',
+        'removeEndTaa',
+        'wordCheck'
+      ];
+
+      self.stem = function() {
+        var counter = 0;
+        self.result = false;
+        self.preRemoved = false;
+        self.sufRemoved = false;
+        while (counter < self.execArray.length && self.result != true) {
+          self.result = self[self.execArray[counter]]();
+          counter++;
+        }
+      }
+
+      self.setCurrent = function(word) {
+        self.word = word;
+      }
+
+      self.getCurrent = function() {
+        return self.word
+      }
+
+      /*remove elongating character and test that the word does not contain non-arabic characters.
+      If the word contains special characters, don't stem. */
+      self.cleanWord = function() {
+        var wordCharacters = "\u0621-\u065b\u0671\u0640";
+        var testRegex = new RegExp("[^" + wordCharacters + "]");
+        self.word = self.word
+          .replace('\u0640', '');
+        if (testRegex.test(word)) {
+          return true;
+        }
+        return false;
+      }
+
+      self.removeDiacritics = function() {
+        var diacriticsRegex = new RegExp("[\u064b-\u065b]");
+        self.word = self.word.replace(/[\u064b-\u065b]/gi, '');
+        return false;
+      }
+
+      /*Replace all variations of alef (آأإٱى) to a plain alef (ا)*/
+      self.cleanAlef = function() {
+        var alefRegex = new RegExp("[\u0622\u0623\u0625\u0671\u0649]");
+        self.word = self.word.replace(alefRegex, "\u0627");
+        return false;
+      }
+
+      /* if the word is a stop word, don't stem*/
+      self.removeStopWords = function() {
+        var stopWords = '، اض امين اه اها اي ا اب اجل اجمع اخ اخذ اصبح اضحى اقبل اقل اكثر الا ام اما امامك امامك امسى اما ان انا انت انتم انتما انتن انت انشا انى او اوشك اولئك اولئكم اولاء اولالك اوه اي ايا اين اينما اي ان اي اف اذ اذا اذا اذما اذن الى اليكم اليكما اليكن اليك اليك الا اما ان انما اي اياك اياكم اياكما اياكن ايانا اياه اياها اياهم اياهما اياهن اياي ايه ان ا ابتدا اثر اجل احد اخرى اخلولق اذا اربعة ارتد استحال اطار اعادة اعلنت اف اكثر اكد الالاء الالى الا الاخيرة الان الاول الاولى التى التي الثاني الثانية الذاتي الذى الذي الذين السابق الف اللائي اللاتي اللتان اللتيا اللتين اللذان اللذين اللواتي الماضي المقبل الوقت الى اليوم اما امام امس ان انبرى انقلب انه انها او اول اي ايار ايام ايضا ب بات باسم بان بخ برس بسبب بس بشكل بضع بطان بعد بعض بك بكم بكما بكن بل بلى بما بماذا بمن بن بنا به بها بي بيد بين بس بله بئس تان تانك تبدل تجاه تحول تلقاء تلك تلكم تلكما تم تينك تين ته تي ثلاثة ثم ثم ثمة ثم جعل جلل جميع جير حار حاشا حاليا حاي حتى حرى حسب حم حوالى حول حيث حيثما حين حي حبذا حتى حذار خلا خلال دون دونك ذا ذات ذاك ذانك ذان ذلك ذلكم ذلكما ذلكن ذو ذوا ذواتا ذواتي ذيت ذينك ذين ذه ذي راح رجع رويدك ريث رب زيارة سبحان سرعان سنة سنوات سوف سوى ساء ساءما شبه شخصا شرع شتان صار صباح صفر صه صه ضد ضمن طاق طالما طفق طق ظل عاد عام عاما عامة عدا عدة عدد عدم عسى عشر عشرة علق على عليك عليه عليها عل عن عند عندما عوض عين عدس عما غدا غير  ف فان فلان فو فى في فيم فيما فيه فيها قال قام قبل قد قط قلما قوة كانما كاين كاي كاين كاد كان كانت كذا كذلك كرب كل كلا كلاهما كلتا كلم كليكما كليهما كلما كلا كم كما كي كيت كيف كيفما كان كخ لئن لا لات لاسيما لدن لدى لعمر لقاء لك لكم لكما لكن لكنما لكي لكيلا للامم لم لما لما لن لنا له لها لو لوكالة لولا لوما لي لست لست لستم لستما لستن لست لسن لعل لكن ليت ليس ليسا ليستا ليست ليسوا لسنا ما ماانفك مابرح مادام ماذا مازال مافتئ مايو متى مثل مذ مساء مع معاذ مقابل مكانكم مكانكما مكانكن مكانك مليار مليون مما ممن من منذ منها مه مهما من من نحن نحو نعم نفس نفسه نهاية نخ نعما نعم ها هاؤم هاك هاهنا هب هذا هذه هكذا هل هلم هلا هم هما هن هنا هناك هنالك هو هي هيا هيت هيا هؤلاء هاتان هاتين هاته هاتي هج هذا هذان هذين هذه هذي هيهات و وا واحد واضاف واضافت واكد وان واها واوضح وراءك وفي وقال وقالت وقد وقف وكان وكانت ولا ولم ومن وهو وهي ويكان وي وشكان يكون يمكن يوم ايان'.split(' ');
+        if (stopWords.indexOf(self.word) >= 0) {
+          return true;
+        }
+      }
+
+      /* changes ؤ ئ to ء and removes alef if at the end of the word*/
+      self.normalizeHamzaAndAlef = function() {
+        self.word = self.word.replace('\u0624', '\u0621');
+        self.word = self.word.replace('\u0626', '\u0621');
+        self.word = self.word.replace(/([\u0627])\1+/gi, '\u0627');
+        return false;
+      }
+
+      /*remove end taa marboota ة*/
+      self.removeEndTaa = function() {
+        if (self.word.length > 2) {
+          self.word = self.word.replace(/[\u0627]$/, '');
+          self.word = self.word.replace('\u0629', '');
+          return false;
+        } else return true;
+      }
+
+      /* if the word starts with double waw وو keep only one of them */
+      self.removeStartWaw = function() {
+        if (self.word.length > 3 && self.word[0] == '\u0648' && self.word[1] == '\u0648') {
+          self.word = self.word.slice(1);
+        }
+        return false;
+      }
+
+      /* remove prefixes of size 4, 3 and 2 characters  */
+      self.removePre432 = function() {
+        var word = self.word;
+        if (self.word.length >= 7) {
+          var pre4Regex = new RegExp('^(' + self.pre.pre4.split(' ').join('|') + ')')
+          self.word = self.word.replace(pre4Regex, '');
+        }
+        if (self.word == word && self.word.length >= 6) {
+          var pre3Regex = new RegExp('^(' + self.pre.pre3.split(' ').join('|') + ')')
+          self.word = self.word.replace(pre3Regex, '');
+        }
+        if (self.word == word && self.word.length >= 5) {
+          var pre2Regex = new RegExp('^(' + self.pre.pre2.split(' ').join('|') + ')')
+          self.word = self.word.replace(pre2Regex, '');
+        }
+        if (word != self.word) self.preRemoved = true;
+        return false;
+      }
+
+      /* check the word against word patterns. If the word matches a pattern, map it to the 
+      alternative pattern if available then stop stemming. */
+      self.patternCheck = function(pattern) {
+        var patternMatch = false;
+        for (var i = 0; i < pattern.length; i++) {
+          var currentPatternCheck = true;
+          for (var j = 0; j < pattern[i].pt.length; j++) {
+            var chars = pattern[i].pt[j].c.split(',');
+            var charMatch = false;
+            chars.forEach(function(el) {
+              if (self.word[pattern[i].pt[j].l] == el) {
+                charMatch = true;
+              }
+            })
+            if (!charMatch) {
+              currentPatternCheck = false;
+              break;
+            }
+          }
+          if (currentPatternCheck == true) {
+            if (pattern[i].mPt) {
+              var newWord = [];
+              for (var k = 0; k < pattern[i].mPt.length; k++) {
+                if (pattern[i].mPt[k].m != null) {
+                  newWord[pattern[i].mPt[k].l] = self.word[pattern[i].mPt[k].m]
+                } else {
+                  newWord[pattern[i].mPt[k].l] = pattern[i].mPt[k].c
+                }
+              }
+              self.word = newWord.join('');
+            }
+            self.result = true;
+            break;
+          }
+        }
+      }
+
+      /* remove prefixes of size 1 char*/
+      self.removePre1 = function() {
+        var word = self.word;
+        if (self.preRemoved == false)
+          if (self.word.length > 3) {
+            var pre1Regex = new RegExp('^(' + self.pre.pre1.split(' ').join('|') + ')')
+            self.word = self.word.replace(pre1Regex, '');
+          }
+        if (word != self.word) self.preRemoved = true;
+        return false;
+      }
+
+      /*remove suffixes of size 1 char */
+      self.removeSuf1 = function() {
+        var word = self.word;
+        if (self.sufRemoved == false)
+          if (self.word.length > 3) {
+            var suf1Regex = new RegExp('(' + self.suf.suf1.split(' ').join('|') + ')$')
+            self.word = self.word.replace(suf1Regex, '');
+          }
+        if (word != self.word) self.sufRemoved = true;
+        return false;
+      }
+
+      /*remove suffixes of size 4, 3 and 2 chars*/
+      self.removeSuf432 = function() {
+        var word = self.word;
+        if (self.word.length >= 6) {
+          var suf4Regex = new RegExp('(' + self.suf.suf4.split(' ').join('|') + ')$')
+          self.word = self.word.replace(suf4Regex, '');
+        }
+        if (self.word == word && self.word.length >= 5) {
+          var suf3Regex = new RegExp('(' + self.suf.suf3.split(' ').join('|') + ')$')
+          self.word = self.word.replace(suf3Regex, '');
+        }
+        if (self.word == word && self.word.length >= 4) {
+          var suf2Regex = new RegExp('(' + self.suf.suf2.split(' ').join('|') + ')$')
+          self.word = self.word.replace(suf2Regex, '');
+        }
+        if (word != self.word) self.sufRemoved = true;
+        return false;
+      }
+
+      /*check the word length and decide what is the next step accordingly*/
+      self.wordCheck = function() {
+        var word = self.word;
+        var word7Exec = [self.removeSuf432, self.removeSuf1, self.removePre1]
+        var counter = 0;
+        var patternChecked = false;
+        while (self.word.length >= 7 && !self.result && counter < word7Exec.length) {
+          if (self.word.length == 7 && !patternChecked) {
+            self.checkPattern73();
+            patternChecked = true;
+          } else {
+            word7Exec[counter]();
+            counter++;
+            patternChecked = false;
+          }
+        }
+
+        var word6Exec = [self.checkPattern63, self.removeSuf432, self.removeSuf1, self.removePre1, self.checkPattern64];
+        counter = 0;
+        while (self.word.length == 6 && !self.result && counter < word6Exec.length) {
+          word6Exec[counter]();
+          counter++;
+        }
+
+        var word5Exec = [self.checkPattern53, self.removeSuf432, self.removeSuf1, self.removePre1, self.checkPattern54];
+        counter = 0;
+        while (self.word.length == 5 && !self.result && counter < word5Exec.length) {
+          word5Exec[counter]();
+          counter++;
+        }
+
+        var word4Exec = [self.checkPattern43, self.removeSuf1, self.removePre1, self.removeSuf432];
+        counter = 0;
+        while (self.word.length == 4 && !self.result && counter < word4Exec.length) {
+          word4Exec[counter]();
+          counter++;
+        }
+        return true;
+      }
+
+      self.checkPattern43 = function() {
+        self.patternCheck(self.patterns.pt43)
+      }
+      self.checkPattern53 = function() {
+        self.patternCheck(self.patterns.pt53)
+      }
+      self.checkPattern54 = function() {
+        self.patternCheck(self.patterns.pt54)
+      }
+      self.checkPattern63 = function() {
+        self.patternCheck(self.patterns.pt63)
+      }
+      self.checkPattern64 = function() {
+        self.patternCheck(self.patterns.pt64)
+      }
+      self.checkPattern73 = function() {
+        self.patternCheck(self.patterns.pt73)
+      }
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            self.setCurrent(word);
+            self.stem();
+            return self.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          self.setCurrent(token);
+          self.stem();
+          return self.getCurrent();
+        }
+
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.ar.stemmer, 'stemmer-ar');
+
+    lunr.ar.stopWordFilter = lunr.generateStopWordFilter('، اض امين اه اها اي ا اب اجل اجمع اخ اخذ اصبح اضحى اقبل اقل اكثر الا ام اما امامك امامك امسى اما ان انا انت انتم انتما انتن انت انشا انى او اوشك اولئك اولئكم اولاء اولالك اوه اي ايا اين اينما اي ان اي اف اذ اذا اذا اذما اذن الى اليكم اليكما اليكن اليك اليك الا اما ان انما اي اياك اياكم اياكما اياكن ايانا اياه اياها اياهم اياهما اياهن اياي ايه ان ا ابتدا اثر اجل احد اخرى اخلولق اذا اربعة ارتد استحال اطار اعادة اعلنت اف اكثر اكد الالاء الالى الا الاخيرة الان الاول الاولى التى التي الثاني الثانية الذاتي الذى الذي الذين السابق الف اللائي اللاتي اللتان اللتيا اللتين اللذان اللذين اللواتي الماضي المقبل الوقت الى اليوم اما امام امس ان انبرى انقلب انه انها او اول اي ايار ايام ايضا ب بات باسم بان بخ برس بسبب بس بشكل بضع بطان بعد بعض بك بكم بكما بكن بل بلى بما بماذا بمن بن بنا به بها بي بيد بين بس بله بئس تان تانك تبدل تجاه تحول تلقاء تلك تلكم تلكما تم تينك تين ته تي ثلاثة ثم ثم ثمة ثم جعل جلل جميع جير حار حاشا حاليا حاي حتى حرى حسب حم حوالى حول حيث حيثما حين حي حبذا حتى حذار خلا خلال دون دونك ذا ذات ذاك ذانك ذان ذلك ذلكم ذلكما ذلكن ذو ذوا ذواتا ذواتي ذيت ذينك ذين ذه ذي راح رجع رويدك ريث رب زيارة سبحان سرعان سنة سنوات سوف سوى ساء ساءما شبه شخصا شرع شتان صار صباح صفر صه صه ضد ضمن طاق طالما طفق طق ظل عاد عام عاما عامة عدا عدة عدد عدم عسى عشر عشرة علق على عليك عليه عليها عل عن عند عندما عوض عين عدس عما غدا غير  ف فان فلان فو فى في فيم فيما فيه فيها قال قام قبل قد قط قلما قوة كانما كاين كاي كاين كاد كان كانت كذا كذلك كرب كل كلا كلاهما كلتا كلم كليكما كليهما كلما كلا كم كما كي كيت كيف كيفما كان كخ لئن لا لات لاسيما لدن لدى لعمر لقاء لك لكم لكما لكن لكنما لكي لكيلا للامم لم لما لما لن لنا له لها لو لوكالة لولا لوما لي لست لست لستم لستما لستن لست لسن لعل لكن ليت ليس ليسا ليستا ليست ليسوا لسنا ما ماانفك مابرح مادام ماذا مازال مافتئ مايو متى مثل مذ مساء مع معاذ مقابل مكانكم مكانكما مكانكن مكانك مليار مليون مما ممن من منذ منها مه مهما من من نحن نحو نعم نفس نفسه نهاية نخ نعما نعم ها هاؤم هاك هاهنا هب هذا هذه هكذا هل هلم هلا هم هما هن هنا هناك هنالك هو هي هيا هيت هيا هؤلاء هاتان هاتين هاته هاتي هج هذا هذان هذين هذه هذي هيهات وا واحد واضاف واضافت واكد وان واها واوضح وراءك وفي وقال وقالت وقد وقف وكان وكانت ولا ولم ومن وهو وهي ويكان وي وشكان يكون يمكن يوم ايان'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.ar.stopWordFilter, 'stopWordFilter-ar');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.da.js

@@ -0,0 +1,284 @@
+/*!
+ * Lunr languages, `Danish` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.da = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.da.trimmer,
+        lunr.da.stopWordFilter,
+        lunr.da.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.da.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.da.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.da.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.da.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.da.trimmer, 'trimmer-da');
+
+    /* lunr stemmer function */
+    lunr.da.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function DanishStemmer() {
+          var a_0 = [new Among("hed", -1, 1), new Among("ethed", 0, 1),
+              new Among("ered", -1, 1), new Among("e", -1, 1),
+              new Among("erede", 3, 1), new Among("ende", 3, 1),
+              new Among("erende", 5, 1), new Among("ene", 3, 1),
+              new Among("erne", 3, 1), new Among("ere", 3, 1),
+              new Among("en", -1, 1), new Among("heden", 10, 1),
+              new Among("eren", 10, 1), new Among("er", -1, 1),
+              new Among("heder", 13, 1), new Among("erer", 13, 1),
+              new Among("s", -1, 2), new Among("heds", 16, 1),
+              new Among("es", 16, 1), new Among("endes", 18, 1),
+              new Among("erendes", 19, 1), new Among("enes", 18, 1),
+              new Among("ernes", 18, 1), new Among("eres", 18, 1),
+              new Among("ens", 16, 1), new Among("hedens", 24, 1),
+              new Among("erens", 24, 1), new Among("ers", 16, 1),
+              new Among("ets", 16, 1), new Among("erets", 28, 1),
+              new Among("et", -1, 1), new Among("eret", 30, 1)
+            ],
+            a_1 = [
+              new Among("gd", -1, -1), new Among("dt", -1, -1),
+              new Among("gt", -1, -1), new Among("kt", -1, -1)
+            ],
+            a_2 = [
+              new Among("ig", -1, 1), new Among("lig", 0, 1),
+              new Among("elig", 1, 1), new Among("els", -1, 1),
+              new Among("l\u00F8st", -1, 2)
+            ],
+            g_v = [17, 65, 16, 1, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128
+            ],
+            g_s_ending = [239, 254, 42, 3,
+              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16
+            ],
+            I_x, I_p1, S_ch, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_mark_regions() {
+            var v_1, c = sbp.cursor + 3;
+            I_p1 = sbp.limit;
+            if (0 <= c && c <= sbp.limit) {
+              I_x = c;
+              while (true) {
+                v_1 = sbp.cursor;
+                if (sbp.in_grouping(g_v, 97, 248)) {
+                  sbp.cursor = v_1;
+                  break;
+                }
+                sbp.cursor = v_1;
+                if (v_1 >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              while (!sbp.out_grouping(g_v, 97, 248)) {
+                if (sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              I_p1 = sbp.cursor;
+              if (I_p1 < I_x)
+                I_p1 = I_x;
+            }
+          }
+
+          function r_main_suffix() {
+            var among_var, v_1;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_0, 32);
+              sbp.limit_backward = v_1;
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    if (sbp.in_grouping_b(g_s_ending, 97, 229))
+                      sbp.slice_del();
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_consonant_pair() {
+            var v_1 = sbp.limit - sbp.cursor,
+              v_2;
+            if (sbp.cursor >= I_p1) {
+              v_2 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              if (sbp.find_among_b(a_1, 4)) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_2;
+                sbp.cursor = sbp.limit - v_1;
+                if (sbp.cursor > sbp.limit_backward) {
+                  sbp.cursor--;
+                  sbp.bra = sbp.cursor;
+                  sbp.slice_del();
+                }
+              } else
+                sbp.limit_backward = v_2;
+            }
+          }
+
+          function r_other_suffix() {
+            var among_var, v_1 = sbp.limit - sbp.cursor,
+              v_2, v_3;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(2, "st")) {
+              sbp.bra = sbp.cursor;
+              if (sbp.eq_s_b(2, "ig"))
+                sbp.slice_del();
+            }
+            sbp.cursor = sbp.limit - v_1;
+            if (sbp.cursor >= I_p1) {
+              v_2 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_2, 5);
+              sbp.limit_backward = v_2;
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    v_3 = sbp.limit - sbp.cursor;
+                    r_consonant_pair();
+                    sbp.cursor = sbp.limit - v_3;
+                    break;
+                  case 2:
+                    sbp.slice_from("l\u00F8s");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_undouble() {
+            var v_1;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              if (sbp.out_grouping_b(g_v, 97, 248)) {
+                sbp.bra = sbp.cursor;
+                S_ch = sbp.slice_to(S_ch);
+                sbp.limit_backward = v_1;
+                if (sbp.eq_v_b(S_ch))
+                  sbp.slice_del();
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_main_suffix();
+            sbp.cursor = sbp.limit;
+            r_consonant_pair();
+            sbp.cursor = sbp.limit;
+            r_other_suffix();
+            sbp.cursor = sbp.limit;
+            r_undouble();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.da.stemmer, 'stemmer-da');
+
+    lunr.da.stopWordFilter = lunr.generateStopWordFilter('ad af alle alt anden at blev blive bliver da de dem den denne der deres det dette dig din disse dog du efter eller en end er et for fra ham han hans har havde have hende hendes her hos hun hvad hvis hvor i ikke ind jeg jer jo kunne man mange med meget men mig min mine mit mod ned noget nogle nu når og også om op os over på selv sig sin sine sit skal skulle som sådan thi til ud under var vi vil ville vor være været'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.da.stopWordFilter, 'stopWordFilter-da');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.de.js

@@ -0,0 +1,384 @@
+/*!
+ * Lunr languages, `German` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.de = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.de.trimmer,
+        lunr.de.stopWordFilter,
+        lunr.de.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.de.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.de.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.de.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.de.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.de.trimmer, 'trimmer-de');
+
+    /* lunr stemmer function */
+    lunr.de.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function GermanStemmer() {
+          var a_0 = [new Among("", -1, 6), new Among("U", 0, 2),
+              new Among("Y", 0, 1), new Among("\u00E4", 0, 3),
+              new Among("\u00F6", 0, 4), new Among("\u00FC", 0, 5)
+            ],
+            a_1 = [
+              new Among("e", -1, 2), new Among("em", -1, 1),
+              new Among("en", -1, 2), new Among("ern", -1, 1),
+              new Among("er", -1, 1), new Among("s", -1, 3),
+              new Among("es", 5, 2)
+            ],
+            a_2 = [new Among("en", -1, 1),
+              new Among("er", -1, 1), new Among("st", -1, 2),
+              new Among("est", 2, 1)
+            ],
+            a_3 = [new Among("ig", -1, 1),
+              new Among("lich", -1, 1)
+            ],
+            a_4 = [new Among("end", -1, 1),
+              new Among("ig", -1, 2), new Among("ung", -1, 1),
+              new Among("lich", -1, 3), new Among("isch", -1, 2),
+              new Among("ik", -1, 2), new Among("heit", -1, 3),
+              new Among("keit", -1, 4)
+            ],
+            g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 8, 0, 32, 8
+            ],
+            g_s_ending = [117, 30, 5],
+            g_st_ending = [
+              117, 30, 4
+            ],
+            I_x, I_p2, I_p1, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function habr1(c1, c2, v_1) {
+            if (sbp.eq_s(1, c1)) {
+              sbp.ket = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 252)) {
+                sbp.slice_from(c2);
+                sbp.cursor = v_1;
+                return true;
+              }
+            }
+            return false;
+          }
+
+          function r_prelude() {
+            var v_1 = sbp.cursor,
+              v_2, v_3, v_4, v_5;
+            while (true) {
+              v_2 = sbp.cursor;
+              sbp.bra = v_2;
+              if (sbp.eq_s(1, "\u00DF")) {
+                sbp.ket = sbp.cursor;
+                sbp.slice_from("ss");
+              } else {
+                if (v_2 >= sbp.limit)
+                  break;
+                sbp.cursor = v_2 + 1;
+              }
+            }
+            sbp.cursor = v_1;
+            while (true) {
+              v_3 = sbp.cursor;
+              while (true) {
+                v_4 = sbp.cursor;
+                if (sbp.in_grouping(g_v, 97, 252)) {
+                  v_5 = sbp.cursor;
+                  sbp.bra = v_5;
+                  if (habr1("u", "U", v_4))
+                    break;
+                  sbp.cursor = v_5;
+                  if (habr1("y", "Y", v_4))
+                    break;
+                }
+                if (v_4 >= sbp.limit) {
+                  sbp.cursor = v_3;
+                  return;
+                }
+                sbp.cursor = v_4 + 1;
+              }
+            }
+          }
+
+          function habr2() {
+            while (!sbp.in_grouping(g_v, 97, 252)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 252)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            return false;
+          }
+
+          function r_mark_regions() {
+            I_p1 = sbp.limit;
+            I_p2 = I_p1;
+            var c = sbp.cursor + 3;
+            if (0 <= c && c <= sbp.limit) {
+              I_x = c;
+              if (!habr2()) {
+                I_p1 = sbp.cursor;
+                if (I_p1 < I_x)
+                  I_p1 = I_x;
+                if (!habr2())
+                  I_p2 = sbp.cursor;
+              }
+            }
+          }
+
+          function r_postlude() {
+            var among_var, v_1;
+            while (true) {
+              v_1 = sbp.cursor;
+              sbp.bra = v_1;
+              among_var = sbp.find_among(a_0, 6);
+              if (!among_var)
+                return;
+              sbp.ket = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  sbp.slice_from("y");
+                  break;
+                case 2:
+                case 5:
+                  sbp.slice_from("u");
+                  break;
+                case 3:
+                  sbp.slice_from("a");
+                  break;
+                case 4:
+                  sbp.slice_from("o");
+                  break;
+                case 6:
+                  if (sbp.cursor >= sbp.limit)
+                    return;
+                  sbp.cursor++;
+                  break;
+              }
+            }
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_standard_suffix() {
+            var among_var, v_1 = sbp.limit - sbp.cursor,
+              v_2, v_3, v_4;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_1, 7);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(1, "s")) {
+                      sbp.bra = sbp.cursor;
+                      if (sbp.eq_s_b(3, "nis"))
+                        sbp.slice_del();
+                    }
+                    break;
+                  case 3:
+                    if (sbp.in_grouping_b(g_s_ending, 98, 116))
+                      sbp.slice_del();
+                    break;
+                }
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_2, 4);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    if (sbp.in_grouping_b(g_st_ending, 98, 116)) {
+                      var c = sbp.cursor - 3;
+                      if (sbp.limit_backward <= c && c <= sbp.limit) {
+                        sbp.cursor = c;
+                        sbp.slice_del();
+                      }
+                    }
+                    break;
+                }
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_4, 8);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R2()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(2, "ig")) {
+                      sbp.bra = sbp.cursor;
+                      v_2 = sbp.limit - sbp.cursor;
+                      if (!sbp.eq_s_b(1, "e")) {
+                        sbp.cursor = sbp.limit - v_2;
+                        if (r_R2())
+                          sbp.slice_del();
+                      }
+                    }
+                    break;
+                  case 2:
+                    v_3 = sbp.limit - sbp.cursor;
+                    if (!sbp.eq_s_b(1, "e")) {
+                      sbp.cursor = sbp.limit - v_3;
+                      sbp.slice_del();
+                    }
+                    break;
+                  case 3:
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    v_4 = sbp.limit - sbp.cursor;
+                    if (!sbp.eq_s_b(2, "er")) {
+                      sbp.cursor = sbp.limit - v_4;
+                      if (!sbp.eq_s_b(2, "en"))
+                        break;
+                    }
+                    sbp.bra = sbp.cursor;
+                    if (r_R1())
+                      sbp.slice_del();
+                    break;
+                  case 4:
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    among_var = sbp.find_among_b(a_3, 2);
+                    if (among_var) {
+                      sbp.bra = sbp.cursor;
+                      if (r_R2() && among_var == 1)
+                        sbp.slice_del();
+                    }
+                    break;
+                }
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_standard_suffix();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.de.stemmer, 'stemmer-de');
+
+    lunr.de.stopWordFilter = lunr.generateStopWordFilter('aber alle allem allen aller alles als also am an ander andere anderem anderen anderer anderes anderm andern anderr anders auch auf aus bei bin bis bist da damit dann das dasselbe dazu daß dein deine deinem deinen deiner deines dem demselben den denn denselben der derer derselbe derselben des desselben dessen dich die dies diese dieselbe dieselben diesem diesen dieser dieses dir doch dort du durch ein eine einem einen einer eines einig einige einigem einigen einiger einiges einmal er es etwas euch euer eure eurem euren eurer eures für gegen gewesen hab habe haben hat hatte hatten hier hin hinter ich ihm ihn ihnen ihr ihre ihrem ihren ihrer ihres im in indem ins ist jede jedem jeden jeder jedes jene jenem jenen jener jenes jetzt kann kein keine keinem keinen keiner keines können könnte machen man manche manchem manchen mancher manches mein meine meinem meinen meiner meines mich mir mit muss musste nach nicht nichts noch nun nur ob oder ohne sehr sein seine seinem seinen seiner seines selbst sich sie sind so solche solchem solchen solcher solches soll sollte sondern sonst um und uns unse unsem unsen unser unses unter viel vom von vor war waren warst was weg weil weiter welche welchem welchen welcher welches wenn werde werden wie wieder will wir wird wirst wo wollen wollte während würde würden zu zum zur zwar zwischen über'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.de.stopWordFilter, 'stopWordFilter-de');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.du.js

@@ -0,0 +1,450 @@
+/*!
+ * Lunr languages, `Dutch` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    console.warn("[Lunr Languages] Please use the \"nl\" instead of the \"du\". The \"nl\" code is the standard code for Dutch language, and \"du\" will be removed in the next major versions.");
+
+    /* register specific locale function */
+    lunr.du = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.du.trimmer,
+        lunr.du.stopWordFilter,
+        lunr.du.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.du.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.du.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.du.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.du.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.du.trimmer, 'trimmer-du');
+
+    /* lunr stemmer function */
+    lunr.du.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function DutchStemmer() {
+          var a_0 = [new Among("", -1, 6), new Among("\u00E1", 0, 1),
+              new Among("\u00E4", 0, 1), new Among("\u00E9", 0, 2),
+              new Among("\u00EB", 0, 2), new Among("\u00ED", 0, 3),
+              new Among("\u00EF", 0, 3), new Among("\u00F3", 0, 4),
+              new Among("\u00F6", 0, 4), new Among("\u00FA", 0, 5),
+              new Among("\u00FC", 0, 5)
+            ],
+            a_1 = [new Among("", -1, 3),
+              new Among("I", 0, 2), new Among("Y", 0, 1)
+            ],
+            a_2 = [
+              new Among("dd", -1, -1), new Among("kk", -1, -1),
+              new Among("tt", -1, -1)
+            ],
+            a_3 = [new Among("ene", -1, 2),
+              new Among("se", -1, 3), new Among("en", -1, 2),
+              new Among("heden", 2, 1), new Among("s", -1, 3)
+            ],
+            a_4 = [
+              new Among("end", -1, 1), new Among("ig", -1, 2),
+              new Among("ing", -1, 1), new Among("lijk", -1, 3),
+              new Among("baar", -1, 4), new Among("bar", -1, 5)
+            ],
+            a_5 = [
+              new Among("aa", -1, -1), new Among("ee", -1, -1),
+              new Among("oo", -1, -1), new Among("uu", -1, -1)
+            ],
+            g_v = [17, 65,
+              16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            g_v_I = [1, 0, 0,
+              17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            g_v_j = [
+              17, 67, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            I_p2, I_p1, B_e_found, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_prelude() {
+            var among_var, v_1 = sbp.cursor,
+              v_2, v_3;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_0, 11);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("a");
+                    continue;
+                  case 2:
+                    sbp.slice_from("e");
+                    continue;
+                  case 3:
+                    sbp.slice_from("i");
+                    continue;
+                  case 4:
+                    sbp.slice_from("o");
+                    continue;
+                  case 5:
+                    sbp.slice_from("u");
+                    continue;
+                  case 6:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+            sbp.cursor = v_1;
+            sbp.bra = v_1;
+            if (sbp.eq_s(1, "y")) {
+              sbp.ket = sbp.cursor;
+              sbp.slice_from("Y");
+            } else
+              sbp.cursor = v_1;
+            while (true) {
+              v_2 = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 232)) {
+                v_3 = sbp.cursor;
+                sbp.bra = v_3;
+                if (sbp.eq_s(1, "i")) {
+                  sbp.ket = sbp.cursor;
+                  if (sbp.in_grouping(g_v, 97, 232)) {
+                    sbp.slice_from("I");
+                    sbp.cursor = v_2;
+                  }
+                } else {
+                  sbp.cursor = v_3;
+                  if (sbp.eq_s(1, "y")) {
+                    sbp.ket = sbp.cursor;
+                    sbp.slice_from("Y");
+                    sbp.cursor = v_2;
+                  } else if (habr1(v_2))
+                    break;
+                }
+              } else if (habr1(v_2))
+                break;
+            }
+          }
+
+          function habr1(v_1) {
+            sbp.cursor = v_1;
+            if (v_1 >= sbp.limit)
+              return true;
+            sbp.cursor++;
+            return false;
+          }
+
+          function r_mark_regions() {
+            I_p1 = sbp.limit;
+            I_p2 = I_p1;
+            if (!habr2()) {
+              I_p1 = sbp.cursor;
+              if (I_p1 < 3)
+                I_p1 = 3;
+              if (!habr2())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function habr2() {
+            while (!sbp.in_grouping(g_v, 97, 232)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 232)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            return false;
+          }
+
+          function r_postlude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_1, 3);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("y");
+                    break;
+                  case 2:
+                    sbp.slice_from("i");
+                    break;
+                  case 3:
+                    if (sbp.cursor >= sbp.limit)
+                      return;
+                    sbp.cursor++;
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_undouble() {
+            var v_1 = sbp.limit - sbp.cursor;
+            if (sbp.find_among_b(a_2, 3)) {
+              sbp.cursor = sbp.limit - v_1;
+              sbp.ket = sbp.cursor;
+              if (sbp.cursor > sbp.limit_backward) {
+                sbp.cursor--;
+                sbp.bra = sbp.cursor;
+                sbp.slice_del();
+              }
+            }
+          }
+
+          function r_e_ending() {
+            var v_1;
+            B_e_found = false;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "e")) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                v_1 = sbp.limit - sbp.cursor;
+                if (sbp.out_grouping_b(g_v, 97, 232)) {
+                  sbp.cursor = sbp.limit - v_1;
+                  sbp.slice_del();
+                  B_e_found = true;
+                  r_undouble();
+                }
+              }
+            }
+          }
+
+          function r_en_ending() {
+            var v_1;
+            if (r_R1()) {
+              v_1 = sbp.limit - sbp.cursor;
+              if (sbp.out_grouping_b(g_v, 97, 232)) {
+                sbp.cursor = sbp.limit - v_1;
+                if (!sbp.eq_s_b(3, "gem")) {
+                  sbp.cursor = sbp.limit - v_1;
+                  sbp.slice_del();
+                  r_undouble();
+                }
+              }
+            }
+          }
+
+          function r_standard_suffix() {
+            var among_var, v_1 = sbp.limit - sbp.cursor,
+              v_2, v_3, v_4, v_5, v_6;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_3, 5);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (r_R1())
+                    sbp.slice_from("heid");
+                  break;
+                case 2:
+                  r_en_ending();
+                  break;
+                case 3:
+                  if (r_R1() && sbp.out_grouping_b(g_v_j, 97, 232))
+                    sbp.slice_del();
+                  break;
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            r_e_ending();
+            sbp.cursor = sbp.limit - v_1;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(4, "heid")) {
+              sbp.bra = sbp.cursor;
+              if (r_R2()) {
+                v_2 = sbp.limit - sbp.cursor;
+                if (!sbp.eq_s_b(1, "c")) {
+                  sbp.cursor = sbp.limit - v_2;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  if (sbp.eq_s_b(2, "en")) {
+                    sbp.bra = sbp.cursor;
+                    r_en_ending();
+                  }
+                }
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_4, 6);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    v_3 = sbp.limit - sbp.cursor;
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(2, "ig")) {
+                      sbp.bra = sbp.cursor;
+                      if (r_R2()) {
+                        v_4 = sbp.limit - sbp.cursor;
+                        if (!sbp.eq_s_b(1, "e")) {
+                          sbp.cursor = sbp.limit - v_4;
+                          sbp.slice_del();
+                          break;
+                        }
+                      }
+                    }
+                    sbp.cursor = sbp.limit - v_3;
+                    r_undouble();
+                  }
+                  break;
+                case 2:
+                  if (r_R2()) {
+                    v_5 = sbp.limit - sbp.cursor;
+                    if (!sbp.eq_s_b(1, "e")) {
+                      sbp.cursor = sbp.limit - v_5;
+                      sbp.slice_del();
+                    }
+                  }
+                  break;
+                case 3:
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    r_e_ending();
+                  }
+                  break;
+                case 4:
+                  if (r_R2())
+                    sbp.slice_del();
+                  break;
+                case 5:
+                  if (r_R2() && B_e_found)
+                    sbp.slice_del();
+                  break;
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            if (sbp.out_grouping_b(g_v_I, 73, 232)) {
+              v_6 = sbp.limit - sbp.cursor;
+              if (sbp.find_among_b(a_5, 4) && sbp.out_grouping_b(g_v, 97, 232)) {
+                sbp.cursor = sbp.limit - v_6;
+                sbp.ket = sbp.cursor;
+                if (sbp.cursor > sbp.limit_backward) {
+                  sbp.cursor--;
+                  sbp.bra = sbp.cursor;
+                  sbp.slice_del();
+                }
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_standard_suffix();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.du.stemmer, 'stemmer-du');
+
+    lunr.du.stopWordFilter = lunr.generateStopWordFilter(' aan al alles als altijd andere ben bij daar dan dat de der deze die dit doch doen door dus een eens en er ge geen geweest haar had heb hebben heeft hem het hier hij hoe hun iemand iets ik in is ja je kan kon kunnen maar me meer men met mij mijn moet na naar niet niets nog nu of om omdat onder ons ook op over reeds te tegen toch toen tot u uit uw van veel voor want waren was wat werd wezen wie wil worden wordt zal ze zelf zich zij zijn zo zonder zou'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.du.stopWordFilter, 'stopWordFilter-du');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.es.js

@@ -0,0 +1,599 @@
+/*!
+ * Lunr languages, `Spanish` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.es = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.es.trimmer,
+        lunr.es.stopWordFilter,
+        lunr.es.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.es.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.es.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.es.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.es.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.es.trimmer, 'trimmer-es');
+
+    /* lunr stemmer function */
+    lunr.es.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function SpanishStemmer() {
+          var a_0 = [new Among("", -1, 6), new Among("\u00E1", 0, 1),
+              new Among("\u00E9", 0, 2), new Among("\u00ED", 0, 3),
+              new Among("\u00F3", 0, 4), new Among("\u00FA", 0, 5)
+            ],
+            a_1 = [
+              new Among("la", -1, -1), new Among("sela", 0, -1),
+              new Among("le", -1, -1), new Among("me", -1, -1),
+              new Among("se", -1, -1), new Among("lo", -1, -1),
+              new Among("selo", 5, -1), new Among("las", -1, -1),
+              new Among("selas", 7, -1), new Among("les", -1, -1),
+              new Among("los", -1, -1), new Among("selos", 10, -1),
+              new Among("nos", -1, -1)
+            ],
+            a_2 = [new Among("ando", -1, 6),
+              new Among("iendo", -1, 6), new Among("yendo", -1, 7),
+              new Among("\u00E1ndo", -1, 2), new Among("i\u00E9ndo", -1, 1),
+              new Among("ar", -1, 6), new Among("er", -1, 6),
+              new Among("ir", -1, 6), new Among("\u00E1r", -1, 3),
+              new Among("\u00E9r", -1, 4), new Among("\u00EDr", -1, 5)
+            ],
+            a_3 = [
+              new Among("ic", -1, -1), new Among("ad", -1, -1),
+              new Among("os", -1, -1), new Among("iv", -1, 1)
+            ],
+            a_4 = [
+              new Among("able", -1, 1), new Among("ible", -1, 1),
+              new Among("ante", -1, 1)
+            ],
+            a_5 = [new Among("ic", -1, 1),
+              new Among("abil", -1, 1), new Among("iv", -1, 1)
+            ],
+            a_6 = [
+              new Among("ica", -1, 1), new Among("ancia", -1, 2),
+              new Among("encia", -1, 5), new Among("adora", -1, 2),
+              new Among("osa", -1, 1), new Among("ista", -1, 1),
+              new Among("iva", -1, 9), new Among("anza", -1, 1),
+              new Among("log\u00EDa", -1, 3), new Among("idad", -1, 8),
+              new Among("able", -1, 1), new Among("ible", -1, 1),
+              new Among("ante", -1, 2), new Among("mente", -1, 7),
+              new Among("amente", 13, 6), new Among("aci\u00F3n", -1, 2),
+              new Among("uci\u00F3n", -1, 4), new Among("ico", -1, 1),
+              new Among("ismo", -1, 1), new Among("oso", -1, 1),
+              new Among("amiento", -1, 1), new Among("imiento", -1, 1),
+              new Among("ivo", -1, 9), new Among("ador", -1, 2),
+              new Among("icas", -1, 1), new Among("ancias", -1, 2),
+              new Among("encias", -1, 5), new Among("adoras", -1, 2),
+              new Among("osas", -1, 1), new Among("istas", -1, 1),
+              new Among("ivas", -1, 9), new Among("anzas", -1, 1),
+              new Among("log\u00EDas", -1, 3), new Among("idades", -1, 8),
+              new Among("ables", -1, 1), new Among("ibles", -1, 1),
+              new Among("aciones", -1, 2), new Among("uciones", -1, 4),
+              new Among("adores", -1, 2), new Among("antes", -1, 2),
+              new Among("icos", -1, 1), new Among("ismos", -1, 1),
+              new Among("osos", -1, 1), new Among("amientos", -1, 1),
+              new Among("imientos", -1, 1), new Among("ivos", -1, 9)
+            ],
+            a_7 = [
+              new Among("ya", -1, 1), new Among("ye", -1, 1),
+              new Among("yan", -1, 1), new Among("yen", -1, 1),
+              new Among("yeron", -1, 1), new Among("yendo", -1, 1),
+              new Among("yo", -1, 1), new Among("yas", -1, 1),
+              new Among("yes", -1, 1), new Among("yais", -1, 1),
+              new Among("yamos", -1, 1), new Among("y\u00F3", -1, 1)
+            ],
+            a_8 = [
+              new Among("aba", -1, 2), new Among("ada", -1, 2),
+              new Among("ida", -1, 2), new Among("ara", -1, 2),
+              new Among("iera", -1, 2), new Among("\u00EDa", -1, 2),
+              new Among("ar\u00EDa", 5, 2), new Among("er\u00EDa", 5, 2),
+              new Among("ir\u00EDa", 5, 2), new Among("ad", -1, 2),
+              new Among("ed", -1, 2), new Among("id", -1, 2),
+              new Among("ase", -1, 2), new Among("iese", -1, 2),
+              new Among("aste", -1, 2), new Among("iste", -1, 2),
+              new Among("an", -1, 2), new Among("aban", 16, 2),
+              new Among("aran", 16, 2), new Among("ieran", 16, 2),
+              new Among("\u00EDan", 16, 2), new Among("ar\u00EDan", 20, 2),
+              new Among("er\u00EDan", 20, 2), new Among("ir\u00EDan", 20, 2),
+              new Among("en", -1, 1), new Among("asen", 24, 2),
+              new Among("iesen", 24, 2), new Among("aron", -1, 2),
+              new Among("ieron", -1, 2), new Among("ar\u00E1n", -1, 2),
+              new Among("er\u00E1n", -1, 2), new Among("ir\u00E1n", -1, 2),
+              new Among("ado", -1, 2), new Among("ido", -1, 2),
+              new Among("ando", -1, 2), new Among("iendo", -1, 2),
+              new Among("ar", -1, 2), new Among("er", -1, 2),
+              new Among("ir", -1, 2), new Among("as", -1, 2),
+              new Among("abas", 39, 2), new Among("adas", 39, 2),
+              new Among("idas", 39, 2), new Among("aras", 39, 2),
+              new Among("ieras", 39, 2), new Among("\u00EDas", 39, 2),
+              new Among("ar\u00EDas", 45, 2), new Among("er\u00EDas", 45, 2),
+              new Among("ir\u00EDas", 45, 2), new Among("es", -1, 1),
+              new Among("ases", 49, 2), new Among("ieses", 49, 2),
+              new Among("abais", -1, 2), new Among("arais", -1, 2),
+              new Among("ierais", -1, 2), new Among("\u00EDais", -1, 2),
+              new Among("ar\u00EDais", 55, 2), new Among("er\u00EDais", 55, 2),
+              new Among("ir\u00EDais", 55, 2), new Among("aseis", -1, 2),
+              new Among("ieseis", -1, 2), new Among("asteis", -1, 2),
+              new Among("isteis", -1, 2), new Among("\u00E1is", -1, 2),
+              new Among("\u00E9is", -1, 1), new Among("ar\u00E9is", 64, 2),
+              new Among("er\u00E9is", 64, 2), new Among("ir\u00E9is", 64, 2),
+              new Among("ados", -1, 2), new Among("idos", -1, 2),
+              new Among("amos", -1, 2), new Among("\u00E1bamos", 70, 2),
+              new Among("\u00E1ramos", 70, 2), new Among("i\u00E9ramos", 70, 2),
+              new Among("\u00EDamos", 70, 2), new Among("ar\u00EDamos", 74, 2),
+              new Among("er\u00EDamos", 74, 2), new Among("ir\u00EDamos", 74, 2),
+              new Among("emos", -1, 1), new Among("aremos", 78, 2),
+              new Among("eremos", 78, 2), new Among("iremos", 78, 2),
+              new Among("\u00E1semos", 78, 2), new Among("i\u00E9semos", 78, 2),
+              new Among("imos", -1, 2), new Among("ar\u00E1s", -1, 2),
+              new Among("er\u00E1s", -1, 2), new Among("ir\u00E1s", -1, 2),
+              new Among("\u00EDs", -1, 2), new Among("ar\u00E1", -1, 2),
+              new Among("er\u00E1", -1, 2), new Among("ir\u00E1", -1, 2),
+              new Among("ar\u00E9", -1, 2), new Among("er\u00E9", -1, 2),
+              new Among("ir\u00E9", -1, 2), new Among("i\u00F3", -1, 2)
+            ],
+            a_9 = [
+              new Among("a", -1, 1), new Among("e", -1, 2),
+              new Among("o", -1, 1), new Among("os", -1, 1),
+              new Among("\u00E1", -1, 1), new Among("\u00E9", -1, 2),
+              new Among("\u00ED", -1, 1), new Among("\u00F3", -1, 1)
+            ],
+            g_v = [17,
+              65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 4, 10
+            ],
+            I_p2, I_p1, I_pV, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function habr1() {
+            if (sbp.out_grouping(g_v, 97, 252)) {
+              while (!sbp.in_grouping(g_v, 97, 252)) {
+                if (sbp.cursor >= sbp.limit)
+                  return true;
+                sbp.cursor++;
+              }
+              return false;
+            }
+            return true;
+          }
+
+          function habr2() {
+            if (sbp.in_grouping(g_v, 97, 252)) {
+              var v_1 = sbp.cursor;
+              if (habr1()) {
+                sbp.cursor = v_1;
+                if (!sbp.in_grouping(g_v, 97, 252))
+                  return true;
+                while (!sbp.out_grouping(g_v, 97, 252)) {
+                  if (sbp.cursor >= sbp.limit)
+                    return true;
+                  sbp.cursor++;
+                }
+              }
+              return false;
+            }
+            return true;
+          }
+
+          function habr3() {
+            var v_1 = sbp.cursor,
+              v_2;
+            if (habr2()) {
+              sbp.cursor = v_1;
+              if (!sbp.out_grouping(g_v, 97, 252))
+                return;
+              v_2 = sbp.cursor;
+              if (habr1()) {
+                sbp.cursor = v_2;
+                if (!sbp.in_grouping(g_v, 97, 252) || sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+            }
+            I_pV = sbp.cursor;
+          }
+
+          function habr4() {
+            while (!sbp.in_grouping(g_v, 97, 252)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 252)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function r_mark_regions() {
+            var v_1 = sbp.cursor;
+            I_pV = sbp.limit;
+            I_p1 = I_pV;
+            I_p2 = I_pV;
+            habr3();
+            sbp.cursor = v_1;
+            if (habr4()) {
+              I_p1 = sbp.cursor;
+              if (habr4())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function r_postlude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_0, 6);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("a");
+                    continue;
+                  case 2:
+                    sbp.slice_from("e");
+                    continue;
+                  case 3:
+                    sbp.slice_from("i");
+                    continue;
+                  case 4:
+                    sbp.slice_from("o");
+                    continue;
+                  case 5:
+                    sbp.slice_from("u");
+                    continue;
+                  case 6:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+          }
+
+          function r_RV() {
+            return I_pV <= sbp.cursor;
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_attached_pronoun() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            if (sbp.find_among_b(a_1, 13)) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among_b(a_2, 11);
+              if (among_var && r_RV())
+                switch (among_var) {
+                  case 1:
+                    sbp.bra = sbp.cursor;
+                    sbp.slice_from("iendo");
+                    break;
+                  case 2:
+                    sbp.bra = sbp.cursor;
+                    sbp.slice_from("ando");
+                    break;
+                  case 3:
+                    sbp.bra = sbp.cursor;
+                    sbp.slice_from("ar");
+                    break;
+                  case 4:
+                    sbp.bra = sbp.cursor;
+                    sbp.slice_from("er");
+                    break;
+                  case 5:
+                    sbp.bra = sbp.cursor;
+                    sbp.slice_from("ir");
+                    break;
+                  case 6:
+                    sbp.slice_del();
+                    break;
+                  case 7:
+                    if (sbp.eq_s_b(1, "u"))
+                      sbp.slice_del();
+                    break;
+                }
+            }
+          }
+
+          function habr5(a, n) {
+            if (!r_R2())
+              return true;
+            sbp.slice_del();
+            sbp.ket = sbp.cursor;
+            var among_var = sbp.find_among_b(a, n);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (among_var == 1 && r_R2())
+                sbp.slice_del();
+            }
+            return false;
+          }
+
+          function habr6(c1) {
+            if (!r_R2())
+              return true;
+            sbp.slice_del();
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(2, c1)) {
+              sbp.bra = sbp.cursor;
+              if (r_R2())
+                sbp.slice_del();
+            }
+            return false;
+          }
+
+          function r_standard_suffix() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_6, 46);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_del();
+                  break;
+                case 2:
+                  if (habr6("ic"))
+                    return false;
+                  break;
+                case 3:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_from("log");
+                  break;
+                case 4:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_from("u");
+                  break;
+                case 5:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_from("ente");
+                  break;
+                case 6:
+                  if (!r_R1())
+                    return false;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  among_var = sbp.find_among_b(a_3, 4);
+                  if (among_var) {
+                    sbp.bra = sbp.cursor;
+                    if (r_R2()) {
+                      sbp.slice_del();
+                      if (among_var == 1) {
+                        sbp.ket = sbp.cursor;
+                        if (sbp.eq_s_b(2, "at")) {
+                          sbp.bra = sbp.cursor;
+                          if (r_R2())
+                            sbp.slice_del();
+                        }
+                      }
+                    }
+                  }
+                  break;
+                case 7:
+                  if (habr5(a_4, 3))
+                    return false;
+                  break;
+                case 8:
+                  if (habr5(a_5, 3))
+                    return false;
+                  break;
+                case 9:
+                  if (habr6("at"))
+                    return false;
+                  break;
+              }
+              return true;
+            }
+            return false;
+          }
+
+          function r_y_verb_suffix() {
+            var among_var, v_1;
+            if (sbp.cursor >= I_pV) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_pV;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_7, 12);
+              sbp.limit_backward = v_1;
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                if (among_var == 1) {
+                  if (!sbp.eq_s_b(1, "u"))
+                    return false;
+                  sbp.slice_del();
+                }
+                return true;
+              }
+            }
+            return false;
+          }
+
+          function r_verb_suffix() {
+            var among_var, v_1, v_2, v_3;
+            if (sbp.cursor >= I_pV) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_pV;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_8, 96);
+              sbp.limit_backward = v_1;
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    v_2 = sbp.limit - sbp.cursor;
+                    if (sbp.eq_s_b(1, "u")) {
+                      v_3 = sbp.limit - sbp.cursor;
+                      if (sbp.eq_s_b(1, "g"))
+                        sbp.cursor = sbp.limit - v_3;
+                      else
+                        sbp.cursor = sbp.limit - v_2;
+                    } else
+                      sbp.cursor = sbp.limit - v_2;
+                    sbp.bra = sbp.cursor;
+                  case 2:
+                    sbp.slice_del();
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_residual_suffix() {
+            var among_var, v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_9, 8);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (r_RV())
+                    sbp.slice_del();
+                  break;
+                case 2:
+                  if (r_RV()) {
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(1, "u")) {
+                      sbp.bra = sbp.cursor;
+                      v_1 = sbp.limit - sbp.cursor;
+                      if (sbp.eq_s_b(1, "g")) {
+                        sbp.cursor = sbp.limit - v_1;
+                        if (r_RV())
+                          sbp.slice_del();
+                      }
+                    }
+                  }
+                  break;
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_attached_pronoun();
+            sbp.cursor = sbp.limit;
+            if (!r_standard_suffix()) {
+              sbp.cursor = sbp.limit;
+              if (!r_y_verb_suffix()) {
+                sbp.cursor = sbp.limit;
+                r_verb_suffix();
+              }
+            }
+            sbp.cursor = sbp.limit;
+            r_residual_suffix();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.es.stemmer, 'stemmer-es');
+
+    lunr.es.stopWordFilter = lunr.generateStopWordFilter('a al algo algunas algunos ante antes como con contra cual cuando de del desde donde durante e el ella ellas ellos en entre era erais eran eras eres es esa esas ese eso esos esta estaba estabais estaban estabas estad estada estadas estado estados estamos estando estar estaremos estará estarán estarás estaré estaréis estaría estaríais estaríamos estarían estarías estas este estemos esto estos estoy estuve estuviera estuvierais estuvieran estuvieras estuvieron estuviese estuvieseis estuviesen estuvieses estuvimos estuviste estuvisteis estuviéramos estuviésemos estuvo está estábamos estáis están estás esté estéis estén estés fue fuera fuerais fueran fueras fueron fuese fueseis fuesen fueses fui fuimos fuiste fuisteis fuéramos fuésemos ha habida habidas habido habidos habiendo habremos habrá habrán habrás habré habréis habría habríais habríamos habrían habrías habéis había habíais habíamos habían habías han has hasta hay haya hayamos hayan hayas hayáis he hemos hube hubiera hubierais hubieran hubieras hubieron hubiese hubieseis hubiesen hubieses hubimos hubiste hubisteis hubiéramos hubiésemos hubo la las le les lo los me mi mis mucho muchos muy más mí mía mías mío míos nada ni no nos nosotras nosotros nuestra nuestras nuestro nuestros o os otra otras otro otros para pero poco por porque que quien quienes qué se sea seamos sean seas seremos será serán serás seré seréis sería seríais seríamos serían serías seáis sido siendo sin sobre sois somos son soy su sus suya suyas suyo suyos sí también tanto te tendremos tendrá tendrán tendrás tendré tendréis tendría tendríais tendríamos tendrían tendrías tened tenemos tenga tengamos tengan tengas tengo tengáis tenida tenidas tenido tenidos teniendo tenéis tenía teníais teníamos tenían tenías ti tiene tienen tienes todo todos tu tus tuve tuviera tuvierais tuvieran tuvieras tuvieron tuviese tuvieseis tuviesen tuvieses tuvimos tuviste tuvisteis tuviéramos tuviésemos tuvo tuya tuyas tuyo tuyos tú un una uno unos vosotras vosotros vuestra vuestras vuestro vuestros y ya yo él éramos'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.es.stopWordFilter, 'stopWordFilter-es');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.fi.js

@@ -0,0 +1,541 @@
+/*!
+ * Lunr languages, `Finnish` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.fi = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.fi.trimmer,
+        lunr.fi.stopWordFilter,
+        lunr.fi.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.fi.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.fi.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.fi.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.fi.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.fi.trimmer, 'trimmer-fi');
+
+    /* lunr stemmer function */
+    lunr.fi.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function FinnishStemmer() {
+          var a_0 = [new Among("pa", -1, 1), new Among("sti", -1, 2),
+              new Among("kaan", -1, 1), new Among("han", -1, 1),
+              new Among("kin", -1, 1), new Among("h\u00E4n", -1, 1),
+              new Among("k\u00E4\u00E4n", -1, 1), new Among("ko", -1, 1),
+              new Among("p\u00E4", -1, 1), new Among("k\u00F6", -1, 1)
+            ],
+            a_1 = [
+              new Among("lla", -1, -1), new Among("na", -1, -1),
+              new Among("ssa", -1, -1), new Among("ta", -1, -1),
+              new Among("lta", 3, -1), new Among("sta", 3, -1)
+            ],
+            a_2 = [
+              new Among("ll\u00E4", -1, -1), new Among("n\u00E4", -1, -1),
+              new Among("ss\u00E4", -1, -1), new Among("t\u00E4", -1, -1),
+              new Among("lt\u00E4", 3, -1), new Among("st\u00E4", 3, -1)
+            ],
+            a_3 = [
+              new Among("lle", -1, -1), new Among("ine", -1, -1)
+            ],
+            a_4 = [
+              new Among("nsa", -1, 3), new Among("mme", -1, 3),
+              new Among("nne", -1, 3), new Among("ni", -1, 2),
+              new Among("si", -1, 1), new Among("an", -1, 4),
+              new Among("en", -1, 6), new Among("\u00E4n", -1, 5),
+              new Among("ns\u00E4", -1, 3)
+            ],
+            a_5 = [new Among("aa", -1, -1),
+              new Among("ee", -1, -1), new Among("ii", -1, -1),
+              new Among("oo", -1, -1), new Among("uu", -1, -1),
+              new Among("\u00E4\u00E4", -1, -1),
+              new Among("\u00F6\u00F6", -1, -1)
+            ],
+            a_6 = [new Among("a", -1, 8),
+              new Among("lla", 0, -1), new Among("na", 0, -1),
+              new Among("ssa", 0, -1), new Among("ta", 0, -1),
+              new Among("lta", 4, -1), new Among("sta", 4, -1),
+              new Among("tta", 4, 9), new Among("lle", -1, -1),
+              new Among("ine", -1, -1), new Among("ksi", -1, -1),
+              new Among("n", -1, 7), new Among("han", 11, 1),
+              new Among("den", 11, -1, r_VI), new Among("seen", 11, -1, r_LONG),
+              new Among("hen", 11, 2), new Among("tten", 11, -1, r_VI),
+              new Among("hin", 11, 3), new Among("siin", 11, -1, r_VI),
+              new Among("hon", 11, 4), new Among("h\u00E4n", 11, 5),
+              new Among("h\u00F6n", 11, 6), new Among("\u00E4", -1, 8),
+              new Among("ll\u00E4", 22, -1), new Among("n\u00E4", 22, -1),
+              new Among("ss\u00E4", 22, -1), new Among("t\u00E4", 22, -1),
+              new Among("lt\u00E4", 26, -1), new Among("st\u00E4", 26, -1),
+              new Among("tt\u00E4", 26, 9)
+            ],
+            a_7 = [new Among("eja", -1, -1),
+              new Among("mma", -1, 1), new Among("imma", 1, -1),
+              new Among("mpa", -1, 1), new Among("impa", 3, -1),
+              new Among("mmi", -1, 1), new Among("immi", 5, -1),
+              new Among("mpi", -1, 1), new Among("impi", 7, -1),
+              new Among("ej\u00E4", -1, -1), new Among("mm\u00E4", -1, 1),
+              new Among("imm\u00E4", 10, -1), new Among("mp\u00E4", -1, 1),
+              new Among("imp\u00E4", 12, -1)
+            ],
+            a_8 = [new Among("i", -1, -1),
+              new Among("j", -1, -1)
+            ],
+            a_9 = [new Among("mma", -1, 1),
+              new Among("imma", 0, -1)
+            ],
+            g_AEI = [17, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 8
+            ],
+            g_V1 = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 8, 0, 32
+            ],
+            g_V2 = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 8, 0, 32
+            ],
+            g_particle_end = [17, 97, 24, 1, 0, 0,
+              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32
+            ],
+            B_ending_removed, S_x, I_p2, I_p1, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_mark_regions() {
+            I_p1 = sbp.limit;
+            I_p2 = I_p1;
+            if (!habr1()) {
+              I_p1 = sbp.cursor;
+              if (!habr1())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function habr1() {
+            var v_1;
+            while (true) {
+              v_1 = sbp.cursor;
+              if (sbp.in_grouping(g_V1, 97, 246))
+                break;
+              sbp.cursor = v_1;
+              if (v_1 >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            sbp.cursor = v_1;
+            while (!sbp.out_grouping(g_V1, 97, 246)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            return false;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_particle_etc() {
+            var among_var, v_1;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_0, 10);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_1;
+                switch (among_var) {
+                  case 1:
+                    if (!sbp.in_grouping_b(g_particle_end, 97, 246))
+                      return;
+                    break;
+                  case 2:
+                    if (!r_R2())
+                      return;
+                    break;
+                }
+                sbp.slice_del();
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_possessive() {
+            var among_var, v_1, v_2;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_4, 9);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_1;
+                switch (among_var) {
+                  case 1:
+                    v_2 = sbp.limit - sbp.cursor;
+                    if (!sbp.eq_s_b(1, "k")) {
+                      sbp.cursor = sbp.limit - v_2;
+                      sbp.slice_del();
+                    }
+                    break;
+                  case 2:
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(3, "kse")) {
+                      sbp.bra = sbp.cursor;
+                      sbp.slice_from("ksi");
+                    }
+                    break;
+                  case 3:
+                    sbp.slice_del();
+                    break;
+                  case 4:
+                    if (sbp.find_among_b(a_1, 6))
+                      sbp.slice_del();
+                    break;
+                  case 5:
+                    if (sbp.find_among_b(a_2, 6))
+                      sbp.slice_del();
+                    break;
+                  case 6:
+                    if (sbp.find_among_b(a_3, 2))
+                      sbp.slice_del();
+                    break;
+                }
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_LONG() {
+            return sbp.find_among_b(a_5, 7);
+          }
+
+          function r_VI() {
+            return sbp.eq_s_b(1, "i") && sbp.in_grouping_b(g_V2, 97, 246);
+          }
+
+          function r_case_ending() {
+            var among_var, v_1, v_2;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_6, 30);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_1;
+                switch (among_var) {
+                  case 1:
+                    if (!sbp.eq_s_b(1, "a"))
+                      return;
+                    break;
+                  case 2:
+                  case 9:
+                    if (!sbp.eq_s_b(1, "e"))
+                      return;
+                    break;
+                  case 3:
+                    if (!sbp.eq_s_b(1, "i"))
+                      return;
+                    break;
+                  case 4:
+                    if (!sbp.eq_s_b(1, "o"))
+                      return;
+                    break;
+                  case 5:
+                    if (!sbp.eq_s_b(1, "\u00E4"))
+                      return;
+                    break;
+                  case 6:
+                    if (!sbp.eq_s_b(1, "\u00F6"))
+                      return;
+                    break;
+                  case 7:
+                    v_2 = sbp.limit - sbp.cursor;
+                    if (!r_LONG()) {
+                      sbp.cursor = sbp.limit - v_2;
+                      if (!sbp.eq_s_b(2, "ie")) {
+                        sbp.cursor = sbp.limit - v_2;
+                        break;
+                      }
+                    }
+                    sbp.cursor = sbp.limit - v_2;
+                    if (sbp.cursor <= sbp.limit_backward) {
+                      sbp.cursor = sbp.limit - v_2;
+                      break;
+                    }
+                    sbp.cursor--;
+                    sbp.bra = sbp.cursor;
+                    break;
+                  case 8:
+                    if (!sbp.in_grouping_b(g_V1, 97, 246) ||
+                      !sbp.out_grouping_b(g_V1, 97, 246))
+                      return;
+                    break;
+                }
+                sbp.slice_del();
+                B_ending_removed = true;
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_other_endings() {
+            var among_var, v_1, v_2;
+            if (sbp.cursor >= I_p2) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p2;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_7, 14);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_1;
+                if (among_var == 1) {
+                  v_2 = sbp.limit - sbp.cursor;
+                  if (sbp.eq_s_b(2, "po"))
+                    return;
+                  sbp.cursor = sbp.limit - v_2;
+                }
+                sbp.slice_del();
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_i_plural() {
+            var v_1;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              if (sbp.find_among_b(a_8, 2)) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_1;
+                sbp.slice_del();
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_t_plural() {
+            var among_var, v_1, v_2, v_3, v_4, v_5;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              if (sbp.eq_s_b(1, "t")) {
+                sbp.bra = sbp.cursor;
+                v_2 = sbp.limit - sbp.cursor;
+                if (sbp.in_grouping_b(g_V1, 97, 246)) {
+                  sbp.cursor = sbp.limit - v_2;
+                  sbp.slice_del();
+                  sbp.limit_backward = v_1;
+                  v_3 = sbp.limit - sbp.cursor;
+                  if (sbp.cursor >= I_p2) {
+                    sbp.cursor = I_p2;
+                    v_4 = sbp.limit_backward;
+                    sbp.limit_backward = sbp.cursor;
+                    sbp.cursor = sbp.limit - v_3;
+                    sbp.ket = sbp.cursor;
+                    among_var = sbp.find_among_b(a_9, 2);
+                    if (among_var) {
+                      sbp.bra = sbp.cursor;
+                      sbp.limit_backward = v_4;
+                      if (among_var == 1) {
+                        v_5 = sbp.limit - sbp.cursor;
+                        if (sbp.eq_s_b(2, "po"))
+                          return;
+                        sbp.cursor = sbp.limit - v_5;
+                      }
+                      sbp.slice_del();
+                      return;
+                    }
+                  }
+                }
+              }
+              sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_tidy() {
+            var v_1, v_2, v_3, v_4;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              v_2 = sbp.limit - sbp.cursor;
+              if (r_LONG()) {
+                sbp.cursor = sbp.limit - v_2;
+                sbp.ket = sbp.cursor;
+                if (sbp.cursor > sbp.limit_backward) {
+                  sbp.cursor--;
+                  sbp.bra = sbp.cursor;
+                  sbp.slice_del();
+                }
+              }
+              sbp.cursor = sbp.limit - v_2;
+              sbp.ket = sbp.cursor;
+              if (sbp.in_grouping_b(g_AEI, 97, 228)) {
+                sbp.bra = sbp.cursor;
+                if (sbp.out_grouping_b(g_V1, 97, 246))
+                  sbp.slice_del();
+              }
+              sbp.cursor = sbp.limit - v_2;
+              sbp.ket = sbp.cursor;
+              if (sbp.eq_s_b(1, "j")) {
+                sbp.bra = sbp.cursor;
+                v_3 = sbp.limit - sbp.cursor;
+                if (!sbp.eq_s_b(1, "o")) {
+                  sbp.cursor = sbp.limit - v_3;
+                  if (sbp.eq_s_b(1, "u"))
+                    sbp.slice_del();
+                } else
+                  sbp.slice_del();
+              }
+              sbp.cursor = sbp.limit - v_2;
+              sbp.ket = sbp.cursor;
+              if (sbp.eq_s_b(1, "o")) {
+                sbp.bra = sbp.cursor;
+                if (sbp.eq_s_b(1, "j"))
+                  sbp.slice_del();
+              }
+              sbp.cursor = sbp.limit - v_2;
+              sbp.limit_backward = v_1;
+              while (true) {
+                v_4 = sbp.limit - sbp.cursor;
+                if (sbp.out_grouping_b(g_V1, 97, 246)) {
+                  sbp.cursor = sbp.limit - v_4;
+                  break;
+                }
+                sbp.cursor = sbp.limit - v_4;
+                if (sbp.cursor <= sbp.limit_backward)
+                  return;
+                sbp.cursor--;
+              }
+              sbp.ket = sbp.cursor;
+              if (sbp.cursor > sbp.limit_backward) {
+                sbp.cursor--;
+                sbp.bra = sbp.cursor;
+                S_x = sbp.slice_to();
+                if (sbp.eq_v_b(S_x))
+                  sbp.slice_del();
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_mark_regions();
+            B_ending_removed = false;
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_particle_etc();
+            sbp.cursor = sbp.limit;
+            r_possessive();
+            sbp.cursor = sbp.limit;
+            r_case_ending();
+            sbp.cursor = sbp.limit;
+            r_other_endings();
+            sbp.cursor = sbp.limit;
+            if (B_ending_removed) {
+              r_i_plural();
+              sbp.cursor = sbp.limit;
+            } else {
+              sbp.cursor = sbp.limit;
+              r_t_plural();
+              sbp.cursor = sbp.limit;
+            }
+            r_tidy();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.fi.stemmer, 'stemmer-fi');
+
+    lunr.fi.stopWordFilter = lunr.generateStopWordFilter('ei eivät emme en et ette että he heidän heidät heihin heille heillä heiltä heissä heistä heitä hän häneen hänelle hänellä häneltä hänen hänessä hänestä hänet häntä itse ja johon joiden joihin joiksi joilla joille joilta joina joissa joista joita joka joksi jolla jolle jolta jona jonka jos jossa josta jota jotka kanssa keiden keihin keiksi keille keillä keiltä keinä keissä keistä keitä keneen keneksi kenelle kenellä keneltä kenen kenenä kenessä kenestä kenet ketkä ketkä ketä koska kuin kuka kun me meidän meidät meihin meille meillä meiltä meissä meistä meitä mihin miksi mikä mille millä miltä minkä minkä minua minulla minulle minulta minun minussa minusta minut minuun minä minä missä mistä mitkä mitä mukaan mutta ne niiden niihin niiksi niille niillä niiltä niin niin niinä niissä niistä niitä noiden noihin noiksi noilla noille noilta noin noina noissa noista noita nuo nyt näiden näihin näiksi näille näillä näiltä näinä näissä näistä näitä nämä ole olemme olen olet olette oli olimme olin olisi olisimme olisin olisit olisitte olisivat olit olitte olivat olla olleet ollut on ovat poikki se sekä sen siihen siinä siitä siksi sille sillä sillä siltä sinua sinulla sinulle sinulta sinun sinussa sinusta sinut sinuun sinä sinä sitä tai te teidän teidät teihin teille teillä teiltä teissä teistä teitä tuo tuohon tuoksi tuolla tuolle tuolta tuon tuona tuossa tuosta tuota tähän täksi tälle tällä tältä tämä tämän tänä tässä tästä tätä vaan vai vaikka yli'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.fi.stopWordFilter, 'stopWordFilter-fi');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.fr.js

@@ -0,0 +1,703 @@
+/*!
+ * Lunr languages, `French` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.fr = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.fr.trimmer,
+        lunr.fr.stopWordFilter,
+        lunr.fr.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.fr.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.fr.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.fr.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.fr.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.fr.trimmer, 'trimmer-fr');
+
+    /* lunr stemmer function */
+    lunr.fr.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function FrenchStemmer() {
+          var a_0 = [new Among("col", -1, -1), new Among("par", -1, -1),
+              new Among("tap", -1, -1)
+            ],
+            a_1 = [new Among("", -1, 4),
+              new Among("I", 0, 1), new Among("U", 0, 2), new Among("Y", 0, 3)
+            ],
+            a_2 = [
+              new Among("iqU", -1, 3), new Among("abl", -1, 3),
+              new Among("I\u00E8r", -1, 4), new Among("i\u00E8r", -1, 4),
+              new Among("eus", -1, 2), new Among("iv", -1, 1)
+            ],
+            a_3 = [
+              new Among("ic", -1, 2), new Among("abil", -1, 1),
+              new Among("iv", -1, 3)
+            ],
+            a_4 = [new Among("iqUe", -1, 1),
+              new Among("atrice", -1, 2), new Among("ance", -1, 1),
+              new Among("ence", -1, 5), new Among("logie", -1, 3),
+              new Among("able", -1, 1), new Among("isme", -1, 1),
+              new Among("euse", -1, 11), new Among("iste", -1, 1),
+              new Among("ive", -1, 8), new Among("if", -1, 8),
+              new Among("usion", -1, 4), new Among("ation", -1, 2),
+              new Among("ution", -1, 4), new Among("ateur", -1, 2),
+              new Among("iqUes", -1, 1), new Among("atrices", -1, 2),
+              new Among("ances", -1, 1), new Among("ences", -1, 5),
+              new Among("logies", -1, 3), new Among("ables", -1, 1),
+              new Among("ismes", -1, 1), new Among("euses", -1, 11),
+              new Among("istes", -1, 1), new Among("ives", -1, 8),
+              new Among("ifs", -1, 8), new Among("usions", -1, 4),
+              new Among("ations", -1, 2), new Among("utions", -1, 4),
+              new Among("ateurs", -1, 2), new Among("ments", -1, 15),
+              new Among("ements", 30, 6), new Among("issements", 31, 12),
+              new Among("it\u00E9s", -1, 7), new Among("ment", -1, 15),
+              new Among("ement", 34, 6), new Among("issement", 35, 12),
+              new Among("amment", 34, 13), new Among("emment", 34, 14),
+              new Among("aux", -1, 10), new Among("eaux", 39, 9),
+              new Among("eux", -1, 1), new Among("it\u00E9", -1, 7)
+            ],
+            a_5 = [
+              new Among("ira", -1, 1), new Among("ie", -1, 1),
+              new Among("isse", -1, 1), new Among("issante", -1, 1),
+              new Among("i", -1, 1), new Among("irai", 4, 1),
+              new Among("ir", -1, 1), new Among("iras", -1, 1),
+              new Among("ies", -1, 1), new Among("\u00EEmes", -1, 1),
+              new Among("isses", -1, 1), new Among("issantes", -1, 1),
+              new Among("\u00EEtes", -1, 1), new Among("is", -1, 1),
+              new Among("irais", 13, 1), new Among("issais", 13, 1),
+              new Among("irions", -1, 1), new Among("issions", -1, 1),
+              new Among("irons", -1, 1), new Among("issons", -1, 1),
+              new Among("issants", -1, 1), new Among("it", -1, 1),
+              new Among("irait", 21, 1), new Among("issait", 21, 1),
+              new Among("issant", -1, 1), new Among("iraIent", -1, 1),
+              new Among("issaIent", -1, 1), new Among("irent", -1, 1),
+              new Among("issent", -1, 1), new Among("iront", -1, 1),
+              new Among("\u00EEt", -1, 1), new Among("iriez", -1, 1),
+              new Among("issiez", -1, 1), new Among("irez", -1, 1),
+              new Among("issez", -1, 1)
+            ],
+            a_6 = [new Among("a", -1, 3),
+              new Among("era", 0, 2), new Among("asse", -1, 3),
+              new Among("ante", -1, 3), new Among("\u00E9e", -1, 2),
+              new Among("ai", -1, 3), new Among("erai", 5, 2),
+              new Among("er", -1, 2), new Among("as", -1, 3),
+              new Among("eras", 8, 2), new Among("\u00E2mes", -1, 3),
+              new Among("asses", -1, 3), new Among("antes", -1, 3),
+              new Among("\u00E2tes", -1, 3), new Among("\u00E9es", -1, 2),
+              new Among("ais", -1, 3), new Among("erais", 15, 2),
+              new Among("ions", -1, 1), new Among("erions", 17, 2),
+              new Among("assions", 17, 3), new Among("erons", -1, 2),
+              new Among("ants", -1, 3), new Among("\u00E9s", -1, 2),
+              new Among("ait", -1, 3), new Among("erait", 23, 2),
+              new Among("ant", -1, 3), new Among("aIent", -1, 3),
+              new Among("eraIent", 26, 2), new Among("\u00E8rent", -1, 2),
+              new Among("assent", -1, 3), new Among("eront", -1, 2),
+              new Among("\u00E2t", -1, 3), new Among("ez", -1, 2),
+              new Among("iez", 32, 2), new Among("eriez", 33, 2),
+              new Among("assiez", 33, 3), new Among("erez", 32, 2),
+              new Among("\u00E9", -1, 2)
+            ],
+            a_7 = [new Among("e", -1, 3),
+              new Among("I\u00E8re", 0, 2), new Among("i\u00E8re", 0, 2),
+              new Among("ion", -1, 1), new Among("Ier", -1, 2),
+              new Among("ier", -1, 2), new Among("\u00EB", -1, 4)
+            ],
+            a_8 = [
+              new Among("ell", -1, -1), new Among("eill", -1, -1),
+              new Among("enn", -1, -1), new Among("onn", -1, -1),
+              new Among("ett", -1, -1)
+            ],
+            g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 128, 130, 103, 8, 5
+            ],
+            g_keep_with_s = [1, 65, 20, 0,
+              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            I_p2, I_p1, I_pV, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function habr1(c1, c2, v_1) {
+            if (sbp.eq_s(1, c1)) {
+              sbp.ket = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 251)) {
+                sbp.slice_from(c2);
+                sbp.cursor = v_1;
+                return true;
+              }
+            }
+            return false;
+          }
+
+          function habr2(c1, c2, v_1) {
+            if (sbp.eq_s(1, c1)) {
+              sbp.ket = sbp.cursor;
+              sbp.slice_from(c2);
+              sbp.cursor = v_1;
+              return true;
+            }
+            return false;
+          }
+
+          function r_prelude() {
+            var v_1, v_2;
+            while (true) {
+              v_1 = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 251)) {
+                sbp.bra = sbp.cursor;
+                v_2 = sbp.cursor;
+                if (habr1("u", "U", v_1))
+                  continue;
+                sbp.cursor = v_2;
+                if (habr1("i", "I", v_1))
+                  continue;
+                sbp.cursor = v_2;
+                if (habr2("y", "Y", v_1))
+                  continue;
+              }
+              sbp.cursor = v_1;
+              sbp.bra = v_1;
+              if (!habr1("y", "Y", v_1)) {
+                sbp.cursor = v_1;
+                if (sbp.eq_s(1, "q")) {
+                  sbp.bra = sbp.cursor;
+                  if (habr2("u", "U", v_1))
+                    continue;
+                }
+                sbp.cursor = v_1;
+                if (v_1 >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+            }
+          }
+
+          function habr3() {
+            while (!sbp.in_grouping(g_v, 97, 251)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 251)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            return false;
+          }
+
+          function r_mark_regions() {
+            var v_1 = sbp.cursor;
+            I_pV = sbp.limit;
+            I_p1 = I_pV;
+            I_p2 = I_pV;
+            if (sbp.in_grouping(g_v, 97, 251) && sbp.in_grouping(g_v, 97, 251) &&
+              sbp.cursor < sbp.limit)
+              sbp.cursor++;
+            else {
+              sbp.cursor = v_1;
+              if (!sbp.find_among(a_0, 3)) {
+                sbp.cursor = v_1;
+                do {
+                  if (sbp.cursor >= sbp.limit) {
+                    sbp.cursor = I_pV;
+                    break;
+                  }
+                  sbp.cursor++;
+                } while (!sbp.in_grouping(g_v, 97, 251));
+              }
+            }
+            I_pV = sbp.cursor;
+            sbp.cursor = v_1;
+            if (!habr3()) {
+              I_p1 = sbp.cursor;
+              if (!habr3())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function r_postlude() {
+            var among_var, v_1;
+            while (true) {
+              v_1 = sbp.cursor;
+              sbp.bra = v_1;
+              among_var = sbp.find_among(a_1, 4);
+              if (!among_var)
+                break;
+              sbp.ket = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  sbp.slice_from("i");
+                  break;
+                case 2:
+                  sbp.slice_from("u");
+                  break;
+                case 3:
+                  sbp.slice_from("y");
+                  break;
+                case 4:
+                  if (sbp.cursor >= sbp.limit)
+                    return;
+                  sbp.cursor++;
+                  break;
+              }
+            }
+          }
+
+          function r_RV() {
+            return I_pV <= sbp.cursor;
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_standard_suffix() {
+            var among_var, v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_4, 43);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_del();
+                  break;
+                case 2:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  if (sbp.eq_s_b(2, "ic")) {
+                    sbp.bra = sbp.cursor;
+                    if (!r_R2())
+                      sbp.slice_from("iqU");
+                    else
+                      sbp.slice_del();
+                  }
+                  break;
+                case 3:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_from("log");
+                  break;
+                case 4:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_from("u");
+                  break;
+                case 5:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_from("ent");
+                  break;
+                case 6:
+                  if (!r_RV())
+                    return false;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  among_var = sbp.find_among_b(a_2, 6);
+                  if (among_var) {
+                    sbp.bra = sbp.cursor;
+                    switch (among_var) {
+                      case 1:
+                        if (r_R2()) {
+                          sbp.slice_del();
+                          sbp.ket = sbp.cursor;
+                          if (sbp.eq_s_b(2, "at")) {
+                            sbp.bra = sbp.cursor;
+                            if (r_R2())
+                              sbp.slice_del();
+                          }
+                        }
+                        break;
+                      case 2:
+                        if (r_R2())
+                          sbp.slice_del();
+                        else if (r_R1())
+                          sbp.slice_from("eux");
+                        break;
+                      case 3:
+                        if (r_R2())
+                          sbp.slice_del();
+                        break;
+                      case 4:
+                        if (r_RV())
+                          sbp.slice_from("i");
+                        break;
+                    }
+                  }
+                  break;
+                case 7:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  among_var = sbp.find_among_b(a_3, 3);
+                  if (among_var) {
+                    sbp.bra = sbp.cursor;
+                    switch (among_var) {
+                      case 1:
+                        if (r_R2())
+                          sbp.slice_del();
+                        else
+                          sbp.slice_from("abl");
+                        break;
+                      case 2:
+                        if (r_R2())
+                          sbp.slice_del();
+                        else
+                          sbp.slice_from("iqU");
+                        break;
+                      case 3:
+                        if (r_R2())
+                          sbp.slice_del();
+                        break;
+                    }
+                  }
+                  break;
+                case 8:
+                  if (!r_R2())
+                    return false;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  if (sbp.eq_s_b(2, "at")) {
+                    sbp.bra = sbp.cursor;
+                    if (r_R2()) {
+                      sbp.slice_del();
+                      sbp.ket = sbp.cursor;
+                      if (sbp.eq_s_b(2, "ic")) {
+                        sbp.bra = sbp.cursor;
+                        if (r_R2())
+                          sbp.slice_del();
+                        else
+                          sbp.slice_from("iqU");
+                        break;
+                      }
+                    }
+                  }
+                  break;
+                case 9:
+                  sbp.slice_from("eau");
+                  break;
+                case 10:
+                  if (!r_R1())
+                    return false;
+                  sbp.slice_from("al");
+                  break;
+                case 11:
+                  if (r_R2())
+                    sbp.slice_del();
+                  else if (!r_R1())
+                    return false;
+                  else
+                    sbp.slice_from("eux");
+                  break;
+                case 12:
+                  if (!r_R1() || !sbp.out_grouping_b(g_v, 97, 251))
+                    return false;
+                  sbp.slice_del();
+                  break;
+                case 13:
+                  if (r_RV())
+                    sbp.slice_from("ant");
+                  return false;
+                case 14:
+                  if (r_RV())
+                    sbp.slice_from("ent");
+                  return false;
+                case 15:
+                  v_1 = sbp.limit - sbp.cursor;
+                  if (sbp.in_grouping_b(g_v, 97, 251) && r_RV()) {
+                    sbp.cursor = sbp.limit - v_1;
+                    sbp.slice_del();
+                  }
+                  return false;
+              }
+              return true;
+            }
+            return false;
+          }
+
+          function r_i_verb_suffix() {
+            var among_var, v_1;
+            if (sbp.cursor < I_pV)
+              return false;
+            v_1 = sbp.limit_backward;
+            sbp.limit_backward = I_pV;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_5, 35);
+            if (!among_var) {
+              sbp.limit_backward = v_1;
+              return false;
+            }
+            sbp.bra = sbp.cursor;
+            if (among_var == 1) {
+              if (!sbp.out_grouping_b(g_v, 97, 251)) {
+                sbp.limit_backward = v_1;
+                return false;
+              }
+              sbp.slice_del();
+            }
+            sbp.limit_backward = v_1;
+            return true;
+          }
+
+          function r_verb_suffix() {
+            var among_var, v_2, v_3;
+            if (sbp.cursor < I_pV)
+              return false;
+            v_2 = sbp.limit_backward;
+            sbp.limit_backward = I_pV;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_6, 38);
+            if (!among_var) {
+              sbp.limit_backward = v_2;
+              return false;
+            }
+            sbp.bra = sbp.cursor;
+            switch (among_var) {
+              case 1:
+                if (!r_R2()) {
+                  sbp.limit_backward = v_2;
+                  return false;
+                }
+                sbp.slice_del();
+                break;
+              case 2:
+                sbp.slice_del();
+                break;
+              case 3:
+                sbp.slice_del();
+                v_3 = sbp.limit - sbp.cursor;
+                sbp.ket = sbp.cursor;
+                if (sbp.eq_s_b(1, "e")) {
+                  sbp.bra = sbp.cursor;
+                  sbp.slice_del();
+                } else
+                  sbp.cursor = sbp.limit - v_3;
+                break;
+            }
+            sbp.limit_backward = v_2;
+            return true;
+          }
+
+          function r_residual_suffix() {
+            var among_var, v_1 = sbp.limit - sbp.cursor,
+              v_2, v_4, v_5;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "s")) {
+              sbp.bra = sbp.cursor;
+              v_2 = sbp.limit - sbp.cursor;
+              if (sbp.out_grouping_b(g_keep_with_s, 97, 232)) {
+                sbp.cursor = sbp.limit - v_2;
+                sbp.slice_del();
+              } else
+                sbp.cursor = sbp.limit - v_1;
+            } else
+              sbp.cursor = sbp.limit - v_1;
+            if (sbp.cursor >= I_pV) {
+              v_4 = sbp.limit_backward;
+              sbp.limit_backward = I_pV;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_7, 7);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    if (r_R2()) {
+                      v_5 = sbp.limit - sbp.cursor;
+                      if (!sbp.eq_s_b(1, "s")) {
+                        sbp.cursor = sbp.limit - v_5;
+                        if (!sbp.eq_s_b(1, "t"))
+                          break;
+                      }
+                      sbp.slice_del();
+                    }
+                    break;
+                  case 2:
+                    sbp.slice_from("i");
+                    break;
+                  case 3:
+                    sbp.slice_del();
+                    break;
+                  case 4:
+                    if (sbp.eq_s_b(2, "gu"))
+                      sbp.slice_del();
+                    break;
+                }
+              }
+              sbp.limit_backward = v_4;
+            }
+          }
+
+          function r_un_double() {
+            var v_1 = sbp.limit - sbp.cursor;
+            if (sbp.find_among_b(a_8, 5)) {
+              sbp.cursor = sbp.limit - v_1;
+              sbp.ket = sbp.cursor;
+              if (sbp.cursor > sbp.limit_backward) {
+                sbp.cursor--;
+                sbp.bra = sbp.cursor;
+                sbp.slice_del();
+              }
+            }
+          }
+
+          function r_un_accent() {
+            var v_1, v_2 = 1;
+            while (sbp.out_grouping_b(g_v, 97, 251))
+              v_2--;
+            if (v_2 <= 0) {
+              sbp.ket = sbp.cursor;
+              v_1 = sbp.limit - sbp.cursor;
+              if (!sbp.eq_s_b(1, "\u00E9")) {
+                sbp.cursor = sbp.limit - v_1;
+                if (!sbp.eq_s_b(1, "\u00E8"))
+                  return;
+              }
+              sbp.bra = sbp.cursor;
+              sbp.slice_from("e");
+            }
+          }
+
+          function habr5() {
+            if (!r_standard_suffix()) {
+              sbp.cursor = sbp.limit;
+              if (!r_i_verb_suffix()) {
+                sbp.cursor = sbp.limit;
+                if (!r_verb_suffix()) {
+                  sbp.cursor = sbp.limit;
+                  r_residual_suffix();
+                  return;
+                }
+              }
+            }
+            sbp.cursor = sbp.limit;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "Y")) {
+              sbp.bra = sbp.cursor;
+              sbp.slice_from("i");
+            } else {
+              sbp.cursor = sbp.limit;
+              if (sbp.eq_s_b(1, "\u00E7")) {
+                sbp.bra = sbp.cursor;
+                sbp.slice_from("c");
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            habr5();
+            sbp.cursor = sbp.limit;
+            r_un_double();
+            sbp.cursor = sbp.limit;
+            r_un_accent();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.fr.stemmer, 'stemmer-fr');
+
+    lunr.fr.stopWordFilter = lunr.generateStopWordFilter('ai aie aient aies ait as au aura aurai auraient aurais aurait auras aurez auriez aurions aurons auront aux avaient avais avait avec avez aviez avions avons ayant ayez ayons c ce ceci celà ces cet cette d dans de des du elle en es est et eu eue eues eurent eus eusse eussent eusses eussiez eussions eut eux eûmes eût eûtes furent fus fusse fussent fusses fussiez fussions fut fûmes fût fûtes ici il ils j je l la le les leur leurs lui m ma mais me mes moi mon même n ne nos notre nous on ont ou par pas pour qu que quel quelle quelles quels qui s sa sans se sera serai seraient serais serait seras serez seriez serions serons seront ses soi soient sois soit sommes son sont soyez soyons suis sur t ta te tes toi ton tu un une vos votre vous y à étaient étais était étant étiez étions été étée étées étés êtes'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.fr.stopWordFilter, 'stopWordFilter-fr');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.hu.js

@@ -0,0 +1,565 @@
+/*!
+ * Lunr languages, `Hungarian` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.hu = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.hu.trimmer,
+        lunr.hu.stopWordFilter,
+        lunr.hu.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.hu.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.hu.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.hu.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.hu.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.hu.trimmer, 'trimmer-hu');
+
+    /* lunr stemmer function */
+    lunr.hu.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function HungarianStemmer() {
+          var a_0 = [new Among("cs", -1, -1), new Among("dzs", -1, -1),
+              new Among("gy", -1, -1), new Among("ly", -1, -1),
+              new Among("ny", -1, -1), new Among("sz", -1, -1),
+              new Among("ty", -1, -1), new Among("zs", -1, -1)
+            ],
+            a_1 = [
+              new Among("\u00E1", -1, 1), new Among("\u00E9", -1, 2)
+            ],
+            a_2 = [
+              new Among("bb", -1, -1), new Among("cc", -1, -1),
+              new Among("dd", -1, -1), new Among("ff", -1, -1),
+              new Among("gg", -1, -1), new Among("jj", -1, -1),
+              new Among("kk", -1, -1), new Among("ll", -1, -1),
+              new Among("mm", -1, -1), new Among("nn", -1, -1),
+              new Among("pp", -1, -1), new Among("rr", -1, -1),
+              new Among("ccs", -1, -1), new Among("ss", -1, -1),
+              new Among("zzs", -1, -1), new Among("tt", -1, -1),
+              new Among("vv", -1, -1), new Among("ggy", -1, -1),
+              new Among("lly", -1, -1), new Among("nny", -1, -1),
+              new Among("tty", -1, -1), new Among("ssz", -1, -1),
+              new Among("zz", -1, -1)
+            ],
+            a_3 = [new Among("al", -1, 1),
+              new Among("el", -1, 2)
+            ],
+            a_4 = [new Among("ba", -1, -1),
+              new Among("ra", -1, -1), new Among("be", -1, -1),
+              new Among("re", -1, -1), new Among("ig", -1, -1),
+              new Among("nak", -1, -1), new Among("nek", -1, -1),
+              new Among("val", -1, -1), new Among("vel", -1, -1),
+              new Among("ul", -1, -1), new Among("n\u00E1l", -1, -1),
+              new Among("n\u00E9l", -1, -1), new Among("b\u00F3l", -1, -1),
+              new Among("r\u00F3l", -1, -1), new Among("t\u00F3l", -1, -1),
+              new Among("b\u00F5l", -1, -1), new Among("r\u00F5l", -1, -1),
+              new Among("t\u00F5l", -1, -1), new Among("\u00FCl", -1, -1),
+              new Among("n", -1, -1), new Among("an", 19, -1),
+              new Among("ban", 20, -1), new Among("en", 19, -1),
+              new Among("ben", 22, -1), new Among("k\u00E9ppen", 22, -1),
+              new Among("on", 19, -1), new Among("\u00F6n", 19, -1),
+              new Among("k\u00E9pp", -1, -1), new Among("kor", -1, -1),
+              new Among("t", -1, -1), new Among("at", 29, -1),
+              new Among("et", 29, -1), new Among("k\u00E9nt", 29, -1),
+              new Among("ank\u00E9nt", 32, -1), new Among("enk\u00E9nt", 32, -1),
+              new Among("onk\u00E9nt", 32, -1), new Among("ot", 29, -1),
+              new Among("\u00E9rt", 29, -1), new Among("\u00F6t", 29, -1),
+              new Among("hez", -1, -1), new Among("hoz", -1, -1),
+              new Among("h\u00F6z", -1, -1), new Among("v\u00E1", -1, -1),
+              new Among("v\u00E9", -1, -1)
+            ],
+            a_5 = [new Among("\u00E1n", -1, 2),
+              new Among("\u00E9n", -1, 1), new Among("\u00E1nk\u00E9nt", -1, 3)
+            ],
+            a_6 = [
+              new Among("stul", -1, 2), new Among("astul", 0, 1),
+              new Among("\u00E1stul", 0, 3), new Among("st\u00FCl", -1, 2),
+              new Among("est\u00FCl", 3, 1), new Among("\u00E9st\u00FCl", 3, 4)
+            ],
+            a_7 = [
+              new Among("\u00E1", -1, 1), new Among("\u00E9", -1, 2)
+            ],
+            a_8 = [
+              new Among("k", -1, 7), new Among("ak", 0, 4),
+              new Among("ek", 0, 6), new Among("ok", 0, 5),
+              new Among("\u00E1k", 0, 1), new Among("\u00E9k", 0, 2),
+              new Among("\u00F6k", 0, 3)
+            ],
+            a_9 = [new Among("\u00E9i", -1, 7),
+              new Among("\u00E1\u00E9i", 0, 6), new Among("\u00E9\u00E9i", 0, 5),
+              new Among("\u00E9", -1, 9), new Among("k\u00E9", 3, 4),
+              new Among("ak\u00E9", 4, 1), new Among("ek\u00E9", 4, 1),
+              new Among("ok\u00E9", 4, 1), new Among("\u00E1k\u00E9", 4, 3),
+              new Among("\u00E9k\u00E9", 4, 2), new Among("\u00F6k\u00E9", 4, 1),
+              new Among("\u00E9\u00E9", 3, 8)
+            ],
+            a_10 = [new Among("a", -1, 18),
+              new Among("ja", 0, 17), new Among("d", -1, 16),
+              new Among("ad", 2, 13), new Among("ed", 2, 13),
+              new Among("od", 2, 13), new Among("\u00E1d", 2, 14),
+              new Among("\u00E9d", 2, 15), new Among("\u00F6d", 2, 13),
+              new Among("e", -1, 18), new Among("je", 9, 17),
+              new Among("nk", -1, 4), new Among("unk", 11, 1),
+              new Among("\u00E1nk", 11, 2), new Among("\u00E9nk", 11, 3),
+              new Among("\u00FCnk", 11, 1), new Among("uk", -1, 8),
+              new Among("juk", 16, 7), new Among("\u00E1juk", 17, 5),
+              new Among("\u00FCk", -1, 8), new Among("j\u00FCk", 19, 7),
+              new Among("\u00E9j\u00FCk", 20, 6), new Among("m", -1, 12),
+              new Among("am", 22, 9), new Among("em", 22, 9),
+              new Among("om", 22, 9), new Among("\u00E1m", 22, 10),
+              new Among("\u00E9m", 22, 11), new Among("o", -1, 18),
+              new Among("\u00E1", -1, 19), new Among("\u00E9", -1, 20)
+            ],
+            a_11 = [
+              new Among("id", -1, 10), new Among("aid", 0, 9),
+              new Among("jaid", 1, 6), new Among("eid", 0, 9),
+              new Among("jeid", 3, 6), new Among("\u00E1id", 0, 7),
+              new Among("\u00E9id", 0, 8), new Among("i", -1, 15),
+              new Among("ai", 7, 14), new Among("jai", 8, 11),
+              new Among("ei", 7, 14), new Among("jei", 10, 11),
+              new Among("\u00E1i", 7, 12), new Among("\u00E9i", 7, 13),
+              new Among("itek", -1, 24), new Among("eitek", 14, 21),
+              new Among("jeitek", 15, 20), new Among("\u00E9itek", 14, 23),
+              new Among("ik", -1, 29), new Among("aik", 18, 26),
+              new Among("jaik", 19, 25), new Among("eik", 18, 26),
+              new Among("jeik", 21, 25), new Among("\u00E1ik", 18, 27),
+              new Among("\u00E9ik", 18, 28), new Among("ink", -1, 20),
+              new Among("aink", 25, 17), new Among("jaink", 26, 16),
+              new Among("eink", 25, 17), new Among("jeink", 28, 16),
+              new Among("\u00E1ink", 25, 18), new Among("\u00E9ink", 25, 19),
+              new Among("aitok", -1, 21), new Among("jaitok", 32, 20),
+              new Among("\u00E1itok", -1, 22), new Among("im", -1, 5),
+              new Among("aim", 35, 4), new Among("jaim", 36, 1),
+              new Among("eim", 35, 4), new Among("jeim", 38, 1),
+              new Among("\u00E1im", 35, 2), new Among("\u00E9im", 35, 3)
+            ],
+            g_v = [
+              17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 52, 14
+            ],
+            I_p1, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_mark_regions() {
+            var v_1 = sbp.cursor,
+              v_2;
+            I_p1 = sbp.limit;
+            if (sbp.in_grouping(g_v, 97, 252)) {
+              while (true) {
+                v_2 = sbp.cursor;
+                if (sbp.out_grouping(g_v, 97, 252)) {
+                  sbp.cursor = v_2;
+                  if (!sbp.find_among(a_0, 8)) {
+                    sbp.cursor = v_2;
+                    if (v_2 < sbp.limit)
+                      sbp.cursor++;
+                  }
+                  I_p1 = sbp.cursor;
+                  return;
+                }
+                sbp.cursor = v_2;
+                if (v_2 >= sbp.limit) {
+                  I_p1 = v_2;
+                  return;
+                }
+                sbp.cursor++;
+              }
+            }
+            sbp.cursor = v_1;
+            if (sbp.out_grouping(g_v, 97, 252)) {
+              while (!sbp.in_grouping(g_v, 97, 252)) {
+                if (sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              I_p1 = sbp.cursor;
+            }
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_v_ending() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_1, 2);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("a");
+                    break;
+                  case 2:
+                    sbp.slice_from("e");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_double() {
+            var v_1 = sbp.limit - sbp.cursor;
+            if (!sbp.find_among_b(a_2, 23))
+              return false;
+            sbp.cursor = sbp.limit - v_1;
+            return true;
+          }
+
+          function r_undouble() {
+            if (sbp.cursor > sbp.limit_backward) {
+              sbp.cursor--;
+              sbp.ket = sbp.cursor;
+              var c = sbp.cursor - 1;
+              if (sbp.limit_backward <= c && c <= sbp.limit) {
+                sbp.cursor = c;
+                sbp.bra = c;
+                sbp.slice_del();
+              }
+            }
+          }
+
+          function r_instrum() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_3, 2);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                if (among_var == 1 || among_var == 2)
+                  if (!r_double())
+                    return;
+                sbp.slice_del();
+                r_undouble();
+              }
+            }
+          }
+
+          function r_case() {
+            sbp.ket = sbp.cursor;
+            if (sbp.find_among_b(a_4, 44)) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                sbp.slice_del();
+                r_v_ending();
+              }
+            }
+          }
+
+          function r_case_special() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_5, 3);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("e");
+                    break;
+                  case 2:
+                  case 3:
+                    sbp.slice_from("a");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_case_other() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_6, 6);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                  case 2:
+                    sbp.slice_del();
+                    break;
+                  case 3:
+                    sbp.slice_from("a");
+                    break;
+                  case 4:
+                    sbp.slice_from("e");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_factive() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_7, 2);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                if (among_var == 1 || among_var == 2)
+                  if (!r_double())
+                    return;
+                sbp.slice_del();
+                r_undouble()
+              }
+            }
+          }
+
+          function r_plural() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_8, 7);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("a");
+                    break;
+                  case 2:
+                    sbp.slice_from("e");
+                    break;
+                  case 3:
+                  case 4:
+                  case 5:
+                  case 6:
+                  case 7:
+                    sbp.slice_del();
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_owned() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_9, 12);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                  case 4:
+                  case 7:
+                  case 9:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                  case 5:
+                  case 8:
+                    sbp.slice_from("e");
+                    break;
+                  case 3:
+                  case 6:
+                    sbp.slice_from("a");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_sing_owner() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_10, 31);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                  case 4:
+                  case 7:
+                  case 8:
+                  case 9:
+                  case 12:
+                  case 13:
+                  case 16:
+                  case 17:
+                  case 18:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                  case 5:
+                  case 10:
+                  case 14:
+                  case 19:
+                    sbp.slice_from("a");
+                    break;
+                  case 3:
+                  case 6:
+                  case 11:
+                  case 15:
+                  case 20:
+                    sbp.slice_from("e");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_plur_owner() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_11, 42);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                  case 4:
+                  case 5:
+                  case 6:
+                  case 9:
+                  case 10:
+                  case 11:
+                  case 14:
+                  case 15:
+                  case 16:
+                  case 17:
+                  case 20:
+                  case 21:
+                  case 24:
+                  case 25:
+                  case 26:
+                  case 29:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                  case 7:
+                  case 12:
+                  case 18:
+                  case 22:
+                  case 27:
+                    sbp.slice_from("a");
+                    break;
+                  case 3:
+                  case 8:
+                  case 13:
+                  case 19:
+                  case 23:
+                  case 28:
+                    sbp.slice_from("e");
+                    break;
+                }
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_instrum();
+            sbp.cursor = sbp.limit;
+            r_case();
+            sbp.cursor = sbp.limit;
+            r_case_special();
+            sbp.cursor = sbp.limit;
+            r_case_other();
+            sbp.cursor = sbp.limit;
+            r_factive();
+            sbp.cursor = sbp.limit;
+            r_owned();
+            sbp.cursor = sbp.limit;
+            r_sing_owner();
+            sbp.cursor = sbp.limit;
+            r_plur_owner();
+            sbp.cursor = sbp.limit;
+            r_plural();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.hu.stemmer, 'stemmer-hu');
+
+    lunr.hu.stopWordFilter = lunr.generateStopWordFilter('a abban ahhoz ahogy ahol aki akik akkor alatt amely amelyek amelyekben amelyeket amelyet amelynek ami amikor amit amolyan amíg annak arra arról az azok azon azonban azt aztán azután azzal azért be belül benne bár cikk cikkek cikkeket csak de e ebben eddig egy egyes egyetlen egyik egyre egyéb egész ehhez ekkor el ellen elsõ elég elõ elõször elõtt emilyen ennek erre ez ezek ezen ezt ezzel ezért fel felé hanem hiszen hogy hogyan igen ill ill. illetve ilyen ilyenkor ismét ison itt jobban jó jól kell kellett keressünk keresztül ki kívül között közül legalább legyen lehet lehetett lenne lenni lesz lett maga magát majd majd meg mellett mely melyek mert mi mikor milyen minden mindenki mindent mindig mint mintha mit mivel miért most már más másik még míg nagy nagyobb nagyon ne nekem neki nem nincs néha néhány nélkül olyan ott pedig persze rá s saját sem semmi sok sokat sokkal szemben szerint szinte számára talán tehát teljes tovább továbbá több ugyanis utolsó után utána vagy vagyis vagyok valaki valami valamint való van vannak vele vissza viszont volna volt voltak voltam voltunk által általában át én éppen és így õ õk õket össze úgy új újabb újra'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.hu.stopWordFilter, 'stopWordFilter-hu');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.it.js

@@ -0,0 +1,617 @@
+/*!
+ * Lunr languages, `Italian` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.it = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.it.trimmer,
+        lunr.it.stopWordFilter,
+        lunr.it.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.it.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.it.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.it.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.it.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.it.trimmer, 'trimmer-it');
+
+    /* lunr stemmer function */
+    lunr.it.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function ItalianStemmer() {
+          var a_0 = [new Among("", -1, 7), new Among("qu", 0, 6),
+              new Among("\u00E1", 0, 1), new Among("\u00E9", 0, 2),
+              new Among("\u00ED", 0, 3), new Among("\u00F3", 0, 4),
+              new Among("\u00FA", 0, 5)
+            ],
+            a_1 = [new Among("", -1, 3),
+              new Among("I", 0, 1), new Among("U", 0, 2)
+            ],
+            a_2 = [
+              new Among("la", -1, -1), new Among("cela", 0, -1),
+              new Among("gliela", 0, -1), new Among("mela", 0, -1),
+              new Among("tela", 0, -1), new Among("vela", 0, -1),
+              new Among("le", -1, -1), new Among("cele", 6, -1),
+              new Among("gliele", 6, -1), new Among("mele", 6, -1),
+              new Among("tele", 6, -1), new Among("vele", 6, -1),
+              new Among("ne", -1, -1), new Among("cene", 12, -1),
+              new Among("gliene", 12, -1), new Among("mene", 12, -1),
+              new Among("sene", 12, -1), new Among("tene", 12, -1),
+              new Among("vene", 12, -1), new Among("ci", -1, -1),
+              new Among("li", -1, -1), new Among("celi", 20, -1),
+              new Among("glieli", 20, -1), new Among("meli", 20, -1),
+              new Among("teli", 20, -1), new Among("veli", 20, -1),
+              new Among("gli", 20, -1), new Among("mi", -1, -1),
+              new Among("si", -1, -1), new Among("ti", -1, -1),
+              new Among("vi", -1, -1), new Among("lo", -1, -1),
+              new Among("celo", 31, -1), new Among("glielo", 31, -1),
+              new Among("melo", 31, -1), new Among("telo", 31, -1),
+              new Among("velo", 31, -1)
+            ],
+            a_3 = [new Among("ando", -1, 1),
+              new Among("endo", -1, 1), new Among("ar", -1, 2),
+              new Among("er", -1, 2), new Among("ir", -1, 2)
+            ],
+            a_4 = [
+              new Among("ic", -1, -1), new Among("abil", -1, -1),
+              new Among("os", -1, -1), new Among("iv", -1, 1)
+            ],
+            a_5 = [
+              new Among("ic", -1, 1), new Among("abil", -1, 1),
+              new Among("iv", -1, 1)
+            ],
+            a_6 = [new Among("ica", -1, 1),
+              new Among("logia", -1, 3), new Among("osa", -1, 1),
+              new Among("ista", -1, 1), new Among("iva", -1, 9),
+              new Among("anza", -1, 1), new Among("enza", -1, 5),
+              new Among("ice", -1, 1), new Among("atrice", 7, 1),
+              new Among("iche", -1, 1), new Among("logie", -1, 3),
+              new Among("abile", -1, 1), new Among("ibile", -1, 1),
+              new Among("usione", -1, 4), new Among("azione", -1, 2),
+              new Among("uzione", -1, 4), new Among("atore", -1, 2),
+              new Among("ose", -1, 1), new Among("ante", -1, 1),
+              new Among("mente", -1, 1), new Among("amente", 19, 7),
+              new Among("iste", -1, 1), new Among("ive", -1, 9),
+              new Among("anze", -1, 1), new Among("enze", -1, 5),
+              new Among("ici", -1, 1), new Among("atrici", 25, 1),
+              new Among("ichi", -1, 1), new Among("abili", -1, 1),
+              new Among("ibili", -1, 1), new Among("ismi", -1, 1),
+              new Among("usioni", -1, 4), new Among("azioni", -1, 2),
+              new Among("uzioni", -1, 4), new Among("atori", -1, 2),
+              new Among("osi", -1, 1), new Among("anti", -1, 1),
+              new Among("amenti", -1, 6), new Among("imenti", -1, 6),
+              new Among("isti", -1, 1), new Among("ivi", -1, 9),
+              new Among("ico", -1, 1), new Among("ismo", -1, 1),
+              new Among("oso", -1, 1), new Among("amento", -1, 6),
+              new Among("imento", -1, 6), new Among("ivo", -1, 9),
+              new Among("it\u00E0", -1, 8), new Among("ist\u00E0", -1, 1),
+              new Among("ist\u00E8", -1, 1), new Among("ist\u00EC", -1, 1)
+            ],
+            a_7 = [
+              new Among("isca", -1, 1), new Among("enda", -1, 1),
+              new Among("ata", -1, 1), new Among("ita", -1, 1),
+              new Among("uta", -1, 1), new Among("ava", -1, 1),
+              new Among("eva", -1, 1), new Among("iva", -1, 1),
+              new Among("erebbe", -1, 1), new Among("irebbe", -1, 1),
+              new Among("isce", -1, 1), new Among("ende", -1, 1),
+              new Among("are", -1, 1), new Among("ere", -1, 1),
+              new Among("ire", -1, 1), new Among("asse", -1, 1),
+              new Among("ate", -1, 1), new Among("avate", 16, 1),
+              new Among("evate", 16, 1), new Among("ivate", 16, 1),
+              new Among("ete", -1, 1), new Among("erete", 20, 1),
+              new Among("irete", 20, 1), new Among("ite", -1, 1),
+              new Among("ereste", -1, 1), new Among("ireste", -1, 1),
+              new Among("ute", -1, 1), new Among("erai", -1, 1),
+              new Among("irai", -1, 1), new Among("isci", -1, 1),
+              new Among("endi", -1, 1), new Among("erei", -1, 1),
+              new Among("irei", -1, 1), new Among("assi", -1, 1),
+              new Among("ati", -1, 1), new Among("iti", -1, 1),
+              new Among("eresti", -1, 1), new Among("iresti", -1, 1),
+              new Among("uti", -1, 1), new Among("avi", -1, 1),
+              new Among("evi", -1, 1), new Among("ivi", -1, 1),
+              new Among("isco", -1, 1), new Among("ando", -1, 1),
+              new Among("endo", -1, 1), new Among("Yamo", -1, 1),
+              new Among("iamo", -1, 1), new Among("avamo", -1, 1),
+              new Among("evamo", -1, 1), new Among("ivamo", -1, 1),
+              new Among("eremo", -1, 1), new Among("iremo", -1, 1),
+              new Among("assimo", -1, 1), new Among("ammo", -1, 1),
+              new Among("emmo", -1, 1), new Among("eremmo", 54, 1),
+              new Among("iremmo", 54, 1), new Among("immo", -1, 1),
+              new Among("ano", -1, 1), new Among("iscano", 58, 1),
+              new Among("avano", 58, 1), new Among("evano", 58, 1),
+              new Among("ivano", 58, 1), new Among("eranno", -1, 1),
+              new Among("iranno", -1, 1), new Among("ono", -1, 1),
+              new Among("iscono", 65, 1), new Among("arono", 65, 1),
+              new Among("erono", 65, 1), new Among("irono", 65, 1),
+              new Among("erebbero", -1, 1), new Among("irebbero", -1, 1),
+              new Among("assero", -1, 1), new Among("essero", -1, 1),
+              new Among("issero", -1, 1), new Among("ato", -1, 1),
+              new Among("ito", -1, 1), new Among("uto", -1, 1),
+              new Among("avo", -1, 1), new Among("evo", -1, 1),
+              new Among("ivo", -1, 1), new Among("ar", -1, 1),
+              new Among("ir", -1, 1), new Among("er\u00E0", -1, 1),
+              new Among("ir\u00E0", -1, 1), new Among("er\u00F2", -1, 1),
+              new Among("ir\u00F2", -1, 1)
+            ],
+            g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 128, 128, 8, 2, 1
+            ],
+            g_AEIO = [17, 65, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 8, 2
+            ],
+            g_CG = [17],
+            I_p2, I_p1, I_pV, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function habr1(c1, c2, v_1) {
+            if (sbp.eq_s(1, c1)) {
+              sbp.ket = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 249)) {
+                sbp.slice_from(c2);
+                sbp.cursor = v_1;
+                return true;
+              }
+            }
+            return false;
+          }
+
+          function r_prelude() {
+            var among_var, v_1 = sbp.cursor,
+              v_2, v_3, v_4;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_0, 7);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("\u00E0");
+                    continue;
+                  case 2:
+                    sbp.slice_from("\u00E8");
+                    continue;
+                  case 3:
+                    sbp.slice_from("\u00EC");
+                    continue;
+                  case 4:
+                    sbp.slice_from("\u00F2");
+                    continue;
+                  case 5:
+                    sbp.slice_from("\u00F9");
+                    continue;
+                  case 6:
+                    sbp.slice_from("qU");
+                    continue;
+                  case 7:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+            sbp.cursor = v_1;
+            while (true) {
+              v_2 = sbp.cursor;
+              while (true) {
+                v_3 = sbp.cursor;
+                if (sbp.in_grouping(g_v, 97, 249)) {
+                  sbp.bra = sbp.cursor;
+                  v_4 = sbp.cursor;
+                  if (habr1("u", "U", v_3))
+                    break;
+                  sbp.cursor = v_4;
+                  if (habr1("i", "I", v_3))
+                    break;
+                }
+                sbp.cursor = v_3;
+                if (sbp.cursor >= sbp.limit) {
+                  sbp.cursor = v_2;
+                  return;
+                }
+                sbp.cursor++;
+              }
+            }
+          }
+
+          function habr2(v_1) {
+            sbp.cursor = v_1;
+            if (!sbp.in_grouping(g_v, 97, 249))
+              return false;
+            while (!sbp.out_grouping(g_v, 97, 249)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function habr3() {
+            if (sbp.in_grouping(g_v, 97, 249)) {
+              var v_1 = sbp.cursor;
+              if (sbp.out_grouping(g_v, 97, 249)) {
+                while (!sbp.in_grouping(g_v, 97, 249)) {
+                  if (sbp.cursor >= sbp.limit)
+                    return habr2(v_1);
+                  sbp.cursor++;
+                }
+                return true;
+              }
+              return habr2(v_1);
+            }
+            return false;
+          }
+
+          function habr4() {
+            var v_1 = sbp.cursor,
+              v_2;
+            if (!habr3()) {
+              sbp.cursor = v_1;
+              if (!sbp.out_grouping(g_v, 97, 249))
+                return;
+              v_2 = sbp.cursor;
+              if (sbp.out_grouping(g_v, 97, 249)) {
+                while (!sbp.in_grouping(g_v, 97, 249)) {
+                  if (sbp.cursor >= sbp.limit) {
+                    sbp.cursor = v_2;
+                    if (sbp.in_grouping(g_v, 97, 249) &&
+                      sbp.cursor < sbp.limit)
+                      sbp.cursor++;
+                    return;
+                  }
+                  sbp.cursor++;
+                }
+                I_pV = sbp.cursor;
+                return;
+              }
+              sbp.cursor = v_2;
+              if (!sbp.in_grouping(g_v, 97, 249) || sbp.cursor >= sbp.limit)
+                return;
+              sbp.cursor++;
+            }
+            I_pV = sbp.cursor;
+          }
+
+          function habr5() {
+            while (!sbp.in_grouping(g_v, 97, 249)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 249)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function r_mark_regions() {
+            var v_1 = sbp.cursor;
+            I_pV = sbp.limit;
+            I_p1 = I_pV;
+            I_p2 = I_pV;
+            habr4();
+            sbp.cursor = v_1;
+            if (habr5()) {
+              I_p1 = sbp.cursor;
+              if (habr5())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function r_postlude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_1, 3);
+              if (!among_var)
+                break;
+              sbp.ket = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  sbp.slice_from("i");
+                  break;
+                case 2:
+                  sbp.slice_from("u");
+                  break;
+                case 3:
+                  if (sbp.cursor >= sbp.limit)
+                    return;
+                  sbp.cursor++;
+                  break;
+              }
+            }
+          }
+
+          function r_RV() {
+            return I_pV <= sbp.cursor;
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_attached_pronoun() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            if (sbp.find_among_b(a_2, 37)) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among_b(a_3, 5);
+              if (among_var && r_RV()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    sbp.slice_from("e");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_standard_suffix() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_6, 51);
+            if (!among_var)
+              return false;
+            sbp.bra = sbp.cursor;
+            switch (among_var) {
+              case 1:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                break;
+              case 2:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                if (sbp.eq_s_b(2, "ic")) {
+                  sbp.bra = sbp.cursor;
+                  if (r_R2())
+                    sbp.slice_del();
+                }
+                break;
+              case 3:
+                if (!r_R2())
+                  return false;
+                sbp.slice_from("log");
+                break;
+              case 4:
+                if (!r_R2())
+                  return false;
+                sbp.slice_from("u");
+                break;
+              case 5:
+                if (!r_R2())
+                  return false;
+                sbp.slice_from("ente");
+                break;
+              case 6:
+                if (!r_RV())
+                  return false;
+                sbp.slice_del();
+                break;
+              case 7:
+                if (!r_R1())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                among_var = sbp.find_among_b(a_4, 4);
+                if (among_var) {
+                  sbp.bra = sbp.cursor;
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    if (among_var == 1) {
+                      sbp.ket = sbp.cursor;
+                      if (sbp.eq_s_b(2, "at")) {
+                        sbp.bra = sbp.cursor;
+                        if (r_R2())
+                          sbp.slice_del();
+                      }
+                    }
+                  }
+                }
+                break;
+              case 8:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                among_var = sbp.find_among_b(a_5, 3);
+                if (among_var) {
+                  sbp.bra = sbp.cursor;
+                  if (among_var == 1)
+                    if (r_R2())
+                      sbp.slice_del();
+                }
+                break;
+              case 9:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                if (sbp.eq_s_b(2, "at")) {
+                  sbp.bra = sbp.cursor;
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(2, "ic")) {
+                      sbp.bra = sbp.cursor;
+                      if (r_R2())
+                        sbp.slice_del();
+                    }
+                  }
+                }
+                break;
+            }
+            return true;
+          }
+
+          function r_verb_suffix() {
+            var among_var, v_1;
+            if (sbp.cursor >= I_pV) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_pV;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_7, 87);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                if (among_var == 1)
+                  sbp.slice_del();
+              }
+              sbp.limit_backward = v_1;
+            }
+          }
+
+          function habr6() {
+            var v_1 = sbp.limit - sbp.cursor;
+            sbp.ket = sbp.cursor;
+            if (sbp.in_grouping_b(g_AEIO, 97, 242)) {
+              sbp.bra = sbp.cursor;
+              if (r_RV()) {
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                if (sbp.eq_s_b(1, "i")) {
+                  sbp.bra = sbp.cursor;
+                  if (r_RV()) {
+                    sbp.slice_del();
+                    return;
+                  }
+                }
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+          }
+
+          function r_vowel_suffix() {
+            habr6();
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "h")) {
+              sbp.bra = sbp.cursor;
+              if (sbp.in_grouping_b(g_CG, 99, 103))
+                if (r_RV())
+                  sbp.slice_del();
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_attached_pronoun();
+            sbp.cursor = sbp.limit;
+            if (!r_standard_suffix()) {
+              sbp.cursor = sbp.limit;
+              r_verb_suffix();
+            }
+            sbp.cursor = sbp.limit;
+            r_vowel_suffix();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.it.stemmer, 'stemmer-it');
+
+    lunr.it.stopWordFilter = lunr.generateStopWordFilter('a abbia abbiamo abbiano abbiate ad agl agli ai al all alla alle allo anche avemmo avendo avesse avessero avessi avessimo aveste avesti avete aveva avevamo avevano avevate avevi avevo avrai avranno avrebbe avrebbero avrei avremmo avremo avreste avresti avrete avrà avrò avuta avute avuti avuto c che chi ci coi col come con contro cui da dagl dagli dai dal dall dalla dalle dallo degl degli dei del dell della delle dello di dov dove e ebbe ebbero ebbi ed era erano eravamo eravate eri ero essendo faccia facciamo facciano facciate faccio facemmo facendo facesse facessero facessi facessimo faceste facesti faceva facevamo facevano facevate facevi facevo fai fanno farai faranno farebbe farebbero farei faremmo faremo fareste faresti farete farà farò fece fecero feci fosse fossero fossi fossimo foste fosti fu fui fummo furono gli ha hai hanno ho i il in io l la le lei li lo loro lui ma mi mia mie miei mio ne negl negli nei nel nell nella nelle nello noi non nostra nostre nostri nostro o per perché più quale quanta quante quanti quanto quella quelle quelli quello questa queste questi questo sarai saranno sarebbe sarebbero sarei saremmo saremo sareste saresti sarete sarà sarò se sei si sia siamo siano siate siete sono sta stai stando stanno starai staranno starebbe starebbero starei staremmo staremo stareste staresti starete starà starò stava stavamo stavano stavate stavi stavo stemmo stesse stessero stessi stessimo steste stesti stette stettero stetti stia stiamo stiano stiate sto su sua sue sugl sugli sui sul sull sulla sulle sullo suo suoi ti tra tu tua tue tuo tuoi tutti tutto un una uno vi voi vostra vostre vostri vostro è'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.it.stopWordFilter, 'stopWordFilter-it');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.ja.js

@@ -0,0 +1,188 @@
+/*!
+ * Lunr languages, `Japanese` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Chad Liu
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /*
+    Japanese tokenization is trickier, since it does not
+    take into account spaces.
+    Since the tokenization function is represented different
+    internally for each of the Lunr versions, this had to be done
+    in order to try to try to pick the best way of doing this based
+    on the Lunr version
+     */
+    var isLunr2 = lunr.version[0] == "2";
+
+    /* register specific locale function */
+    lunr.ja = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.ja.trimmer,
+        lunr.ja.stopWordFilter,
+        lunr.ja.stemmer
+      );
+
+      // change the tokenizer for japanese one
+      if (isLunr2) { // for lunr version 2.0.0
+        this.tokenizer = lunr.ja.tokenizer;
+      } else {
+        if (lunr.tokenizer) { // for lunr version 0.6.0
+          lunr.tokenizer = lunr.ja.tokenizer;
+        }
+        if (this.tokenizerFn) { // for lunr version 0.7.0 -> 1.0.0
+          this.tokenizerFn = lunr.ja.tokenizer;
+        }
+      }
+    };
+    var segmenter = new lunr.TinySegmenter(); // インスタンス生成
+
+    lunr.ja.tokenizer = function(obj) {
+      var i;
+      var str;
+      var len;
+      var segs;
+      var tokens;
+      var char;
+      var sliceLength;
+      var sliceStart;
+      var sliceEnd;
+      var segStart;
+
+      if (!arguments.length || obj == null || obj == undefined)
+        return [];
+
+      if (Array.isArray(obj)) {
+        return obj.map(
+          function(t) {
+            return isLunr2 ? new lunr.Token(t.toLowerCase()) : t.toLowerCase();
+          }
+        );
+      }
+
+      str = obj.toString().toLowerCase().replace(/^\s+/, '');
+      for (i = str.length - 1; i >= 0; i--) {
+        if (/\S/.test(str.charAt(i))) {
+          str = str.substring(0, i + 1);
+          break;
+        }
+      }
+
+      tokens = [];
+      len = str.length;
+      for (sliceEnd = 0, sliceStart = 0; sliceEnd <= len; sliceEnd++) {
+        char = str.charAt(sliceEnd);
+        sliceLength = sliceEnd - sliceStart;
+
+        if ((char.match(/\s/) || sliceEnd == len)) {
+          if (sliceLength > 0) {
+            segs = segmenter.segment(str.slice(sliceStart, sliceEnd)).filter(
+              function(token) {
+                return !!token;
+              }
+            );
+
+            segStart = sliceStart;
+            for (i = 0; i < segs.length; i++) {
+              if (isLunr2) {
+                tokens.push(
+                  new lunr.Token(
+                    segs[i], {
+                      position: [segStart, segs[i].length],
+                      index: tokens.length
+                    }
+                  )
+                );
+              } else {
+                tokens.push(segs[i]);
+              }
+              segStart += segs[i].length;
+            }
+          }
+
+          sliceStart = sliceEnd + 1;
+        }
+      }
+
+      return tokens;
+    }
+
+    /* lunr stemmer function */
+    lunr.ja.stemmer = (function() {
+
+      /* TODO japanese stemmer  */
+      return function(word) {
+        return word;
+      }
+    })();
+    lunr.Pipeline.registerFunction(lunr.ja.stemmer, 'stemmer-ja');
+
+    /* lunr trimmer function */
+    lunr.ja.wordCharacters = "一二三四五六七八九十百千万億兆一-龠々〆ヵヶぁ-んァ-ヴーｱ-ﾝﾞa-zA-Zａ-ｚＡ-Ｚ0-9０-９";
+    lunr.ja.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.ja.wordCharacters);
+    lunr.Pipeline.registerFunction(lunr.ja.trimmer, 'trimmer-ja');
+
+    /* lunr stop word filter. see http://www.ranks.nl/stopwords/japanese */
+    lunr.ja.stopWordFilter = lunr.generateStopWordFilter(
+      'これ それ あれ この その あの ここ そこ あそこ こちら どこ だれ なに なん 何 私 貴方 貴方方 我々 私達 あの人 あのかた 彼女 彼 です あります おります います は が の に を で え から まで より も どの と し それで しかし'.split(' '));
+    lunr.Pipeline.registerFunction(lunr.ja.stopWordFilter, 'stopWordFilter-ja');
+
+    // alias ja => jp for backward-compatibility.
+    // jp is the country code, while ja is the language code
+    // a new lunr.ja.js has been created, but in order to
+    // keep the backward compatibility, we'll leave the lunr.jp.js
+    // here for a while, and just make it use the new lunr.ja.js
+    lunr.jp = lunr.ja;
+    lunr.Pipeline.registerFunction(lunr.jp.stemmer, 'stemmer-jp');
+    lunr.Pipeline.registerFunction(lunr.jp.trimmer, 'trimmer-jp');
+    lunr.Pipeline.registerFunction(lunr.jp.stopWordFilter, 'stopWordFilter-jp');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.jp.js

@@ -0,0 +1,5 @@
+// jp is the country code, while ja is the language code
+// a new lunr.ja.js has been created, but in order to
+// keep the backward compatibility, we'll leave the lunr.jp.js
+// here for a while, and just make it use the new lunr.ja.js
+module.exports = require('./lunr.ja');

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.multi.js

@@ -0,0 +1,79 @@
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(factory)
+    } else if (typeof exports === 'object') {
+        /**
+         * Node. Does not work with strict CommonJS, but
+         * only CommonJS-like environments that support module.exports,
+         * like Node.
+         */
+        module.exports = factory()
+    } else {
+        // Browser globals (root is window)
+        factory()(root.lunr);
+    }
+}(this, function () {
+    /**
+     * Just return a value to define the module export.
+     * This example returns an object, but the module
+     * can return a function as the exported value.
+     */
+    return function(lunr) {
+        /* Set up the pipeline for indexing content in multiple languages. The
+           corresponding lunr.{lang} files must be loaded before calling this
+           function; English ('en') is built in.
+
+           Returns: a lunr plugin for use in your indexer.
+
+           Known drawback: every word will be stemmed with stemmers for every
+           language. This could mean that sometimes words that have the same
+           stemming root will not be stemmed as such.
+           */
+        lunr.multiLanguage = function(/* lang1, lang2, ... */) {
+            var languages = Array.prototype.slice.call(arguments);
+            var nameSuffix = languages.join('-');
+            var wordCharacters = "";
+            var pipeline = [];
+            var searchPipeline = [];
+            for (var i = 0; i < languages.length; ++i) {
+                if (languages[i] == 'en') {
+                    wordCharacters += '\\w';
+                    pipeline.unshift(lunr.stopWordFilter);
+                    pipeline.push(lunr.stemmer);
+                    searchPipeline.push(lunr.stemmer);
+                } else {
+                    wordCharacters += lunr[languages[i]].wordCharacters;
+                    if (lunr[languages[i]].stopWordFilter) {
+                        pipeline.unshift(lunr[languages[i]].stopWordFilter);
+                    }
+                    if (lunr[languages[i]].stemmer) {
+                        pipeline.push(lunr[languages[i]].stemmer);
+                        searchPipeline.push(lunr[languages[i]].stemmer);
+                    }
+                }
+            };
+            var multiTrimmer = lunr.trimmerSupport.generateTrimmer(wordCharacters);
+            lunr.Pipeline.registerFunction(multiTrimmer, 'lunr-multi-trimmer-' + nameSuffix);
+            pipeline.unshift(multiTrimmer);
+
+            return function() {
+                this.pipeline.reset();
+
+                this.pipeline.add.apply(this.pipeline, pipeline);
+
+                // for lunr version 2
+                // this is necessary so that every searched word is also stemmed before
+                // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+                if (this.searchPipeline) {
+                    this.searchPipeline.reset();
+                    this.searchPipeline.add.apply(this.searchPipeline, searchPipeline);
+                }
+            };
+        }
+    }
+}));

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.nl.js

@@ -0,0 +1,448 @@
+/*!
+ * Lunr languages, `Dutch` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.nl = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.nl.trimmer,
+        lunr.nl.stopWordFilter,
+        lunr.nl.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.nl.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.nl.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.nl.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.nl.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.nl.trimmer, 'trimmer-nl');
+
+    /* lunr stemmer function */
+    lunr.nl.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function DutchStemmer() {
+          var a_0 = [new Among("", -1, 6), new Among("\u00E1", 0, 1),
+              new Among("\u00E4", 0, 1), new Among("\u00E9", 0, 2),
+              new Among("\u00EB", 0, 2), new Among("\u00ED", 0, 3),
+              new Among("\u00EF", 0, 3), new Among("\u00F3", 0, 4),
+              new Among("\u00F6", 0, 4), new Among("\u00FA", 0, 5),
+              new Among("\u00FC", 0, 5)
+            ],
+            a_1 = [new Among("", -1, 3),
+              new Among("I", 0, 2), new Among("Y", 0, 1)
+            ],
+            a_2 = [
+              new Among("dd", -1, -1), new Among("kk", -1, -1),
+              new Among("tt", -1, -1)
+            ],
+            a_3 = [new Among("ene", -1, 2),
+              new Among("se", -1, 3), new Among("en", -1, 2),
+              new Among("heden", 2, 1), new Among("s", -1, 3)
+            ],
+            a_4 = [
+              new Among("end", -1, 1), new Among("ig", -1, 2),
+              new Among("ing", -1, 1), new Among("lijk", -1, 3),
+              new Among("baar", -1, 4), new Among("bar", -1, 5)
+            ],
+            a_5 = [
+              new Among("aa", -1, -1), new Among("ee", -1, -1),
+              new Among("oo", -1, -1), new Among("uu", -1, -1)
+            ],
+            g_v = [17, 65,
+              16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            g_v_I = [1, 0, 0,
+              17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            g_v_j = [
+              17, 67, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128
+            ],
+            I_p2, I_p1, B_e_found, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_prelude() {
+            var among_var, v_1 = sbp.cursor,
+              v_2, v_3;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_0, 11);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("a");
+                    continue;
+                  case 2:
+                    sbp.slice_from("e");
+                    continue;
+                  case 3:
+                    sbp.slice_from("i");
+                    continue;
+                  case 4:
+                    sbp.slice_from("o");
+                    continue;
+                  case 5:
+                    sbp.slice_from("u");
+                    continue;
+                  case 6:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+            sbp.cursor = v_1;
+            sbp.bra = v_1;
+            if (sbp.eq_s(1, "y")) {
+              sbp.ket = sbp.cursor;
+              sbp.slice_from("Y");
+            } else
+              sbp.cursor = v_1;
+            while (true) {
+              v_2 = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 232)) {
+                v_3 = sbp.cursor;
+                sbp.bra = v_3;
+                if (sbp.eq_s(1, "i")) {
+                  sbp.ket = sbp.cursor;
+                  if (sbp.in_grouping(g_v, 97, 232)) {
+                    sbp.slice_from("I");
+                    sbp.cursor = v_2;
+                  }
+                } else {
+                  sbp.cursor = v_3;
+                  if (sbp.eq_s(1, "y")) {
+                    sbp.ket = sbp.cursor;
+                    sbp.slice_from("Y");
+                    sbp.cursor = v_2;
+                  } else if (habr1(v_2))
+                    break;
+                }
+              } else if (habr1(v_2))
+                break;
+            }
+          }
+
+          function habr1(v_1) {
+            sbp.cursor = v_1;
+            if (v_1 >= sbp.limit)
+              return true;
+            sbp.cursor++;
+            return false;
+          }
+
+          function r_mark_regions() {
+            I_p1 = sbp.limit;
+            I_p2 = I_p1;
+            if (!habr2()) {
+              I_p1 = sbp.cursor;
+              if (I_p1 < 3)
+                I_p1 = 3;
+              if (!habr2())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function habr2() {
+            while (!sbp.in_grouping(g_v, 97, 232)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 232)) {
+              if (sbp.cursor >= sbp.limit)
+                return true;
+              sbp.cursor++;
+            }
+            return false;
+          }
+
+          function r_postlude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_1, 3);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("y");
+                    break;
+                  case 2:
+                    sbp.slice_from("i");
+                    break;
+                  case 3:
+                    if (sbp.cursor >= sbp.limit)
+                      return;
+                    sbp.cursor++;
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_undouble() {
+            var v_1 = sbp.limit - sbp.cursor;
+            if (sbp.find_among_b(a_2, 3)) {
+              sbp.cursor = sbp.limit - v_1;
+              sbp.ket = sbp.cursor;
+              if (sbp.cursor > sbp.limit_backward) {
+                sbp.cursor--;
+                sbp.bra = sbp.cursor;
+                sbp.slice_del();
+              }
+            }
+          }
+
+          function r_e_ending() {
+            var v_1;
+            B_e_found = false;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "e")) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                v_1 = sbp.limit - sbp.cursor;
+                if (sbp.out_grouping_b(g_v, 97, 232)) {
+                  sbp.cursor = sbp.limit - v_1;
+                  sbp.slice_del();
+                  B_e_found = true;
+                  r_undouble();
+                }
+              }
+            }
+          }
+
+          function r_en_ending() {
+            var v_1;
+            if (r_R1()) {
+              v_1 = sbp.limit - sbp.cursor;
+              if (sbp.out_grouping_b(g_v, 97, 232)) {
+                sbp.cursor = sbp.limit - v_1;
+                if (!sbp.eq_s_b(3, "gem")) {
+                  sbp.cursor = sbp.limit - v_1;
+                  sbp.slice_del();
+                  r_undouble();
+                }
+              }
+            }
+          }
+
+          function r_standard_suffix() {
+            var among_var, v_1 = sbp.limit - sbp.cursor,
+              v_2, v_3, v_4, v_5, v_6;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_3, 5);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (r_R1())
+                    sbp.slice_from("heid");
+                  break;
+                case 2:
+                  r_en_ending();
+                  break;
+                case 3:
+                  if (r_R1() && sbp.out_grouping_b(g_v_j, 97, 232))
+                    sbp.slice_del();
+                  break;
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            r_e_ending();
+            sbp.cursor = sbp.limit - v_1;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(4, "heid")) {
+              sbp.bra = sbp.cursor;
+              if (r_R2()) {
+                v_2 = sbp.limit - sbp.cursor;
+                if (!sbp.eq_s_b(1, "c")) {
+                  sbp.cursor = sbp.limit - v_2;
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  if (sbp.eq_s_b(2, "en")) {
+                    sbp.bra = sbp.cursor;
+                    r_en_ending();
+                  }
+                }
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_4, 6);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    v_3 = sbp.limit - sbp.cursor;
+                    sbp.ket = sbp.cursor;
+                    if (sbp.eq_s_b(2, "ig")) {
+                      sbp.bra = sbp.cursor;
+                      if (r_R2()) {
+                        v_4 = sbp.limit - sbp.cursor;
+                        if (!sbp.eq_s_b(1, "e")) {
+                          sbp.cursor = sbp.limit - v_4;
+                          sbp.slice_del();
+                          break;
+                        }
+                      }
+                    }
+                    sbp.cursor = sbp.limit - v_3;
+                    r_undouble();
+                  }
+                  break;
+                case 2:
+                  if (r_R2()) {
+                    v_5 = sbp.limit - sbp.cursor;
+                    if (!sbp.eq_s_b(1, "e")) {
+                      sbp.cursor = sbp.limit - v_5;
+                      sbp.slice_del();
+                    }
+                  }
+                  break;
+                case 3:
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    r_e_ending();
+                  }
+                  break;
+                case 4:
+                  if (r_R2())
+                    sbp.slice_del();
+                  break;
+                case 5:
+                  if (r_R2() && B_e_found)
+                    sbp.slice_del();
+                  break;
+              }
+            }
+            sbp.cursor = sbp.limit - v_1;
+            if (sbp.out_grouping_b(g_v_I, 73, 232)) {
+              v_6 = sbp.limit - sbp.cursor;
+              if (sbp.find_among_b(a_5, 4) && sbp.out_grouping_b(g_v, 97, 232)) {
+                sbp.cursor = sbp.limit - v_6;
+                sbp.ket = sbp.cursor;
+                if (sbp.cursor > sbp.limit_backward) {
+                  sbp.cursor--;
+                  sbp.bra = sbp.cursor;
+                  sbp.slice_del();
+                }
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_standard_suffix();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.nl.stemmer, 'stemmer-nl');
+
+    lunr.nl.stopWordFilter = lunr.generateStopWordFilter(' aan al alles als altijd andere ben bij daar dan dat de der deze die dit doch doen door dus een eens en er ge geen geweest haar had heb hebben heeft hem het hier hij hoe hun iemand iets ik in is ja je kan kon kunnen maar me meer men met mij mijn moet na naar niet niets nog nu of om omdat onder ons ook op over reeds te tegen toch toen tot u uit uw van veel voor want waren was wat werd wezen wie wil worden wordt zal ze zelf zich zij zijn zo zonder zou'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.nl.stopWordFilter, 'stopWordFilter-nl');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.no.js

@@ -0,0 +1,258 @@
+/*!
+ * Lunr languages, `Norwegian` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.no = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.no.trimmer,
+        lunr.no.stopWordFilter,
+        lunr.no.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.no.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.no.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.no.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.no.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.no.trimmer, 'trimmer-no');
+
+    /* lunr stemmer function */
+    lunr.no.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function NorwegianStemmer() {
+          var a_0 = [new Among("a", -1, 1), new Among("e", -1, 1),
+              new Among("ede", 1, 1), new Among("ande", 1, 1),
+              new Among("ende", 1, 1), new Among("ane", 1, 1),
+              new Among("ene", 1, 1), new Among("hetene", 6, 1),
+              new Among("erte", 1, 3), new Among("en", -1, 1),
+              new Among("heten", 9, 1), new Among("ar", -1, 1),
+              new Among("er", -1, 1), new Among("heter", 12, 1),
+              new Among("s", -1, 2), new Among("as", 14, 1),
+              new Among("es", 14, 1), new Among("edes", 16, 1),
+              new Among("endes", 16, 1), new Among("enes", 16, 1),
+              new Among("hetenes", 19, 1), new Among("ens", 14, 1),
+              new Among("hetens", 21, 1), new Among("ers", 14, 1),
+              new Among("ets", 14, 1), new Among("et", -1, 1),
+              new Among("het", 25, 1), new Among("ert", -1, 3),
+              new Among("ast", -1, 1)
+            ],
+            a_1 = [new Among("dt", -1, -1),
+              new Among("vt", -1, -1)
+            ],
+            a_2 = [new Among("leg", -1, 1),
+              new Among("eleg", 0, 1), new Among("ig", -1, 1),
+              new Among("eig", 2, 1), new Among("lig", 2, 1),
+              new Among("elig", 4, 1), new Among("els", -1, 1),
+              new Among("lov", -1, 1), new Among("elov", 7, 1),
+              new Among("slov", 7, 1), new Among("hetslov", 9, 1)
+            ],
+            g_v = [17,
+              65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128
+            ],
+            g_s_ending = [
+              119, 125, 149, 1
+            ],
+            I_x, I_p1, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_mark_regions() {
+            var v_1, c = sbp.cursor + 3;
+            I_p1 = sbp.limit;
+            if (0 <= c || c <= sbp.limit) {
+              I_x = c;
+              while (true) {
+                v_1 = sbp.cursor;
+                if (sbp.in_grouping(g_v, 97, 248)) {
+                  sbp.cursor = v_1;
+                  break;
+                }
+                if (v_1 >= sbp.limit)
+                  return;
+                sbp.cursor = v_1 + 1;
+              }
+              while (!sbp.out_grouping(g_v, 97, 248)) {
+                if (sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              I_p1 = sbp.cursor;
+              if (I_p1 < I_x)
+                I_p1 = I_x;
+            }
+          }
+
+          function r_main_suffix() {
+            var among_var, v_1, v_2;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_0, 29);
+              sbp.limit_backward = v_1;
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    v_2 = sbp.limit - sbp.cursor;
+                    if (sbp.in_grouping_b(g_s_ending, 98, 122))
+                      sbp.slice_del();
+                    else {
+                      sbp.cursor = sbp.limit - v_2;
+                      if (sbp.eq_s_b(1, "k") &&
+                        sbp.out_grouping_b(g_v, 97, 248))
+                        sbp.slice_del();
+                    }
+                    break;
+                  case 3:
+                    sbp.slice_from("er");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_consonant_pair() {
+            var v_1 = sbp.limit - sbp.cursor,
+              v_2;
+            if (sbp.cursor >= I_p1) {
+              v_2 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              if (sbp.find_among_b(a_1, 2)) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_2;
+                sbp.cursor = sbp.limit - v_1;
+                if (sbp.cursor > sbp.limit_backward) {
+                  sbp.cursor--;
+                  sbp.bra = sbp.cursor;
+                  sbp.slice_del();
+                }
+              } else
+                sbp.limit_backward = v_2;
+            }
+          }
+
+          function r_other_suffix() {
+            var among_var, v_1;
+            if (sbp.cursor >= I_p1) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_2, 11);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                sbp.limit_backward = v_1;
+                if (among_var == 1)
+                  sbp.slice_del();
+              } else
+                sbp.limit_backward = v_1;
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_main_suffix();
+            sbp.cursor = sbp.limit;
+            r_consonant_pair();
+            sbp.cursor = sbp.limit;
+            r_other_suffix();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.no.stemmer, 'stemmer-no');
+
+    lunr.no.stopWordFilter = lunr.generateStopWordFilter('alle at av bare begge ble blei bli blir blitt både båe da de deg dei deim deira deires dem den denne der dere deres det dette di din disse ditt du dykk dykkar då eg ein eit eitt eller elles en enn er et ett etter for fordi fra før ha hadde han hans har hennar henne hennes her hjå ho hoe honom hoss hossen hun hva hvem hver hvilke hvilken hvis hvor hvordan hvorfor i ikke ikkje ikkje ingen ingi inkje inn inni ja jeg kan kom korleis korso kun kunne kva kvar kvarhelst kven kvi kvifor man mange me med medan meg meget mellom men mi min mine mitt mot mykje ned no noe noen noka noko nokon nokor nokre nå når og også om opp oss over på samme seg selv si si sia sidan siden sin sine sitt sjøl skal skulle slik so som som somme somt så sånn til um upp ut uten var vart varte ved vere verte vi vil ville vore vors vort vår være være vært å'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.no.stopWordFilter, 'stopWordFilter-no');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.pt.js

@@ -0,0 +1,570 @@
+/*!
+ * Lunr languages, `Portuguese` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.pt = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.pt.trimmer,
+        lunr.pt.stopWordFilter,
+        lunr.pt.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.pt.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.pt.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.pt.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.pt.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.pt.trimmer, 'trimmer-pt');
+
+    /* lunr stemmer function */
+    lunr.pt.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function PortugueseStemmer() {
+          var a_0 = [new Among("", -1, 3), new Among("\u00E3", 0, 1),
+              new Among("\u00F5", 0, 2)
+            ],
+            a_1 = [new Among("", -1, 3),
+              new Among("a~", 0, 1), new Among("o~", 0, 2)
+            ],
+            a_2 = [
+              new Among("ic", -1, -1), new Among("ad", -1, -1),
+              new Among("os", -1, -1), new Among("iv", -1, 1)
+            ],
+            a_3 = [
+              new Among("ante", -1, 1), new Among("avel", -1, 1),
+              new Among("\u00EDvel", -1, 1)
+            ],
+            a_4 = [new Among("ic", -1, 1),
+              new Among("abil", -1, 1), new Among("iv", -1, 1)
+            ],
+            a_5 = [
+              new Among("ica", -1, 1), new Among("\u00E2ncia", -1, 1),
+              new Among("\u00EAncia", -1, 4), new Among("ira", -1, 9),
+              new Among("adora", -1, 1), new Among("osa", -1, 1),
+              new Among("ista", -1, 1), new Among("iva", -1, 8),
+              new Among("eza", -1, 1), new Among("log\u00EDa", -1, 2),
+              new Among("idade", -1, 7), new Among("ante", -1, 1),
+              new Among("mente", -1, 6), new Among("amente", 12, 5),
+              new Among("\u00E1vel", -1, 1), new Among("\u00EDvel", -1, 1),
+              new Among("uci\u00F3n", -1, 3), new Among("ico", -1, 1),
+              new Among("ismo", -1, 1), new Among("oso", -1, 1),
+              new Among("amento", -1, 1), new Among("imento", -1, 1),
+              new Among("ivo", -1, 8), new Among("a\u00E7a~o", -1, 1),
+              new Among("ador", -1, 1), new Among("icas", -1, 1),
+              new Among("\u00EAncias", -1, 4), new Among("iras", -1, 9),
+              new Among("adoras", -1, 1), new Among("osas", -1, 1),
+              new Among("istas", -1, 1), new Among("ivas", -1, 8),
+              new Among("ezas", -1, 1), new Among("log\u00EDas", -1, 2),
+              new Among("idades", -1, 7), new Among("uciones", -1, 3),
+              new Among("adores", -1, 1), new Among("antes", -1, 1),
+              new Among("a\u00E7o~es", -1, 1), new Among("icos", -1, 1),
+              new Among("ismos", -1, 1), new Among("osos", -1, 1),
+              new Among("amentos", -1, 1), new Among("imentos", -1, 1),
+              new Among("ivos", -1, 8)
+            ],
+            a_6 = [new Among("ada", -1, 1),
+              new Among("ida", -1, 1), new Among("ia", -1, 1),
+              new Among("aria", 2, 1), new Among("eria", 2, 1),
+              new Among("iria", 2, 1), new Among("ara", -1, 1),
+              new Among("era", -1, 1), new Among("ira", -1, 1),
+              new Among("ava", -1, 1), new Among("asse", -1, 1),
+              new Among("esse", -1, 1), new Among("isse", -1, 1),
+              new Among("aste", -1, 1), new Among("este", -1, 1),
+              new Among("iste", -1, 1), new Among("ei", -1, 1),
+              new Among("arei", 16, 1), new Among("erei", 16, 1),
+              new Among("irei", 16, 1), new Among("am", -1, 1),
+              new Among("iam", 20, 1), new Among("ariam", 21, 1),
+              new Among("eriam", 21, 1), new Among("iriam", 21, 1),
+              new Among("aram", 20, 1), new Among("eram", 20, 1),
+              new Among("iram", 20, 1), new Among("avam", 20, 1),
+              new Among("em", -1, 1), new Among("arem", 29, 1),
+              new Among("erem", 29, 1), new Among("irem", 29, 1),
+              new Among("assem", 29, 1), new Among("essem", 29, 1),
+              new Among("issem", 29, 1), new Among("ado", -1, 1),
+              new Among("ido", -1, 1), new Among("ando", -1, 1),
+              new Among("endo", -1, 1), new Among("indo", -1, 1),
+              new Among("ara~o", -1, 1), new Among("era~o", -1, 1),
+              new Among("ira~o", -1, 1), new Among("ar", -1, 1),
+              new Among("er", -1, 1), new Among("ir", -1, 1),
+              new Among("as", -1, 1), new Among("adas", 47, 1),
+              new Among("idas", 47, 1), new Among("ias", 47, 1),
+              new Among("arias", 50, 1), new Among("erias", 50, 1),
+              new Among("irias", 50, 1), new Among("aras", 47, 1),
+              new Among("eras", 47, 1), new Among("iras", 47, 1),
+              new Among("avas", 47, 1), new Among("es", -1, 1),
+              new Among("ardes", 58, 1), new Among("erdes", 58, 1),
+              new Among("irdes", 58, 1), new Among("ares", 58, 1),
+              new Among("eres", 58, 1), new Among("ires", 58, 1),
+              new Among("asses", 58, 1), new Among("esses", 58, 1),
+              new Among("isses", 58, 1), new Among("astes", 58, 1),
+              new Among("estes", 58, 1), new Among("istes", 58, 1),
+              new Among("is", -1, 1), new Among("ais", 71, 1),
+              new Among("eis", 71, 1), new Among("areis", 73, 1),
+              new Among("ereis", 73, 1), new Among("ireis", 73, 1),
+              new Among("\u00E1reis", 73, 1), new Among("\u00E9reis", 73, 1),
+              new Among("\u00EDreis", 73, 1), new Among("\u00E1sseis", 73, 1),
+              new Among("\u00E9sseis", 73, 1), new Among("\u00EDsseis", 73, 1),
+              new Among("\u00E1veis", 73, 1), new Among("\u00EDeis", 73, 1),
+              new Among("ar\u00EDeis", 84, 1), new Among("er\u00EDeis", 84, 1),
+              new Among("ir\u00EDeis", 84, 1), new Among("ados", -1, 1),
+              new Among("idos", -1, 1), new Among("amos", -1, 1),
+              new Among("\u00E1ramos", 90, 1), new Among("\u00E9ramos", 90, 1),
+              new Among("\u00EDramos", 90, 1), new Among("\u00E1vamos", 90, 1),
+              new Among("\u00EDamos", 90, 1), new Among("ar\u00EDamos", 95, 1),
+              new Among("er\u00EDamos", 95, 1), new Among("ir\u00EDamos", 95, 1),
+              new Among("emos", -1, 1), new Among("aremos", 99, 1),
+              new Among("eremos", 99, 1), new Among("iremos", 99, 1),
+              new Among("\u00E1ssemos", 99, 1), new Among("\u00EAssemos", 99, 1),
+              new Among("\u00EDssemos", 99, 1), new Among("imos", -1, 1),
+              new Among("armos", -1, 1), new Among("ermos", -1, 1),
+              new Among("irmos", -1, 1), new Among("\u00E1mos", -1, 1),
+              new Among("ar\u00E1s", -1, 1), new Among("er\u00E1s", -1, 1),
+              new Among("ir\u00E1s", -1, 1), new Among("eu", -1, 1),
+              new Among("iu", -1, 1), new Among("ou", -1, 1),
+              new Among("ar\u00E1", -1, 1), new Among("er\u00E1", -1, 1),
+              new Among("ir\u00E1", -1, 1)
+            ],
+            a_7 = [new Among("a", -1, 1),
+              new Among("i", -1, 1), new Among("o", -1, 1),
+              new Among("os", -1, 1), new Among("\u00E1", -1, 1),
+              new Among("\u00ED", -1, 1), new Among("\u00F3", -1, 1)
+            ],
+            a_8 = [
+              new Among("e", -1, 1), new Among("\u00E7", -1, 2),
+              new Among("\u00E9", -1, 1), new Among("\u00EA", -1, 1)
+            ],
+            g_v = [17,
+              65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 19, 12, 2
+            ],
+            I_p2, I_p1, I_pV, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_prelude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_0, 3);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("a~");
+                    continue;
+                  case 2:
+                    sbp.slice_from("o~");
+                    continue;
+                  case 3:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+          }
+
+          function habr2() {
+            if (sbp.out_grouping(g_v, 97, 250)) {
+              while (!sbp.in_grouping(g_v, 97, 250)) {
+                if (sbp.cursor >= sbp.limit)
+                  return true;
+                sbp.cursor++;
+              }
+              return false;
+            }
+            return true;
+          }
+
+          function habr3() {
+            if (sbp.in_grouping(g_v, 97, 250)) {
+              while (!sbp.out_grouping(g_v, 97, 250)) {
+                if (sbp.cursor >= sbp.limit)
+                  return false;
+                sbp.cursor++;
+              }
+            }
+            I_pV = sbp.cursor;
+            return true;
+          }
+
+          function habr4() {
+            var v_1 = sbp.cursor,
+              v_2, v_3;
+            if (sbp.in_grouping(g_v, 97, 250)) {
+              v_2 = sbp.cursor;
+              if (habr2()) {
+                sbp.cursor = v_2;
+                if (habr3())
+                  return;
+              } else
+                I_pV = sbp.cursor;
+            }
+            sbp.cursor = v_1;
+            if (sbp.out_grouping(g_v, 97, 250)) {
+              v_3 = sbp.cursor;
+              if (habr2()) {
+                sbp.cursor = v_3;
+                if (!sbp.in_grouping(g_v, 97, 250) || sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              I_pV = sbp.cursor;
+            }
+          }
+
+          function habr5() {
+            while (!sbp.in_grouping(g_v, 97, 250)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 250)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function r_mark_regions() {
+            var v_1 = sbp.cursor;
+            I_pV = sbp.limit;
+            I_p1 = I_pV;
+            I_p2 = I_pV;
+            habr4();
+            sbp.cursor = v_1;
+            if (habr5()) {
+              I_p1 = sbp.cursor;
+              if (habr5())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function r_postlude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_1, 3);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("\u00E3");
+                    continue;
+                  case 2:
+                    sbp.slice_from("\u00F5");
+                    continue;
+                  case 3:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+          }
+
+          function r_RV() {
+            return I_pV <= sbp.cursor;
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_standard_suffix() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_5, 45);
+            if (!among_var)
+              return false;
+            sbp.bra = sbp.cursor;
+            switch (among_var) {
+              case 1:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                break;
+              case 2:
+                if (!r_R2())
+                  return false;
+                sbp.slice_from("log");
+                break;
+              case 3:
+                if (!r_R2())
+                  return false;
+                sbp.slice_from("u");
+                break;
+              case 4:
+                if (!r_R2())
+                  return false;
+                sbp.slice_from("ente");
+                break;
+              case 5:
+                if (!r_R1())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                among_var = sbp.find_among_b(a_2, 4);
+                if (among_var) {
+                  sbp.bra = sbp.cursor;
+                  if (r_R2()) {
+                    sbp.slice_del();
+                    if (among_var == 1) {
+                      sbp.ket = sbp.cursor;
+                      if (sbp.eq_s_b(2, "at")) {
+                        sbp.bra = sbp.cursor;
+                        if (r_R2())
+                          sbp.slice_del();
+                      }
+                    }
+                  }
+                }
+                break;
+              case 6:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                among_var = sbp.find_among_b(a_3, 3);
+                if (among_var) {
+                  sbp.bra = sbp.cursor;
+                  if (among_var == 1)
+                    if (r_R2())
+                      sbp.slice_del();
+                }
+                break;
+              case 7:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                among_var = sbp.find_among_b(a_4, 3);
+                if (among_var) {
+                  sbp.bra = sbp.cursor;
+                  if (among_var == 1)
+                    if (r_R2())
+                      sbp.slice_del();
+                }
+                break;
+              case 8:
+                if (!r_R2())
+                  return false;
+                sbp.slice_del();
+                sbp.ket = sbp.cursor;
+                if (sbp.eq_s_b(2, "at")) {
+                  sbp.bra = sbp.cursor;
+                  if (r_R2())
+                    sbp.slice_del();
+                }
+                break;
+              case 9:
+                if (!r_RV() || !sbp.eq_s_b(1, "e"))
+                  return false;
+                sbp.slice_from("ir");
+                break;
+            }
+            return true;
+          }
+
+          function r_verb_suffix() {
+            var among_var, v_1;
+            if (sbp.cursor >= I_pV) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_pV;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_6, 120);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                if (among_var == 1)
+                  sbp.slice_del();
+                sbp.limit_backward = v_1;
+                return true;
+              }
+              sbp.limit_backward = v_1;
+            }
+            return false;
+          }
+
+          function r_residual_suffix() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_7, 7);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (among_var == 1)
+                if (r_RV())
+                  sbp.slice_del();
+            }
+          }
+
+          function habr6(c1, c2) {
+            if (sbp.eq_s_b(1, c1)) {
+              sbp.bra = sbp.cursor;
+              var v_1 = sbp.limit - sbp.cursor;
+              if (sbp.eq_s_b(1, c2)) {
+                sbp.cursor = sbp.limit - v_1;
+                if (r_RV())
+                  sbp.slice_del();
+                return false;
+              }
+            }
+            return true;
+          }
+
+          function r_residual_form() {
+            var among_var, v_1, v_2, v_3;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_8, 4);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  if (r_RV()) {
+                    sbp.slice_del();
+                    sbp.ket = sbp.cursor;
+                    v_1 = sbp.limit - sbp.cursor;
+                    if (habr6("u", "g"))
+                      habr6("i", "c")
+                  }
+                  break;
+                case 2:
+                  sbp.slice_from("c");
+                  break;
+              }
+            }
+          }
+
+          function habr1() {
+            if (!r_standard_suffix()) {
+              sbp.cursor = sbp.limit;
+              if (!r_verb_suffix()) {
+                sbp.cursor = sbp.limit;
+                r_residual_suffix();
+                return;
+              }
+            }
+            sbp.cursor = sbp.limit;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "i")) {
+              sbp.bra = sbp.cursor;
+              if (sbp.eq_s_b(1, "c")) {
+                sbp.cursor = sbp.limit;
+                if (r_RV())
+                  sbp.slice_del();
+              }
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            habr1();
+            sbp.cursor = sbp.limit;
+            r_residual_form();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.pt.stemmer, 'stemmer-pt');
+
+    lunr.pt.stopWordFilter = lunr.generateStopWordFilter('a ao aos aquela aquelas aquele aqueles aquilo as até com como da das de dela delas dele deles depois do dos e ela elas ele eles em entre era eram essa essas esse esses esta estamos estas estava estavam este esteja estejam estejamos estes esteve estive estivemos estiver estivera estiveram estiverem estivermos estivesse estivessem estivéramos estivéssemos estou está estávamos estão eu foi fomos for fora foram forem formos fosse fossem fui fôramos fôssemos haja hajam hajamos havemos hei houve houvemos houver houvera houveram houverei houverem houveremos houveria houveriam houvermos houverá houverão houveríamos houvesse houvessem houvéramos houvéssemos há hão isso isto já lhe lhes mais mas me mesmo meu meus minha minhas muito na nas nem no nos nossa nossas nosso nossos num numa não nós o os ou para pela pelas pelo pelos por qual quando que quem se seja sejam sejamos sem serei seremos seria seriam será serão seríamos seu seus somos sou sua suas são só também te tem temos tenha tenham tenhamos tenho terei teremos teria teriam terá terão teríamos teu teus teve tinha tinham tive tivemos tiver tivera tiveram tiverem tivermos tivesse tivessem tivéramos tivéssemos tu tua tuas tém tínhamos um uma você vocês vos à às éramos'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.pt.stopWordFilter, 'stopWordFilter-pt');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.ro.js

@@ -0,0 +1,558 @@
+/*!
+ * Lunr languages, `Romanian` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.ro = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.ro.trimmer,
+        lunr.ro.stopWordFilter,
+        lunr.ro.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.ro.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.ro.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.ro.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.ro.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.ro.trimmer, 'trimmer-ro');
+
+    /* lunr stemmer function */
+    lunr.ro.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function RomanianStemmer() {
+          var a_0 = [new Among("", -1, 3), new Among("I", 0, 1), new Among("U", 0, 2)],
+            a_1 = [
+              new Among("ea", -1, 3), new Among("a\u0163ia", -1, 7),
+              new Among("aua", -1, 2), new Among("iua", -1, 4),
+              new Among("a\u0163ie", -1, 7), new Among("ele", -1, 3),
+              new Among("ile", -1, 5), new Among("iile", 6, 4),
+              new Among("iei", -1, 4), new Among("atei", -1, 6),
+              new Among("ii", -1, 4), new Among("ului", -1, 1),
+              new Among("ul", -1, 1), new Among("elor", -1, 3),
+              new Among("ilor", -1, 4), new Among("iilor", 14, 4)
+            ],
+            a_2 = [
+              new Among("icala", -1, 4), new Among("iciva", -1, 4),
+              new Among("ativa", -1, 5), new Among("itiva", -1, 6),
+              new Among("icale", -1, 4), new Among("a\u0163iune", -1, 5),
+              new Among("i\u0163iune", -1, 6), new Among("atoare", -1, 5),
+              new Among("itoare", -1, 6), new Among("\u0103toare", -1, 5),
+              new Among("icitate", -1, 4), new Among("abilitate", -1, 1),
+              new Among("ibilitate", -1, 2), new Among("ivitate", -1, 3),
+              new Among("icive", -1, 4), new Among("ative", -1, 5),
+              new Among("itive", -1, 6), new Among("icali", -1, 4),
+              new Among("atori", -1, 5), new Among("icatori", 18, 4),
+              new Among("itori", -1, 6), new Among("\u0103tori", -1, 5),
+              new Among("icitati", -1, 4), new Among("abilitati", -1, 1),
+              new Among("ivitati", -1, 3), new Among("icivi", -1, 4),
+              new Among("ativi", -1, 5), new Among("itivi", -1, 6),
+              new Among("icit\u0103i", -1, 4), new Among("abilit\u0103i", -1, 1),
+              new Among("ivit\u0103i", -1, 3),
+              new Among("icit\u0103\u0163i", -1, 4),
+              new Among("abilit\u0103\u0163i", -1, 1),
+              new Among("ivit\u0103\u0163i", -1, 3), new Among("ical", -1, 4),
+              new Among("ator", -1, 5), new Among("icator", 35, 4),
+              new Among("itor", -1, 6), new Among("\u0103tor", -1, 5),
+              new Among("iciv", -1, 4), new Among("ativ", -1, 5),
+              new Among("itiv", -1, 6), new Among("ical\u0103", -1, 4),
+              new Among("iciv\u0103", -1, 4), new Among("ativ\u0103", -1, 5),
+              new Among("itiv\u0103", -1, 6)
+            ],
+            a_3 = [new Among("ica", -1, 1),
+              new Among("abila", -1, 1), new Among("ibila", -1, 1),
+              new Among("oasa", -1, 1), new Among("ata", -1, 1),
+              new Among("ita", -1, 1), new Among("anta", -1, 1),
+              new Among("ista", -1, 3), new Among("uta", -1, 1),
+              new Among("iva", -1, 1), new Among("ic", -1, 1),
+              new Among("ice", -1, 1), new Among("abile", -1, 1),
+              new Among("ibile", -1, 1), new Among("isme", -1, 3),
+              new Among("iune", -1, 2), new Among("oase", -1, 1),
+              new Among("ate", -1, 1), new Among("itate", 17, 1),
+              new Among("ite", -1, 1), new Among("ante", -1, 1),
+              new Among("iste", -1, 3), new Among("ute", -1, 1),
+              new Among("ive", -1, 1), new Among("ici", -1, 1),
+              new Among("abili", -1, 1), new Among("ibili", -1, 1),
+              new Among("iuni", -1, 2), new Among("atori", -1, 1),
+              new Among("osi", -1, 1), new Among("ati", -1, 1),
+              new Among("itati", 30, 1), new Among("iti", -1, 1),
+              new Among("anti", -1, 1), new Among("isti", -1, 3),
+              new Among("uti", -1, 1), new Among("i\u015Fti", -1, 3),
+              new Among("ivi", -1, 1), new Among("it\u0103i", -1, 1),
+              new Among("o\u015Fi", -1, 1), new Among("it\u0103\u0163i", -1, 1),
+              new Among("abil", -1, 1), new Among("ibil", -1, 1),
+              new Among("ism", -1, 3), new Among("ator", -1, 1),
+              new Among("os", -1, 1), new Among("at", -1, 1),
+              new Among("it", -1, 1), new Among("ant", -1, 1),
+              new Among("ist", -1, 3), new Among("ut", -1, 1),
+              new Among("iv", -1, 1), new Among("ic\u0103", -1, 1),
+              new Among("abil\u0103", -1, 1), new Among("ibil\u0103", -1, 1),
+              new Among("oas\u0103", -1, 1), new Among("at\u0103", -1, 1),
+              new Among("it\u0103", -1, 1), new Among("ant\u0103", -1, 1),
+              new Among("ist\u0103", -1, 3), new Among("ut\u0103", -1, 1),
+              new Among("iv\u0103", -1, 1)
+            ],
+            a_4 = [new Among("ea", -1, 1),
+              new Among("ia", -1, 1), new Among("esc", -1, 1),
+              new Among("\u0103sc", -1, 1), new Among("ind", -1, 1),
+              new Among("\u00E2nd", -1, 1), new Among("are", -1, 1),
+              new Among("ere", -1, 1), new Among("ire", -1, 1),
+              new Among("\u00E2re", -1, 1), new Among("se", -1, 2),
+              new Among("ase", 10, 1), new Among("sese", 10, 2),
+              new Among("ise", 10, 1), new Among("use", 10, 1),
+              new Among("\u00E2se", 10, 1), new Among("e\u015Fte", -1, 1),
+              new Among("\u0103\u015Fte", -1, 1), new Among("eze", -1, 1),
+              new Among("ai", -1, 1), new Among("eai", 19, 1),
+              new Among("iai", 19, 1), new Among("sei", -1, 2),
+              new Among("e\u015Fti", -1, 1), new Among("\u0103\u015Fti", -1, 1),
+              new Among("ui", -1, 1), new Among("ezi", -1, 1),
+              new Among("\u00E2i", -1, 1), new Among("a\u015Fi", -1, 1),
+              new Among("se\u015Fi", -1, 2), new Among("ase\u015Fi", 29, 1),
+              new Among("sese\u015Fi", 29, 2), new Among("ise\u015Fi", 29, 1),
+              new Among("use\u015Fi", 29, 1),
+              new Among("\u00E2se\u015Fi", 29, 1), new Among("i\u015Fi", -1, 1),
+              new Among("u\u015Fi", -1, 1), new Among("\u00E2\u015Fi", -1, 1),
+              new Among("a\u0163i", -1, 2), new Among("ea\u0163i", 38, 1),
+              new Among("ia\u0163i", 38, 1), new Among("e\u0163i", -1, 2),
+              new Among("i\u0163i", -1, 2), new Among("\u00E2\u0163i", -1, 2),
+              new Among("ar\u0103\u0163i", -1, 1),
+              new Among("ser\u0103\u0163i", -1, 2),
+              new Among("aser\u0103\u0163i", 45, 1),
+              new Among("seser\u0103\u0163i", 45, 2),
+              new Among("iser\u0103\u0163i", 45, 1),
+              new Among("user\u0103\u0163i", 45, 1),
+              new Among("\u00E2ser\u0103\u0163i", 45, 1),
+              new Among("ir\u0103\u0163i", -1, 1),
+              new Among("ur\u0103\u0163i", -1, 1),
+              new Among("\u00E2r\u0103\u0163i", -1, 1), new Among("am", -1, 1),
+              new Among("eam", 54, 1), new Among("iam", 54, 1),
+              new Among("em", -1, 2), new Among("asem", 57, 1),
+              new Among("sesem", 57, 2), new Among("isem", 57, 1),
+              new Among("usem", 57, 1), new Among("\u00E2sem", 57, 1),
+              new Among("im", -1, 2), new Among("\u00E2m", -1, 2),
+              new Among("\u0103m", -1, 2), new Among("ar\u0103m", 65, 1),
+              new Among("ser\u0103m", 65, 2), new Among("aser\u0103m", 67, 1),
+              new Among("seser\u0103m", 67, 2), new Among("iser\u0103m", 67, 1),
+              new Among("user\u0103m", 67, 1),
+              new Among("\u00E2ser\u0103m", 67, 1),
+              new Among("ir\u0103m", 65, 1), new Among("ur\u0103m", 65, 1),
+              new Among("\u00E2r\u0103m", 65, 1), new Among("au", -1, 1),
+              new Among("eau", 76, 1), new Among("iau", 76, 1),
+              new Among("indu", -1, 1), new Among("\u00E2ndu", -1, 1),
+              new Among("ez", -1, 1), new Among("easc\u0103", -1, 1),
+              new Among("ar\u0103", -1, 1), new Among("ser\u0103", -1, 2),
+              new Among("aser\u0103", 84, 1), new Among("seser\u0103", 84, 2),
+              new Among("iser\u0103", 84, 1), new Among("user\u0103", 84, 1),
+              new Among("\u00E2ser\u0103", 84, 1), new Among("ir\u0103", -1, 1),
+              new Among("ur\u0103", -1, 1), new Among("\u00E2r\u0103", -1, 1),
+              new Among("eaz\u0103", -1, 1)
+            ],
+            a_5 = [new Among("a", -1, 1),
+              new Among("e", -1, 1), new Among("ie", 1, 1),
+              new Among("i", -1, 1), new Among("\u0103", -1, 1)
+            ],
+            g_v = [17, 65,
+              16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 32, 0, 0, 4
+            ],
+            B_standard_suffix_removed, I_p2, I_p1, I_pV, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function habr1(c1, c2) {
+            if (sbp.eq_s(1, c1)) {
+              sbp.ket = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 259))
+                sbp.slice_from(c2);
+            }
+          }
+
+          function r_prelude() {
+            var v_1, v_2;
+            while (true) {
+              v_1 = sbp.cursor;
+              if (sbp.in_grouping(g_v, 97, 259)) {
+                v_2 = sbp.cursor;
+                sbp.bra = v_2;
+                habr1("u", "U");
+                sbp.cursor = v_2;
+                habr1("i", "I");
+              }
+              sbp.cursor = v_1;
+              if (sbp.cursor >= sbp.limit) {
+                break;
+              }
+              sbp.cursor++;
+            }
+          }
+
+          function habr2() {
+            if (sbp.out_grouping(g_v, 97, 259)) {
+              while (!sbp.in_grouping(g_v, 97, 259)) {
+                if (sbp.cursor >= sbp.limit)
+                  return true;
+                sbp.cursor++;
+              }
+              return false;
+            }
+            return true;
+          }
+
+          function habr3() {
+            if (sbp.in_grouping(g_v, 97, 259)) {
+              while (!sbp.out_grouping(g_v, 97, 259)) {
+                if (sbp.cursor >= sbp.limit)
+                  return true;
+                sbp.cursor++;
+              }
+            }
+            return false;
+          }
+
+          function habr4() {
+            var v_1 = sbp.cursor,
+              v_2, v_3;
+            if (sbp.in_grouping(g_v, 97, 259)) {
+              v_2 = sbp.cursor;
+              if (habr2()) {
+                sbp.cursor = v_2;
+                if (!habr3()) {
+                  I_pV = sbp.cursor;
+                  return;
+                }
+              } else {
+                I_pV = sbp.cursor;
+                return;
+              }
+            }
+            sbp.cursor = v_1;
+            if (sbp.out_grouping(g_v, 97, 259)) {
+              v_3 = sbp.cursor;
+              if (habr2()) {
+                sbp.cursor = v_3;
+                if (sbp.in_grouping(g_v, 97, 259) && sbp.cursor < sbp.limit)
+                  sbp.cursor++;
+              }
+              I_pV = sbp.cursor;
+            }
+          }
+
+          function habr5() {
+            while (!sbp.in_grouping(g_v, 97, 259)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            while (!sbp.out_grouping(g_v, 97, 259)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function r_mark_regions() {
+            var v_1 = sbp.cursor;
+            I_pV = sbp.limit;
+            I_p1 = I_pV;
+            I_p2 = I_pV;
+            habr4();
+            sbp.cursor = v_1;
+            if (habr5()) {
+              I_p1 = sbp.cursor;
+              if (habr5())
+                I_p2 = sbp.cursor;
+            }
+          }
+
+          function r_postlude() {
+            var among_var;
+            while (true) {
+              sbp.bra = sbp.cursor;
+              among_var = sbp.find_among(a_0, 3);
+              if (among_var) {
+                sbp.ket = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("i");
+                    continue;
+                  case 2:
+                    sbp.slice_from("u");
+                    continue;
+                  case 3:
+                    if (sbp.cursor >= sbp.limit)
+                      break;
+                    sbp.cursor++;
+                    continue;
+                }
+              }
+              break;
+            }
+          }
+
+          function r_RV() {
+            return I_pV <= sbp.cursor;
+          }
+
+          function r_R1() {
+            return I_p1 <= sbp.cursor;
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function r_step_0() {
+            var among_var, v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_1, 16);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    sbp.slice_from("a");
+                    break;
+                  case 3:
+                    sbp.slice_from("e");
+                    break;
+                  case 4:
+                    sbp.slice_from("i");
+                    break;
+                  case 5:
+                    v_1 = sbp.limit - sbp.cursor;
+                    if (!sbp.eq_s_b(2, "ab")) {
+                      sbp.cursor = sbp.limit - v_1;
+                      sbp.slice_from("i");
+                    }
+                    break;
+                  case 6:
+                    sbp.slice_from("at");
+                    break;
+                  case 7:
+                    sbp.slice_from("a\u0163i");
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_combo_suffix() {
+            var among_var, v_1 = sbp.limit - sbp.cursor;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_2, 46);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R1()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_from("abil");
+                    break;
+                  case 2:
+                    sbp.slice_from("ibil");
+                    break;
+                  case 3:
+                    sbp.slice_from("iv");
+                    break;
+                  case 4:
+                    sbp.slice_from("ic");
+                    break;
+                  case 5:
+                    sbp.slice_from("at");
+                    break;
+                  case 6:
+                    sbp.slice_from("it");
+                    break;
+                }
+                B_standard_suffix_removed = true;
+                sbp.cursor = sbp.limit - v_1;
+                return true;
+              }
+            }
+            return false;
+          }
+
+          function r_standard_suffix() {
+            var among_var, v_1;
+            B_standard_suffix_removed = false;
+            while (true) {
+              v_1 = sbp.limit - sbp.cursor;
+              if (!r_combo_suffix()) {
+                sbp.cursor = sbp.limit - v_1;
+                break;
+              }
+            }
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_3, 62);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R2()) {
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    if (sbp.eq_s_b(1, "\u0163")) {
+                      sbp.bra = sbp.cursor;
+                      sbp.slice_from("t");
+                    }
+                    break;
+                  case 3:
+                    sbp.slice_from("ist");
+                    break;
+                }
+                B_standard_suffix_removed = true;
+              }
+            }
+          }
+
+          function r_verb_suffix() {
+            var among_var, v_1, v_2;
+            if (sbp.cursor >= I_pV) {
+              v_1 = sbp.limit_backward;
+              sbp.limit_backward = I_pV;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_4, 94);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    v_2 = sbp.limit - sbp.cursor;
+                    if (!sbp.out_grouping_b(g_v, 97, 259)) {
+                      sbp.cursor = sbp.limit - v_2;
+                      if (!sbp.eq_s_b(1, "u"))
+                        break;
+                    }
+                  case 2:
+                    sbp.slice_del();
+                    break;
+                }
+              }
+              sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_vowel_suffix() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_5, 5);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_RV() && among_var == 1)
+                sbp.slice_del();
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_prelude();
+            sbp.cursor = v_1;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_step_0();
+            sbp.cursor = sbp.limit;
+            r_standard_suffix();
+            sbp.cursor = sbp.limit;
+            if (!B_standard_suffix_removed) {
+              sbp.cursor = sbp.limit;
+              r_verb_suffix();
+              sbp.cursor = sbp.limit;
+            }
+            r_vowel_suffix();
+            sbp.cursor = sbp.limit_backward;
+            r_postlude();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.ro.stemmer, 'stemmer-ro');
+
+    lunr.ro.stopWordFilter = lunr.generateStopWordFilter('acea aceasta această aceea acei aceia acel acela acele acelea acest acesta aceste acestea aceşti aceştia acolo acord acum ai aia aibă aici al ale alea altceva altcineva am ar are asemenea asta astea astăzi asupra au avea avem aveţi azi aş aşadar aţi bine bucur bună ca care caut ce cel ceva chiar cinci cine cineva contra cu cum cumva curând curînd când cât câte câtva câţi cînd cît cîte cîtva cîţi că căci cărei căror cărui către da dacă dar datorită dată dau de deci deja deoarece departe deşi din dinaintea dintr- dintre doi doilea două drept după dă ea ei el ele eram este eu eşti face fata fi fie fiecare fii fim fiu fiţi frumos fără graţie halbă iar ieri la le li lor lui lângă lîngă mai mea mei mele mereu meu mi mie mine mult multă mulţi mulţumesc mâine mîine mă ne nevoie nici nicăieri nimeni nimeri nimic nişte noastre noastră noi noroc nostru nouă noştri nu opt ori oricare orice oricine oricum oricând oricât oricînd oricît oriunde patra patru patrulea pe pentru peste pic poate pot prea prima primul prin puţin puţina puţină până pînă rog sa sale sau se spate spre sub sunt suntem sunteţi sută sînt sîntem sînteţi să săi său ta tale te timp tine toate toată tot totuşi toţi trei treia treilea tu tăi tău un una unde undeva unei uneia unele uneori unii unor unora unu unui unuia unul vi voastre voastră voi vostru vouă voştri vreme vreo vreun vă zece zero zi zice îi îl îmi împotriva în  înainte înaintea încotro încât încît între întrucât întrucît îţi ăla ălea ăsta ăstea ăştia şapte şase şi ştiu ţi ţie'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.ro.stopWordFilter, 'stopWordFilter-ro');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.ru.js

@@ -0,0 +1,391 @@
+/*!
+ * Lunr languages, `Russian` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.ru = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.ru.trimmer,
+        lunr.ru.stopWordFilter,
+        lunr.ru.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.ru.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.ru.wordCharacters = "\u0400-\u0484\u0487-\u052F\u1D2B\u1D78\u2DE0-\u2DFF\uA640-\uA69F\uFE2E\uFE2F";
+    lunr.ru.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.ru.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.ru.trimmer, 'trimmer-ru');
+
+    /* lunr stemmer function */
+    lunr.ru.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function RussianStemmer() {
+          var a_0 = [new Among("\u0432", -1, 1), new Among("\u0438\u0432", 0, 2),
+              new Among("\u044B\u0432", 0, 2),
+              new Among("\u0432\u0448\u0438", -1, 1),
+              new Among("\u0438\u0432\u0448\u0438", 3, 2),
+              new Among("\u044B\u0432\u0448\u0438", 3, 2),
+              new Among("\u0432\u0448\u0438\u0441\u044C", -1, 1),
+              new Among("\u0438\u0432\u0448\u0438\u0441\u044C", 6, 2),
+              new Among("\u044B\u0432\u0448\u0438\u0441\u044C", 6, 2)
+            ],
+            a_1 = [
+              new Among("\u0435\u0435", -1, 1), new Among("\u0438\u0435", -1, 1),
+              new Among("\u043E\u0435", -1, 1), new Among("\u044B\u0435", -1, 1),
+              new Among("\u0438\u043C\u0438", -1, 1),
+              new Among("\u044B\u043C\u0438", -1, 1),
+              new Among("\u0435\u0439", -1, 1), new Among("\u0438\u0439", -1, 1),
+              new Among("\u043E\u0439", -1, 1), new Among("\u044B\u0439", -1, 1),
+              new Among("\u0435\u043C", -1, 1), new Among("\u0438\u043C", -1, 1),
+              new Among("\u043E\u043C", -1, 1), new Among("\u044B\u043C", -1, 1),
+              new Among("\u0435\u0433\u043E", -1, 1),
+              new Among("\u043E\u0433\u043E", -1, 1),
+              new Among("\u0435\u043C\u0443", -1, 1),
+              new Among("\u043E\u043C\u0443", -1, 1),
+              new Among("\u0438\u0445", -1, 1), new Among("\u044B\u0445", -1, 1),
+              new Among("\u0435\u044E", -1, 1), new Among("\u043E\u044E", -1, 1),
+              new Among("\u0443\u044E", -1, 1), new Among("\u044E\u044E", -1, 1),
+              new Among("\u0430\u044F", -1, 1), new Among("\u044F\u044F", -1, 1)
+            ],
+            a_2 = [
+              new Among("\u0435\u043C", -1, 1), new Among("\u043D\u043D", -1, 1),
+              new Among("\u0432\u0448", -1, 1),
+              new Among("\u0438\u0432\u0448", 2, 2),
+              new Among("\u044B\u0432\u0448", 2, 2), new Among("\u0449", -1, 1),
+              new Among("\u044E\u0449", 5, 1),
+              new Among("\u0443\u044E\u0449", 6, 2)
+            ],
+            a_3 = [
+              new Among("\u0441\u044C", -1, 1), new Among("\u0441\u044F", -1, 1)
+            ],
+            a_4 = [
+              new Among("\u043B\u0430", -1, 1),
+              new Among("\u0438\u043B\u0430", 0, 2),
+              new Among("\u044B\u043B\u0430", 0, 2),
+              new Among("\u043D\u0430", -1, 1),
+              new Among("\u0435\u043D\u0430", 3, 2),
+              new Among("\u0435\u0442\u0435", -1, 1),
+              new Among("\u0438\u0442\u0435", -1, 2),
+              new Among("\u0439\u0442\u0435", -1, 1),
+              new Among("\u0435\u0439\u0442\u0435", 7, 2),
+              new Among("\u0443\u0439\u0442\u0435", 7, 2),
+              new Among("\u043B\u0438", -1, 1),
+              new Among("\u0438\u043B\u0438", 10, 2),
+              new Among("\u044B\u043B\u0438", 10, 2), new Among("\u0439", -1, 1),
+              new Among("\u0435\u0439", 13, 2), new Among("\u0443\u0439", 13, 2),
+              new Among("\u043B", -1, 1), new Among("\u0438\u043B", 16, 2),
+              new Among("\u044B\u043B", 16, 2), new Among("\u0435\u043C", -1, 1),
+              new Among("\u0438\u043C", -1, 2), new Among("\u044B\u043C", -1, 2),
+              new Among("\u043D", -1, 1), new Among("\u0435\u043D", 22, 2),
+              new Among("\u043B\u043E", -1, 1),
+              new Among("\u0438\u043B\u043E", 24, 2),
+              new Among("\u044B\u043B\u043E", 24, 2),
+              new Among("\u043D\u043E", -1, 1),
+              new Among("\u0435\u043D\u043E", 27, 2),
+              new Among("\u043D\u043D\u043E", 27, 1),
+              new Among("\u0435\u0442", -1, 1),
+              new Among("\u0443\u0435\u0442", 30, 2),
+              new Among("\u0438\u0442", -1, 2), new Among("\u044B\u0442", -1, 2),
+              new Among("\u044E\u0442", -1, 1),
+              new Among("\u0443\u044E\u0442", 34, 2),
+              new Among("\u044F\u0442", -1, 2), new Among("\u043D\u044B", -1, 1),
+              new Among("\u0435\u043D\u044B", 37, 2),
+              new Among("\u0442\u044C", -1, 1),
+              new Among("\u0438\u0442\u044C", 39, 2),
+              new Among("\u044B\u0442\u044C", 39, 2),
+              new Among("\u0435\u0448\u044C", -1, 1),
+              new Among("\u0438\u0448\u044C", -1, 2), new Among("\u044E", -1, 2),
+              new Among("\u0443\u044E", 44, 2)
+            ],
+            a_5 = [
+              new Among("\u0430", -1, 1), new Among("\u0435\u0432", -1, 1),
+              new Among("\u043E\u0432", -1, 1), new Among("\u0435", -1, 1),
+              new Among("\u0438\u0435", 3, 1), new Among("\u044C\u0435", 3, 1),
+              new Among("\u0438", -1, 1), new Among("\u0435\u0438", 6, 1),
+              new Among("\u0438\u0438", 6, 1),
+              new Among("\u0430\u043C\u0438", 6, 1),
+              new Among("\u044F\u043C\u0438", 6, 1),
+              new Among("\u0438\u044F\u043C\u0438", 10, 1),
+              new Among("\u0439", -1, 1), new Among("\u0435\u0439", 12, 1),
+              new Among("\u0438\u0435\u0439", 13, 1),
+              new Among("\u0438\u0439", 12, 1), new Among("\u043E\u0439", 12, 1),
+              new Among("\u0430\u043C", -1, 1), new Among("\u0435\u043C", -1, 1),
+              new Among("\u0438\u0435\u043C", 18, 1),
+              new Among("\u043E\u043C", -1, 1), new Among("\u044F\u043C", -1, 1),
+              new Among("\u0438\u044F\u043C", 21, 1), new Among("\u043E", -1, 1),
+              new Among("\u0443", -1, 1), new Among("\u0430\u0445", -1, 1),
+              new Among("\u044F\u0445", -1, 1),
+              new Among("\u0438\u044F\u0445", 26, 1), new Among("\u044B", -1, 1),
+              new Among("\u044C", -1, 1), new Among("\u044E", -1, 1),
+              new Among("\u0438\u044E", 30, 1), new Among("\u044C\u044E", 30, 1),
+              new Among("\u044F", -1, 1), new Among("\u0438\u044F", 33, 1),
+              new Among("\u044C\u044F", 33, 1)
+            ],
+            a_6 = [
+              new Among("\u043E\u0441\u0442", -1, 1),
+              new Among("\u043E\u0441\u0442\u044C", -1, 1)
+            ],
+            a_7 = [
+              new Among("\u0435\u0439\u0448\u0435", -1, 1),
+              new Among("\u043D", -1, 2), new Among("\u0435\u0439\u0448", -1, 1),
+              new Among("\u044C", -1, 3)
+            ],
+            g_v = [33, 65, 8, 232],
+            I_p2, I_pV, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function habr3() {
+            while (!sbp.in_grouping(g_v, 1072, 1103)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function habr4() {
+            while (!sbp.out_grouping(g_v, 1072, 1103)) {
+              if (sbp.cursor >= sbp.limit)
+                return false;
+              sbp.cursor++;
+            }
+            return true;
+          }
+
+          function r_mark_regions() {
+            I_pV = sbp.limit;
+            I_p2 = I_pV;
+            if (habr3()) {
+              I_pV = sbp.cursor;
+              if (habr4())
+                if (habr3())
+                  if (habr4())
+                    I_p2 = sbp.cursor;
+            }
+          }
+
+          function r_R2() {
+            return I_p2 <= sbp.cursor;
+          }
+
+          function habr2(a, n) {
+            var among_var, v_1;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a, n);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  v_1 = sbp.limit - sbp.cursor;
+                  if (!sbp.eq_s_b(1, "\u0430")) {
+                    sbp.cursor = sbp.limit - v_1;
+                    if (!sbp.eq_s_b(1, "\u044F"))
+                      return false;
+                  }
+                case 2:
+                  sbp.slice_del();
+                  break;
+              }
+              return true;
+            }
+            return false;
+          }
+
+          function r_perfective_gerund() {
+            return habr2(a_0, 9);
+          }
+
+          function habr1(a, n) {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a, n);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (among_var == 1)
+                sbp.slice_del();
+              return true;
+            }
+            return false;
+          }
+
+          function r_adjective() {
+            return habr1(a_1, 26);
+          }
+
+          function r_adjectival() {
+            var among_var;
+            if (r_adjective()) {
+              habr2(a_2, 8);
+              return true;
+            }
+            return false;
+          }
+
+          function r_reflexive() {
+            return habr1(a_3, 2);
+          }
+
+          function r_verb() {
+            return habr2(a_4, 46);
+          }
+
+          function r_noun() {
+            habr1(a_5, 36);
+          }
+
+          function r_derivational() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_6, 2);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              if (r_R2() && among_var == 1)
+                sbp.slice_del();
+            }
+          }
+
+          function r_tidy_up() {
+            var among_var;
+            sbp.ket = sbp.cursor;
+            among_var = sbp.find_among_b(a_7, 4);
+            if (among_var) {
+              sbp.bra = sbp.cursor;
+              switch (among_var) {
+                case 1:
+                  sbp.slice_del();
+                  sbp.ket = sbp.cursor;
+                  if (!sbp.eq_s_b(1, "\u043D"))
+                    break;
+                  sbp.bra = sbp.cursor;
+                case 2:
+                  if (!sbp.eq_s_b(1, "\u043D"))
+                    break;
+                case 3:
+                  sbp.slice_del();
+                  break;
+              }
+            }
+          }
+          this.stem = function() {
+            r_mark_regions();
+            sbp.cursor = sbp.limit;
+            if (sbp.cursor < I_pV)
+              return false;
+            sbp.limit_backward = I_pV;
+            if (!r_perfective_gerund()) {
+              sbp.cursor = sbp.limit;
+              if (!r_reflexive())
+                sbp.cursor = sbp.limit;
+              if (!r_adjectival()) {
+                sbp.cursor = sbp.limit;
+                if (!r_verb()) {
+                  sbp.cursor = sbp.limit;
+                  r_noun();
+                }
+              }
+            }
+            sbp.cursor = sbp.limit;
+            sbp.ket = sbp.cursor;
+            if (sbp.eq_s_b(1, "\u0438")) {
+              sbp.bra = sbp.cursor;
+              sbp.slice_del();
+            } else
+              sbp.cursor = sbp.limit;
+            r_derivational();
+            sbp.cursor = sbp.limit;
+            r_tidy_up();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.ru.stemmer, 'stemmer-ru');
+
+    lunr.ru.stopWordFilter = lunr.generateStopWordFilter('алло без близко более больше будем будет будете будешь будто буду будут будь бы бывает бывь был была были было быть в важная важное важные важный вам вами вас ваш ваша ваше ваши вверх вдали вдруг ведь везде весь вниз внизу во вокруг вон восемнадцатый восемнадцать восемь восьмой вот впрочем времени время все всегда всего всем всеми всему всех всею всю всюду вся всё второй вы г где говорил говорит год года году да давно даже далеко дальше даром два двадцатый двадцать две двенадцатый двенадцать двух девятнадцатый девятнадцать девятый девять действительно дел день десятый десять для до довольно долго должно другая другие других друго другое другой е его ее ей ему если есть еще ещё ею её ж же жизнь за занят занята занято заняты затем зато зачем здесь значит и из или им именно иметь ими имя иногда их к каждая каждое каждые каждый кажется как какая какой кем когда кого ком кому конечно которая которого которой которые который которых кроме кругом кто куда лет ли лишь лучше люди м мало между меля менее меньше меня миллионов мимо мира мне много многочисленная многочисленное многочисленные многочисленный мной мною мог могут мож может можно можхо мои мой мор мочь моя моё мы на наверху над надо назад наиболее наконец нам нами нас начала наш наша наше наши не него недавно недалеко нее ней нельзя нем немного нему непрерывно нередко несколько нет нею неё ни нибудь ниже низко никогда никуда ними них ничего но ну нужно нх о об оба обычно один одиннадцатый одиннадцать однажды однако одного одной около он она они оно опять особенно от отовсюду отсюда очень первый перед по под пожалуйста позже пока пор пора после посреди потом потому почему почти прекрасно при про просто против процентов пятнадцатый пятнадцать пятый пять раз разве рано раньше рядом с сам сама сами самим самими самих само самого самой самом самому саму свое своего своей свои своих свою сеаой себе себя сегодня седьмой сейчас семнадцатый семнадцать семь сих сказал сказала сказать сколько слишком сначала снова со собой собою совсем спасибо стал суть т та так такая также такие такое такой там твой твоя твоё те тебе тебя тем теми теперь тех то тобой тобою тогда того тоже только том тому тот тою третий три тринадцатый тринадцать ту туда тут ты тысяч у уж уже уметь хорошо хотеть хоть хотя хочешь часто чаще чего человек чем чему через четвертый четыре четырнадцатый четырнадцать что чтоб чтобы чуть шестнадцатый шестнадцать шестой шесть эта эти этим этими этих это этого этой этом этому этот эту я а'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.ru.stopWordFilter, 'stopWordFilter-ru');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.stemmer.support.js

@@ -0,0 +1,304 @@
+/*!
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(factory)
+    } else if (typeof exports === 'object') {
+        /**
+         * Node. Does not work with strict CommonJS, but
+         * only CommonJS-like environments that support module.exports,
+         * like Node.
+         */
+        module.exports = factory()
+    } else {
+        // Browser globals (root is window)
+        factory()(root.lunr);
+    }
+}(this, function () {
+    /**
+     * Just return a value to define the module export.
+     * This example returns an object, but the module
+     * can return a function as the exported value.
+     */
+    return function(lunr) {
+        /* provides utilities for the included stemmers */
+        lunr.stemmerSupport = {
+            Among: function(s, substring_i, result, method) {
+                this.toCharArray = function(s) {
+                    var sLength = s.length, charArr = new Array(sLength);
+                    for (var i = 0; i < sLength; i++)
+                        charArr[i] = s.charCodeAt(i);
+                    return charArr;
+                };
+
+                if ((!s && s != "") || (!substring_i && (substring_i != 0)) || !result)
+                    throw ("Bad Among initialisation: s:" + s + ", substring_i: "
+                        + substring_i + ", result: " + result);
+                this.s_size = s.length;
+                this.s = this.toCharArray(s);
+                this.substring_i = substring_i;
+                this.result = result;
+                this.method = method;
+            },
+            SnowballProgram: function() {
+                var current;
+                return {
+                    bra : 0,
+                    ket : 0,
+                    limit : 0,
+                    cursor : 0,
+                    limit_backward : 0,
+                    setCurrent : function(word) {
+                        current = word;
+                        this.cursor = 0;
+                        this.limit = word.length;
+                        this.limit_backward = 0;
+                        this.bra = this.cursor;
+                        this.ket = this.limit;
+                    },
+                    getCurrent : function() {
+                        var result = current;
+                        current = null;
+                        return result;
+                    },
+                    in_grouping : function(s, min, max) {
+                        if (this.cursor < this.limit) {
+                            var ch = current.charCodeAt(this.cursor);
+                            if (ch <= max && ch >= min) {
+                                ch -= min;
+                                if (s[ch >> 3] & (0X1 << (ch & 0X7))) {
+                                    this.cursor++;
+                                    return true;
+                                }
+                            }
+                        }
+                        return false;
+                    },
+                    in_grouping_b : function(s, min, max) {
+                        if (this.cursor > this.limit_backward) {
+                            var ch = current.charCodeAt(this.cursor - 1);
+                            if (ch <= max && ch >= min) {
+                                ch -= min;
+                                if (s[ch >> 3] & (0X1 << (ch & 0X7))) {
+                                    this.cursor--;
+                                    return true;
+                                }
+                            }
+                        }
+                        return false;
+                    },
+                    out_grouping : function(s, min, max) {
+                        if (this.cursor < this.limit) {
+                            var ch = current.charCodeAt(this.cursor);
+                            if (ch > max || ch < min) {
+                                this.cursor++;
+                                return true;
+                            }
+                            ch -= min;
+                            if (!(s[ch >> 3] & (0X1 << (ch & 0X7)))) {
+                                this.cursor++;
+                                return true;
+                            }
+                        }
+                        return false;
+                    },
+                    out_grouping_b : function(s, min, max) {
+                        if (this.cursor > this.limit_backward) {
+                            var ch = current.charCodeAt(this.cursor - 1);
+                            if (ch > max || ch < min) {
+                                this.cursor--;
+                                return true;
+                            }
+                            ch -= min;
+                            if (!(s[ch >> 3] & (0X1 << (ch & 0X7)))) {
+                                this.cursor--;
+                                return true;
+                            }
+                        }
+                        return false;
+                    },
+                    eq_s : function(s_size, s) {
+                        if (this.limit - this.cursor < s_size)
+                            return false;
+                        for (var i = 0; i < s_size; i++)
+                            if (current.charCodeAt(this.cursor + i) != s.charCodeAt(i))
+                                return false;
+                        this.cursor += s_size;
+                        return true;
+                    },
+                    eq_s_b : function(s_size, s) {
+                        if (this.cursor - this.limit_backward < s_size)
+                            return false;
+                        for (var i = 0; i < s_size; i++)
+                            if (current.charCodeAt(this.cursor - s_size + i) != s
+                                .charCodeAt(i))
+                                return false;
+                        this.cursor -= s_size;
+                        return true;
+                    },
+                    find_among : function(v, v_size) {
+                        var i = 0, j = v_size, c = this.cursor, l = this.limit, common_i = 0, common_j = 0, first_key_inspected = false;
+                        while (true) {
+                            var k = i + ((j - i) >> 1), diff = 0, common = common_i < common_j
+                                ? common_i
+                                : common_j, w = v[k];
+                            for (var i2 = common; i2 < w.s_size; i2++) {
+                                if (c + common == l) {
+                                    diff = -1;
+                                    break;
+                                }
+                                diff = current.charCodeAt(c + common) - w.s[i2];
+                                if (diff)
+                                    break;
+                                common++;
+                            }
+                            if (diff < 0) {
+                                j = k;
+                                common_j = common;
+                            } else {
+                                i = k;
+                                common_i = common;
+                            }
+                            if (j - i <= 1) {
+                                if (i > 0 || j == i || first_key_inspected)
+                                    break;
+                                first_key_inspected = true;
+                            }
+                        }
+                        while (true) {
+                            var w = v[i];
+                            if (common_i >= w.s_size) {
+                                this.cursor = c + w.s_size;
+                                if (!w.method)
+                                    return w.result;
+                                var res = w.method();
+                                this.cursor = c + w.s_size;
+                                if (res)
+                                    return w.result;
+                            }
+                            i = w.substring_i;
+                            if (i < 0)
+                                return 0;
+                        }
+                    },
+                    find_among_b : function(v, v_size) {
+                        var i = 0, j = v_size, c = this.cursor, lb = this.limit_backward, common_i = 0, common_j = 0, first_key_inspected = false;
+                        while (true) {
+                            var k = i + ((j - i) >> 1), diff = 0, common = common_i < common_j
+                                ? common_i
+                                : common_j, w = v[k];
+                            for (var i2 = w.s_size - 1 - common; i2 >= 0; i2--) {
+                                if (c - common == lb) {
+                                    diff = -1;
+                                    break;
+                                }
+                                diff = current.charCodeAt(c - 1 - common) - w.s[i2];
+                                if (diff)
+                                    break;
+                                common++;
+                            }
+                            if (diff < 0) {
+                                j = k;
+                                common_j = common;
+                            } else {
+                                i = k;
+                                common_i = common;
+                            }
+                            if (j - i <= 1) {
+                                if (i > 0 || j == i || first_key_inspected)
+                                    break;
+                                first_key_inspected = true;
+                            }
+                        }
+                        while (true) {
+                            var w = v[i];
+                            if (common_i >= w.s_size) {
+                                this.cursor = c - w.s_size;
+                                if (!w.method)
+                                    return w.result;
+                                var res = w.method();
+                                this.cursor = c - w.s_size;
+                                if (res)
+                                    return w.result;
+                            }
+                            i = w.substring_i;
+                            if (i < 0)
+                                return 0;
+                        }
+                    },
+                    replace_s : function(c_bra, c_ket, s) {
+                        var adjustment = s.length - (c_ket - c_bra), left = current
+                            .substring(0, c_bra), right = current.substring(c_ket);
+                        current = left + s + right;
+                        this.limit += adjustment;
+                        if (this.cursor >= c_ket)
+                            this.cursor += adjustment;
+                        else if (this.cursor > c_bra)
+                            this.cursor = c_bra;
+                        return adjustment;
+                    },
+                    slice_check : function() {
+                        if (this.bra < 0 || this.bra > this.ket || this.ket > this.limit
+                            || this.limit > current.length)
+                            throw ("faulty slice operation");
+                    },
+                    slice_from : function(s) {
+                        this.slice_check();
+                        this.replace_s(this.bra, this.ket, s);
+                    },
+                    slice_del : function() {
+                        this.slice_from("");
+                    },
+                    insert : function(c_bra, c_ket, s) {
+                        var adjustment = this.replace_s(c_bra, c_ket, s);
+                        if (c_bra <= this.bra)
+                            this.bra += adjustment;
+                        if (c_bra <= this.ket)
+                            this.ket += adjustment;
+                    },
+                    slice_to : function() {
+                        this.slice_check();
+                        return current.substring(this.bra, this.ket);
+                    },
+                    eq_v_b : function(s) {
+                        return this.eq_s_b(s.length, s);
+                    }
+                };
+            }
+        };
+
+        lunr.trimmerSupport = {
+            generateTrimmer: function(wordCharacters) {
+                var startRegex = new RegExp("^[^" + wordCharacters + "]+")
+                var endRegex = new RegExp("[^" + wordCharacters + "]+$")
+
+                return function(token) {
+                    // for lunr version 2
+                    if (typeof token.update === "function") {
+                        return token.update(function (s) {
+                            return s
+                                .replace(startRegex, '')
+                                .replace(endRegex, '');
+                        })
+                    } else { // for lunr version 1
+                        return token
+                            .replace(startRegex, '')
+                            .replace(endRegex, '');
+                    }
+                };
+            }
+        }
+    }
+}));

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.sv.js

@@ -0,0 +1,256 @@
+/*!
+ * Lunr languages, `Swedish` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2014, Mihai Valentin
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.sv = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.sv.trimmer,
+        lunr.sv.stopWordFilter,
+        lunr.sv.stemmer
+      );
+
+      // for lunr version 2
+      // this is necessary so that every searched word is also stemmed before
+      // in lunr <= 1 this is not needed, as it is done using the normal pipeline
+      if (this.searchPipeline) {
+        this.searchPipeline.reset();
+        this.searchPipeline.add(lunr.sv.stemmer)
+      }
+    };
+
+    /* lunr trimmer function */
+    lunr.sv.wordCharacters = "A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A";
+    lunr.sv.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.sv.wordCharacters);
+
+    lunr.Pipeline.registerFunction(lunr.sv.trimmer, 'trimmer-sv');
+
+    /* lunr stemmer function */
+    lunr.sv.stemmer = (function() {
+      /* create the wrapped stemmer object */
+      var Among = lunr.stemmerSupport.Among,
+        SnowballProgram = lunr.stemmerSupport.SnowballProgram,
+        st = new function SwedishStemmer() {
+          var a_0 = [new Among("a", -1, 1), new Among("arna", 0, 1),
+              new Among("erna", 0, 1), new Among("heterna", 2, 1),
+              new Among("orna", 0, 1), new Among("ad", -1, 1),
+              new Among("e", -1, 1), new Among("ade", 6, 1),
+              new Among("ande", 6, 1), new Among("arne", 6, 1),
+              new Among("are", 6, 1), new Among("aste", 6, 1),
+              new Among("en", -1, 1), new Among("anden", 12, 1),
+              new Among("aren", 12, 1), new Among("heten", 12, 1),
+              new Among("ern", -1, 1), new Among("ar", -1, 1),
+              new Among("er", -1, 1), new Among("heter", 18, 1),
+              new Among("or", -1, 1), new Among("s", -1, 2),
+              new Among("as", 21, 1), new Among("arnas", 22, 1),
+              new Among("ernas", 22, 1), new Among("ornas", 22, 1),
+              new Among("es", 21, 1), new Among("ades", 26, 1),
+              new Among("andes", 26, 1), new Among("ens", 21, 1),
+              new Among("arens", 29, 1), new Among("hetens", 29, 1),
+              new Among("erns", 21, 1), new Among("at", -1, 1),
+              new Among("andet", -1, 1), new Among("het", -1, 1),
+              new Among("ast", -1, 1)
+            ],
+            a_1 = [new Among("dd", -1, -1),
+              new Among("gd", -1, -1), new Among("nn", -1, -1),
+              new Among("dt", -1, -1), new Among("gt", -1, -1),
+              new Among("kt", -1, -1), new Among("tt", -1, -1)
+            ],
+            a_2 = [
+              new Among("ig", -1, 1), new Among("lig", 0, 1),
+              new Among("els", -1, 1), new Among("fullt", -1, 3),
+              new Among("l\u00F6st", -1, 2)
+            ],
+            g_v = [17, 65, 16, 1, 0, 0, 0, 0,
+              0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 32
+            ],
+            g_s_ending = [119, 127, 149],
+            I_x, I_p1, sbp = new SnowballProgram();
+          this.setCurrent = function(word) {
+            sbp.setCurrent(word);
+          };
+          this.getCurrent = function() {
+            return sbp.getCurrent();
+          };
+
+          function r_mark_regions() {
+            var v_1, c = sbp.cursor + 3;
+            I_p1 = sbp.limit;
+            if (0 <= c || c <= sbp.limit) {
+              I_x = c;
+              while (true) {
+                v_1 = sbp.cursor;
+                if (sbp.in_grouping(g_v, 97, 246)) {
+                  sbp.cursor = v_1;
+                  break;
+                }
+                sbp.cursor = v_1;
+                if (sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              while (!sbp.out_grouping(g_v, 97, 246)) {
+                if (sbp.cursor >= sbp.limit)
+                  return;
+                sbp.cursor++;
+              }
+              I_p1 = sbp.cursor;
+              if (I_p1 < I_x)
+                I_p1 = I_x;
+            }
+          }
+
+          function r_main_suffix() {
+            var among_var, v_2 = sbp.limit_backward;
+            if (sbp.cursor >= I_p1) {
+              sbp.limit_backward = I_p1;
+              sbp.cursor = sbp.limit;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_0, 37);
+              sbp.limit_backward = v_2;
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    if (sbp.in_grouping_b(g_s_ending, 98, 121))
+                      sbp.slice_del();
+                    break;
+                }
+              }
+            }
+          }
+
+          function r_consonant_pair() {
+            var v_1 = sbp.limit_backward;
+            if (sbp.cursor >= I_p1) {
+              sbp.limit_backward = I_p1;
+              sbp.cursor = sbp.limit;
+              if (sbp.find_among_b(a_1, 7)) {
+                sbp.cursor = sbp.limit;
+                sbp.ket = sbp.cursor;
+                if (sbp.cursor > sbp.limit_backward) {
+                  sbp.bra = --sbp.cursor;
+                  sbp.slice_del();
+                }
+              }
+              sbp.limit_backward = v_1;
+            }
+          }
+
+          function r_other_suffix() {
+            var among_var, v_2;
+            if (sbp.cursor >= I_p1) {
+              v_2 = sbp.limit_backward;
+              sbp.limit_backward = I_p1;
+              sbp.cursor = sbp.limit;
+              sbp.ket = sbp.cursor;
+              among_var = sbp.find_among_b(a_2, 5);
+              if (among_var) {
+                sbp.bra = sbp.cursor;
+                switch (among_var) {
+                  case 1:
+                    sbp.slice_del();
+                    break;
+                  case 2:
+                    sbp.slice_from("l\u00F6s");
+                    break;
+                  case 3:
+                    sbp.slice_from("full");
+                    break;
+                }
+              }
+              sbp.limit_backward = v_2;
+            }
+          }
+          this.stem = function() {
+            var v_1 = sbp.cursor;
+            r_mark_regions();
+            sbp.limit_backward = v_1;
+            sbp.cursor = sbp.limit;
+            r_main_suffix();
+            sbp.cursor = sbp.limit;
+            r_consonant_pair();
+            sbp.cursor = sbp.limit;
+            r_other_suffix();
+            return true;
+          }
+        };
+
+      /* and return a function that stems a word for the current locale */
+      return function(token) {
+        // for lunr version 2
+        if (typeof token.update === "function") {
+          return token.update(function(word) {
+            st.setCurrent(word);
+            st.stem();
+            return st.getCurrent();
+          })
+        } else { // for lunr version <= 1
+          st.setCurrent(token);
+          st.stem();
+          return st.getCurrent();
+        }
+      }
+    })();
+
+    lunr.Pipeline.registerFunction(lunr.sv.stemmer, 'stemmer-sv');
+
+    lunr.sv.stopWordFilter = lunr.generateStopWordFilter('alla allt att av blev bli blir blivit de dem den denna deras dess dessa det detta dig din dina ditt du där då efter ej eller en er era ert ett från för ha hade han hans har henne hennes hon honom hur här i icke ingen inom inte jag ju kan kunde man med mellan men mig min mina mitt mot mycket ni nu när någon något några och om oss på samma sedan sig sin sina sitta själv skulle som så sådan sådana sådant till under upp ut utan vad var vara varför varit varje vars vart vem vi vid vilka vilkas vilken vilket vår våra vårt än är åt över'.split(' '));
+
+    lunr.Pipeline.registerFunction(lunr.sv.stopWordFilter, 'stopWordFilter-sv');
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.th.js

@@ -0,0 +1,97 @@
+/*!
+ * Lunr languages, `Thai` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2017, Keerati Thiwanruk
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /*
+    Thai tokenization is the same to Japanense, which does not take into account spaces.
+    So, it uses the same logic to assign tokenization function due to different Lunr versions.
+    */
+    var isLunr2 = lunr.version[0] == "2";
+
+    /* register specific locale function */
+    lunr.th = function() {
+        this.pipeline.reset();
+        this.pipeline.add(
+            /*lunr.th.stopWordFilter,*/
+            lunr.th.trimmer
+        );
+
+        if (isLunr2) { // for lunr version 2.0.0
+            this.tokenizer = lunr.th.tokenizer;
+        } else {
+            if (lunr.tokenizer) { // for lunr version 0.6.0
+                lunr.tokenizer = lunr.th.tokenizer;
+            }
+            if (this.tokenizerFn) { // for lunr version 0.7.0 -> 1.0.0
+                this.tokenizerFn = lunr.th.tokenizer;
+            }
+        }
+    };
+
+    /* lunr trimmer function */
+    lunr.th.wordCharacters = "[\u0e00-\u0e7f]";
+    lunr.th.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.th.wordCharacters);
+    lunr.Pipeline.registerFunction(lunr.th.trimmer, 'trimmer-th');
+
+    var segmenter = lunr.wordcut;
+    segmenter.init();
+    lunr.th.tokenizer = function (obj) {
+      //console.log(obj);
+      if (!arguments.length || obj == null || obj == undefined) return []
+      if (Array.isArray(obj)) return obj.map(function (t) { return isLunr2 ? new lunr.Token(t) : t })
+
+      var str = obj.toString().replace(/^\s+/, '');
+      return segmenter.cut(str).split('|');
+    }
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/lunr.vi.js

@@ -0,0 +1,84 @@
+/*!
+ * Lunr languages, `Vietnamese` language
+ * https://github.com/MihaiValentin/lunr-languages
+ *
+ * Copyright 2017, Keerati Thiwanruk
+ * http://www.mozilla.org/MPL/
+ */
+/*!
+ * based on
+ * Snowball JavaScript Library v0.3
+ * http://code.google.com/p/urim/
+ * http://snowball.tartarus.org/
+ *
+ * Copyright 2010, Oleg Mazko
+ * http://www.mozilla.org/MPL/
+ */
+
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(factory)
+  } else if (typeof exports === 'object') {
+    /**
+     * Node. Does not work with strict CommonJS, but
+     * only CommonJS-like environments that support module.exports,
+     * like Node.
+     */
+    module.exports = factory()
+  } else {
+    // Browser globals (root is window)
+    factory()(root.lunr);
+  }
+}(this, function() {
+  /**
+   * Just return a value to define the module export.
+   * This example returns an object, but the module
+   * can return a function as the exported value.
+   */
+  return function(lunr) {
+    /* throw error if lunr is not yet included */
+    if ('undefined' === typeof lunr) {
+      throw new Error('Lunr is not present. Please include / require Lunr before this script.');
+    }
+
+    /* throw error if lunr stemmer support is not yet included */
+    if ('undefined' === typeof lunr.stemmerSupport) {
+      throw new Error('Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.');
+    }
+
+    /* register specific locale function */
+    lunr.vi = function() {
+      this.pipeline.reset();
+      this.pipeline.add(
+        lunr.vi.stopWordFilter,
+        lunr.vi.trimmer
+      );
+    };
+
+    /* lunr trimmer function */
+    lunr.vi.wordCharacters = "[" +
+      "A-Za-z" +
+      "\u0300\u0350" + // dấu huyền
+      "\u0301\u0351" + // dấu sắc
+      "\u0309" + // dấu hỏi
+      "\u0323" + // dấu nặng
+      "\u0303\u0343" + // dấu ngã
+      "\u00C2\u00E2" + // Â
+      "\u00CA\u00EA" + // Ê
+      "\u00D4\u00F4" + // Ô
+      "\u0102-\u0103" + // Ă
+      "\u0110-\u0111" + // Đ
+      "\u01A0-\u01A1" + // Ơ
+      "\u01AF-\u01B0" + // Ư
+      "]";
+    lunr.vi.trimmer = lunr.trimmerSupport.generateTrimmer(lunr.vi.wordCharacters);
+    lunr.Pipeline.registerFunction(lunr.vi.trimmer, 'trimmer-vi');
+    lunr.vi.stopWordFilter = lunr.generateStopWordFilter('là cái nhưng mà'.split(' '));
+  };
+}))

venv/lib/python3.11/site-packages/mkdocs/contrib/search/lunr-language/tinyseg.js

@@ -0,0 +1,206 @@
+/**
+ * export the module via AMD, CommonJS or as a browser global
+ * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
+ */
+;(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(factory)
+    } else if (typeof exports === 'object') {
+        /**
+         * Node. Does not work with strict CommonJS, but
+         * only CommonJS-like environments that support module.exports,
+         * like Node.
+         */
+        module.exports = factory()
+    } else {
+        // Browser globals (root is window)
+        factory()(root.lunr);
+    }
+}(this, function () {
+    /**
+     * Just return a value to define the module export.
+     * This example returns an object, but the module
+     * can return a function as the exported value.
+     */
+
+    return function(lunr) {
+        // TinySegmenter 0.1 -- Super compact Japanese tokenizer in Javascript
+        // (c) 2008 Taku Kudo <taku@chasen.org>
+        // TinySegmenter is freely distributable under the terms of a new BSD licence.
+        // For details, see http://chasen.org/~taku/software/TinySegmenter/LICENCE.txt
+
+        function TinySegmenter() {
+          var patterns = {
+            "[一二三四五六七八九十百千万億兆]":"M",
+            "[一-龠々〆ヵヶ]":"H",
+            "[ぁ-ん]":"I",
+            "[ァ-ヴーｱ-ﾝﾞｰ]":"K",
+            "[a-zA-Zａ-ｚＡ-Ｚ]":"A",
+            "[0-9０-９]":"N"
+          }
+          this.chartype_ = [];
+          for (var i in patterns) {
+            var regexp = new RegExp(i);
+            this.chartype_.push([regexp, patterns[i]]);
+          }
+
+          this.BIAS__ = -332
+          this.BC1__ = {"HH":6,"II":2461,"KH":406,"OH":-1378};
+          this.BC2__ = {"AA":-3267,"AI":2744,"AN":-878,"HH":-4070,"HM":-1711,"HN":4012,"HO":3761,"IA":1327,"IH":-1184,"II":-1332,"IK":1721,"IO":5492,"KI":3831,"KK":-8741,"MH":-3132,"MK":3334,"OO":-2920};
+          this.BC3__ = {"HH":996,"HI":626,"HK":-721,"HN":-1307,"HO":-836,"IH":-301,"KK":2762,"MK":1079,"MM":4034,"OA":-1652,"OH":266};
+          this.BP1__ = {"BB":295,"OB":304,"OO":-125,"UB":352};
+          this.BP2__ = {"BO":60,"OO":-1762};
+          this.BQ1__ = {"BHH":1150,"BHM":1521,"BII":-1158,"BIM":886,"BMH":1208,"BNH":449,"BOH":-91,"BOO":-2597,"OHI":451,"OIH":-296,"OKA":1851,"OKH":-1020,"OKK":904,"OOO":2965};
+          this.BQ2__ = {"BHH":118,"BHI":-1159,"BHM":466,"BIH":-919,"BKK":-1720,"BKO":864,"OHH":-1139,"OHM":-181,"OIH":153,"UHI":-1146};
+          this.BQ3__ = {"BHH":-792,"BHI":2664,"BII":-299,"BKI":419,"BMH":937,"BMM":8335,"BNN":998,"BOH":775,"OHH":2174,"OHM":439,"OII":280,"OKH":1798,"OKI":-793,"OKO":-2242,"OMH":-2402,"OOO":11699};
+          this.BQ4__ = {"BHH":-3895,"BIH":3761,"BII":-4654,"BIK":1348,"BKK":-1806,"BMI":-3385,"BOO":-12396,"OAH":926,"OHH":266,"OHK":-2036,"ONN":-973};
+          this.BW1__ = {",と":660,",同":727,"B1あ":1404,"B1同":542,"、と":660,"、同":727,"」と":1682,"あっ":1505,"いう":1743,"いっ":-2055,"いる":672,"うし":-4817,"うん":665,"から":3472,"がら":600,"こう":-790,"こと":2083,"こん":-1262,"さら":-4143,"さん":4573,"した":2641,"して":1104,"すで":-3399,"そこ":1977,"それ":-871,"たち":1122,"ため":601,"った":3463,"つい":-802,"てい":805,"てき":1249,"でき":1127,"です":3445,"では":844,"とい":-4915,"とみ":1922,"どこ":3887,"ない":5713,"なっ":3015,"など":7379,"なん":-1113,"にし":2468,"には":1498,"にも":1671,"に対":-912,"の一":-501,"の中":741,"ませ":2448,"まで":1711,"まま":2600,"まる":-2155,"やむ":-1947,"よっ":-2565,"れた":2369,"れで":-913,"をし":1860,"を見":731,"亡く":-1886,"京都":2558,"取り":-2784,"大き":-2604,"大阪":1497,"平方":-2314,"引き":-1336,"日本":-195,"本当":-2423,"毎日":-2113,"目指":-724,"Ｂ１あ":1404,"Ｂ１同":542,"｣と":1682};
+          this.BW2__ = {"..":-11822,"11":-669,"――":-5730,"−−":-13175,"いう":-1609,"うか":2490,"かし":-1350,"かも":-602,"から":-7194,"かれ":4612,"がい":853,"がら":-3198,"きた":1941,"くな":-1597,"こと":-8392,"この":-4193,"させ":4533,"され":13168,"さん":-3977,"しい":-1819,"しか":-545,"した":5078,"して":972,"しな":939,"その":-3744,"たい":-1253,"たた":-662,"ただ":-3857,"たち":-786,"たと":1224,"たは":-939,"った":4589,"って":1647,"っと":-2094,"てい":6144,"てき":3640,"てく":2551,"ては":-3110,"ても":-3065,"でい":2666,"でき":-1528,"でし":-3828,"です":-4761,"でも":-4203,"とい":1890,"とこ":-1746,"とと":-2279,"との":720,"とみ":5168,"とも":-3941,"ない":-2488,"なが":-1313,"など":-6509,"なの":2614,"なん":3099,"にお":-1615,"にし":2748,"にな":2454,"によ":-7236,"に対":-14943,"に従":-4688,"に関":-11388,"のか":2093,"ので":-7059,"のに":-6041,"のの":-6125,"はい":1073,"はが":-1033,"はず":-2532,"ばれ":1813,"まし":-1316,"まで":-6621,"まれ":5409,"めて":-3153,"もい":2230,"もの":-10713,"らか":-944,"らし":-1611,"らに":-1897,"りし":651,"りま":1620,"れた":4270,"れて":849,"れば":4114,"ろう":6067,"われ":7901,"を通":-11877,"んだ":728,"んな":-4115,"一人":602,"一方":-1375,"一日":970,"一部":-1051,"上が":-4479,"会社":-1116,"出て":2163,"分の":-7758,"同党":970,"同日":-913,"大阪":-2471,"委員":-1250,"少な":-1050,"年度":-8669,"年間":-1626,"府県":-2363,"手権":-1982,"新聞":-4066,"日新":-722,"日本":-7068,"日米":3372,"曜日":-601,"朝鮮":-2355,"本人":-2697,"東京":-1543,"然と":-1384,"社会":-1276,"立て":-990,"第に":-1612,"米国":-4268,"１１":-669};
+          this.BW3__ = {"あた":-2194,"あり":719,"ある":3846,"い.":-1185,"い。":-1185,"いい":5308,"いえ":2079,"いく":3029,"いた":2056,"いっ":1883,"いる":5600,"いわ":1527,"うち":1117,"うと":4798,"えと":1454,"か.":2857,"か。":2857,"かけ":-743,"かっ":-4098,"かに":-669,"から":6520,"かり":-2670,"が,":1816,"が、":1816,"がき":-4855,"がけ":-1127,"がっ":-913,"がら":-4977,"がり":-2064,"きた":1645,"けど":1374,"こと":7397,"この":1542,"ころ":-2757,"さい":-714,"さを":976,"し,":1557,"し、":1557,"しい":-3714,"した":3562,"して":1449,"しな":2608,"しま":1200,"す.":-1310,"す。":-1310,"する":6521,"ず,":3426,"ず、":3426,"ずに":841,"そう":428,"た.":8875,"た。":8875,"たい":-594,"たの":812,"たり":-1183,"たる":-853,"だ.":4098,"だ。":4098,"だっ":1004,"った":-4748,"って":300,"てい":6240,"てお":855,"ても":302,"です":1437,"でに":-1482,"では":2295,"とう":-1387,"とし":2266,"との":541,"とも":-3543,"どう":4664,"ない":1796,"なく":-903,"など":2135,"に,":-1021,"に、":-1021,"にし":1771,"にな":1906,"には":2644,"の,":-724,"の、":-724,"の子":-1000,"は,":1337,"は、":1337,"べき":2181,"まし":1113,"ます":6943,"まっ":-1549,"まで":6154,"まれ":-793,"らし":1479,"られ":6820,"るる":3818,"れ,":854,"れ、":854,"れた":1850,"れて":1375,"れば":-3246,"れる":1091,"われ":-605,"んだ":606,"んで":798,"カ月":990,"会議":860,"入り":1232,"大会":2217,"始め":1681,"市":965,"新聞":-5055,"日,":974,"日、":974,"社会":2024,"ｶ月":990};
+          this.TC1__ = {"AAA":1093,"HHH":1029,"HHM":580,"HII":998,"HOH":-390,"HOM":-331,"IHI":1169,"IOH":-142,"IOI":-1015,"IOM":467,"MMH":187,"OOI":-1832};
+          this.TC2__ = {"HHO":2088,"HII":-1023,"HMM":-1154,"IHI":-1965,"KKH":703,"OII":-2649};
+          this.TC3__ = {"AAA":-294,"HHH":346,"HHI":-341,"HII":-1088,"HIK":731,"HOH":-1486,"IHH":128,"IHI":-3041,"IHO":-1935,"IIH":-825,"IIM":-1035,"IOI":-542,"KHH":-1216,"KKA":491,"KKH":-1217,"KOK":-1009,"MHH":-2694,"MHM":-457,"MHO":123,"MMH":-471,"NNH":-1689,"NNO":662,"OHO":-3393};
+          this.TC4__ = {"HHH":-203,"HHI":1344,"HHK":365,"HHM":-122,"HHN":182,"HHO":669,"HIH":804,"HII":679,"HOH":446,"IHH":695,"IHO":-2324,"IIH":321,"III":1497,"IIO":656,"IOO":54,"KAK":4845,"KKA":3386,"KKK":3065,"MHH":-405,"MHI":201,"MMH":-241,"MMM":661,"MOM":841};
+          this.TQ1__ = {"BHHH":-227,"BHHI":316,"BHIH":-132,"BIHH":60,"BIII":1595,"BNHH":-744,"BOHH":225,"BOOO":-908,"OAKK":482,"OHHH":281,"OHIH":249,"OIHI":200,"OIIH":-68};
+          this.TQ2__ = {"BIHH":-1401,"BIII":-1033,"BKAK":-543,"BOOO":-5591};
+          this.TQ3__ = {"BHHH":478,"BHHM":-1073,"BHIH":222,"BHII":-504,"BIIH":-116,"BIII":-105,"BMHI":-863,"BMHM":-464,"BOMH":620,"OHHH":346,"OHHI":1729,"OHII":997,"OHMH":481,"OIHH":623,"OIIH":1344,"OKAK":2792,"OKHH":587,"OKKA":679,"OOHH":110,"OOII":-685};
+          this.TQ4__ = {"BHHH":-721,"BHHM":-3604,"BHII":-966,"BIIH":-607,"BIII":-2181,"OAAA":-2763,"OAKK":180,"OHHH":-294,"OHHI":2446,"OHHO":480,"OHIH":-1573,"OIHH":1935,"OIHI":-493,"OIIH":626,"OIII":-4007,"OKAK":-8156};
+          this.TW1__ = {"につい":-4681,"東京都":2026};
+          this.TW2__ = {"ある程":-2049,"いった":-1256,"ころが":-2434,"しょう":3873,"その後":-4430,"だって":-1049,"ていた":1833,"として":-4657,"ともに":-4517,"もので":1882,"一気に":-792,"初めて":-1512,"同時に":-8097,"大きな":-1255,"対して":-2721,"社会党":-3216};
+          this.TW3__ = {"いただ":-1734,"してい":1314,"として":-4314,"につい":-5483,"にとっ":-5989,"に当た":-6247,"ので,":-727,"ので、":-727,"のもの":-600,"れから":-3752,"十二月":-2287};
+          this.TW4__ = {"いう.":8576,"いう。":8576,"からな":-2348,"してい":2958,"たが,":1516,"たが、":1516,"ている":1538,"という":1349,"ました":5543,"ません":1097,"ようと":-4258,"よると":5865};
+          this.UC1__ = {"A":484,"K":93,"M":645,"O":-505};
+          this.UC2__ = {"A":819,"H":1059,"I":409,"M":3987,"N":5775,"O":646};
+          this.UC3__ = {"A":-1370,"I":2311};
+          this.UC4__ = {"A":-2643,"H":1809,"I":-1032,"K":-3450,"M":3565,"N":3876,"O":6646};
+          this.UC5__ = {"H":313,"I":-1238,"K":-799,"M":539,"O":-831};
+          this.UC6__ = {"H":-506,"I":-253,"K":87,"M":247,"O":-387};
+          this.UP1__ = {"O":-214};
+          this.UP2__ = {"B":69,"O":935};
+          this.UP3__ = {"B":189};
+          this.UQ1__ = {"BH":21,"BI":-12,"BK":-99,"BN":142,"BO":-56,"OH":-95,"OI":477,"OK":410,"OO":-2422};
+          this.UQ2__ = {"BH":216,"BI":113,"OK":1759};
+          this.UQ3__ = {"BA":-479,"BH":42,"BI":1913,"BK":-7198,"BM":3160,"BN":6427,"BO":14761,"OI":-827,"ON":-3212};
+          this.UW1__ = {",":156,"、":156,"「":-463,"あ":-941,"う":-127,"が":-553,"き":121,"こ":505,"で":-201,"と":-547,"ど":-123,"に":-789,"の":-185,"は":-847,"も":-466,"や":-470,"よ":182,"ら":-292,"り":208,"れ":169,"を":-446,"ん":-137,"・":-135,"主":-402,"京":-268,"区":-912,"午":871,"国":-460,"大":561,"委":729,"市":-411,"日":-141,"理":361,"生":-408,"県":-386,"都":-718,"｢":-463,"･":-135};
+          this.UW2__ = {",":-829,"、":-829,"〇":892,"「":-645,"」":3145,"あ":-538,"い":505,"う":134,"お":-502,"か":1454,"が":-856,"く":-412,"こ":1141,"さ":878,"ざ":540,"し":1529,"す":-675,"せ":300,"そ":-1011,"た":188,"だ":1837,"つ":-949,"て":-291,"で":-268,"と":-981,"ど":1273,"な":1063,"に":-1764,"の":130,"は":-409,"ひ":-1273,"べ":1261,"ま":600,"も":-1263,"や":-402,"よ":1639,"り":-579,"る":-694,"れ":571,"を":-2516,"ん":2095,"ア":-587,"カ":306,"キ":568,"ッ":831,"三":-758,"不":-2150,"世":-302,"中":-968,"主":-861,"事":492,"人":-123,"会":978,"保":362,"入":548,"初":-3025,"副":-1566,"北":-3414,"区":-422,"大":-1769,"天":-865,"太":-483,"子":-1519,"学":760,"実":1023,"小":-2009,"市":-813,"年":-1060,"強":1067,"手":-1519,"揺":-1033,"政":1522,"文":-1355,"新":-1682,"日":-1815,"明":-1462,"最":-630,"朝":-1843,"本":-1650,"東":-931,"果":-665,"次":-2378,"民":-180,"気":-1740,"理":752,"発":529,"目":-1584,"相":-242,"県":-1165,"立":-763,"第":810,"米":509,"自":-1353,"行":838,"西":-744,"見":-3874,"調":1010,"議":1198,"込":3041,"開":1758,"間":-1257,"｢":-645,"｣":3145,"ｯ":831,"ｱ":-587,"ｶ":306,"ｷ":568};
+          this.UW3__ = {",":4889,"1":-800,"−":-1723,"、":4889,"々":-2311,"〇":5827,"」":2670,"〓":-3573,"あ":-2696,"い":1006,"う":2342,"え":1983,"お":-4864,"か":-1163,"が":3271,"く":1004,"け":388,"げ":401,"こ":-3552,"ご":-3116,"さ":-1058,"し":-395,"す":584,"せ":3685,"そ":-5228,"た":842,"ち":-521,"っ":-1444,"つ":-1081,"て":6167,"で":2318,"と":1691,"ど":-899,"な":-2788,"に":2745,"の":4056,"は":4555,"ひ":-2171,"ふ":-1798,"へ":1199,"ほ":-5516,"ま":-4384,"み":-120,"め":1205,"も":2323,"や":-788,"よ":-202,"ら":727,"り":649,"る":5905,"れ":2773,"わ":-1207,"を":6620,"ん":-518,"ア":551,"グ":1319,"ス":874,"ッ":-1350,"ト":521,"ム":1109,"ル":1591,"ロ":2201,"ン":278,"・":-3794,"一":-1619,"下":-1759,"世":-2087,"両":3815,"中":653,"主":-758,"予":-1193,"二":974,"人":2742,"今":792,"他":1889,"以":-1368,"低":811,"何":4265,"作":-361,"保":-2439,"元":4858,"党":3593,"全":1574,"公":-3030,"六":755,"共":-1880,"円":5807,"再":3095,"分":457,"初":2475,"別":1129,"前":2286,"副":4437,"力":365,"動":-949,"務":-1872,"化":1327,"北":-1038,"区":4646,"千":-2309,"午":-783,"協":-1006,"口":483,"右":1233,"各":3588,"合":-241,"同":3906,"和":-837,"員":4513,"国":642,"型":1389,"場":1219,"外":-241,"妻":2016,"学":-1356,"安":-423,"実":-1008,"家":1078,"小":-513,"少":-3102,"州":1155,"市":3197,"平":-1804,"年":2416,"広":-1030,"府":1605,"度":1452,"建":-2352,"当":-3885,"得":1905,"思":-1291,"性":1822,"戸":-488,"指":-3973,"政":-2013,"教":-1479,"数":3222,"文":-1489,"新":1764,"日":2099,"旧":5792,"昨":-661,"時":-1248,"曜":-951,"最":-937,"月":4125,"期":360,"李":3094,"村":364,"東":-805,"核":5156,"森":2438,"業":484,"氏":2613,"民":-1694,"決":-1073,"法":1868,"海":-495,"無":979,"物":461,"特":-3850,"生":-273,"用":914,"町":1215,"的":7313,"直":-1835,"省":792,"県":6293,"知":-1528,"私":4231,"税":401,"立":-960,"第":1201,"米":7767,"系":3066,"約":3663,"級":1384,"統":-4229,"総":1163,"線":1255,"者":6457,"能":725,"自":-2869,"英":785,"見":1044,"調":-562,"財":-733,"費":1777,"車":1835,"軍":1375,"込":-1504,"通":-1136,"選":-681,"郎":1026,"郡":4404,"部":1200,"金":2163,"長":421,"開":-1432,"間":1302,"関":-1282,"雨":2009,"電":-1045,"非":2066,"駅":1620,"１":-800,"｣":2670,"･":-3794,"ｯ":-1350,"ｱ":551,"ｸﾞ":1319,"ｽ":874,"ﾄ":521,"ﾑ":1109,"ﾙ":1591,"ﾛ":2201,"ﾝ":278};
+          this.UW4__ = {",":3930,".":3508,"―":-4841,"、":3930,"。":3508,"〇":4999,"「":1895,"」":3798,"〓":-5156,"あ":4752,"い":-3435,"う":-640,"え":-2514,"お":2405,"か":530,"が":6006,"き":-4482,"ぎ":-3821,"く":-3788,"け":-4376,"げ":-4734,"こ":2255,"ご":1979,"さ":2864,"し":-843,"じ":-2506,"す":-731,"ず":1251,"せ":181,"そ":4091,"た":5034,"だ":5408,"ち":-3654,"っ":-5882,"つ":-1659,"て":3994,"で":7410,"と":4547,"な":5433,"に":6499,"ぬ":1853,"ね":1413,"の":7396,"は":8578,"ば":1940,"ひ":4249,"び":-4134,"ふ":1345,"へ":6665,"べ":-744,"ほ":1464,"ま":1051,"み":-2082,"む":-882,"め":-5046,"も":4169,"ゃ":-2666,"や":2795,"ょ":-1544,"よ":3351,"ら":-2922,"り":-9726,"る":-14896,"れ":-2613,"ろ":-4570,"わ":-1783,"を":13150,"ん":-2352,"カ":2145,"コ":1789,"セ":1287,"ッ":-724,"ト":-403,"メ":-1635,"ラ":-881,"リ":-541,"ル":-856,"ン":-3637,"・":-4371,"ー":-11870,"一":-2069,"中":2210,"予":782,"事":-190,"井":-1768,"人":1036,"以":544,"会":950,"体":-1286,"作":530,"側":4292,"先":601,"党":-2006,"共":-1212,"内":584,"円":788,"初":1347,"前":1623,"副":3879,"力":-302,"動":-740,"務":-2715,"化":776,"区":4517,"協":1013,"参":1555,"合":-1834,"和":-681,"員":-910,"器":-851,"回":1500,"国":-619,"園":-1200,"地":866,"場":-1410,"塁":-2094,"士":-1413,"多":1067,"大":571,"子":-4802,"学":-1397,"定":-1057,"寺":-809,"小":1910,"屋":-1328,"山":-1500,"島":-2056,"川":-2667,"市":2771,"年":374,"庁":-4556,"後":456,"性":553,"感":916,"所":-1566,"支":856,"改":787,"政":2182,"教":704,"文":522,"方":-856,"日":1798,"時":1829,"最":845,"月":-9066,"木":-485,"来":-442,"校":-360,"業":-1043,"氏":5388,"民":-2716,"気":-910,"沢":-939,"済":-543,"物":-735,"率":672,"球":-1267,"生":-1286,"産":-1101,"田":-2900,"町":1826,"的":2586,"目":922,"省":-3485,"県":2997,"空":-867,"立":-2112,"第":788,"米":2937,"系":786,"約":2171,"経":1146,"統":-1169,"総":940,"線":-994,"署":749,"者":2145,"能":-730,"般":-852,"行":-792,"規":792,"警":-1184,"議":-244,"谷":-1000,"賞":730,"車":-1481,"軍":1158,"輪":-1433,"込":-3370,"近":929,"道":-1291,"選":2596,"郎":-4866,"都":1192,"野":-1100,"銀":-2213,"長":357,"間":-2344,"院":-2297,"際":-2604,"電":-878,"領":-1659,"題":-792,"館":-1984,"首":1749,"高":2120,"｢":1895,"｣":3798,"･":-4371,"ｯ":-724,"ｰ":-11870,"ｶ":2145,"ｺ":1789,"ｾ":1287,"ﾄ":-403,"ﾒ":-1635,"ﾗ":-881,"ﾘ":-541,"ﾙ":-856,"ﾝ":-3637};
+          this.UW5__ = {",":465,".":-299,"1":-514,"E2":-32768,"]":-2762,"、":465,"。":-299,"「":363,"あ":1655,"い":331,"う":-503,"え":1199,"お":527,"か":647,"が":-421,"き":1624,"ぎ":1971,"く":312,"げ":-983,"さ":-1537,"し":-1371,"す":-852,"だ":-1186,"ち":1093,"っ":52,"つ":921,"て":-18,"で":-850,"と":-127,"ど":1682,"な":-787,"に":-1224,"の":-635,"は":-578,"べ":1001,"み":502,"め":865,"ゃ":3350,"ょ":854,"り":-208,"る":429,"れ":504,"わ":419,"を":-1264,"ん":327,"イ":241,"ル":451,"ン":-343,"中":-871,"京":722,"会":-1153,"党":-654,"務":3519,"区":-901,"告":848,"員":2104,"大":-1296,"学":-548,"定":1785,"嵐":-1304,"市":-2991,"席":921,"年":1763,"思":872,"所":-814,"挙":1618,"新":-1682,"日":218,"月":-4353,"査":932,"格":1356,"機":-1508,"氏":-1347,"田":240,"町":-3912,"的":-3149,"相":1319,"省":-1052,"県":-4003,"研":-997,"社":-278,"空":-813,"統":1955,"者":-2233,"表":663,"語":-1073,"議":1219,"選":-1018,"郎":-368,"長":786,"間":1191,"題":2368,"館":-689,"１":-514,"Ｅ２":-32768,"｢":363,"ｲ":241,"ﾙ":451,"ﾝ":-343};
+          this.UW6__ = {",":227,".":808,"1":-270,"E1":306,"、":227,"。":808,"あ":-307,"う":189,"か":241,"が":-73,"く":-121,"こ":-200,"じ":1782,"す":383,"た":-428,"っ":573,"て":-1014,"で":101,"と":-105,"な":-253,"に":-149,"の":-417,"は":-236,"も":-206,"り":187,"る":-135,"を":195,"ル":-673,"ン":-496,"一":-277,"中":201,"件":-800,"会":624,"前":302,"区":1792,"員":-1212,"委":798,"学":-960,"市":887,"広":-695,"後":535,"業":-697,"相":753,"社":-507,"福":974,"空":-822,"者":1811,"連":463,"郎":1082,"１":-270,"Ｅ１":306,"ﾙ":-673,"ﾝ":-496};
+          
+          return this;
+        }
+        TinySegmenter.prototype.ctype_ = function(str) {
+          for (var i in this.chartype_) {
+            if (str.match(this.chartype_[i][0])) {
+              return this.chartype_[i][1];
+            }
+          }
+          return "O";
+        }
+
+        TinySegmenter.prototype.ts_ = function(v) {
+          if (v) { return v; }
+          return 0;
+        }
+
+        TinySegmenter.prototype.segment = function(input) {
+          if (input == null || input == undefined || input == "") {
+            return [];
+          }
+          var result = [];
+          var seg = ["B3","B2","B1"];
+          var ctype = ["O","O","O"];
+          var o = input.split("");
+          for (i = 0; i < o.length; ++i) {
+            seg.push(o[i]);
+            ctype.push(this.ctype_(o[i]))
+          }
+          seg.push("E1");
+          seg.push("E2");
+          seg.push("E3");
+          ctype.push("O");
+          ctype.push("O");
+          ctype.push("O");
+          var word = seg[3];
+          var p1 = "U";
+          var p2 = "U";
+          var p3 = "U";
+          for (var i = 4; i < seg.length - 3; ++i) {
+            var score = this.BIAS__;
+            var w1 = seg[i-3];
+            var w2 = seg[i-2];
+            var w3 = seg[i-1];
+            var w4 = seg[i];
+            var w5 = seg[i+1];
+            var w6 = seg[i+2];
+            var c1 = ctype[i-3];
+            var c2 = ctype[i-2];
+            var c3 = ctype[i-1];
+            var c4 = ctype[i];
+            var c5 = ctype[i+1];
+            var c6 = ctype[i+2];
+            score += this.ts_(this.UP1__[p1]);
+            score += this.ts_(this.UP2__[p2]);
+            score += this.ts_(this.UP3__[p3]);
+            score += this.ts_(this.BP1__[p1 + p2]);
+            score += this.ts_(this.BP2__[p2 + p3]);
+            score += this.ts_(this.UW1__[w1]);
+            score += this.ts_(this.UW2__[w2]);
+            score += this.ts_(this.UW3__[w3]);
+            score += this.ts_(this.UW4__[w4]);
+            score += this.ts_(this.UW5__[w5]);
+            score += this.ts_(this.UW6__[w6]);
+            score += this.ts_(this.BW1__[w2 + w3]);
+            score += this.ts_(this.BW2__[w3 + w4]);
+            score += this.ts_(this.BW3__[w4 + w5]);
+            score += this.ts_(this.TW1__[w1 + w2 + w3]);
+            score += this.ts_(this.TW2__[w2 + w3 + w4]);
+            score += this.ts_(this.TW3__[w3 + w4 + w5]);
+            score += this.ts_(this.TW4__[w4 + w5 + w6]);
+            score += this.ts_(this.UC1__[c1]);
+            score += this.ts_(this.UC2__[c2]);
+            score += this.ts_(this.UC3__[c3]);
+            score += this.ts_(this.UC4__[c4]);
+            score += this.ts_(this.UC5__[c5]);
+            score += this.ts_(this.UC6__[c6]);
+            score += this.ts_(this.BC1__[c2 + c3]);
+            score += this.ts_(this.BC2__[c3 + c4]);
+            score += this.ts_(this.BC3__[c4 + c5]);
+            score += this.ts_(this.TC1__[c1 + c2 + c3]);
+            score += this.ts_(this.TC2__[c2 + c3 + c4]);
+            score += this.ts_(this.TC3__[c3 + c4 + c5]);
+            score += this.ts_(this.TC4__[c4 + c5 + c6]);
+        //  score += this.ts_(this.TC5__[c4 + c5 + c6]);    
+            score += this.ts_(this.UQ1__[p1 + c1]);
+            score += this.ts_(this.UQ2__[p2 + c2]);
+            score += this.ts_(this.UQ3__[p3 + c3]);
+            score += this.ts_(this.BQ1__[p2 + c2 + c3]);
+            score += this.ts_(this.BQ2__[p2 + c3 + c4]);
+            score += this.ts_(this.BQ3__[p3 + c2 + c3]);
+            score += this.ts_(this.BQ4__[p3 + c3 + c4]);
+            score += this.ts_(this.TQ1__[p2 + c1 + c2 + c3]);
+            score += this.ts_(this.TQ2__[p2 + c2 + c3 + c4]);
+            score += this.ts_(this.TQ3__[p3 + c1 + c2 + c3]);
+            score += this.ts_(this.TQ4__[p3 + c2 + c3 + c4]);
+            var p = "O";
+            if (score > 0) {
+              result.push(word);
+              word = "";
+              p = "B";
+            }
+            p1 = p2;
+            p2 = p3;
+            p3 = p;
+            word += seg[i];
+          }
+          result.push(word);
+
+          return result;
+        }
+
+        lunr.TinySegmenter = TinySegmenter;
+    };
+
+}));

venv/lib/python3.11/site-packages/mkdocs/contrib/search/prebuild-index.js

@@ -0,0 +1,56 @@
+var lunr = require('./templates/search/lunr'),
+    stdin = process.stdin,
+    stdout = process.stdout,
+    buffer = [];
+
+stdin.resume();
+stdin.setEncoding('utf8');
+
+stdin.on('data', function (data) {
+  buffer.push(data);
+});
+
+stdin.on('end', function () {
+  var data = JSON.parse(buffer.join('')),
+      lang = ['en'];
+
+  if (data.config) {
+    if (data.config.lang && data.config.lang.length) {
+      lang = data.config.lang;
+      if (lang.length > 1 || lang[0] !== "en") {
+        require('./lunr-language/lunr.stemmer.support')(lunr);
+        if (lang.length > 1) {
+          require('./lunr-language/lunr.multi')(lunr);
+        }
+        if (lang.includes("ja") || lang.includes("jp")) {
+          require('./lunr-language/tinyseg')(lunr);
+        }
+        for (var i=0; i < lang.length; i++) {
+          if (lang[i] != 'en') {
+            require('./lunr-language/lunr.' + lang[i])(lunr);
+          }
+        }
+      }
+    }
+    if (data.config.separator && data.config.separator.length) {
+      lunr.tokenizer.separator = new RegExp(data.config.separator);
+    }
+  }
+
+  var idx = lunr(function () {
+    if (lang.length === 1 && lang[0] !== "en" && lunr[lang[0]]) {
+      this.use(lunr[lang[0]]);
+    } else if (lang.length > 1) {
+      this.use(lunr.multiLanguage.apply(null, lang));
+    }
+    this.field('title');
+    this.field('text');
+    this.ref('location');
+
+    data.docs.forEach(function (doc) {
+      this.add(doc);
+    }, this);
+  });
+
+  stdout.write(JSON.stringify(idx));
+});

venv/lib/python3.11/site-packages/mkdocs/contrib/search/search_index.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import subprocess
+from html.parser import HTMLParser
+from typing import List, Optional, Tuple
+
+from mkdocs.structure.pages import Page
+from mkdocs.structure.toc import AnchorLink, TableOfContents
+
+try:
+    from lunr import lunr
+
+    haslunrpy = True
+except ImportError:
+    haslunrpy = False
+
+log = logging.getLogger(__name__)
+
+
+class SearchIndex:
+    """
+    Search index is a collection of pages and sections (heading
+    tags and their following content are sections).
+    """
+
+    def __init__(self, **config) -> None:
+        self._entries: List[dict] = []
+        self.config = config
+
+    def _find_toc_by_id(self, toc, id_: Optional[str]) -> Optional[AnchorLink]:
+        """
+        Given a table of contents and HTML ID, iterate through
+        and return the matched item in the TOC.
+        """
+        for toc_item in toc:
+            if toc_item.id == id_:
+                return toc_item
+            toc_item_r = self._find_toc_by_id(toc_item.children, id_)
+            if toc_item_r is not None:
+                return toc_item_r
+        return None
+
+    def _add_entry(self, title: Optional[str], text: str, loc: str) -> None:
+        """
+        A simple wrapper to add an entry, dropping bad characters.
+        """
+        text = text.replace('\u00a0', ' ')
+        text = re.sub(r'[ \t\n\r\f\v]+', ' ', text.strip())
+
+        self._entries.append({'title': title, 'text': text, 'location': loc})
+
+    def add_entry_from_context(self, page: Page) -> None:
+        """
+        Create a set of entries in the index for a page. One for
+        the page itself and then one for each of its' heading
+        tags.
+        """
+        # Create the content parser and feed in the HTML for the
+        # full page. This handles all the parsing and prepares
+        # us to iterate through it.
+        parser = ContentParser()
+        assert page.content is not None
+        parser.feed(page.content)
+        parser.close()
+
+        # Get the absolute URL for the page, this is then
+        # prepended to the urls of the sections
+        url = page.url
+
+        # Create an entry for the full page.
+        text = parser.stripped_html.rstrip('\n') if self.config['indexing'] == 'full' else ''
+        self._add_entry(title=page.title, text=text, loc=url)
+
+        if self.config['indexing'] in ['full', 'sections']:
+            for section in parser.data:
+                self.create_entry_for_section(section, page.toc, url)
+
+    def create_entry_for_section(
+        self, section: ContentSection, toc: TableOfContents, abs_url: str
+    ) -> None:
+        """
+        Given a section on the page, the table of contents and
+        the absolute url for the page create an entry in the
+        index
+        """
+        toc_item = self._find_toc_by_id(toc, section.id)
+
+        text = ' '.join(section.text) if self.config['indexing'] == 'full' else ''
+        if toc_item is not None:
+            self._add_entry(title=toc_item.title, text=text, loc=abs_url + toc_item.url)
+
+    def generate_search_index(self) -> str:
+        """python to json conversion"""
+        page_dicts = {'docs': self._entries, 'config': self.config}
+        data = json.dumps(page_dicts, sort_keys=True, separators=(',', ':'), default=str)
+
+        if self.config['prebuild_index'] in (True, 'node'):
+            try:
+                script_path = os.path.join(
+                    os.path.dirname(os.path.abspath(__file__)), 'prebuild-index.js'
+                )
+                p = subprocess.Popen(
+                    ['node', script_path],
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    encoding='utf-8',
+                )
+                idx, err = p.communicate(data)
+                if not err:
+                    page_dicts['index'] = json.loads(idx)
+                    data = json.dumps(page_dicts, sort_keys=True, separators=(',', ':'))
+                    log.debug('Pre-built search index created successfully.')
+                else:
+                    log.warning(f'Failed to pre-build search index. Error: {err}')
+            except (OSError, ValueError) as e:
+                log.warning(f'Failed to pre-build search index. Error: {e}')
+        elif self.config['prebuild_index'] == 'python':
+            if haslunrpy:
+                lunr_idx = lunr(
+                    ref='location',
+                    fields=('title', 'text'),
+                    documents=self._entries,
+                    languages=self.config['lang'],
+                )
+                page_dicts['index'] = lunr_idx.serialize()
+                data = json.dumps(page_dicts, sort_keys=True, separators=(',', ':'))
+            else:
+                log.warning(
+                    "Failed to pre-build search index. The 'python' method was specified; "
+                    "however, the 'lunr.py' library does not appear to be installed. Try "
+                    "installing it with 'pip install lunr'. If you are using any language "
+                    "other than English you will also need to install 'lunr[languages]'."
+                )
+
+        return data
+
+
+class ContentSection:
+    """
+    Used by the ContentParser class to capture the information we
+    need when it is parsing the HMTL.
+    """
+
+    def __init__(
+        self,
+        text: Optional[List[str]] = None,
+        id_: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> None:
+        self.text = text or []
+        self.id = id_
+        self.title = title
+
+    def __eq__(self, other):
+        return self.text == other.text and self.id == other.id and self.title == other.title
+
+
+_HEADER_TAGS = tuple(f"h{x}" for x in range(1, 7))
+
+
+class ContentParser(HTMLParser):
+    """
+    Given a block of HTML, group the content under the preceding
+    heading tags which can then be used for creating an index
+    for that section.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.data: List[ContentSection] = []
+        self.section: Optional[ContentSection] = None
+        self.is_header_tag = False
+        self._stripped_html: List[str] = []
+
+    def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None:
+        """Called at the start of every HTML tag."""
+
+        # We only care about the opening tag for headings.
+        if tag not in _HEADER_TAGS:
+            return
+
+        # We are dealing with a new header, create a new section
+        # for it and assign the ID if it has one.
+        self.is_header_tag = True
+        self.section = ContentSection()
+        self.data.append(self.section)
+
+        for attr in attrs:
+            if attr[0] == "id":
+                self.section.id = attr[1]
+
+    def handle_endtag(self, tag: str) -> None:
+        """Called at the end of every HTML tag."""
+
+        # We only care about the opening tag for headings.
+        if tag not in _HEADER_TAGS:
+            return
+
+        self.is_header_tag = False
+
+    def handle_data(self, data: str) -> None:
+        """
+        Called for the text contents of each tag.
+        """
+        self._stripped_html.append(data)
+
+        if self.section is None:
+            # This means we have some content at the start of the
+            # HTML before we reach a heading tag. We don't actually
+            # care about that content as it will be added to the
+            # overall page entry in the search. So just skip it.
+            return
+
+        # If this is a header, then the data is the title.
+        # Otherwise it is content of something under that header
+        # section.
+        if self.is_header_tag:
+            self.section.title = data
+        else:
+            self.section.text.append(data.rstrip('\n'))
+
+    @property
+    def stripped_html(self) -> str:
+        return '\n'.join(self._stripped_html)

venv/lib/python3.11/site-packages/mkdocs/contrib/search/templates/search/main.js

@@ -0,0 +1,109 @@
+function getSearchTermFromLocation() {
+  var sPageURL = window.location.search.substring(1);
+  var sURLVariables = sPageURL.split('&');
+  for (var i = 0; i < sURLVariables.length; i++) {
+    var sParameterName = sURLVariables[i].split('=');
+    if (sParameterName[0] == 'q') {
+      return decodeURIComponent(sParameterName[1].replace(/\+/g, '%20'));
+    }
+  }
+}
+
+function joinUrl (base, path) {
+  if (path.substring(0, 1) === "/") {
+    // path starts with `/`. Thus it is absolute.
+    return path;
+  }
+  if (base.substring(base.length-1) === "/") {
+    // base ends with `/`
+    return base + path;
+  }
+  return base + "/" + path;
+}
+
+function escapeHtml (value) {
+  return value.replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function formatResult (location, title, summary) {
+  return '<article><h3><a href="' + joinUrl(base_url, location) + '">'+ escapeHtml(title) + '</a></h3><p>' + escapeHtml(summary) +'</p></article>';
+}
+
+function displayResults (results) {
+  var search_results = document.getElementById("mkdocs-search-results");
+  while (search_results.firstChild) {
+    search_results.removeChild(search_results.firstChild);
+  }
+  if (results.length > 0){
+    for (var i=0; i < results.length; i++){
+      var result = results[i];
+      var html = formatResult(result.location, result.title, result.summary);
+      search_results.insertAdjacentHTML('beforeend', html);
+    }
+  } else {
+    var noResultsText = search_results.getAttribute('data-no-results-text');
+    if (!noResultsText) {
+      noResultsText = "No results found";
+    }
+    search_results.insertAdjacentHTML('beforeend', '<p>' + noResultsText + '</p>');
+  }
+}
+
+function doSearch () {
+  var query = document.getElementById('mkdocs-search-query').value;
+  if (query.length > min_search_length) {
+    if (!window.Worker) {
+      displayResults(search(query));
+    } else {
+      searchWorker.postMessage({query: query});
+    }
+  } else {
+    // Clear results for short queries
+    displayResults([]);
+  }
+}
+
+function initSearch () {
+  var search_input = document.getElementById('mkdocs-search-query');
+  if (search_input) {
+    search_input.addEventListener("keyup", doSearch);
+  }
+  var term = getSearchTermFromLocation();
+  if (term) {
+    search_input.value = term;
+    doSearch();
+  }
+}
+
+function onWorkerMessage (e) {
+  if (e.data.allowSearch) {
+    initSearch();
+  } else if (e.data.results) {
+    var results = e.data.results;
+    displayResults(results);
+  } else if (e.data.config) {
+    min_search_length = e.data.config.min_search_length-1;
+  }
+}
+
+if (!window.Worker) {
+  console.log('Web Worker API not supported');
+  // load index in main thread
+  $.getScript(joinUrl(base_url, "search/worker.js")).done(function () {
+    console.log('Loaded worker');
+    init();
+    window.postMessage = function (msg) {
+      onWorkerMessage({data: msg});
+    };
+  }).fail(function (jqxhr, settings, exception) {
+    console.error('Could not load worker.js');
+  });
+} else {
+  // Wrap search in a web worker
+  var searchWorker = new Worker(joinUrl(base_url, "search/worker.js"));
+  searchWorker.postMessage({init: true});
+  searchWorker.onmessage = onWorkerMessage;
+}

venv/lib/python3.11/site-packages/mkdocs/contrib/search/templates/search/worker.js

@@ -0,0 +1,133 @@
+var base_path = 'function' === typeof importScripts ? '.' : '/search/';
+var allowSearch = false;
+var index;
+var documents = {};
+var lang = ['en'];
+var data;
+
+function getScript(script, callback) {
+  console.log('Loading script: ' + script);
+  $.getScript(base_path + script).done(function () {
+    callback();
+  }).fail(function (jqxhr, settings, exception) {
+    console.log('Error: ' + exception);
+  });
+}
+
+function getScriptsInOrder(scripts, callback) {
+  if (scripts.length === 0) {
+    callback();
+    return;
+  }
+  getScript(scripts[0], function() {
+    getScriptsInOrder(scripts.slice(1), callback);
+  });
+}
+
+function loadScripts(urls, callback) {
+  if( 'function' === typeof importScripts ) {
+    importScripts.apply(null, urls);
+    callback();
+  } else {
+    getScriptsInOrder(urls, callback);
+  }
+}
+
+function onJSONLoaded () {
+  data = JSON.parse(this.responseText);
+  var scriptsToLoad = ['lunr.js'];
+  if (data.config && data.config.lang && data.config.lang.length) {
+    lang = data.config.lang;
+  }
+  if (lang.length > 1 || lang[0] !== "en") {
+    scriptsToLoad.push('lunr.stemmer.support.js');
+    if (lang.length > 1) {
+      scriptsToLoad.push('lunr.multi.js');
+    }
+    if (lang.includes("ja") || lang.includes("jp")) {
+      scriptsToLoad.push('tinyseg.js');
+    }
+    for (var i=0; i < lang.length; i++) {
+      if (lang[i] != 'en') {
+        scriptsToLoad.push(['lunr', lang[i], 'js'].join('.'));
+      }
+    }
+  }
+  loadScripts(scriptsToLoad, onScriptsLoaded);
+}
+
+function onScriptsLoaded () {
+  console.log('All search scripts loaded, building Lunr index...');
+  if (data.config && data.config.separator && data.config.separator.length) {
+    lunr.tokenizer.separator = new RegExp(data.config.separator);
+  }
+
+  if (data.index) {
+    index = lunr.Index.load(data.index);
+    data.docs.forEach(function (doc) {
+      documents[doc.location] = doc;
+    });
+    console.log('Lunr pre-built index loaded, search ready');
+  } else {
+    index = lunr(function () {
+      if (lang.length === 1 && lang[0] !== "en" && lunr[lang[0]]) {
+        this.use(lunr[lang[0]]);
+      } else if (lang.length > 1) {
+        this.use(lunr.multiLanguage.apply(null, lang));  // spread operator not supported in all browsers: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator#Browser_compatibility
+      }
+      this.field('title');
+      this.field('text');
+      this.ref('location');
+
+      for (var i=0; i < data.docs.length; i++) {
+        var doc = data.docs[i];
+        this.add(doc);
+        documents[doc.location] = doc;
+      }
+    });
+    console.log('Lunr index built, search ready');
+  }
+  allowSearch = true;
+  postMessage({config: data.config});
+  postMessage({allowSearch: allowSearch});
+}
+
+function init () {
+  var oReq = new XMLHttpRequest();
+  oReq.addEventListener("load", onJSONLoaded);
+  var index_path = base_path + '/search_index.json';
+  if( 'function' === typeof importScripts ){
+      index_path = 'search_index.json';
+  }
+  oReq.open("GET", index_path);
+  oReq.send();
+}
+
+function search (query) {
+  if (!allowSearch) {
+    console.error('Assets for search still loading');
+    return;
+  }
+
+  var resultDocuments = [];
+  var results = index.search(query);
+  for (var i=0; i < results.length; i++){
+    var result = results[i];
+    doc = documents[result.ref];
+    doc.summary = doc.text.substring(0, 200);
+    resultDocuments.push(doc);
+  }
+  return resultDocuments;
+}
+
+if( 'function' === typeof importScripts ) {
+  onmessage = function (e) {
+    if (e.data.init) {
+      init();
+    } else if (e.data.query) {
+      postMessage({ results: search(e.data.query) });
+    } else {
+      console.error("Worker - Unrecognized message: " + e);
+    }
+  };
+}

venv/lib/python3.11/site-packages/mkdocs/exceptions.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from click import ClickException, echo
+
+
+class MkDocsException(ClickException):
+    """The base class which all MkDocs exceptions inherit from. This should
+    not be raised directly. One of the subclasses should be raised instead."""
+
+
+class Abort(MkDocsException):
+    """Abort the build"""
+
+    def show(self, *args, **kwargs) -> None:
+        echo(self.format_message())
+
+
+class ConfigurationError(MkDocsException):
+    """This error is raised by configuration validation when a validation error
+    is encountered. This error should be raised by any configuration options
+    defined in a plugin's [config_scheme][]."""
+
+
+class BuildError(MkDocsException):
+    """This error may be raised by MkDocs during the build process. Plugins should
+    not raise this error."""
+
+
+class PluginError(BuildError):
+    """A subclass of [`mkdocs.exceptions.BuildError`][] which can be raised by plugin
+    events."""

venv/lib/python3.11/site-packages/mkdocs/livereload/__init__.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+import functools
+import io
+import ipaddress
+import logging
+import mimetypes
+import os
+import os.path
+import pathlib
+import posixpath
+import re
+import socket
+import socketserver
+import string
+import threading
+import time
+import urllib.parse
+import warnings
+import wsgiref.simple_server
+import wsgiref.util
+from typing import Any, BinaryIO, Callable, Dict, Iterable, Optional, Tuple
+
+import watchdog.events
+import watchdog.observers.polling
+
+_SCRIPT_TEMPLATE_STR = """
+var livereload = function(epoch, requestId) {
+    var req = new XMLHttpRequest();
+    req.onloadend = function() {
+        if (parseFloat(this.responseText) > epoch) {
+            location.reload();
+            return;
+        }
+        var launchNext = livereload.bind(this, epoch, requestId);
+        if (this.status === 200) {
+            launchNext();
+        } else {
+            setTimeout(launchNext, 3000);
+        }
+    };
+    req.open("GET", "/livereload/" + epoch + "/" + requestId);
+    req.send();
+
+    console.log('Enabled live reload');
+}
+livereload(${epoch}, ${request_id});
+"""
+_SCRIPT_TEMPLATE = string.Template(_SCRIPT_TEMPLATE_STR)
+
+
+class _LoggerAdapter(logging.LoggerAdapter):
+    def process(self, msg: str, kwargs: dict) -> Tuple[str, dict]:  # type: ignore[override]
+        return time.strftime("[%H:%M:%S] ") + msg, kwargs
+
+
+log = _LoggerAdapter(logging.getLogger(__name__), {})
+
+
+class LiveReloadServer(socketserver.ThreadingMixIn, wsgiref.simple_server.WSGIServer):
+    daemon_threads = True
+    poll_response_timeout = 60
+
+    def __init__(
+        self,
+        builder: Callable[[], None],
+        host: str,
+        port: int,
+        root: str,
+        mount_path: str = "/",
+        polling_interval: float = 0.5,
+        shutdown_delay: float = 0.25,
+        **kwargs,
+    ) -> None:
+        self.builder = builder
+        self.server_name = host
+        self.server_port = port
+        try:
+            if isinstance(ipaddress.ip_address(host), ipaddress.IPv6Address):
+                self.address_family = socket.AF_INET6
+        except Exception:
+            pass
+        self.root = os.path.abspath(root)
+        self.mount_path = ("/" + mount_path.lstrip("/")).rstrip("/") + "/"
+        self.url = f"http://{self.server_name}:{self.server_port}{self.mount_path}"
+        self.build_delay = 0.1
+        self.shutdown_delay = shutdown_delay
+        # To allow custom error pages.
+        self.error_handler: Callable[[int], Optional[bytes]] = lambda code: None
+
+        super().__init__((host, port), _Handler, **kwargs)
+        self.set_app(self.serve_request)
+
+        self._wanted_epoch = _timestamp()  # The version of the site that started building.
+        self._visible_epoch = self._wanted_epoch  # Latest fully built version of the site.
+        self._epoch_cond = threading.Condition()  # Must be held when accessing _visible_epoch.
+
+        self._to_rebuild: Dict[
+            Callable[[], None], bool
+        ] = {}  # Used as an ordered set of functions to call.
+        self._rebuild_cond = threading.Condition()  # Must be held when accessing _to_rebuild.
+
+        self._shutdown = False
+        self.serve_thread = threading.Thread(target=lambda: self.serve_forever(shutdown_delay))
+        self.observer = watchdog.observers.polling.PollingObserver(timeout=polling_interval)
+
+        self._watched_paths: Dict[str, int] = {}
+        self._watch_refs: Dict[str, Any] = {}
+
+    def watch(
+        self, path: str, func: Optional[Callable[[], None]] = None, recursive: bool = True
+    ) -> None:
+        """Add the 'path' to watched paths, call the function and reload when any file changes under it."""
+        path = os.path.abspath(path)
+        if func is None or func is self.builder:
+            funct = self.builder
+        else:
+            funct = func
+            warnings.warn(
+                "Plugins should not pass the 'func' parameter of watch(). "
+                "The ability to execute custom callbacks will be removed soon.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        if path in self._watched_paths:
+            self._watched_paths[path] += 1
+            return
+        self._watched_paths[path] = 1
+
+        def callback(event):
+            if event.is_directory:
+                return
+            log.debug(str(event))
+            with self._rebuild_cond:
+                self._to_rebuild[funct] = True
+                self._rebuild_cond.notify_all()
+
+        handler = watchdog.events.FileSystemEventHandler()
+        handler.on_any_event = callback
+        log.debug(f"Watching '{path}'")
+        self._watch_refs[path] = self.observer.schedule(handler, path, recursive=recursive)
+
+    def unwatch(self, path: str) -> None:
+        """Stop watching file changes for path. Raises if there was no corresponding `watch` call."""
+        path = os.path.abspath(path)
+
+        self._watched_paths[path] -= 1
+        if self._watched_paths[path] <= 0:
+            self._watched_paths.pop(path)
+            self.observer.unschedule(self._watch_refs.pop(path))
+
+    def serve(self):
+        self.observer.start()
+
+        paths_str = ", ".join(f"'{_try_relativize_path(path)}'" for path in self._watched_paths)
+        log.info(f"Watching paths for changes: {paths_str}")
+
+        log.info(f"Serving on {self.url}")
+        self.serve_thread.start()
+
+        self._build_loop()
+
+    def _build_loop(self):
+        while True:
+            with self._rebuild_cond:
+                while not self._rebuild_cond.wait_for(
+                    lambda: self._to_rebuild or self._shutdown, timeout=self.shutdown_delay
+                ):
+                    # We could have used just one wait instead of a loop + timeout, but we need
+                    # occasional breaks, otherwise on Windows we can't receive KeyboardInterrupt.
+                    pass
+                if self._shutdown:
+                    break
+                log.info("Detected file changes")
+                while self._rebuild_cond.wait(timeout=self.build_delay):
+                    log.debug("Waiting for file changes to stop happening")
+
+                self._wanted_epoch = _timestamp()
+                funcs = list(self._to_rebuild)
+                self._to_rebuild.clear()
+
+            for func in funcs:
+                func()
+
+            with self._epoch_cond:
+                log.info("Reloading browsers")
+                self._visible_epoch = self._wanted_epoch
+                self._epoch_cond.notify_all()
+
+    def shutdown(self, wait=False) -> None:
+        self.observer.stop()
+        with self._rebuild_cond:
+            self._shutdown = True
+            self._rebuild_cond.notify_all()
+
+        if self.serve_thread.is_alive():
+            super().shutdown()
+        if wait:
+            self.serve_thread.join()
+            self.observer.join()
+
+    def serve_request(self, environ, start_response) -> Iterable[bytes]:
+        try:
+            result = self._serve_request(environ, start_response)
+        except Exception:
+            code = 500
+            msg = "500 Internal Server Error"
+            log.exception(msg)
+        else:
+            if result is not None:
+                return result
+            code = 404
+            msg = "404 Not Found"
+
+        error_content = None
+        try:
+            error_content = self.error_handler(code)
+        except Exception:
+            log.exception("Failed to render an error message!")
+        if error_content is None:
+            error_content = msg.encode()
+
+        start_response(msg, [("Content-Type", "text/html")])
+        return [error_content]
+
+    def _serve_request(self, environ, start_response) -> Optional[Iterable[bytes]]:
+        # https://bugs.python.org/issue16679
+        # https://github.com/bottlepy/bottle/blob/f9b1849db4/bottle.py#L984
+        path = environ["PATH_INFO"].encode("latin-1").decode("utf-8", "ignore")
+
+        if path.startswith("/livereload/"):
+            m = re.fullmatch(r"/livereload/([0-9]+)/[0-9]+", path)
+            if m:
+                epoch = int(m[1])
+                start_response("200 OK", [("Content-Type", "text/plain")])
+
+                def condition():
+                    return self._visible_epoch > epoch
+
+                with self._epoch_cond:
+                    if not condition():
+                        # Stall the browser, respond as soon as there's something new.
+                        # If there's not, respond anyway after a minute.
+                        self._log_poll_request(environ.get("HTTP_REFERER"), request_id=path)
+                        self._epoch_cond.wait_for(condition, timeout=self.poll_response_timeout)
+                    return [b"%d" % self._visible_epoch]
+
+        if (path + "/").startswith(self.mount_path):
+            rel_file_path = path[len(self.mount_path) :]
+
+            if path.endswith("/"):
+                rel_file_path += "index.html"
+            # Prevent directory traversal - normalize the path.
+            rel_file_path = posixpath.normpath("/" + rel_file_path).lstrip("/")
+            file_path = os.path.join(self.root, rel_file_path)
+        elif path == "/":
+            start_response("302 Found", [("Location", urllib.parse.quote(self.mount_path))])
+            return []
+        else:
+            return None  # Not found
+
+        # Wait until the ongoing rebuild (if any) finishes, so we're not serving a half-built site.
+        with self._epoch_cond:
+            self._epoch_cond.wait_for(lambda: self._visible_epoch == self._wanted_epoch)
+            epoch = self._visible_epoch
+
+        try:
+            file: BinaryIO = open(file_path, "rb")
+        except OSError:
+            if not path.endswith("/") and os.path.isfile(os.path.join(file_path, "index.html")):
+                start_response("302 Found", [("Location", urllib.parse.quote(path) + "/")])
+                return []
+            return None  # Not found
+
+        if self._watched_paths and file_path.endswith(".html"):
+            with file:
+                content = file.read()
+            content = self._inject_js_into_html(content, epoch)
+            file = io.BytesIO(content)
+            content_length = len(content)
+        else:
+            content_length = os.path.getsize(file_path)
+
+        content_type = self._guess_type(file_path)
+        start_response(
+            "200 OK", [("Content-Type", content_type), ("Content-Length", str(content_length))]
+        )
+        return wsgiref.util.FileWrapper(file)
+
+    def _inject_js_into_html(self, content, epoch):
+        try:
+            body_end = content.rindex(b"</body>")
+        except ValueError:
+            body_end = len(content)
+        # The page will reload if the livereload poller returns a newer epoch than what it knows.
+        # The other timestamp becomes just a unique identifier for the initiating page.
+        script = _SCRIPT_TEMPLATE.substitute(epoch=epoch, request_id=_timestamp())
+        return b"%b<script>%b</script>%b" % (
+            content[:body_end],
+            script.encode(),
+            content[body_end:],
+        )
+
+    @classmethod
+    @functools.lru_cache()  # "Cache" to not repeat the same message for the same browser tab.
+    def _log_poll_request(cls, url, request_id):
+        log.info(f"Browser connected: {url}")
+
+    @classmethod
+    def _guess_type(cls, path):
+        # MkDocs only ensures a few common types (as seen in livereload_tests.py::test_mime_types).
+        # Other uncommon types will not be accepted.
+        if path.endswith((".js", ".JS")):
+            return "application/javascript"
+        if path.endswith(".gz"):
+            return "application/gzip"
+
+        guess, _ = mimetypes.guess_type(path)
+        if guess:
+            return guess
+        return "application/octet-stream"
+
+
+class _Handler(wsgiref.simple_server.WSGIRequestHandler):
+    def log_request(self, code="-", size="-"):
+        level = logging.DEBUG if str(code) == "200" else logging.WARNING
+        log.log(level, f'"{self.requestline}" code {code}')
+
+    def log_message(self, format, *args):
+        log.debug(format, *args)
+
+
+def _timestamp() -> int:
+    return round(time.monotonic() * 1000)
+
+
+def _try_relativize_path(path: str) -> str:
+    """Make the path relative to current directory if it's under that directory."""
+    p = pathlib.Path(path)
+    try:
+        p = p.relative_to(os.getcwd())
+    except ValueError:
+        pass
+    return str(p)

venv/lib/python3.11/site-packages/mkdocs/localization.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional, Sequence
+
+import jinja2
+from jinja2.ext import Extension, InternationalizationExtension
+
+from mkdocs.config.base import ValidationError
+
+try:
+    from babel.core import Locale, UnknownLocaleError
+    from babel.support import NullTranslations, Translations
+
+    has_babel = True
+except ImportError:  # pragma: no cover
+    from mkdocs.utils.babel_stub import Locale, UnknownLocaleError
+
+    has_babel = False
+
+
+log = logging.getLogger(__name__)
+base_path = os.path.dirname(os.path.abspath(__file__))
+
+
+class NoBabelExtension(InternationalizationExtension):  # pragma: no cover
+    def __init__(self, environment):
+        Extension.__init__(self, environment)
+        environment.extend(
+            install_null_translations=self._install_null,
+            newstyle_gettext=False,
+        )
+
+
+def parse_locale(locale) -> Locale:
+    try:
+        return Locale.parse(locale, sep='_')
+    except (ValueError, UnknownLocaleError, TypeError) as e:
+        raise ValidationError(f'Invalid value for locale: {str(e)}')
+
+
+def install_translations(
+    env: jinja2.Environment, locale: Locale, theme_dirs: Sequence[str]
+) -> None:
+    if has_babel:
+        env.add_extension('jinja2.ext.i18n')
+        translations = _get_merged_translations(theme_dirs, 'locales', locale)
+        if translations is not None:
+            env.install_gettext_translations(translations)
+        else:
+            env.install_null_translations()
+            if locale.language != 'en':
+                log.warning(
+                    f"No translations could be found for the locale '{locale}'. "
+                    'Defaulting to English.'
+                )
+    else:  # pragma: no cover
+        # no babel installed, add dummy support for trans/endtrans blocks
+        env.add_extension(NoBabelExtension)
+        env.install_null_translations()
+
+
+def _get_merged_translations(
+    theme_dirs: Sequence[str], locales_dir: str, locale: Locale
+) -> Optional[Translations]:
+    merged_translations: Optional[Translations] = None
+
+    log.debug(f"Looking for translations for locale '{locale}'")
+    if locale.territory:
+        locale_str = f"{locale.language}_{locale.territory}"
+    else:
+        locale_str = locale.language
+    for theme_dir in reversed(theme_dirs):
+        dirname = os.path.join(theme_dir, locales_dir)
+        translations = Translations.load(dirname, [locale_str])
+
+        if type(translations) is NullTranslations:
+            log.debug(f"No translations found here: '{dirname}'")
+            continue
+
+        log.debug(f"Translations found here: '{dirname}'")
+        if merged_translations is None:
+            merged_translations = translations
+        else:
+            merged_translations.merge(translations)
+
+    return merged_translations

venv/lib/python3.11/site-packages/mkdocs/plugins.py

@@ -0,0 +1,526 @@
+"""
+Implements the plugin API for MkDocs.
+
+"""
+from __future__ import annotations
+
+import logging
+import sys
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    MutableMapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    overload,
+)
+
+if sys.version_info >= (3, 10):
+    from importlib.metadata import EntryPoint, entry_points
+else:
+    from importlib_metadata import EntryPoint, entry_points
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+import jinja2.environment
+
+from mkdocs import utils
+from mkdocs.config.base import Config, ConfigErrors, ConfigWarnings, LegacyConfig, PlainConfigSchema
+from mkdocs.livereload import LiveReloadServer
+from mkdocs.structure.files import Files
+from mkdocs.structure.nav import Navigation
+from mkdocs.structure.pages import Page
+
+if TYPE_CHECKING:
+    from mkdocs.config.defaults import MkDocsConfig
+
+
+log = logging.getLogger('mkdocs.plugins')
+
+
+def get_plugins() -> Dict[str, EntryPoint]:
+    """Return a dict of all installed Plugins as {name: EntryPoint}."""
+
+    plugins = entry_points(group='mkdocs.plugins')
+
+    # Allow third-party plugins to override core plugins
+    pluginmap = {}
+    for plugin in plugins:
+        if plugin.name in pluginmap and plugin.value.startswith("mkdocs.contrib."):
+            continue
+
+        pluginmap[plugin.name] = plugin
+
+    return pluginmap
+
+
+SomeConfig = TypeVar('SomeConfig', bound=Config)
+
+
+class BasePlugin(Generic[SomeConfig]):
+    """
+    Plugin base class.
+
+    All plugins should subclass this class.
+    """
+
+    config_class: Type[SomeConfig] = LegacyConfig  # type: ignore[assignment]
+    config_scheme: PlainConfigSchema = ()
+    config: SomeConfig = {}  # type: ignore[assignment]
+
+    supports_multiple_instances: bool = False
+    """Set to true in subclasses to declare support for adding the same plugin multiple times."""
+
+    def __class_getitem__(cls, config_class: Type[Config]):
+        """Eliminates the need to write `config_class = FooConfig` when subclassing BasePlugin[FooConfig]"""
+        name = f'{cls.__name__}[{config_class.__name__}]'
+        return type(name, (cls,), dict(config_class=config_class))
+
+    def __init_subclass__(cls):
+        if not issubclass(cls.config_class, Config):
+            raise TypeError(
+                f"config_class {cls.config_class} must be a subclass of `mkdocs.config.base.Config`"
+            )
+        if cls.config_class is not LegacyConfig:
+            cls.config_scheme = cls.config_class._schema  # For compatibility.
+
+    def load_config(
+        self, options: Dict[str, Any], config_file_path: Optional[str] = None
+    ) -> Tuple[ConfigErrors, ConfigWarnings]:
+        """Load config from a dict of options. Returns a tuple of (errors, warnings)."""
+
+        if self.config_class is LegacyConfig:
+            self.config = LegacyConfig(self.config_scheme, config_file_path=config_file_path)  # type: ignore
+        else:
+            self.config = self.config_class(config_file_path=config_file_path)
+
+        self.config.load_dict(options)
+
+        return self.config.validate()
+
+    # One-time events
+
+    def on_startup(self, *, command: Literal['build', 'gh-deploy', 'serve'], dirty: bool) -> None:
+        """
+        The `startup` event runs once at the very beginning of an `mkdocs` invocation.
+
+        New in MkDocs 1.4.
+
+        The presence of an `on_startup` method (even if empty) migrates the plugin to the new
+        system where the plugin object is kept across builds within one `mkdocs serve`.
+
+        Note that for initializing variables, the `__init__` method is still preferred.
+        For initializing per-build variables (and whenever in doubt), use the `on_config` event.
+
+        Parameters:
+            command: the command that MkDocs was invoked with, e.g. "serve" for `mkdocs serve`.
+            dirty: whether `--dirtyreload` or `--dirty` flags were passed.
+        """
+
+    def on_shutdown(self) -> None:
+        """
+        The `shutdown` event runs once at the very end of an `mkdocs` invocation, before exiting.
+
+        This event is relevant only for support of `mkdocs serve`, otherwise within a
+        single build it's undistinguishable from `on_post_build`.
+
+        New in MkDocs 1.4.
+
+        The presence of an `on_shutdown` method (even if empty) migrates the plugin to the new
+        system where the plugin object is kept across builds within one `mkdocs serve`.
+
+        Note the `on_post_build` method is still preferred for cleanups, when possible, as it has
+        a much higher chance of actually triggering. `on_shutdown` is "best effort" because it
+        relies on detecting a graceful shutdown of MkDocs.
+        """
+
+    def on_serve(
+        self, server: LiveReloadServer, *, config: MkDocsConfig, builder: Callable
+    ) -> Optional[LiveReloadServer]:
+        """
+        The `serve` event is only called when the `serve` command is used during
+        development. It runs only once, after the first build finishes.
+        It is passed the `Server` instance which can be modified before
+        it is activated. For example, additional files or directories could be added
+        to the list of "watched" files for auto-reloading.
+
+        Parameters:
+            server: `livereload.Server` instance
+            config: global configuration object
+            builder: a callable which gets passed to each call to `server.watch`
+
+        Returns:
+            `livereload.Server` instance
+        """
+        return server
+
+    # Global events
+
+    def on_config(self, config: MkDocsConfig) -> Optional[Config]:
+        """
+        The `config` event is the first event called on build and is run immediately
+        after the user configuration is loaded and validated. Any alterations to the
+        config should be made here.
+
+        Parameters:
+            config: global configuration object
+
+        Returns:
+            global configuration object
+        """
+        return config
+
+    def on_pre_build(self, *, config: MkDocsConfig) -> None:
+        """
+        The `pre_build` event does not alter any variables. Use this event to call
+        pre-build scripts.
+
+        Parameters:
+            config: global configuration object
+        """
+
+    def on_files(self, files: Files, *, config: MkDocsConfig) -> Optional[Files]:
+        """
+        The `files` event is called after the files collection is populated from the
+        `docs_dir`. Use this event to add, remove, or alter files in the
+        collection. Note that Page objects have not yet been associated with the
+        file objects in the collection. Use [Page Events](plugins.md#page-events) to manipulate page
+        specific data.
+
+        Parameters:
+            files: global files collection
+            config: global configuration object
+
+        Returns:
+            global files collection
+        """
+        return files
+
+    def on_nav(
+        self, nav: Navigation, *, config: MkDocsConfig, files: Files
+    ) -> Optional[Navigation]:
+        """
+        The `nav` event is called after the site navigation is created and can
+        be used to alter the site navigation.
+
+        Parameters:
+            nav: global navigation object
+            config: global configuration object
+            files: global files collection
+
+        Returns:
+            global navigation object
+        """
+        return nav
+
+    def on_env(
+        self, env: jinja2.Environment, *, config: MkDocsConfig, files: Files
+    ) -> Optional[jinja2.Environment]:
+        """
+        The `env` event is called after the Jinja template environment is created
+        and can be used to alter the
+        [Jinja environment](https://jinja.palletsprojects.com/en/latest/api/#jinja2.Environment).
+
+        Parameters:
+            env: global Jinja environment
+            config: global configuration object
+            files: global files collection
+
+        Returns:
+            global Jinja Environment
+        """
+        return env
+
+    def on_post_build(self, *, config: MkDocsConfig) -> None:
+        """
+        The `post_build` event does not alter any variables. Use this event to call
+        post-build scripts.
+
+        Parameters:
+            config: global configuration object
+        """
+
+    def on_build_error(self, error: Exception) -> None:
+        """
+        The `build_error` event is called after an exception of any kind
+        is caught by MkDocs during the build process.
+        Use this event to clean things up before MkDocs terminates. Note that any other
+        events which were scheduled to run after the error will have been skipped. See
+        [Handling Errors](plugins.md#handling-errors) for more details.
+
+        Parameters:
+            error: exception raised
+        """
+
+    # Template events
+
+    def on_pre_template(
+        self, template: jinja2.Template, *, template_name: str, config: MkDocsConfig
+    ) -> Optional[jinja2.Template]:
+        """
+        The `pre_template` event is called immediately after the subject template is
+        loaded and can be used to alter the template.
+
+        Parameters:
+            template: a Jinja2 [Template](https://jinja.palletsprojects.com/en/latest/api/#jinja2.Template) object
+            template_name: string filename of template
+            config: global configuration object
+
+        Returns:
+            a Jinja2 [Template](https://jinja.palletsprojects.com/en/latest/api/#jinja2.Template) object
+        """
+        return template
+
+    def on_template_context(
+        self, context: Dict[str, Any], *, template_name: str, config: MkDocsConfig
+    ) -> Optional[Dict[str, Any]]:
+        """
+        The `template_context` event is called immediately after the context is created
+        for the subject template and can be used to alter the context for that specific
+        template only.
+
+        Parameters:
+            context: dict of template context variables
+            template_name: string filename of template
+            config: global configuration object
+
+        Returns:
+            dict of template context variables
+        """
+        return context
+
+    def on_post_template(
+        self, output_content: str, *, template_name: str, config: MkDocsConfig
+    ) -> Optional[str]:
+        """
+        The `post_template` event is called after the template is rendered, but before
+        it is written to disc and can be used to alter the output of the template.
+        If an empty string is returned, the template is skipped and nothing is is
+        written to disc.
+
+        Parameters:
+            output_content: output of rendered template as string
+            template_name: string filename of template
+            config: global configuration object
+
+        Returns:
+            output of rendered template as string
+        """
+        return output_content
+
+    # Page events
+
+    def on_pre_page(self, page: Page, *, config: MkDocsConfig, files: Files) -> Optional[Page]:
+        """
+        The `pre_page` event is called before any actions are taken on the subject
+        page and can be used to alter the `Page` instance.
+
+        Parameters:
+            page: `mkdocs.nav.Page` instance
+            config: global configuration object
+            files: global files collection
+
+        Returns:
+            `mkdocs.nav.Page` instance
+        """
+        return page
+
+    def on_page_read_source(self, *, page: Page, config: MkDocsConfig) -> Optional[str]:
+        """
+        The `on_page_read_source` event can replace the default mechanism to read
+        the contents of a page's source from the filesystem.
+
+        Parameters:
+            page: `mkdocs.nav.Page` instance
+            config: global configuration object
+
+        Returns:
+            The raw source for a page as unicode string. If `None` is returned, the
+                default loading from a file will be performed.
+        """
+        return None
+
+    def on_page_markdown(
+        self, markdown: str, *, page: Page, config: MkDocsConfig, files: Files
+    ) -> Optional[str]:
+        """
+        The `page_markdown` event is called after the page's markdown is loaded
+        from file and can be used to alter the Markdown source text. The meta-
+        data has been stripped off and is available as `page.meta` at this point.
+
+        Parameters:
+            markdown: Markdown source text of page as string
+            page: `mkdocs.nav.Page` instance
+            config: global configuration object
+            files: global files collection
+
+        Returns:
+            Markdown source text of page as string
+        """
+        return markdown
+
+    def on_page_content(
+        self, html: str, *, page: Page, config: MkDocsConfig, files: Files
+    ) -> Optional[str]:
+        """
+        The `page_content` event is called after the Markdown text is rendered to
+        HTML (but before being passed to a template) and can be used to alter the
+        HTML body of the page.
+
+        Parameters:
+            html: HTML rendered from Markdown source as string
+            page: `mkdocs.nav.Page` instance
+            config: global configuration object
+            files: global files collection
+
+        Returns:
+            HTML rendered from Markdown source as string
+        """
+        return html
+
+    def on_page_context(
+        self, context: Dict[str, Any], *, page: Page, config: MkDocsConfig, nav: Navigation
+    ) -> Optional[Dict[str, Any]]:
+        """
+        The `page_context` event is called after the context for a page is created
+        and can be used to alter the context for that specific page only.
+
+        Parameters:
+            context: dict of template context variables
+            page: `mkdocs.nav.Page` instance
+            config: global configuration object
+            nav: global navigation object
+
+        Returns:
+            dict of template context variables
+        """
+        return context
+
+    def on_post_page(self, output: str, *, page: Page, config: MkDocsConfig) -> Optional[str]:
+        """
+        The `post_page` event is called after the template is rendered, but
+        before it is written to disc and can be used to alter the output of the
+        page. If an empty string is returned, the page is skipped and nothing is
+        written to disc.
+
+        Parameters:
+            output: output of rendered template as string
+            page: `mkdocs.nav.Page` instance
+            config: global configuration object
+
+        Returns:
+            output of rendered template as string
+        """
+        return output
+
+
+EVENTS = tuple(k[3:] for k in BasePlugin.__dict__ if k.startswith("on_"))
+
+# The above definitions were just for docs and type checking, we don't actually want them.
+for k in EVENTS:
+    delattr(BasePlugin, 'on_' + k)
+
+
+T = TypeVar('T')
+
+
+def event_priority(priority: float) -> Callable[[T], T]:
+    """A decorator to set an event priority for an event handler method.
+
+    Recommended priority values:
+    `100` "first", `50` "early", `0` "default", `-50` "late", `-100` "last".
+    As different plugins discover more precise relations to each other, the values should be further tweaked.
+
+    ```python
+    @plugins.event_priority(-100)  # Wishing to run this after all other plugins' `on_files` events.
+    def on_files(self, files, config, **kwargs):
+        ...
+    ```
+
+    New in MkDocs 1.4.
+    Recommended shim for backwards compatibility:
+
+    ```python
+    try:
+        from mkdocs.plugins import event_priority
+    except ImportError:
+        event_priority = lambda priority: lambda f: f  # No-op fallback
+    ```
+    """
+
+    def decorator(event_method):
+        event_method.mkdocs_priority = priority
+        return event_method
+
+    return decorator
+
+
+class PluginCollection(dict, MutableMapping[str, BasePlugin]):
+    """
+    A collection of plugins.
+
+    In addition to being a dict of Plugin instances, each event method is registered
+    upon being added. All registered methods for a given event can then be run in order
+    by calling `run_event`.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.events: Dict[str, List[Callable]] = {k: [] for k in EVENTS}
+
+    def _register_event(self, event_name: str, method: Callable) -> None:
+        """Register a method for an event."""
+        utils.insort(
+            self.events[event_name], method, key=lambda m: -getattr(m, 'mkdocs_priority', 0)
+        )
+
+    def __getitem__(self, key: str) -> BasePlugin:
+        return super().__getitem__(key)
+
+    def __setitem__(self, key: str, value: BasePlugin) -> None:
+        super().__setitem__(key, value)
+        # Register all of the event methods defined for this Plugin.
+        for event_name in (x for x in dir(value) if x.startswith('on_')):
+            method = getattr(value, event_name, None)
+            if callable(method):
+                self._register_event(event_name[3:], method)
+
+    @overload
+    def run_event(self, name: str, item: None = None, **kwargs) -> Any:
+        ...
+
+    @overload
+    def run_event(self, name: str, item: T, **kwargs) -> T:
+        ...
+
+    def run_event(self, name: str, item=None, **kwargs):
+        """
+        Run all registered methods of an event.
+
+        `item` is the object to be modified or replaced and returned by the event method.
+        If it isn't given the event method creates a new object to be returned.
+        All other keywords are variables for context, but would not generally
+        be modified by the event method.
+        """
+        pass_item = item is not None
+        events = self.events[name]
+        if events:
+            log.debug(f'Running {len(events)} `{name}` events')
+        for method in events:
+            if pass_item:
+                result = method(item, **kwargs)
+            else:
+                result = method(**kwargs)
+            # keep item if method returned `None`
+            if result is not None:
+                item = result
+        return item

venv/lib/python3.11/site-packages/mkdocs/structure/files.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import fnmatch
+import logging
+import os
+import posixpath
+import shutil
+from pathlib import PurePath
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+)
+from urllib.parse import quote as urlquote
+
+import jinja2.environment
+
+from mkdocs import utils
+
+if TYPE_CHECKING:
+    from mkdocs.config.defaults import MkDocsConfig
+    from mkdocs.structure.pages import Page
+
+
+log = logging.getLogger(__name__)
+
+
+class Files:
+    """A collection of [File][mkdocs.structure.files.File] objects."""
+
+    def __init__(self, files: List[File]) -> None:
+        self._files = files
+        self._src_uris: Optional[Dict[str, File]] = None
+
+    def __iter__(self) -> Iterator[File]:
+        """Iterate over the files within."""
+        return iter(self._files)
+
+    def __len__(self) -> int:
+        """The number of files within."""
+        return len(self._files)
+
+    def __contains__(self, path: str) -> bool:
+        """Whether the file with this `src_uri` is in the collection."""
+        return PurePath(path).as_posix() in self.src_uris
+
+    @property
+    def src_paths(self) -> Dict[str, File]:
+        """Soft-deprecated, prefer `src_uris`."""
+        return {file.src_path: file for file in self._files}
+
+    @property
+    def src_uris(self) -> Dict[str, File]:
+        """A mapping containing every file, with the keys being their
+        [`src_uri`][mkdocs.structure.files.File.src_uri]."""
+        if self._src_uris is None:
+            self._src_uris = {file.src_uri: file for file in self._files}
+        return self._src_uris
+
+    def get_file_from_path(self, path: str) -> Optional[File]:
+        """Return a File instance with File.src_uri equal to path."""
+        return self.src_uris.get(PurePath(path).as_posix())
+
+    def append(self, file: File) -> None:
+        """Append file to Files collection."""
+        self._src_uris = None
+        self._files.append(file)
+
+    def remove(self, file: File) -> None:
+        """Remove file from Files collection."""
+        self._src_uris = None
+        self._files.remove(file)
+
+    def copy_static_files(self, dirty: bool = False) -> None:
+        """Copy static files from source to destination."""
+        for file in self:
+            if not file.is_documentation_page():
+                file.copy_file(dirty)
+
+    def documentation_pages(self) -> Sequence[File]:
+        """Return iterable of all Markdown page file objects."""
+        return [file for file in self if file.is_documentation_page()]
+
+    def static_pages(self) -> Sequence[File]:
+        """Return iterable of all static page file objects."""
+        return [file for file in self if file.is_static_page()]
+
+    def media_files(self) -> Sequence[File]:
+        """Return iterable of all file objects which are not documentation or static pages."""
+        return [file for file in self if file.is_media_file()]
+
+    def javascript_files(self) -> Sequence[File]:
+        """Return iterable of all javascript file objects."""
+        return [file for file in self if file.is_javascript()]
+
+    def css_files(self) -> Sequence[File]:
+        """Return iterable of all CSS file objects."""
+        return [file for file in self if file.is_css()]
+
+    def add_files_from_theme(self, env: jinja2.Environment, config: MkDocsConfig) -> None:
+        """Retrieve static files from Jinja environment and add to collection."""
+
+        def filter(name):
+            # '.*' filters dot files/dirs at root level whereas '*/.*' filters nested levels
+            patterns = ['.*', '*/.*', '*.py', '*.pyc', '*.html', '*readme*', 'mkdocs_theme.yml']
+            # Exclude translation files
+            patterns.append("locales/*")
+            patterns.extend(f'*{x}' for x in utils.markdown_extensions)
+            patterns.extend(config.theme.static_templates)
+            for pattern in patterns:
+                if fnmatch.fnmatch(name.lower(), pattern):
+                    return False
+            return True
+
+        for path in env.list_templates(filter_func=filter):
+            # Theme files do not override docs_dir files
+            path = PurePath(path).as_posix()
+            if path not in self.src_uris:
+                for dir in config.theme.dirs:
+                    # Find the first theme dir which contains path
+                    if os.path.isfile(os.path.join(dir, path)):
+                        self.append(File(path, dir, config.site_dir, config.use_directory_urls))
+                        break
+
+
+class File:
+    """
+    A MkDocs File object.
+
+    Points to the source and destination locations of a file.
+
+    The `path` argument must be a path that exists relative to `src_dir`.
+
+    The `src_dir` and `dest_dir` must be absolute paths on the local file system.
+
+    The `use_directory_urls` argument controls how destination paths are generated. If `False`, a Markdown file is
+    mapped to an HTML file of the same name (the file extension is changed to `.html`). If True, a Markdown file is
+    mapped to an HTML index file (`index.html`) nested in a directory using the "name" of the file in `path`. The
+    `use_directory_urls` argument has no effect on non-Markdown files.
+
+    File objects have the following properties, which are Unicode strings:
+    """
+
+    src_uri: str
+    """The pure path (always '/'-separated) of the source file relative to the source directory."""
+
+    abs_src_path: str
+    """The absolute concrete path of the source file. Will use backslashes on Windows."""
+
+    dest_uri: str
+    """The pure path (always '/'-separated) of the destination file relative to the destination directory."""
+
+    abs_dest_path: str
+    """The absolute concrete path of the destination file. Will use backslashes on Windows."""
+
+    url: str
+    """The URI of the destination file relative to the destination directory as a string."""
+
+    @property
+    def src_path(self) -> str:
+        """Same as `src_uri` (and synchronized with it) but will use backslashes on Windows. Discouraged."""
+        return os.path.normpath(self.src_uri)
+
+    @src_path.setter
+    def src_path(self, value):
+        self.src_uri = PurePath(value).as_posix()
+
+    @property
+    def dest_path(self) -> str:
+        """Same as `dest_uri` (and synchronized with it) but will use backslashes on Windows. Discouraged."""
+        return os.path.normpath(self.dest_uri)
+
+    @dest_path.setter
+    def dest_path(self, value):
+        self.dest_uri = PurePath(value).as_posix()
+
+    page: Optional[Page]
+
+    def __init__(self, path: str, src_dir: str, dest_dir: str, use_directory_urls: bool) -> None:
+        self.page = None
+        self.src_path = path
+        self.abs_src_path = os.path.normpath(os.path.join(src_dir, self.src_path))
+        self.name = self._get_stem()
+        self.dest_uri = self._get_dest_path(use_directory_urls)
+        self.abs_dest_path = os.path.normpath(os.path.join(dest_dir, self.dest_path))
+        self.url = self._get_url(use_directory_urls)
+
+    def __eq__(self, other) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.src_uri == other.src_uri
+            and self.abs_src_path == other.abs_src_path
+            and self.url == other.url
+        )
+
+    def __repr__(self):
+        return (
+            f"File(src_uri='{self.src_uri}', dest_uri='{self.dest_uri}',"
+            f" name='{self.name}', url='{self.url}')"
+        )
+
+    def _get_stem(self) -> str:
+        """Return the name of the file without it's extension."""
+        filename = posixpath.basename(self.src_uri)
+        stem, ext = posixpath.splitext(filename)
+        return 'index' if stem in ('index', 'README') else stem
+
+    def _get_dest_path(self, use_directory_urls: bool) -> str:
+        """Return destination path based on source path."""
+        if self.is_documentation_page():
+            parent, filename = posixpath.split(self.src_uri)
+            if not use_directory_urls or self.name == 'index':
+                # index.md or README.md => index.html
+                # foo.md => foo.html
+                return posixpath.join(parent, self.name + '.html')
+            else:
+                # foo.md => foo/index.html
+                return posixpath.join(parent, self.name, 'index.html')
+        return self.src_uri
+
+    def _get_url(self, use_directory_urls: bool) -> str:
+        """Return url based in destination path."""
+        url = self.dest_uri
+        dirname, filename = posixpath.split(url)
+        if use_directory_urls and filename == 'index.html':
+            url = (dirname or '.') + '/'
+        return urlquote(url)
+
+    def url_relative_to(self, other: File) -> str:
+        """Return url for file relative to other file."""
+        return utils.get_relative_url(self.url, other.url if isinstance(other, File) else other)
+
+    def copy_file(self, dirty: bool = False) -> None:
+        """Copy source file to destination, ensuring parent directories exist."""
+        if dirty and not self.is_modified():
+            log.debug(f"Skip copying unmodified file: '{self.src_uri}'")
+        else:
+            log.debug(f"Copying media file: '{self.src_uri}'")
+            try:
+                utils.copy_file(self.abs_src_path, self.abs_dest_path)
+            except shutil.SameFileError:
+                pass  # Let plugins write directly into site_dir.
+
+    def is_modified(self) -> bool:
+        if os.path.isfile(self.abs_dest_path):
+            return os.path.getmtime(self.abs_dest_path) < os.path.getmtime(self.abs_src_path)
+        return True
+
+    def is_documentation_page(self) -> bool:
+        """Return True if file is a Markdown page."""
+        return utils.is_markdown_file(self.src_uri)
+
+    def is_static_page(self) -> bool:
+        """Return True if file is a static page (HTML, XML, JSON)."""
+        return self.src_uri.endswith(('.html', '.htm', '.xml', '.json'))
+
+    def is_media_file(self) -> bool:
+        """Return True if file is not a documentation or static page."""
+        return not (self.is_documentation_page() or self.is_static_page())
+
+    def is_javascript(self) -> bool:
+        """Return True if file is a JavaScript file."""
+        return self.src_uri.endswith(('.js', '.javascript'))
+
+    def is_css(self) -> bool:
+        """Return True if file is a CSS file."""
+        return self.src_uri.endswith('.css')
+
+
+def get_files(config: Union[MkDocsConfig, Mapping[str, Any]]) -> Files:
+    """Walk the `docs_dir` and return a Files collection."""
+    files = []
+    exclude = ['.*', '/templates']
+
+    for source_dir, dirnames, filenames in os.walk(config['docs_dir'], followlinks=True):
+        relative_dir = os.path.relpath(source_dir, config['docs_dir'])
+
+        for dirname in list(dirnames):
+            path = os.path.normpath(os.path.join(relative_dir, dirname))
+            # Skip any excluded directories
+            if _filter_paths(basename=dirname, path=path, is_dir=True, exclude=exclude):
+                dirnames.remove(dirname)
+        dirnames.sort()
+
+        for filename in _sort_files(filenames):
+            path = os.path.normpath(os.path.join(relative_dir, filename))
+            # Skip any excluded files
+            if _filter_paths(basename=filename, path=path, is_dir=False, exclude=exclude):
+                continue
+            # Skip README.md if an index file also exists in dir
+            if filename == 'README.md' and 'index.md' in filenames:
+                log.warning(
+                    f"Both index.md and README.md found. Skipping README.md from {source_dir}"
+                )
+                continue
+            files.append(
+                File(path, config['docs_dir'], config['site_dir'], config['use_directory_urls'])
+            )
+
+    return Files(files)
+
+
+def _sort_files(filenames: Iterable[str]) -> List[str]:
+    """Always sort `index` or `README` as first filename in list."""
+
+    def key(f):
+        if os.path.splitext(f)[0] in ['index', 'README']:
+            return (0,)
+        return (1, f)
+
+    return sorted(filenames, key=key)
+
+
+def _filter_paths(basename: str, path: str, is_dir: bool, exclude: Iterable[str]) -> bool:
+    """.gitignore style file filtering."""
+    for item in exclude:
+        # Items ending in '/' apply only to directories.
+        if item.endswith('/') and not is_dir:
+            continue
+        # Items starting with '/' apply to the whole path.
+        # In any other cases just the basename is used.
+        match = path if item.startswith('/') else basename
+        if fnmatch.fnmatch(match, item.strip('/')):
+            return True
+    return False

venv/lib/python3.11/site-packages/mkdocs/structure/nav.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Iterator, List, Mapping, Optional, Type, TypeVar, Union
+from urllib.parse import urlsplit
+
+from mkdocs.structure.files import Files
+from mkdocs.structure.pages import Page
+from mkdocs.utils import nest_paths
+
+if TYPE_CHECKING:
+    from mkdocs.config.defaults import MkDocsConfig
+
+
+log = logging.getLogger(__name__)
+
+
+class Navigation:
+    def __init__(self, items: List[Union[Page, Section, Link]], pages: List[Page]) -> None:
+        self.items = items  # Nested List with full navigation of Sections, Pages, and Links.
+        self.pages = pages  # Flat List of subset of Pages in nav, in order.
+
+        self.homepage = None
+        for page in pages:
+            if page.is_homepage:
+                self.homepage = page
+                break
+
+    homepage: Optional[Page]
+    """The [page][mkdocs.structure.pages.Page] object for the homepage of the site."""
+
+    pages: List[Page]
+    """A flat list of all [page][mkdocs.structure.pages.Page] objects contained in the navigation."""
+
+    def __repr__(self):
+        return '\n'.join(item._indent_print() for item in self)
+
+    def __iter__(self) -> Iterator[Union[Page, Section, Link]]:
+        return iter(self.items)
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+
+class Section:
+    def __init__(self, title: str, children: List[Union[Page, Section, Link]]) -> None:
+        self.title = title
+        self.children = children
+
+        self.parent = None
+        self.active = False
+
+    def __repr__(self):
+        return f"Section(title='{self.title}')"
+
+    title: str
+    """The title of the section."""
+
+    parent: Optional[Section]
+    """The immediate parent of the section or `None` if the section is at the top level."""
+
+    children: List[Union[Page, Section, Link]]
+    """An iterable of all child navigation objects. Children may include nested sections, pages and links."""
+
+    @property
+    def active(self) -> bool:
+        """
+        When `True`, indicates that a child page of this section is the current page and
+        can be used to highlight the section as the currently viewed section. Defaults
+        to `False`.
+        """
+        return self.__active
+
+    @active.setter
+    def active(self, value: bool):
+        """Set active status of section and ancestors."""
+        self.__active = bool(value)
+        if self.parent is not None:
+            self.parent.active = bool(value)
+
+    is_section: bool = True
+    """Indicates that the navigation object is a "section" object. Always `True` for section objects."""
+
+    is_page: bool = False
+    """Indicates that the navigation object is a "page" object. Always `False` for section objects."""
+
+    is_link: bool = False
+    """Indicates that the navigation object is a "link" object. Always `False` for section objects."""
+
+    @property
+    def ancestors(self):
+        if self.parent is None:
+            return []
+        return [self.parent] + self.parent.ancestors
+
+    def _indent_print(self, depth=0):
+        ret = ['{}{}'.format('    ' * depth, repr(self))]
+        for item in self.children:
+            ret.append(item._indent_print(depth + 1))
+        return '\n'.join(ret)
+
+
+class Link:
+    def __init__(self, title: str, url: str):
+        self.title = title
+        self.url = url
+        self.parent = None
+
+    def __repr__(self):
+        title = f"'{self.title}'" if (self.title is not None) else '[blank]'
+        return f"Link(title={title}, url='{self.url}')"
+
+    title: str
+    """The title of the link. This would generally be used as the label of the link."""
+
+    url: str
+    """The URL that the link points to. The URL should always be an absolute URLs and
+    should not need to have `base_url` prepended."""
+
+    parent: Optional[Section]
+    """The immediate parent of the link. `None` if the link is at the top level."""
+
+    children: None = None
+    """Links do not contain children and the attribute is always `None`."""
+
+    active: bool = False
+    """External links cannot be "active" and the attribute is always `False`."""
+
+    is_section: bool = False
+    """Indicates that the navigation object is a "section" object. Always `False` for link objects."""
+
+    is_page: bool = False
+    """Indicates that the navigation object is a "page" object. Always `False` for link objects."""
+
+    is_link: bool = True
+    """Indicates that the navigation object is a "link" object. Always `True` for link objects."""
+
+    @property
+    def ancestors(self):
+        if self.parent is None:
+            return []
+        return [self.parent] + self.parent.ancestors
+
+    def _indent_print(self, depth=0):
+        return '{}{}'.format('    ' * depth, repr(self))
+
+
+def get_navigation(files: Files, config: Union[MkDocsConfig, Mapping[str, Any]]) -> Navigation:
+    """Build site navigation from config and files."""
+    nav_config = config['nav'] or nest_paths(f.src_uri for f in files.documentation_pages())
+    items = _data_to_navigation(nav_config, files, config)
+    if not isinstance(items, list):
+        items = [items]
+
+    # Get only the pages from the navigation, ignoring any sections and links.
+    pages = _get_by_type(items, Page)
+
+    # Include next, previous and parent links.
+    _add_previous_and_next_links(pages)
+    _add_parent_links(items)
+
+    missing_from_config = [file for file in files.documentation_pages() if file.page is None]
+    if missing_from_config:
+        log.info(
+            'The following pages exist in the docs directory, but are not '
+            'included in the "nav" configuration:\n  - {}'.format(
+                '\n  - '.join(file.src_path for file in missing_from_config)
+            )
+        )
+        # Any documentation files not found in the nav should still have an associated page, so we
+        # create them here. The Page object will automatically be assigned to `file.page` during
+        # its creation (and this is the only way in which these page objects are accessible).
+        for file in missing_from_config:
+            Page(None, file, config)
+
+    links = _get_by_type(items, Link)
+    for link in links:
+        scheme, netloc, path, query, fragment = urlsplit(link.url)
+        if scheme or netloc:
+            log.debug(f"An external link to '{link.url}' is included in the 'nav' configuration.")
+        elif link.url.startswith('/'):
+            log.debug(
+                f"An absolute path to '{link.url}' is included in the 'nav' "
+                "configuration, which presumably points to an external resource."
+            )
+        else:
+            msg = (
+                f"A relative path to '{link.url}' is included in the 'nav' "
+                "configuration, which is not found in the documentation files"
+            )
+            log.warning(msg)
+    return Navigation(items, pages)
+
+
+def _data_to_navigation(data, files: Files, config: Union[MkDocsConfig, Mapping[str, Any]]):
+    if isinstance(data, dict):
+        return [
+            _data_to_navigation((key, value), files, config)
+            if isinstance(value, str)
+            else Section(title=key, children=_data_to_navigation(value, files, config))
+            for key, value in data.items()
+        ]
+    elif isinstance(data, list):
+        return [
+            _data_to_navigation(item, files, config)[0]
+            if isinstance(item, dict) and len(item) == 1
+            else _data_to_navigation(item, files, config)
+            for item in data
+        ]
+    title, path = data if isinstance(data, tuple) else (None, data)
+    file = files.get_file_from_path(path)
+    if file:
+        return Page(title, file, config)
+    return Link(title, path)
+
+
+T = TypeVar('T')
+
+
+def _get_by_type(nav, t: Type[T]) -> List[T]:
+    ret = []
+    for item in nav:
+        if isinstance(item, t):
+            ret.append(item)
+        if item.children:
+            ret.extend(_get_by_type(item.children, t))
+    return ret
+
+
+def _add_parent_links(nav) -> None:
+    for item in nav:
+        if item.is_section:
+            for child in item.children:
+                child.parent = item
+            _add_parent_links(item.children)
+
+
+def _add_previous_and_next_links(pages: List[Page]) -> None:
+    bookended = [None, *pages, None]
+    zipped = zip(bookended[:-2], pages, bookended[2:])
+    for page0, page1, page2 in zipped:
+        page1.previous_page, page1.next_page = page0, page2

venv/lib/python3.11/site-packages/mkdocs/structure/pages.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import logging
+import os
+import posixpath
+from typing import TYPE_CHECKING, Any, Mapping, MutableMapping, Optional, Union
+from urllib.parse import unquote as urlunquote
+from urllib.parse import urljoin, urlsplit, urlunsplit
+from xml.etree.ElementTree import Element
+
+import markdown
+from markdown.extensions import Extension
+from markdown.treeprocessors import Treeprocessor
+from markdown.util import AMP_SUBSTITUTE
+
+from mkdocs.structure.files import File, Files
+from mkdocs.structure.toc import get_toc
+from mkdocs.utils import get_build_date, get_markdown_title, meta
+
+if TYPE_CHECKING:
+    from mkdocs.config.defaults import MkDocsConfig
+    from mkdocs.structure.nav import Section
+    from mkdocs.structure.toc import TableOfContents
+
+
+log = logging.getLogger(__name__)
+
+
+class Page:
+    def __init__(
+        self, title: Optional[str], file: File, config: Union[MkDocsConfig, Mapping[str, Any]]
+    ) -> None:
+        file.page = self
+        self.file = file
+        self.title = title
+
+        # Navigation attributes
+        self.parent = None
+        self.children = None
+        self.previous_page = None
+        self.next_page = None
+        self.active = False
+
+        self.update_date = get_build_date()
+
+        self._set_canonical_url(config.get('site_url', None))
+        self._set_edit_url(
+            config.get('repo_url', None), config.get('edit_uri'), config.get('edit_uri_template')
+        )
+
+        # Placeholders to be filled in later in the build process.
+        self.markdown = None
+        self.content = None
+        self.toc = []  # type: ignore
+        self.meta = {}
+
+    def __eq__(self, other) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.title == other.title
+            and self.file == other.file
+        )
+
+    def __repr__(self):
+        title = f"'{self.title}'" if (self.title is not None) else '[blank]'
+        url = self.abs_url or self.file.url
+        return f"Page(title={title}, url='{url}')"
+
+    def _indent_print(self, depth=0):
+        return '{}{}'.format('    ' * depth, repr(self))
+
+    title: Optional[str]
+    """Contains the Title for the current page."""
+
+    markdown: Optional[str]
+    """The original Markdown content from the file."""
+
+    content: Optional[str]
+    """The rendered Markdown as HTML, this is the contents of the documentation."""
+
+    toc: TableOfContents
+    """An iterable object representing the Table of contents for a page. Each item in
+    the `toc` is an [`AnchorLink`][mkdocs.structure.toc.AnchorLink]."""
+
+    meta: MutableMapping[str, Any]
+    """A mapping of the metadata included at the top of the markdown page."""
+
+    @property
+    def url(self) -> str:
+        """The URL of the page relative to the MkDocs `site_dir`."""
+        return '' if self.file.url in ('.', './') else self.file.url
+
+    file: File
+    """The documentation [`File`][mkdocs.structure.files.File] that the page is being rendered from."""
+
+    abs_url: Optional[str]
+    """The absolute URL of the page from the server root as determined by the value
+    assigned to the [site_url][] configuration setting. The value includes any
+    subdirectory included in the `site_url`, but not the domain. [base_url][] should
+    not be used with this variable."""
+
+    canonical_url: Optional[str]
+    """The full, canonical URL to the current page as determined by the value assigned
+    to the [site_url][] configuration setting. The value includes the domain and any
+    subdirectory included in the `site_url`. [base_url][] should not be used with this
+    variable."""
+
+    @property
+    def active(self) -> bool:
+        """When `True`, indicates that this page is the currently viewed page. Defaults to `False`."""
+        return self.__active
+
+    @active.setter
+    def active(self, value: bool):
+        """Set active status of page and ancestors."""
+        self.__active = bool(value)
+        if self.parent is not None:
+            self.parent.active = bool(value)
+
+    @property
+    def is_index(self) -> bool:
+        return self.file.name == 'index'
+
+    @property
+    def is_top_level(self) -> bool:
+        return self.parent is None
+
+    edit_url: Optional[str]
+    """The full URL to the source page in the source repository. Typically used to
+    provide a link to edit the source page. [base_url][] should not be used with this
+    variable."""
+
+    @property
+    def is_homepage(self) -> bool:
+        """Evaluates to `True` for the homepage of the site and `False` for all other pages."""
+        return self.is_top_level and self.is_index and self.file.url in ('.', './', 'index.html')
+
+    previous_page: Optional[Page]
+    """The [page][mkdocs.structure.pages.Page] object for the previous page or `None`.
+    The value will be `None` if the current page is the first item in the site navigation
+    or if the current page is not included in the navigation at all."""
+
+    next_page: Optional[Page]
+    """The [page][mkdocs.structure.pages.Page] object for the next page or `None`.
+    The value will be `None` if the current page is the last item in the site navigation
+    or if the current page is not included in the navigation at all."""
+
+    parent: Optional[Section]
+    """The immediate parent of the page in the site navigation. `None` if the
+    page is at the top level."""
+
+    children: None = None
+    """Pages do not contain children and the attribute is always `None`."""
+
+    is_section: bool = False
+    """Indicates that the navigation object is a "section" object. Always `False` for page objects."""
+
+    is_page: bool = True
+    """Indicates that the navigation object is a "page" object. Always `True` for page objects."""
+
+    is_link: bool = False
+    """Indicates that the navigation object is a "link" object. Always `False` for page objects."""
+
+    @property
+    def ancestors(self):
+        if self.parent is None:
+            return []
+        return [self.parent] + self.parent.ancestors
+
+    def _set_canonical_url(self, base: Optional[str]) -> None:
+        if base:
+            if not base.endswith('/'):
+                base += '/'
+            self.canonical_url = canonical_url = urljoin(base, self.url)
+            self.abs_url = urlsplit(canonical_url).path
+        else:
+            self.canonical_url = None
+            self.abs_url = None
+
+    def _set_edit_url(
+        self,
+        repo_url: Optional[str],
+        edit_uri: Optional[str] = None,
+        edit_uri_template: Optional[str] = None,
+    ) -> None:
+        if edit_uri or edit_uri_template:
+            src_uri = self.file.src_uri
+            if edit_uri_template:
+                noext = posixpath.splitext(src_uri)[0]
+                edit_uri = edit_uri_template.format(path=src_uri, path_noext=noext)
+            else:
+                assert edit_uri is not None and edit_uri.endswith('/')
+                edit_uri += src_uri
+            if repo_url:
+                # Ensure urljoin behavior is correct
+                if not edit_uri.startswith(('?', '#')) and not repo_url.endswith('/'):
+                    repo_url += '/'
+            else:
+                try:
+                    parsed_url = urlsplit(edit_uri)
+                    if not parsed_url.scheme or not parsed_url.netloc:
+                        log.warning(
+                            f"edit_uri: {edit_uri!r} is not a valid URL, it should include the http:// (scheme)"
+                        )
+                except ValueError as e:
+                    log.warning(f"edit_uri: {edit_uri!r} is not a valid URL: {e}")
+
+            self.edit_url = urljoin(repo_url or '', edit_uri)
+        else:
+            self.edit_url = None
+
+    def read_source(self, config: MkDocsConfig) -> None:
+        source = config['plugins'].run_event('page_read_source', page=self, config=config)
+        if source is None:
+            try:
+                with open(self.file.abs_src_path, encoding='utf-8-sig', errors='strict') as f:
+                    source = f.read()
+            except OSError:
+                log.error(f'File not found: {self.file.src_path}')
+                raise
+            except ValueError:
+                log.error(f'Encoding error reading file: {self.file.src_path}')
+                raise
+
+        self.markdown, self.meta = meta.get_data(source)
+        self._set_title()
+
+    def _set_title(self) -> None:
+        """
+        Set the title for a Markdown document.
+
+        Check these in order and use the first that returns a valid title:
+        - value provided on init (passed in from config)
+        - value of metadata 'title'
+        - content of the first H1 in Markdown content
+        - convert filename to title
+        """
+        if self.title is not None:
+            return
+
+        if 'title' in self.meta:
+            self.title = self.meta['title']
+            return
+
+        assert self.markdown is not None
+        title = get_markdown_title(self.markdown)
+
+        if title is None:
+            if self.is_homepage:
+                title = 'Home'
+            else:
+                title = self.file.name.replace('-', ' ').replace('_', ' ')
+                # Capitalize if the filename was all lowercase, otherwise leave it as-is.
+                if title.lower() == title:
+                    title = title.capitalize()
+
+        self.title = title
+
+    def render(self, config: MkDocsConfig, files: Files) -> None:
+        """
+        Convert the Markdown source file to HTML as per the config.
+        """
+        extensions = [_RelativePathExtension(self.file, files), *config['markdown_extensions']]
+
+        md = markdown.Markdown(
+            extensions=extensions,
+            extension_configs=config['mdx_configs'] or {},
+        )
+        assert self.markdown is not None
+        self.content = md.convert(self.markdown)
+        self.toc = get_toc(getattr(md, 'toc_tokens', []))
+
+
+class _RelativePathTreeprocessor(Treeprocessor):
+    def __init__(self, file: File, files: Files) -> None:
+        self.file = file
+        self.files = files
+
+    def run(self, root: Element) -> Element:
+        """
+        Update urls on anchors and images to make them relative
+
+        Iterates through the full document tree looking for specific
+        tags and then makes them relative based on the site navigation
+        """
+        for element in root.iter():
+            if element.tag == 'a':
+                key = 'href'
+            elif element.tag == 'img':
+                key = 'src'
+            else:
+                continue
+
+            url = element.get(key)
+            assert url is not None
+            new_url = self.path_to_url(url)
+            element.set(key, new_url)
+
+        return root
+
+    def path_to_url(self, url: str) -> str:
+        scheme, netloc, path, query, fragment = urlsplit(url)
+
+        if (
+            scheme
+            or netloc
+            or not path
+            or url.startswith('/')
+            or url.startswith('\\')
+            or AMP_SUBSTITUTE in url
+            or '.' not in os.path.split(path)[-1]
+        ):
+            # Ignore URLs unless they are a relative link to a source file.
+            # AMP_SUBSTITUTE is used internally by Markdown only for email.
+            # No '.' in the last part of a path indicates path does not point to a file.
+            return url
+
+        # Determine the filepath of the target.
+        target_uri = posixpath.join(posixpath.dirname(self.file.src_uri), urlunquote(path))
+        target_uri = posixpath.normpath(target_uri).lstrip('/')
+
+        # Validate that the target exists in files collection.
+        target_file = self.files.get_file_from_path(target_uri)
+        if target_file is None:
+            log.warning(
+                f"Documentation file '{self.file.src_uri}' contains a link to "
+                f"'{target_uri}' which is not found in the documentation files."
+            )
+            return url
+        path = target_file.url_relative_to(self.file)
+        components = (scheme, netloc, path, query, fragment)
+        return urlunsplit(components)
+
+
+class _RelativePathExtension(Extension):
+    """
+    The Extension class is what we pass to markdown, it then
+    registers the Treeprocessor.
+    """
+
+    def __init__(self, file: File, files: Files) -> None:
+        self.file = file
+        self.files = files
+
+    def extendMarkdown(self, md: markdown.Markdown) -> None:
+        relpath = _RelativePathTreeprocessor(self.file, self.files)
+        md.treeprocessors.register(relpath, "relpath", 0)

venv/lib/python3.11/site-packages/mkdocs/structure/toc.py

@@ -0,0 +1,77 @@
+"""
+Deals with generating the per-page table of contents.
+
+For the sake of simplicity we use the Python-Markdown `toc` extension to
+generate a list of dicts for each toc item, and then store it as AnchorLinks to
+maintain compatibility with older versions of MkDocs.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+
+def get_toc(toc_tokens: list) -> TableOfContents:
+    toc = [_parse_toc_token(i) for i in toc_tokens]
+    # For the table of contents, always mark the first element as active
+    if len(toc):
+        toc[0].active = True  # type: ignore[attr-defined]
+    return TableOfContents(toc)
+
+
+class TableOfContents:
+    """
+    Represents the table of contents for a given page.
+    """
+
+    def __init__(self, items: list) -> None:
+        self.items = items
+
+    def __iter__(self):
+        return iter(self.items)
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+    def __str__(self) -> str:
+        return ''.join(str(item) for item in self)
+
+
+class AnchorLink:
+    """
+    A single entry in the table of contents.
+    """
+
+    def __init__(self, title: str, id: str, level: int) -> None:
+        self.title, self.id, self.level = title, id, level
+        self.children = []
+
+    title: str
+    """The text of the item."""
+
+    @property
+    def url(self) -> str:
+        """The hash fragment of a URL pointing to the item."""
+        return '#' + self.id
+
+    level: int
+    """The zero-based level of the item."""
+
+    children: List[AnchorLink]
+    """An iterable of any child items."""
+
+    def __str__(self):
+        return self.indent_print()
+
+    def indent_print(self, depth=0):
+        indent = '    ' * depth
+        ret = f'{indent}{self.title} - {self.url}\n'
+        for item in self.children:
+            ret += item.indent_print(depth + 1)
+        return ret
+
+
+def _parse_toc_token(token: Dict[str, Any]) -> AnchorLink:
+    anchor = AnchorLink(token['name'], token['id'], token['level'])
+    for i in token['children']:
+        anchor.children.append(_parse_toc_token(i))
+    return anchor

venv/lib/python3.11/site-packages/mkdocs/templates/sitemap.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+{%- for file in pages -%}
+    {% if not file.page.is_link %}
+    <url>
+         <loc>{% if file.page.canonical_url %}{{ file.page.canonical_url|e }}{% else %}{{ file.page.abs_url|e }}{% endif %}</loc>
+         {% if file.page.update_date %}<lastmod>{{file.page.update_date}}</lastmod>{% endif %}
+         <changefreq>daily</changefreq>
+    </url>
+    {%- endif -%}
+{% endfor %}
+</urlset>

venv/lib/python3.11/site-packages/mkdocs/tests/__init__.py

@@ -0,0 +1,13 @@
+import logging
+
+
+class DisallowLogsHandler(logging.Handler):
+    def __init__(self, level=logging.WARNING):
+        super().__init__(level=level)
+        self.formatter = logging.Formatter("%(levelname)s:%(name)s:%(message)s")
+
+    def emit(self, record):
+        raise AssertionError(f'Unexpected log: {self.format(record)!r}')
+
+
+logging.lastResort = DisallowLogsHandler()  # type: ignore

venv/lib/python3.11/site-packages/mkdocs/tests/base.py

@@ -0,0 +1,140 @@
+import contextlib
+import os
+import textwrap
+from functools import wraps
+from tempfile import TemporaryDirectory
+
+import markdown
+
+from mkdocs import utils
+from mkdocs.config.defaults import MkDocsConfig
+
+
+def dedent(text):
+    return textwrap.dedent(text).strip()
+
+
+def get_markdown_toc(markdown_source):
+    """Return TOC generated by Markdown parser from Markdown source text."""
+    md = markdown.Markdown(extensions=['toc'])
+    md.convert(markdown_source)
+    return md.toc_tokens
+
+
+def load_config(**cfg) -> MkDocsConfig:
+    """Helper to build a simple config for testing."""
+    path_base = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'integration', 'minimal')
+    cfg = cfg or {}
+    if 'site_name' not in cfg:
+        cfg['site_name'] = 'Example'
+    if 'config_file_path' not in cfg:
+        cfg['config_file_path'] = os.path.join(path_base, 'mkdocs.yml')
+    if 'docs_dir' not in cfg:
+        # Point to an actual dir to avoid a 'does not exist' error on validation.
+        cfg['docs_dir'] = os.path.join(path_base, 'docs')
+    conf = MkDocsConfig(config_file_path=cfg['config_file_path'])
+    conf.load_dict(cfg)
+
+    errors_warnings = conf.validate()
+    assert errors_warnings == ([], []), errors_warnings
+    return conf
+
+
+def tempdir(files=None, **kw):
+    """
+    A decorator for building a temporary directory with prepopulated files.
+
+    The temporary directory and files are created just before the wrapped function is called and are destroyed
+    immediately after the wrapped function returns.
+
+    The `files` keyword should be a dict of file paths as keys and strings of file content as values.
+    If `files` is a list, then each item is assumed to be a path of an empty file. All other
+    keywords are passed to `tempfile.TemporaryDirectory` to create the parent directory.
+
+    In the following example, two files are created in the temporary directory and then are destroyed when
+    the function exits:
+
+        @tempdir(files={
+            'foo.txt': 'foo content',
+            'bar.txt': 'bar content'
+        })
+        def example(self, tdir):
+            assert os.path.isfile(os.path.join(tdir, 'foo.txt'))
+            pth = os.path.join(tdir, 'bar.txt')
+            assert os.path.isfile(pth)
+            with open(pth, 'r', encoding='utf-8') as f:
+                assert f.read() == 'bar content'
+    """
+    files = {f: '' for f in files} if isinstance(files, (list, tuple)) else files or {}
+
+    kw['prefix'] = 'mkdocs_test-' + kw.get('prefix', '')
+
+    def decorator(fn):
+        @wraps(fn)
+        def wrapper(self, *args):
+            with TemporaryDirectory(**kw) as td:
+                for path, content in files.items():
+                    pth = os.path.join(td, path)
+                    utils.write_file(content.encode(encoding='utf-8'), pth)
+                return fn(self, td, *args)
+
+        return wrapper
+
+    return decorator
+
+
+@contextlib.contextmanager
+def change_dir(path):
+    old_cwd = os.getcwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(old_cwd)
+
+
+class PathAssertionMixin:
+    """
+    Assertion methods for testing paths.
+
+    Each method accepts one or more strings, which are first joined using os.path.join.
+    """
+
+    def assertPathsEqual(self, a, b, msg=None):
+        self.assertEqual(a.replace(os.sep, '/'), b.replace(os.sep, '/'))
+
+    def assertPathExists(self, *parts):
+        path = os.path.join(*parts)
+        if not os.path.exists(path):
+            msg = self._formatMessage(None, f"The path '{path}' does not exist")
+            raise self.failureException(msg)
+
+    def assertPathNotExists(self, *parts):
+        path = os.path.join(*parts)
+        if os.path.exists(path):
+            msg = self._formatMessage(None, f"The path '{path}' does exist")
+            raise self.failureException(msg)
+
+    def assertPathIsFile(self, *parts):
+        path = os.path.join(*parts)
+        if not os.path.isfile(path):
+            msg = self._formatMessage(None, f"The path '{path}' is not a file that exists")
+            raise self.failureException(msg)
+
+    def assertPathNotFile(self, *parts):
+        path = os.path.join(*parts)
+        if os.path.isfile(path):
+            msg = self._formatMessage(None, f"The path '{path}' is a file that exists")
+            raise self.failureException(msg)
+
+    def assertPathIsDir(self, *parts):
+        path = os.path.join(*parts)
+        if not os.path.isdir(path):
+            msg = self._formatMessage(None, f"The path '{path}' is not a directory that exists")
+            raise self.failureException(msg)
+
+    def assertPathNotDir(self, *parts):
+        path = os.path.join(*parts)
+        if os.path.isfile(path):
+            msg = self._formatMessage(None, f"The path '{path}' is a directory that exists")
+            raise self.failureException(msg)

venv/lib/python3.11/site-packages/mkdocs/tests/build_tests.py

@@ -0,0 +1,571 @@
+#!/usr/bin/env python
+
+import unittest
+from unittest import mock
+
+from mkdocs.commands import build
+from mkdocs.exceptions import PluginError
+from mkdocs.structure.files import File, Files
+from mkdocs.structure.nav import get_navigation
+from mkdocs.structure.pages import Page
+from mkdocs.tests.base import PathAssertionMixin, load_config, tempdir
+from mkdocs.utils import meta
+
+
+def build_page(title, path, config, md_src=''):
+    """Helper which returns a Page object."""
+
+    files = Files([File(path, config.docs_dir, config.site_dir, config.use_directory_urls)])
+    page = Page(title, list(files)[0], config)
+    # Fake page.read_source()
+    page.markdown, page.meta = meta.get_data(md_src)
+    return page, files
+
+
+class BuildTests(PathAssertionMixin, unittest.TestCase):
+    def _get_env_with_null_translations(self, config):
+        env = config.theme.get_env()
+        env.add_extension('jinja2.ext.i18n')
+        env.install_null_translations()
+        return env
+
+    # Test build.get_context
+
+    def test_context_base_url_homepage(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+        ]
+        cfg = load_config(nav=nav_cfg, use_directory_urls=False)
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[0])
+        self.assertEqual(context['base_url'], '.')
+
+    def test_context_base_url_homepage_use_directory_urls(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+        ]
+        cfg = load_config(nav=nav_cfg)
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[0])
+        self.assertEqual(context['base_url'], '.')
+
+    def test_context_base_url_nested_page(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+            {'Nested': 'foo/bar.md'},
+        ]
+        cfg = load_config(nav=nav_cfg, use_directory_urls=False)
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+            File('foo/bar.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[1])
+        self.assertEqual(context['base_url'], '..')
+
+    def test_context_base_url_nested_page_use_directory_urls(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+            {'Nested': 'foo/bar.md'},
+        ]
+        cfg = load_config(nav=nav_cfg)
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+            File('foo/bar.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[1])
+        self.assertEqual(context['base_url'], '../..')
+
+    def test_context_base_url_relative_no_page(self):
+        cfg = load_config(use_directory_urls=False)
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='..')
+        self.assertEqual(context['base_url'], '..')
+
+    def test_context_base_url_relative_no_page_use_directory_urls(self):
+        cfg = load_config()
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='..')
+        self.assertEqual(context['base_url'], '..')
+
+    def test_context_base_url_absolute_no_page(self):
+        cfg = load_config(use_directory_urls=False)
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='/')
+        self.assertEqual(context['base_url'], '/')
+
+    def test_context_base_url__absolute_no_page_use_directory_urls(self):
+        cfg = load_config()
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='/')
+        self.assertEqual(context['base_url'], '/')
+
+    def test_context_base_url_absolute_nested_no_page(self):
+        cfg = load_config(use_directory_urls=False)
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='/foo/')
+        self.assertEqual(context['base_url'], '/foo/')
+
+    def test_context_base_url__absolute_nested_no_page_use_directory_urls(self):
+        cfg = load_config()
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='/foo/')
+        self.assertEqual(context['base_url'], '/foo/')
+
+    def test_context_extra_css_js_from_homepage(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+        ]
+        cfg = load_config(
+            nav=nav_cfg,
+            extra_css=['style.css'],
+            extra_javascript=['script.js'],
+            use_directory_urls=False,
+        )
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[0])
+        self.assertEqual(context['extra_css'], ['style.css'])
+        self.assertEqual(context['extra_javascript'], ['script.js'])
+
+    def test_context_extra_css_js_from_nested_page(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+            {'Nested': 'foo/bar.md'},
+        ]
+        cfg = load_config(
+            nav=nav_cfg,
+            extra_css=['style.css'],
+            extra_javascript=['script.js'],
+            use_directory_urls=False,
+        )
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+            File('foo/bar.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[1])
+        self.assertEqual(context['extra_css'], ['../style.css'])
+        self.assertEqual(context['extra_javascript'], ['../script.js'])
+
+    def test_context_extra_css_js_from_nested_page_use_directory_urls(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+            {'Nested': 'foo/bar.md'},
+        ]
+        cfg = load_config(
+            nav=nav_cfg,
+            extra_css=['style.css'],
+            extra_javascript=['script.js'],
+        )
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+            File('foo/bar.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        context = build.get_context(nav, files, cfg, nav.pages[1])
+        self.assertEqual(context['extra_css'], ['../../style.css'])
+        self.assertEqual(context['extra_javascript'], ['../../script.js'])
+
+    # TODO: This shouldn't pass on Linux
+    # @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")
+    def test_context_extra_css_path_warning(self):
+        nav_cfg = [
+            {'Home': 'index.md'},
+        ]
+        cfg = load_config(
+            nav=nav_cfg,
+            extra_css=['assets\\style.css'],
+            use_directory_urls=False,
+        )
+        fs = [
+            File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        with self.assertLogs('mkdocs') as cm:
+            context = build.get_context(nav, files, cfg, nav.pages[0])
+        self.assertEqual(context['extra_css'], ['assets/style.css'])
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "WARNING:mkdocs.utils:Path 'assets\\style.css' uses OS-specific separator '\\'. "
+            "That will be unsupported in a future release. Please change it to '/'.",
+        )
+
+    def test_context_extra_css_js_no_page(self):
+        cfg = load_config(extra_css=['style.css'], extra_javascript=['script.js'])
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg, base_url='..')
+        self.assertEqual(context['extra_css'], ['../style.css'])
+        self.assertEqual(context['extra_javascript'], ['../script.js'])
+
+    def test_extra_context(self):
+        cfg = load_config(extra={'a': 1})
+        context = build.get_context(mock.Mock(), mock.Mock(), cfg)
+        self.assertEqual(context['config']['extra']['a'], 1)
+
+    # Test build._build_theme_template
+
+    @mock.patch('mkdocs.utils.write_file')
+    @mock.patch('mkdocs.commands.build._build_template', return_value='some content')
+    def test_build_theme_template(self, mock_build_template, mock_write_file):
+        cfg = load_config()
+        env = cfg['theme'].get_env()
+        build._build_theme_template('main.html', env, mock.Mock(), cfg, mock.Mock())
+        mock_write_file.assert_called_once()
+        mock_build_template.assert_called_once()
+
+    @mock.patch('mkdocs.utils.write_file')
+    @mock.patch('mkdocs.commands.build._build_template', return_value='some content')
+    @mock.patch('gzip.GzipFile')
+    @tempdir()
+    def test_build_sitemap_template(
+        self, site_dir, mock_gzip_gzipfile, mock_build_template, mock_write_file
+    ):
+        cfg = load_config(site_dir=site_dir)
+        env = cfg['theme'].get_env()
+        build._build_theme_template('sitemap.xml', env, mock.Mock(), cfg, mock.Mock())
+        mock_write_file.assert_called_once()
+        mock_build_template.assert_called_once()
+        mock_gzip_gzipfile.assert_called_once()
+
+    @mock.patch('mkdocs.utils.write_file')
+    @mock.patch('mkdocs.commands.build._build_template', return_value='')
+    def test_skip_missing_theme_template(self, mock_build_template, mock_write_file):
+        cfg = load_config()
+        env = cfg['theme'].get_env()
+        with self.assertLogs('mkdocs') as cm:
+            build._build_theme_template('missing.html', env, mock.Mock(), cfg, mock.Mock())
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "WARNING:mkdocs.commands.build:Template skipped: 'missing.html' not found in theme directories.",
+        )
+        mock_write_file.assert_not_called()
+        mock_build_template.assert_not_called()
+
+    @mock.patch('mkdocs.utils.write_file')
+    @mock.patch('mkdocs.commands.build._build_template', return_value='')
+    def test_skip_theme_template_empty_output(self, mock_build_template, mock_write_file):
+        cfg = load_config()
+        env = cfg['theme'].get_env()
+        with self.assertLogs('mkdocs') as cm:
+            build._build_theme_template('main.html', env, mock.Mock(), cfg, mock.Mock())
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "INFO:mkdocs.commands.build:Template skipped: 'main.html' generated empty output.",
+        )
+        mock_write_file.assert_not_called()
+        mock_build_template.assert_called_once()
+
+    # Test build._build_extra_template
+
+    @tempdir()
+    @mock.patch('mkdocs.commands.build.open', mock.mock_open(read_data='template content'))
+    def test_build_extra_template(self, site_dir):
+        cfg = load_config(site_dir=site_dir)
+        fs = [
+            File('foo.html', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        build._build_extra_template('foo.html', files, cfg, mock.Mock())
+
+    @mock.patch('mkdocs.commands.build.open', mock.mock_open(read_data='template content'))
+    def test_skip_missing_extra_template(self):
+        cfg = load_config()
+        fs = [
+            File('foo.html', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        with self.assertLogs('mkdocs') as cm:
+            build._build_extra_template('missing.html', files, cfg, mock.Mock())
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "WARNING:mkdocs.commands.build:Template skipped: 'missing.html' not found in docs_dir.",
+        )
+
+    @mock.patch('mkdocs.commands.build.open', side_effect=OSError('Error message.'))
+    def test_skip_ioerror_extra_template(self, mock_open):
+        cfg = load_config()
+        fs = [
+            File('foo.html', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        with self.assertLogs('mkdocs') as cm:
+            build._build_extra_template('foo.html', files, cfg, mock.Mock())
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "WARNING:mkdocs.commands.build:Error reading template 'foo.html': Error message.",
+        )
+
+    @mock.patch('mkdocs.commands.build.open', mock.mock_open(read_data=''))
+    def test_skip_extra_template_empty_output(self):
+        cfg = load_config()
+        fs = [
+            File('foo.html', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls']),
+        ]
+        files = Files(fs)
+        with self.assertLogs('mkdocs') as cm:
+            build._build_extra_template('foo.html', files, cfg, mock.Mock())
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "INFO:mkdocs.commands.build:Template skipped: 'foo.html' generated empty output.",
+        )
+
+    # Test build._populate_page
+
+    @tempdir(files={'index.md': 'page content'})
+    def test_populate_page(self, docs_dir):
+        cfg = load_config(docs_dir=docs_dir)
+        file = File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])
+        page = Page('Foo', file, cfg)
+        build._populate_page(page, cfg, Files([file]))
+        self.assertEqual(page.content, '<p>page content</p>')
+
+    @tempdir(files={'testing.html': '<p>page content</p>'})
+    def test_populate_page_dirty_modified(self, site_dir):
+        cfg = load_config(site_dir=site_dir)
+        file = File('testing.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])
+        page = Page('Foo', file, cfg)
+        build._populate_page(page, cfg, Files([file]), dirty=True)
+        self.assertTrue(page.markdown.startswith('# Welcome to MkDocs'))
+        self.assertTrue(
+            page.content.startswith('<h1 id="welcome-to-mkdocs">Welcome to MkDocs</h1>')
+        )
+
+    @tempdir(files={'index.md': 'page content'})
+    @tempdir(files={'index.html': '<p>page content</p>'})
+    def test_populate_page_dirty_not_modified(self, site_dir, docs_dir):
+        cfg = load_config(docs_dir=docs_dir, site_dir=site_dir)
+        file = File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])
+        page = Page('Foo', file, cfg)
+        build._populate_page(page, cfg, Files([file]), dirty=True)
+        # Content is empty as file read was skipped
+        self.assertEqual(page.markdown, None)
+        self.assertEqual(page.content, None)
+
+    @tempdir(files={'index.md': 'new page content'})
+    @mock.patch('mkdocs.structure.pages.open', side_effect=OSError('Error message.'))
+    def test_populate_page_read_error(self, docs_dir, mock_open):
+        cfg = load_config(docs_dir=docs_dir)
+        file = File('missing.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])
+        page = Page('Foo', file, cfg)
+        with self.assertLogs('mkdocs') as cm:
+            with self.assertRaises(OSError):
+                build._populate_page(page, cfg, Files([file]))
+        self.assertEqual(
+            cm.output,
+            [
+                'ERROR:mkdocs.structure.pages:File not found: missing.md',
+                "ERROR:mkdocs.commands.build:Error reading page 'missing.md': Error message.",
+            ],
+        )
+        mock_open.assert_called_once()
+
+    @tempdir(files={'index.md': 'page content'})
+    @mock.patch(
+        'mkdocs.plugins.PluginCollection.run_event', side_effect=PluginError('Error message.')
+    )
+    def test_populate_page_read_plugin_error(self, docs_dir, mock_open):
+        cfg = load_config(docs_dir=docs_dir)
+        file = File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])
+        page = Page('Foo', file, cfg)
+        with self.assertLogs('mkdocs') as cm:
+            with self.assertRaises(PluginError):
+                build._populate_page(page, cfg, Files([file]))
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "ERROR:mkdocs.commands.build:Error reading page 'index.md':",
+        )
+        mock_open.assert_called_once()
+
+    # Test build._build_page
+
+    @tempdir()
+    def test_build_page(self, site_dir):
+        cfg = load_config(site_dir=site_dir, nav=['index.md'], plugins=[])
+        fs = [File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        page = files.documentation_pages()[0].page
+        # Fake populate page
+        page.title = 'Title'
+        page.markdown = 'page content'
+        page.content = '<p>page content</p>'
+        build._build_page(page, cfg, files, nav, self._get_env_with_null_translations(cfg))
+        self.assertPathIsFile(site_dir, 'index.html')
+
+    @tempdir()
+    @mock.patch('jinja2.environment.Template.render', return_value='')
+    def test_build_page_empty(self, site_dir, render_mock):
+        cfg = load_config(site_dir=site_dir, nav=['index.md'], plugins=[])
+        fs = [File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        with self.assertLogs('mkdocs') as cm:
+            build._build_page(
+                files.documentation_pages()[0].page, cfg, files, nav, cfg['theme'].get_env()
+            )
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "INFO:mkdocs.commands.build:Page skipped: 'index.md'. Generated empty output.",
+        )
+        self.assertPathNotFile(site_dir, 'index.html')
+        render_mock.assert_called_once()
+
+    @tempdir(files={'index.md': 'page content'})
+    @tempdir(files={'index.html': '<p>page content</p>'})
+    @mock.patch('mkdocs.utils.write_file')
+    def test_build_page_dirty_modified(self, site_dir, docs_dir, mock_write_file):
+        cfg = load_config(docs_dir=docs_dir, site_dir=site_dir, nav=['index.md'], plugins=[])
+        fs = [File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        page = files.documentation_pages()[0].page
+        # Fake populate page
+        page.title = 'Title'
+        page.markdown = 'new page content'
+        page.content = '<p>new page content</p>'
+        build._build_page(
+            page, cfg, files, nav, self._get_env_with_null_translations(cfg), dirty=True
+        )
+        mock_write_file.assert_not_called()
+
+    @tempdir(files={'testing.html': '<p>page content</p>'})
+    @mock.patch('mkdocs.utils.write_file')
+    def test_build_page_dirty_not_modified(self, site_dir, mock_write_file):
+        cfg = load_config(site_dir=site_dir, nav=['testing.md'], plugins=[])
+        fs = [File('testing.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        page = files.documentation_pages()[0].page
+        # Fake populate page
+        page.title = 'Title'
+        page.markdown = 'page content'
+        page.content = '<p>page content</p>'
+        build._build_page(
+            page, cfg, files, nav, self._get_env_with_null_translations(cfg), dirty=True
+        )
+        mock_write_file.assert_called_once()
+
+    @tempdir()
+    def test_build_page_custom_template(self, site_dir):
+        cfg = load_config(site_dir=site_dir, nav=['index.md'], plugins=[])
+        fs = [File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        page = files.documentation_pages()[0].page
+        # Fake populate page
+        page.title = 'Title'
+        page.meta = {'template': '404.html'}
+        page.markdown = 'page content'
+        page.content = '<p>page content</p>'
+        build._build_page(page, cfg, files, nav, self._get_env_with_null_translations(cfg))
+        self.assertPathIsFile(site_dir, 'index.html')
+
+    @tempdir()
+    @mock.patch('mkdocs.utils.write_file', side_effect=OSError('Error message.'))
+    def test_build_page_error(self, site_dir, mock_write_file):
+        cfg = load_config(site_dir=site_dir, nav=['index.md'], plugins=[])
+        fs = [File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        page = files.documentation_pages()[0].page
+        # Fake populate page
+        page.title = 'Title'
+        page.markdown = 'page content'
+        page.content = '<p>page content</p>'
+        with self.assertLogs('mkdocs') as cm:
+            with self.assertRaises(OSError):
+                build._build_page(page, cfg, files, nav, self._get_env_with_null_translations(cfg))
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "ERROR:mkdocs.commands.build:Error building page 'index.md': Error message.",
+        )
+        mock_write_file.assert_called_once()
+
+    @tempdir()
+    @mock.patch(
+        'mkdocs.plugins.PluginCollection.run_event', side_effect=PluginError('Error message.')
+    )
+    def test_build_page_plugin_error(self, site_dir, mock_write_file):
+        cfg = load_config(site_dir=site_dir, nav=['index.md'], plugins=[])
+        fs = [File('index.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])]
+        files = Files(fs)
+        nav = get_navigation(files, cfg)
+        page = files.documentation_pages()[0].page
+        # Fake populate page
+        page.title = 'Title'
+        page.markdown = 'page content'
+        page.content = '<p>page content</p>'
+        with self.assertLogs('mkdocs') as cm:
+            with self.assertRaises(PluginError):
+                build._build_page(page, cfg, files, nav, cfg['theme'].get_env())
+        self.assertEqual(
+            '\n'.join(cm.output),
+            "ERROR:mkdocs.commands.build:Error building page 'index.md':",
+        )
+        mock_write_file.assert_called_once()
+
+    # Test build.build
+
+    @tempdir(
+        files={
+            'index.md': 'page content',
+            'empty.md': '',
+            'img.jpg': '',
+            'static.html': 'content',
+            '.hidden': 'content',
+            '.git/hidden': 'content',
+        }
+    )
+    @tempdir()
+    def test_copying_media(self, site_dir, docs_dir):
+        cfg = load_config(docs_dir=docs_dir, site_dir=site_dir)
+        build.build(cfg)
+
+        # Verify that only non-empty md file (converted to html), static HTML file and image are copied.
+        self.assertPathIsFile(site_dir, 'index.html')
+        self.assertPathIsFile(site_dir, 'img.jpg')
+        self.assertPathIsFile(site_dir, 'static.html')
+        self.assertPathNotExists(site_dir, 'empty.md')
+        self.assertPathNotExists(site_dir, '.hidden')
+        self.assertPathNotExists(site_dir, '.git/hidden')
+
+    @tempdir(files={'index.md': 'page content'})
+    @tempdir()
+    def test_copy_theme_files(self, site_dir, docs_dir):
+        cfg = load_config(docs_dir=docs_dir, site_dir=site_dir)
+        build.build(cfg)
+
+        # Verify only theme media are copied, not templates, Python or localization files.
+        self.assertPathIsFile(site_dir, 'index.html')
+        self.assertPathIsFile(site_dir, '404.html')
+        self.assertPathIsDir(site_dir, 'js')
+        self.assertPathIsDir(site_dir, 'css')
+        self.assertPathIsDir(site_dir, 'img')
+        self.assertPathIsDir(site_dir, 'fonts')
+        self.assertPathNotExists(site_dir, '__init__.py')
+        self.assertPathNotExists(site_dir, '__init__.pyc')
+        self.assertPathNotExists(site_dir, 'base.html')
+        self.assertPathNotExists(site_dir, 'content.html')
+        self.assertPathNotExists(site_dir, 'main.html')
+        self.assertPathNotExists(site_dir, 'locales')
+
+    # Test build.site_directory_contains_stale_files
+
+    @tempdir(files=['index.html'])
+    def test_site_dir_contains_stale_files(self, site_dir):
+        self.assertTrue(build.site_directory_contains_stale_files(site_dir))
+
+    @tempdir()
+    def test_not_site_dir_contains_stale_files(self, site_dir):
+        self.assertFalse(build.site_directory_contains_stale_files(site_dir))

venv/lib/python3.11/site-packages/mkdocs/tests/cli_tests.py

@@ -0,0 +1,626 @@
+#!/usr/bin/env python
+
+import io
+import logging
+import unittest
+from unittest import mock
+
+from click.testing import CliRunner
+
+from mkdocs import __main__ as cli
+
+
+class CLITests(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_default(self, mock_serve):
+        result = self.runner.invoke(cli.cli, ["serve"], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_config_file(self, mock_serve):
+        result = self.runner.invoke(
+            cli.cli, ["serve", "--config-file", "mkdocs.yml"], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_serve.call_count, 1)
+        args, kwargs = mock_serve.call_args
+        self.assertTrue('config_file' in kwargs)
+        self.assertIsInstance(kwargs['config_file'], io.BufferedReader)
+        self.assertEqual(kwargs['config_file'].name, 'mkdocs.yml')
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_dev_addr(self, mock_serve):
+        result = self.runner.invoke(
+            cli.cli, ["serve", '--dev-addr', '0.0.0.0:80'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr='0.0.0.0:80',
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_strict(self, mock_serve):
+        result = self.runner.invoke(cli.cli, ["serve", '--strict'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=True,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_theme(self, mock_serve):
+        result = self.runner.invoke(
+            cli.cli, ["serve", '--theme', 'readthedocs'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme='readthedocs',
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_use_directory_urls(self, mock_serve):
+        result = self.runner.invoke(
+            cli.cli, ["serve", '--use-directory-urls'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=True,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_no_directory_urls(self, mock_serve):
+        result = self.runner.invoke(
+            cli.cli, ["serve", '--no-directory-urls'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=False,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_livereload(self, mock_serve):
+        result = self.runner.invoke(cli.cli, ["serve", '--livereload'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_no_livereload(self, mock_serve):
+        result = self.runner.invoke(cli.cli, ["serve", '--no-livereload'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='no-livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_dirtyreload(self, mock_serve):
+        result = self.runner.invoke(cli.cli, ["serve", '--dirtyreload'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='dirty',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=False,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.commands.serve.serve', autospec=True)
+    def test_serve_watch_theme(self, mock_serve):
+        result = self.runner.invoke(cli.cli, ["serve", '--watch-theme'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_serve.assert_called_once_with(
+            dev_addr=None,
+            livereload='livereload',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            watch_theme=True,
+            watch=(),
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_defaults(self, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['build'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        args, kwargs = mock_build.call_args
+        self.assertTrue('dirty' in kwargs)
+        self.assertFalse(kwargs['dirty'])
+        mock_load_config.assert_called_once_with(
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            site_dir=None,
+        )
+        handler = logging._handlers.get('MkDocsStreamHandler')
+        self.assertEqual(handler.level, logging.INFO)
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_clean(self, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['build', '--clean'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        args, kwargs = mock_build.call_args
+        self.assertTrue('dirty' in kwargs)
+        self.assertFalse(kwargs['dirty'])
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_dirty(self, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['build', '--dirty'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        args, kwargs = mock_build.call_args
+        self.assertTrue('dirty' in kwargs)
+        self.assertTrue(kwargs['dirty'])
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_config_file(self, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['build', '--config-file', 'mkdocs.yml'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        self.assertEqual(mock_load_config.call_count, 1)
+        args, kwargs = mock_load_config.call_args
+        self.assertTrue('config_file' in kwargs)
+        self.assertIsInstance(kwargs['config_file'], io.BufferedReader)
+        self.assertEqual(kwargs['config_file'].name, 'mkdocs.yml')
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_strict(self, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['build', '--strict'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            config_file=None,
+            strict=True,
+            theme=None,
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_theme(self, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['build', '--theme', 'readthedocs'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            config_file=None,
+            strict=None,
+            theme='readthedocs',
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_use_directory_urls(self, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['build', '--use-directory-urls'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=True,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_no_directory_urls(self, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['build', '--no-directory-urls'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=False,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_site_dir(self, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['build', '--site-dir', 'custom'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            site_dir='custom',
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_verbose(self, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['build', '--verbose'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        handler = logging._handlers.get('MkDocsStreamHandler')
+        self.assertEqual(handler.level, logging.DEBUG)
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    def test_build_quiet(self, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['build', '--quiet'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_build.call_count, 1)
+        handler = logging._handlers.get('MkDocsStreamHandler')
+        self.assertEqual(handler.level, logging.ERROR)
+
+    @mock.patch('mkdocs.commands.new.new', autospec=True)
+    def test_new(self, mock_new):
+        result = self.runner.invoke(cli.cli, ["new", "project"], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        mock_new.assert_called_once_with('project')
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_defaults(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['gh-deploy'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        g_args, g_kwargs = mock_gh_deploy.call_args
+        self.assertTrue('message' in g_kwargs)
+        self.assertEqual(g_kwargs['message'], None)
+        self.assertTrue('force' in g_kwargs)
+        self.assertEqual(g_kwargs['force'], False)
+        self.assertTrue('ignore_version' in g_kwargs)
+        self.assertEqual(g_kwargs['ignore_version'], False)
+        self.assertEqual(mock_build.call_count, 1)
+        b_args, b_kwargs = mock_build.call_args
+        self.assertTrue('dirty' in b_kwargs)
+        self.assertFalse(b_kwargs['dirty'])
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name=None,
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_clean(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['gh-deploy', '--clean'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        args, kwargs = mock_build.call_args
+        self.assertTrue('dirty' in kwargs)
+        self.assertFalse(kwargs['dirty'])
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_dirty(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['gh-deploy', '--dirty'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        args, kwargs = mock_build.call_args
+        self.assertTrue('dirty' in kwargs)
+        self.assertTrue(kwargs['dirty'])
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_config_file(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--config-file', 'mkdocs.yml'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        self.assertEqual(mock_load_config.call_count, 1)
+        args, kwargs = mock_load_config.call_args
+        self.assertTrue('config_file' in kwargs)
+        self.assertIsInstance(kwargs['config_file'], io.BufferedReader)
+        self.assertEqual(kwargs['config_file'].name, 'mkdocs.yml')
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_message(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--message', 'A commit message'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        g_args, g_kwargs = mock_gh_deploy.call_args
+        self.assertTrue('message' in g_kwargs)
+        self.assertEqual(g_kwargs['message'], 'A commit message')
+        self.assertEqual(mock_build.call_count, 1)
+        self.assertEqual(mock_load_config.call_count, 1)
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_remote_branch(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--remote-branch', 'foo'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch='foo',
+            remote_name=None,
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_remote_name(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--remote-name', 'foo'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name='foo',
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_force(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['gh-deploy', '--force'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        g_args, g_kwargs = mock_gh_deploy.call_args
+        self.assertTrue('force' in g_kwargs)
+        self.assertEqual(g_kwargs['force'], True)
+        self.assertEqual(mock_build.call_count, 1)
+        self.assertEqual(mock_load_config.call_count, 1)
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_ignore_version(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--ignore-version'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        g_args, g_kwargs = mock_gh_deploy.call_args
+        self.assertTrue('ignore_version' in g_kwargs)
+        self.assertEqual(g_kwargs['ignore_version'], True)
+        self.assertEqual(mock_build.call_count, 1)
+        self.assertEqual(mock_load_config.call_count, 1)
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_strict(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(cli.cli, ['gh-deploy', '--strict'], catch_exceptions=False)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name=None,
+            config_file=None,
+            strict=True,
+            theme=None,
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_theme(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--theme', 'readthedocs'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name=None,
+            config_file=None,
+            strict=None,
+            theme='readthedocs',
+            use_directory_urls=None,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_use_directory_urls(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--use-directory-urls'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name=None,
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=True,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_no_directory_urls(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--no-directory-urls'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name=None,
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=False,
+            site_dir=None,
+        )
+
+    @mock.patch('mkdocs.config.load_config', autospec=True)
+    @mock.patch('mkdocs.commands.build.build', autospec=True)
+    @mock.patch('mkdocs.commands.gh_deploy.gh_deploy', autospec=True)
+    def test_gh_deploy_site_dir(self, mock_gh_deploy, mock_build, mock_load_config):
+        result = self.runner.invoke(
+            cli.cli, ['gh-deploy', '--site-dir', 'custom'], catch_exceptions=False
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(mock_gh_deploy.call_count, 1)
+        self.assertEqual(mock_build.call_count, 1)
+        mock_load_config.assert_called_once_with(
+            remote_branch=None,
+            remote_name=None,
+            config_file=None,
+            strict=None,
+            theme=None,
+            use_directory_urls=None,
+            site_dir='custom',
+        )