Add files using upload-large-folder tool

evalkit_tf446/lib/python3.10/site-packages/imageio-2.36.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

evalkit_tf446/lib/python3.10/site-packages/imageio-2.36.0.dist-info/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014-2022, imageio developers
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

evalkit_tf446/lib/python3.10/site-packages/imageio-2.36.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: imageio
+Version: 2.36.0
+Summary: Library for reading and writing a wide range of image, video, scientific, and volumetric data formats.
+Home-page: https://github.com/imageio/imageio
+Download-URL: http://pypi.python.org/pypi/imageio
+Author: imageio contributors
+Author-email: almar.klein@gmail.com
+License: BSD-2-Clause
+Keywords: image video volume imread imwrite io animation ffmpeg
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides: imageio
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pillow>=8.3.2
+Provides-Extra: all-plugins
+Requires-Dist: astropy; extra == "all-plugins"
+Requires-Dist: av; extra == "all-plugins"
+Requires-Dist: imageio-ffmpeg; extra == "all-plugins"
+Requires-Dist: numpy>2; extra == "all-plugins"
+Requires-Dist: pillow-heif; extra == "all-plugins"
+Requires-Dist: psutil; extra == "all-plugins"
+Requires-Dist: rawpy; extra == "all-plugins"
+Requires-Dist: tifffile; extra == "all-plugins"
+Provides-Extra: all-plugins-pypy
+Requires-Dist: av; extra == "all-plugins-pypy"
+Requires-Dist: imageio-ffmpeg; extra == "all-plugins-pypy"
+Requires-Dist: pillow-heif; extra == "all-plugins-pypy"
+Requires-Dist: psutil; extra == "all-plugins-pypy"
+Requires-Dist: tifffile; extra == "all-plugins-pypy"
+Provides-Extra: bsdf
+Provides-Extra: build
+Requires-Dist: wheel; extra == "build"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: fsspec[github]; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Provides-Extra: dicom
+Provides-Extra: docs
+Requires-Dist: sphinx<6; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: pydata-sphinx-theme; extra == "docs"
+Provides-Extra: feisem
+Provides-Extra: ffmpeg
+Requires-Dist: imageio-ffmpeg; extra == "ffmpeg"
+Requires-Dist: psutil; extra == "ffmpeg"
+Provides-Extra: fits
+Requires-Dist: astropy; extra == "fits"
+Provides-Extra: freeimage
+Provides-Extra: full
+Requires-Dist: astropy; extra == "full"
+Requires-Dist: av; extra == "full"
+Requires-Dist: black; extra == "full"
+Requires-Dist: flake8; extra == "full"
+Requires-Dist: fsspec[github]; extra == "full"
+Requires-Dist: gdal; extra == "full"
+Requires-Dist: imageio-ffmpeg; extra == "full"
+Requires-Dist: itk; extra == "full"
+Requires-Dist: numpy>2; extra == "full"
+Requires-Dist: numpydoc; extra == "full"
+Requires-Dist: pillow-heif; extra == "full"
+Requires-Dist: psutil; extra == "full"
+Requires-Dist: pydata-sphinx-theme; extra == "full"
+Requires-Dist: pytest; extra == "full"
+Requires-Dist: pytest-cov; extra == "full"
+Requires-Dist: rawpy; extra == "full"
+Requires-Dist: sphinx<6; extra == "full"
+Requires-Dist: tifffile; extra == "full"
+Requires-Dist: wheel; extra == "full"
+Provides-Extra: gdal
+Requires-Dist: gdal; extra == "gdal"
+Provides-Extra: itk
+Requires-Dist: itk; extra == "itk"
+Provides-Extra: linting
+Requires-Dist: black; extra == "linting"
+Requires-Dist: flake8; extra == "linting"
+Provides-Extra: lytro
+Provides-Extra: numpy
+Provides-Extra: pillow
+Provides-Extra: pillow-heif
+Requires-Dist: pillow-heif; extra == "pillow-heif"
+Provides-Extra: pyav
+Requires-Dist: av; extra == "pyav"
+Provides-Extra: rawpy
+Requires-Dist: rawpy; extra == "rawpy"
+Requires-Dist: numpy>2; extra == "rawpy"
+Provides-Extra: simpleitk
+Provides-Extra: spe
+Provides-Extra: swf
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: fsspec[github]; extra == "test"
+Provides-Extra: tifffile
+Requires-Dist: tifffile; extra == "tifffile"
+
+
+.. image:: https://github.com/imageio/imageio/workflows/CI/badge.svg
+    :target: https://github.com/imageio/imageio/actions
+
+
+Imageio is a Python library that provides an easy interface to read and
+write a wide range of image data, including animated images, volumetric
+data, and scientific formats. It is cross-platform, runs on Python 3.5+,
+and is easy to install.
+
+Main website: https://imageio.readthedocs.io/
+
+
+Release notes: https://github.com/imageio/imageio/blob/master/CHANGELOG.md
+
+Example:
+
+.. code-block:: python
+
+    >>> import imageio
+    >>> im = imageio.imread('imageio:astronaut.png')
+    >>> im.shape  # im is a numpy array
+    (512, 512, 3)
+    >>> imageio.imwrite('astronaut-gray.jpg', im[:, :, 0])
+
+See the `API Reference <https://imageio.readthedocs.io/en/stable/reference/index.html>`_
+or `examples <https://imageio.readthedocs.io/en/stable/examples.html>`_
+for more information.

evalkit_tf446/lib/python3.10/site-packages/imageio/core/findlib.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015-1018, imageio contributors
+# Copyright (C) 2013, Zach Pincus, Almar Klein and others
+
+""" This module contains generic code to find and load a dynamic library.
+"""
+
+import os
+import sys
+import ctypes
+
+
+LOCALDIR = os.path.abspath(os.path.dirname(__file__))
+
+# Flag that can be patched / set to True to disable loading non-system libs
+SYSTEM_LIBS_ONLY = False
+
+
+def looks_lib(fname):
+    """Returns True if the given filename looks like a dynamic library.
+    Based on extension, but cross-platform and more flexible.
+    """
+    fname = fname.lower()
+    if sys.platform.startswith("win"):
+        return fname.endswith(".dll")
+    elif sys.platform.startswith("darwin"):
+        return fname.endswith(".dylib")
+    else:
+        return fname.endswith(".so") or ".so." in fname
+
+
+def generate_candidate_libs(lib_names, lib_dirs=None):
+    """Generate a list of candidate filenames of what might be the dynamic
+    library corresponding with the given list of names.
+    Returns (lib_dirs, lib_paths)
+    """
+    lib_dirs = lib_dirs or []
+
+    # Get system dirs to search
+    sys_lib_dirs = [
+        "/lib",
+        "/usr/lib",
+        "/usr/lib/x86_64-linux-gnu",
+        "/usr/lib/aarch64-linux-gnu",
+        "/usr/local/lib",
+        "/opt/local/lib",
+    ]
+
+    # Get Python dirs to search (shared if for Pyzo)
+    py_sub_dirs = ["bin", "lib", "DLLs", "Library/bin", "shared"]
+    py_lib_dirs = [os.path.join(sys.prefix, d) for d in py_sub_dirs]
+    if hasattr(sys, "base_prefix"):
+        py_lib_dirs += [os.path.join(sys.base_prefix, d) for d in py_sub_dirs]
+
+    # Get user dirs to search (i.e. HOME)
+    home_dir = os.path.expanduser("~")
+    user_lib_dirs = [os.path.join(home_dir, d) for d in ["lib"]]
+
+    # Select only the dirs for which a directory exists, and remove duplicates
+    potential_lib_dirs = lib_dirs + sys_lib_dirs + py_lib_dirs + user_lib_dirs
+    lib_dirs = []
+    for ld in potential_lib_dirs:
+        if os.path.isdir(ld) and ld not in lib_dirs:
+            lib_dirs.append(ld)
+
+    # Now attempt to find libraries of that name in the given directory
+    # (case-insensitive)
+    lib_paths = []
+    for lib_dir in lib_dirs:
+        # Get files, prefer short names, last version
+        files = os.listdir(lib_dir)
+        files = reversed(sorted(files))
+        files = sorted(files, key=len)
+        for lib_name in lib_names:
+            # Test all filenames for name and ext
+            for fname in files:
+                if fname.lower().startswith(lib_name) and looks_lib(fname):
+                    lib_paths.append(os.path.join(lib_dir, fname))
+
+    # Return (only the items which are files)
+    lib_paths = [lp for lp in lib_paths if os.path.isfile(lp)]
+    return lib_dirs, lib_paths
+
+
+def load_lib(exact_lib_names, lib_names, lib_dirs=None):
+    """load_lib(exact_lib_names, lib_names, lib_dirs=None)
+
+    Load a dynamic library.
+
+    This function first tries to load the library from the given exact
+    names. When that fails, it tries to find the library in common
+    locations. It searches for files that start with one of the names
+    given in lib_names (case insensitive). The search is performed in
+    the given lib_dirs and a set of common library dirs.
+
+    Returns ``(ctypes_library, library_path)``
+    """
+
+    # Checks
+    assert isinstance(exact_lib_names, list)
+    assert isinstance(lib_names, list)
+    if lib_dirs is not None:
+        assert isinstance(lib_dirs, list)
+    exact_lib_names = [n for n in exact_lib_names if n]
+    lib_names = [n for n in lib_names if n]
+
+    # Get reference name (for better messages)
+    if lib_names:
+        the_lib_name = lib_names[0]
+    elif exact_lib_names:
+        the_lib_name = exact_lib_names[0]
+    else:
+        raise ValueError("No library name given.")
+
+    # Collect filenames of potential libraries
+    # First try a few bare library names that ctypes might be able to find
+    # in the default locations for each platform.
+    if SYSTEM_LIBS_ONLY:
+        lib_dirs, lib_paths = [], []
+    else:
+        lib_dirs, lib_paths = generate_candidate_libs(lib_names, lib_dirs)
+    lib_paths = exact_lib_names + lib_paths
+
+    # Select loader
+    if sys.platform.startswith("win"):
+        loader = ctypes.windll
+    else:
+        loader = ctypes.cdll
+
+    # Try to load until success
+    the_lib = None
+    errors = []
+    for fname in lib_paths:
+        try:
+            the_lib = loader.LoadLibrary(fname)
+            break
+        except Exception as err:
+            # Don't record errors when it couldn't load the library from an
+            # exact name -- this fails often, and doesn't provide any useful
+            # debugging information anyway, beyond "couldn't find library..."
+            if fname not in exact_lib_names:
+                errors.append((fname, err))
+
+    # No success ...
+    if the_lib is None:
+        if errors:
+            # No library loaded, and load-errors reported for some
+            # candidate libs
+            err_txt = ["%s:\n%s" % (lib, str(e)) for lib, e in errors]
+            msg = (
+                "One or more %s libraries were found, but "
+                + "could not be loaded due to the following errors:\n%s"
+            )
+            raise OSError(msg % (the_lib_name, "\n\n".join(err_txt)))
+        else:
+            # No errors, because no potential libraries found at all!
+            msg = "Could not find a %s library in any of:\n%s"
+            raise OSError(msg % (the_lib_name, "\n".join(lib_dirs)))
+
+    # Done
+    return the_lib, fname

evalkit_tf446/lib/python3.10/site-packages/imageio/core/legacy_plugin_wrapper.py

@@ -0,0 +1,363 @@
+from pathlib import Path
+
+import numpy as np
+
+from ..config import known_extensions
+from .request import InitializationError, IOMode
+from .v3_plugin_api import ImageProperties, PluginV3
+
+
+def _legacy_default_index(format):
+    if format._name == "FFMPEG":
+        index = Ellipsis
+    elif format._name == "GIF-PIL":
+        index = Ellipsis
+    else:
+        index = 0
+
+    return index
+
+
+class LegacyPlugin(PluginV3):
+    """A plugin to  make old (v2.9) plugins compatible with v3.0
+
+    .. depreciated:: 2.9
+        `legacy_get_reader` will be removed in a future version of imageio.
+        `legacy_get_writer` will be removed in a future version of imageio.
+
+    This plugin is a wrapper around the old FormatManager class and exposes
+    all the old plugins via the new API. On top of this it has
+    ``legacy_get_reader`` and ``legacy_get_writer`` methods to allow using
+    it with the v2.9 API.
+
+    Methods
+    -------
+    read(index=None, **kwargs)
+        Read the image at position ``index``.
+    write(image, **kwargs)
+        Write image to the URI.
+    iter(**kwargs)
+        Iteratively yield images from the given URI.
+    get_meta(index=None)
+        Return the metadata for the image at position ``index``.
+    legacy_get_reader(**kwargs)
+        Returns the v2.9 image reader. (depreciated)
+    legacy_get_writer(**kwargs)
+        Returns the v2.9 image writer. (depreciated)
+
+    Examples
+    --------
+
+    >>> import imageio.v3 as iio
+    >>> with iio.imopen("/path/to/image.tiff", "r", legacy_mode=True) as file:
+    >>>     reader = file.legacy_get_reader()  # depreciated
+    >>>     for im in file.iter():
+    >>>         print(im.shape)
+
+    """
+
+    def __init__(self, request, legacy_plugin):
+        """Instantiate a new Legacy Plugin
+
+        Parameters
+        ----------
+        uri : {str, pathlib.Path, bytes, file}
+            The resource to load the image from, e.g. a filename, pathlib.Path,
+            http address or file object, see the docs for more info.
+        legacy_plugin : Format
+            The (legacy) format to use to interface with the URI.
+
+        """
+        self._request = request
+        self._format = legacy_plugin
+
+        source = (
+            "<bytes>"
+            if isinstance(self._request.raw_uri, bytes)
+            else self._request.raw_uri
+        )
+        if self._request.mode.io_mode == IOMode.read:
+            if not self._format.can_read(request):
+                raise InitializationError(
+                    f"`{self._format.name}`" f" can not read `{source}`."
+                )
+        else:
+            if not self._format.can_write(request):
+                raise InitializationError(
+                    f"`{self._format.name}`" f" can not write to `{source}`."
+                )
+
+    def legacy_get_reader(self, **kwargs):
+        """legacy_get_reader(**kwargs)
+
+        a utility method to provide support vor the V2.9 API
+
+        Parameters
+        ----------
+        kwargs : ...
+            Further keyword arguments are passed to the reader. See :func:`.help`
+            to see what arguments are available for a particular format.
+        """
+
+        # Note: this will break thread-safety
+        self._request._kwargs = kwargs
+
+        # safeguard for DICOM plugin reading from folders
+        try:
+            assert Path(self._request.filename).is_dir()
+        except OSError:
+            pass  # not a valid path on this OS
+        except AssertionError:
+            pass  # not a folder
+        else:
+            return self._format.get_reader(self._request)
+
+        self._request.get_file().seek(0)
+        return self._format.get_reader(self._request)
+
+    def read(self, *, index=None, **kwargs):
+        """
+        Parses the given URI and creates a ndarray from it.
+
+        Parameters
+        ----------
+        index : {integer, None}
+            If the URI contains a list of ndimages return the index-th
+            image. If None, stack all images into an ndimage along the
+            0-th dimension (equivalent to np.stack(imgs, axis=0)).
+        kwargs : ...
+            Further keyword arguments are passed to the reader. See
+            :func:`.help` to see what arguments are available for a particular
+            format.
+
+        Returns
+        -------
+        ndimage : np.ndarray
+            A numpy array containing the decoded image data.
+
+        """
+
+        if index is None:
+            index = _legacy_default_index(self._format)
+
+        if index is Ellipsis:
+            img = np.stack([im for im in self.iter(**kwargs)])
+            return img
+
+        reader = self.legacy_get_reader(**kwargs)
+        return reader.get_data(index)
+
+    def legacy_get_writer(self, **kwargs):
+        """legacy_get_writer(**kwargs)
+
+        Returns a :class:`.Writer` object which can be used to write data
+        and meta data to the specified file.
+
+        Parameters
+        ----------
+        kwargs : ...
+            Further keyword arguments are passed to the writer. See :func:`.help`
+            to see what arguments are available for a particular format.
+        """
+
+        # Note: this will break thread-safety
+        self._request._kwargs = kwargs
+        return self._format.get_writer(self._request)
+
+    def write(self, ndimage, *, is_batch=None, metadata=None, **kwargs):
+        """
+        Write an ndimage to the URI specified in path.
+
+        If the URI points to a file on the current host and the file does not
+        yet exist it will be created. If the file exists already, it will be
+        appended if possible; otherwise, it will be replaced.
+
+        Parameters
+        ----------
+        ndimage : numpy.ndarray
+            The ndimage or list of ndimages to write.
+        is_batch : bool
+            If True, treat the supplied ndimage as a batch of images. If False,
+            treat the supplied ndimage as a single image. If None, try to
+            determine ``is_batch`` from the ndimage's shape and ndim.
+        metadata : dict
+            The metadata passed to write alongside the image.
+        kwargs : ...
+            Further keyword arguments are passed to the writer. See
+            :func:`.help` to see what arguments are available for a
+            particular format.
+
+
+        Returns
+        -------
+        buffer : bytes
+            When writing to the special target "<bytes>", this function will
+            return the encoded image data as a bytes string. Otherwise it
+            returns None.
+
+        Notes
+        -----
+        Automatically determining ``is_batch`` may fail for some images due to
+        shape aliasing. For example, it may classify a channel-first color image
+        as a batch of gray images. In most cases this automatic deduction works
+        fine (it has for almost a decade), but if you do have one of those edge
+        cases (or are worried that you might) consider explicitly setting
+        ``is_batch``.
+
+        """
+
+        if is_batch or isinstance(ndimage, (list, tuple)):
+            pass  # ndimage is list of images
+        elif is_batch is False:
+            ndimage = [ndimage]
+        else:
+            # Write the largest possible block by guessing the meaning of each
+            # dimension from the shape/ndim and then checking if any batch
+            # dimensions are left.
+            ndimage = np.asanyarray(ndimage)
+            batch_dims = ndimage.ndim
+
+            # two spatial dimensions
+            batch_dims = max(batch_dims - 2, 0)
+
+            # packed (channel-last) image
+            if ndimage.ndim >= 3 and ndimage.shape[-1] < 5:
+                batch_dims = max(batch_dims - 1, 0)
+
+            # format supports volumetric images
+            ext_infos = known_extensions.get(self._request.extension, list())
+            for ext_info in ext_infos:
+                if self._format.name in ext_info.priority and ext_info.volume_support:
+                    batch_dims = max(batch_dims - 1, 0)
+                    break
+
+            if batch_dims == 0:
+                ndimage = [ndimage]
+
+        with self.legacy_get_writer(**kwargs) as writer:
+            for image in ndimage:
+                image = np.asanyarray(image)
+
+                if image.ndim < 2:
+                    raise ValueError(
+                        "The image must have at least two spatial dimensions."
+                    )
+
+                if not np.issubdtype(image.dtype, np.number) and not np.issubdtype(
+                    image.dtype, bool
+                ):
+                    raise ValueError(
+                        f"All images have to be numeric, and not `{image.dtype}`."
+                    )
+
+                writer.append_data(image, metadata)
+
+        return writer.request.get_result()
+
+    def iter(self, **kwargs):
+        """Iterate over a list of ndimages given by the URI
+
+        Parameters
+        ----------
+        kwargs : ...
+            Further keyword arguments are passed to the reader. See
+            :func:`.help` to see what arguments are available for a particular
+            format.
+        """
+
+        reader = self.legacy_get_reader(**kwargs)
+        for image in reader:
+            yield image
+
+    def properties(self, index=None):
+        """Standardized ndimage metadata.
+
+        Parameters
+        ----------
+        index : int
+            The index of the ndimage for which to return properties. If the
+            index is out of bounds a ``ValueError`` is raised. If ``None``,
+            return the properties for the ndimage stack. If this is impossible,
+            e.g., due to shape mismatch, an exception will be raised.
+
+        Returns
+        -------
+        properties : ImageProperties
+            A dataclass filled with standardized image metadata.
+
+        """
+
+        if index is None:
+            index = _legacy_default_index(self._format)
+
+        # for backwards compatibility ... actually reads pixel data :(
+        if index is Ellipsis:
+            image = self.read(index=0)
+            n_images = self.legacy_get_reader().get_length()
+            return ImageProperties(
+                shape=(n_images, *image.shape),
+                dtype=image.dtype,
+                n_images=n_images,
+                is_batch=True,
+            )
+
+        image = self.read(index=index)
+        return ImageProperties(
+            shape=image.shape,
+            dtype=image.dtype,
+            is_batch=False,
+        )
+
+    def get_meta(self, *, index=None):
+        """Read ndimage metadata from the URI
+
+        Parameters
+        ----------
+        index : {integer, None}
+            If the URI contains a list of ndimages return the metadata
+            corresponding to the index-th image. If None, behavior depends on
+            the used api
+
+            Legacy-style API: return metadata of the first element (index=0)
+            New-style API: Behavior depends on the used Plugin.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary of metadata.
+
+        """
+
+        return self.metadata(index=index, exclude_applied=False)
+
+    def metadata(self, index=None, exclude_applied: bool = True):
+        """Format-Specific ndimage metadata.
+
+        Parameters
+        ----------
+        index : int
+            The index of the ndimage to read. If the index is out of bounds a
+            ``ValueError`` is raised. If ``None``, global metadata is returned.
+        exclude_applied : bool
+            This parameter exists for compatibility and has no effect. Legacy
+            plugins always report all metadata they find.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary filled with format-specific metadata fields and their
+            values.
+
+        """
+
+        if index is None:
+            index = _legacy_default_index(self._format)
+
+        return self.legacy_get_reader().get_meta_data(index=index)
+
+    def __del__(self) -> None:
+        pass
+        # turns out we can't close the file here for LegacyPlugin
+        # because it would break backwards compatibility
+        # with legacy_get_writer and legacy_get_reader
+        # self._request.finish()

evalkit_tf446/lib/python3.10/site-packages/imageio/core/request.pyi

@@ -0,0 +1,90 @@
+from typing import BinaryIO, Optional, Dict, Any, Sequence, overload, Literal
+from ..typing import ImageResource
+import enum
+
+EXAMPLE_IMAGES: Dict[str, str]
+RETURN_BYTES = "<bytes>"
+URI_BYTES = 1
+URI_FILE = 2
+URI_FILENAME = 3
+URI_ZIPPED = 4
+URI_HTTP = 5
+URI_FTP = 6
+
+class IOMode(str, enum.Enum):
+    read = "r"
+    write = "w"
+
+class ImageMode(str, enum.Enum):
+    single_image = "i"
+    multi_image = "I"
+    single_volume = "v"
+    multi_volume = "V"
+    any_mode = "?"
+
+@enum.unique
+class Mode(str, enum.Enum):
+    read_single_image = "ri"
+    read_multi_image = "rI"
+    read_single_volume = "rv"
+    read_multi_volume = "rV"
+    read_any = "r?"
+    write_single_image = "wi"
+    write_multi_image = "wI"
+    write_single_volume = "wv"
+    write_multi_volume = "wV"
+    write_any = "w?"
+
+    @classmethod
+    def _missing_(cls, value: Any) -> Mode: ...
+    @property
+    def io_mode(self) -> IOMode: ...
+    @property
+    def image_mode(self) -> ImageMode: ...
+
+class InitializationError(Exception): ...
+
+class Request(object):
+    _uri_type: int
+    raw_uri: ImageResource
+
+    @property
+    def filename(self) -> str: ...
+    @property
+    def extension(self) -> str: ...
+    @property
+    def format_hint(self) -> Optional[str]: ...
+    @format_hint.setter
+    def format_hint(self, format: str) -> None: ...
+    @property
+    def mode(self) -> Mode: ...
+    @property
+    def kwargs(self) -> Dict[str, Any]: ...
+    @property
+    def firstbytes(self) -> bytes: ...
+    def __init__(
+        self,
+        uri: ImageResource,
+        mode: str,
+        *,
+        extension: str = None,
+        format_hint: str = None,
+        **kwargs
+    ) -> None: ...
+    def _parse_uri(self, uri: ImageResource) -> None: ...
+    def get_file(self) -> BinaryIO: ...
+    def get_local_filename(self) -> str: ...
+    def finish(self) -> None: ...
+    def get_result(self) -> Optional[bytes]: ...
+    def _read_first_bytes(self, N: int = 256) -> bytes: ...
+
+def read_n_bytes(f: BinaryIO, N: int) -> bytes: ...
+
+class SeekableFileObject:
+    def __init__(self, f: BinaryIO) -> None: ...
+    def read(self, n: int = None) -> bytes: ...
+    def tell(self) -> int: ...
+    def seek(self, i: int, mode: int = 0) -> int: ...
+    def close(self) -> None: ...
+    def isatty(self) -> bool: ...
+    def seekable(self) -> bool: ...

evalkit_tf446/lib/python3.10/site-packages/imageio/core/util.py

@@ -0,0 +1,561 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""
+Various utilities for imageio
+"""
+
+
+from collections import OrderedDict
+import numpy as np
+import os
+import re
+import struct
+import sys
+import time
+import logging
+
+
+logger = logging.getLogger("imageio")
+
+IS_PYPY = "__pypy__" in sys.builtin_module_names
+THIS_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+def urlopen(*args, **kwargs):
+    """Compatibility function for the urlopen function. Raises an
+    RuntimeError if urlopen could not be imported (which can occur in
+    frozen applications.
+    """
+    try:
+        from urllib.request import urlopen
+    except ImportError:
+        raise RuntimeError("Could not import urlopen.")
+    return urlopen(*args, **kwargs)
+
+
+def _precision_warn(p1, p2, extra=""):
+    t = (
+        "Lossy conversion from {} to {}. {} Convert image to {} prior to "
+        "saving to suppress this warning."
+    )
+    logger.warning(t.format(p1, p2, extra, p2))
+
+
+def image_as_uint(im, bitdepth=None):
+    """Convert the given image to uint (default: uint8)
+
+    If the dtype already matches the desired format, it is returned
+    as-is. If the image is float, and all values are between 0 and 1,
+    the values are multiplied by np.power(2.0, bitdepth). In all other
+    situations, the values are scaled such that the minimum value
+    becomes 0 and the maximum value becomes np.power(2.0, bitdepth)-1
+    (255 for 8-bit and 65535 for 16-bit).
+    """
+    if not bitdepth:
+        bitdepth = 8
+    if not isinstance(im, np.ndarray):
+        raise ValueError("Image must be a numpy array")
+    if bitdepth == 8:
+        out_type = np.uint8
+    elif bitdepth == 16:
+        out_type = np.uint16
+    else:
+        raise ValueError("Bitdepth must be either 8 or 16")
+    dtype_str1 = str(im.dtype)
+    dtype_str2 = out_type.__name__
+    if (im.dtype == np.uint8 and bitdepth == 8) or (
+        im.dtype == np.uint16 and bitdepth == 16
+    ):
+        # Already the correct format? Return as-is
+        return im
+    if dtype_str1.startswith("float") and np.nanmin(im) >= 0 and np.nanmax(im) <= 1:
+        _precision_warn(dtype_str1, dtype_str2, "Range [0, 1].")
+        im = im.astype(np.float64) * (np.power(2.0, bitdepth) - 1) + 0.499999999
+    elif im.dtype == np.uint16 and bitdepth == 8:
+        _precision_warn(dtype_str1, dtype_str2, "Losing 8 bits of resolution.")
+        im = np.right_shift(im, 8)
+    elif im.dtype == np.uint32:
+        _precision_warn(
+            dtype_str1,
+            dtype_str2,
+            "Losing {} bits of resolution.".format(32 - bitdepth),
+        )
+        im = np.right_shift(im, 32 - bitdepth)
+    elif im.dtype == np.uint64:
+        _precision_warn(
+            dtype_str1,
+            dtype_str2,
+            "Losing {} bits of resolution.".format(64 - bitdepth),
+        )
+        im = np.right_shift(im, 64 - bitdepth)
+    else:
+        mi = np.nanmin(im)
+        ma = np.nanmax(im)
+        if not np.isfinite(mi):
+            raise ValueError("Minimum image value is not finite")
+        if not np.isfinite(ma):
+            raise ValueError("Maximum image value is not finite")
+        if ma == mi:
+            return im.astype(out_type)
+        _precision_warn(dtype_str1, dtype_str2, "Range [{}, {}].".format(mi, ma))
+        # Now make float copy before we scale
+        im = im.astype("float64")
+        # Scale the values between 0 and 1 then multiply by the max value
+        im = (im - mi) / (ma - mi) * (np.power(2.0, bitdepth) - 1) + 0.499999999
+    assert np.nanmin(im) >= 0
+    assert np.nanmax(im) < np.power(2.0, bitdepth)
+    return im.astype(out_type)
+
+
+class Array(np.ndarray):
+    """Array(array, meta=None)
+
+    A subclass of np.ndarray that has a meta attribute. Get the dictionary
+    that contains the meta data using ``im.meta``. Convert to a plain numpy
+    array using ``np.asarray(im)``.
+
+    """
+
+    def __new__(cls, array, meta=None):
+        # Check
+        if not isinstance(array, np.ndarray):
+            raise ValueError("Array expects a numpy array.")
+        if not (meta is None or isinstance(meta, dict)):
+            raise ValueError("Array expects meta data to be a dict.")
+        # Convert and return
+        meta = meta if meta is not None else getattr(array, "meta", {})
+        try:
+            ob = array.view(cls)
+        except AttributeError:  # pragma: no cover
+            # Just return the original; no metadata on the array in Pypy!
+            return array
+        ob._copy_meta(meta)
+        return ob
+
+    def _copy_meta(self, meta):
+        """Make a 2-level deep copy of the meta dictionary."""
+        self._meta = Dict()
+        for key, val in meta.items():
+            if isinstance(val, dict):
+                val = Dict(val)  # Copy this level
+            self._meta[key] = val
+
+    @property
+    def meta(self):
+        """The dict with the meta data of this image."""
+        return self._meta
+
+    def __array_finalize__(self, ob):
+        """So the meta info is maintained when doing calculations with
+        the array.
+        """
+        if isinstance(ob, Array):
+            self._copy_meta(ob.meta)
+        else:
+            self._copy_meta({})
+
+    def __array_wrap__(self, out, context=None):
+        """So that we return a native numpy array (or scalar) when a
+        reducting ufunc is applied (such as sum(), std(), etc.)
+        """
+        if not out.shape:
+            return out.dtype.type(out)  # Scalar
+        elif out.shape != self.shape:
+            return out.view(type=np.ndarray)
+        elif not isinstance(out, Array):
+            return Array(out, self.meta)
+        else:
+            return out  # Type Array
+
+
+Image = Array  # Alias for backwards compatibility
+
+
+def asarray(a):
+    """Pypy-safe version of np.asarray. Pypy's np.asarray consumes a
+    *lot* of memory if the given array is an ndarray subclass. This
+    function does not.
+    """
+    if isinstance(a, np.ndarray):
+        if IS_PYPY:  # pragma: no cover
+            a = a.copy()  # pypy has issues with base views
+        plain = a.view(type=np.ndarray)
+        return plain
+    return np.asarray(a)
+
+
+class Dict(OrderedDict):
+    """A dict in which the keys can be get and set as if they were
+    attributes. Very convenient in combination with autocompletion.
+
+    This Dict still behaves as much as possible as a normal dict, and
+    keys can be anything that are otherwise valid keys. However,
+    keys that are not valid identifiers or that are names of the dict
+    class (such as 'items' and 'copy') cannot be get/set as attributes.
+    """
+
+    __reserved_names__ = dir(OrderedDict())  # Also from OrderedDict
+    __pure_names__ = dir(dict())
+
+    def __getattribute__(self, key):
+        try:
+            return object.__getattribute__(self, key)
+        except AttributeError:
+            if key in self:
+                return self[key]
+            else:
+                raise
+
+    def __setattr__(self, key, val):
+        if key in Dict.__reserved_names__:
+            # Either let OrderedDict do its work, or disallow
+            if key not in Dict.__pure_names__:
+                return OrderedDict.__setattr__(self, key, val)
+            else:
+                raise AttributeError(
+                    "Reserved name, this key can only "
+                    + "be set via ``d[%r] = X``" % key
+                )
+        else:
+            # if isinstance(val, dict): val = Dict(val) -> no, makes a copy!
+            self[key] = val
+
+    def __dir__(self):
+        def isidentifier(x):
+            return bool(re.match(r"[a-z_]\w*$", x, re.I))
+
+        names = [k for k in self.keys() if (isinstance(k, str) and isidentifier(k))]
+        return Dict.__reserved_names__ + names
+
+
+class BaseProgressIndicator(object):
+    """BaseProgressIndicator(name)
+
+    A progress indicator helps display the progress of a task to the
+    user. Progress can be pending, running, finished or failed.
+
+    Each task has:
+      * a name - a short description of what needs to be done.
+      * an action - the current action in performing the task (e.g. a subtask)
+      * progress - how far the task is completed
+      * max - max number of progress units. If 0, the progress is indefinite
+      * unit - the units in which the progress is counted
+      * status - 0: pending, 1: in progress, 2: finished, 3: failed
+
+    This class defines an abstract interface. Subclasses should implement
+    _start, _stop, _update_progress(progressText), _write(message).
+    """
+
+    def __init__(self, name):
+        self._name = name
+        self._action = ""
+        self._unit = ""
+        self._max = 0
+        self._status = 0
+        self._last_progress_update = 0
+
+    def start(self, action="", unit="", max=0):
+        """start(action='', unit='', max=0)
+
+        Start the progress. Optionally specify an action, a unit,
+        and a maximum progress value.
+        """
+        if self._status == 1:
+            self.finish()
+        self._action = action
+        self._unit = unit
+        self._max = max
+        #
+        self._progress = 0
+        self._status = 1
+        self._start()
+
+    def status(self):
+        """status()
+
+        Get the status of the progress - 0: pending, 1: in progress,
+        2: finished, 3: failed
+        """
+        return self._status
+
+    def set_progress(self, progress=0, force=False):
+        """set_progress(progress=0, force=False)
+
+        Set the current progress. To avoid unnecessary progress updates
+        this will only have a visual effect if the time since the last
+        update is > 0.1 seconds, or if force is True.
+        """
+        self._progress = progress
+        # Update or not?
+        if not (force or (time.time() - self._last_progress_update > 0.1)):
+            return
+        self._last_progress_update = time.time()
+        # Compose new string
+        unit = self._unit or ""
+        progressText = ""
+        if unit == "%":
+            progressText = "%2.1f%%" % progress
+        elif self._max > 0:
+            percent = 100 * float(progress) / self._max
+            progressText = "%i/%i %s (%2.1f%%)" % (progress, self._max, unit, percent)
+        elif progress > 0:
+            if isinstance(progress, float):
+                progressText = "%0.4g %s" % (progress, unit)
+            else:
+                progressText = "%i %s" % (progress, unit)
+        # Update
+        self._update_progress(progressText)
+
+    def increase_progress(self, extra_progress):
+        """increase_progress(extra_progress)
+
+        Increase the progress by a certain amount.
+        """
+        self.set_progress(self._progress + extra_progress)
+
+    def finish(self, message=None):
+        """finish(message=None)
+
+        Finish the progress, optionally specifying a message. This will
+        not set the progress to the maximum.
+        """
+        self.set_progress(self._progress, True)  # fore update
+        self._status = 2
+        self._stop()
+        if message is not None:
+            self._write(message)
+
+    def fail(self, message=None):
+        """fail(message=None)
+
+        Stop the progress with a failure, optionally specifying a message.
+        """
+        self.set_progress(self._progress, True)  # fore update
+        self._status = 3
+        self._stop()
+        message = "FAIL " + (message or "")
+        self._write(message)
+
+    def write(self, message):
+        """write(message)
+
+        Write a message during progress (such as a warning).
+        """
+        if self.__class__ == BaseProgressIndicator:
+            # When this class is used as a dummy, print explicit message
+            print(message)
+        else:
+            return self._write(message)
+
+    # Implementing classes should implement these
+
+    def _start(self):
+        pass
+
+    def _stop(self):
+        pass
+
+    def _update_progress(self, progressText):
+        pass
+
+    def _write(self, message):
+        pass
+
+
+class StdoutProgressIndicator(BaseProgressIndicator):
+    """StdoutProgressIndicator(name)
+
+    A progress indicator that shows the progress in stdout. It
+    assumes that the tty can appropriately deal with backspace
+    characters.
+    """
+
+    def _start(self):
+        self._chars_prefix, self._chars = "", ""
+        # Write message
+        if self._action:
+            self._chars_prefix = "%s (%s): " % (self._name, self._action)
+        else:
+            self._chars_prefix = "%s: " % self._name
+        sys.stdout.write(self._chars_prefix)
+        sys.stdout.flush()
+
+    def _update_progress(self, progressText):
+        # If progress is unknown, at least make something move
+        if not progressText:
+            i1, i2, i3, i4 = "-\\|/"
+            M = {i1: i2, i2: i3, i3: i4, i4: i1}
+            progressText = M.get(self._chars, i1)
+        # Store new string and write
+        delChars = "\b" * len(self._chars)
+        self._chars = progressText
+        sys.stdout.write(delChars + self._chars)
+        sys.stdout.flush()
+
+    def _stop(self):
+        self._chars = self._chars_prefix = ""
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+    def _write(self, message):
+        # Write message
+        delChars = "\b" * len(self._chars_prefix + self._chars)
+        sys.stdout.write(delChars + "  " + message + "\n")
+        # Reprint progress text
+        sys.stdout.write(self._chars_prefix + self._chars)
+        sys.stdout.flush()
+
+
+# From pyzolib/paths.py (https://bitbucket.org/pyzo/pyzolib/src/tip/paths.py)
+def appdata_dir(appname=None, roaming=False):
+    """appdata_dir(appname=None, roaming=False)
+
+    Get the path to the application directory, where applications are allowed
+    to write user specific files (e.g. configurations). For non-user specific
+    data, consider using common_appdata_dir().
+    If appname is given, a subdir is appended (and created if necessary).
+    If roaming is True, will prefer a roaming directory (Windows Vista/7).
+    """
+
+    # Define default user directory
+    userDir = os.getenv("IMAGEIO_USERDIR", None)
+    if userDir is None:
+        userDir = os.path.expanduser("~")
+        if not os.path.isdir(userDir):  # pragma: no cover
+            userDir = "/var/tmp"  # issue #54
+
+    # Get system app data dir
+    path = None
+    if sys.platform.startswith("win"):
+        path1, path2 = os.getenv("LOCALAPPDATA"), os.getenv("APPDATA")
+        path = (path2 or path1) if roaming else (path1 or path2)
+    elif sys.platform.startswith("darwin"):
+        path = os.path.join(userDir, "Library", "Application Support")
+    # On Linux and as fallback
+    if not (path and os.path.isdir(path)):
+        path = userDir
+
+    # Maybe we should store things local to the executable (in case of a
+    # portable distro or a frozen application that wants to be portable)
+    prefix = sys.prefix
+    if getattr(sys, "frozen", None):
+        prefix = os.path.abspath(os.path.dirname(sys.executable))
+    for reldir in ("settings", "../settings"):
+        localpath = os.path.abspath(os.path.join(prefix, reldir))
+        if os.path.isdir(localpath):  # pragma: no cover
+            try:
+                open(os.path.join(localpath, "test.write"), "wb").close()
+                os.remove(os.path.join(localpath, "test.write"))
+            except IOError:
+                pass  # We cannot write in this directory
+            else:
+                path = localpath
+                break
+
+    # Get path specific for this app
+    if appname:
+        if path == userDir:
+            appname = "." + appname.lstrip(".")  # Make it a hidden directory
+        path = os.path.join(path, appname)
+        if not os.path.isdir(path):  # pragma: no cover
+            os.makedirs(path, exist_ok=True)
+
+    # Done
+    return path
+
+
+def resource_dirs():
+    """resource_dirs()
+
+    Get a list of directories where imageio resources may be located.
+    The first directory in this list is the "resources" directory in
+    the package itself. The second directory is the appdata directory
+    (~/.imageio on Linux). The list further contains the application
+    directory (for frozen apps), and may include additional directories
+    in the future.
+    """
+    dirs = [resource_package_dir()]
+    # Resource dir baked in the package.
+    # Appdata directory
+    try:
+        dirs.append(appdata_dir("imageio"))
+    except Exception:  # pragma: no cover
+        pass  # The home dir may not be writable
+    # Directory where the app is located (mainly for frozen apps)
+    if getattr(sys, "frozen", None):
+        dirs.append(os.path.abspath(os.path.dirname(sys.executable)))
+    elif sys.path and sys.path[0]:
+        dirs.append(os.path.abspath(sys.path[0]))
+    return dirs
+
+
+def resource_package_dir():
+    """package_dir
+
+    Get the resources directory in the imageio package installation
+    directory.
+
+    Notes
+    -----
+    This is a convenience method that is used by `resource_dirs` and
+    imageio entry point scripts.
+    """
+    # Make pkg_resources optional if setuptools is not available
+    try:
+        # Avoid importing pkg_resources in the top level due to how slow it is
+        # https://github.com/pypa/setuptools/issues/510
+        import pkg_resources
+    except ImportError:
+        pkg_resources = None
+
+    if pkg_resources:
+        # The directory returned by `pkg_resources.resource_filename`
+        # also works with eggs.
+        pdir = pkg_resources.resource_filename("imageio", "resources")
+    else:
+        # If setuptools is not available, use fallback
+        pdir = os.path.abspath(os.path.join(THIS_DIR, "..", "resources"))
+    return pdir
+
+
+def get_platform():
+    """get_platform()
+
+    Get a string that specifies the platform more specific than
+    sys.platform does. The result can be: linux32, linux64, win32,
+    win64, osx32, osx64. Other platforms may be added in the future.
+    """
+    # Get platform
+    if sys.platform.startswith("linux"):
+        plat = "linux%i"
+    elif sys.platform.startswith("win"):
+        plat = "win%i"
+    elif sys.platform.startswith("darwin"):
+        plat = "osx%i"
+    elif sys.platform.startswith("freebsd"):
+        plat = "freebsd%i"
+    else:  # pragma: no cover
+        return None
+
+    return plat % (struct.calcsize("P") * 8)  # 32 or 64 bits
+
+
+def has_module(module_name):
+    """Check to see if a python module is available."""
+    if sys.version_info > (3, 4):
+        import importlib
+
+        name_parts = module_name.split(".")
+        for i in range(len(name_parts)):
+            if importlib.util.find_spec(".".join(name_parts[: i + 1])) is None:
+                return False
+        return True
+    else:  # pragma: no cover
+        import imp
+
+        try:
+            imp.find_module(module_name)
+        except ImportError:
+            return False
+        return True

evalkit_tf446/lib/python3.10/site-packages/markdown_it/common/entities.py

@@ -0,0 +1,4 @@
+"""HTML5 entities map: { name -> characters }."""
+import html.entities
+
+entities = {name.rstrip(";"): chars for name, chars in html.entities.html5.items()}

evalkit_tf446/lib/python3.10/site-packages/markdown_it/common/html_blocks.py

@@ -0,0 +1,68 @@
+"""List of valid html blocks names, according to commonmark spec
+http://jgm.github.io/CommonMark/spec.html#html-blocks
+"""
+
+block_names = [
+    "address",
+    "article",
+    "aside",
+    "base",
+    "basefont",
+    "blockquote",
+    "body",
+    "caption",
+    "center",
+    "col",
+    "colgroup",
+    "dd",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "html",
+    "iframe",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "menu",
+    "menuitem",
+    "nav",
+    "noframes",
+    "ol",
+    "optgroup",
+    "option",
+    "p",
+    "param",
+    "section",
+    "source",
+    "summary",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "title",
+    "tr",
+    "track",
+    "ul",
+]

evalkit_tf446/lib/python3.10/site-packages/markdown_it/common/html_re.py

@@ -0,0 +1,40 @@
+"""Regexps to match html elements
+"""
+
+import re
+
+attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
+
+unquoted = "[^\"'=<>`\\x00-\\x20]+"
+single_quoted = "'[^']*'"
+double_quoted = '"[^"]*"'
+
+attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")"
+
+attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)"
+
+open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>"
+
+close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>"
+comment = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->"
+processing = "<[?][\\s\\S]*?[?]>"
+declaration = "<![A-Z]+\\s+[^>]*>"
+cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
+
+HTML_TAG_RE = re.compile(
+    "^(?:"
+    + open_tag
+    + "|"
+    + close_tag
+    + "|"
+    + comment
+    + "|"
+    + processing
+    + "|"
+    + declaration
+    + "|"
+    + cdata
+    + ")"
+)
+HTML_OPEN_CLOSE_TAG_STR = "^(?:" + open_tag + "|" + close_tag + ")"
+HTML_OPEN_CLOSE_TAG_RE = re.compile(HTML_OPEN_CLOSE_TAG_STR)

evalkit_tf446/lib/python3.10/site-packages/markdown_it/common/normalize_url.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextlib import suppress
+import re
+from urllib.parse import quote, unquote, urlparse, urlunparse  # noqa: F401
+
+import mdurl
+
+from .. import _punycode
+
+RECODE_HOSTNAME_FOR = ("http:", "https:", "mailto:")
+
+
+def normalizeLink(url: str) -> str:
+    """Normalize destination URLs in links
+
+    ::
+
+        [label]:   destination   'title'
+                ^^^^^^^^^^^
+    """
+    parsed = mdurl.parse(url, slashes_denote_host=True)
+
+    # Encode hostnames in urls like:
+    # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    #
+    # We don't encode unknown schemas, because it's likely that we encode
+    # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    #
+    if parsed.hostname and (
+        not parsed.protocol or parsed.protocol in RECODE_HOSTNAME_FOR
+    ):
+        with suppress(Exception):
+            parsed = parsed._replace(hostname=_punycode.to_ascii(parsed.hostname))
+
+    return mdurl.encode(mdurl.format(parsed))
+
+
+def normalizeLinkText(url: str) -> str:
+    """Normalize autolink content
+
+    ::
+
+        <destination>
+         ~~~~~~~~~~~
+    """
+    parsed = mdurl.parse(url, slashes_denote_host=True)
+
+    # Encode hostnames in urls like:
+    # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    #
+    # We don't encode unknown schemas, because it's likely that we encode
+    # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    #
+    if parsed.hostname and (
+        not parsed.protocol or parsed.protocol in RECODE_HOSTNAME_FOR
+    ):
+        with suppress(Exception):
+            parsed = parsed._replace(hostname=_punycode.to_unicode(parsed.hostname))
+
+    # add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720
+    return mdurl.decode(mdurl.format(parsed), mdurl.DECODE_DEFAULT_CHARS + "%")
+
+
+BAD_PROTO_RE = re.compile(r"^(vbscript|javascript|file|data):")
+GOOD_DATA_RE = re.compile(r"^data:image\/(gif|png|jpeg|webp);")
+
+
+def validateLink(url: str, validator: Callable[[str], bool] | None = None) -> bool:
+    """Validate URL link is allowed in output.
+
+    This validator can prohibit more than really needed to prevent XSS.
+    It's a tradeoff to keep code simple and to be secure by default.
+
+    Note: url should be normalized at this point, and existing entities decoded.
+    """
+    if validator is not None:
+        return validator(url)
+    url = url.strip().lower()
+    return bool(GOOD_DATA_RE.search(url)) if BAD_PROTO_RE.search(url) else True

evalkit_tf446/lib/python3.10/site-packages/markdown_it/common/utils.py

@@ -0,0 +1,318 @@
+"""Utilities for parsing source text
+"""
+from __future__ import annotations
+
+import re
+from typing import Match, TypeVar
+
+from .entities import entities
+
+
+def charCodeAt(src: str, pos: int) -> int | None:
+    """
+    Returns the Unicode value of the character at the specified location.
+
+    @param - index The zero-based index of the desired character.
+    If there is no character at the specified index, NaN is returned.
+
+    This was added for compatibility with python
+    """
+    try:
+        return ord(src[pos])
+    except IndexError:
+        return None
+
+
+def charStrAt(src: str, pos: int) -> str | None:
+    """
+    Returns the Unicode value of the character at the specified location.
+
+    @param - index The zero-based index of the desired character.
+    If there is no character at the specified index, NaN is returned.
+
+    This was added for compatibility with python
+    """
+    try:
+        return src[pos]
+    except IndexError:
+        return None
+
+
+_ItemTV = TypeVar("_ItemTV")
+
+
+def arrayReplaceAt(
+    src: list[_ItemTV], pos: int, newElements: list[_ItemTV]
+) -> list[_ItemTV]:
+    """
+    Remove element from array and put another array at those position.
+    Useful for some operations with tokens
+    """
+    return src[:pos] + newElements + src[pos + 1 :]
+
+
+def isValidEntityCode(c: int) -> bool:
+    # broken sequence
+    if c >= 0xD800 and c <= 0xDFFF:
+        return False
+    # never used
+    if c >= 0xFDD0 and c <= 0xFDEF:
+        return False
+    if ((c & 0xFFFF) == 0xFFFF) or ((c & 0xFFFF) == 0xFFFE):
+        return False
+    # control codes
+    if c >= 0x00 and c <= 0x08:
+        return False
+    if c == 0x0B:
+        return False
+    if c >= 0x0E and c <= 0x1F:
+        return False
+    if c >= 0x7F and c <= 0x9F:
+        return False
+    # out of range
+    if c > 0x10FFFF:
+        return False
+    return True
+
+
+def fromCodePoint(c: int) -> str:
+    """Convert ordinal to unicode.
+
+    Note, in the original Javascript two string characters were required,
+    for codepoints larger than `0xFFFF`.
+    But Python 3 can represent any unicode codepoint in one character.
+    """
+    return chr(c)
+
+
+# UNESCAPE_MD_RE = re.compile(r'\\([!"#$%&\'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])')
+# ENTITY_RE_g       = re.compile(r'&([a-z#][a-z0-9]{1,31})', re.IGNORECASE)
+UNESCAPE_ALL_RE = re.compile(
+    r'\\([!"#$%&\'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])' + "|" + r"&([a-z#][a-z0-9]{1,31});",
+    re.IGNORECASE,
+)
+DIGITAL_ENTITY_BASE10_RE = re.compile(r"#([0-9]{1,8})")
+DIGITAL_ENTITY_BASE16_RE = re.compile(r"#x([a-f0-9]{1,8})", re.IGNORECASE)
+
+
+def replaceEntityPattern(match: str, name: str) -> str:
+    """Convert HTML entity patterns,
+    see https://spec.commonmark.org/0.30/#entity-references
+    """
+    if name in entities:
+        return entities[name]
+
+    code: None | int = None
+    if pat := DIGITAL_ENTITY_BASE10_RE.fullmatch(name):
+        code = int(pat.group(1), 10)
+    elif pat := DIGITAL_ENTITY_BASE16_RE.fullmatch(name):
+        code = int(pat.group(1), 16)
+
+    if code is not None and isValidEntityCode(code):
+        return fromCodePoint(code)
+
+    return match
+
+
+def unescapeAll(string: str) -> str:
+    def replacer_func(match: Match[str]) -> str:
+        escaped = match.group(1)
+        if escaped:
+            return escaped
+        entity = match.group(2)
+        return replaceEntityPattern(match.group(), entity)
+
+    if "\\" not in string and "&" not in string:
+        return string
+    return UNESCAPE_ALL_RE.sub(replacer_func, string)
+
+
+ESCAPABLE = r"""\\!"#$%&'()*+,./:;<=>?@\[\]^`{}|_~-"""
+ESCAPE_CHAR = re.compile(r"\\([" + ESCAPABLE + r"])")
+
+
+def stripEscape(string: str) -> str:
+    """Strip escape \\ characters"""
+    return ESCAPE_CHAR.sub(r"\1", string)
+
+
+def escapeHtml(raw: str) -> str:
+    """Replace special characters "&", "<", ">" and '"' to HTML-safe sequences."""
+    # like html.escape, but without escaping single quotes
+    raw = raw.replace("&", "&amp;")  # Must be done first!
+    raw = raw.replace("<", "&lt;")
+    raw = raw.replace(">", "&gt;")
+    raw = raw.replace('"', "&quot;")
+    return raw
+
+
+# //////////////////////////////////////////////////////////////////////////////
+
+REGEXP_ESCAPE_RE = re.compile(r"[.?*+^$[\]\\(){}|-]")
+
+
+def escapeRE(string: str) -> str:
+    string = REGEXP_ESCAPE_RE.sub("\\$&", string)
+    return string
+
+
+# //////////////////////////////////////////////////////////////////////////////
+
+
+def isSpace(code: int | None) -> bool:
+    """Check if character code is a whitespace."""
+    return code in (0x09, 0x20)
+
+
+def isStrSpace(ch: str | None) -> bool:
+    """Check if character is a whitespace."""
+    return ch in ("\t", " ")
+
+
+MD_WHITESPACE = {
+    0x09,  # \t
+    0x0A,  # \n
+    0x0B,  # \v
+    0x0C,  # \f
+    0x0D,  # \r
+    0x20,  # space
+    0xA0,
+    0x1680,
+    0x202F,
+    0x205F,
+    0x3000,
+}
+
+
+def isWhiteSpace(code: int) -> bool:
+    r"""Zs (unicode class) || [\t\f\v\r\n]"""
+    if code >= 0x2000 and code <= 0x200A:
+        return True
+    return code in MD_WHITESPACE
+
+
+# //////////////////////////////////////////////////////////////////////////////
+
+UNICODE_PUNCT_RE = re.compile(
+    r"[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4E\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]"  # noqa: E501
+)
+
+
+# Currently without astral characters support.
+def isPunctChar(ch: str) -> bool:
+    """Check if character is a punctuation character."""
+    return UNICODE_PUNCT_RE.search(ch) is not None
+
+
+MD_ASCII_PUNCT = {
+    0x21,  # /* ! */
+    0x22,  # /* " */
+    0x23,  # /* # */
+    0x24,  # /* $ */
+    0x25,  # /* % */
+    0x26,  # /* & */
+    0x27,  # /* ' */
+    0x28,  # /* ( */
+    0x29,  # /* ) */
+    0x2A,  # /* * */
+    0x2B,  # /* + */
+    0x2C,  # /* , */
+    0x2D,  # /* - */
+    0x2E,  # /* . */
+    0x2F,  # /* / */
+    0x3A,  # /* : */
+    0x3B,  # /* ; */
+    0x3C,  # /* < */
+    0x3D,  # /* = */
+    0x3E,  # /* > */
+    0x3F,  # /* ? */
+    0x40,  # /* @ */
+    0x5B,  # /* [ */
+    0x5C,  # /* \ */
+    0x5D,  # /* ] */
+    0x5E,  # /* ^ */
+    0x5F,  # /* _ */
+    0x60,  # /* ` */
+    0x7B,  # /* { */
+    0x7C,  # /* | */
+    0x7D,  # /* } */
+    0x7E,  # /* ~ */
+}
+
+
+def isMdAsciiPunct(ch: int) -> bool:
+    """Markdown ASCII punctuation characters.
+
+    ::
+
+        !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~
+
+    See http://spec.commonmark.org/0.15/#ascii-punctuation-character
+
+    Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
+
+    """  # noqa: E501
+    return ch in MD_ASCII_PUNCT
+
+
+def normalizeReference(string: str) -> str:
+    """Helper to unify [reference labels]."""
+    # Trim and collapse whitespace
+    #
+    string = re.sub(r"\s+", " ", string.strip())
+
+    # In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug
+    # fixed in v12 (couldn't find any details).
+    #
+    # So treat this one as a special case
+    # (remove this when node v10 is no longer supported).
+    #
+    # if ('ẞ'.toLowerCase() === 'Ṿ') {
+    #   str = str.replace(/ẞ/g, 'ß')
+    # }
+
+    # .toLowerCase().toUpperCase() should get rid of all differences
+    # between letter variants.
+    #
+    # Simple .toLowerCase() doesn't normalize 125 code points correctly,
+    # and .toUpperCase doesn't normalize 6 of them (list of exceptions:
+    # İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
+    # uppercased versions).
+    #
+    # Here's an example showing how it happens. Lets take greek letter omega:
+    # uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
+    #
+    # Unicode entries:
+    # 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8
+    # 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
+    # 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
+    # 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8
+    #
+    # Case-insensitive comparison should treat all of them as equivalent.
+    #
+    # But .toLowerCase() doesn't change ϑ (it's already lowercase),
+    # and .toUpperCase() doesn't change ϴ (already uppercase).
+    #
+    # Applying first lower then upper case normalizes any character:
+    # '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
+    #
+    # Note: this is equivalent to unicode case folding; unicode normalization
+    # is a different step that is not required here.
+    #
+    # Final result should be uppercased, because it's later stored in an object
+    # (this avoid a conflict with Object.prototype members,
+    # most notably, `__proto__`)
+    #
+    return string.lower().upper()
+
+
+LINK_OPEN_RE = re.compile(r"^<a[>\s]", flags=re.IGNORECASE)
+LINK_CLOSE_RE = re.compile(r"^</a\s*>", flags=re.IGNORECASE)
+
+
+def isLinkOpen(string: str) -> bool:
+    return bool(LINK_OPEN_RE.search(string))
+
+
+def isLinkClose(string: str) -> bool:
+    return bool(LINK_CLOSE_RE.search(string))

evalkit_tf446/lib/python3.10/site-packages/markdown_it/helpers/__init__.py

@@ -0,0 +1,6 @@
+"""Functions for parsing Links
+"""
+__all__ = ("parseLinkLabel", "parseLinkDestination", "parseLinkTitle")
+from .parse_link_destination import parseLinkDestination
+from .parse_link_label import parseLinkLabel
+from .parse_link_title import parseLinkTitle

evalkit_tf446/lib/python3.10/site-packages/markdown_it/helpers/parse_link_destination.py

@@ -0,0 +1,86 @@
+"""
+Parse link destination
+"""
+
+from ..common.utils import charCodeAt, unescapeAll
+
+
+class _Result:
+    __slots__ = ("ok", "pos", "lines", "str")
+
+    def __init__(self) -> None:
+        self.ok = False
+        self.pos = 0
+        self.lines = 0
+        self.str = ""
+
+
+def parseLinkDestination(string: str, pos: int, maximum: int) -> _Result:
+    lines = 0
+    start = pos
+    result = _Result()
+
+    if charCodeAt(string, pos) == 0x3C:  # /* < */
+        pos += 1
+        while pos < maximum:
+            code = charCodeAt(string, pos)
+            if code == 0x0A:  # /* \n */)
+                return result
+            if code == 0x3C:  # / * < * /
+                return result
+            if code == 0x3E:  # /* > */) {
+                result.pos = pos + 1
+                result.str = unescapeAll(string[start + 1 : pos])
+                result.ok = True
+                return result
+
+            if code == 0x5C and pos + 1 < maximum:  # \
+                pos += 2
+                continue
+
+            pos += 1
+
+        # no closing '>'
+        return result
+
+    # this should be ... } else { ... branch
+
+    level = 0
+    while pos < maximum:
+        code = charCodeAt(string, pos)
+
+        if code is None or code == 0x20:
+            break
+
+        # ascii control characters
+        if code < 0x20 or code == 0x7F:
+            break
+
+        if code == 0x5C and pos + 1 < maximum:
+            if charCodeAt(string, pos + 1) == 0x20:
+                break
+            pos += 2
+            continue
+
+        if code == 0x28:  # /* ( */)
+            level += 1
+            if level > 32:
+                return result
+
+        if code == 0x29:  # /* ) */)
+            if level == 0:
+                break
+            level -= 1
+
+        pos += 1
+
+    if start == pos:
+        return result
+    if level != 0:
+        return result
+
+    result.str = unescapeAll(string[start:pos])
+    result.lines = lines
+    result.pos = pos
+    result.ok = True
+    return result

evalkit_tf446/lib/python3.10/site-packages/markdown_it/helpers/parse_link_label.py

@@ -0,0 +1,43 @@
+"""
+Parse link label
+
+this function assumes that first character ("[") already matches
+returns the end of the label
+
+"""
+from markdown_it.rules_inline import StateInline
+
+
+def parseLinkLabel(state: StateInline, start: int, disableNested: bool = False) -> int:
+    labelEnd = -1
+    oldPos = state.pos
+    found = False
+
+    state.pos = start + 1
+    level = 1
+
+    while state.pos < state.posMax:
+        marker = state.src[state.pos]
+        if marker == "]":
+            level -= 1
+            if level == 0:
+                found = True
+                break
+
+        prevPos = state.pos
+        state.md.inline.skipToken(state)
+        if marker == "[":
+            if prevPos == state.pos - 1:
+                # increase level if we find text `[`,
+                # which is not a part of any token
+                level += 1
+            elif disableNested:
+                state.pos = oldPos
+                return -1
+    if found:
+        labelEnd = state.pos
+
+    # restore old state
+    state.pos = oldPos
+
+    return labelEnd

evalkit_tf446/lib/python3.10/site-packages/markdown_it/helpers/parse_link_title.py

@@ -0,0 +1,60 @@
+"""Parse link title
+"""
+from ..common.utils import charCodeAt, unescapeAll
+
+
+class _Result:
+    __slots__ = ("ok", "pos", "lines", "str")
+
+    def __init__(self) -> None:
+        self.ok = False
+        self.pos = 0
+        self.lines = 0
+        self.str = ""
+
+    def __str__(self) -> str:
+        return self.str
+
+
+def parseLinkTitle(string: str, pos: int, maximum: int) -> _Result:
+    lines = 0
+    start = pos
+    result = _Result()
+
+    if pos >= maximum:
+        return result
+
+    marker = charCodeAt(string, pos)
+
+    # /* " */  /* ' */  /* ( */
+    if marker != 0x22 and marker != 0x27 and marker != 0x28:
+        return result
+
+    pos += 1
+
+    # if opening marker is "(", switch it to closing marker ")"
+    if marker == 0x28:
+        marker = 0x29
+
+    while pos < maximum:
+        code = charCodeAt(string, pos)
+        if code == marker:
+            title = string[start + 1 : pos]
+            title = unescapeAll(title)
+            result.pos = pos + 1
+            result.lines = lines
+            result.str = title
+            result.ok = True
+            return result
+        elif code == 0x28 and marker == 0x29:  # /* ( */  /* ) */
+            return result
+        elif code == 0x0A:
+            lines += 1
+        elif code == 0x5C and pos + 1 < maximum:  # /* \ */
+            pos += 1
+            if charCodeAt(string, pos) == 0x0A:
+                lines += 1
+
+        pos += 1
+
+    return result

evalkit_tf446/lib/python3.10/site-packages/markdown_it/presets/default.py

@@ -0,0 +1,35 @@
+"""markdown-it default options."""
+from ..utils import PresetType
+
+
+def make() -> PresetType:
+    return {
+        "options": {
+            "maxNesting": 100,  # Internal protection, recursion limit
+            "html": False,  # Enable HTML tags in source
+            # this is just a shorthand for .disable(["html_inline", "html_block"])
+            # used by the linkify rule:
+            "linkify": False,  # autoconvert URL-like texts to links
+            # used by the replacements and smartquotes rules:
+            # Enable some language-neutral replacements + quotes beautification
+            "typographer": False,
+            # used by the smartquotes rule:
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Could be either a String or an Array.
+            # For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+            # and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+            "quotes": "\u201c\u201d\u2018\u2019",  # /* “”‘’ */
+            # Renderer specific; these options are used directly in the HTML renderer
+            "xhtmlOut": False,  # Use '/' to close single tags (<br />)
+            "breaks": False,  # Convert '\n' in paragraphs into <br>
+            "langPrefix": "language-",  # CSS language prefix for fenced blocks
+            # Highlighter function. Should return escaped HTML,
+            # or '' if the source string is not changed and should be escaped externally.
+            # If result starts with <pre... internal wrapper is skipped.
+            #
+            # function (/*str, lang, attrs*/) { return ''; }
+            #
+            "highlight": None,
+        },
+        "components": {"core": {}, "block": {}, "inline": {}},
+    }