+
+
+ Back to top
+
+
+
+
+
+
+
+
+
+
+from __future__ import annotations
+
+from abc import ABC
+from collections import defaultdict
+from itertools import groupby
+from pprint import pprint
+from typing import TYPE_CHECKING, Generator
+
+from .utils.handler import POS, ContentHandler, Match, Pattern
+from .utils.logger import LOGGER
+
+if TYPE_CHECKING:
+ from .parser import GrammarParser
+
+
+TOKEN_DICT = dict[POS, list[str]]
+
+
+
+[docs]
+class Capture:
+ """A captured matching group.
+
+ After mathing, any pattern can have a number of capture groups for which subsequent parsers can be defined.
+ The Capture object stores this subsequent parse to be dispatched at a later moment.
+ """
+
+ def __init__(
+ self,
+ handler: ContentHandler,
+ pattern: Pattern,
+ matching: Match,
+ parsers: dict[int, GrammarParser],
+ starting: tuple[int, int],
+ boundary: tuple[int, int],
+ key: str = "",
+ **kwargs,
+ ):
+ """
+ Initialize a new instance of the Element class.
+
+ :param handler: The content handler for the element.
+ :param pattern: The pattern used for matching.
+ :param matching: The match object.
+ :param parsers: A dictionary of grammar parsers.
+ :param starting: The starting position of the element.
+ :param boundary: The boundary position of the element.
+ :param key: The key for the element. Defaults to "".
+ :param **kwargs: Additional keyword arguments.
+ :returns: None
+ """
+ self.handler = handler
+ self.pattern = pattern
+ self.matching = matching
+ self.parsers = parsers
+ self.starting = starting
+ self.boundary = boundary
+ self.key = key
+ self.kwargs = kwargs
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, Capture):
+ return bool(
+ self.key == other.key
+ and self.starting == other.starting
+ and self.matching.group() == other.matching.group()
+ )
+ else:
+ return False
+
+ def __repr__(self) -> str:
+ return f"@capture<{self.key}>"
+
+
+[docs]
+ def dispatch(self) -> list[Capture | ContentElement]:
+ """Dispatches the remaining parse of the capture group.
+
+ This method iterates over the defined parsers for the capture group and dispatches the remaining parse
+ based on the captured elements. It returns a list of captured elements or captures.
+
+ :return: A list of Capture or ContentElement objects representing the parsed elements.
+ """
+ elements = []
+ for group_id, parser in self.parsers.items():
+ if group_id > self.pattern.number_of_captures():
+ LOGGER.warning(
+ f"The capture group {group_id} does not exist in pattern {self.pattern._pattern}"
+ )
+ continue
+
+ group_span = self.matching.span(group_id)
+
+ # Empty group
+ if group_span[0] == group_span[1]:
+ continue
+
+ group_starting = (self.starting[0], group_span[0])
+ group_boundary = (self.starting[0], group_span[1])
+
+ if (
+ parser == self
+ and group_starting == self.starting
+ and group_boundary == self.boundary
+ ):
+ LOGGER.warning("Parser loop detected, continuing...", self, self.starting)
+ continue
+
+ # Dispatch the parse
+ self.kwargs.pop("greedy", None)
+ parsed, captured_elements, _ = parser._parse(
+ self.handler,
+ starting=group_starting,
+ boundary=group_boundary,
+ find_one=self.kwargs.pop("find_one", False),
+ parent_capture=self,
+ **self.kwargs,
+ )
+
+ if parsed:
+ elements.extend(captured_elements)
+
+ return elements
+
+
+
+
+def _dispatch_list(
+ pending_elements: list[Capture | ContentElement], parent: ContentElement | None = None
+) -> list[ContentElement]:
+ """Dispatches all captured parsers in the list."""
+ elements = []
+ for item in pending_elements:
+ if isinstance(item, Capture):
+ captured_elements: list[ContentElement] = _dispatch_list(item.dispatch())
+ elements.extend(captured_elements)
+ elif item != parent:
+ elements.append(item)
+ for element in elements:
+ element.parent = parent
+ return elements
+
+
+def _str_to_list(input: str | list[str]) -> list[str]:
+ if isinstance(input, str):
+ return [input] if input else []
+ else:
+ return input
+
+
+
+[docs]
+class ContentElement:
+ """The parsed grammar element."""
+
+ def __init__(
+ self,
+ token: str,
+ grammar: dict,
+ content: str,
+ characters: dict[POS, str],
+ children: list[Capture | ContentElement] | None = None,
+ ) -> None:
+ """
+ Initialize a new instance of the Element class.
+
+ :param token: The token associated with the element.
+ :param grammar: The grammar associated with the element.
+ :param content: The content associated with the element.
+ :param characters: The characters associated with the element.
+ :param children: The children associated with the element. Defaults to None.
+ """
+ if children is None:
+ children = []
+ self.token = token
+ self.grammar = grammar
+ self.content = content
+ self.characters = characters
+ self._children_captures = children
+ self._dispatched: bool = False
+ self.parent: ContentElement | None = None
+
+ @property
+ def _subelements(self) -> list[ContentElement]:
+ return self.children
+
+ @property
+ def children(self) -> list[ContentElement]:
+ """
+ Returns a list of children elements.
+
+ If the elements have not been dispatched yet, this method will dispatch them before returning.
+
+ :return: A list of ContentElement objects representing the children elements.
+ """
+ if not self._dispatched:
+ self._dispatch()
+ return self._children
+
+ def _dispatch(self, nested: bool = False):
+ """
+ Dispatches the content element and its children.
+
+ :param nested: Indicates whether the dispatch is nested within another dispatch.
+ :type nested: bool
+ :return: None
+ """
+ if self._dispatched:
+ return
+ self._dispatched = True
+ self._children: list[ContentElement] = _dispatch_list(self._children_captures, parent=self)
+ self._children_captures = []
+ if nested:
+ for child in self._children:
+ child._dispatch(True)
+
+ def __eq__(self, other):
+ if not isinstance(other, ContentElement):
+ return False
+ return bool(self.grammar == other.grammar and self.characters == other.characters)
+
+ def _find(
+ self,
+ tokens: str | list[str],
+ start_tokens: str | list[str] = "",
+ hide_tokens: str | list[str] = "",
+ stop_tokens: str | list[str] = "",
+ depth: int = -1,
+ attribute: str = "_subelements",
+ stack: list[str] | None = None,
+ ) -> Generator[tuple[ContentElement, list[str]], None, None]:
+ tokens = _str_to_list(tokens)
+ start_tokens = _str_to_list(start_tokens)
+ hide_tokens = _str_to_list(hide_tokens)
+ stop_tokens = _str_to_list(stop_tokens)
+
+ if not set(tokens).isdisjoint(set(stop_tokens)):
+ raise ValueError("Input tokens and stop_tokens must be disjoint")
+
+ if stack is None:
+ stack = []
+ stack += [self.token]
+
+ start_found = not start_tokens
+
+ if depth:
+ depth -= 1
+ children: list[ContentElement] = getattr(self, attribute, self._subelements)
+ for child in children:
+ if stop_tokens and (
+ child.token in stop_tokens
+ or (stop_tokens == ["*"] and child.token not in tokens)
+ ):
+ return None
+
+ if not start_found and child.token in start_tokens:
+ start_found = True
+ start_tokens = []
+
+ if (
+ start_found
+ and (child.token in tokens or tokens == ["*"])
+ and child.token not in hide_tokens
+ ):
+ yield child, [e for e in stack]
+ if depth:
+ nested_generator = child._find(
+ tokens,
+ start_tokens=start_tokens,
+ hide_tokens=hide_tokens,
+ stop_tokens=stop_tokens,
+ depth=depth - 1,
+ stack=[e for e in stack],
+ )
+ yield from nested_generator
+ return None
+
+
+[docs]
+ def find(
+ self,
+ tokens: str | list[str],
+ start_tokens: str | list[str] = "",
+ hide_tokens: str | list[str] = "",
+ stop_tokens: str | list[str] = "",
+ depth: int = -1,
+ attribute: str = "_subelements",
+ ) -> Generator[tuple[ContentElement, list[str]], None, None]:
+ """
+ Find content elements based on the given criteria.
+
+ The find method will return a generator that globs though the element-tree, searching for the next
+ subelement that matches the given token.
+
+ :param tokens: The tokens to search for. Can be a single token or a list of tokens.
+ :param start_tokens: The tokens that mark the start of the search. Can be a single token or a list of tokens.
+ :param hide_tokens: The tokens to hide from the search results. Can be a single token or a list of tokens.
+ :param stop_tokens: The tokens that mark the end of the search. Can be a single token or a list of tokens.
+ :param depth: The maximum depth to search. Defaults to -1 (unlimited depth).
+ :param attribute: The attribute name to access the subelements. Defaults to "_subelements".
+
+ :yield: A tuple containing the found content element and the stack of tokens encountered.
+
+ :raises ValueError: If the input tokens and stop_tokens are not disjoint.
+
+ :return: None if no matching content elements are found.
+ """
+ return self._find(
+ tokens,
+ start_tokens=start_tokens,
+ hide_tokens=hide_tokens,
+ stop_tokens=stop_tokens,
+ depth=depth,
+ attribute=attribute,
+ )
+
+
+
+[docs]
+ def findall(
+ self,
+ tokens: str | list[str],
+ start_tokens: str | list[str] = "",
+ hide_tokens: str | list[str] = "",
+ stop_tokens: str | list[str] = "",
+ depth: int = -1,
+ attribute: str = "_subelements",
+ ) -> list[tuple[ContentElement, list[str]]]:
+ """
+ Find all occurrences of the specified tokens within the content element.
+
+ :param tokens: The tokens to search for.
+ :param start_tokens: The tokens that must appear before the found tokens. Defaults to "".
+ :param hide_tokens: The tokens that should be hidden from the search. Defaults to "".
+ :param stop_tokens: The tokens that, if found, should stop the search. Defaults to "".
+ :param depth: The maximum depth to search. Defaults to -1 (unlimited depth).
+ :param attribute: The attribute to search within. Defaults to "_subelements".
+
+ :return: A list of tuples containing the content element and the found tokens.
+ """
+ return list(
+ self._find(
+ tokens,
+ start_tokens=start_tokens,
+ hide_tokens=hide_tokens,
+ stop_tokens=stop_tokens,
+ depth=depth,
+ attribute=attribute,
+ )
+ )
+
+
+
+[docs]
+ def to_dict(self, depth: int = -1, all_content: bool = False, **kwargs) -> dict:
+ """
+ Converts the object to a dictionary.
+
+ :param depth: The depth of the conversion. Defaults to -1.
+ :param all_content: Whether to include all content or only the top-level content. Defaults to False.
+
+ :return: The converted dictionary representation of the object.
+ """
+ out_dict = {"token": self.token}
+ if all_content or not self.children:
+ out_dict["content"] = self.content
+ if self.children:
+ out_dict["children"] = (
+ self._list_property_to_dict("children", depth=depth - 1, all_content=all_content)
+ if depth
+ else self.children
+ )
+ return out_dict
+
+
+
+[docs]
+ def flatten(self) -> list[tuple[tuple[int, int], str, list[str]]]:
+ """
+ Converts the object to a flattened array of tokens per index, similarly to vscode-textmate.
+
+ :return: A list of tuples representing the flattened tokens. Each tuple contains:
+ - A tuple representing the starting and ending index of the token.
+ - The content of the token.
+ - A list of keys associated with the token.
+ """
+ token_dict = self._token_by_index(defaultdict(list))
+ tokens = []
+ for (_, key), group in groupby(sorted(token_dict.items()), lambda x: (x[0][0], x[1])):
+ group_tokens = list(group)
+ starting = group_tokens[0][0]
+ content = ""
+ for pos, _ in group_tokens:
+ content += self.characters[pos]
+ if content:
+ tokens.append((starting, content, key))
+ return tokens
+
+
+
+[docs]
+ def print(
+ self,
+ flatten: bool = False,
+ depth: int = -1,
+ all_content: bool = False,
+ **kwargs,
+ ) -> None:
+ """
+ Prints the current object recursively by converting it to a dictionary or a flattened array.
+
+ :param flatten: If True, flattens the object before printing. Defaults to False.
+ :param depth: The maximum depth to print. Defaults to -1 (unlimited depth).
+ :param all_content: If True, includes all content in the printout. Defaults to False.
+ :param **kwargs: Additional keyword arguments to be passed to the pprint function.
+
+ :return: None
+ """
+ if flatten:
+ pprint(
+ self.flatten(**kwargs),
+ sort_dicts=False,
+ width=kwargs.pop("width", 150),
+ **kwargs,
+ )
+ else:
+ pprint(
+ self.to_dict(depth=depth, all_content=all_content, **kwargs),
+ sort_dicts=False,
+ width=kwargs.pop("width", 150),
+ **kwargs,
+ )
+
+
+ def _token_by_index(self, token_dict: TOKEN_DICT | None = None) -> TOKEN_DICT:
+ """Recursively tokenize every index between start and close.
+
+ This method recursively tokenizes every index between the start and close positions of the element.
+ It populates a dictionary, `token_dict`, with the tokens corresponding to each index.
+
+ :param token_dict: A dictionary to store the tokens. If None, a new dictionary is created.
+ :type token_dict: dict | None
+ :return: A dictionary containing the tokens for each index.
+ :rtype: dict
+ """
+ if token_dict is None:
+ token_dict = defaultdict(list)
+ for pos in self.characters:
+ token_dict[pos].append(self.token)
+
+ # Tokenize child elements
+ for element in self.children:
+ element._token_by_index(token_dict)
+ return token_dict
+
+ def _list_property_to_dict(self, prop: str, **kwargs):
+ """Makes a dictionary from a property."""
+ return [
+ item.to_dict(**kwargs) if isinstance(item, ContentElement) else item
+ for item in getattr(self, prop, [])
+ ]
+
+ def __repr__(self) -> str:
+ content = self.content if len(self.content) < 15 else self.content[:15] + "..."
+ return repr(f"{self.token}<<{content}>>({len(self.children)})")
+
+
+
+
+[docs]
+class ContentBlockElement(ContentElement):
+ """A parsed element with a begin and a end"""
+
+ def __init__(
+ self,
+ *args,
+ begin: list[Capture | ContentElement] | None = None,
+ end: list[Capture | ContentElement] | None = None,
+ **kwargs,
+ ) -> None:
+ """
+ Initialize a new instance of the Element class.
+
+ :param begin: A list of Capture or ContentElement objects representing the beginning captures of the element. Defaults to None.
+ :param end: A list of Capture or ContentElement objects representing the ending captures of the element. Defaults to None.
+ :param **kwargs: Additional keyword arguments to be passed to the parent class constructor.
+
+ :return: None
+ """
+ if end is None:
+ end = []
+ if begin is None:
+ begin = []
+ super().__init__(*args, **kwargs)
+ self._begin_captures = begin
+ self._end_captures = end
+
+ @property
+ def _subelements(self) -> list[ContentElement]:
+ return self.begin + self.children + self.end
+
+ @property
+ def begin(self) -> list[ContentElement]:
+ """
+ Returns the list of begin elements.
+
+ If the elements have not been dispatched yet, this method will dispatch them before returning.
+
+ :return: The list of begin elements.
+ """
+ if not self._dispatched:
+ self._dispatch()
+ return self._begin
+
+ @property
+ def end(self) -> list[ContentElement]:
+ """
+ Returns the end elements.
+
+ If the elements have not been dispatched yet, this method will dispatch them before returning.
+
+ :return: A list of end elements.
+ """
+ if not self._dispatched:
+ self._dispatch()
+ return self._end
+
+ def _dispatch(self, nested: bool = False):
+ if self._dispatched:
+ return
+ super()._dispatch(nested)
+ self._begin: list[ContentElement] = _dispatch_list(self._begin_captures, parent=self)
+ self._end: list[ContentElement] = _dispatch_list(self._end_captures, parent=self)
+ self._begin_captures, self._end_captures = [], []
+ if nested:
+ for item in self._begin:
+ item._dispatch(True)
+ for item in self._end:
+ item._dispatch(True)
+
+
+[docs]
+ def to_dict(self, depth: int = -1, all_content: bool = False, **kwargs) -> dict:
+ """
+ Converts the element to a dictionary representation.
+
+ :param depth: The depth of the conversion. Defaults to -1.
+ :param all_content: Whether to include all content. Defaults to False.
+ :param **kwargs: Additional keyword arguments.
+
+ :return: The dictionary representation of the element.
+ """
+ out_dict = super().to_dict(depth=depth, all_content=all_content, **kwargs)
+ if self.begin:
+ out_dict["begin"] = (
+ self._list_property_to_dict("begin", depth=depth - 1, **kwargs)
+ if depth
+ else self.begin
+ )
+ if self.end:
+ out_dict["end"] = (
+ self._list_property_to_dict("end", depth=depth - 1, **kwargs) if depth else self.end
+ )
+
+ ordered_keys = [
+ key for key in ["token", "begin", "end", "content", "children"] if key in out_dict
+ ]
+ ordered_dict = {key: out_dict[key] for key in ordered_keys}
+ return ordered_dict
+
+
+ def _token_by_index(self, token_dict: TOKEN_DICT | None = None) -> TOKEN_DICT:
+ """Converts the object to a flattened array of tokens."""
+ if token_dict is None:
+ token_dict = defaultdict(list)
+ super()._token_by_index(token_dict)
+ for element in self.begin:
+ element._token_by_index(token_dict)
+ for element in self.end:
+ element._token_by_index(token_dict)
+ return token_dict
+
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .elements import Capture, ContentElement
+from .parser import GrammarParser, PatternsParser
+from .utils.cache import TextmateCache, init_cache
+from .utils.exceptions import IncompatibleFileType
+from .utils.handler import POS, ContentHandler
+from .utils.logger import LOGGER
+
+LANGUAGE_PARSERS = {}
+
+
+
+[docs]
+class DummyParser(GrammarParser):
+ """A dummy parser object"""
+
+ def __init__(self):
+ self.key = "DummyLanguage"
+ self.initialized = True
+
+ def _initialize_repository(self):
+ pass
+
+ def _parse(self, *args, **kwargs):
+ pass
+
+
+
+
+[docs]
+class LanguageParser(PatternsParser):
+ """The parser of a language grammar."""
+
+ def __init__(self, grammar: dict, **kwargs):
+ """
+ Initialize a Language object.
+
+ :param grammar: The grammar definition for the language.
+ :param kwargs: Additional keyword arguments.
+
+ :ivar name: The name of the language.
+ :ivar uuid: The UUID of the language.
+ :ivar file_types: The file types associated with the language.
+ :ivar token: The scope name of the language.
+ :ivar repository: The repository of grammar rules for the language.
+ :ivar injections: The list of injection rules for the language.
+ :ivar _cache: The cache object for the language.
+ """
+ super().__init__(grammar, key=grammar.get("name", "myLanguage"), language=self, **kwargs)
+
+ self.name = grammar.get("name", "")
+ self.uuid = grammar.get("uuid", "")
+ self.file_types = grammar.get("fileTypes", [])
+ self.token = grammar.get("scopeName", "myScope")
+ self.repository = {}
+ self.injections: list[dict] = []
+ self._cache: TextmateCache = init_cache()
+
+ # Initialize grammars in repository
+ for repo in _gen_repositories(grammar):
+ for key, parser_grammar in repo.items():
+ self.repository[key] = GrammarParser.initialize(
+ parser_grammar, key=key, language=self
+ )
+
+ # Update language parser store
+ language_name = grammar.get("scopeName", "myLanguage")
+ LANGUAGE_PARSERS[language_name] = self
+
+ self._initialize_repository()
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}:{self.key}"
+
+ @staticmethod
+ def _find_include_scopes(key: str):
+ return LANGUAGE_PARSERS.get(key, DummyParser())
+
+ def _initialize_repository(self):
+ """When the grammar has patterns, this method should called to initialize its inclusions."""
+
+ # Initialize injections
+ injections = self.grammar.get("injections", {})
+ for key, injected_grammar in injections.items():
+ target_string = key[: key.index("-")].strip()
+ if not target_string:
+ target_string = self.grammar.get("scopeName", "myLanguage")
+ target_language = LANGUAGE_PARSERS[target_string]
+
+ injected_parser = GrammarParser.initialize(
+ injected_grammar,
+ key=f"{target_string}.injection",
+ language=target_language,
+ )
+ injected_parser._initialize_repository()
+
+ scope_string = key[key.index("-") :]
+ exception_scopes = [s.strip() for s in scope_string.split("-") if s.strip()]
+ target_language.injections.append([exception_scopes, injected_parser])
+
+ super()._initialize_repository()
+
+
+[docs]
+ def parse_file(self, filePath: str | Path, **kwargs) -> ContentElement | None:
+ """
+ Parses an entire file with the current grammar.
+
+ :param filePath: The path to the file to be parsed.
+ :param kwargs: Additional keyword arguments to be passed to the parser.
+ :return: The parsed element if successful, None otherwise.
+ """
+ if not isinstance(filePath, Path):
+ filePath = Path(filePath).resolve()
+
+ if filePath.suffix.split(".")[-1] not in self.file_types:
+ raise IncompatibleFileType(extensions=self.file_types)
+
+ if self._cache.cache_valid(filePath):
+ element = self._cache.load(filePath)
+ else:
+ handler = ContentHandler.from_path(filePath)
+ if handler.source == "":
+ return None
+
+ # Configure logger
+ LOGGER.configure(self, height=len(handler.lines), width=max(handler.line_lengths))
+ element = self._parse_language(handler, **kwargs) # type: ignore
+
+ if element is not None:
+ self._cache.save(filePath, element)
+ return element
+
+
+
+[docs]
+ def parse_string(self, input: str, **kwargs) -> ContentElement | None:
+ """
+ Parses an input string.
+
+ :param input: The input string to be parsed.
+ :param kwargs: Additional keyword arguments.
+ :return: The result of parsing the input string.
+ """
+ handler = ContentHandler(input)
+ # Configure logger
+ LOGGER.configure(self, height=len(handler.lines), width=max(handler.line_lengths))
+
+ element = self._parse_language(handler, **kwargs)
+
+ return element
+
+
+ def _parse_language(self, handler: ContentHandler, **kwargs) -> ContentElement | None:
+ """Parses the current stream with the language scope."""
+
+ parsed, elements, _ = self.parse(handler, (0, 0), **kwargs)
+
+ if parsed:
+ element = elements[0]
+ element._dispatch(nested=True) # type: ignore
+ else:
+ element = None
+ return element # type: ignore
+
+ def _parse(
+ self, handler: ContentHandler, starting: POS, **kwargs
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[int, int]]:
+ kwargs.pop("find_one", None)
+ return super()._parse(handler, starting, find_one=False, **kwargs)
+
+
+
+def _gen_repositories(grammar, key="repository"):
+ """Recursively gets all repositories from a grammar dictionary"""
+ if hasattr(grammar, "items"):
+ for k, v in grammar.items():
+ if k == key:
+ yield v
+ if isinstance(v, dict):
+ for result in _gen_repositories(v, key):
+ yield result
+ elif isinstance(v, list):
+ for d in v:
+ for result in _gen_repositories(d, key):
+ yield result
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+import onigurumacffi as re
+
+from .elements import Capture, ContentBlockElement, ContentElement
+from .utils.exceptions import IncludedParserNotFound
+from .utils.handler import POS, ContentHandler, Pattern
+from .utils.logger import LOGGER, track_depth
+
+if TYPE_CHECKING:
+ from .language import LanguageParser
+
+
+
+[docs]
+class GrammarParser(ABC):
+ """The abstract grammar parser object"""
+
+
+[docs]
+ @staticmethod
+ def initialize(grammar: dict, **kwargs):
+ """
+ Initializes the parser based on the grammar.
+
+ :param grammar: The grammar to initialize the parser with.
+ :param kwargs: Additional keyword arguments.
+ :return: The initialized parser.
+ """
+ if "include" in grammar:
+ return grammar["include"]
+ elif "match" in grammar:
+ return MatchParser(grammar, **kwargs)
+ elif "begin" in grammar and "end" in grammar:
+ return BeginEndParser(grammar, **kwargs)
+ elif "begin" in grammar and "while" in grammar:
+ return BeginWhileParser(grammar, **kwargs)
+ elif "patterns" in grammar:
+ return PatternsParser(grammar, **kwargs)
+ else:
+ return TokenParser(grammar, **kwargs)
+
+
+ def __init__(
+ self,
+ grammar: dict,
+ language: LanguageParser | None = None,
+ key: str = "",
+ is_capture: bool = False,
+ **kwargs,
+ ) -> None:
+ """
+ Initialize a Parser object.
+
+ :param grammar: The grammar dictionary.
+ :param language: The language parser object. Defaults to None.
+ :param key: The key for the parser. Defaults to "".
+ :param is_capture: Indicates if the parser is a capture. Defaults to False.
+ :param kwargs: Additional keyword arguments.
+
+ :return: None
+ """
+ self.grammar = grammar
+ self.language = language
+ self.key = key
+ self.token = grammar.get("name", "")
+ self.is_capture = is_capture
+ self.initialized = False
+ self.anchored = False
+
+ @property
+ def comment(self) -> str:
+ return self.grammar.get("comment", "")
+
+ @property
+ def disabled(self) -> bool:
+ return self.grammar.get("disabled", False)
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}:<{self.key}>"
+
+ def _init_captures(self, grammar: dict, key: str = "captures", **kwargs) -> dict:
+ """Initializes a captures dictionary"""
+ captures = {}
+ if key in grammar:
+ for group_id, pattern in grammar[key].items():
+ captures[int(group_id)] = self.initialize(
+ pattern, language=self.language, is_capture=True
+ )
+ return captures
+
+ def _find_include(self, key: str, **kwargs) -> GrammarParser:
+ """Find the included grammars and during repository initialization"""
+ if not self.language:
+ raise IncludedParserNotFound(key)
+
+ if key in ["$self", "$base"]: # TODO there is a difference between these
+ return self.language
+ elif key[0] == "#":
+ return self.language.repository.get(key[1:], None)
+ else:
+ return self.language._find_include_scopes(key)
+
+ @abstractmethod
+ def _parse(
+ self,
+ handler: ContentHandler,
+ starting: POS,
+ **kwargs,
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[int, int] | None]:
+ """The abstract method which all parsers much implement
+
+ The ``_parse`` method is called by ``parse``, which will additionally parse any nested Capture elements.
+ The ``_parse`` method should contain all the rules for the extended parser.
+
+ :param handler: The content handler to handle the parsed elements.
+ :param starting: The starting position of the parsing.
+ :param kwargs: Additional keyword arguments.
+ :return: A tuple containing the parsing result, a list of parsed elements, and the ending position of the parsing.
+ """
+ pass
+
+ def _initialize_repository(self, **kwargs) -> None:
+ """Initializes the repository's inclusions.
+
+ When the grammar has patterns, this method should called to initialize its inclusions.
+ This should occur after all sub patterns have been initialized.
+ """
+ return
+
+
+[docs]
+ def parse(
+ self,
+ handler: ContentHandler,
+ starting: POS = (0, 0),
+ boundary: POS | None = None,
+ **kwargs,
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[int, int] | None]:
+ """
+ The method to parse a handler using the current grammar.
+
+ :param handler: The ContentHandler object that will handle the parsed content.
+ :param starting: The starting position for parsing. Defaults to (0, 0).
+ :param boundary: The boundary position for parsing. Defaults to None.
+ :param **kwargs: Additional keyword arguments that can be passed to the parser.
+
+ :return: A tuple containing:
+ - parsed: A boolean indicating whether the parsing was successful.
+ - elements: A list of Capture or ContentElement objects representing the parsed content.
+ - span: A tuple containing the starting and ending positions of the parsed content, or None if parsing failed.
+ """
+ if not self.initialized and self.language is not None:
+ self.language._initialize_repository()
+ parsed, elements, span = self._parse(handler, starting, boundary=boundary, **kwargs)
+ return parsed, elements, span
+
+
+
+[docs]
+ def match_and_capture(
+ self,
+ handler: ContentHandler,
+ pattern: Pattern,
+ starting: POS,
+ boundary: POS,
+ parsers: dict[int, GrammarParser] | None = None,
+ parent_capture: Capture | None = None,
+ **kwargs,
+ ) -> tuple[tuple[POS, POS] | None, str, list[Capture | ContentElement]]:
+ """Matches a pattern and its capture groups.
+
+ Matches the pattern on the handler between the starting and boundary positions. If a pattern is matched,
+ its capture groups are initialized as Capture objects. These are only parsed after the full handler has been
+ parsed. This occurs in GrammarParser.parse when calling parse_captures.
+
+ :param handler: The content handler to match the pattern on.
+ :param pattern: The pattern to match.
+ :param starting: The starting position for the match.
+ :param boundary: The boundary position for the match.
+ :param parsers: A dictionary of parsers.
+ :param parent_capture: The parent capture object.
+ :param kwargs: Additional keyword arguments.
+ :return: A tuple containing the span of the match, the matched string, and a list of capture objects or content elements.
+ """
+ if parsers is None:
+ parsers = {}
+ matching, span = handler.search(pattern, starting=starting, boundary=boundary, **kwargs)
+
+ if matching:
+ if parsers:
+ capture = Capture(
+ handler,
+ pattern,
+ matching,
+ parsers,
+ starting,
+ boundary,
+ key=self.key,
+ **kwargs,
+ )
+ if parent_capture is not None and capture == parent_capture:
+ return None, "", []
+ else:
+ return span, matching.group(), [capture]
+ else:
+ return span, matching.group(), []
+ else:
+ return None, "", []
+
+
+
+
+
+[docs]
+class TokenParser(GrammarParser):
+ """The parser for grammars for which only the token is provided."""
+
+ def __init__(self, grammar: dict, **kwargs) -> None:
+ super().__init__(grammar, **kwargs)
+ self.initialized = True
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}:{self.token}"
+
+ @track_depth
+ def _parse(
+ self,
+ handler: ContentHandler,
+ starting: POS,
+ boundary: POS,
+ **kwargs,
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[POS, POS] | None]:
+ """The parse method for grammars for which only the token is provided.
+
+ When no regex patterns are provided. The element is created between the initial and boundary positions.
+ """
+ content = handler.read_pos(starting, boundary)
+ elements: list[Capture | ContentElement] = [
+ ContentElement(
+ token=self.token,
+ grammar=self.grammar,
+ content=content,
+ characters=handler.chars(starting, boundary),
+ )
+ ]
+ handler.anchor = boundary[1]
+ LOGGER.info(
+ f"{self.__class__.__name__} found < {repr(content)} >",
+ self,
+ starting,
+ kwargs.get("depth", 0),
+ )
+ return True, elements, (starting, boundary)
+
+
+
+
+[docs]
+class MatchParser(GrammarParser):
+ """The parser for grammars for which a match pattern is provided."""
+
+ def __init__(self, grammar: dict, **kwargs) -> None:
+ super().__init__(grammar, **kwargs)
+ self.exp_match = re.compile(grammar["match"])
+ self.parsers = self._init_captures(grammar, key="captures")
+ if "\\G" in grammar["match"]:
+ self.anchored = True
+
+ def __repr__(self) -> str:
+ if self.token:
+ return f"{self.__class__.__name__}:{self.token}"
+ else:
+ identifier = self.key if self.key else "_".join(self.comment.lower().split(" "))
+ return f"{self.__class__.__name__}:<{identifier}>"
+
+ def _initialize_repository(self, **kwargs) -> None:
+ """When the grammar has patterns, this method should called to initialize its inclusions."""
+ self.initialized = True
+ for key, value in self.parsers.items():
+ if not isinstance(value, GrammarParser):
+ self.parsers[key] = self._find_include(value)
+ for parser in self.parsers.values():
+ if not parser.initialized:
+ parser._initialize_repository()
+
+ @track_depth
+ def _parse(
+ self,
+ handler: ContentHandler,
+ starting: POS,
+ boundary: POS,
+ **kwargs,
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[POS, POS] | None]:
+ """The parse method for grammars for which a match pattern is provided."""
+
+ span, content, captures = self.match_and_capture(
+ handler,
+ pattern=self.exp_match,
+ starting=starting,
+ boundary=boundary,
+ parsers=self.parsers,
+ **kwargs,
+ )
+
+ if span is None:
+ LOGGER.debug(
+ f"{self.__class__.__name__} no match",
+ self,
+ starting,
+ kwargs.get("depth", 0),
+ )
+ return False, [], None
+
+ LOGGER.info(
+ f"{self.__class__.__name__} found < {repr(content)} >",
+ self,
+ starting,
+ kwargs.get("depth", 0),
+ )
+
+ if self.token:
+ elements: list[Capture | ContentElement] = [
+ ContentElement(
+ token=self.token,
+ grammar=self.grammar,
+ content=content,
+ characters=handler.chars(*span),
+ children=captures,
+ )
+ ]
+ else:
+ elements = captures
+
+ return True, elements, span
+
+
+
+
+[docs]
+class ParserHasPatterns(GrammarParser, ABC):
+ def __init__(self, grammar: dict, **kwargs) -> None:
+ super().__init__(grammar, **kwargs)
+ self.patterns = [
+ self.initialize(pattern, language=self.language)
+ for pattern in grammar.get("patterns", [])
+ ]
+
+ def _initialize_repository(self):
+ """When the grammar has patterns, this method should called to initialize its inclusions."""
+ self.initialized = True
+ self.patterns = [
+ parser if isinstance(parser, GrammarParser) else self._find_include(parser)
+ for parser in self.patterns
+ ]
+ for parser in self.patterns:
+ if not parser.initialized:
+ parser._initialize_repository()
+
+ # Copy patterns from included pattern parsers
+ pattern_parsers = [parser for parser in self.patterns if isinstance(parser, PatternsParser)]
+ for parser in pattern_parsers:
+ parser_index = self.patterns.index(parser)
+ self.patterns[parser_index : parser_index + 1] = parser.patterns
+
+ # Injection grammars
+ for exception_scopes, injection_pattern in self.language.injections:
+ if self.token:
+ if self.token.split(".")[0] not in exception_scopes:
+ self.patterns.append(injection_pattern)
+ elif self.is_capture:
+ self.patterns.append(injection_pattern)
+
+
+
+
+[docs]
+class PatternsParser(ParserHasPatterns):
+ """The parser for grammars for which several patterns are provided."""
+
+ @track_depth
+ def _parse(
+ self,
+ handler: ContentHandler,
+ starting: POS,
+ boundary: POS | None = None,
+ greedy: bool = False,
+ find_one: bool = True,
+ **kwargs,
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[POS, POS]]:
+ """The parse method for grammars for which a match pattern is provided."""
+
+ if boundary is None:
+ boundary = (len(handler.lines) - 1, handler.line_lengths[-1])
+
+ parsed = False
+ elements: list[Capture | ContentElement] = []
+ patterns = [parser for parser in self.patterns if not parser.disabled]
+
+ current = (starting[0], starting[1])
+
+ while current < boundary:
+ for parser in patterns:
+ # Try to find patterns
+ parsed, captures, span = parser._parse(
+ handler,
+ current,
+ boundary=boundary,
+ greedy=greedy,
+ **kwargs,
+ )
+ if parsed:
+ if find_one:
+ LOGGER.info(
+ f"{self.__class__.__name__} found single element",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ return True, captures, span
+ elements.extend(captures)
+ current = span[1]
+ break
+ else:
+ if find_one:
+ break
+
+ if not parsed and not greedy:
+ # Try again if previously allowed no leading white space charaters, only when multple patterns are to be found
+ options_span, options_elements = {}, {}
+ for parser in patterns:
+ parsed, captures, span = parser._parse(
+ handler,
+ current,
+ boundary=boundary,
+ greedy=True,
+ **kwargs,
+ )
+ if parsed:
+ options_span[parser] = span
+ options_elements[parser] = captures
+ LOGGER.debug(
+ f"{self.__class__.__name__} found pattern choice",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+
+ if options_span:
+ parser = sorted(
+ options_span,
+ key=lambda parser: (
+ *options_span[parser][0],
+ patterns.index(parser),
+ ),
+ )[0]
+ current = options_span[parser][1]
+ elements.extend(options_elements[parser])
+ LOGGER.info(
+ f"{self.__class__.__name__} chosen pattern of {parser}",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ elif self != self.language:
+ break
+ else:
+ remainder = handler.read_line(current)
+ if not remainder.isspace():
+ LOGGER.warning(
+ f"{self.__class__.__name__} remainder of line not parsed: {remainder}",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ if current[0] + 1 <= len(handler.lines):
+ current = (current[0] + 1, 0)
+ else:
+ LOGGER.debug(
+ f"{self.__class__.__name__} EOF encountered",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ break
+
+ if current == starting:
+ LOGGER.warning(
+ f"{self.__class__.__name__} handler did not move after a search round",
+ self,
+ starting,
+ kwargs.get("depth", 0),
+ )
+ break
+
+ line_length = handler.line_lengths[current[0]]
+ if current[1] in [line_length, line_length - 1]:
+ try:
+ empty_lines = next(
+ i for i, v in enumerate(handler.line_lengths[current[0] + 1 :]) if v > 1
+ )
+ current = (current[0] + 1 + empty_lines, 0)
+ except StopIteration:
+ break
+
+ if self.token:
+ elements = [
+ ContentElement(
+ token=self.token,
+ grammar=self.grammar,
+ content=handler.read_pos(starting, boundary),
+ characters=handler.chars(starting, boundary),
+ children=elements,
+ )
+ ]
+
+ return bool(elements), elements, (starting, current)
+
+
+
+
+[docs]
+class BeginEndParser(ParserHasPatterns):
+ """The parser for grammars for which a begin/end pattern is provided."""
+
+ def __init__(self, grammar: dict, **kwargs) -> None:
+ super().__init__(grammar, **kwargs)
+ if "contentName" in grammar:
+ self.token = grammar["contentName"]
+ self.between_content = True
+ else:
+ self.token = grammar.get("name")
+ self.between_content = False
+ self.apply_end_pattern_last = grammar.get("applyEndPatternLast", False)
+ self.exp_begin = re.compile(grammar["begin"])
+ self.exp_end = re.compile(grammar["end"])
+ self.parsers_begin = self._init_captures(grammar, key="beginCaptures")
+ self.parsers_end = self._init_captures(grammar, key="endCaptures")
+ if "\\G" in grammar["begin"]:
+ self.anchored = True
+
+ def __repr__(self) -> str:
+ if self.token:
+ return f"{self.__class__.__name__}:{self.token}"
+ else:
+ identifier = self.key if self.key else "_".join(self.comment.lower().split(" "))
+ return f"{self.__class__.__name__}:<{identifier}>"
+
+ def _initialize_repository(self, **kwargs) -> None:
+ """When the grammar has patterns, this method should called to initialize its inclusions."""
+ self.initialized = True
+ super()._initialize_repository()
+ for key, value in self.parsers_end.items():
+ if not isinstance(value, GrammarParser):
+ self.parsers_end[key] = self._find_include(value)
+ for key, value in self.parsers_begin.items():
+ if not isinstance(value, GrammarParser):
+ self.parsers_begin[key] = self._find_include(value)
+ for parser in self.parsers_begin.values():
+ if not parser.initialized:
+ parser._initialize_repository()
+ for parser in self.parsers_end.values():
+ if not parser.initialized:
+ parser._initialize_repository()
+
+ @track_depth
+ def _parse(
+ self,
+ handler: ContentHandler,
+ starting: POS,
+ boundary: POS,
+ greedy: bool = False,
+ **kwargs,
+ ) -> tuple[bool, list[Capture | ContentElement], tuple[POS, POS] | None]:
+ """The parse method for grammars for which a begin/end pattern is provided."""
+
+ begin_span, _, begin_elements = self.match_and_capture(
+ handler,
+ self.exp_begin,
+ starting,
+ boundary=boundary,
+ parsers=self.parsers_begin,
+ greedy=greedy,
+ **kwargs,
+ )
+
+ if not begin_span:
+ LOGGER.debug(
+ f"{self.__class__.__name__} no begin match",
+ self,
+ starting,
+ kwargs.get("depth", 0),
+ )
+ return False, [], None
+ LOGGER.info(
+ f"{self.__class__.__name__} found begin",
+ self,
+ starting,
+ kwargs.get("depth", 0),
+ )
+
+ # Get initial and boundary positions
+ current = begin_span[1]
+ if boundary is None:
+ boundary = (len(handler.lines) - 1, handler.line_lengths[-1])
+
+ # Define loop parameters
+ end_elements: list[Capture | ContentElement] = []
+ mid_elements: list[Capture | ContentElement] = []
+ patterns = [parser for parser in self.patterns if not parser.disabled]
+ first_run = True
+
+ while current <= boundary:
+ parsed = False
+
+ # Create boolean that is enabled when a parser is recursively called. In this its end pattern should
+ # be applied last, otherwise the same span will be recognzed as the end pattern by the upper level parser
+ apply_end_pattern_last = False
+
+ # Try to find patterns first with no leading whitespace charaters allowed
+ for parser in patterns:
+ parsed, capture_elements, capture_span = parser._parse(
+ handler, current, boundary=boundary, greedy=False, **kwargs
+ )
+ if parsed:
+ if parser == self:
+ apply_end_pattern_last = True
+ LOGGER.debug(
+ f"{self.__class__.__name__} found pattern (no ws)",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ break
+
+ # Try to find the end pattern with no leading whitespace charaters allowed
+ end_span, _, end_elements = self.match_and_capture(
+ handler,
+ self.exp_end,
+ current,
+ boundary=boundary,
+ parsers=self.parsers_end,
+ greedy=False,
+ **kwargs,
+ )
+
+ if not parsed and not end_span:
+ # Try to find the patterns and end pattern allowing for leading whitespace charaters
+
+ LOGGER.info(
+ f"{self.__class__.__name__} getting all pattern options",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+
+ options_span, options_elements = {}, {}
+ for parser in patterns:
+ parsed, capture_elements, capture_span = parser._parse(
+ handler,
+ current,
+ boundary=boundary,
+ greedy=True,
+ **kwargs,
+ )
+ if parsed:
+ options_span[parser] = capture_span
+ options_elements[parser] = capture_elements
+ LOGGER.debug(
+ f"{self.__class__.__name__} found pattern choice",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+
+ if options_span:
+ parsed = True
+ parser = sorted(
+ options_span,
+ key=lambda parser: (
+ *options_span[parser][0],
+ patterns.index(parser),
+ ),
+ )[0]
+ capture_span = options_span[parser]
+ capture_elements = options_elements[parser]
+
+ if parser == self:
+ apply_end_pattern_last = True
+
+ LOGGER.info(
+ f"{self.__class__.__name__} chosen pattern of {parser}",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+
+ end_span, end_content, end_elements = self.match_and_capture(
+ handler,
+ self.exp_end,
+ current,
+ boundary=boundary,
+ parsers=self.parsers_end,
+ greedy=True,
+ **kwargs,
+ )
+
+ if end_span:
+ if parsed:
+ # Check whether the capture pattern has the same closing positions as the end pattern
+ capture_before_end = handler.prev(capture_span[1])
+ if handler.read(capture_before_end, skip_newline=False) == "\n":
+ # If capture pattern ends with \n, both left and right of \n is considered end
+ pattern_at_end = end_span[1] in [
+ capture_before_end,
+ capture_span[1],
+ ]
+ else:
+ pattern_at_end = end_span[1] == capture_span[1]
+
+ end_before_pattern = end_span[0] <= capture_span[0]
+ empty_span_end = end_span[1] == end_span[0]
+
+ if pattern_at_end and (end_before_pattern or empty_span_end):
+ if empty_span_end:
+ # Both found capture pattern and end pattern are accepted, break pattern search
+ LOGGER.debug(
+ f"{self.__class__.__name__} capture+end: both accepted, break",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ mid_elements.extend(capture_elements)
+ closing = end_span[0] if self.between_content else end_span[1]
+ break
+ elif not self.apply_end_pattern_last and not apply_end_pattern_last:
+ # End pattern prioritized over capture pattern, break pattern search
+ LOGGER.debug(
+ f"{self.__class__.__name__} capture+end: end prioritized, break",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ closing = end_span[0] if self.between_content else end_span[1]
+ break
+ else:
+ # Capture pattern prioritized over end pattern, continue pattern search
+ LOGGER.debug(
+ f"{self.__class__.__name__} capture+end: capture prioritized, continue",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ mid_elements.extend(capture_elements)
+ current = capture_span[1]
+
+ elif capture_span[0] < end_span[0]:
+ # Capture pattern found before end pattern, continue pattern search
+ LOGGER.debug(
+ f"{self.__class__.__name__} capture<end: leading capture, continue",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ mid_elements.extend(capture_elements)
+ current = capture_span[1]
+ else:
+ # End pattern found before capture pattern, break pattern search
+ LOGGER.debug(
+ f"{self.__class__.__name__} end<capture: leading end, break",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ closing = end_span[0] if self.between_content else end_span[1]
+ break
+ else:
+ # No capture pattern found, accept end pattern and break pattern search
+ LOGGER.debug(
+ f"{self.__class__.__name__} end: break",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ closing = end_span[0] if self.between_content else end_span[1]
+ break
+ else: # No end pattern found
+ if parsed:
+ # Append found capture pattern and find next starting position
+ mid_elements.extend(capture_elements)
+
+ if handler.read(capture_span[1], skip_newline=False) == "\n":
+ # Next character after capture pattern is newline
+
+ LOGGER.debug(
+ f"{self.__class__.__name__} capture: next is newline, continue",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+
+ end_span, _, _ = self.match_and_capture(
+ handler,
+ self.exp_end,
+ capture_span[1],
+ boundary=boundary,
+ parsers=self.parsers_end,
+ allow_leading_all=False,
+ **kwargs,
+ )
+
+ if end_span and end_span[1] <= handler.next(capture_span[1]):
+ # Potential end pattern can be found directly after the found capture pattern
+ current = capture_span[1]
+ else:
+ # Skip the newline character in the next pattern search round
+ current = handler.next(capture_span[1])
+ else:
+ LOGGER.debug(
+ f"{self.__class__.__name__} capture: continue",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ current = capture_span[1]
+ else:
+ # No capture patterns nor end patterns found. Skip the current line.
+ line = handler.read_line(current)
+
+ if line and not line.isspace():
+ LOGGER.warning(
+ f"No patterns found in line, skipping < {repr(line)} >",
+ self,
+ current,
+ kwargs.get("depth", 0),
+ )
+ current = handler.next((current[0], handler.line_lengths[current[0]]))
+
+ if apply_end_pattern_last:
+ current = handler.next(current)
+
+ if first_run:
+ # Skip all parsers that were anchored to the begin pattern after the first round
+ patterns = [parser for parser in patterns if not parser.anchored]
+ first_run = False
+ else:
+ # Did not break out of while loop, set closing to boundary
+ closing = boundary
+ end_span = ((0, 0), boundary)
+
+ start = begin_span[1] if self.between_content else begin_span[0]
+
+ content = handler.read_pos(start, closing)
+ LOGGER.info(
+ f"{self.__class__.__name__} found < {repr(content)} >",
+ self,
+ start,
+ kwargs.get("depth", 0),
+ )
+
+ # Construct output elements
+ if self.token:
+ elements: list[Capture | ContentElement] = [
+ ContentBlockElement(
+ token=self.token,
+ grammar=self.grammar,
+ content=content,
+ characters=handler.chars(start, closing),
+ children=mid_elements,
+ begin=begin_elements,
+ end=end_elements,
+ )
+ ]
+ else:
+ elements = begin_elements + mid_elements + end_elements
+
+ return True, elements, (begin_span[0], end_span[1])
+
+
+
+
+[docs]
+class BeginWhileParser(PatternsParser):
+ """The parser for grammars for which a begin/end pattern is provided."""
+
+ def __init__(self, grammar: dict, **kwargs) -> None:
+ super().__init__(grammar, **kwargs)
+ if "contentName" in grammar:
+ self.token = grammar["contentName"]
+ self.between_content = True
+ else:
+ self.token = grammar.get("name")
+ self.between_content = False
+ self.exp_begin = re.compile(grammar["begin"])
+ self.exp_while = re.compile(grammar["while"])
+ self.parsers_begin = self._init_captures(grammar, key="beginCaptures")
+ self.parsers_while = self._init_captures(grammar, key="whileCaptures")
+
+ def __repr__(self) -> str:
+ if self.token:
+ return f"{self.__class__.__name__}:{self.token}"
+ else:
+ identifier = self.key if self.key else "_".join(self.comment.lower().split(" "))
+ return f"{self.__class__.__name__}:<{identifier}>"
+
+ def _initialize_repository(self):
+ """When the grammar has patterns, this method should called to initialize its inclusions."""
+ self.initialized = True
+ super()._initialize_repository()
+ for key, value in self.parsers_end.items():
+ if not isinstance(value, GrammarParser):
+ self.parsers_end[key] = self._find_include(value)
+ for key, value in self.parsers_while.items():
+ if not isinstance(value, GrammarParser):
+ self.parsers_while[key] = self._find_include(value)
+ for parser in self.parsers_begin.values():
+ if not parser.initialized:
+ parser._initialize_repository()
+ for parser in self.parsers_while.values():
+ if not parser.initialized:
+ parser._initialize_repository()
+
+ def _parse(
+ self,
+ handler: ContentHandler,
+ starting: POS,
+ **kwargs,
+ ):
+ """The parse method for grammars for which a begin/while pattern is provided."""
+ raise NotImplementedError
+
+
+from __future__ import annotations
+
+import atexit
+from pathlib import Path
+from pickle import UnpicklingError
+from typing import Protocol
+
+from ..elements import ContentElement
+
+CACHE_DIR = (Path() / ".textmate_cache").resolve()
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _path_to_key(path: Path) -> str:
+ return str(path.resolve())
+
+
+
+[docs]
+class TextmateCache(Protocol):
+ """Interface for a Textmate cache."""
+
+
+[docs]
+ def cache_valid(self, filepath: Path) -> bool:
+ """
+ Check if the cache for the given filepath is valid.
+
+ :param filepath: The path to the file.
+ :return: True if the cache is valid, False otherwise.
+ """
+ ...
+
+
+
+[docs]
+ def load(self, filepath: Path) -> ContentElement:
+ """
+ Load the content from the specified filepath.
+
+ :param filepath: The path to the file to load.
+ :return: The loaded content element.
+ """
+ ...
+
+
+
+[docs]
+ def save(self, filePath: Path, element: ContentElement) -> None:
+ """
+ Save the given content element to the specified file path.
+
+ :param filePath: The file path where the content element should be saved.
+ :param element: The content element to be saved.
+ :return: None
+ """
+ ...
+
+
+
+
+
+[docs]
+class SimpleCache(TextmateCache):
+ """A simple cache implementation for storing content elements."""
+
+ def __init__(self) -> None:
+ """Initialize the SimpleCache."""
+ self._element_cache: dict[str, ContentElement] = dict()
+ self._element_timestamp: dict[str, float] = dict()
+
+
+[docs]
+ def cache_valid(self, filepath: Path) -> bool:
+ """Check if the cache is valid for the given filepath.
+
+ :param filepath: The filepath to check.
+ :return: True if the cache is valid, False otherwise.
+ """
+ key = _path_to_key(filepath)
+ if key not in self._element_cache:
+ return False
+ timestamp = filepath.resolve().stat().st_mtime
+ return timestamp == self._element_timestamp[key]
+
+
+
+[docs]
+ def load(self, filepath: Path) -> ContentElement:
+ """Load the content element from the cache for the given filepath.
+
+ :param filepath: The filepath to load the content element from.
+ :return: The loaded content element.
+ """
+ key = _path_to_key(filepath)
+ return self._element_cache[key]
+
+
+
+[docs]
+ def save(self, filepath: Path, element: ContentElement) -> None:
+ """Save the content element to the cache for the given filepath.
+
+ :param filepath: The filepath to save the content element to.
+ :param element: The content element to save.
+ :return: None
+ """
+ key = _path_to_key(filepath)
+ self._element_cache[key] = element
+ self._element_timestamp[key] = filepath.resolve().stat().st_mtime
+
+
+
+
+
+[docs]
+class ShelveCache(TextmateCache):
+ """A cache implementation using the shelve module."""
+
+ def __init__(self) -> None:
+ """Initialize the ShelveCache."""
+ import shelve
+
+ database_path = CACHE_DIR / "textmate.db"
+ self._database = shelve.open(str(database_path))
+
+ def exit():
+ self._database.sync()
+ self._database.close()
+
+ atexit.register(exit)
+
+
+[docs]
+ def cache_valid(self, filepath: Path) -> bool:
+ """Check if the cache is valid for the given filepath.
+
+ :param filepath: The filepath to check.
+ :return: True if the cache is valid, False otherwise.
+ """
+ key = _path_to_key(filepath)
+ if key not in self._database:
+ return False
+ timestamp = filepath.resolve().stat().st_mtime
+ try:
+ valid = timestamp == self._database[key][0]
+ except UnpicklingError:
+ valid = False
+ else:
+ valid = False
+ return valid
+
+
+
+[docs]
+ def load(self, filepath: Path) -> ContentElement:
+ """Load the content element from the cache for the given filepath.
+
+ :param filepath: The path for the cached content element.
+ :return: The loaded content element.
+ """
+ key = _path_to_key(filepath)
+ return self._database[key][1]
+
+
+
+[docs]
+ def save(self, filepath: Path, element: ContentElement) -> None:
+ """Save the content element to the cache for the given filepath.
+
+ :param filepath: The filepath to save the content element to.
+ :param element: The content element to save.
+ """
+ element._dispatch(nested=True)
+ key = _path_to_key(filepath)
+ timestamp = filepath.resolve().stat().st_mtime
+ self._database[key] = (timestamp, element)
+
+
+
+
+CACHE: TextmateCache = SimpleCache()
+
+
+
+[docs]
+def init_cache(type: str = "simple") -> TextmateCache:
+ """
+ Initialize the cache based on the given type.
+
+ :param type: The type of cache to initialize. Defaults to "simple".
+ :return: The initialized cache object.
+ """
+ global CACHE
+ if type == "shelve":
+ CACHE = ShelveCache()
+ elif type == "simple":
+ CACHE = SimpleCache()
+ else:
+ raise NotImplementedError(f"Cache type {type} not implemented.")
+ return CACHE
+
+
+from __future__ import annotations
+
+
+
+[docs]
+class IncludedParserNotFound(Exception):
+ """Exception raised when an included parser is not found in the store."""
+
+ def __init__(self, key: str = "UNKNOWN", **kwargs) -> None:
+ """
+ Initialize the exception.
+
+ :param key: The key of the included parser.
+ :param kwargs: Additional keyword arguments.
+ """
+ message = f"Included parser <{key}> not found in store."
+ super().__init__(message, **kwargs)
+
+
+
+
+[docs]
+class IncompatibleFileType(Exception):
+ """Exception raised when the input file has an incompatible file type."""
+
+ def __init__(self, extensions: list[str], **kwargs) -> None:
+ """
+ Initialize the exception.
+
+ :param extensions: List of compatible file extensions.
+ :param kwargs: Additional keyword arguments.
+ """
+ message = f"Input file must have extension {' / '.join(extensions)}"
+ super().__init__(message, **kwargs)
+
+
+
+
+[docs]
+class FileNotFound(Exception):
+ """Exception raised when a file is not found."""
+
+ def __init__(self, file: str, **kwargs) -> None:
+ """
+ Initialize the exception.
+
+ :param file: The path of the file.
+ :param kwargs: Additional keyword arguments.
+ """
+ message = f"File not found: {file}"
+ super().__init__(message, **kwargs)
+
+
+
+
+[docs]
+class FileNotParsed(Exception):
+ """Exception raised when a file is not parsed."""
+
+ def __init__(self, file: str, **kwargs) -> None:
+ """
+ Initialize the exception.
+
+ :param file: The path of the file.
+ :param kwargs: Additional keyword arguments.
+ """
+ message = f"File not parsed: {file}"
+ super().__init__(message, **kwargs)
+
+
+
+
+[docs]
+class ImpossibleSpan(Exception):
+ """Exception raised when a span is impossible."""
+
+ def __init__(self, **kwargs) -> None:
+ """
+ Initialize the exception.
+
+ :param kwargs: Additional keyword arguments.
+ """
+ super().__init__(
+ "The closing position cannot be less or equal than the starting position",
+ **kwargs,
+ )
+
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from onigurumacffi import _Match as Match
+from onigurumacffi import _Pattern as Pattern
+from onigurumacffi import compile
+
+from .exceptions import FileNotFound, ImpossibleSpan
+from .logger import LOGGER
+
+POS = tuple[int, int]
+
+
+
+[docs]
+class ContentHandler:
+ """The handler object targetted for parsing.
+
+ To parse a string or file, it needs to be loaded into the ContentHandler object.
+ The handler will take care of all read actions on the input stream, where the contents
+ are index by a tuple (line_number, line_position). Additionally, the handler contains the
+ search method to match a search span against a input oniguruma regex pattern.
+ """
+
+ notLookForwardEOL = compile(r"(?<!\(\?=[^\(]*)\$")
+
+ def __init__(self, source: str) -> None:
+ """
+ Initialize a new instance of the Handler class.
+
+ :param source: The source code to be processed.
+ :type source: str
+
+ :ivar source: The source code to be processed.
+ :ivar lines: A list of lines in the source code, with a newline character at the end of each line.
+ :ivar line_lengths: A list of lengths of each line in the source code.
+ :ivar anchor: The current position in the source code.
+ """
+ self.source = source
+ self.lines = [line + "\n" for line in source.split("\n")]
+ self.line_lengths = [len(line) for line in self.lines]
+ self.anchor: int = 0
+
+
+[docs]
+ @classmethod
+ def from_path(cls, file_path: Path):
+ """Loads a file from a path"""
+
+ if not file_path.exists():
+ raise FileNotFound(str(file_path))
+
+ # Open file and replace Windows/Mac line endings
+ with open(file_path) as file:
+ content = file.read()
+ content = content.replace("\r\n", "\n")
+ content = content.replace("\r", "\n")
+
+ return cls(content)
+
+
+ def _check_pos(self, pos: POS):
+ if pos[0] > len(self.lines) or pos[1] > self.line_lengths[pos[0]]:
+ raise ImpossibleSpan
+
+
+[docs]
+ def next(self, pos: POS, step: int = 1) -> POS:
+ """Returns the next position on the current handler.
+
+ :param pos: The current position as a tuple (line, column).
+ :param step: The number of steps to move forward. Defaults to 1.
+ :return: The next position as a tuple (line, column).
+ """
+ if step > 1:
+ pos = self.next(pos, step=step - 1)
+ if pos[1] == self.line_lengths[pos[0]]:
+ if pos[0] == len(self.lines):
+ return pos
+ else:
+ return (pos[0] + 1, 0)
+ else:
+ return (pos[0], pos[1] + 1)
+
+
+
+[docs]
+ def prev(self, pos: POS, step: int = 1) -> POS:
+ """Returns the previous position on the current handler.
+
+ :param pos: The current position as a tuple (line, column).
+ :param step: The number of steps to go back. Defaults to 1.
+ :return: The previous position as a tuple (line, column).
+ """
+ if step > 1:
+ pos = self.prev(pos, step=step - 1)
+ if pos[1] == 0:
+ if pos[0] == 0:
+ return (0, 0)
+ else:
+ return (pos[0] - 1, self.line_lengths[pos[0] - 1])
+ else:
+ return (pos[0], pos[1] - 1)
+
+
+
+[docs]
+ def range(self, start: POS, close: POS) -> list[POS]:
+ """
+ Returns a list of positions between the start and close positions.
+
+ :param start: The starting position.
+ :param close: The closing position.
+ :return: A list of positions between the start and close positions.
+ """
+ indices = []
+ if start[0] == close[0]:
+ for lp in range(start[1], close[1]):
+ indices.append((start[0], lp))
+ else:
+ for lp in range(start[1], self.line_lengths[start[0]]):
+ indices.append((start[0], lp))
+ for ln in range(start[0] + 1, close[0]):
+ for lp in range(self.line_lengths[ln]):
+ indices.append((ln, lp))
+ for lp in range(close[1]):
+ indices.append((close[0], lp))
+ return indices
+
+
+
+[docs]
+ def chars(self, start: POS, close: POS) -> dict[POS, str]:
+ """
+ Returns a dictionary mapping each position within the given range to the corresponding source character.
+
+ :param start: The starting position of the range.
+ :param close: The closing position of the range.
+ :return: A dictionary mapping each position within the range to the corresponding source character.
+ """
+ indices = self.range(start, close)
+ return {pos: self.read(pos) for pos in indices}
+
+
+
+[docs]
+ def read_pos(self, start_pos: POS, close_pos: POS, skip_newline: bool = True) -> str:
+ """Reads the content between the start and end positions.
+
+ :param start_pos: The starting position of the content.
+ :param close_pos: The closing position of the content.
+ :param skip_newline: Whether to skip the newline character at the end of the content.
+ :return: The content between the start and end positions.
+ :raises ImpossibleSpan: If the start position is greater than the close position.
+ """
+ self._check_pos(start_pos)
+ self._check_pos(close_pos)
+ if start_pos > close_pos:
+ raise ImpossibleSpan
+
+ if start_pos[0] == close_pos[0]:
+ readout = self.lines[start_pos[0]][start_pos[1] : close_pos[1]]
+ else:
+ readout = ""
+ for ln in range(start_pos[0], close_pos[0] + 1):
+ if ln == start_pos[0]:
+ readout += self.lines[ln][start_pos[1] :]
+ elif ln == close_pos[0]:
+ readout += self.lines[ln][: close_pos[1]]
+ else:
+ readout += self.lines[ln]
+
+ if skip_newline and readout and readout[-1] == "\n":
+ readout = readout[:-1]
+
+ return readout
+
+
+
+[docs]
+ def read_line(self, pos: POS) -> str:
+ """
+ Reads a line from the specified position and returns it.
+
+ :param pos: The position of the line to read. The first element is the line number (0-based),
+ and the second element is the starting position within the line.
+ :return: The line starting from the specified position.
+ """
+ line = self.lines[pos[0]]
+ return line[pos[1] :]
+
+
+
+[docs]
+ def read(self, start_pos: POS, length: int = 1, skip_newline: bool = True) -> str:
+ """Reads the content from start for a length.
+
+ :param start_pos: The starting position to read from.
+ :param length: The number of characters to read. Defaults to 1.
+ :param skip_newline: Whether to skip the newline character at the end of the read content. Defaults to True.
+ :return: The content read from the specified position.
+ :raises ImpossibleSpan: If the length is negative.
+ """
+ self._check_pos(start_pos)
+ if length < 0:
+ raise ImpossibleSpan
+
+ remainder = self.line_lengths[start_pos[0]] - start_pos[1]
+
+ if length <= remainder:
+ readout = self.lines[start_pos[0]][start_pos[1] : (start_pos[1] + length)]
+ else:
+ readout = self.lines[start_pos[0]][start_pos[1] :]
+ unread_length = length - remainder
+ ln = start_pos[0] + 1
+ if ln >= len(self.lines):
+ return ""
+
+ while unread_length > self.line_lengths[ln]:
+ readout += self.lines[ln]
+ unread_length -= self.line_lengths[ln]
+ ln += 1
+ else:
+ readout += self.lines[ln][:unread_length]
+
+ if skip_newline and readout[-1] == "\n":
+ readout = readout[:-1]
+
+ return readout
+
+
+
+[docs]
+ def search(
+ self,
+ pattern: Pattern,
+ starting: POS,
+ boundary: POS | None = None,
+ greedy: bool = False,
+ **kwargs,
+ ) -> tuple[Match | None, tuple[POS, POS] | None]:
+ """Matches the stream against a capture group.
+
+ :param pattern: The regular expression pattern to match against the stream.
+ :param starting: The starting position in the stream.
+ :param boundary: The boundary position in the stream. Defaults to None.
+ :param greedy: Determines if the matching should be greedy or not. Defaults to False.
+ :param kwargs: Additional keyword arguments.
+
+ :return: A tuple containing the matching result and the span of the match.
+
+ .. note::
+ - The stream is matched against the input pattern. If there are any capture groups,
+ each is then subsequently parsed by the inputted parsers. The number of parsers therefore
+ must match the number of capture groups of the expression, or there must be a single parser
+ and no capture groups.
+ - The `greedy` parameter determines if the matching should be greedy or not. If set to True,
+ the matching will try to consume as much of the stream as possible. If set to False,
+ the matching will stop at the first match found.
+ - The `boundary` parameter can be used to specify a boundary position in the stream. If provided,
+ the matching will not go beyond this boundary position.
+ - The `leading_chars` parameter can be used to specify the type of leading characters allowed, with:
+ - `0`: none allowed
+ - `1`: whitespace characters allowed
+ - `2`: any character allowed.
+ """
+
+ if pattern._pattern in ["\\z", "\\Z"]:
+ greedy = True
+
+ # Get line from starting (and boundary) positions
+ if boundary and starting[0] == boundary[0]:
+ line = self.lines[starting[0]][: boundary[1]]
+ else:
+ line = self.lines[starting[0]]
+
+ # Gets the previous matching end position from anchor in case of \G.
+ init_pos = self.anchor if "\\G" in pattern._pattern else starting[1]
+
+ # Find begin of line and search starting from the initial position
+ matching = pattern.search(line, start=init_pos)
+
+ # Check that no charaters are skipped in case ws-only is enabled
+ if matching:
+ leading_string = line[init_pos : matching.start()]
+ if leading_string and not (greedy or (not greedy and leading_string.isspace())):
+ return None, None
+ else:
+ return None, None
+
+ # Get span of current matching, taking into account the lookback operation
+ start_pos = (starting[0], matching.start())
+ close_pos = (starting[0], matching.end())
+
+ # Do not allow matching past a boundary positition, if provided
+ if boundary and close_pos > boundary:
+ return None, None
+
+ if leading_string and not leading_string.isspace() and greedy:
+ LOGGER.warning(
+ f"skipping < {leading_string} >",
+ position=start_pos,
+ depth=kwargs.get("depth", 0),
+ )
+
+ # Include \n in match span if pattern matches on end of line $
+ if (
+ self.notLookForwardEOL.search(pattern._pattern)
+ and matching.end() + 1 == self.line_lengths[starting[0]]
+ ):
+ newline_matching = pattern.search(line[:-1])
+ if newline_matching and newline_matching.span() == matching.span():
+ close_pos = (starting[0], matching.end() + 1)
+
+ # Set anchor for next matching
+ self.anchor = matching.end()
+
+ return matching, (start_pos, close_pos)
+
+
+
+from __future__ import annotations
+
+import logging
+from functools import wraps
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ..parser import GrammarParser
+
+
+MAX_LENGTH = 79
+
+
+
+[docs]
+def track_depth(func):
+ """Simple decorator to track recusion depth."""
+
+ @wraps(func)
+ def wrapper(*args, depth: int = -1, **kwargs):
+ return func(*args, depth=depth + 1, **kwargs)
+
+ return wrapper
+
+
+
+
+[docs]
+class LogFormatter(logging.Formatter):
+ """
+ A custom log formatter that formats log records with color-coded messages.
+ """
+
+ green = "\x1b[32;32m"
+ grey = "\x1b[38;20m"
+ yellow = "\x1b[33;20m"
+ red = "\x1b[31;20m"
+ bold_red = "\x1b[31;1m"
+ reset = "\x1b[0m"
+ format_string = "%(name)s:%(message)s"
+
+ FORMATS = {
+ logging.DEBUG: green + format_string + reset,
+ logging.INFO: grey + format_string + reset,
+ logging.WARNING: yellow + format_string + reset,
+ logging.ERROR: red + format_string + reset,
+ logging.CRITICAL: bold_red + format_string + reset,
+ }
+
+
+[docs]
+ def format(self, record):
+ """
+ Formats the log record with the color-coded format based on the log level.
+
+ :param record: The log record to be formatted.
+ :return: The formatted log message.
+ """
+ log_fmt = self.FORMATS.get(record.levelno)
+ formatter = logging.Formatter(log_fmt)
+ return formatter.format(record)
+
+
+
+
+
+[docs]
+class Logger:
+ """
+ The logger object for the grammar parsers.
+ """
+
+ long_msg_div = "\x1b[1;32m ... \x1b[0m"
+
+ def __init__(self, **kwargs) -> None:
+ self.id = None
+ self.max_token_length = 50
+ self.line_decimals = 3
+ self.position_decimals = 3
+ self.scope = "UNKNOWN"
+ self.logger = logging.getLogger("textmate_grammar")
+ channel = logging.StreamHandler()
+ channel.setFormatter(LogFormatter())
+ self.logger.addHandler(channel)
+
+
+[docs]
+ def configure(self, parser: GrammarParser, height: int, width: int, **kwargs) -> None:
+ """Configures the logger to a specific grammar and content length"""
+ self.line_decimals = len(str(height))
+ self.position_decimals = len(str(width))
+ id = parser.token if parser.token else parser.key
+ if self.id != id:
+ self.id = id
+ tokens = _gen_all_tokens(parser.grammar)
+ self.max_token_length = max(len(token) for token in tokens)
+ self.scope = parser.token
+
+
+
+[docs]
+ def format_message(
+ self,
+ message: str,
+ parser: GrammarParser | None = None,
+ position: tuple[int, int] | None = None,
+ depth: int = 0,
+ ) -> str:
+ """
+ Formats a logging message to the defined format.
+
+ :param message: The logging message to be formatted.
+ :param parser: The GrammarParser object associated with the message. Defaults to None.
+ :param position: The position tuple (line, column) associated with the message. Defaults to None.
+ :param depth: The depth of the message in the logging hierarchy. Defaults to 0.
+ :return: The formatted logging message.
+ """
+ if position:
+ msg_pos = "{:{ll}d}-{:{lp}d}".format(
+ *position, ll=self.line_decimals, lp=self.position_decimals
+ ).replace(" ", "0")
+ else:
+ msg_pos = "." * (self.line_decimals + self.position_decimals + 1)
+
+ if parser:
+ parser_id = parser.token if parser.token else parser.key
+ msg_id = (
+ "." * (self.max_token_length - len(parser_id)) + parser_id[: self.max_token_length]
+ )
+ else:
+ msg_id = "." * self.max_token_length
+
+ vb_message = f"{'|'*(depth-1)}{'-'*bool(depth)}{message}"
+
+ if len(vb_message) > MAX_LENGTH:
+ half_length = min([(MAX_LENGTH - 6) // 2, (len(vb_message) - 6) // 2])
+ vb_message = vb_message[:half_length] + self.long_msg_div + vb_message[-half_length:]
+
+ return f"{self.scope}:{msg_pos}:{msg_id}: {vb_message}"
+
+
+
+[docs]
+ def debug(self, *args, **kwargs) -> None:
+ if self.logger.getEffectiveLevel() > logging.DEBUG:
+ return
+ message = self.format_message(*args, **kwargs)
+ self.logger.debug(message)
+
+
+
+[docs]
+ def info(self, *args, **kwargs) -> None:
+ if self.logger.getEffectiveLevel() > logging.INFO:
+ return
+ message = self.format_message(*args, **kwargs)
+ self.logger.info(message)
+
+
+
+[docs]
+ def warning(self, *args, **kwargs) -> None:
+ if self.logger.getEffectiveLevel() > logging.WARNING:
+ return
+ message = self.format_message(*args, **kwargs)
+ self.logger.warning(message)
+
+
+
+[docs]
+ def error(self, *args, **kwargs) -> None:
+ if self.logger.getEffectiveLevel() > logging.ERROR:
+ return
+ message = self.format_message(*args, **kwargs)
+ self.logger.error(message)
+
+
+
+[docs]
+ def critical(self, *args, **kwargs) -> None:
+ if self.logger.getEffectiveLevel() > logging.CRITICAL:
+ return
+ message = self.format_message(*args, **kwargs)
+ self.logger.critical(message)
+
+
+
+
+def _gen_all_tokens(grammar: dict, items: list[str] | None = None) -> list[str]:
+ if items is None:
+ items = []
+ for key, value in grammar.items():
+ if key in ["name", "contentName"]:
+ items.append(value)
+ elif isinstance(value, list):
+ for nested_grammar in (item for item in value if isinstance(item, dict)):
+ _gen_all_tokens(nested_grammar, items)
+ elif isinstance(value, dict):
+ _gen_all_tokens(value, items)
+ return items
+
+
+LOGGER = Logger()
+' + + '' + + _("Hide Search Matches") + + "
" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/_static/styles/furo-extensions.css b/_static/styles/furo-extensions.css new file mode 100644 index 0000000..bc447f2 --- /dev/null +++ b/_static/styles/furo-extensions.css @@ -0,0 +1,2 @@ +#furo-sidebar-ad-placement{padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)}#furo-sidebar-ad-placement .ethical-sidebar{background:var(--color-background-secondary);border:none;box-shadow:none}#furo-sidebar-ad-placement .ethical-sidebar:hover{background:var(--color-background-hover)}#furo-sidebar-ad-placement .ethical-sidebar a{color:var(--color-foreground-primary)}#furo-sidebar-ad-placement .ethical-callout a{color:var(--color-foreground-secondary)!important}#furo-readthedocs-versions{background:transparent;display:block;position:static;width:100%}#furo-readthedocs-versions .rst-versions{background:#1a1c1e}#furo-readthedocs-versions .rst-current-version{background:var(--color-sidebar-item-background);cursor:unset}#furo-readthedocs-versions .rst-current-version:hover{background:var(--color-sidebar-item-background)}#furo-readthedocs-versions .rst-current-version .fa-book{color:var(--color-foreground-primary)}#furo-readthedocs-versions>.rst-other-versions{padding:0}#furo-readthedocs-versions>.rst-other-versions small{opacity:1}#furo-readthedocs-versions .injected .rst-versions{position:unset}#furo-readthedocs-versions:focus-within,#furo-readthedocs-versions:hover{box-shadow:0 0 0 1px var(--color-sidebar-background-border)}#furo-readthedocs-versions:focus-within .rst-current-version,#furo-readthedocs-versions:hover .rst-current-version{background:#1a1c1e;font-size:inherit;height:auto;line-height:inherit;padding:12px;text-align:right}#furo-readthedocs-versions:focus-within .rst-current-version .fa-book,#furo-readthedocs-versions:hover .rst-current-version .fa-book{color:#fff;float:left}#furo-readthedocs-versions:focus-within .fa-caret-down,#furo-readthedocs-versions:hover .fa-caret-down{display:none}#furo-readthedocs-versions:focus-within .injected,#furo-readthedocs-versions:focus-within .rst-current-version,#furo-readthedocs-versions:focus-within .rst-other-versions,#furo-readthedocs-versions:hover .injected,#furo-readthedocs-versions:hover .rst-current-version,#furo-readthedocs-versions:hover .rst-other-versions{display:block}#furo-readthedocs-versions:focus-within>.rst-current-version,#furo-readthedocs-versions:hover>.rst-current-version{display:none}.highlight:hover button.copybtn{color:var(--color-code-foreground)}.highlight button.copybtn{align-items:center;background-color:var(--color-code-background);border:none;color:var(--color-background-item);cursor:pointer;height:1.25em;opacity:1;right:.5rem;top:.625rem;transition:color .3s,opacity .3s;width:1.25em}.highlight button.copybtn:hover{background-color:var(--color-code-background);color:var(--color-brand-content)}.highlight button.copybtn:after{background-color:transparent;color:var(--color-code-foreground);display:none}.highlight button.copybtn.success{color:#22863a;transition:color 0ms}.highlight button.copybtn.success:after{display:block}.highlight button.copybtn svg{padding:0}body{--sd-color-primary:var(--color-brand-primary);--sd-color-primary-highlight:var(--color-brand-content);--sd-color-primary-text:var(--color-background-primary);--sd-color-shadow:rgba(0,0,0,.05);--sd-color-card-border:var(--color-card-border);--sd-color-card-border-hover:var(--color-brand-content);--sd-color-card-background:var(--color-card-background);--sd-color-card-text:var(--color-foreground-primary);--sd-color-card-header:var(--color-card-marginals-background);--sd-color-card-footer:var(--color-card-marginals-background);--sd-color-tabs-label-active:var(--color-brand-content);--sd-color-tabs-label-hover:var(--color-foreground-muted);--sd-color-tabs-label-inactive:var(--color-foreground-muted);--sd-color-tabs-underline-active:var(--color-brand-content);--sd-color-tabs-underline-hover:var(--color-foreground-border);--sd-color-tabs-underline-inactive:var(--color-background-border);--sd-color-tabs-overline:var(--color-background-border);--sd-color-tabs-underline:var(--color-background-border)}.sd-tab-content{box-shadow:0 -2px var(--sd-color-tabs-overline),0 1px var(--sd-color-tabs-underline)}.sd-card{box-shadow:0 .1rem .25rem var(--sd-color-shadow),0 0 .0625rem rgba(0,0,0,.1)}.sd-shadow-sm{box-shadow:0 .1rem .25rem var(--sd-color-shadow),0 0 .0625rem rgba(0,0,0,.1)!important}.sd-shadow-md{box-shadow:0 .3rem .75rem var(--sd-color-shadow),0 0 .0625rem rgba(0,0,0,.1)!important}.sd-shadow-lg{box-shadow:0 .6rem 1.5rem var(--sd-color-shadow),0 0 .0625rem rgba(0,0,0,.1)!important}.sd-card-hover:hover{transform:none}.sd-cards-carousel{gap:.25rem;padding:.25rem}body{--tabs--label-text:var(--color-foreground-muted);--tabs--label-text--hover:var(--color-foreground-muted);--tabs--label-text--active:var(--color-brand-content);--tabs--label-text--active--hover:var(--color-brand-content);--tabs--label-background:transparent;--tabs--label-background--hover:transparent;--tabs--label-background--active:transparent;--tabs--label-background--active--hover:transparent;--tabs--padding-x:0.25em;--tabs--margin-x:1em;--tabs--border:var(--color-background-border);--tabs--label-border:transparent;--tabs--label-border--hover:var(--color-foreground-muted);--tabs--label-border--active:var(--color-brand-content);--tabs--label-border--active--hover:var(--color-brand-content)}[role=main] .container{max-width:none;padding-left:0;padding-right:0}.shadow.docutils{border:none;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1)!important}.sphinx-bs .card{background-color:var(--color-background-secondary);color:var(--color-foreground)} +/*# sourceMappingURL=furo-extensions.css.map*/ \ No newline at end of file diff --git a/_static/styles/furo-extensions.css.map b/_static/styles/furo-extensions.css.map new file mode 100644 index 0000000..9ba5637 --- /dev/null +++ b/_static/styles/furo-extensions.css.map @@ -0,0 +1 @@ +{"version":3,"file":"styles/furo-extensions.css","mappings":"AAGA,2BACE,oFACA,4CAKE,6CAHA,YACA,eAEA,CACA,kDACE,yCAEF,8CACE,sCAEJ,8CACE,kDAEJ,2BAGE,uBACA,cAHA,gBACA,UAEA,CAGA,yCACE,mBAEF,gDAEE,gDADA,YACA,CACA,sDACE,gDACF,yDACE,sCAEJ,+CACE,UACA,qDACE,UAGF,mDACE,eAEJ,yEAEE,4DAEA,mHASE,mBAPA,kBAEA,YADA,oBAGA,aADA,gBAIA,CAEA,qIAEE,WADA,UACA,CAEJ,uGACE,aAEF,iUAGE,cAEF,mHACE,aC1EJ,gCACE,mCAEF,0BAKE,mBAUA,8CACA,YAFA,mCAKA,eAZA,cALA,UASA,YADA,YAYA,iCAdA,YAcA,CAEA,gCAEE,8CADA,gCACA,CAEF,gCAGE,6BADA,mCADA,YAEA,CAEF,kCAEE,cADA,oBACA,CACA,wCACE,cAEJ,8BACE,UC5CN,KAEE,6CAA8C,CAC9C,uDAAwD,CACxD,uDAAwD,CAGxD,iCAAsC,CAGtC,+CAAgD,CAChD,uDAAwD,CACxD,uDAAwD,CACxD,oDAAqD,CACrD,6DAA8D,CAC9D,6DAA8D,CAG9D,uDAAwD,CACxD,yDAA0D,CAC1D,4DAA6D,CAC7D,2DAA4D,CAC5D,8DAA+D,CAC/D,iEAAkE,CAClE,uDAAwD,CACxD,wDAAyD,CAG3D,gBACE,qFAGF,SACE,6EAEF,cACE,uFAEF,cACE,uFAEF,cACE,uFAGF,qBACE,eAEF,mBACE,WACA,eChDF,KACE,gDAAiD,CACjD,uDAAwD,CACxD,qDAAsD,CACtD,4DAA6D,CAC7D,oCAAqC,CACrC,2CAA4C,CAC5C,4CAA6C,CAC7C,mDAAoD,CACpD,wBAAyB,CACzB,oBAAqB,CACrB,6CAA8C,CAC9C,gCAAiC,CACjC,yDAA0D,CAC1D,uDAAwD,CACxD,8DAA+D,CCbjE,uBACE,eACA,eACA,gBAGF,iBACE,YACA,+EAGF,iBACE,mDACA","sources":["webpack:///./src/furo/assets/styles/extensions/_readthedocs.sass","webpack:///./src/furo/assets/styles/extensions/_copybutton.sass","webpack:///./src/furo/assets/styles/extensions/_sphinx-design.sass","webpack:///./src/furo/assets/styles/extensions/_sphinx-inline-tabs.sass","webpack:///./src/furo/assets/styles/extensions/_sphinx-panels.sass"],"sourcesContent":["// This file contains the styles used for tweaking how ReadTheDoc's embedded\n// contents would show up inside the theme.\n\n#furo-sidebar-ad-placement\n padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)\n .ethical-sidebar\n // Remove the border and box-shadow.\n border: none\n box-shadow: none\n // Manage the background colors.\n background: var(--color-background-secondary)\n &:hover\n background: var(--color-background-hover)\n // Ensure the text is legible.\n a\n color: var(--color-foreground-primary)\n\n .ethical-callout a\n color: var(--color-foreground-secondary) !important\n\n#furo-readthedocs-versions\n position: static\n width: 100%\n background: transparent\n display: block\n\n // Make the background color fit with the theme's aesthetic.\n .rst-versions\n background: rgb(26, 28, 30)\n\n .rst-current-version\n cursor: unset\n background: var(--color-sidebar-item-background)\n &:hover\n background: var(--color-sidebar-item-background)\n .fa-book\n color: var(--color-foreground-primary)\n\n > .rst-other-versions\n padding: 0\n small\n opacity: 1\n\n .injected\n .rst-versions\n position: unset\n\n &:hover,\n &:focus-within\n box-shadow: 0 0 0 1px var(--color-sidebar-background-border)\n\n .rst-current-version\n // Undo the tweaks done in RTD's CSS\n font-size: inherit\n line-height: inherit\n height: auto\n text-align: right\n padding: 12px\n\n // Match the rest of the body\n background: #1a1c1e\n\n .fa-book\n float: left\n color: white\n\n .fa-caret-down\n display: none\n\n .rst-current-version,\n .rst-other-versions,\n .injected\n display: block\n\n > .rst-current-version\n display: none\n",".highlight\n &:hover button.copybtn\n color: var(--color-code-foreground)\n\n button.copybtn\n // Make it visible\n opacity: 1\n\n // Align things correctly\n align-items: center\n\n height: 1.25em\n width: 1.25em\n\n top: 0.625rem // $code-spacing-vertical\n right: 0.5rem\n\n // Make it look better\n color: var(--color-background-item)\n background-color: var(--color-code-background)\n border: none\n\n // Change to cursor to make it obvious that you can click on it\n cursor: pointer\n\n // Transition smoothly, for aesthetics\n transition: color 300ms, opacity 300ms\n\n &:hover\n color: var(--color-brand-content)\n background-color: var(--color-code-background)\n\n &::after\n display: none\n color: var(--color-code-foreground)\n background-color: transparent\n\n &.success\n transition: color 0ms\n color: #22863a\n &::after\n display: block\n\n svg\n padding: 0\n","body\n // Colors\n --sd-color-primary: var(--color-brand-primary)\n --sd-color-primary-highlight: var(--color-brand-content)\n --sd-color-primary-text: var(--color-background-primary)\n\n // Shadows\n --sd-color-shadow: rgba(0, 0, 0, 0.05)\n\n // Cards\n --sd-color-card-border: var(--color-card-border)\n --sd-color-card-border-hover: var(--color-brand-content)\n --sd-color-card-background: var(--color-card-background)\n --sd-color-card-text: var(--color-foreground-primary)\n --sd-color-card-header: var(--color-card-marginals-background)\n --sd-color-card-footer: var(--color-card-marginals-background)\n\n // Tabs\n --sd-color-tabs-label-active: var(--color-brand-content)\n --sd-color-tabs-label-hover: var(--color-foreground-muted)\n --sd-color-tabs-label-inactive: var(--color-foreground-muted)\n --sd-color-tabs-underline-active: var(--color-brand-content)\n --sd-color-tabs-underline-hover: var(--color-foreground-border)\n --sd-color-tabs-underline-inactive: var(--color-background-border)\n --sd-color-tabs-overline: var(--color-background-border)\n --sd-color-tabs-underline: var(--color-background-border)\n\n// Tabs\n.sd-tab-content\n box-shadow: 0 -2px var(--sd-color-tabs-overline), 0 1px var(--sd-color-tabs-underline)\n\n// Shadows\n.sd-card // Have a shadow by default\n box-shadow: 0 0.1rem 0.25rem var(--sd-color-shadow), 0 0 0.0625rem rgba(0, 0, 0, 0.1)\n\n.sd-shadow-sm\n box-shadow: 0 0.1rem 0.25rem var(--sd-color-shadow), 0 0 0.0625rem rgba(0, 0, 0, 0.1) !important\n\n.sd-shadow-md\n box-shadow: 0 0.3rem 0.75rem var(--sd-color-shadow), 0 0 0.0625rem rgba(0, 0, 0, 0.1) !important\n\n.sd-shadow-lg\n box-shadow: 0 0.6rem 1.5rem var(--sd-color-shadow), 0 0 0.0625rem rgba(0, 0, 0, 0.1) !important\n\n// Cards\n.sd-card-hover:hover // Don't change scale on hover\n transform: none\n\n.sd-cards-carousel // Have a bit of gap in the carousel by default\n gap: 0.25rem\n padding: 0.25rem\n","// This file contains styles to tweak sphinx-inline-tabs to work well with Furo.\n\nbody\n --tabs--label-text: var(--color-foreground-muted)\n --tabs--label-text--hover: var(--color-foreground-muted)\n --tabs--label-text--active: var(--color-brand-content)\n --tabs--label-text--active--hover: var(--color-brand-content)\n --tabs--label-background: transparent\n --tabs--label-background--hover: transparent\n --tabs--label-background--active: transparent\n --tabs--label-background--active--hover: transparent\n --tabs--padding-x: 0.25em\n --tabs--margin-x: 1em\n --tabs--border: var(--color-background-border)\n --tabs--label-border: transparent\n --tabs--label-border--hover: var(--color-foreground-muted)\n --tabs--label-border--active: var(--color-brand-content)\n --tabs--label-border--active--hover: var(--color-brand-content)\n","// This file contains styles to tweak sphinx-panels to work well with Furo.\n\n// sphinx-panels includes Bootstrap 4, which uses .container which can conflict\n// with docutils' `.. container::` directive.\n[role=\"main\"] .container\n max-width: initial\n padding-left: initial\n padding-right: initial\n\n// Make the panels look nicer!\n.shadow.docutils\n border: none\n box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1) !important\n\n// Make panel colors respond to dark mode\n.sphinx-bs .card\n background-color: var(--color-background-secondary)\n color: var(--color-foreground)\n"],"names":[],"sourceRoot":""} \ No newline at end of file diff --git a/_static/styles/furo.css b/_static/styles/furo.css new file mode 100644 index 0000000..3d29a21 --- /dev/null +++ b/_static/styles/furo.css @@ -0,0 +1,2 @@ +/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{-webkit-text-size-adjust:100%;line-height:1.15}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}@media print{.content-icon-container,.headerlink,.mobile-header,.related-pages{display:none!important}.highlight{border:.1pt solid var(--color-foreground-border)}a,blockquote,dl,ol,pre,table,ul{page-break-inside:avoid}caption,figure,h1,h2,h3,h4,h5,h6,img{page-break-after:avoid;page-break-inside:avoid}dl,ol,ul{page-break-before:avoid}}.visually-hidden{clip:rect(0,0,0,0)!important;border:0!important;height:1px!important;margin:-1px!important;overflow:hidden!important;padding:0!important;position:absolute!important;white-space:nowrap!important;width:1px!important}:-moz-focusring{outline:auto}body{--font-stack:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji;--font-stack--monospace:"SFMono-Regular",Menlo,Consolas,Monaco,Liberation Mono,Lucida Console,monospace;--font-size--normal:100%;--font-size--small:87.5%;--font-size--small--2:81.25%;--font-size--small--3:75%;--font-size--small--4:62.5%;--sidebar-caption-font-size:var(--font-size--small--2);--sidebar-item-font-size:var(--font-size--small);--sidebar-search-input-font-size:var(--font-size--small);--toc-font-size:var(--font-size--small--3);--toc-font-size--mobile:var(--font-size--normal);--toc-title-font-size:var(--font-size--small--4);--admonition-font-size:0.8125rem;--admonition-title-font-size:0.8125rem;--code-font-size:var(--font-size--small--2);--api-font-size:var(--font-size--small);--header-height:calc(var(--sidebar-item-line-height) + var(--sidebar-item-spacing-vertical)*4);--header-padding:0.5rem;--sidebar-tree-space-above:1.5rem;--sidebar-caption-space-above:1rem;--sidebar-item-line-height:1rem;--sidebar-item-spacing-vertical:0.5rem;--sidebar-item-spacing-horizontal:1rem;--sidebar-item-height:calc(var(--sidebar-item-line-height) + var(--sidebar-item-spacing-vertical)*2);--sidebar-expander-width:var(--sidebar-item-height);--sidebar-search-space-above:0.5rem;--sidebar-search-input-spacing-vertical:0.5rem;--sidebar-search-input-spacing-horizontal:0.5rem;--sidebar-search-input-height:1rem;--sidebar-search-icon-size:var(--sidebar-search-input-height);--toc-title-padding:0.25rem 0;--toc-spacing-vertical:1.5rem;--toc-spacing-horizontal:1.5rem;--toc-item-spacing-vertical:0.4rem;--toc-item-spacing-horizontal:1rem;--icon-search:url('data:image/svg+xml;charset=utf-8,');--icon-pencil:url('data:image/svg+xml;charset=utf-8,');--icon-abstract:url('data:image/svg+xml;charset=utf-8,');--icon-info:url('data:image/svg+xml;charset=utf-8,');--icon-flame:url('data:image/svg+xml;charset=utf-8,');--icon-question:url('data:image/svg+xml;charset=utf-8,');--icon-warning:url('data:image/svg+xml;charset=utf-8,');--icon-failure:url('data:image/svg+xml;charset=utf-8,');--icon-spark:url('data:image/svg+xml;charset=utf-8,');--color-admonition-title--caution:#ff9100;--color-admonition-title-background--caution:rgba(255,145,0,.2);--color-admonition-title--warning:#ff9100;--color-admonition-title-background--warning:rgba(255,145,0,.2);--color-admonition-title--danger:#ff5252;--color-admonition-title-background--danger:rgba(255,82,82,.2);--color-admonition-title--attention:#ff5252;--color-admonition-title-background--attention:rgba(255,82,82,.2);--color-admonition-title--error:#ff5252;--color-admonition-title-background--error:rgba(255,82,82,.2);--color-admonition-title--hint:#00c852;--color-admonition-title-background--hint:rgba(0,200,82,.2);--color-admonition-title--tip:#00c852;--color-admonition-title-background--tip:rgba(0,200,82,.2);--color-admonition-title--important:#00bfa5;--color-admonition-title-background--important:rgba(0,191,165,.2);--color-admonition-title--note:#00b0ff;--color-admonition-title-background--note:rgba(0,176,255,.2);--color-admonition-title--seealso:#448aff;--color-admonition-title-background--seealso:rgba(68,138,255,.2);--color-admonition-title--admonition-todo:grey;--color-admonition-title-background--admonition-todo:hsla(0,0%,50%,.2);--color-admonition-title:#651fff;--color-admonition-title-background:rgba(101,31,255,.2);--icon-admonition-default:var(--icon-abstract);--color-topic-title:#14b8a6;--color-topic-title-background:rgba(20,184,166,.2);--icon-topic-default:var(--icon-pencil);--color-problematic:#b30000;--color-foreground-primary:#000;--color-foreground-secondary:#5a5c63;--color-foreground-muted:#646776;--color-foreground-border:#878787;--color-background-primary:#fff;--color-background-secondary:#f8f9fb;--color-background-hover:#efeff4;--color-background-hover--transparent:#efeff400;--color-background-border:#eeebee;--color-background-item:#ccc;--color-announcement-background:#000000dd;--color-announcement-text:#eeebee;--color-brand-primary:#2962ff;--color-brand-content:#2a5adf;--color-api-background:var(--color-background-hover--transparent);--color-api-background-hover:var(--color-background-hover);--color-api-overall:var(--color-foreground-secondary);--color-api-name:var(--color-problematic);--color-api-pre-name:var(--color-problematic);--color-api-paren:var(--color-foreground-secondary);--color-api-keyword:var(--color-foreground-primary);--color-highlight-on-target:#ffc;--color-inline-code-background:var(--color-background-secondary);--color-highlighted-background:#def;--color-highlighted-text:var(--color-foreground-primary);--color-guilabel-background:#ddeeff80;--color-guilabel-border:#bedaf580;--color-guilabel-text:var(--color-foreground-primary);--color-admonition-background:transparent;--color-table-header-background:var(--color-background-secondary);--color-table-border:var(--color-background-border);--color-card-border:var(--color-background-secondary);--color-card-background:transparent;--color-card-marginals-background:var(--color-background-secondary);--color-header-background:var(--color-background-primary);--color-header-border:var(--color-background-border);--color-header-text:var(--color-foreground-primary);--color-sidebar-background:var(--color-background-secondary);--color-sidebar-background-border:var(--color-background-border);--color-sidebar-brand-text:var(--color-foreground-primary);--color-sidebar-caption-text:var(--color-foreground-muted);--color-sidebar-link-text:var(--color-foreground-secondary);--color-sidebar-link-text--top-level:var(--color-brand-primary);--color-sidebar-item-background:var(--color-sidebar-background);--color-sidebar-item-background--current:var( --color-sidebar-item-background );--color-sidebar-item-background--hover:linear-gradient(90deg,var(--color-background-hover--transparent) 0%,var(--color-background-hover) var(--sidebar-item-spacing-horizontal),var(--color-background-hover) 100%);--color-sidebar-item-expander-background:transparent;--color-sidebar-item-expander-background--hover:var( --color-background-hover );--color-sidebar-search-text:var(--color-foreground-primary);--color-sidebar-search-background:var(--color-background-secondary);--color-sidebar-search-background--focus:var(--color-background-primary);--color-sidebar-search-border:var(--color-background-border);--color-sidebar-search-icon:var(--color-foreground-muted);--color-toc-background:var(--color-background-primary);--color-toc-title-text:var(--color-foreground-muted);--color-toc-item-text:var(--color-foreground-secondary);--color-toc-item-text--hover:var(--color-foreground-primary);--color-toc-item-text--active:var(--color-brand-primary);--color-content-foreground:var(--color-foreground-primary);--color-content-background:transparent;--color-link:var(--color-brand-content);--color-link--hover:var(--color-brand-content);--color-link-underline:var(--color-background-border);--color-link-underline--hover:var(--color-foreground-border)}.only-light{display:block!important}html body .only-dark{display:none!important}@media not print{body[data-theme=dark]{--color-problematic:#ee5151;--color-foreground-primary:#ffffffcc;--color-foreground-secondary:#9ca0a5;--color-foreground-muted:#81868d;--color-foreground-border:#666;--color-background-primary:#131416;--color-background-secondary:#1a1c1e;--color-background-hover:#1e2124;--color-background-hover--transparent:#1e212400;--color-background-border:#303335;--color-background-item:#444;--color-announcement-background:#000000dd;--color-announcement-text:#eeebee;--color-brand-primary:#2b8cee;--color-brand-content:#368ce2;--color-highlighted-background:#083563;--color-guilabel-background:#08356380;--color-guilabel-border:#13395f80;--color-api-keyword:var(--color-foreground-secondary);--color-highlight-on-target:#330;--color-admonition-background:#18181a;--color-card-border:var(--color-background-secondary);--color-card-background:#18181a;--color-card-marginals-background:var(--color-background-hover)}html body[data-theme=dark] .only-light{display:none!important}body[data-theme=dark] .only-dark{display:block!important}@media(prefers-color-scheme:dark){body:not([data-theme=light]){--color-problematic:#ee5151;--color-foreground-primary:#ffffffcc;--color-foreground-secondary:#9ca0a5;--color-foreground-muted:#81868d;--color-foreground-border:#666;--color-background-primary:#131416;--color-background-secondary:#1a1c1e;--color-background-hover:#1e2124;--color-background-hover--transparent:#1e212400;--color-background-border:#303335;--color-background-item:#444;--color-announcement-background:#000000dd;--color-announcement-text:#eeebee;--color-brand-primary:#2b8cee;--color-brand-content:#368ce2;--color-highlighted-background:#083563;--color-guilabel-background:#08356380;--color-guilabel-border:#13395f80;--color-api-keyword:var(--color-foreground-secondary);--color-highlight-on-target:#330;--color-admonition-background:#18181a;--color-card-border:var(--color-background-secondary);--color-card-background:#18181a;--color-card-marginals-background:var(--color-background-hover)}html body:not([data-theme=light]) .only-light{display:none!important}body:not([data-theme=light]) .only-dark{display:block!important}}}body[data-theme=auto] .theme-toggle svg.theme-icon-when-auto,body[data-theme=dark] .theme-toggle svg.theme-icon-when-dark,body[data-theme=light] .theme-toggle svg.theme-icon-when-light{display:block}body{font-family:var(--font-stack)}code,kbd,pre,samp{font-family:var(--font-stack--monospace)}body{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}article{line-height:1.5}h1,h2,h3,h4,h5,h6{border-radius:.5rem;font-weight:700;line-height:1.25;margin:.5rem -.5rem;padding-left:.5rem;padding-right:.5rem}h1+p,h2+p,h3+p,h4+p,h5+p,h6+p{margin-top:0}h1{font-size:2.5em;margin-bottom:1rem}h1,h2{margin-top:1.75rem}h2{font-size:2em}h3{font-size:1.5em}h4{font-size:1.25em}h5{font-size:1.125em}h6{font-size:1em}small{font-size:80%;opacity:75%}p{margin-bottom:.75rem;margin-top:.5rem}hr.docutils{background-color:var(--color-background-border);border:0;height:1px;margin:2rem 0;padding:0}.centered{text-align:center}a{color:var(--color-link);text-decoration:underline;text-decoration-color:var(--color-link-underline)}a:hover{color:var(--color-link--hover);text-decoration-color:var(--color-link-underline--hover)}a.muted-link{color:inherit}a.muted-link:hover{color:var(--color-link);text-decoration-color:var(--color-link-underline--hover)}html{overflow-x:hidden;overflow-y:scroll;scroll-behavior:smooth}.sidebar-scroll,.toc-scroll,article[role=main] *{scrollbar-color:var(--color-foreground-border) transparent;scrollbar-width:thin}.sidebar-scroll::-webkit-scrollbar,.toc-scroll::-webkit-scrollbar,article[role=main] ::-webkit-scrollbar{height:.25rem;width:.25rem}.sidebar-scroll::-webkit-scrollbar-thumb,.toc-scroll::-webkit-scrollbar-thumb,article[role=main] ::-webkit-scrollbar-thumb{background-color:var(--color-foreground-border);border-radius:.125rem}body,html{background:var(--color-background-primary);color:var(--color-foreground-primary);height:100%}article{background:var(--color-content-background);color:var(--color-content-foreground);overflow-wrap:break-word}.page{display:flex;min-height:100%}.mobile-header{background-color:var(--color-header-background);border-bottom:1px solid var(--color-header-border);color:var(--color-header-text);display:none;height:var(--header-height);width:100%;z-index:10}.mobile-header.scrolled{border-bottom:none;box-shadow:0 0 .2rem rgba(0,0,0,.1),0 .2rem .4rem rgba(0,0,0,.2)}.mobile-header .header-center a{color:var(--color-header-text);text-decoration:none}.main{display:flex;flex:1}.sidebar-drawer{background:var(--color-sidebar-background);border-right:1px solid var(--color-sidebar-background-border);box-sizing:border-box;display:flex;justify-content:flex-end;min-width:15em;width:calc(50% - 26em)}.sidebar-container,.toc-drawer{box-sizing:border-box;width:15em}.toc-drawer{background:var(--color-toc-background);padding-right:1rem}.sidebar-sticky,.toc-sticky{display:flex;flex-direction:column;height:min(100%,100vh);height:100vh;position:sticky;top:0}.sidebar-scroll,.toc-scroll{flex-grow:1;flex-shrink:1;overflow:auto;scroll-behavior:smooth}.content{display:flex;flex-direction:column;justify-content:space-between;padding:0 3em;width:46em}.icon{display:inline-block;height:1rem;width:1rem}.icon svg{height:100%;width:100%}.announcement{align-items:center;background-color:var(--color-announcement-background);color:var(--color-announcement-text);display:flex;height:var(--header-height);overflow-x:auto}.announcement+.page{min-height:calc(100% - var(--header-height))}.announcement-content{box-sizing:border-box;min-width:100%;padding:.5rem;text-align:center;white-space:nowrap}.announcement-content a{color:var(--color-announcement-text);text-decoration-color:var(--color-announcement-text)}.announcement-content a:hover{color:var(--color-announcement-text);text-decoration-color:var(--color-link--hover)}.no-js .theme-toggle-container{display:none}.theme-toggle-container{vertical-align:middle}.theme-toggle{background:transparent;border:none;cursor:pointer;padding:0}.theme-toggle svg{color:var(--color-foreground-primary);display:none;height:1rem;vertical-align:middle;width:1rem}.theme-toggle-header{float:left;padding:1rem .5rem}.nav-overlay-icon,.toc-overlay-icon{cursor:pointer;display:none}.nav-overlay-icon .icon,.toc-overlay-icon .icon{color:var(--color-foreground-secondary);height:1rem;width:1rem}.nav-overlay-icon,.toc-header-icon{align-items:center;justify-content:center}.toc-content-icon{height:1.5rem;width:1.5rem}.content-icon-container{display:flex;float:right;gap:.5rem;margin-bottom:1rem;margin-left:1rem;margin-top:1.5rem}.content-icon-container .edit-this-page svg{color:inherit;height:1rem;width:1rem}.sidebar-toggle{display:none;position:absolute}.sidebar-toggle[name=__toc]{left:20px}.sidebar-toggle:checked{left:40px}.overlay{background-color:rgba(0,0,0,.54);height:0;opacity:0;position:fixed;top:0;transition:width 0ms,height 0ms,opacity .25s ease-out;width:0}.sidebar-overlay{z-index:20}.toc-overlay{z-index:40}.sidebar-drawer{transition:left .25s ease-in-out;z-index:30}.toc-drawer{transition:right .25s ease-in-out;z-index:50}#__navigation:checked~.sidebar-overlay{height:100%;opacity:1;width:100%}#__navigation:checked~.page .sidebar-drawer{left:0;top:0}#__toc:checked~.toc-overlay{height:100%;opacity:1;width:100%}#__toc:checked~.page .toc-drawer{right:0;top:0}.back-to-top{background:var(--color-background-primary);border-radius:1rem;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 1px 0 hsla(220,9%,46%,.502);display:none;font-size:.8125rem;left:0;margin-left:50%;padding:.5rem .75rem .5rem .5rem;position:fixed;text-decoration:none;top:1rem;transform:translateX(-50%);z-index:10}.back-to-top svg{fill:currentColor;display:inline-block;height:1rem;width:1rem}.back-to-top span{margin-left:.25rem}.show-back-to-top .back-to-top{align-items:center;display:flex}@media(min-width:97em){html{font-size:110%}}@media(max-width:82em){.toc-content-icon{display:flex}.toc-drawer{border-left:1px solid var(--color-background-muted);height:100vh;position:fixed;right:-15em;top:0}.toc-tree{border-left:none;font-size:var(--toc-font-size--mobile)}.sidebar-drawer{width:calc(50% - 18.5em)}}@media(max-width:67em){.nav-overlay-icon{display:flex}.sidebar-drawer{height:100vh;left:-15em;position:fixed;top:0;width:15em}.toc-header-icon{display:flex}.theme-toggle-content,.toc-content-icon{display:none}.theme-toggle-header{display:block}.mobile-header{align-items:center;display:flex;justify-content:space-between;position:sticky;top:0}.mobile-header .header-left,.mobile-header .header-right{display:flex;height:var(--header-height);padding:0 var(--header-padding)}.mobile-header .header-left label,.mobile-header .header-right label{height:100%;-webkit-user-select:none;-moz-user-select:none;user-select:none;width:100%}.nav-overlay-icon .icon,.theme-toggle svg{height:1.25rem;width:1.25rem}:target{scroll-margin-top:var(--header-height)}.back-to-top{top:calc(var(--header-height) + .5rem)}.page{flex-direction:column;justify-content:center}.content{margin-left:auto;margin-right:auto}}@media(max-width:52em){.content{overflow-x:auto;width:100%}}@media(max-width:46em){.content{padding:0 1em}article aside.sidebar{float:none;margin:1rem 0;width:100%}}.admonition,.topic{background:var(--color-admonition-background);border-radius:.2rem;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1);font-size:var(--admonition-font-size);margin:1rem auto;overflow:hidden;padding:0 .5rem .5rem;page-break-inside:avoid}.admonition>:nth-child(2),.topic>:nth-child(2){margin-top:0}.admonition>:last-child,.topic>:last-child{margin-bottom:0}.admonition p.admonition-title,p.topic-title{font-size:var(--admonition-title-font-size);font-weight:500;line-height:1.3;margin:0 -.5rem .5rem;padding:.4rem .5rem .4rem 2rem;position:relative}.admonition p.admonition-title:before,p.topic-title:before{content:"";height:1rem;left:.5rem;position:absolute;width:1rem}p.admonition-title{background-color:var(--color-admonition-title-background)}p.admonition-title:before{background-color:var(--color-admonition-title);-webkit-mask-image:var(--icon-admonition-default);mask-image:var(--icon-admonition-default);-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}p.topic-title{background-color:var(--color-topic-title-background)}p.topic-title:before{background-color:var(--color-topic-title);-webkit-mask-image:var(--icon-topic-default);mask-image:var(--icon-topic-default);-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.admonition{border-left:.2rem solid var(--color-admonition-title)}.admonition.caution{border-left-color:var(--color-admonition-title--caution)}.admonition.caution>.admonition-title{background-color:var(--color-admonition-title-background--caution)}.admonition.caution>.admonition-title:before{background-color:var(--color-admonition-title--caution);-webkit-mask-image:var(--icon-spark);mask-image:var(--icon-spark)}.admonition.warning{border-left-color:var(--color-admonition-title--warning)}.admonition.warning>.admonition-title{background-color:var(--color-admonition-title-background--warning)}.admonition.warning>.admonition-title:before{background-color:var(--color-admonition-title--warning);-webkit-mask-image:var(--icon-warning);mask-image:var(--icon-warning)}.admonition.danger{border-left-color:var(--color-admonition-title--danger)}.admonition.danger>.admonition-title{background-color:var(--color-admonition-title-background--danger)}.admonition.danger>.admonition-title:before{background-color:var(--color-admonition-title--danger);-webkit-mask-image:var(--icon-spark);mask-image:var(--icon-spark)}.admonition.attention{border-left-color:var(--color-admonition-title--attention)}.admonition.attention>.admonition-title{background-color:var(--color-admonition-title-background--attention)}.admonition.attention>.admonition-title:before{background-color:var(--color-admonition-title--attention);-webkit-mask-image:var(--icon-warning);mask-image:var(--icon-warning)}.admonition.error{border-left-color:var(--color-admonition-title--error)}.admonition.error>.admonition-title{background-color:var(--color-admonition-title-background--error)}.admonition.error>.admonition-title:before{background-color:var(--color-admonition-title--error);-webkit-mask-image:var(--icon-failure);mask-image:var(--icon-failure)}.admonition.hint{border-left-color:var(--color-admonition-title--hint)}.admonition.hint>.admonition-title{background-color:var(--color-admonition-title-background--hint)}.admonition.hint>.admonition-title:before{background-color:var(--color-admonition-title--hint);-webkit-mask-image:var(--icon-question);mask-image:var(--icon-question)}.admonition.tip{border-left-color:var(--color-admonition-title--tip)}.admonition.tip>.admonition-title{background-color:var(--color-admonition-title-background--tip)}.admonition.tip>.admonition-title:before{background-color:var(--color-admonition-title--tip);-webkit-mask-image:var(--icon-info);mask-image:var(--icon-info)}.admonition.important{border-left-color:var(--color-admonition-title--important)}.admonition.important>.admonition-title{background-color:var(--color-admonition-title-background--important)}.admonition.important>.admonition-title:before{background-color:var(--color-admonition-title--important);-webkit-mask-image:var(--icon-flame);mask-image:var(--icon-flame)}.admonition.note{border-left-color:var(--color-admonition-title--note)}.admonition.note>.admonition-title{background-color:var(--color-admonition-title-background--note)}.admonition.note>.admonition-title:before{background-color:var(--color-admonition-title--note);-webkit-mask-image:var(--icon-pencil);mask-image:var(--icon-pencil)}.admonition.seealso{border-left-color:var(--color-admonition-title--seealso)}.admonition.seealso>.admonition-title{background-color:var(--color-admonition-title-background--seealso)}.admonition.seealso>.admonition-title:before{background-color:var(--color-admonition-title--seealso);-webkit-mask-image:var(--icon-info);mask-image:var(--icon-info)}.admonition.admonition-todo{border-left-color:var(--color-admonition-title--admonition-todo)}.admonition.admonition-todo>.admonition-title{background-color:var(--color-admonition-title-background--admonition-todo)}.admonition.admonition-todo>.admonition-title:before{background-color:var(--color-admonition-title--admonition-todo);-webkit-mask-image:var(--icon-pencil);mask-image:var(--icon-pencil)}.admonition-todo>.admonition-title{text-transform:uppercase}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) dd{margin-left:2rem}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) dd>:first-child{margin-top:.125rem}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .field-list,dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) dd>:last-child{margin-bottom:.75rem}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .field-list>dt{font-size:var(--font-size--small);text-transform:uppercase}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .field-list dd:empty{margin-bottom:.5rem}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .field-list dd>ul{margin-left:-1.2rem}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .field-list dd>ul>li>p:nth-child(2){margin-top:0}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .field-list dd>ul>li>p+p:last-child:empty{margin-bottom:0;margin-top:0}dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple)>dt{color:var(--color-api-overall)}.sig:not(.sig-inline){background:var(--color-api-background);border-radius:.25rem;font-family:var(--font-stack--monospace);font-size:var(--api-font-size);font-weight:700;margin-left:-.25rem;margin-right:-.25rem;padding:.25rem .5rem .25rem 3em;text-indent:-2.5em;transition:background .1s ease-out}.sig:not(.sig-inline):hover{background:var(--color-api-background-hover)}.sig:not(.sig-inline) a.reference .viewcode-link{font-weight:400;width:3.5rem}em.property{font-style:normal}em.property:first-child{color:var(--color-api-keyword)}.sig-name{color:var(--color-api-name)}.sig-prename{color:var(--color-api-pre-name);font-weight:400}.sig-paren{color:var(--color-api-paren)}.sig-param{font-style:normal}.versionmodified{font-style:italic}div.deprecated p,div.versionadded p,div.versionchanged p{margin-bottom:.125rem;margin-top:.125rem}.viewcode-back,.viewcode-link{float:right;text-align:right}.line-block{margin-bottom:.75rem;margin-top:.5rem}.line-block .line-block{margin-bottom:0;margin-top:0;padding-left:1rem}.code-block-caption,article p.caption,table>caption{font-size:var(--font-size--small);text-align:center}.toctree-wrapper.compound .caption,.toctree-wrapper.compound :not(.caption)>.caption-text{font-size:var(--font-size--small);margin-bottom:0;text-align:initial;text-transform:uppercase}.toctree-wrapper.compound>ul{margin-bottom:0;margin-top:0}.sig-inline,code.literal{background:var(--color-inline-code-background);border-radius:.2em;font-size:var(--font-size--small--2);padding:.1em .2em}pre.literal-block .sig-inline,pre.literal-block code.literal{font-size:inherit;padding:0}p .sig-inline,p code.literal{border:1px solid var(--color-background-border)}.sig-inline{font-family:var(--font-stack--monospace)}div[class*=" highlight-"],div[class^=highlight-]{display:flex;margin:1em 0}div[class*=" highlight-"] .table-wrapper,div[class^=highlight-] .table-wrapper,pre{margin:0;padding:0}pre{overflow:auto}article[role=main] .highlight pre{line-height:1.5}.highlight pre,pre.literal-block{font-size:var(--code-font-size);padding:.625rem .875rem}pre.literal-block{background-color:var(--color-code-background);border-radius:.2rem;color:var(--color-code-foreground);margin-bottom:1rem;margin-top:1rem}.highlight{border-radius:.2rem;width:100%}.highlight .gp,.highlight span.linenos{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.highlight .hll{display:block;margin-left:-.875rem;margin-right:-.875rem;padding-left:.875rem;padding-right:.875rem}.code-block-caption{background-color:var(--color-code-background);border-bottom:1px solid;border-radius:.25rem;border-bottom-left-radius:0;border-bottom-right-radius:0;border-color:var(--color-background-border);color:var(--color-code-foreground);display:flex;font-weight:300;padding:.625rem .875rem}.code-block-caption+div[class]{margin-top:0}.code-block-caption+div[class] pre{border-top-left-radius:0;border-top-right-radius:0}.highlighttable{display:block;width:100%}.highlighttable tbody{display:block}.highlighttable tr{display:flex}.highlighttable td.linenos{background-color:var(--color-code-background);border-bottom-left-radius:.2rem;border-top-left-radius:.2rem;color:var(--color-code-foreground);padding:.625rem 0 .625rem .875rem}.highlighttable .linenodiv{box-shadow:-.0625rem 0 var(--color-foreground-border) inset;font-size:var(--code-font-size);padding-right:.875rem}.highlighttable td.code{display:block;flex:1;overflow:hidden;padding:0}.highlighttable td.code .highlight{border-bottom-left-radius:0;border-top-left-radius:0}.highlight span.linenos{box-shadow:-.0625rem 0 var(--color-foreground-border) inset;display:inline-block;margin-right:.875rem;padding-left:0;padding-right:.875rem}.footnote-reference{font-size:var(--font-size--small--4);vertical-align:super}dl.footnote.brackets{color:var(--color-foreground-secondary);display:grid;font-size:var(--font-size--small);grid-template-columns:max-content auto}dl.footnote.brackets dt{margin:0}dl.footnote.brackets dt>.fn-backref{margin-left:.25rem}dl.footnote.brackets dt:after{content:":"}dl.footnote.brackets dt .brackets:before{content:"["}dl.footnote.brackets dt .brackets:after{content:"]"}dl.footnote.brackets dd{margin:0;padding:0 1rem}aside.footnote{color:var(--color-foreground-secondary);font-size:var(--font-size--small)}aside.footnote>span,div.citation>span{float:left;font-weight:500;padding-right:.25rem}aside.footnote>p,div.citation>p{margin-left:2rem}img{box-sizing:border-box;height:auto;max-width:100%}article .figure,article figure{border-radius:.2rem;margin:0}article .figure :last-child,article figure :last-child{margin-bottom:0}article .align-left{clear:left;float:left;margin:0 1rem 1rem}article .align-right{clear:right;float:right;margin:0 1rem 1rem}article .align-center,article .align-default{display:block;margin-left:auto;margin-right:auto;text-align:center}article table.align-default{display:table;text-align:initial}.domainindex-jumpbox,.genindex-jumpbox{border-bottom:1px solid var(--color-background-border);border-top:1px solid var(--color-background-border);padding:.25rem}.domainindex-section h2,.genindex-section h2{margin-bottom:.5rem;margin-top:.75rem}.domainindex-section ul,.genindex-section ul{margin-bottom:0;margin-top:0}ol,ul{margin-bottom:1rem;margin-top:1rem;padding-left:1.2rem}ol li>p:first-child,ul li>p:first-child{margin-bottom:.25rem;margin-top:.25rem}ol li>p:last-child,ul li>p:last-child{margin-top:.25rem}ol li>ol,ol li>ul,ul li>ol,ul li>ul{margin-bottom:.5rem;margin-top:.5rem}ol.arabic{list-style:decimal}ol.loweralpha{list-style:lower-alpha}ol.upperalpha{list-style:upper-alpha}ol.lowerroman{list-style:lower-roman}ol.upperroman{list-style:upper-roman}.simple li>ol,.simple li>ul,.toctree-wrapper li>ol,.toctree-wrapper li>ul{margin-bottom:0;margin-top:0}.field-list dt,.option-list dt,dl.footnote dt,dl.glossary dt,dl.simple dt,dl:not([class]) dt{font-weight:500;margin-top:.25rem}.field-list dt+dt,.option-list dt+dt,dl.footnote dt+dt,dl.glossary dt+dt,dl.simple dt+dt,dl:not([class]) dt+dt{margin-top:0}.field-list dt .classifier:before,.option-list dt .classifier:before,dl.footnote dt .classifier:before,dl.glossary dt .classifier:before,dl.simple dt .classifier:before,dl:not([class]) dt .classifier:before{content:":";margin-left:.2rem;margin-right:.2rem}.field-list dd ul,.field-list dd>p:first-child,.option-list dd ul,.option-list dd>p:first-child,dl.footnote dd ul,dl.footnote dd>p:first-child,dl.glossary dd ul,dl.glossary dd>p:first-child,dl.simple dd ul,dl.simple dd>p:first-child,dl:not([class]) dd ul,dl:not([class]) dd>p:first-child{margin-top:.125rem}.field-list dd ul,.option-list dd ul,dl.footnote dd ul,dl.glossary dd ul,dl.simple dd ul,dl:not([class]) dd ul{margin-bottom:.125rem}.math-wrapper{overflow-x:auto;width:100%}div.math{position:relative;text-align:center}div.math .headerlink,div.math:focus .headerlink{display:none}div.math:hover .headerlink{display:inline-block}div.math span.eqno{position:absolute;right:.5rem;top:50%;transform:translateY(-50%);z-index:1}abbr[title]{cursor:help}.problematic{color:var(--color-problematic)}kbd:not(.compound){background-color:var(--color-background-secondary);border:1px solid var(--color-foreground-border);border-radius:.2rem;box-shadow:0 .0625rem 0 rgba(0,0,0,.2),inset 0 0 0 .125rem var(--color-background-primary);color:var(--color-foreground-primary);display:inline-block;font-size:var(--font-size--small--3);margin:0 .2rem;padding:0 .2rem;vertical-align:text-bottom}blockquote{background:var(--color-background-secondary);border-left:4px solid var(--color-background-border);margin-left:0;margin-right:0;padding:.5rem 1rem}blockquote .attribution{font-weight:600;text-align:right}blockquote.highlights,blockquote.pull-quote{font-size:1.25em}blockquote.epigraph,blockquote.pull-quote{border-left-width:0;border-radius:.5rem}blockquote.highlights{background:transparent;border-left-width:0}p .reference img{vertical-align:middle}p.rubric{font-size:1.125em;font-weight:700;line-height:1.25}dd p.rubric{font-size:var(--font-size--small);font-weight:inherit;line-height:inherit;text-transform:uppercase}article .sidebar{background-color:var(--color-background-secondary);border:1px solid var(--color-background-border);border-radius:.2rem;clear:right;float:right;margin-left:1rem;margin-right:0;width:30%}article .sidebar>*{padding-left:1rem;padding-right:1rem}article .sidebar>ol,article .sidebar>ul{padding-left:2.2rem}article .sidebar .sidebar-title{border-bottom:1px solid var(--color-background-border);font-weight:500;margin:0;padding:.5rem 1rem}.table-wrapper{margin-bottom:.5rem;margin-top:1rem;overflow-x:auto;padding:.2rem .2rem .75rem;width:100%}table.docutils{border-collapse:collapse;border-radius:.2rem;border-spacing:0;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1)}table.docutils th{background:var(--color-table-header-background)}table.docutils td,table.docutils th{border-bottom:1px solid var(--color-table-border);border-left:1px solid var(--color-table-border);border-right:1px solid var(--color-table-border);padding:0 .25rem}table.docutils td p,table.docutils th p{margin:.25rem}table.docutils td:first-child,table.docutils th:first-child{border-left:none}table.docutils td:last-child,table.docutils th:last-child{border-right:none}table.docutils td.text-left,table.docutils th.text-left{text-align:left}table.docutils td.text-right,table.docutils th.text-right{text-align:right}table.docutils td.text-center,table.docutils th.text-center{text-align:center}:target{scroll-margin-top:.5rem}@media(max-width:67em){:target{scroll-margin-top:calc(.5rem + var(--header-height))}section>span:target{scroll-margin-top:calc(.8rem + var(--header-height))}}.headerlink{font-weight:100;-webkit-user-select:none;-moz-user-select:none;user-select:none}.code-block-caption>.headerlink,dl dt>.headerlink,figcaption p>.headerlink,h1>.headerlink,h2>.headerlink,h3>.headerlink,h4>.headerlink,h5>.headerlink,h6>.headerlink,p.caption>.headerlink,table>caption>.headerlink{margin-left:.5rem;visibility:hidden}.code-block-caption:hover>.headerlink,dl dt:hover>.headerlink,figcaption p:hover>.headerlink,h1:hover>.headerlink,h2:hover>.headerlink,h3:hover>.headerlink,h4:hover>.headerlink,h5:hover>.headerlink,h6:hover>.headerlink,p.caption:hover>.headerlink,table>caption:hover>.headerlink{visibility:visible}.code-block-caption>.toc-backref,dl dt>.toc-backref,figcaption p>.toc-backref,h1>.toc-backref,h2>.toc-backref,h3>.toc-backref,h4>.toc-backref,h5>.toc-backref,h6>.toc-backref,p.caption>.toc-backref,table>caption>.toc-backref{color:inherit;text-decoration-line:none}figure:hover>figcaption>p>.headerlink,table:hover>caption>.headerlink{visibility:visible}:target>h1:first-of-type,:target>h2:first-of-type,:target>h3:first-of-type,:target>h4:first-of-type,:target>h5:first-of-type,:target>h6:first-of-type,span:target~h1:first-of-type,span:target~h2:first-of-type,span:target~h3:first-of-type,span:target~h4:first-of-type,span:target~h5:first-of-type,span:target~h6:first-of-type{background-color:var(--color-highlight-on-target)}:target>h1:first-of-type code.literal,:target>h2:first-of-type code.literal,:target>h3:first-of-type code.literal,:target>h4:first-of-type code.literal,:target>h5:first-of-type code.literal,:target>h6:first-of-type code.literal,span:target~h1:first-of-type code.literal,span:target~h2:first-of-type code.literal,span:target~h3:first-of-type code.literal,span:target~h4:first-of-type code.literal,span:target~h5:first-of-type code.literal,span:target~h6:first-of-type code.literal{background-color:transparent}.literal-block-wrapper:target .code-block-caption,.this-will-duplicate-information-and-it-is-still-useful-here li :target,figure:target,table:target>caption{background-color:var(--color-highlight-on-target)}dt:target{background-color:var(--color-highlight-on-target)!important}.footnote-reference:target,.footnote>dt:target+dd{background-color:var(--color-highlight-on-target)}.guilabel{background-color:var(--color-guilabel-background);border:1px solid var(--color-guilabel-border);border-radius:.5em;color:var(--color-guilabel-text);font-size:.9em;padding:0 .3em}footer{display:flex;flex-direction:column;font-size:var(--font-size--small);margin-top:2rem}.bottom-of-page{align-items:center;border-top:1px solid var(--color-background-border);color:var(--color-foreground-secondary);display:flex;justify-content:space-between;line-height:1.5;margin-top:1rem;padding-bottom:1rem;padding-top:1rem}@media(max-width:46em){.bottom-of-page{flex-direction:column-reverse;gap:.25rem;text-align:center}}.bottom-of-page .left-details{font-size:var(--font-size--small)}.bottom-of-page .right-details{display:flex;flex-direction:column;gap:.25rem;text-align:right}.bottom-of-page .icons{display:flex;font-size:1rem;gap:.25rem;justify-content:flex-end}.bottom-of-page .icons a{text-decoration:none}.bottom-of-page .icons img,.bottom-of-page .icons svg{font-size:1.125rem;height:1em;width:1em}.related-pages a{align-items:center;display:flex;text-decoration:none}.related-pages a:hover .page-info .title{color:var(--color-link);text-decoration:underline;text-decoration-color:var(--color-link-underline)}.related-pages a svg.furo-related-icon,.related-pages a svg.furo-related-icon>use{color:var(--color-foreground-border);flex-shrink:0;height:.75rem;margin:0 .5rem;width:.75rem}.related-pages a.next-page{clear:right;float:right;max-width:50%;text-align:right}.related-pages a.prev-page{clear:left;float:left;max-width:50%}.related-pages a.prev-page svg{transform:rotate(180deg)}.page-info{display:flex;flex-direction:column;overflow-wrap:anywhere}.next-page .page-info{align-items:flex-end}.page-info .context{align-items:center;color:var(--color-foreground-muted);display:flex;font-size:var(--font-size--small);padding-bottom:.1rem;text-decoration:none}ul.search{list-style:none;padding-left:0}ul.search li{border-bottom:1px solid var(--color-background-border);padding:1rem 0}[role=main] .highlighted{background-color:var(--color-highlighted-background);color:var(--color-highlighted-text)}.sidebar-brand{display:flex;flex-direction:column;flex-shrink:0;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);text-decoration:none}.sidebar-brand-text{color:var(--color-sidebar-brand-text);font-size:1.5rem;overflow-wrap:break-word}.sidebar-brand-text,.sidebar-logo-container{margin:var(--sidebar-item-spacing-vertical) 0}.sidebar-logo{display:block;margin:0 auto;max-width:100%}.sidebar-search-container{align-items:center;background:var(--color-sidebar-search-background);display:flex;margin-top:var(--sidebar-search-space-above);position:relative}.sidebar-search-container:focus-within,.sidebar-search-container:hover{background:var(--color-sidebar-search-background--focus)}.sidebar-search-container:before{background-color:var(--color-sidebar-search-icon);content:"";height:var(--sidebar-search-icon-size);left:var(--sidebar-item-spacing-horizontal);-webkit-mask-image:var(--icon-search);mask-image:var(--icon-search);position:absolute;width:var(--sidebar-search-icon-size)}.sidebar-search{background:transparent;border:none;border-bottom:1px solid var(--color-sidebar-search-border);border-top:1px solid var(--color-sidebar-search-border);box-sizing:border-box;color:var(--color-sidebar-search-foreground);padding:var(--sidebar-search-input-spacing-vertical) var(--sidebar-search-input-spacing-horizontal) var(--sidebar-search-input-spacing-vertical) calc(var(--sidebar-item-spacing-horizontal) + var(--sidebar-search-input-spacing-horizontal) + var(--sidebar-search-icon-size));width:100%;z-index:10}.sidebar-search:focus{outline:none}.sidebar-search::-moz-placeholder{font-size:var(--sidebar-search-input-font-size)}.sidebar-search::placeholder{font-size:var(--sidebar-search-input-font-size)}#searchbox .highlight-link{margin:0;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal) 0;text-align:center}#searchbox .highlight-link a{color:var(--color-sidebar-search-icon);font-size:var(--font-size--small--2)}.sidebar-tree{font-size:var(--sidebar-item-font-size);margin-bottom:var(--sidebar-item-spacing-vertical);margin-top:var(--sidebar-tree-space-above)}.sidebar-tree ul{display:flex;flex-direction:column;list-style:none;margin-bottom:0;margin-top:0;padding:0}.sidebar-tree li{margin:0;position:relative}.sidebar-tree li>ul{margin-left:var(--sidebar-item-spacing-horizontal)}.sidebar-tree .icon,.sidebar-tree .reference{color:var(--color-sidebar-link-text)}.sidebar-tree .reference{box-sizing:border-box;display:inline-block;height:100%;line-height:var(--sidebar-item-line-height);overflow-wrap:anywhere;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);text-decoration:none;width:100%}.sidebar-tree .reference:hover{background:var(--color-sidebar-item-background--hover)}.sidebar-tree .reference.external:after{color:var(--color-sidebar-link-text);content:url("data:image/svg+xml;charset=utf-8,%3Csvg width='12' height='12' xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' stroke-width='1.5' stroke='%23607D8B' fill='none' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M0 0h24v24H0z' stroke='none'/%3E%3Cpath d='M11 7H6a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h9a2 2 0 0 0 2-2v-5M10 14 20 4M15 4h5v5'/%3E%3C/svg%3E");margin:0 .25rem;vertical-align:middle}.sidebar-tree .current-page>.reference{font-weight:700}.sidebar-tree label{align-items:center;cursor:pointer;display:flex;height:var(--sidebar-item-height);justify-content:center;position:absolute;right:0;top:0;-webkit-user-select:none;-moz-user-select:none;user-select:none;width:var(--sidebar-expander-width)}.sidebar-tree .caption,.sidebar-tree :not(.caption)>.caption-text{color:var(--color-sidebar-caption-text);font-size:var(--sidebar-caption-font-size);font-weight:700;margin:var(--sidebar-caption-space-above) 0 0 0;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);text-transform:uppercase}.sidebar-tree li.has-children>.reference{padding-right:var(--sidebar-expander-width)}.sidebar-tree .toctree-l1>.reference,.sidebar-tree .toctree-l1>label .icon{color:var(--color-sidebar-link-text--top-level)}.sidebar-tree label{background:var(--color-sidebar-item-expander-background)}.sidebar-tree label:hover{background:var(--color-sidebar-item-expander-background--hover)}.sidebar-tree .current>.reference{background:var(--color-sidebar-item-background--current)}.sidebar-tree .current>.reference:hover{background:var(--color-sidebar-item-background--hover)}.toctree-checkbox{display:none;position:absolute}.toctree-checkbox~ul{display:none}.toctree-checkbox~label .icon svg{transform:rotate(90deg)}.toctree-checkbox:checked~ul{display:block}.toctree-checkbox:checked~label .icon svg{transform:rotate(-90deg)}.toc-title-container{padding:var(--toc-title-padding);padding-top:var(--toc-spacing-vertical)}.toc-title{color:var(--color-toc-title-text);font-size:var(--toc-title-font-size);padding-left:var(--toc-spacing-horizontal);text-transform:uppercase}.no-toc{display:none}.toc-tree-container{padding-bottom:var(--toc-spacing-vertical)}.toc-tree{border-left:1px solid var(--color-background-border);font-size:var(--toc-font-size);line-height:1.3;padding-left:calc(var(--toc-spacing-horizontal) - var(--toc-item-spacing-horizontal))}.toc-tree>ul>li:first-child{padding-top:0}.toc-tree>ul>li:first-child>ul{padding-left:0}.toc-tree>ul>li:first-child>a{display:none}.toc-tree ul{list-style-type:none;margin-bottom:0;margin-top:0;padding-left:var(--toc-item-spacing-horizontal)}.toc-tree li{padding-top:var(--toc-item-spacing-vertical)}.toc-tree li.scroll-current>.reference{color:var(--color-toc-item-text--active);font-weight:700}.toc-tree .reference{color:var(--color-toc-item-text);overflow-wrap:anywhere;text-decoration:none}.toc-scroll{max-height:100vh;overflow-y:scroll}.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here){background:rgba(255,0,0,.25);color:var(--color-problematic)}.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here):before{content:"ERROR: Adding a table of contents in Furo-based documentation is unnecessary, and does not work well with existing styling.Add a 'this-will-duplicate-information-and-it-is-still-useful-here' class, if you want an escape hatch."}.text-align\:left>p{text-align:left}.text-align\:center>p{text-align:center}.text-align\:right>p{text-align:right} +/*# sourceMappingURL=furo.css.map*/ \ No newline at end of file diff --git a/_static/styles/furo.css.map b/_static/styles/furo.css.map new file mode 100644 index 0000000..1924b33 --- /dev/null +++ b/_static/styles/furo.css.map @@ -0,0 +1 @@ +{"version":3,"file":"styles/furo.css","mappings":"AAAA,2EAA2E,CAU3E,KAEE,6BAA8B,CAD9B,gBAEF,CASA,KACE,QACF,CAMA,KACE,aACF,CAOA,GACE,aAAc,CACd,cACF,CAUA,GACE,sBAAuB,CACvB,QAAS,CACT,gBACF,CAOA,IACE,+BAAiC,CACjC,aACF,CASA,EACE,4BACF,CAOA,YACE,kBAAmB,CACnB,yBAA0B,CAC1B,gCACF,CAMA,SAEE,kBACF,CAOA,cAGE,+BAAiC,CACjC,aACF,CAeA,QAEE,aAAc,CACd,aAAc,CACd,iBAAkB,CAClB,uBACF,CAEA,IACE,aACF,CAEA,IACE,SACF,CASA,IACE,iBACF,CAUA,sCAKE,mBAAoB,CACpB,cAAe,CACf,gBAAiB,CACjB,QACF,CAOA,aAEE,gBACF,CAOA,cAEE,mBACF,CAMA,gDAIE,yBACF,CAMA,wHAIE,iBAAkB,CAClB,SACF,CAMA,4GAIE,6BACF,CAMA,SACE,0BACF,CASA,OACE,qBAAsB,CACtB,aAAc,CACd,aAAc,CACd,cAAe,CACf,SAAU,CACV,kBACF,CAMA,SACE,uBACF,CAMA,SACE,aACF,CAOA,6BAEE,qBAAsB,CACtB,SACF,CAMA,kFAEE,WACF,CAOA,cACE,4BAA6B,CAC7B,mBACF,CAMA,yCACE,uBACF,CAOA,6BACE,yBAA0B,CAC1B,YACF,CASA,QACE,aACF,CAMA,QACE,iBACF,CAiBA,kBACE,YACF,CCvVA,aAcE,kEACE,uBAOF,WACE,iDAMF,gCACE,wBAEF,qCAEE,uBADA,uBACA,CAEF,SACE,wBAtBA,CCpBJ,iBAOE,6BAEA,mBANA,qBAEA,sBACA,0BAFA,oBAHA,4BAOA,6BANA,mBAOA,CAEF,gBACE,aCPF,KCGE,mHAEA,wGAGA,wBAAyB,CACzB,wBAAyB,CACzB,4BAA6B,CAC7B,yBAA0B,CAC1B,2BAA4B,CAG5B,sDAAuD,CACvD,gDAAiD,CACjD,wDAAyD,CAGzD,0CAA2C,CAC3C,gDAAiD,CACjD,gDAAiD,CAKjD,gCAAiC,CACjC,sCAAuC,CAGvC,2CAA4C,CAG5C,uCAAwC,CChCxC,+FAGA,uBAAwB,CAGxB,iCAAkC,CAClC,kCAAmC,CAEnC,+BAAgC,CAChC,sCAAuC,CACvC,sCAAuC,CACvC,qGAIA,mDAAoD,CAEpD,mCAAoC,CACpC,8CAA+C,CAC/C,gDAAiD,CACjD,kCAAmC,CACnC,6DAA8D,CAG9D,6BAA8B,CAC9B,6BAA8B,CAC9B,+BAAgC,CAChC,kCAAmC,CACnC,kCAAmC,CCPjC,ukBCYA,srCAZF,kaCVA,mLAOA,oTAWA,2UAaA,0CACA,gEACA,0CAGA,gEAUA,yCACA,+DAGA,4CACA,CACA,iEAGA,sGACA,uCACA,4DAGA,sCACA,2DAEA,4CACA,kEACA,oGACA,CAEA,0GACA,+CAGA,+MAOA,+EACA,wCAIA,4DACA,sEACA,kEACA,sEACA,gDAGA,+DACA,0CACA,gEACA,gGACA,CAGA,2DACA,qDAGA,0CACA,8CACA,oDACA,oDL7GF,iCAEA,iEAME,oCKyGA,yDAIA,sCACA,kCACA,sDAGA,0CACA,kEACA,oDAEA,sDAGA,oCACA,oEAIA,CAGA,yDAGA,qDACA,oDAGA,6DAIA,iEAGA,2DAEA,2DL9IE,4DAEA,gEAIF,gEKgGA,gFAIA,oNAOA,qDAEA,gFAIA,4DAIA,oEAMA,yEAIA,6DACA,0DAGA,uDAGA,qDAEA,wDLpII,6DAEA,yDACE,2DAMN,uCAIA,yCACE,8CAGF,sDMjDA,6DAKA,oCAIA,4CACA,kBAGF,sBAMA,2BAME,qCAGA,qCAEA,iCAEA,+BAEA,mCAEA,qCAIA,CACA,gCACA,gDAKA,kCAIA,6BAEA,0CAQA,kCAIF,8BAGE,8BACA,uCAGF,sCAKE,kCAEA,sDAGA,iCACE,CACA,2FAGA,gCACE,CACA,+DCzEJ,wCAEA,sBAEF,yDAEE,mCACA,wDAGA,2GAGA,wIACE,gDAMJ,kCAGE,6BACA,0CAGA,gEACA,8BACA,uCAKA,sCAIA,kCACA,sDACA,iCACA,sCAOA,sDAKE,gGAIE,+CAGN,sBAEE,yCAMA,0BAOA,yLAKA,aACA,MAEF,6BACE,mBAEA,wCAEF,wCAIE,kCAGA,SACA,kCAKA,mBAGA,CAJA,eACA,CAHF,gBAEE,CAWA,mBACA,mBACA,mDAIA,YACA,mBACA,CAEE,kBAMF,OAPE,kBAOF,oCACA,yCAEA,wBAEA,cADA,WACA,GACA,oBACA,CAFA,gBAEA,aAGF,+CAEE,UAJE,wBAEJ,CAFI,SAIF,CACA,2BACA,GAGA,uBACE,CAJF,yBAGA,CACE,iDACA,uCAEA,yDACE,cACA,wDAKN,yDAIE,uBAEF,kBACE,uBAEA,kDAKA,0DAEA,CAHA,oBAIA,0GAWA,aAEA,CAHA,YAGA,4HAKF,+CAGE,sBAEF,WAKE,0CAGA,CANA,qCAGA,CAJA,WAOA,SAIA,0CACE,CALF,qCAIA,CACE,wBAEA,mBAEJ,gBACE,gBAIA,+CAKF,CAIE,kDAEA,CANF,8BAIE,CAEA,YAGA,CAfF,2BACE,CAHA,UAEF,CAYE,UAGA,2CACF,iEAOE,iCACA,8BAGA,wCAIA,wBAMI,0CAKF,CATA,6DAGA,CALF,qBAEE,CASA,YACA,yBAGA,CAEE,cAKN,CAPI,sBAOJ,gCAGE,qBAEA,WACA,aACA,sCAEA,mBACA,6BAGA,uEADA,qBACA,6BAIA,yBACA,qCAEE,UAEA,YACA,sBAEF,8BAGA,CAPE,aACA,WAMF,4BACE,sBACA,WAMJ,uBACE,cAYE,mBAXA,qDAKA,qCAGA,CAEA,YACA,CAHA,2BAEA,CACA,oCAEA,4CACA,uBAIA,sBAEJ,eAFI,cAIF,iBACE,CAHJ,kBAGI,yBAEA,oCAIA,qDAMF,mEAGE,+CAKA,gCAEA,qCAGA,oCAGE,sBACA,CAJF,WAEE,CAFF,eAEE,SAEA,mBACA,qCACE,aACA,CAFF,YADA,qBACA,WAEE,sBACA,kEAEN,cAEE,CAFF,YAEE,iDAKA,uCAIA,2DAKA,kBAEA,CAHA,sBAGA,mBACA,0BAEJ,yBAII,aADA,WACA,CAMF,UAFE,kBAEF,CAJF,gBAEI,CAFJ,iBAIE,6CC9ZF,yBACE,WACA,iBAEA,aAFA,iBAEA,6BAEA,kCACA,mBAKA,gCAGA,CARA,QAEA,CAGA,UALA,qBAEA,qDAGA,CALA,OAQA,4BACE,cAGF,2BACE,gCAEJ,CAHE,UAGF,8CAGE,CAHF,UAGE,wCAGA,qBACA,CAFA,UAEA,6CAGA,yCAIA,sBAHA,UAGA,kCACE,OACA,CADA,KACA,cAQF,0CACE,CAFF,kBACA,CACE,wEACA,CARA,YACA,CAKF,mBAFF,MACE,CAIE,gBAJF,iCAJE,cAGJ,CANI,oBAEA,CAKF,SAIE,2BADA,UACA,kBAGF,sCACA,CAFF,WACE,WACA,mBACE,kDACA,0EACA,uDAKJ,aACE,mDAII,CAJJ,6CAII,4BACA,sCACE,kEACA,+CACE,aACA,WADA,+BACA,uEANN,YACE,mDAEE,mBADF,0CACE,CADF,qBACE,0DACA,YACE,4DACA,sEANN,YACE,8CACA,kBADA,UACA,2CACE,2EACA,cACE,kEACA,mEANN,yBACE,4DACA,sBACE,+EAEE,iEACA,qEANN,sCACE,CAGE,iBAHF,gBAGE,qBACE,CAJJ,uBACA,gDACE,wDACA,6DAHF,2CACA,CADA,gBACA,eACE,CAGE,sBANN,8BACE,CAII,iBAFF,4DACA,WACE,YADF,uCACE,6EACA,2BANN,8CACE,kDACA,0CACE,8BACA,yFACE,sBACA,sFALJ,mEACA,sBACE,kEACA,6EACE,uCACA,kEALJ,qGAEE,kEACA,6EACE,uCACA,kEALJ,8CACA,uDACE,sEACA,2EACE,sCACA,iEALJ,mGACA,qCACE,oDACA,0DACE,6GACA,gDAGR,yDCrEA,sEACE,CACA,6GACE,gEACF,iGAIF,wFACE,qDAGA,mGAEE,2CAEF,4FACE,gCACF,wGACE,8DAEE,6FAIA,iJAKN,6GACE,gDAKF,yDACA,qCAGA,6BACA,kBACA,qDAKA,oCAEA,+DAGA,2CAGE,oDAIA,oEAEE,qBAGJ,wDAEE,uCAEF,kEAGA,8CAEA,uDAKA,oCAEA,yDAEE,gEAKF,+CC5FA,0EAGE,CACA,qDCLJ,+DAIE,sCAIA,kEACE,yBACA,2FAMA,gBACA,yGCbF,mBAOA,2MAIA,4HAYA,0DACE,8GAYF,8HAQE,mBAEA,6HAOF,YAGA,mIAME,eACA,CAFF,YAEE,4FAMJ,8BAEE,uBAYA,sCAEE,CAJF,oBAEA,CARA,wCAEA,CAHA,8BACA,CAFA,eACA,CAGA,wCAEA,CAEA,mDAIE,kCACE,6BACA,4CAKJ,kDAIA,eACE,aAGF,8BACE,uDACA,sCACA,cAEA,+BACA,CAFA,eAEA,wCAEF,YACE,iBACA,mCACA,0DAGF,qBAEE,CAFF,kBAEE,+BAIA,yCAEE,qBADA,gBACA,yBAKF,eACA,CAFF,YACE,CACA,iBACA,qDAEA,mDCvIJ,2FAOE,iCACA,CAEA,eACA,CAHA,kBAEA,CAFA,wBAGA,8BACA,eACE,CAFF,YAEE,0BACA,8CAGA,oBACE,oCAGA,kBACE,8DAEA,iBAEN,UACE,8BAIJ,+CAEE,qDAEF,kDAIE,YAEF,CAFE,YAEF,CCjCE,mFAJA,QACA,UAIE,CADF,iBACE,mCAGA,iDACE,+BAGF,wBAEA,mBAKA,6CAEF,CAHE,mBACA,CAEF,kCAIE,CARA,kBACA,CAFF,eASE,YACA,mBAGF,CAJE,UAIF,wCCjCA,oBDmCE,wBCpCJ,uCACE,8BACA,4CACA,oBAGA,2CCAA,6CAGE,CAPF,uBAIA,CDGA,gDACE,6BCVJ,CAWM,2CAEF,CAJA,kCAEE,CDJF,aCLF,gBDKE,uBCMA,gCAGA,gDAGE,wBAGJ,0BAEA,iBACE,aACF,CADE,UACF,uBACE,aACF,oBACE,YACF,4BACE,6CAMA,CAYF,6DAZE,mCAGE,iCASJ,4BAGE,4DADA,+BACA,CAFA,qBAEA,yBACE,aAEF,wBAHA,SAGA,iHACE,2DAKF,CANA,yCACE,CADF,oCAMA,uSAIA,sGACE,oDChEJ,WAEF,yBACE,QACA,eAEA,gBAEE,uCAGA,CALF,iCAKE,uCAGA,0BACA,CACA,oBACA,iCClBJ,gBACE,KAGF,qBACE,YAGF,CAHE,cAGF,gCAEE,mBACA,iEAEA,oCACA,wCAEA,sBACA,WAEA,CAFA,YAEA,8EAEA,mCAFA,iBAEA,6BAIA,wEAKA,sDAIE,CARF,mDAIA,CAIE,cAEF,8CAIA,oBAFE,iBAEF,8CAGE,eAEF,CAFE,YAEF,OAEE,kBAGJ,CAJI,eACA,CAFF,mBAKF,yCCjDE,oBACA,CAFA,iBAEA,uCAKE,iBACA,qCAGA,mBCZJ,CDWI,gBCXJ,6BAEE,eACA,sBAGA,eAEA,sBACA,oDACA,iGAMA,gBAFE,YAEF,8FAME,iJClBF,YACA,gNAUE,6BAEF,oTAcI,kBACF,gHAIA,qBACE,eACF,qDACE,kBACF,6DACE,4BCxCJ,oBAEF,qCAEI,+CAGF,uBACE,uDAGJ,oBAkBE,mDAhBA,+CAaA,CAbA,oBAaA,0FAEE,CAFF,gGAbA,+BAaA,0BAGA,mQAIA,oNAEE,iBAGJ,CAHI,gBADA,gBAIJ,8CAYI,CAZJ,wCAYI,sVACE,iCAGA,uEAHA,QAGA,qXAKJ,iDAGF,CARM,+CACE,iDAIN,CALI,gBAQN,mHACE,gBAGF,2DACE,0EAOA,0EAKA,6EC/EA,iDACA,gCACA,oDAGA,qBACA,oDCFA,cACA,eAEA,yBAGF,sBAEE,iBACA,sNAWA,iBACE,kBACA,wRAgBA,kBAEA,iOAgBA,uCACE,uEAEA,kBAEF,qUAuBE,iDAIJ,CACA,geCxFF,4BAEE,CAQA,6JACA,iDAIA,sEAGA,mDAOF,iDAGE,4DAIA,8CACA,qDAEE,eAFF,cAEE,oBAEF,uBAFE,kCAGA,eACA,iBACA,mBAIA,mDACA,CAHA,uCAEA,CAJA,0CACA,CAIA,gBAJA,gBACA,oBADA,gBAIA,wBAEJ,gBAGE,6BACA,YAHA,iBAGA,gCACA,iEAEA,6CACA,sDACA,0BADA,wBACA,0BACA,oIAIA,mBAFA,YAEA,qBACA,0CAIE,uBAEF,CAHA,yBACE,CAEF,iDACE,mFAKJ,oCACE,CANE,aAKJ,CACE,qEAIA,YAFA,WAEA,CAHA,aACA,CAEA,gBACE,4BACA,sBADA,aACA,gCAMF,oCACA,yDACA,2CAEA,qBAGE,kBAEA,CACA,mCAIF,CARE,YACA,CAOF,iCAEE,CAPA,oBACA,CAQA,oBACE,uDAEJ,sDAGA,CAHA,cAGA,0BACE,oDAIA,oCACA,4BACA,sBAGA,cAEA,oFAGA,sBAEA,yDACE,CAIA,iBAJA,wBAIA,6CAJA,6CAOA,4BAGJ,CAHI,cAGJ,yCAGA,kBACE,CAIA,iDAEA,CATA,YAEF,CACE,4CAGA,kBAIA,wEAEA,wDAIF,kCAOE,iDACA,CARF,WAIE,sCAGA,CANA,2CACA,CAMA,oEARF,iBACE,CACA,qCAMA,iBAuBE,uBAlBF,YAKA,2DALA,uDAKA,CALA,sBAiBA,4CACE,CALA,gRAIF,YACE,UAEN,uBACE,YACA,mCAOE,+CAGA,8BAGF,+CAGA,4BCjNA,SDiNA,qFCjNA,gDAGA,sCACA,qCACA,sDAIF,CAIE,kDAGA,CAPF,0CAOE,kBAEA,kDAEA,CAHA,eACA,CAFA,YACA,CADA,SAIA,mHAIE,CAGA,6CAFA,oCAeE,CAbF,yBACE,qBAEJ,CAGE,oBACA,CAEA,YAFA,2CACF,CACE,uBAEA,mFAEE,CALJ,oBACE,CAEA,UAEE,gCAGF,sDAEA,yCC7CJ,oCAGA,CD6CE,yXAQE,sCCrDJ,wCAGA,oCACE","sources":["webpack:///./node_modules/normalize.css/normalize.css","webpack:///./src/furo/assets/styles/base/_print.sass","webpack:///./src/furo/assets/styles/base/_screen-readers.sass","webpack:///./src/furo/assets/styles/base/_theme.sass","webpack:///./src/furo/assets/styles/variables/_fonts.scss","webpack:///./src/furo/assets/styles/variables/_spacing.scss","webpack:///./src/furo/assets/styles/variables/_icons.scss","webpack:///./src/furo/assets/styles/variables/_admonitions.scss","webpack:///./src/furo/assets/styles/variables/_colors.scss","webpack:///./src/furo/assets/styles/base/_typography.sass","webpack:///./src/furo/assets/styles/_scaffold.sass","webpack:///./src/furo/assets/styles/content/_admonitions.sass","webpack:///./src/furo/assets/styles/content/_api.sass","webpack:///./src/furo/assets/styles/content/_blocks.sass","webpack:///./src/furo/assets/styles/content/_captions.sass","webpack:///./src/furo/assets/styles/content/_code.sass","webpack:///./src/furo/assets/styles/content/_footnotes.sass","webpack:///./src/furo/assets/styles/content/_images.sass","webpack:///./src/furo/assets/styles/content/_indexes.sass","webpack:///./src/furo/assets/styles/content/_lists.sass","webpack:///./src/furo/assets/styles/content/_math.sass","webpack:///./src/furo/assets/styles/content/_misc.sass","webpack:///./src/furo/assets/styles/content/_rubrics.sass","webpack:///./src/furo/assets/styles/content/_sidebar.sass","webpack:///./src/furo/assets/styles/content/_tables.sass","webpack:///./src/furo/assets/styles/content/_target.sass","webpack:///./src/furo/assets/styles/content/_gui-labels.sass","webpack:///./src/furo/assets/styles/components/_footer.sass","webpack:///./src/furo/assets/styles/components/_sidebar.sass","webpack:///./src/furo/assets/styles/components/_table_of_contents.sass","webpack:///./src/furo/assets/styles/_shame.sass"],"sourcesContent":["/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */\n\n/* Document\n ========================================================================== */\n\n/**\n * 1. Correct the line height in all browsers.\n * 2. Prevent adjustments of font size after orientation changes in iOS.\n */\n\nhtml {\n line-height: 1.15; /* 1 */\n -webkit-text-size-adjust: 100%; /* 2 */\n}\n\n/* Sections\n ========================================================================== */\n\n/**\n * Remove the margin in all browsers.\n */\n\nbody {\n margin: 0;\n}\n\n/**\n * Render the `main` element consistently in IE.\n */\n\nmain {\n display: block;\n}\n\n/**\n * Correct the font size and margin on `h1` elements within `section` and\n * `article` contexts in Chrome, Firefox, and Safari.\n */\n\nh1 {\n font-size: 2em;\n margin: 0.67em 0;\n}\n\n/* Grouping content\n ========================================================================== */\n\n/**\n * 1. Add the correct box sizing in Firefox.\n * 2. Show the overflow in Edge and IE.\n */\n\nhr {\n box-sizing: content-box; /* 1 */\n height: 0; /* 1 */\n overflow: visible; /* 2 */\n}\n\n/**\n * 1. Correct the inheritance and scaling of font size in all browsers.\n * 2. Correct the odd `em` font sizing in all browsers.\n */\n\npre {\n font-family: monospace, monospace; /* 1 */\n font-size: 1em; /* 2 */\n}\n\n/* Text-level semantics\n ========================================================================== */\n\n/**\n * Remove the gray background on active links in IE 10.\n */\n\na {\n background-color: transparent;\n}\n\n/**\n * 1. Remove the bottom border in Chrome 57-\n * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.\n */\n\nabbr[title] {\n border-bottom: none; /* 1 */\n text-decoration: underline; /* 2 */\n text-decoration: underline dotted; /* 2 */\n}\n\n/**\n * Add the correct font weight in Chrome, Edge, and Safari.\n */\n\nb,\nstrong {\n font-weight: bolder;\n}\n\n/**\n * 1. Correct the inheritance and scaling of font size in all browsers.\n * 2. Correct the odd `em` font sizing in all browsers.\n */\n\ncode,\nkbd,\nsamp {\n font-family: monospace, monospace; /* 1 */\n font-size: 1em; /* 2 */\n}\n\n/**\n * Add the correct font size in all browsers.\n */\n\nsmall {\n font-size: 80%;\n}\n\n/**\n * Prevent `sub` and `sup` elements from affecting the line height in\n * all browsers.\n */\n\nsub,\nsup {\n font-size: 75%;\n line-height: 0;\n position: relative;\n vertical-align: baseline;\n}\n\nsub {\n bottom: -0.25em;\n}\n\nsup {\n top: -0.5em;\n}\n\n/* Embedded content\n ========================================================================== */\n\n/**\n * Remove the border on images inside links in IE 10.\n */\n\nimg {\n border-style: none;\n}\n\n/* Forms\n ========================================================================== */\n\n/**\n * 1. Change the font styles in all browsers.\n * 2. Remove the margin in Firefox and Safari.\n */\n\nbutton,\ninput,\noptgroup,\nselect,\ntextarea {\n font-family: inherit; /* 1 */\n font-size: 100%; /* 1 */\n line-height: 1.15; /* 1 */\n margin: 0; /* 2 */\n}\n\n/**\n * Show the overflow in IE.\n * 1. Show the overflow in Edge.\n */\n\nbutton,\ninput { /* 1 */\n overflow: visible;\n}\n\n/**\n * Remove the inheritance of text transform in Edge, Firefox, and IE.\n * 1. Remove the inheritance of text transform in Firefox.\n */\n\nbutton,\nselect { /* 1 */\n text-transform: none;\n}\n\n/**\n * Correct the inability to style clickable types in iOS and Safari.\n */\n\nbutton,\n[type=\"button\"],\n[type=\"reset\"],\n[type=\"submit\"] {\n -webkit-appearance: button;\n}\n\n/**\n * Remove the inner border and padding in Firefox.\n */\n\nbutton::-moz-focus-inner,\n[type=\"button\"]::-moz-focus-inner,\n[type=\"reset\"]::-moz-focus-inner,\n[type=\"submit\"]::-moz-focus-inner {\n border-style: none;\n padding: 0;\n}\n\n/**\n * Restore the focus styles unset by the previous rule.\n */\n\nbutton:-moz-focusring,\n[type=\"button\"]:-moz-focusring,\n[type=\"reset\"]:-moz-focusring,\n[type=\"submit\"]:-moz-focusring {\n outline: 1px dotted ButtonText;\n}\n\n/**\n * Correct the padding in Firefox.\n */\n\nfieldset {\n padding: 0.35em 0.75em 0.625em;\n}\n\n/**\n * 1. Correct the text wrapping in Edge and IE.\n * 2. Correct the color inheritance from `fieldset` elements in IE.\n * 3. Remove the padding so developers are not caught out when they zero out\n * `fieldset` elements in all browsers.\n */\n\nlegend {\n box-sizing: border-box; /* 1 */\n color: inherit; /* 2 */\n display: table; /* 1 */\n max-width: 100%; /* 1 */\n padding: 0; /* 3 */\n white-space: normal; /* 1 */\n}\n\n/**\n * Add the correct vertical alignment in Chrome, Firefox, and Opera.\n */\n\nprogress {\n vertical-align: baseline;\n}\n\n/**\n * Remove the default vertical scrollbar in IE 10+.\n */\n\ntextarea {\n overflow: auto;\n}\n\n/**\n * 1. Add the correct box sizing in IE 10.\n * 2. Remove the padding in IE 10.\n */\n\n[type=\"checkbox\"],\n[type=\"radio\"] {\n box-sizing: border-box; /* 1 */\n padding: 0; /* 2 */\n}\n\n/**\n * Correct the cursor style of increment and decrement buttons in Chrome.\n */\n\n[type=\"number\"]::-webkit-inner-spin-button,\n[type=\"number\"]::-webkit-outer-spin-button {\n height: auto;\n}\n\n/**\n * 1. Correct the odd appearance in Chrome and Safari.\n * 2. Correct the outline style in Safari.\n */\n\n[type=\"search\"] {\n -webkit-appearance: textfield; /* 1 */\n outline-offset: -2px; /* 2 */\n}\n\n/**\n * Remove the inner padding in Chrome and Safari on macOS.\n */\n\n[type=\"search\"]::-webkit-search-decoration {\n -webkit-appearance: none;\n}\n\n/**\n * 1. Correct the inability to style clickable types in iOS and Safari.\n * 2. Change font properties to `inherit` in Safari.\n */\n\n::-webkit-file-upload-button {\n -webkit-appearance: button; /* 1 */\n font: inherit; /* 2 */\n}\n\n/* Interactive\n ========================================================================== */\n\n/*\n * Add the correct display in Edge, IE 10+, and Firefox.\n */\n\ndetails {\n display: block;\n}\n\n/*\n * Add the correct display in all browsers.\n */\n\nsummary {\n display: list-item;\n}\n\n/* Misc\n ========================================================================== */\n\n/**\n * Add the correct display in IE 10+.\n */\n\ntemplate {\n display: none;\n}\n\n/**\n * Add the correct display in IE 10.\n */\n\n[hidden] {\n display: none;\n}\n","// This file contains styles for managing print media.\n\n////////////////////////////////////////////////////////////////////////////////\n// Hide elements not relevant to print media.\n////////////////////////////////////////////////////////////////////////////////\n@media print\n // Hide icon container.\n .content-icon-container\n display: none !important\n\n // Hide showing header links if hovering over when printing.\n .headerlink\n display: none !important\n\n // Hide mobile header.\n .mobile-header\n display: none !important\n\n // Hide navigation links.\n .related-pages\n display: none !important\n\n////////////////////////////////////////////////////////////////////////////////\n// Tweaks related to decolorization.\n////////////////////////////////////////////////////////////////////////////////\n@media print\n // Apply a border around code which no longer have a color background.\n .highlight\n border: 0.1pt solid var(--color-foreground-border)\n\n////////////////////////////////////////////////////////////////////////////////\n// Avoid page break in some relevant cases.\n////////////////////////////////////////////////////////////////////////////////\n@media print\n ul, ol, dl, a, table, pre, blockquote\n page-break-inside: avoid\n\n h1, h2, h3, h4, h5, h6, img, figure, caption\n page-break-inside: avoid\n page-break-after: avoid\n\n ul, ol, dl\n page-break-before: avoid\n",".visually-hidden\n position: absolute !important\n width: 1px !important\n height: 1px !important\n padding: 0 !important\n margin: -1px !important\n overflow: hidden !important\n clip: rect(0,0,0,0) !important\n white-space: nowrap !important\n border: 0 !important\n\n:-moz-focusring\n outline: auto\n","// This file serves as the \"skeleton\" of the theming logic.\n//\n// This contains the bulk of the logic for handling dark mode, color scheme\n// toggling and the handling of color-scheme-specific hiding of elements.\n\nbody\n @include fonts\n @include spacing\n @include icons\n @include admonitions\n @include default-admonition(#651fff, \"abstract\")\n @include default-topic(#14B8A6, \"pencil\")\n\n @include colors\n\n.only-light\n display: block !important\nhtml body .only-dark\n display: none !important\n\n// Ignore dark-mode hints if print media.\n@media not print\n // Enable dark-mode, if requested.\n body[data-theme=\"dark\"]\n @include colors-dark\n\n html & .only-light\n display: none !important\n .only-dark\n display: block !important\n\n // Enable dark mode, unless explicitly told to avoid.\n @media (prefers-color-scheme: dark)\n body:not([data-theme=\"light\"])\n @include colors-dark\n\n html & .only-light\n display: none !important\n .only-dark\n display: block !important\n\n//\n// Theme toggle presentation\n//\nbody[data-theme=\"auto\"]\n .theme-toggle svg.theme-icon-when-auto\n display: block\n\nbody[data-theme=\"dark\"]\n .theme-toggle svg.theme-icon-when-dark\n display: block\n\nbody[data-theme=\"light\"]\n .theme-toggle svg.theme-icon-when-light\n display: block\n","// Fonts used by this theme.\n//\n// There are basically two things here -- using the system font stack and\n// defining sizes for various elements in %ages. We could have also used `em`\n// but %age is easier to reason about for me.\n\n@mixin fonts {\n // These are adapted from https://systemfontstack.com/\n --font-stack: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial,\n sans-serif, Apple Color Emoji, Segoe UI Emoji;\n --font-stack--monospace: \"SFMono-Regular\", Menlo, Consolas, Monaco,\n Liberation Mono, Lucida Console, monospace;\n\n --font-size--normal: 100%;\n --font-size--small: 87.5%;\n --font-size--small--2: 81.25%;\n --font-size--small--3: 75%;\n --font-size--small--4: 62.5%;\n\n // Sidebar\n --sidebar-caption-font-size: var(--font-size--small--2);\n --sidebar-item-font-size: var(--font-size--small);\n --sidebar-search-input-font-size: var(--font-size--small);\n\n // Table of Contents\n --toc-font-size: var(--font-size--small--3);\n --toc-font-size--mobile: var(--font-size--normal);\n --toc-title-font-size: var(--font-size--small--4);\n\n // Admonitions\n //\n // These aren't defined in terms of %ages, since nesting these is permitted.\n --admonition-font-size: 0.8125rem;\n --admonition-title-font-size: 0.8125rem;\n\n // Code\n --code-font-size: var(--font-size--small--2);\n\n // API\n --api-font-size: var(--font-size--small);\n}\n","// Spacing for various elements on the page\n//\n// If the user wants to tweak things in a certain way, they are permitted to.\n// They also have to deal with the consequences though!\n\n@mixin spacing {\n // Header!\n --header-height: calc(\n var(--sidebar-item-line-height) + 4 * #{var(--sidebar-item-spacing-vertical)}\n );\n --header-padding: 0.5rem;\n\n // Sidebar\n --sidebar-tree-space-above: 1.5rem;\n --sidebar-caption-space-above: 1rem;\n\n --sidebar-item-line-height: 1rem;\n --sidebar-item-spacing-vertical: 0.5rem;\n --sidebar-item-spacing-horizontal: 1rem;\n --sidebar-item-height: calc(\n var(--sidebar-item-line-height) + 2 *#{var(--sidebar-item-spacing-vertical)}\n );\n\n --sidebar-expander-width: var(--sidebar-item-height); // be square\n\n --sidebar-search-space-above: 0.5rem;\n --sidebar-search-input-spacing-vertical: 0.5rem;\n --sidebar-search-input-spacing-horizontal: 0.5rem;\n --sidebar-search-input-height: 1rem;\n --sidebar-search-icon-size: var(--sidebar-search-input-height);\n\n // Table of Contents\n --toc-title-padding: 0.25rem 0;\n --toc-spacing-vertical: 1.5rem;\n --toc-spacing-horizontal: 1.5rem;\n --toc-item-spacing-vertical: 0.4rem;\n --toc-item-spacing-horizontal: 1rem;\n}\n","// Expose theme icons as CSS variables.\n\n$icons: (\n // Adapted from tabler-icons\n // url: https://tablericons.com/\n \"search\":\n url('data:image/svg+xml;charset=utf-8,'),\n // Factored out from mkdocs-material on 24-Aug-2020.\n // url: https://squidfunk.github.io/mkdocs-material/reference/admonitions/\n \"pencil\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"abstract\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"info\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"flame\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"question\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"warning\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"failure\":\n url('data:image/svg+xml;charset=utf-8,'),\n \"spark\":\n url('data:image/svg+xml;charset=utf-8,')\n);\n\n@mixin icons {\n @each $name, $glyph in $icons {\n --icon-#{$name}: #{$glyph};\n }\n}\n","// Admonitions\n\n// Structure of these is:\n// admonition-class: color \"icon-name\";\n//\n// The colors are translated into CSS variables below. The icons are\n// used directly in the main declarations to set the `mask-image` in\n// the title.\n\n// prettier-ignore\n$admonitions: (\n // Each of these has an reST directives for it.\n \"caution\": #ff9100 \"spark\",\n \"warning\": #ff9100 \"warning\",\n \"danger\": #ff5252 \"spark\",\n \"attention\": #ff5252 \"warning\",\n \"error\": #ff5252 \"failure\",\n \"hint\": #00c852 \"question\",\n \"tip\": #00c852 \"info\",\n \"important\": #00bfa5 \"flame\",\n \"note\": #00b0ff \"pencil\",\n \"seealso\": #448aff \"info\",\n \"admonition-todo\": #808080 \"pencil\"\n);\n\n@mixin default-admonition($color, $icon-name) {\n --color-admonition-title: #{$color};\n --color-admonition-title-background: #{rgba($color, 0.2)};\n\n --icon-admonition-default: var(--icon-#{$icon-name});\n}\n\n@mixin default-topic($color, $icon-name) {\n --color-topic-title: #{$color};\n --color-topic-title-background: #{rgba($color, 0.2)};\n\n --icon-topic-default: var(--icon-#{$icon-name});\n}\n\n@mixin admonitions {\n @each $name, $values in $admonitions {\n --color-admonition-title--#{$name}: #{nth($values, 1)};\n --color-admonition-title-background--#{$name}: #{rgba(\n nth($values, 1),\n 0.2\n )};\n }\n}\n","// Colors used throughout this theme.\n//\n// The aim is to give the user more control. Thus, instead of hard-coding colors\n// in various parts of the stylesheet, the approach taken is to define all\n// colors as CSS variables and reusing them in all the places.\n//\n// `colors-dark` depends on `colors` being included at a lower specificity.\n\n@mixin colors {\n --color-problematic: #b30000;\n\n // Base Colors\n --color-foreground-primary: black; // for main text and headings\n --color-foreground-secondary: #5a5c63; // for secondary text\n --color-foreground-muted: #646776; // for muted text\n --color-foreground-border: #878787; // for content borders\n\n --color-background-primary: white; // for content\n --color-background-secondary: #f8f9fb; // for navigation + ToC\n --color-background-hover: #efeff4ff; // for navigation-item hover\n --color-background-hover--transparent: #efeff400;\n --color-background-border: #eeebee; // for UI borders\n --color-background-item: #ccc; // for \"background\" items (eg: copybutton)\n\n // Announcements\n --color-announcement-background: #000000dd;\n --color-announcement-text: #eeebee;\n\n // Brand colors\n --color-brand-primary: #2962ff;\n --color-brand-content: #2a5adf;\n\n // API documentation\n --color-api-background: var(--color-background-hover--transparent);\n --color-api-background-hover: var(--color-background-hover);\n --color-api-overall: var(--color-foreground-secondary);\n --color-api-name: var(--color-problematic);\n --color-api-pre-name: var(--color-problematic);\n --color-api-paren: var(--color-foreground-secondary);\n --color-api-keyword: var(--color-foreground-primary);\n --color-highlight-on-target: #ffffcc;\n\n // Inline code background\n --color-inline-code-background: var(--color-background-secondary);\n\n // Highlighted text (search)\n --color-highlighted-background: #ddeeff;\n --color-highlighted-text: var(--color-foreground-primary);\n\n // GUI Labels\n --color-guilabel-background: #ddeeff80;\n --color-guilabel-border: #bedaf580;\n --color-guilabel-text: var(--color-foreground-primary);\n\n // Admonitions!\n --color-admonition-background: transparent;\n\n //////////////////////////////////////////////////////////////////////////////\n // Everything below this should be one of:\n // - var(...)\n // - *-gradient(...)\n // - special literal values (eg: transparent, none)\n //////////////////////////////////////////////////////////////////////////////\n\n // Tables\n --color-table-header-background: var(--color-background-secondary);\n --color-table-border: var(--color-background-border);\n\n // Cards\n --color-card-border: var(--color-background-secondary);\n --color-card-background: transparent;\n --color-card-marginals-background: var(--color-background-secondary);\n\n // Header\n --color-header-background: var(--color-background-primary);\n --color-header-border: var(--color-background-border);\n --color-header-text: var(--color-foreground-primary);\n\n // Sidebar (left)\n --color-sidebar-background: var(--color-background-secondary);\n --color-sidebar-background-border: var(--color-background-border);\n\n --color-sidebar-brand-text: var(--color-foreground-primary);\n --color-sidebar-caption-text: var(--color-foreground-muted);\n --color-sidebar-link-text: var(--color-foreground-secondary);\n --color-sidebar-link-text--top-level: var(--color-brand-primary);\n\n --color-sidebar-item-background: var(--color-sidebar-background);\n --color-sidebar-item-background--current: var(\n --color-sidebar-item-background\n );\n --color-sidebar-item-background--hover: linear-gradient(\n 90deg,\n var(--color-background-hover--transparent) 0%,\n var(--color-background-hover) var(--sidebar-item-spacing-horizontal),\n var(--color-background-hover) 100%\n );\n\n --color-sidebar-item-expander-background: transparent;\n --color-sidebar-item-expander-background--hover: var(\n --color-background-hover\n );\n\n --color-sidebar-search-text: var(--color-foreground-primary);\n --color-sidebar-search-background: var(--color-background-secondary);\n --color-sidebar-search-background--focus: var(--color-background-primary);\n --color-sidebar-search-border: var(--color-background-border);\n --color-sidebar-search-icon: var(--color-foreground-muted);\n\n // Table of Contents (right)\n --color-toc-background: var(--color-background-primary);\n --color-toc-title-text: var(--color-foreground-muted);\n --color-toc-item-text: var(--color-foreground-secondary);\n --color-toc-item-text--hover: var(--color-foreground-primary);\n --color-toc-item-text--active: var(--color-brand-primary);\n\n // Actual page contents\n --color-content-foreground: var(--color-foreground-primary);\n --color-content-background: transparent;\n\n // Links\n --color-link: var(--color-brand-content);\n --color-link--hover: var(--color-brand-content);\n --color-link-underline: var(--color-background-border);\n --color-link-underline--hover: var(--color-foreground-border);\n}\n\n@mixin colors-dark {\n --color-problematic: #ee5151;\n\n // Base Colors\n --color-foreground-primary: #ffffffcc; // for main text and headings\n --color-foreground-secondary: #9ca0a5; // for secondary text\n --color-foreground-muted: #81868d; // for muted text\n --color-foreground-border: #666666; // for content borders\n\n --color-background-primary: #131416; // for content\n --color-background-secondary: #1a1c1e; // for navigation + ToC\n --color-background-hover: #1e2124ff; // for navigation-item hover\n --color-background-hover--transparent: #1e212400;\n --color-background-border: #303335; // for UI borders\n --color-background-item: #444; // for \"background\" items (eg: copybutton)\n\n // Announcements\n --color-announcement-background: #000000dd;\n --color-announcement-text: #eeebee;\n\n // Brand colors\n --color-brand-primary: #2b8cee;\n --color-brand-content: #368ce2;\n\n // Highlighted text (search)\n --color-highlighted-background: #083563;\n\n // GUI Labels\n --color-guilabel-background: #08356380;\n --color-guilabel-border: #13395f80;\n\n // API documentation\n --color-api-keyword: var(--color-foreground-secondary);\n --color-highlight-on-target: #333300;\n\n // Admonitions\n --color-admonition-background: #18181a;\n\n // Cards\n --color-card-border: var(--color-background-secondary);\n --color-card-background: #18181a;\n --color-card-marginals-background: var(--color-background-hover);\n}\n","// This file contains the styling for making the content throughout the page,\n// including fonts, paragraphs, headings and spacing among these elements.\n\nbody\n font-family: var(--font-stack)\npre,\ncode,\nkbd,\nsamp\n font-family: var(--font-stack--monospace)\n\n// Make fonts look slightly nicer.\nbody\n -webkit-font-smoothing: antialiased\n -moz-osx-font-smoothing: grayscale\n\n// Line height from Bootstrap 4.1\narticle\n line-height: 1.5\n\n//\n// Headings\n//\nh1,\nh2,\nh3,\nh4,\nh5,\nh6\n line-height: 1.25\n font-weight: bold\n\n border-radius: 0.5rem\n margin-top: 0.5rem\n margin-bottom: 0.5rem\n margin-left: -0.5rem\n margin-right: -0.5rem\n padding-left: 0.5rem\n padding-right: 0.5rem\n\n + p\n margin-top: 0\n\nh1\n font-size: 2.5em\n margin-top: 1.75rem\n margin-bottom: 1rem\nh2\n font-size: 2em\n margin-top: 1.75rem\nh3\n font-size: 1.5em\nh4\n font-size: 1.25em\nh5\n font-size: 1.125em\nh6\n font-size: 1em\n\nsmall\n opacity: 75%\n font-size: 80%\n\n// Paragraph\np\n margin-top: 0.5rem\n margin-bottom: 0.75rem\n\n// Horizontal rules\nhr.docutils\n height: 1px\n padding: 0\n margin: 2rem 0\n background-color: var(--color-background-border)\n border: 0\n\n.centered\n text-align: center\n\n// Links\na\n text-decoration: underline\n\n color: var(--color-link)\n text-decoration-color: var(--color-link-underline)\n\n &:hover\n color: var(--color-link--hover)\n text-decoration-color: var(--color-link-underline--hover)\n &.muted-link\n color: inherit\n &:hover\n color: var(--color-link)\n text-decoration-color: var(--color-link-underline--hover)\n","// This file contains the styles for the overall layouting of the documentation\n// skeleton, including the responsive changes as well as sidebar toggles.\n//\n// This is implemented as a mobile-last design, which isn't ideal, but it is\n// reasonably good-enough and I got pretty tired by the time I'd finished this\n// to move the rules around to fix this. Shouldn't take more than 3-4 hours,\n// if you know what you're doing tho.\n\n// HACK: Not all browsers account for the scrollbar width in media queries.\n// This results in horizontal scrollbars in the breakpoint where we go\n// from displaying everything to hiding the ToC. We accomodate for this by\n// adding a bit of padding to the TOC drawer, disabling the horizontal\n// scrollbar and allowing the scrollbars to cover the padding.\n// https://www.456bereastreet.com/archive/201301/media_query_width_and_vertical_scrollbars/\n\n// HACK: Always having the scrollbar visible, prevents certain browsers from\n// causing the content to stutter horizontally between taller-than-viewport and\n// not-taller-than-viewport pages.\n\nhtml\n overflow-x: hidden\n overflow-y: scroll\n scroll-behavior: smooth\n\n.sidebar-scroll, .toc-scroll, article[role=main] *\n // Override Firefox scrollbar style\n scrollbar-width: thin\n scrollbar-color: var(--color-foreground-border) transparent\n\n // Override Chrome scrollbar styles\n &::-webkit-scrollbar\n width: 0.25rem\n height: 0.25rem\n &::-webkit-scrollbar-thumb\n background-color: var(--color-foreground-border)\n border-radius: 0.125rem\n\n//\n// Overalls\n//\nhtml,\nbody\n height: 100%\n color: var(--color-foreground-primary)\n background: var(--color-background-primary)\n\narticle\n color: var(--color-content-foreground)\n background: var(--color-content-background)\n overflow-wrap: break-word\n\n.page\n display: flex\n // fill the viewport for pages with little content.\n min-height: 100%\n\n.mobile-header\n width: 100%\n height: var(--header-height)\n background-color: var(--color-header-background)\n color: var(--color-header-text)\n border-bottom: 1px solid var(--color-header-border)\n\n // Looks like sub-script/super-script have this, and we need this to\n // be \"on top\" of those.\n z-index: 10\n\n // We don't show the header on large screens.\n display: none\n\n // Add shadow when scrolled\n &.scrolled\n border-bottom: none\n box-shadow: 0 0 0.2rem rgba(0, 0, 0, 0.1), 0 0.2rem 0.4rem rgba(0, 0, 0, 0.2)\n\n .header-center\n a\n color: var(--color-header-text)\n text-decoration: none\n\n.main\n display: flex\n flex: 1\n\n// Sidebar (left) also covers the entire left portion of screen.\n.sidebar-drawer\n box-sizing: border-box\n\n border-right: 1px solid var(--color-sidebar-background-border)\n background: var(--color-sidebar-background)\n\n display: flex\n justify-content: flex-end\n // These next two lines took me two days to figure out.\n width: calc((100% - #{$full-width}) / 2 + #{$sidebar-width})\n min-width: $sidebar-width\n\n// Scroll-along sidebars\n.sidebar-container,\n.toc-drawer\n box-sizing: border-box\n width: $sidebar-width\n\n.toc-drawer\n background: var(--color-toc-background)\n // See HACK described on top of this document\n padding-right: 1rem\n\n.sidebar-sticky,\n.toc-sticky\n position: sticky\n top: 0\n height: min(100%, 100vh)\n height: 100vh\n\n display: flex\n flex-direction: column\n\n.sidebar-scroll,\n.toc-scroll\n flex-grow: 1\n flex-shrink: 1\n\n overflow: auto\n scroll-behavior: smooth\n\n// Central items.\n.content\n padding: 0 $content-padding\n width: $content-width\n\n display: flex\n flex-direction: column\n justify-content: space-between\n\n.icon\n display: inline-block\n height: 1rem\n width: 1rem\n svg\n width: 100%\n height: 100%\n\n//\n// Accommodate announcement banner\n//\n.announcement\n background-color: var(--color-announcement-background)\n color: var(--color-announcement-text)\n\n height: var(--header-height)\n display: flex\n align-items: center\n overflow-x: auto\n & + .page\n min-height: calc(100% - var(--header-height))\n\n.announcement-content\n box-sizing: border-box\n padding: 0.5rem\n min-width: 100%\n white-space: nowrap\n text-align: center\n\n a\n color: var(--color-announcement-text)\n text-decoration-color: var(--color-announcement-text)\n\n &:hover\n color: var(--color-announcement-text)\n text-decoration-color: var(--color-link--hover)\n\n////////////////////////////////////////////////////////////////////////////////\n// Toggles for theme\n////////////////////////////////////////////////////////////////////////////////\n.no-js .theme-toggle-container // don't show theme toggle if there's no JS\n display: none\n\n.theme-toggle-container\n vertical-align: middle\n\n.theme-toggle\n cursor: pointer\n border: none\n padding: 0\n background: transparent\n\n.theme-toggle svg\n vertical-align: middle\n height: 1rem\n width: 1rem\n color: var(--color-foreground-primary)\n display: none\n\n.theme-toggle-header\n float: left\n padding: 1rem 0.5rem\n\n////////////////////////////////////////////////////////////////////////////////\n// Toggles for elements\n////////////////////////////////////////////////////////////////////////////////\n.toc-overlay-icon, .nav-overlay-icon\n display: none\n cursor: pointer\n\n .icon\n color: var(--color-foreground-secondary)\n height: 1rem\n width: 1rem\n\n.toc-header-icon, .nav-overlay-icon\n // for when we set display: flex\n justify-content: center\n align-items: center\n\n.toc-content-icon\n height: 1.5rem\n width: 1.5rem\n\n.content-icon-container\n float: right\n display: flex\n margin-top: 1.5rem\n margin-left: 1rem\n margin-bottom: 1rem\n gap: 0.5rem\n\n .edit-this-page svg\n color: inherit\n height: 1rem\n width: 1rem\n\n.sidebar-toggle\n position: absolute\n display: none\n//