diff --git a/.gitignore b/.gitignore index f2beee6b..ef46ec5e 100644 --- a/.gitignore +++ b/.gitignore @@ -158,4 +158,7 @@ tags *.gcno *.gcda *.gcov -test_calculator + +*/*/_build +*/_build + diff --git a/book/content/_build/.doctrees/base.doctree b/book/content/_build/.doctrees/base.doctree deleted file mode 100644 index ba694984..00000000 Binary files a/book/content/_build/.doctrees/base.doctree and /dev/null differ diff --git a/book/content/_build/.doctrees/dissimilarity.doctree b/book/content/_build/.doctrees/dissimilarity.doctree deleted file mode 100644 index a3af7418..00000000 Binary files a/book/content/_build/.doctrees/dissimilarity.doctree and /dev/null differ diff --git a/book/content/_build/.doctrees/environment.pickle b/book/content/_build/.doctrees/environment.pickle deleted file mode 100644 index a051ff66..00000000 Binary files a/book/content/_build/.doctrees/environment.pickle and /dev/null differ diff --git a/book/content/_build/.doctrees/glue_cache.json b/book/content/_build/.doctrees/glue_cache.json deleted file mode 100644 index 0967ef42..00000000 --- a/book/content/_build/.doctrees/glue_cache.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/book/content/_build/.doctrees/installation.doctree b/book/content/_build/.doctrees/installation.doctree deleted file mode 100644 index ffc4b34d..00000000 Binary files a/book/content/_build/.doctrees/installation.doctree and /dev/null differ diff --git a/book/content/_build/.doctrees/intro.doctree b/book/content/_build/.doctrees/intro.doctree deleted file mode 100644 index fba92ed8..00000000 Binary files a/book/content/_build/.doctrees/intro.doctree and /dev/null differ diff --git a/book/content/_build/.doctrees/partition.doctree b/book/content/_build/.doctrees/partition.doctree deleted file mode 100644 index 930368f2..00000000 Binary files a/book/content/_build/.doctrees/partition.doctree and /dev/null differ diff --git a/book/content/_build/.doctrees/starting.doctree b/book/content/_build/.doctrees/starting.doctree deleted file mode 100644 index dbe44dbf..00000000 Binary files a/book/content/_build/.doctrees/starting.doctree and /dev/null differ diff --git a/book/content/_build/.doctrees/utils.doctree b/book/content/_build/.doctrees/utils.doctree deleted file mode 100644 index 0c6e5084..00000000 Binary files a/book/content/_build/.doctrees/utils.doctree and /dev/null differ diff --git a/book/content/_build/html/.buildinfo b/book/content/_build/html/.buildinfo deleted file mode 100644 index f0afb4fa..00000000 --- a/book/content/_build/html/.buildinfo +++ /dev/null @@ -1,4 +0,0 @@ -# Sphinx build info version 1 -# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: c106cc1324f6fc026b0dab6d46502249 -tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/book/content/_build/html/_images/starting_10_0.png b/book/content/_build/html/_images/starting_10_0.png deleted file mode 100644 index 8ab8c1c3..00000000 Binary files a/book/content/_build/html/_images/starting_10_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_10_1.png b/book/content/_build/html/_images/starting_10_1.png deleted file mode 100644 index abe312fa..00000000 Binary files a/book/content/_build/html/_images/starting_10_1.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_12_0.png b/book/content/_build/html/_images/starting_12_0.png deleted file mode 100644 index d5712e97..00000000 Binary files a/book/content/_build/html/_images/starting_12_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_12_1.png b/book/content/_build/html/_images/starting_12_1.png deleted file mode 100644 index a483a143..00000000 Binary files a/book/content/_build/html/_images/starting_12_1.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_14_0.png b/book/content/_build/html/_images/starting_14_0.png deleted file mode 100644 index 833413f8..00000000 Binary files a/book/content/_build/html/_images/starting_14_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_14_1.png b/book/content/_build/html/_images/starting_14_1.png deleted file mode 100644 index 7ad6fe4b..00000000 Binary files a/book/content/_build/html/_images/starting_14_1.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_16_0.png b/book/content/_build/html/_images/starting_16_0.png deleted file mode 100644 index d3e63fc6..00000000 Binary files a/book/content/_build/html/_images/starting_16_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_16_1.png b/book/content/_build/html/_images/starting_16_1.png deleted file mode 100644 index 733c0ce6..00000000 Binary files a/book/content/_build/html/_images/starting_16_1.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_18_0.png b/book/content/_build/html/_images/starting_18_0.png deleted file mode 100644 index d19cdc00..00000000 Binary files a/book/content/_build/html/_images/starting_18_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_19_0.png b/book/content/_build/html/_images/starting_19_0.png deleted file mode 100644 index f8688f21..00000000 Binary files a/book/content/_build/html/_images/starting_19_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_22_0.png b/book/content/_build/html/_images/starting_22_0.png deleted file mode 100644 index 26f5fb5a..00000000 Binary files a/book/content/_build/html/_images/starting_22_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_25_0.png b/book/content/_build/html/_images/starting_25_0.png deleted file mode 100644 index 26f5fb5a..00000000 Binary files a/book/content/_build/html/_images/starting_25_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_28_0.png b/book/content/_build/html/_images/starting_28_0.png deleted file mode 100644 index 145e218f..00000000 Binary files a/book/content/_build/html/_images/starting_28_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_31_0.png b/book/content/_build/html/_images/starting_31_0.png deleted file mode 100644 index ea3944fd..00000000 Binary files a/book/content/_build/html/_images/starting_31_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_34_0.png b/book/content/_build/html/_images/starting_34_0.png deleted file mode 100644 index ffe80ceb..00000000 Binary files a/book/content/_build/html/_images/starting_34_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_6_0.png b/book/content/_build/html/_images/starting_6_0.png deleted file mode 100644 index cbc67e93..00000000 Binary files a/book/content/_build/html/_images/starting_6_0.png and /dev/null differ diff --git a/book/content/_build/html/_images/starting_6_1.png b/book/content/_build/html/_images/starting_6_1.png deleted file mode 100644 index 86407139..00000000 Binary files a/book/content/_build/html/_images/starting_6_1.png and /dev/null differ diff --git a/book/content/_build/html/_panels_static/panels-main.c949a650a448cc0ae9fd3441c0e17fb0.css b/book/content/_build/html/_panels_static/panels-main.c949a650a448cc0ae9fd3441c0e17fb0.css deleted file mode 100644 index fc14abc8..00000000 --- a/book/content/_build/html/_panels_static/panels-main.c949a650a448cc0ae9fd3441c0e17fb0.css +++ /dev/null @@ -1 +0,0 @@ -details.dropdown .summary-title{padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.dropdown:hover{cursor:pointer}details.dropdown .summary-content{cursor:default}details.dropdown summary{list-style:none;padding:1em}details.dropdown summary .octicon.no-title{vertical-align:middle}details.dropdown[open] summary .octicon.no-title{visibility:hidden}details.dropdown summary::-webkit-details-marker{display:none}details.dropdown summary:focus{outline:none}details.dropdown summary:hover .summary-up svg,details.dropdown summary:hover .summary-down svg{opacity:1}details.dropdown .summary-up svg,details.dropdown .summary-down svg{display:block;opacity:.6}details.dropdown .summary-up,details.dropdown .summary-down{pointer-events:none;position:absolute;right:1em;top:.75em}details.dropdown[open] .summary-down{visibility:hidden}details.dropdown:not([open]) .summary-up{visibility:hidden}details.dropdown.fade-in[open] summary~*{-moz-animation:panels-fade-in .5s ease-in-out;-webkit-animation:panels-fade-in .5s ease-in-out;animation:panels-fade-in .5s ease-in-out}details.dropdown.fade-in-slide-down[open] summary~*{-moz-animation:panels-fade-in .5s ease-in-out, panels-slide-down .5s ease-in-out;-webkit-animation:panels-fade-in .5s ease-in-out, panels-slide-down .5s ease-in-out;animation:panels-fade-in .5s ease-in-out, panels-slide-down .5s ease-in-out}@keyframes panels-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes panels-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.octicon{display:inline-block;fill:currentColor;vertical-align:text-top}.tabbed-content{box-shadow:0 -.0625rem var(--tabs-color-overline),0 .0625rem var(--tabs-color-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.tabbed-content>:first-child{margin-top:0 !important}.tabbed-content>:last-child{margin-bottom:0 !important}.tabbed-content>.tabbed-set{margin:0}.tabbed-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.tabbed-set>input{opacity:0;position:absolute}.tabbed-set>input:checked+label{border-color:var(--tabs-color-label-active);color:var(--tabs-color-label-active)}.tabbed-set>input:checked+label+.tabbed-content{display:block}.tabbed-set>input:focus+label{outline-style:auto}.tabbed-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.tabbed-set>label{border-bottom:.125rem solid transparent;color:var(--tabs-color-label-inactive);cursor:pointer;font-size:var(--tabs-size-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .tabbed-set>label:hover{color:var(--tabs-color-label-active)} diff --git a/book/content/_build/html/_panels_static/panels-variables.06eb56fa6e07937060861dad626602ad.css b/book/content/_build/html/_panels_static/panels-variables.06eb56fa6e07937060861dad626602ad.css deleted file mode 100644 index 521a5511..00000000 --- a/book/content/_build/html/_panels_static/panels-variables.06eb56fa6e07937060861dad626602ad.css +++ /dev/null @@ -1,7 +0,0 @@ -:root { ---tabs-color-label-active: hsla(231, 99%, 66%, 1); ---tabs-color-label-inactive: rgba(178, 206, 245, 0.62); ---tabs-color-overline: rgb(207, 236, 238); ---tabs-color-underline: rgb(207, 236, 238); ---tabs-size-label: 1rem; -} diff --git a/book/content/_build/html/_sources/base.rst b/book/content/_build/html/_sources/base.rst deleted file mode 100644 index 6e2dd9d4..00000000 --- a/book/content/_build/html/_sources/base.rst +++ /dev/null @@ -1,4 +0,0 @@ -Base class -============= -.. automodule:: selector.base - :members: diff --git a/book/content/_build/html/_sources/dissimilarity.rst b/book/content/_build/html/_sources/dissimilarity.rst deleted file mode 100644 index 627d8555..00000000 --- a/book/content/_build/html/_sources/dissimilarity.rst +++ /dev/null @@ -1,4 +0,0 @@ -Dissimilarity based methods -============= -.. automodule:: selector.dissimilarity - :members: diff --git a/book/content/_build/html/_sources/installation.ipynb b/book/content/_build/html/_sources/installation.ipynb deleted file mode 100644 index 225ccd26..00000000 --- a/book/content/_build/html/_sources/installation.ipynb +++ /dev/null @@ -1,192 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f1be9e2f", - "metadata": {}, - "source": [ - "# Installation\n", - "\n", - "## Stable releases\n", - "\n", - "
\n", - "Warning:\n", - "\n", - " \n", - "We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the “Latest git revision” section below.\n", - "
\n", - "\n", - "The following dependencies are required to run selector properly,\n", - "\n", - "* Python >= 3.6: http://www.python.org/ \n", - "* NumPy >= 1.21.5: http://www.numpy.org/\n", - "* SciPy >= 1.5.0: http://www.scipy.org/\n", - "* PyTest >= 5.3.4: https://docs.pytest.org/\n", - "* PyTest-Cov >= 2.8.0: https://pypi.org/project/pytest-cov\n", - "\n", - "Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below.\n", - "\n", - "\n", - "## Installation with Ana- or Miniconda:\n", - "\n", - "1. To install selector using the conda package management system, install [miniconda](https://conda.io/miniconda.html) or [anaconda](https://www.anaconda.com/download) first, and then:\n", - "\n", - "```\n", - "# Activate your main conda environment if it is not loaded in your .bashrc.\n", - "# E.g. run the following if you have miniconda installed in e.g. ~/miniconda3\n", - "source ~/miniconda3/bin/activate\n", - "\n", - "# Create a horton3 conda environment. (optional, recommended)\n", - "conda create -n horton3\n", - "source activate horton3\n", - "\n", - "# Install the stable release.\n", - "conda install -c theochem qc-selector\n", - "\n", - "# Unstable releases\n", - "# (Only do this if you understand the implications.)\n", - "# Install the testing release. (beta)\n", - "conda install -c theochem/label/test qc-selector\n", - "# Install the development release. (alpha)\n", - "conda install -c theochem/label/dev qc-selector\n", - "```\n", - "\n", - "## Installation with Pip\n", - "\n", - "1. You can work in a [virtual environment](https://docs.python.org/3/tutorial/venv.html):\n", - "\n", - "```\n", - "# Create a virtual environment in ~/horton3\n", - "# Feel free to change the path.\n", - "python3 -m venv ~/horton3\n", - "\n", - "# Activate the virtual environemnt.\n", - "source ~/horton3/bin/activate\n", - "\n", - "# Install the stable release in the venv horton3.\n", - "pip3 install qc-selector\n", - "# alternative: python3 -m pip install qc-selector\n", - "\n", - "# For developers, install a pre-release (alpha or beta).\n", - "# (Only do this if you understand the implications.)\n", - "pip3 install --pre qc-selector\n", - "# alternative: python3 -m pip install --pre qc-selector\n", - "```\n", - "\n", - "\n", - "2. You can install into your `{$HOME}` directory without creating a virtual environment\n", - "\n", - "```\n", - "# Install the stable release in your home directory.\n", - "pip3 install qc-selector --user\n", - "# alternative: python3 -m pip install qc-selector --user\n", - "\n", - "# For developers, install a pre-release (alpha or beta).\n", - "# (Only do this if you understand the implications.)\n", - "pip3 install --pre qc-selector --user\n", - "# alternative: python3 -m pip install --pre qc-selector --user\n", - "```\n", - "\n", - "This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options.\n", - " \n", - "In case the `pip3` executable is not found, pip may be installed in a directory which is not included in your `${PATH}` variable. This seems to be a common issue on macOS. A simple workaround is to replace `pip3` by `python3 -m pip`.\n", - "\n", - "In case Python and your operating system are up to date, you may also use `pip` instead of `pip3` or `python` instead of `python3`. The `3` is only used to avoid potential confusion with Python 2. Note that the `3` is only present in names of executables, not names of \n", - "Python modules.\n", - "\n", - "## Latest git revision\n", - "\n", - "This section shows how one can install the latest revision of selector from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, …) and so be prepared to accept them when using the following installation instructions.\n", - "\n", - "There are two installation methods:\n", - "\n", - "1. **Quick and dirty.** Of this method, there are four variants, depending on the correctness of your `PATH` variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section.\n", - "```\n", - "# with env, correct PATH\n", - "pip install git+https://github.com/theochem/Selector.git\n", - "# with env, broken PATH\n", - "python -m pip install git+https://github.com/theochem/Selector.git\n", - "# without env, correct PATH\n", - "pip install git+https://github.com/theochem/Selector.git --user\n", - "# without env, broken PATH\n", - "python -m pip install git+https://github.com/theochem/Selector.git --user\n", - "```\n", - "\n", - "2. **Slow and Smart.** In addition to the four variations in the quick and dirty method, the slow and smart can be used with `pip` or just with `setup.py`. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you.\n", - "```\n", - "# A) Clone git repo with https OR ssh:\n", - "# The second one only works if you have ssh set up for Github\n", - "# A1) https\n", - "git clone https://github.com/theochem/Selector.git\n", - "# A2) ssh\n", - "git clone git@github.com:theochem/Selector.git\n", - "# B) Optionally write the version string\n", - "pip install roberto # or any of the three other ways of running pip, see above.\n", - "rob write-version\n", - "# C) Actual install, 6 different methods.\n", - "# C1) setup.py, with env\n", - "python setup.py install\n", - "# C2) pip, with env, correct PATH\n", - "pip install .\n", - "# C3) pip, with env, broken PATH\n", - "python -m pip install .\n", - "# C4) setup.py, without env\n", - "python setup.py install --user\n", - "# C5) pip, without env, correct PATH\n", - "pip install . --user\n", - "# C6) pip, without env, broken PATH\n", - "python -m pip install . --user\n", - "```\n", - "\n", - "\n", - "## Testing\n", - "\n", - "The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation.\n", - "\n", - "With Ana- or Miniconda:\n", - "```\n", - "# Install pytest in your conda env.\n", - "conda install pytest pytest-xdist\n", - "# Then run the tests.\n", - "pytest --pyargs selector -n auto\n", - "```\n", - "\n", - "With Pip:\n", - "```\n", - "# Install pytest in your conda env ...\n", - "pip install pytest pytest-xdist\n", - "# .. and refresh the virtual environment.\n", - "# This is a venv quirk. Without it, pytest may not find IOData.\n", - "deactivate && source ~/selector/activate\n", - "\n", - "# Alternatively, install pytest in your home directory.\n", - "pip install pytest pytest-xdist --user\n", - "\n", - "# Finally, run the tests.\n", - "pytest --pyargs selector -n auto\n", - "```" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/book/content/_build/html/_sources/intro.md b/book/content/_build/html/_sources/intro.md deleted file mode 100644 index 3de34b3e..00000000 --- a/book/content/_build/html/_sources/intro.md +++ /dev/null @@ -1,20 +0,0 @@ - -# Welcome to QC-Selector's Documentation! - -[selector](https://github.com/theochem/Selector) is a free, open-source, and cross-platform Python library designed to help you effortlessly identify the most diverse subset of molecules from your dataset. Please use the following citation in any publication using selector library: - -**"QC-Selector: A Generic Python Package for Subset Selection"**, Fanwang Meng, Alireza Tehrani, Valerii Chuiko, Abigail Broscius, Abdul, Hassan, Maximilian van Zyl, Marco Martínez González, Yang, Ramón Alain Miranda-Quintana, Paul W. Ayers, and Farnaz Heidar-Zadeh" - -The selector source code is hosted on [GitHub](https://github.com/theochem/Selector) and is released under the [GNU General Public License v3.0](https://github.com/theochem/Selector/blob/main/LICENSE). We welcome any contributions to the selector library in accordance with our Code of Conduct; please see our [Contributing Guidelines](https://qcdevs.org/guidelines/QCDevsCodeOfConduct/). Please report any issues you encounter while using selector library on [GitHub Issues](https://github.com/theochem/Selector/issues). For further information and inquiries please contact us at qcdevs@gmail.com. - - -## Why QC-Selector? - -In the world of chemistry, selecting the right subset of molecules is critical for a wide range of applications, including drug discovery, materials science, and molecular optimization. QC-Selector offers a cutting-edge solution to streamline this process, empowering researchers, scientists, and developers to make smarter decisions faster. - -## Key Features -1. Import Your Dataset: Simply import your molecule dataset in various file formats, including SDF, SMILES, and InChi, to get started. -2. Define Selection Criteria: Specify the desired level of diversity and other relevant parameters to tailor the subset selection to your unique requirements. -3. Run the Analysis: Let QC-Selector's powerful algorithms process your dataset and efficiently select the most diverse molecules. -4. Export: Explore the diverse subset and export the results for further analysis and integration into your projects. - diff --git a/book/content/_build/html/_sources/partition.rst b/book/content/_build/html/_sources/partition.rst deleted file mode 100644 index c7d78299..00000000 --- a/book/content/_build/html/_sources/partition.rst +++ /dev/null @@ -1,5 +0,0 @@ -Partition based methods -============= - -.. automodule:: selector.partition - :members: diff --git a/book/content/_build/html/_sources/starting.ipynb b/book/content/_build/html/_sources/starting.ipynb deleted file mode 100644 index 0613d4da..00000000 --- a/book/content/_build/html/_sources/starting.ipynb +++ /dev/null @@ -1,776 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "bc778cac", - "metadata": {}, - "source": [ - "# Getting started\n", - "## Demo - Dissimilarity Based Selection Synthetic Data" - ] - }, - { - "cell_type": "markdown", - "id": "073d04b2", - "metadata": {}, - "source": [ - "In this tutorial, we are going to show how the `QC-Selector` work with 2D synthstic data. Each axis represents one feature. For each example, we will have two different synthstic datasets where the first one can be seen as randomly generated data points and the latter generates data points beloing to different clusters. By using 2D feature data points, it makes visualization easy." - ] - }, - { - "cell_type": "markdown", - "id": "edfc38fb", - "metadata": {}, - "source": [ - "## Generating Synthetic Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "feb64be2", - "metadata": {}, - "outputs": [], - "source": [ - "# install the selector module\n", - "!pip install git+https://github.com/theochem/Selector\n", - "!pip install rdkit" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "6b21c8c6", - "metadata": {}, - "outputs": [], - "source": [ - "import selector\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from typing import Any, Tuple, Union\n", - "from sklearn.datasets import make_blobs\n", - "from sklearn.metrics import pairwise_distances\n", - "\n", - "def generate_synthetic_data(n_samples: int = 100,\n", - " n_features: int = 2,\n", - " n_clusters: int = 2,\n", - " cluster_std: float = 1.0,\n", - " center_box: Tuple[float, float] = (-10.0, 10.0),\n", - " metric: str = \"euclidean\",\n", - " shuffle: bool = True,\n", - " random_state: int = 42,\n", - " pairwise_dist: bool = False,\n", - " **kwargs: Any,\n", - " ) -> Union[Tuple[np.ndarray, np.ndarray],\n", - " Tuple[np.ndarray, np.ndarray, np.ndarray]]:\n", - " \"\"\"Generate synthetic data.\n", - "\n", - " Parameters\n", - " ----------\n", - " n_samples : int, optional\n", - " The number of samples. Default=100.\n", - " n_features : int, optional\n", - " The number of features. Default=2.\n", - " n_clusters : int, optional\n", - " The number of clusters. Default=2.\n", - " cluster_std : float, optional\n", - " The standard deviation of the clusters. Default=1.0.\n", - " center_box : tuple[float, float], optional\n", - " The bounding box for each cluster center when centers are generated at random.\n", - " Default=(-10.0, 10.0).\n", - " metric : str, optional\n", - " The metric used for computing pairwise distances. For the supported\n", - " distance matrix, please refer to\n", - " https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html.\n", - " Default=\"euclidean\".\n", - " shuffle : bool, optional\n", - " Whether to shuffle the samples. Default=True.\n", - " random_state : int, optional\n", - " The random state used for generating synthetic data. Default=42.\n", - " pairwise_dist : bool, optional\n", - " If True, then compute and return the pairwise distances between samples. Default=False.\n", - " **kwargs : Any, optional\n", - " Additional keyword arguments for the scikit-learn `pairwise_distances` function.\n", - "\n", - " Returns\n", - " -------\n", - " syn_data : np.ndarray\n", - " The synthetic data.\n", - " class_labels : np.ndarray\n", - " The integer labels for cluster membership of each sample.\n", - " dist: np.ndarray\n", - " The symmetric pairwise distances between samples.\n", - "\n", - " \"\"\"\n", - " # pylint: disable=W0632\n", - " syn_data, class_labels = make_blobs(n_samples=n_samples,\n", - " n_features=n_features,\n", - " centers=n_clusters,\n", - " cluster_std=cluster_std,\n", - " center_box=center_box,\n", - " shuffle=shuffle,\n", - " random_state=random_state,\n", - " return_centers=False,\n", - " )\n", - " if pairwise_dist:\n", - " dist = pairwise_distances(X=syn_data,\n", - " Y=None,\n", - " metric=metric,\n", - " **kwargs,\n", - " )\n", - " return syn_data, class_labels, dist\n", - " else:\n", - " return syn_data, class_labels" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "12c42ad7", - "metadata": {}, - "outputs": [], - "source": [ - "coords, class_labels, arr_dist = generate_synthetic_data(n_samples=100,\n", - " n_features=2,\n", - " n_clusters=1,\n", - " pairwise_dist=True,\n", - " metric=\"euclidean\",\n", - " random_state=42)\n", - "\n", - "coords_cluster, class_labels_cluster, arr_dist_cluster = generate_synthetic_data(n_samples=100,\n", - " n_features=2,\n", - " n_clusters=3,\n", - " pairwise_dist=True,\n", - " metric=\"euclidean\",\n", - " random_state=42)\n", - "def graph_data(coords, selected=None, reference=False):\n", - " plt.figure(dpi=150)\n", - " plt.scatter(coords[:, 0], coords[:, 1])\n", - " if selected:\n", - " for i, mol_id in enumerate(selected):\n", - " plt.scatter(coords[mol_id, 0], coords[mol_id, 1], c='r')\n", - " plt.text(coords[mol_id,0], coords[mol_id,1], str(i+1))\n", - " if reference:\n", - " plt.scatter(coords[0, 0], coords[0, 1], c='black')\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0ae728a4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxgAAAIFCAYAAABRQluVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAABcSAAAXEgFnn9JSAABVPElEQVR4nO3df3xcZZ33//eHNCSUlh8p5V6UBNOWVhOLP9omFUTtsog/NqvUbrWuiFtu94e4q3dXXLj31tBdv1tWUdFVbncVtIv7rdRs/ZF1V1goaqG2aQMCJgsNpNBUxKYtYFJISMN1/zEzkKYzk3POXGfmzOT1fDz6GDIz5+TKAM15n+v6XB9zzgkAAAAAfDih1AMAAAAAUDkIGAAAAAC8IWAAAAAA8IaAAQAAAMAbAgYAAAAAbwgYAAAAALwhYAAAAADwhoABAAAAwBsCBgAAAABvCBgAAAAAvCFgAAAAAPCGgAEAAADAmxmlHkA5M7MnJc2UNFDqsQAAAAAe1Ut61jn3O2EPNOdcDOOZHszstzU1NbPnz59f6qEAAAAA3jz66KMaHR0dcs6dEvZYZjAKMzB//vymnp6eUo8DAAAA8Ka5uVm9vb2RVulQgwEAAADAGwIGAAAAAG8IGAAAAAC8IWAAAAAA8IaAAQAAAMAbAgYAAAAAbwgYAAAAALwhYAAAAADwhoABAAAAwBsCBgAAAABvCBgAAAAAvCFgAAAAAPBmRqkHAADlanBoVLfu2qedew9rePSoZtXM0PJ5c7R6ab3mzq4p9fAAACgJAgYAhDQyNq71nT3q6N6vsXF3zGvb+g7qhjv2aNWSerW3Nam2uqpEowQAoDQIGAAQwsjYuC6/uUs79x7O+Z6xcadNXfvUPzisjWtbCBkAgGmFGgwACGF9Z0/ecDHRzr2Htb6zN+YRAQCQLAQMAAjowNCIOrr3hzqmo3tAg0OjMY0IAIDkIWAAQECbdw0cV3MxlbFxp827B2IaEQAAyUMNBgAEFHRp1GQ7+g/pyhULQh/HLlUAgHJEwACAgIZHjxblOJ+7VBFSAADFRsAAgIBm1UT7KzPMcb52qWIrXQBAqVCDAQABtTbWRTpu+bw5gd/rY5eqTEjZ1JW7ZiQTUi6/uUsjY+OBxwcAwFQIGAAQ0Opl9aquslDHVFeZVi+tD/ReX7tUsZUuAKCUCBgAENCZs2u1asnZoY5ZtSR4rYOPXari3Ep3cGhUX9nap8tu2qlLb7xHl920U1+96xG24QUAHIMaDAAIob2tWf2DRwLNELQ21qm9rSnwuX3sUlVISMm10xX1HACAMJjBAIAQaqurtHFti9a0NORcLlVdZVrT0pCzADsXH7tUFRJSsqGeAwAQFjMYABBSbXWVNqxcrHUXL9Tm3QPa0X/IyxawPnap8r2VbpR6jg0rF0caAwCgMhAwACCiubNrdOWKBZGa6GXT2linbX0HQx83cZcqn1vpRq3nWHfxQnpsAMA0xhIpAEgIH7tU+dxK10fROQBg+iFgAIBnUXdb8rFLlc+tdH3XcwAApofYlkiZ2RJJF0tqSf95uSQ55/L+5jOzD0n6iKQmSc9L2iHpM8657RHGUCXpLyWtlbRA0rCkuyS1O+f+O+z5ACAfH7sttbc16+Enh3Tvvqen/H7ZdqnKhJRNXcFnEXJtpeu7ngMAMD3EWYPxKUnvCnOAmd0g6WOSnpN0u6RapULKW81slXPu+yHOdYKk70q6VNLTkn4k6QxJqyS908xWOOe6wowPAHLJ7LaU765/Zrel/sHhrDtMZQLKA/ufzvu9Zpxg+sOluYNKoSElw2c9BwBg+ojzt8DPJT0gaVf6z2OSclb9mdnvKRUuDkl6g3OuL/38GyT9RNI3zewnzrmnA37/tUqFiz5JFzrnfpM+33skdUj6VzN7lXOOW20AClbobktBAkrGeWefmjNc+AopUvSic+eky27a6WVnLQBA+YmtBsM59w/OuU875zqdc08GOGRd+vEzmXCRPs/PJX1N0mmSrggxhMz5PpkJF+nz/ZukHyq1ZCrUDAsAZOOje3aYgHLvvqe1vrP3uOcn9qw4+kL+c+QLKRlR6jkk6e5HDmpb30Hdt+9pbes7qM/d9rDOv+5OXbPlQfpkAMA0kIgibzM7SdLvpr/syPKWzHNtAc/XKOlVSi21+lGh5wOAfArdbclHQJH8hJSJohSd50IzPgCYPhIRMCQtUmr51KBzLttv2XvTj+cFPN9r0o+/dM6NeTgfAORU6G5LPraD9RVSJmtva4689W02meVhUUTdnQsAUFxJCRgN6cesvx2dc0eUKtQ+3cxmF3q+Cc+fE3SAAJBLobst+dgONq6eFbXVVdq4tkVrWhoiLZfKJkiwmWhkbFzXbHlA5193p66/fQ/LrwAg4ZKy1ces9OOzed5zRKk6jNmShgo835H0Y5CwIjPryfHS/CDHA6hshe625GM72EJCylSdyGurq7Rh5WKtu3ihNu8e0I7+Qy8WcDuXqrkIIxNsgnRA97E7FwCguJIygwEAZavQ7tk+toMtRs+KubNrdOWKBbrlilZ97yMX6JYrWmURJzWCNuOLsjsXAKC0kjKDMZx+nJnnPSenH6eavQhyvjDnknOuOdvz6ZmN7BvIA6hIg0OjunXXPu3ce/jFu/ivfvmpmnGCpty5aaKJ3bOjbgebCShS6XpWxBlsotaVrLt4IVviAkAJJSVg7Es/Zt2uxMxOVmp51FPOuSChIO/5Jjz/eNABApjepurSfULIO/kTu2evXlavL93ZF6qGYmJAkfyElCjiDDaF1JUEWX4FAIhHUpZIPSxpVNJcM3t5ltdfn358IOD57k8/vtrMqj2cD8A0NrG/RK4L3hdCXAcve8Xpx3TPjrId7MSAIkXrWTE5pERR6PKwfHwUvwMAii8RAcM595ykrekv/zDLW1alHzsDnm+vpP+WdJKkdxZ6PgDTW5g6gECyhJEw28G2NtYdE1AkPyElijiDTTHqSgAA/iUiYKR9If34f8zs3MyTZvYGSX+q1Da1N008wMxazOwhM7szz/k+a2ZnTjhmpaQ/kPSIpB/4Gz6AShSlDmAqux5/6rhi5CDbwVZXmda0NOTcKanQkBJFnMGmVHUlAIDCxPa3sJm9U9KnJjx1Yvr5HROe+zvn3I8kyTl3h5l9SdLHJP3CzP4rfczFkkzSHzvnnp70bWYq1aSvNssQbpb0DkmXSsqEkDMkvVmpDt8fcM5xmwuocNmKspfPm6PVS4Nd5EapAwgiWzFyvu1gg4w5E1LWd/aqozv7uKurTKuW1Ku9rcnbdq7tbc3qHzwSaJYnTLApVV0JAKAw5pz/X5ySZGYfkvTNKd72x865b2U57qOSXiXpeUk7lAoi27N8j7dIukvS4865V2R5vUqpwLJWqZ4VR9Lvb3fOFbyXoZn1NDU1NfX05GqTAaBU8hVlS9KME6Sml52qWTUz9NzYeM6L+Mtu2hnpIjeIqy5ZFFsx8uDQaKSQElXq8/YbbA4MjeiC67aGLn7ffvVF7CIFAAVqbm5Wb29vb67dVPOJLWBMBwQMIJmCNGfLZfKF8KU33qP79j3tf5CSLjz3DN1yRWss5y4V38Hmmi0PaFNX/m7jE61padCGlYtDfx8AwLEKCRgsVAVQ1rItgXrmuTE9sP+ZSOeb3BU6zvX8lViMnGnG52tmJq7lVwCA+BAwAJSlqZZAFSrTFTpqHUAQ5VCMXGgNS6FKVVcCAIgu+b/dAGCSQpZAhdHRPaAffvSNoZvgBZXkYuSpGgvecMeeol3UF1r8DgAoLgIGgLLjvS9FDmPjTlsfOqBVS84OVQcQhI8md3EJEuAmLyUrxsyB7+VXAIB4JKkPBgBMKY6+FPns6D8Uqr9EUD6a3MUlTIDLLCUDACCDgAGgrMTVlyKX4dGjgZrghZHkYuQoAa6je0CDQ6MxjQgAUG4IGADKSjGWRk2UKcTO1AFsv/oi/flb5itKzJhxgvJ24k6CKAFubNxp826/S8gAAOWLgAGgrBR7a9fJhdhzZ9fo5BOrFGUO5U/eNF8bVi5ObLiQoge4Hf2HPI8EAFCuCBgAykoxt3bNVYgd9SL8wV9F681RTFEDXCX29AAARMMuUgDKSpx9KSbLVYhdyRfhUQOc7+BX6v4bAIDoCBgAysrqZfWx9aWYKF8hdtSL6V8/PaKRsfFEL5GKGuB89fRIUv8NAEA0BAwAZeXM2bWh+1Kcd/apOvWkag2PHtVJ1VUaHj2q3id+q6MvZO8K/c7zXqZX1M3Uh/9ld9a751Evwp/87Yguv7krb5F3qe/cRwlwvnp6JLX/BgAgHHOueNs9Vhoz62lqamrq6ekp9VCAaSVMJ+/WxrqsF6KDQ6PHdYVecs7peuzgs/rRg09kvcCurjKtWlKvtW88R2/94jZF/etzTUuDNqxcfNzPlOvO/cTvXYw799dseSBUgMv285TT9wUAHK+5uVm9vb29zrnmsMcSMApAwABKJ3VB3quO7uzbqoa9IA8TWmbXztDQSPR6iuoq0/arL3pxRsJHYJqskJmQOMYzlQNDI7rguq2hZ04mfo4AAH8IGCVCwABKL9tMRJQlRWHvnhfqqksW6coVCyJ973x37n3NhPgOcFP5ytY+XX/7ntDHTfwcAQD+FBIwqMEAUNbmzq7RlSsWFHSRGaV7daF29B/SlSsWRO6cve7ihccFKJ81DJnGgusuXuglwE2lkP4bBAwASBYCBoBpL0r36kJltqwtpHP25Avr9Z09gS/Ud+49rPWdvVPWMPgIcEFU8ta/ADDdEDAAlFSpd02Sot89L8RJ6ZkDX3fufc6ElEJS+m8AAArH38wASiJJ/Q5KcRc88z193bn3ORNSCqXuvwEA8OeEUg8AwPSTqRXY1JX7ojhTK3D5zV0aGRuPdTyluAve+8QzGhwa9XbnPupMyPZHitMVfSqrl9WruspCHeOr/wYAwC8CBoCii1IrMDg0qq9s7dNlN+3UpTfeo8tu2qmv3vWIBodGCx5Pa2NdwecI6+gL0ubdA5G/9+Q791FnQu7f/3TsAS6ITAPFMFYtKd4yOgBAcAQMAEUVpVbgO7v26Q0b7tT1t+/Rtr6Dum/f09rWd1Cfu+1hnX/dnbpmy4MFXSRHuXvuw47+Q97u3EedCRkeTW1HmwTtbc2BA1drY53a25piHhEAIAoCBoCiilIr4Jx09IX4llJFuXvuw/DoUW937guZhenoHvAyE1So2uoqbVzbojUtDTlDV3WVaU1Lg5fmfgCAeBAwABRVXDs2ZZZSRRXm7vnsWj81G5lZBx937guZhckUeydBpv/G9qsv0lWXLNKF556h1zWcpgvPPUNXXbJI26++SBtWLiZcAECCETAAFFWcOzYVcic+zN3zuz+5Iu/7gsrUUfi4c1/oLMyO/kORj41Dpv/GLVe06nsfuUC3XNGqK1csoOYCAMoA29QCKKo4d2wqdNvVMN2rJ77vZ3sG1bX3sMIs/JpcR+Gjc3Z7W7M6739Cw6Phl4rRsA4A4AsBA0BRRe13ENTkBnRRBO1ePfF912x5QJu6gi8zyrUDUiGds2urq3Te2adp+6PhZyNoWAcA8IXfKACKavWyen3pzr7Qhd5BlepOfHtbs/oHjwSqMQmzA1LYTufnz58TKWDQsA4A4As1GACKKu4dm0p1J973DkgjY+O6ZssDOv+6cNvz0rAOAFBqzGAAKLowd/vDKuWdeB91FNJLnc7zfT6Z7Xn7B4ePCSyZAOdjuRYAAFGYc/EsU5gOzKynqampqaenp9RDAcrOyFiqwVtHd/a+GDNOkF5wqT9BVVeZtl99UdaL5bBLjUopbD3HmpYGbVi5+MWvgwSUjNbGOnpKAACO09zcrN7e3l7nXHPYYwkYBSBgAIUbHBrNebf/C//1cEEX2lImyPSoo3t/1iBTXWVataRe7W1NibjIPjA0oguu2xqqRiVbsJoqwEX5ucsppAEACkPAKBECBhCvQu/El+Od/K9s7dP1t+8JfdxVlyzKuvNUvgAXNBSUW0gDABSukIBBDQaAxMoUTke9E7++sydwnUemE/jkGZBii1qXkmt73kK2vZUKqwcBAExPBAwAiRa1cPrA0Ig6uveH+l4d3QNad/HCki73ibrNblzb85ZjSAMAlBYBA0BZCHsnfvOu7DMe+YyNO6362nbVnXxiyeoLom6zG8f2vOUa0gAApUUfDAAVKepSo8cPPRuo30RcWhvrIh33zHNj3scYNaRt3h28MB8AUHkSEzDM7C1m5gL8+XTA8z02xXleGffPBKB0fC0ZytQXXH5zV1FCRpRGeZL0wP5nvI+xkHoQAMD0laQlUk9K2pjjtSpJH0j/87aQ5811zmdCngdAGfG9ZKhY9QVRGuVl+B5j0upBAADlITEBwzn3kKQPZXvNzN6uVMAYkPSTkOfNek4Ala21sU7b+g56PWex6gsK6XTuc4xJqgcBAJSPxCyRmkJm9uJfHY07AAQQdalRPsWqL8hsz3ve2aeGPtbnGKPWgyyfN8fL9wcAlKfEBwwzO1nSu9Jf3lLKsQAoH5mlRr4Vq76gtrpKp55UHelYX2OMEtKqq0yrl9Z7+f4AgPJUDvPYKyWdLOk+51xv2IPN7CpJ8yWNSuqR9D3n3KDfIQJIokKWGuVSzPqCQmsgBodGdeuufdq593CkLt5R6kFWLSnutr4AgOQph4CRWR4Vdfbis5O+/qKZ/YVz7uagJzCznhwvzY84JgBFEKQTeFjFrC+I+r1Oqq7SNVseUEf3/uN+5m19B3XDHXtydj+fLExIa22sU3tbU6QxAwAqR6KXSJnZWZIukjQuaVPIw3+o1OzHOZJmSnq1pC9IqpH0DTN7V55jAVSITCfw7VdfpKsuWaQLzz1Dr2s4TefMmRnpfMWsL4haAzFw+Flt6sodqMJsvZsJaWtaGnIul6quMq1padDGtS1TBhYAQOWzJNdMm9k6SZ+X9GPn3Ns9nfPDkv5Z0sPOuYJ6YZhZT1NTU1NPT64JDgBJdWBoRBdctzXUrEZ1lWn71RcVbQlQlDGaSWH+Wl/T0hB4W9vBoVFt3j2gHf2HIi25AgCUj+bmZvX29vY655rDHpv0JVKFLo/K5iZJn5G0yMxe4Zx7zOO5AZSJcqgviNQTI+Q9ozDb2s6dXaMrVyzQlSsWhPsmAIBpJbFLpMzsVZJeJ2lY0vd9ndc594KkR9NfnuXrvADKT3tbc+BlSKWqLwgzRil0vija1rsAgOkjsQFD0mXpxy3OuWc9n/v09OMRz+cFUEbKob4gyBgLVaytdwEA00Mil0iZmUl6f/pLr70vzKxZ0iJJz0p6yOe5AZSfTBH4uosXJra+INsYf/vcmB47dETPPFf4trnF3HoXAFD5EhkwJF2o1O5Pv5K0NdebzOyjkj6qVG+LayY8/w5JI865rZPef56k70gySd9wzj0fw9gBlKFyqC+YOMZrtjyg+/c/4+W8xdx6FwBQ+ZL6WyVT3P3/p2smcjlDqdmIybUULZLazexxSfcrNVsxT9LrlfqZfyLpap8DBoBiOTA0oo7u/d7OV8ytdwEAlS9xAcPMaiStSn/57YinuU1SvaRlki6QdKqk30q6W9K/Svqmcy7/5u8AkFCbd/lpGiilakxWL633ci4AAKQEBgzn3KikQFumOOeulXRtlud/LunnXgcGAAkRpKt2UMXeehcAUPmSvIsUACALX0XZpdp6FwBQ2RI3gwEAyK/QouwTTHrvsga1tzWVZOtdAEBlI2AAQJlpbazTtr6DkY49waT/+MsL9cqzTvE8KgAAUlgiBQBlZvWy+shN9967rIFwAQCIFQEDAMrMmbNrtWrJ2aGPo+YCAFAMBAwAKEPtbc1qbQy04Z5M0uql9dq4toWaCwBA7AgYAFCGaqurtHFti9a0NORcLmWSzjv7VG376xX67KrzCBcAgKKgyBsAylRtdZU2rFysdRcv1ObdA9rRf0jDo0c1q2aGls+bo9VL6XEBACg+AgYAlLm5s2t05YoFunLFglIPBQAAlkgBAAAA8IeAAQAAAMAbAgYAAAAAbwgYAAAAALwhYAAAAADwhoABAAAAwBsCBgAAAABvCBgAAAAAvCFgAAAAAPCGgAEAAADAGwIGAAAAAG8IGAAAAAC8IWAAAAAA8IaAAQAAAMAbAgYAAAAAbwgYAAAAALwhYAAAAADwhoABAAAAwBsCBgAAAABvCBgAAAAAvCFgAAAAAPCGgAEAAADAGwIGAAAAAG8IGAAAAAC8IWAAAAAA8IaAAQAAAMAbAgYAAAAAbxIVMMzsJ2bm8vx5W8jznW5mXzKzx81sNP14g5mdFtOPAAAAAExrM0o9gBz+TdJwlud/FfQEZnaGpJ9LWiCpX9L3JTVL+pikt5vZG5xzhwsfKgAAAICMpAaMTzjnHivwHDcoFS62SHqvc+6oJJnZlyX9haQvSPpQgd8DAAAAwASJWiLli5mdJWmNpOclfSQTLtKukjQo6QNmdmYpxgcAAABUqooMGJLeptTPts0595uJLzjnRiV1SqqS9I4SjA0AAACoWEldInWFmc2R9IKkPZK+75zbF+L416Qf783x+r2S1ko6L/oQAQAAAEyW1IDxfyZ9fb2Z/Z1z7u8CHt+Qftyf4/XM8+cEOZmZ9eR4aX7A8QAAAADTQtKWSP1M0mVKXbjPlLRI0t9IOirpb83sYwHPMyv9+GyO14+kH2dHHCcAAACALBI1g+Gc+/Skp/ZI+nsz2y3pNknXmtk/O+eeK/K4mrM9n57ZaCrmWAAAAIAkS9oMRlbOudsl7ZZ0mqTWAIdkemjMzPH6yenHocJGBgAAAGCisggYaX3px7MCvDdTEH52jtczzz9e0IgAAAAAHKOcAsbp6ccjed+Vcn/68fU5Xs88/0BBIwIAAABwjETVYORiZnMlXZj+MtfWsxP9WKktbi80szOdcwcmnKtGUpukcUn/4XusAAAASBkcGtWtu/Zp597DGh49qlk1M7R83hytXlqvubNrSj08xCQxAcPMzpd0pqRO59z4hOdfIenbStVN/NA5t3/Cax+V9FFJ33POXZN53jn3azPbJOmPJN1oZu+b0M37s5LmSto4MXgAAADAj5Gxca3v7FFH936NjbtjXtvWd1A33LFHq5bUq72tSbXVVSUaJeKSmIAhaaGkb0p60szulfS0Un0qlkiqldQj6cOTjjlDqa1ss9VlfFzScknvkfRQeieqZkmvVqqeY533nwAAAGCaGxkb1+U3d2nn3sM53zM27rSpa5/6B4e1cW0LIaPCJKkGY6ek/yvpCUnLJK1WKgz8QtJfSVoWZsbBOXdQUoukf5R0oqRLJZ0q6cuSWpxzuf+rBwAAQCTrO3vyhouJdu49rPWdvTGPCMVmzrmp34WszKynqampqacnV6NvAACA6ePA0IguuG7rccui8qmuMm2/+iJqMhKmublZvb29vbn6weWTpBkMAAAAlLHNuwZChQsptVxq8+6BmEaEUkhSDQYAAADKWNClUZPt6D+kK1csCPx+dqdKNgIGAAAAvBgePTr1mwo4jt2pygMBAwAAAF7Mqol2aRnkOHanKh/UYAAAAMCL1sa6SMctnzdnyvewO1X5IGAAAADAi9XL6lVdZaGOqa4yrV5an/c9B4ZG1NG9P+97JuvoHtDg0GioY+AHAQMAAABenDm7VquWnB3qmFVLpi7MZneq8kLAAAAAgDftbc2Bl0q1Ntapva1pyvcVsjsVio+AAQAAAG9qq6u0cW2L1rQ05FwuVV1lWtPSELgQO+7dqeAXu0gBAADAq9rqKm1YuVjrLl6ozbsHtKP/UEH9KuLcnQr+8akDAAAgFnNn1+jKFQtCNdHLprWxTtv6DoY+LsjuVPCPJVIAAABItLh2p0I8CBgAAABItLh2p0I8CBgAAABIvDh2p0I8CBgAAABIvDh2p0I8KPIGAAAoQ4NDo7p11z7t3Hu4oB2ayonv3akQD3MuXFdEvMTMepqampp6enpKPRQAADBNjIyNa31njzq692ftbl1dZVq1pF7tbU3cxUdkzc3N6u3t7XXONYc9lhkMAACAMjEyNq7Lb+7K29l6bNxpU9c+9Q8Os1QIJUENBgAAQJlY39mTN1xMtHPvYa3v7I15RMDxCBgAAABl4MDQiDq694c6pqN7QINDozGNCMiOgAEAAFAGNu8ayFpzkc/YuNPm3QMxjQjIjoABAABQBoIujZpsR/8hzyMB8iNgAAAAlIHh0aNFPQ6IioABAABQBmbVRNv8M+pxQFQEDAAAgDLQ2lgX6bjl8+Z4HgmQHwEDAACgDKxeVq/qKgt1THWVafXS+phGBGRHwAAAACgDZ86u1aolZ4c6ZtWSes2dXRPTiIDsWJQHAABQJtrbmtU/eCTQjlKtjXVqb2sqwqjyGxwa1a279mnn3sMaHj2qWTUztHzeHK1eSvipVAQMAACAMlFbXaWNa1u0vrNXHd3Z+2JUV5lWLalXe1uTaqurSjDKlJGxca3v7FFH9/7jxrmt76BuuGNPIsYJ/wgYAAAAZaS2ukobVi7WuosXavPuAe3oP5S4mYGRsXFdfnNX3pmWsXGnTV371D84rI1rWwgZFYSAAQAAUIbmzq7RlSsW6MoVC0o9lOOs7+wJ3Bhw597DWt/Zqw0rF8c8KhQLAQMAACQSa/fL04GhEXV07w91TEf3gNZdvJB/rxWCgAEAABKFtfvlbfOu7LUh+YyNO23ePZCY2RjCbWEIGAAAIDFYu1/+gi6NmmxH/6GSBwzCrR/0wQAAAIkRZe0+kmV49GhRj/MlE243deWegcmE28tv7tLI2HiRR1g+CBgAACARoq7dHxwajWlEiGJWTbQFMlGP84Vw609iAoaZzTSzd5vZTWb2sJmNmNkRM7vfzD5tZrNCnu8xM3N5/rwyrp8FAACEV8jafSRHa2NdpOOWz5vjeSTBEW79SlINxvslfT39z/8t6YeSTpF0vqT1ktaY2ZudcwdCnndjjuefiTRKAAAQi3Jeu1+O4ipkXr2sXl+6sy9UWKyuMq1eWh/5exaqEgrTkyRJAWNM0j9LusE599+ZJ83sLEk/kvQ6STcoFUQCc859yN8QAQBAXMp17X6c4ggBcRcynzm7VquWnK1NXcFnllYtKe3uTIRbvxITMJxzG5VltsE592szu1LSdkkrzexE59zzRR8gAACIVbmu3Y9DXCGgWLt0tbc1q3/wSKAL99bGOrW3NYX+Hj4Rbv1KTA3GFO5PP9ZIKt0CPQAAEJtyXLsfhzh3M/JZyDw4NKqvbO3TZTft1KU33qPLbtqpr971iAaHRlVbXaWNa1u0pqVB1VWW9fjqKtOaloZEbDVMuPWrXD6VeenHMUmh5rDM7CpJ8yWNSuqR9D3n3KDf4QEAgEKV49r9OEQJARtWLp7yvT46bA8OjerbOx7TrbsG9Jvfjmryv6nJsysbVi7WuosXavPuAe3oP1TypnW5lpy9+mWnalvfwdDnq7Rw60u5BIyPpR9/7JwLW67/2Ulff9HM/sI5d7OHcQEAAE/Kce2+bz5CQC6FFDJf8cZGre/s0Xd3D+joC1MfM3GJ1dzZNbpyxYKS1ipMteRsxgnSCSa9EOLjqcRw60viA4aZvUPSFUrNXnwqxKE/lHSXpG5Jg0rNgqxVKqx8w8wOOed+EHAMPTlemh9iPAAAYArltnbftzh3M4payHzPIwf1sz2DoY8PM7sS145WUrC6k6lCUzaVFm59SnTASPeq+LYkk3SVc+7+KQ55kXPuLyc91SPpr8zsIaV2q/oHSYECBgAAKI7M2v31nb3q6M5+sV1dZQXtcpRkce5mFLUg+eEnh3ToSLT9daaaXYl7Rysp3JKzoOIMt3GGrWJJbMAws5dL+rGk0yV9wTn3JU+nvknSZyQtMrNXOOcem+oA51xzjjH2SKqsWycAAJRYbXVV4tbuF0ucuxlFLUg+HDFcSPlnV4qxo1WUJWcnmHSCmY5mWS8VZ7gtRtgqlkQGDDOrk3S7pHMkfVPSJ3yd2zn3gpk9KulMSWdJeszXuQEAgD9JWLtfbHHuZtTaWBepkDncgq3j5ZpdiauYfaIoS85ecNKfvXmeTq6ZUbRwW6ztg4slcQHDzGZJ+k+lZga2SPqwc67Q/7YnOz39eMTzeQEAwDRW6PKWqCEgyG5GUXbpMhUeMLLNrsRZzD5R1KVRD/7qGd1yRWvRwm0xwlYxJaoPhpnVKFUX0SLpNklrnHPBN3cO9j2aJS2S9Kykh3yeGwAATE8jY+O6ZssDOv+6O3X97Xu0re+g7tv3tLb1HdTnbntY5193p67Z8uCUPStWL6vP2Tcil6C7GWV26QqjbtaJod6fTbbZlUKK2cMohwZ6UcPW4FDYjVWLJzEBw8yqJG2S9LuStklaOVXHbjP7qJk9ZGYbJj3/DjP73SzvP0/Sd5UK5N+gIzgAAJgoX/O4XHw2xosSAsLsZtTe1hy4oWFrY51e+T9mhxpLNtlmVwopZg+jHBroFStsFVOSlkh9VNKl6X8+KOlGs6wJ/hPOuczc4RlKzUacNek9LZLazexxpbqAP6vUNrWvV+pn/omkq30OHgAAlK9CCmx9L2+Jc6vesLt0fWNbv+55NNxF/eRzZZtdKdbMQpxLznyJc+ewUklSwDh9wj9fmvNd0rVKBZB8bpNUL2mZpAsknSrpt5LulvSvkr7pe+kVAAAoT4UU2MZRSxD3Vr1hdulavaxeX/ivPaEa0E2Ua3blpIgFymFnFsqhO3w5LOMKKzEBwzl3rVLhoeBjnHM/l/RzD8MCAAAVrpAZiLga4xVjq94gu3SdObtWf/Cal+n7v3gi9Plf33Ba1tmVkbFx7Tv8bOjzSeFnFsqhO3w5LOMKK7kjAwAAiFmhMxBxL29Jwla9173nPN3z6KFQRcWvmDNTbzr3DH34X3YfF4y+8F8Pa/9Tz4UeR9SZhaR3hy+HZVxhJabIGwAAoNgKLbCtxOUtk9VWV+m//tebdGbAu/pzTj5R+596Tjfc+chxu2m9YcMdunVXtOLkqDMLmSVna1oacu7QVV1lWtPSUJL+EnHuHFYqzGAAAIBpq9AZiKQtb5nch+PEqhNUXWUaG3d6fvyFyEusTpt5on72yRW6ZsuD+sEvfpW1JmPGCVLdyTU6kGem4+gLUX4q6ezTTypoZiHJ3eHLYRlXWAQMAAAwbRU6A5GU5S35dsGabKpdsXKpra7SF9/7Wv3vd7wq60V632+G9f1f/MrHj3OchrqZXmYWkrDkLJukL+MKi4ABAACmrUJnIKJ2x/7ZnsHU8R7unAfZBWuyXLtiBZHtIv3A0IguuG5rqHGH8dwUDQrLXdw7hxUbAQMAAExbhc5ARFne4pRamrVz7+FIMwmThdkFa7IgfTmCiFLLEkaSd0zyJcnLuMKq/H9bAAAAOfjokxBmectkhcwkSNF2wZpsqr4cQUQNOEElecekiSbXwEQJB0ldxhUGAQMAAExbPgpsgyxvmUrQmYTJF7CHjzxf8MxBkL4cU4lzV6yk75gkFdYJvhIRMAAAwLTmo8B28vKWn+0ZVNfewwpz6Z9vJiFMEXcUQfty5BLnEqak75hUSCf4SkUfDAAAMK357JOQWd5y4blnhAoX0rH9NSbKXMBu6oqvzqHQGYjWxjpPIzn+vEnfMSlKJ/hKxwwGAACY9nwX2Prs8F1IEXdQhc5ARKllyadcdkwqtBN8pSJgAAAApPkqsPXV4dtHEXcQhRZRR6llyeacOTO1eml92eyYVEgn+HIu4p4KAQMAAMAzXx2+497+VcpdRB12R6RCdtPKaKibWVYX3j5nqioJAQMAAMAzXx2+414aJR1fRB11R6SJu2lt6toXaSxx7kYVB18zVZWGIm8AAADPVi+rz1kwnku2mYS4L0QnF1EHKSjP7Ih0+c1dGpnUYTtTy7LsnNMjjafcGur5mqmqNAQMAAAAzzI1CWFk2441rgvRXLti+doR6c2L5kYal8+GeoNDo/rK1j5ddtNOXXrjPbrspp366l2PaHBo1Nv3iLp7Vrk0DoyqsuMTAABAifjorxF1qVUuJunP3zJff3xB43FhxueOSD46pEdVzKZ3pfw5k4wZDAAAgBj46K8RZalVPu9radAn3/bKrEXaheyINJmvGZywCl3iFVapfs6kI2AAAADEJFOTsP3qi3TVJYt04bln6HUNp+nCc8/QVZcs0varL9KGlYtz3kmPcgGby1RN6wrZESmb9rbmwEuIfDXUK0XTu1L8nEnHEikAAICYFdJfo9DtX4M2rfO9I9LEXaU6urPPKPhsqFeqpnfF/jnLAQEDAAAgwYJewL7zvJfpFXNmqvvxpyJ1IfexI1Ku3hmdH32j7nzoQMEd0vMpZdM7353gyx0BAwAAIOGKcQFbSO+OoIXVX//g0tju4Ceh6Z2vTvDljoABAABQJuK8gI26I9K7XvsyXX5zV94L/Exhdf/gcM6C9kLR9C45KPIGAABA5B2RvnrXI0UvrM4m6hKvk6ZBTUSxETAAAAAgKfyOSB9ZMS9SYbXPZncTxxMFMxj+ETAAAAAgKXzvjh/c94S33hmFWr2sXjNOCN8zpPeJZwoKPMXoGF5uqMEAAADAi4ZGjurlp9Xq9Q2na9/hZ/Xc2LhOqq5SQ91MvWnh3GMKypNQWJ1x5uxaNZ11ih741TOhjjv6giLtJFXMjuHlhoABAACAvBfMT2tMB4dHNW/uLM2ufenyMWmF1bNqo13ahg08mY7hpS5sTyqWSAEAAExzmQvmTV25e0lkLpgvv7lLI2Pjkvz0zvDpufS4wgobeErRMbycEDAAAACmuagXzFELq5fPmxPpuKkUI/BE7Rg+nWoyCBgAAADTWCEXzKuX1ecsBs+lusq0eml9qGOCKkbgKaRj+HRBwAAAAJjGCrlgjto7o9Cu47kUI/AUUtg+XRAwAAAAprFCL5jD9s5ob2uK9P2CKEbgSVphexIRMAAAAKaxQi+Yw/bOiHs3pbgDT9IK25No+vykAAAAOI6PC+ba6iptWLlY6y5eqM27B7Sj/5CGR49qVs0MLZ8355jeGXHLBJ71nb3q6M6+/Ku6yiL3qGhtrNO2voOhxxVXYXsSETAAAACmMZ8XzHNn1+jKFQu8N9ELK87As3pZvb50Z1+oupU4C9uTiIABAAAwjVXyBXMcgSdT57GpK/iuUHEWtidR4mowzOwkM/tbM9tjZiNm9oSZ3WxmL49wrtPN7Etm9riZjaYfbzCz02IYOgAAQNlJ2k5Q5SBJhe1JlKgZDDOrlbRV0nJJv5b0A0mvkPTHkn7fzJY75/oDnusMST+XtEBSv6TvS2qW9DFJbzezNzjnom2bAAAAUEHa25rVP3gk0I5SYS+YB4dGdeuufdq593DJ6jJ8i7vOo9yZc+H2PY6TmX1G0t8oFQze6pwbTj+/TtLnJf3UOfeWgOf6tqQ/krRF0nudc0fTz39Z0l9I2uic+1CB4+1pampq6unpKeQ0AAAAJTcyNu71gjl1vh51dO+v6AvwwaHRkhe2x6G5uVm9vb29zrnmsMcmJmCY2YmSDkg6VdLrnXP3TXr9fknnSVrqnOue4lxnSdov6aikBufcbya8ViNpQFKdpJc55w4UMGYCBgAAqCg+LphHxsZ1+c1dgWdEirF9LcIpJGAkaYnUBUqFi0cnh4u0DqUCRpukvAFD0tuUqi/ZNjFcSJJzbtTMOiWtlfQOSd8qcNwAAAAVw0dh9PrOnsAN/HbuPaz1nb3asHJx5O+HZElSkfdr0o/35ng98/x5RT4XAAAAAjowNKKO7v2hjunoHtDg0GhMI0KxJWkGoyH9mOu/yMzz5xT5XDKzXGug5gc5HgAAYLrYvCt7DUc+Y+NOm3cPlLx/BvxI0gzGrPTjszleP5J+nF3kcwEAACCgoEujJtvRf8jzSFAqSZrBSKxcxS3pmY3ptbExAABAHsOjR4t6HJInSTMYw+nHmTlePzn9OFTkcwEAACCgWTXR7l9HPQ7Jk6SAsS/9mKuVZOb5x4t8LgAAAAQUtMP1ZMvnzfE8EpRKkgLG/enH1+d4PfP8A0U+FwAAAAJavaxe1VUW6pjqKtPqpfUxjQjFlqSAcY+kZyTNN7PXZnl9VfqxM8C5fizpBUkXmtmZE19IN9prkzQu6T8ijxYAAADHOXN2rVYtybWIJLtVS8q76zWOlZiA4Zx7XtJX0l9+1cwydRIys3VK9az46cQu3mb2UTN7yMw2TDrXryVtknSipBvNbOKivs9Kmivp24V08QYAAEB27W3NgZdKtTbWqb2NPXMqSWICRtpnJO2UdL6kPjO71cx2SPq8pEGlum9PdIakRZLOynKuj0t6VNJ7JD1kZt8xswcl/aWkPknrYvkJAAAAprna6iptXNuiNS0NOZdLVVeZ1rQ0aOPaFtVWVxV5hIhTosr1nXMjZrZC0jWS3i/p3ZIOS/qWpE855wK3hXTOHTSzFknXps9zqaTfSPqypHbn3NMehw4AAIAJaqurtGHlYq27eKE27x7Qjv5DGh49qlk1M7R83hytXsqyqEplzoXrtIiXmFlPU1NTU09PrkbfAAAAQPlpbm5Wb29vb65+cPkkbYkUAAAAgDJGwAAAAADgDQEDAAAAgDcEDAAAAADeEDAAAAAAeEPAAAAAAOANAQMAAACANwQMAAAAAN4QMAAAAAB4Q8AAAAAA4A0BAwAAAIA3BAwAAAAA3hAwAAAAAHhDwAAAAADgDQEDAAAAgDcEDAAAAADeEDAAAAAAeEPAAAAAAOANAQMAAACANwQMAAAAAN4QMAAAAAB4Q8AAAAAA4A0BAwAAAIA3BAwAAAAA3hAwAAAAAHhDwAAAAADgDQEDAAAAgDcEDAAAAADeEDAAAAAAeEPAAAAAAOANAQMAAACANwQMAAAAAN4QMAAAAAB4Q8AAAAAA4A0BAwAAAIA3BAwAAAAA3iQiYJjZK83sr83sLjM7aGZjZvakmW0xswsjnO9DZuby/PlOHD8HAAAAMN3NKPUA0u6Q9HJJw5J2SDosqUnSpZLebWbrnHM3RDjv/ZJ+keX5ndGGCQAAACCfpASMhyRdI+m7zrmRzJNm9qeSvibpejO73TnXG/K833fOXetvmAAAAADyScQSKefc7znnbpkYLtLP/5Ok2yVVSfrDkgwOAAAAQGCJCBhTuD/9+LKSjgIAAADAlJKyRCqfeenHJyMcu8TMPifplPTxW51zP/U2MgAAAADHSHTAMLP5kn4//eUPI5zi9yccL0mfNrOfSnqvc+43hY4PAAAAwLESGzDMbIakb0mqkXSrc647xOG/lnStpB9I6pd0kqQWSZ+V9GZJ/25my51z4wHH0pPjpfkhxgQAAABUPC8Bw8y+J+lVIQ/7oHOuK8/rX5b0RqUCwkfCnNg5d5uk2yY89VtJnWZ2l6RuSUslrZa0KdSIAQAAAOTlawajUdKikMfMzPWCmf2NpD+X9BtJlzjnDhcwthc554bN7MuSviLpEgUMGM655hzj7FGqXwcAAAAAeQoYzrnX+jiPJJnZn0n6jKRnJL3NOfeIr3On9aUfz/J8XgAAAGDaS9Q2tWb2PklflfSspHc6534Rw7c5Pf14JIZzAwAAANNaYgKGmb1D0r9IOirpUufcPTF9q/ekH++N6fwAAADAtJWIgGFmF0jqkGRKbSF7e8DjHkr/efmk568xszMmPVdtZu1KdQR/TtI3/YweAAAAQEZStqn9d6W2kt0r6d1m9u4s77nbOfeNSc9lCsurJz3/95LazWy3pAGlGu29Vqlu4COSPuCc+5WfoQMAAADISErAOC392Jj+k8vkgJHL30p6g1IB5PVKzYzsl/RPkr7onHs42jABAAAA5JOIgOGcM5/HOefaCxsRAAAAgCgSUYMBAAAAoDIQMAAAAAB4Q8AAAAAA4A0BAwAAAIA3BAwAAAAA3hAwAAAAAHhDwAAAAADgDQEDAAAAgDcEDAAAAADeEDAAAAAAeEPAAAAAAOANAQMAAACANwQMAAAAAN4QMAAAAAB4Q8AAAAAA4A0BAwAAAIA3BAwAAAAA3hAwAAAAAHhDwAAAAADgzYxSDwDIZnBoVLfu2qedew9rePSoZtXM0PJ5c7R6ab3mzq4p9fAAAACQAwEDiTIyNq71nT3q6N6vsXF3zGvb+g7qhjv2aNWSerW3Nam2uqpEowQAAEAuBAwkxsjYuC6/uUs79x7O+Z6xcadNXfvUPzisjWtbCBkAAAAJQw0GEmN9Z0/ecDHRzr2Htb6zN+YRAQAAICwCBhLhwNCIOrr3hzqmo3tAg0OjMY0IAAAAURAwkAibdw0cV3MxlbFxp827B2IaEQAAAKIgYCARgi6NmmxH/yHPIwEAAEAhCBhIhOHRo0U9DgAAAPEgYCARZtVE29As6nEAAACIBwEDidDaWBfpuOXz5ngeCQAAAApBwEAirF5Wr+oqC3VMdZVp9dL6mEYEAACAKAgYSIQzZ9dq1ZKzQx2zakm95s6uiWlEAAAAiIKAgcRob2sOvFSqtbFO7W1NMY8IAAAAYREwkBi11VXauLZFa1oaci6Xqq4yrWlp0Ma1LaqtriryCAEAADAVtuBBotRWV2nDysVad/FCbd49oB39hzQ8elSzamZo+bw5Wr2UZVEAAABJRsBAIs2dXaMrVyzQlSsWlHooAAAACIElUgAAAAC8IWAAAAAA8CYRS6TM7C2S7srzlp3OueURztsm6ROSXpd+6l5Jn3PO/SjsuYAgBodGdeuufdq59zC1IwAAYFpKRMCY4FFJd+d4PhQz+7ikL0o6KukOSaOS3irp383sL5xzXylgnMAxRsbGtb6zRx3d+zU27o55bVvfQd1wxx6tWlKv9rYmdr8CAAAVLWkB427n3IcKPYmZLZJ0vVKhYoVz7ufp5xdK2i7pi2b2Y+fcI4V+L2BkbFyX39ylnXsP53zP2LjTpq596h8cZotdAABQ0Sq1BuNjkqokfS0TLiTJObdH0v+nVLD6WInGhgqzvrMnb7iYaOfew1rf2RvziAAAAEqnUgPGO9OPHVleyzzXVqSxoIIdGBpRR/f+UMd0dA9ocGg0phEBAACUVtICxrlmtsHM/tnM/t7M3mFmocZoZqdJakh/ed/k151zA5IOSjrHzE4peMSY1jbvGjiu5mIqY+NOm3cPxDQiAACA0kpaDcb56T8TPWhm73HO9QU8RyZcPOWcO5LjPfslnSHpHEkPTnVCM+vJ8dL8gGNChQq6NGqyHf2HaCIIAAAqUlJmMJ6R9DlJyyXNSf+5SNIOSYsl3W5mpwY816z047N53pMJHrPDDxV4yfDo0aIeBwAAkHReZjDM7HuSXhXysA8657okyTl3n45fzrTVzN6oVH+MCyV9RNKGQscahXOuOdvz6ZmNpiIPBwkyqyba/0JRjwMAAEg6X1c5jZIWhTxm5lRvcM6Nm9k/KBUwLlGwgDEc4Pwnpx+HApwPCVfK5natjXXa1ncw9HHL582JYTQAAACl5yVgOOde6+M8OWRqL84K+P596cfTzezkHHUYZ6cfHy9oZCipJDS3W72sXl+6sy9UoXd1lWn10vpYxgMAAFBqSanByOf09GOugu1jOOee1ksh43WTXzezeqUKvB93zv3WxwBRfJnmdpu6cu/ilGlud/nNXRoZG49lHGfOrtWqJWdP/cYJVi2Jf2YFAACgVMphIfh70o/3hjjmR5L+XNIqSXdPem1V+rGzwHGhhMI2t7tmy4OaP/fkWJZRtbc1q3/wSKDxtDbWqb2Nsh0AAFC5zLlwe/jHMgizj0v6t3SPisxzJulPJH1Fqa7cy5xz3ZOOeyj9jxc553414flFknokHZX0FufcjvTz50r6uaRTJb3KOfdIgePuaWpqaurpybWLLeJwYGhEF1y3NXT/iWyqq8zLMqrUcq1edXRnn1Hx9X0AAACKobm5Wb29vb25NjvKJykzGB+XdL2Z3Stpr6RapbanbZT0gqS/nBwu0jKF5dUTn3TOPWxmV0n6gqRtZvZfkp6X9FZJJ6XPV1C4QOlEaW6XS2YZVf/gsDaubYl88V9bXaUNKxdr3cULtXn3gHb0Hyp6wTkAAEASJCVgfF6pi/9mpbZ9rZb0a0nflvRl59yusCd0zn3RzB6RdJVSu1BJ0m5Jn3XO/buXUaMkoja3m+qc6zt7tWHl4oLOM3d2ja5csYAmegAAYNpKRMBwzv2jpH+McJxN8XqnqLWoOHE1qevoHtC6ixcy0wAAAFCActhFCjhGXE3qxsadNu8emPqNAAAAyCkRMxhAGFGb2wWxo/9Q0ZY3lbJBIAAAQFwIGCg7UZrbBRXX8quJktAgEAAAIC4skULZidLcLqi4ll9lJKVBIAAAQFwIGChL7W3Nam2s837e5fPmeD/nRGEbBK7v7I11PAAAAL6xRAolUWj9QW11lTaubcnb3C6s6irT6qX1BZ8nlwNDI+ro3h/qGHa2AgAA5YaAgaLyWX8wVXO7vgND+v59TwQe26ol8RZXR2kQmNnZir4aAACgXBAwkJfPnY4y9Qf5lghF6aydq7ndyNi4fv30SOAlSeMvvKCRsfHYCqujNggs5s5WAAAAhSJgIKs4djoKW39w9ZYHtWDuyQUvo/rUD36p7+6eemnS5t37tXfwiG75n62xhIyoO1QVY2crAAAAXwgY01S+mYnZtTO8zzREqT/4/n2/Ou65KMuopODLknY9/pQ+9YNf6nOrXhNqrEFE3aEq7p2tAAAAfOLKZZoJMjPRUDdTjw4eCXS+zE5HG1Yuzvu+KPUHuYQJN6lgc3xQyeffuvfrk5e80ns9RtQGgXHvbAUAAOAT29ROI0F7MAQNFxkd3QMaHBrN+56o9QdTnXOqbVy/efdeuZC55gUnffWuvgJGlt3qZfWqrrJQx8S9sxUAAIBvBIxpJEwNRBiZnY7yiauOYKpw8x+/fDLSeb+1/XFds+VBr43uojQIjHtnKwAAAN9YIjVNRKmBCGOqnY7iqiOYahvXw0eej3zusLtZBdHe1qz+wSOBgl5rY53a25q8fN9cfO4SBgAAIDGDMW34rIHIZqoZiji6bmfs6D8U27l9d9PO7Gy1pqUh53Kp6irTmpYGr8FmspGxcV2z5QGdf92duv72PdrWd1D37Xta2/oO6nO3Pazzr7vT+wwOAACYHpjBmCbiWBo10VQzFKuX1etLd/bFEnLyhZtTT6rW0Ehhy7MK7aada5ag86Nv1J0PHTiuQWDcswdx9SMBAACQCBjTRty9FKba6ShTf7CpK3+tRhSPHBjWZTftPObiPLNb1hNPP1fw+aN20w7aS+TrH1xa1Av4sP1IguwSBgAAkEHAmCbi7KUQdKejMPUHYQyNHNW2voMvXrS/+3Uv12MHj2jXY095+x5f++mj2tF/KPAMQ1JnCaLU4hQ6gwMAAKYXajCmiThrICbudDQ4NKqvbO3TZTft1KU33qPLbtqpr971iAaHRgPVHxRqbNzpu7v3ew0X0kshJmh9QpRZgmKIUosTZJcwAACADHNhmwTgRWbW09TU1NTT01PU7xtl558DQyO64Lqt3msgWhvrtHFtiyTlXA4kpWY5JnbfHhwa1ebdA8fVH/T9Zljf/0W4xnilkvnZJ888RPmsq6tM26++KPZZgstu2hmp2d+F556hW65ojWFEAAAgiZqbm9Xb29vrnGsOeyxLpMpI0DX9mYv4ieKogfidU2p1/vw5Ghwa1Se+e3+o5UBzZ9foyhULjqtrGBkb16+feS72onQfctUnFDJLELbOI6yotThx1/AAAIDKwRKpMhG0C/emrn26/OaurMt32tuavS6VevK3I/riHX160+fu8rYcqBjLqHzK1ugvajiKc7vdjKi1OHHW8AAAgMpCwCgTPtb0x3XxHnaV3VTdt2urq7Rh5WJtv/oiXXXJIl147hmaXZvMC9xs9QlJniWIGjCn2iUMAAAgg4BRBqLu/JPtIn7yxXtrY52KPU8QtGg4s4zqlitateDMWUUYWTSTZx6SPEuwell96HAZdJcwAAAAiYBRFuLY+Sdz8X7rn75B72sp/sVj2OVASV6iM3nmIcmzBJlanDAm7hIGAAAwFQJGGYh7Tb/v2owgwi4HKvb4wpgcfpI+SxDm33drY53a25piHhEAAKgkBIwyEPea/lIUVoedkYhy0V4sk2cekj5LEOTfd3WVaU1LQ9EaAAIAgMqR3HUneFEx1vRnajPWXbzwxf4U3Y8/pWefz91MrhBhlwPFsc2uD7lmHsJ0LS/FLEG2f99Be6oAAADkQ8AoA62NdZGao0VZ0z+xP0XUpmxTibocKMxF+7JzTlfj3JO15d79OvpClFEGk2vmITNLsL6zVx3d2WtoJjcfLIVc/UgAAACiImCUgdXL6vWlO/tCd4YudE1/1GAzlajLgaJctF91ySv1rzsf13e6BvSb344o2yc44wTTC87phZDb7b6+4bS8Mw/MEgAAgOnIXNgmBniRmfU0NTU19fT0xP69rtnyQKjlQWtaGo7rMB3WgaERXXDd1tA7WOXT2ljnZV3/4NBo6Iv2XMcMj4zp//60P/QYPv575+rjv7ewoJ8DAAAgiZqbm9Xb29vrnGsOeywzGGWiFGv6o9Q9nGDKOhPgezlQlKU9uY657KadkcbQ/fhTkY4DAACoZASMMlGqNf1hg83nV79GP/jFE2W1HCjJnbcBAADKDQGjjJRiTX+UYFNuRcNJ7rwNAABQbrhCKkPF3vmn0ouVi7lLFwAAQKUjYCCwSt3StFS7dAEAAFSiRHTyNrOfmJmb4k/gbgZm9qEpzvWdOH8elJekd94GAAAoJ0mZwfixpMdyvLZE0qslbYtw3vsl/SLL89G2DULFSnrnbQAAgHKRiIDhnLsu12tmlgkDt0Q49fedc9dGGhSmlXLpvA0AAJB0iQgYuZjZuZJaJI1I+m6Jh4MKMTg0qlt37dPOvYePK1av5GJ2AACAYkh0wJD0gfRjp3PumZKOBEWVLwREvcgfGRvX+s4edXTvP26GYlvfQd1wx54XZygqsZgdAACgGJIeMP4o/fjtiMcvMbPPSTpF0pOStjrnfuplZNNQHBf9k4UJAWGWKY2Mjevym7vy1liMjTtt6tqn/sFhbVzbUtRlUMX4bAEAAIrBnAu+NWcxmdkbJG2XdEjSWc65sRDHfkjSN3O8/FNJ73XO/cbDGHuampqaenp6Cj1VouW76Jf81SYECQEZrY11oULANVse0KaugcBjWdPSoA0rFx/zXLFnVSTqPgAAQGk0Nzert7e31znXHPbYJM9gXJZ+/E6YcJH2a0nXSvqBpH5JJylVy/FZSW+W9O9mttw5Nx7kZGaWK0HMDzmuovJxQVzMO//rO3sChQtJ2rn3sNZ39h4XArI5MDSiju79ocbS0T2gdRcv1NzZNdN2VgUAACAKLzMYZvY9Sa8KedgHnXNdOc5XrVRImCNpuXPOy7ayZjZLUrekhZLe75zbFPC4nAGjqampJmkzGD7vivu48x/EgaERXXDd1tDN7rZffdGUYekrW/t0/e17Qo/pqksW6Yo3NiZ6VgUAACAOhcxg+Gq01yhpUcg/M/Oc7+1KhYs+X+FCkpxzw5K+nP7ykhDHNWf7I+lRX2PzJXNXfFNX9q1WpZfuil9+c5dGxnJP4kS98z84NBrqGEnavCv3eHMZG3favHvqC/SgsyKT7eg/FGlWJYhifrYAAADF5CVgOOde65yzkH9+kueUmd2johZ359OXfjwrhnOXnM8L4jgv+rONJYod/YemfM/w6NFI537q2edjCwHF/GwBAACKydcMhjdmdoqktvSXcQSM09OPR2I4d0n5vise50X/ZFFDQJDjZtVEKzUaGjmayFkVAACAJEtikfcqSbWS7nHO9cdw/vekH++N4dwlVchd8Ww9H+K86J8sagiYeFyuovZXv+wUbes7GOn8UezoPzRlD41ifrYAAADFlMSAkVkedctUbzSzh9L/eJFz7lcTnr9G0tedcwcnPFct6X9L+kNJzyn3NrZlq5C74tkuiH1c9AfV2lgXKQQsnzdnyl2eZpxgOsGkF0Jkr+oq0+zaaD9/nLMqUY8DAAAolkQtkTKzs5XaRvZ5SZsDHJIpGK+e9PzfS9pvZneb2SYz+5Gkx5TaunZE0gcmBpJK4fuueGtjXaTzLZ83J/Qxq5fVq7rKQh1TXWX6g9e8bMqi9qMvuFDhQpJWLanX6TNPDHdQWpAQUMzPFgAAoJgSFTAkvV+pMf3IOfdUAef5W0k/k1Qv6V2SflfSs5L+SdJrnXNbCh1oEvm+Kx71on/10vrQYzhzdq1WLTk71DGrltTrxp88EnnmJpfWxjq1tzXFGgKK+dkCAAAUU6IChnPus+kdplYGfH9mR6rHJj3f7px7q3PuHOfcTOfcSc65c51zf+aceziWwSdA1AvifYef1VfveuS4Yu+oF/1Ru1q3tzUH/hlaG+v0kbfMD13Uns+ME1K9JjK9LOIMAcX+bAEAAIolUQEDhYlyQSxJjx96Vp+77WGdf92dumbLg8f0xgh70d/e1hT6+2fUVldp49oWrWlpyPlzVFfZiyHgB7/4Veii9nzaXvNybVi5+MVGeXGHgGJ+tgAAAMVCwKggUS6IJ8rWgC/sRX/QLta51FZXacPKxdp+9UW66pJFuvDcM/S6htN04bln6KpLFmn71Re9GAJ8L4369weeOG4WJ84QUOzPFgAAoBjMOX93gKcbM+tpampq6unpKfVQXpTp5F3oxfealgZtWLn4mOcGh0a1efeAdvQfOmYb2NVLS7N059Ib79F9+572es6rLll03I5aqV2qetXRnb2QvLrKtGpJvdrbmiKHgKR9tgAAYHprbm5Wb29vr3OuOeyxBIwCJDFgSFNfEAdRXWXafvVFWS9uc/WbKPbF8GU37fTe3+LCc8/QLVe0Zn2NEAAAAKaLQgIGm+pXoMwyo3UXL9Tm3QPavHtAjx96NtQ5sjXgm6rfxA137Cn4Tn4YUXtn5JNvq9+5s2t05YoFUzbRAwAAmM6owahgmQvihrqZkY7f0X/oxX/OLL3K128iWw1HnKIWtedDIzsAAIDCEDCmAR8N+NZ39gSu69i597DWd/ZG+p5hFFrUng2N7AAAAApDwJgGCm3Ad2BoJHS/iY7ugeN2ZIpDmF2epkIjOwAAgMIRMKaBQjtSb94Vvlg8U8MRtyBbvQZFIzsAAIDCETCmgUI7Ukfd8nZiDUeccvXOOH/+HJ19+kmBzkEjOwAAAD+oaJ0GMrUKm7qCzyhMvJvvo4ajGLLt8lSMHhYAAAB4CQFjmmhva1b/4JFAsxGT7+YXWsNRSpO37KWHBQAAQLxKfwWIosjUKkS5mx+130SSdmSihwUAAEBxEDCmkah381cvq9eX7uwLVejNjkwAAADTEwFjGgp7N7/QGg4AAABMH+wihUDC9JtgRyYAAIDpi4CBQIL0m6iuMq1padDGtS3syAQAADBNsUQKgbEjEwAAAKZCwEBo7MgEAACAXFgiBQAAAMAbAgYAAAAAbwgYAAAAALwhYAAAAADwhoABAAAAwBsCBgAAAABvCBgAAAAAvCFgAAAAAPCGgAEAAADAGwIGAAAAAG/MOVfqMZQtM/ttTU3N7Pnz55d6KAAAAIA3jz76qEZHR4ecc6eEPZaAUQAze1LSTEkDpR6LJ5mk9GhJR1FZ+Ez94vP0j8/ULz5P//hM/eLz9K9SP9N6Sc86534n7IEEDLzIzHokyTnXXOqxVAo+U7/4PP3jM/WLz9M/PlO/+Dz94zM9HjUYAAAAALwhYAAAAADwhoABAAAAwBsCBgAAAABvCBgAAAAAvGEXKQAAAADeMIMBAAAAwBsCBgAAAABvCBgAAAAAvCFgAAAAAPCGgAEAAADAGwIGAAAAAG8IGAAAAAC8IWAAAAAA8IaAgbzMrMbM/trM7jWzYTMbNbO9ZvZ1M5tX6vGVMzN7t5n92MwGzWzEzAbM7Htm9sZSj62cmdmnzMyl/3yg1OMpN2b2yvT/83eZ2UEzGzOzJ81si5ldWOrxJZWZnWRmf2tme9L/Pz9hZjeb2ctLPbZyY2Yz038/3mRmD6c/zyNmdr+ZfdrMZpV6jOXOzOaY2YH035OPlHo85czM5prZ9en/Vp8zs8Ppa6bPlXpspUQnb+RkZrWS7pK0XNLTkrZLGpH0ekmvkDQkaYVzrrtEQyxLZnaCpK9LWivpiKS7lfp8GyQtkfR3zrnPlGyAZczMFkm6X9KJkkzSZc65b5d2VOXFzPZLermkYUk7JB2W1CTp1ZKcpHXOuRtKNsAEmvR35a8lbVPq78gWSYOSljvn+ks2wDJjZv9Tqb8jJem/Jf1S0imSzpc0W9JDkt7snDtQmhGWPzP7lqQPKvX35KPOuQWlHVF5MrMlkm6TNEdSj176b7VJ0tnOuRklHF5JTdsfHIH8iVK/MHdJutg594wkmVmVpBskfVTSFyS9uVQDLFOfVipcdEr6kHPucOYFMztd0hmlGlg5MzOT9M9KhbUdkt5V0gGVr4ckXSPpu865kcyTZvankr4m6Xozu90511uqASbQ/1Hq78qfS3qrc25YksxsnaTPS7pZ0ltKNrryM6bU/8s3OOf+O/OkmZ0l6UeSXqfU76D3l2R0Zc7MLpJ0uVKf8Z+UeDhly8zmSvqxpJMkvcs598NJr7eUZGAJwQwGcjKzDknvkbTGOfedSa+drtSdzeecczNLMb5yZGZnS3pU0pOSXumce67EQ6oYZvZhpX5hfkDSxUr9AmUGwyMzu03SWyVd65xbX+rxJIGZnSjpgKRTJb3eOXffpNfvl3SepKXM9hbOzN6g1Gz6qKRTnHPPl3hIZcXMTpL0oFKf37sl7REzGJGY2Y2S/lzSlc65G0s9nqShBgP5jAZ4z6HYR1FZLldq+c43CBf+mNnvSPqspDudc/9a6vFUsPvTjy8r6SiS5QKlwsWjk8NFWkf6sa14Q6pomf8Ga5RaloJw2iXNk/RnSs0UIYJ0UPuAUsucv1ni4SQSS6SQz+1KTUGvM7P/nLRE6m/T77mpVIMrU7+bftyenu7/I0kLJD2j1Bru2xzTilF8Walp6j8v9UAqXGZjhydLOopkeU368d4cr2eeP68IY5kOMv8Njik1i46AzOw8SX8l6ZvOuW1m9ooSD6mcLVWqHuhu59xzZvZ2pWbOa5WaFdrsnHuilAMsNQIG8vm2pLdJep+kx8zsHqWKvJdI+h+SPifp70o3vLLUNOHx35S685nxSUk/MbNLnXNPF3tg5crMfl/SH0pqd871lXo8lcrM5kv6/fSXP8z33mmmIf24P8frmefPKcJYpoOPpR9/7JwLMssOvbi5yDeUqlH7ZGlHUxEyv8sPmNn3dXzN39+b2RXOuU3FHVZysEQKOTnnxpWaAvyspNMkvVOpmoxXKLWzx53p9yC409OPX5D0gFI7cp0i6fck7VWqEPTrWY/EcdLbVd6o1B2jfyjxcCqWmc2Q9C2llqXcSi3BMTJbpj6b4/Uj6cfZRRhLRTOzd0i6QqnZi0+VeDjl5i8kLZN0lXOOpc2Fy/wu/wOlbsReKelMpa6PrldqRn2jmb22FINLAmYwKpiZfU/Sq0Ie9kHnXFf6+NMlfU+pv5Q+ptQd92clvUnSP0r6DzN7v3PuVn+jTrZCP1O9FOqfkvR251zm4uNOM/sDpULHKjNb6JzbU/iIk83D5/n3kuolXcTdzBQPn2k2X5b0Rkn9kj4SdWxAVGb2SqVm1U2pi+T7pzgEaWbWIOkzkn7qnPtWiYdTKTK/y2dI+ptJRd5Xmdk5Ss2sX6XUUuhph4BR2RolLQp5zMQdob6o1Ba0/8s59+UJz//AzH4lqUvS581si3NuuhSLFfqZDit15+O7E8KFJMk590sz26XU3vlvUuqufKWL/HmmtwC8UtItzrmtvgdWxgr9b/QYZvY3StW2/EbSJRO3VYak1P/TUu7P8OT041ARxlKR0s0Kf6zU351fcM59qcRDKjdfVWpzkT8r9UAqyPCEf85W5P1NpQLGtN3Gn4BRwZxzr416bLqQe036y47JrzvndpvZXqUK7uZJejjq9yonhXymaY8r9UvysRyvP6ZUwDizwO9TFgr8PN+h1F2kxWb2k0mvvTL9+Dfppl0/ds5dV8D3Khse/ht9kZn9mVJ3Pp+R9DbnHB1/j7cv/Xh2jtczzz9ehLFUHDOrU2rDkXOUumj7RGlHVJZ+X6nai6+l2gW9qDb9+PIJf4e+zznHJg5Ty/z//KxzbjDL64+lH6fF7/JsCBjI5Uyl7nhIqYuLbDLPn57jdRzvPkmvVe7PrC79OJzjdRzvtXlee2X6z2NFGUkFMbP3KXXn81lJ73TO/aK0I0qszFKd1+d4PfP8A0UYS0VJ11j9p1IFtVskfZhd9iI7TbnvptdOeK02x3twrMyW1CeZWU2WJbrT/nc5Rd7I5bCkTAOjpZNfNLNT9NIyDO7MBZfZfee4v+jTv0wzFyPZ9tPHBM65a51zlu2PpI3pt12Wfu5DJRxq2UkX0/6LpKOSLnXO3VPiISXZPUrdbJmfo6BzVfqxs2gjqgBmViPpB0rN6N6mVMNXNhWJIM/fk43ptzw64fnHSjjUsuGc26fUzQVT9uCWeW7a/i4nYCCrdBr/cfrLL6R7NkiSzKxWqZ17Zkq6xzn36xIMsVx1KrUD1/lm9mKxbHpJ2heUuuvxS0l3l2Z4mO7M7AKllkWapPc6524v8ZASLd1J+ivpL79qZpmaC5nZOqX6X/yUnbeCS/99uEmpvkHbJK2kYzcS6LPpx+snXSO9Vql+I5L0tWIPKimM2Ubkkt73/h6lel4MSfq5pOeU2lXqZUrNcrzZOffLkg2yDKX/8vmpUtvT3i/pEUmvU6qW5ZCkFc65B0s2wApgZt9Sqmv6Zc65b5d4OGXFzJ5SajnFXkk/y/G2u51z3yjaoBIufdPlJ5JaJf1aqYvic9JfD0pa7pzrL9kAy4yZfUzSDekvvyfptzne+gnn3MGiDKoCpRvt7VVqBmNBiYdTlib8rnla0naltqc9X6ktvb/unPuTkg2uxKjBQE7OuUfN7DWS/lrS25Xa2cgkDSi1Nvs651yu5lLIwTn3i3TIuFbSW5VaX/wbpZogfcY5x5IzlNJp6cdGvbSEIhsCRppzbsTMVki6RtL7Jb1bqRsw35L0Kf6eDG1ijdqled53rSQCBkrpj5W6EfunSvWxcpLulfRPzrmNeY6reMxgAAAAAPCGGgwAAAAA3hAwAAAAAHhDwAAAAADgDQEDAAAAgDcEDAAAAADeEDAAAAAAeEPAAAAAAOANAQMAAACANwQMAAAAAN4QMAAAAAB4Q8AAAAAA4A0BAwAAAIA3BAwAAAAA3hAwAAAAAHhDwAAAAADgDQEDAAAAgDcEDAAAAADe/D+R2J+qxUVwqgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(coords)\n", - "graph_data(coords_cluster)" - ] - }, - { - "cell_type": "markdown", - "id": "ff524176", - "metadata": {}, - "source": [ - "## Running Dissimilarity Algorithms" - ] - }, - { - "cell_type": "markdown", - "id": "38c88220", - "metadata": {}, - "source": [ - "### Brute Strength - MaxMin" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "27e5864f", - "metadata": {}, - "outputs": [], - "source": [ - "# MaxMin method\n", - "from selector.methods.partition import *\n", - "from selector.methods.dissimilarity import *\n", - "\n", - "# diverse subset selection from randomly generated data points\n", - "selector = MaxMin()\n", - "selected_ids1 = selector.select(arr=arr_dist, size=12)\n", - "\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selector = MaxMin()\n", - "selected_ids2 = selector.select(arr=arr_dist_cluster, labels=class_labels_cluster, size=12)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "76e8e320", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(coords,selected_ids1)\n", - "graph_data(coords_cluster,selected_ids2)" - ] - }, - { - "cell_type": "markdown", - "id": "0fb215f3", - "metadata": {}, - "source": [ - "### Adapted Optimizable K-Dissimilarity Selection (OptiSim)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "aaac7176", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# diverse subset selection from randomly generated data points\n", - "selected_id3 = OptiSim().select(coords, 12)\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selected_id4 = OptiSim().select(coords_cluster, size=12, labels=class_labels_cluster)\n", - "\n", - "graph_data(coords,selected_id3)\n", - "graph_data(coords_cluster,selected_id4)" - ] - }, - { - "cell_type": "markdown", - "id": "3dddc3d6", - "metadata": {}, - "source": [ - "### Directed Sphere Exclusion" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "3cfc8fbf", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# diverse subset selection from randomly generated data points\n", - "selected_id5 = DirectedSphereExclusion().select(coords, 12)\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selected_id6 = DirectedSphereExclusion().select(coords_cluster, size=12, labels=class_labels_cluster)\n", - "\n", - "graph_data(coords,selected_id5)\n", - "graph_data(coords_cluster,selected_id6)" - ] - }, - { - "cell_type": "markdown", - "id": "abfa0f31", - "metadata": {}, - "source": [ - "### Grid Partitioning Method" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "c9927492", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# diverse subset selection from randomly generated data points\n", - "selected_id7 = GridPartitioning(2, \"equisized_independent\").select(coords, 12)\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selected_id8 = GridPartitioning(2, \"equisized_independent\").select(coords_cluster, \n", - " size=12, \n", - " labels=class_labels_cluster)\n", - "\n", - "graph_data(coords,selected_id7)\n", - "graph_data(coords_cluster,selected_id8)\n", - "# 20, 5, 3, \"equisized_independent\"" - ] - }, - { - "cell_type": "markdown", - "id": "9e67816c", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## MinMax selection with clusters, but without assuming there are clusters" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e79d09a6", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "selector = MaxMin()\n", - "selected_ids = selector.select(arr=arr_dist_cluster, size=15)\n", - "graph_data(coords_cluster, selected_ids)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "9d5ab489", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 10, 11, 9, 13]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "from sklearn.metrics import pairwise_distances\n", - "np.random.seed(42)\n", - "cluster_one = np.random.normal(0, 1, (3,2))\n", - "cluster_two = np.random.normal(10, 1, (6,2))\n", - "cluster_three = np.random.normal(20, 1, (7,2))\n", - "labels_mocked = np.hstack([[0 for i in range(3)],\n", - " [1 for i in range(6)],\n", - " [2 for i in range(7)]])\n", - "\n", - "mocked_cluster_coords = np.vstack([cluster_one, cluster_two, cluster_three])\n", - "selector = MaxMin(lambda x: pairwise_distances(x, metric='euclidean'))\n", - "selected_mocked = selector.select(mocked_cluster_coords, size=15, labels=labels_mocked)\n", - "\n", - "graph_data(mocked_cluster_coords, selected_mocked)\n", - "\n", - "selected_mocked" - ] - }, - { - "cell_type": "markdown", - "id": "b230dd49", - "metadata": {}, - "source": [ - "### Brute Strength - maxsum" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3b4efad5", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " arr_dist=arr_dist,\n", - " random_seed=42,\n", - " method=\"maxsum\")\n", - "selector.starting_idx = 0\n", - "selected_ids2 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "c393e1ed", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids2)" - ] - }, - { - "cell_type": "markdown", - "id": "07a66848", - "metadata": {}, - "source": [ - "### Grid Partitioning - Equisized Independent" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "10c2afd0", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(features=coords,\n", - " num_selected=12,\n", - " arr_dist=arr_dist,\n", - " grid_method=\"grid_partioning\",\n", - " random_seed=42)\n", - "selector.starting_idx = 0\n", - "selected_ids3 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "d910c193", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids3)" - ] - }, - { - "cell_type": "markdown", - "id": "30157fdb", - "metadata": {}, - "source": [ - "### Grid Partitioning - Equisized Dependent" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "df78a5e9", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " features = coords,\n", - " random_seed=42,\n", - " dissim_func=\"grid_partitioning\",\n", - " grid_method=\"equisized_dependent\")\n", - "selector.starting_idx = 0\n", - "selected_ids4 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "69c111e4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids4)" - ] - }, - { - "cell_type": "markdown", - "id": "bbae7222", - "metadata": {}, - "source": [ - "### Directed Sphere Exclusion" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "a6f80d02", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " features=coords,\n", - " dissim_func=\"sphere_exclusion\",\n", - " random_seed=42)\n", - "selector.starting_idx = 0\n", - "selected_ids5 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "70060bc3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids5, True)" - ] - }, - { - "cell_type": "markdown", - "id": "cf8b3965", - "metadata": {}, - "source": [ - "### Optisim" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "735df074", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " features=coords,\n", - " dissim_func=\"optisim\",\n", - " random_seed=42)\n", - "selector.starting_idx = 0\n", - "selected_ids6 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "363b36d1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids6)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/book/content/_build/html/_sources/utils.rst b/book/content/_build/html/_sources/utils.rst deleted file mode 100644 index cd129d60..00000000 --- a/book/content/_build/html/_sources/utils.rst +++ /dev/null @@ -1,4 +0,0 @@ -Utilities -============= -.. automodule:: selector.utils - :members: diff --git a/book/content/_build/html/_static/__init__.py b/book/content/_build/html/_static/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/book/content/_build/html/_static/basic.css b/book/content/_build/html/_static/basic.css deleted file mode 100644 index 14a03c5d..00000000 --- a/book/content/_build/html/_static/basic.css +++ /dev/null @@ -1,904 +0,0 @@ -/* - * basic.css - * ~~~~~~~~~ - * - * Sphinx stylesheet -- basic theme. - * - * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * - */ - -/* -- main layout ----------------------------------------------------------- */ - -div.clearer { - clear: both; -} - -div.section::after { - display: block; - content: ''; - clear: left; -} - -/* -- relbar ---------------------------------------------------------------- */ - -div.related { - width: 100%; - font-size: 90%; -} - -div.related h3 { - display: none; -} - -div.related ul { - margin: 0; - padding: 0 0 0 10px; - list-style: none; -} - -div.related li { - display: inline; -} - -div.related li.right { - float: right; - margin-right: 5px; -} - -/* -- sidebar --------------------------------------------------------------- */ - -div.sphinxsidebarwrapper { - padding: 10px 5px 0 10px; -} - -div.sphinxsidebar { - float: left; - width: 270px; - margin-left: -100%; - font-size: 90%; - word-wrap: break-word; - overflow-wrap : break-word; -} - -div.sphinxsidebar ul { - list-style: none; -} - -div.sphinxsidebar ul ul, -div.sphinxsidebar ul.want-points { - margin-left: 20px; - list-style: square; -} - -div.sphinxsidebar ul ul { - margin-top: 0; - margin-bottom: 0; -} - -div.sphinxsidebar form { - margin-top: 10px; -} - -div.sphinxsidebar input { - border: 1px solid #98dbcc; - font-family: sans-serif; - font-size: 1em; -} - -div.sphinxsidebar #searchbox form.search { - overflow: hidden; -} - -div.sphinxsidebar #searchbox input[type="text"] { - float: left; - width: 80%; - padding: 0.25em; - box-sizing: border-box; -} - -div.sphinxsidebar #searchbox input[type="submit"] { - float: left; - width: 20%; - border-left: none; - padding: 0.25em; - box-sizing: border-box; -} - - -img { - border: 0; - max-width: 100%; -} - -/* -- search page ----------------------------------------------------------- */ - -ul.search { - margin: 10px 0 0 20px; - padding: 0; -} - -ul.search li { - padding: 5px 0 5px 20px; - background-image: url(file.png); - background-repeat: no-repeat; - background-position: 0 7px; -} - -ul.search li a { - font-weight: bold; -} - -ul.search li p.context { - color: #888; - margin: 2px 0 0 30px; - text-align: left; -} - -ul.keywordmatches li.goodmatch a { - font-weight: bold; -} - -/* -- index page ------------------------------------------------------------ */ - -table.contentstable { - width: 90%; - margin-left: auto; - margin-right: auto; -} - -table.contentstable p.biglink { - line-height: 150%; -} - -a.biglink { - font-size: 1.3em; -} - -span.linkdescr { - font-style: italic; - padding-top: 5px; - font-size: 90%; -} - -/* -- general index --------------------------------------------------------- */ - -table.indextable { - width: 100%; -} - -table.indextable td { - text-align: left; - vertical-align: top; -} - -table.indextable ul { - margin-top: 0; - margin-bottom: 0; - list-style-type: none; -} - -table.indextable > tbody > tr > td > ul { - padding-left: 0em; -} - -table.indextable tr.pcap { - height: 10px; -} - -table.indextable tr.cap { - margin-top: 10px; - background-color: #f2f2f2; -} - -img.toggler { - margin-right: 3px; - margin-top: 3px; - cursor: pointer; -} - -div.modindex-jumpbox { - border-top: 1px solid #ddd; - border-bottom: 1px solid #ddd; - margin: 1em 0 1em 0; - padding: 0.4em; -} - -div.genindex-jumpbox { - border-top: 1px solid #ddd; - border-bottom: 1px solid #ddd; - margin: 1em 0 1em 0; - padding: 0.4em; -} - -/* -- domain module index --------------------------------------------------- */ - -table.modindextable td { - padding: 2px; - border-collapse: collapse; -} - -/* -- general body styles --------------------------------------------------- */ - -div.body { - min-width: 450px; - max-width: 800px; -} - -div.body p, div.body dd, div.body li, div.body blockquote { - -moz-hyphens: auto; - -ms-hyphens: auto; - -webkit-hyphens: auto; - hyphens: auto; -} - -a.headerlink { - visibility: hidden; -} - -a.brackets:before, -span.brackets > a:before{ - content: "["; -} - -a.brackets:after, -span.brackets > a:after { - content: "]"; -} - -h1:hover > a.headerlink, -h2:hover > a.headerlink, -h3:hover > a.headerlink, -h4:hover > a.headerlink, -h5:hover > a.headerlink, -h6:hover > a.headerlink, -dt:hover > a.headerlink, -caption:hover > a.headerlink, -p.caption:hover > a.headerlink, -div.code-block-caption:hover > a.headerlink { - visibility: visible; -} - -div.body p.caption { - text-align: inherit; -} - -div.body td { - text-align: left; -} - -.first { - margin-top: 0 !important; -} - -p.rubric { - margin-top: 30px; - font-weight: bold; -} - -img.align-left, figure.align-left, .figure.align-left, object.align-left { - clear: left; - float: left; - margin-right: 1em; -} - -img.align-right, figure.align-right, .figure.align-right, object.align-right { - clear: right; - float: right; - margin-left: 1em; -} - -img.align-center, figure.align-center, .figure.align-center, object.align-center { - display: block; - margin-left: auto; - margin-right: auto; -} - -img.align-default, figure.align-default, .figure.align-default { - display: block; - margin-left: auto; - margin-right: auto; -} - -.align-left { - text-align: left; -} - -.align-center { - text-align: center; -} - -.align-default { - text-align: center; -} - -.align-right { - text-align: right; -} - -/* -- sidebars -------------------------------------------------------------- */ - -div.sidebar, -aside.sidebar { - margin: 0 0 0.5em 1em; - border: 1px solid #ddb; - padding: 7px; - background-color: #ffe; - width: 40%; - float: right; - clear: right; - overflow-x: auto; -} - -p.sidebar-title { - font-weight: bold; -} - -div.admonition, div.topic, blockquote { - clear: left; -} - -/* -- topics ---------------------------------------------------------------- */ - -div.topic { - border: 1px solid #ccc; - padding: 7px; - margin: 10px 0 10px 0; -} - -p.topic-title { - font-size: 1.1em; - font-weight: bold; - margin-top: 10px; -} - -/* -- admonitions ----------------------------------------------------------- */ - -div.admonition { - margin-top: 10px; - margin-bottom: 10px; - padding: 7px; -} - -div.admonition dt { - font-weight: bold; -} - -p.admonition-title { - margin: 0px 10px 5px 0px; - font-weight: bold; -} - -div.body p.centered { - text-align: center; - margin-top: 25px; -} - -/* -- content of sidebars/topics/admonitions -------------------------------- */ - -div.sidebar > :last-child, -aside.sidebar > :last-child, -div.topic > :last-child, -div.admonition > :last-child { - margin-bottom: 0; -} - -div.sidebar::after, -aside.sidebar::after, -div.topic::after, -div.admonition::after, -blockquote::after { - display: block; - content: ''; - clear: both; -} - -/* -- tables ---------------------------------------------------------------- */ - -table.docutils { - margin-top: 10px; - margin-bottom: 10px; - border: 0; - border-collapse: collapse; -} - -table.align-center { - margin-left: auto; - margin-right: auto; -} - -table.align-default { - margin-left: auto; - margin-right: auto; -} - -table caption span.caption-number { - font-style: italic; -} - -table caption span.caption-text { -} - -table.docutils td, table.docutils th { - padding: 1px 8px 1px 5px; - border-top: 0; - border-left: 0; - border-right: 0; - border-bottom: 1px solid #aaa; -} - -table.footnote td, table.footnote th { - border: 0 !important; -} - -th { - text-align: left; - padding-right: 5px; -} - -table.citation { - border-left: solid 1px gray; - margin-left: 1px; -} - -table.citation td { - border-bottom: none; -} - -th > :first-child, -td > :first-child { - margin-top: 0px; -} - -th > :last-child, -td > :last-child { - margin-bottom: 0px; -} - -/* -- figures --------------------------------------------------------------- */ - -div.figure, figure { - margin: 0.5em; - padding: 0.5em; -} - -div.figure p.caption, figcaption { - padding: 0.3em; -} - -div.figure p.caption span.caption-number, -figcaption span.caption-number { - font-style: italic; -} - -div.figure p.caption span.caption-text, -figcaption span.caption-text { -} - -/* -- field list styles ----------------------------------------------------- */ - -table.field-list td, table.field-list th { - border: 0 !important; -} - -.field-list ul { - margin: 0; - padding-left: 1em; -} - -.field-list p { - margin: 0; -} - -.field-name { - -moz-hyphens: manual; - -ms-hyphens: manual; - -webkit-hyphens: manual; - hyphens: manual; -} - -/* -- hlist styles ---------------------------------------------------------- */ - -table.hlist { - margin: 1em 0; -} - -table.hlist td { - vertical-align: top; -} - -/* -- object description styles --------------------------------------------- */ - -.sig { - font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; -} - -.sig-name, code.descname { - background-color: transparent; - font-weight: bold; -} - -.sig-name { - font-size: 1.1em; -} - -code.descname { - font-size: 1.2em; -} - -.sig-prename, code.descclassname { - background-color: transparent; -} - -.optional { - font-size: 1.3em; -} - -.sig-paren { - font-size: larger; -} - -.sig-param.n { - font-style: italic; -} - -/* C++ specific styling */ - -.sig-inline.c-texpr, -.sig-inline.cpp-texpr { - font-family: unset; -} - -.sig.c .k, .sig.c .kt, -.sig.cpp .k, .sig.cpp .kt { - color: #0033B3; -} - -.sig.c .m, -.sig.cpp .m { - color: #1750EB; -} - -.sig.c .s, .sig.c .sc, -.sig.cpp .s, .sig.cpp .sc { - color: #067D17; -} - - -/* -- other body styles ----------------------------------------------------- */ - -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; -} - -:not(li) > ol > li:first-child > :first-child, -:not(li) > ul > li:first-child > :first-child { - margin-top: 0px; -} - -:not(li) > ol > li:last-child > :last-child, -:not(li) > ul > li:last-child > :last-child { - margin-bottom: 0px; -} - -ol.simple ol p, -ol.simple ul p, -ul.simple ol p, -ul.simple ul p { - margin-top: 0; -} - -ol.simple > li:not(:first-child) > p, -ul.simple > li:not(:first-child) > p { - margin-top: 0; -} - -ol.simple p, -ul.simple p { - margin-bottom: 0; -} - -dl.footnote > dt, -dl.citation > dt { - float: left; - margin-right: 0.5em; -} - -dl.footnote > dd, -dl.citation > dd { - margin-bottom: 0em; -} - -dl.footnote > dd:after, -dl.citation > dd:after { - content: ""; - clear: both; -} - -dl.field-list { - display: grid; - grid-template-columns: fit-content(30%) auto; -} - -dl.field-list > dt { - font-weight: bold; - word-break: break-word; - padding-left: 0.5em; - padding-right: 5px; -} - -dl.field-list > dt:after { - content: ":"; -} - -dl.field-list > dd { - padding-left: 0.5em; - margin-top: 0em; - margin-left: 0em; - margin-bottom: 0em; -} - -dl { - margin-bottom: 15px; -} - -dd > :first-child { - margin-top: 0px; -} - -dd ul, dd table { - margin-bottom: 10px; -} - -dd { - margin-top: 3px; - margin-bottom: 10px; - margin-left: 30px; -} - -dl > dd:last-child, -dl > dd:last-child > :last-child { - margin-bottom: 0; -} - -dt:target, span.highlighted { - background-color: #fbe54e; -} - -rect.highlighted { - fill: #fbe54e; -} - -dl.glossary dt { - font-weight: bold; - font-size: 1.1em; -} - -.versionmodified { - font-style: italic; -} - -.system-message { - background-color: #fda; - padding: 5px; - border: 3px solid red; -} - -.footnote:target { - background-color: #ffa; -} - -.line-block { - display: block; - margin-top: 1em; - margin-bottom: 1em; -} - -.line-block .line-block { - margin-top: 0; - margin-bottom: 0; - margin-left: 1.5em; -} - -.guilabel, .menuselection { - font-family: sans-serif; -} - -.accelerator { - text-decoration: underline; -} - -.classifier { - font-style: oblique; -} - -.classifier:before { - font-style: normal; - margin: 0.5em; - content: ":"; -} - -abbr, acronym { - border-bottom: dotted 1px; - cursor: help; -} - -/* -- code displays --------------------------------------------------------- */ - -pre { - overflow: auto; - overflow-y: hidden; /* fixes display issues on Chrome browsers */ -} - -pre, div[class*="highlight-"] { - clear: both; -} - -span.pre { - -moz-hyphens: none; - -ms-hyphens: none; - -webkit-hyphens: none; - hyphens: none; -} - -div[class*="highlight-"] { - margin: 1em 0; -} - -td.linenos pre { - border: 0; - background-color: transparent; - color: #aaa; -} - -table.highlighttable { - display: block; -} - -table.highlighttable tbody { - display: block; -} - -table.highlighttable tr { - display: flex; -} - -table.highlighttable td { - margin: 0; - padding: 0; -} - -table.highlighttable td.linenos { - padding-right: 0.5em; -} - -table.highlighttable td.code { - flex: 1; - overflow: hidden; -} - -.highlight .hll { - display: block; -} - -div.highlight pre, -table.highlighttable pre { - margin: 0; -} - -div.code-block-caption + div { - margin-top: 0; -} - -div.code-block-caption { - margin-top: 1em; - padding: 2px 5px; - font-size: small; -} - -div.code-block-caption code { - background-color: transparent; -} - -table.highlighttable td.linenos, -span.linenos, -div.highlight span.gp { /* gp: Generic.Prompt */ - user-select: none; - -webkit-user-select: text; /* Safari fallback only */ - -webkit-user-select: none; /* Chrome/Safari */ - -moz-user-select: none; /* Firefox */ - -ms-user-select: none; /* IE10+ */ -} - -div.code-block-caption span.caption-number { - padding: 0.1em 0.3em; - font-style: italic; -} - -div.code-block-caption span.caption-text { -} - -div.literal-block-wrapper { - margin: 1em 0; -} - -code.xref, a code { - background-color: transparent; - font-weight: bold; -} - -h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { - background-color: transparent; -} - -.viewcode-link { - float: right; -} - -.viewcode-back { - float: right; - font-family: sans-serif; -} - -div.viewcode-block:target { - margin: -1px -10px; - padding: 0 10px; -} - -/* -- math display ---------------------------------------------------------- */ - -img.math { - vertical-align: middle; -} - -div.body div.math p { - text-align: center; -} - -span.eqno { - float: right; -} - -span.eqno a.headerlink { - position: absolute; - z-index: 1; -} - -div.math:hover a.headerlink { - visibility: visible; -} - -/* -- printout stylesheet --------------------------------------------------- */ - -@media print { - div.document, - div.documentwrapper, - div.bodywrapper { - margin: 0 !important; - width: 100%; - } - - div.sphinxsidebar, - div.related, - div.footer, - #top-link { - display: none; - } -} diff --git a/book/content/_build/html/_static/check-solid.svg b/book/content/_build/html/_static/check-solid.svg deleted file mode 100644 index 92fad4b5..00000000 --- a/book/content/_build/html/_static/check-solid.svg +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/book/content/_build/html/_static/clipboard.min.js b/book/content/_build/html/_static/clipboard.min.js deleted file mode 100644 index a17ea72e..00000000 --- a/book/content/_build/html/_static/clipboard.min.js +++ /dev/null @@ -1,7 +0,0 @@ -/*! - * clipboard.js v2.0.8 - * https://clipboardjs.com/ - * - * Licensed MIT © Zeno Rocha - */ -!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return o}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),c=n.n(e);function a(t){try{return document.execCommand(t)}catch(t){return}}var f=function(t){t=c()(t);return a("cut"),t};var l=function(t){var e,n,o,r=1 - - - - diff --git a/book/content/_build/html/_static/copybutton.css b/book/content/_build/html/_static/copybutton.css deleted file mode 100644 index 5d291490..00000000 --- a/book/content/_build/html/_static/copybutton.css +++ /dev/null @@ -1,81 +0,0 @@ -/* Copy buttons */ -button.copybtn { - position: absolute; - display: flex; - top: .3em; - right: .5em; - width: 1.7em; - height: 1.7em; - opacity: 0; - transition: opacity 0.3s, border .3s, background-color .3s; - user-select: none; - padding: 0; - border: none; - outline: none; - border-radius: 0.4em; - border: #e1e1e1 1px solid; - background-color: rgb(245, 245, 245); -} - -button.copybtn.success { - border-color: #22863a; -} - -button.copybtn img { - width: 100%; - padding: .2em; -} - -div.highlight { - position: relative; -} - -.highlight:hover button.copybtn { - opacity: 1; -} - -.highlight button.copybtn:hover { - background-color: rgb(235, 235, 235); -} - -.highlight button.copybtn:active { - background-color: rgb(187, 187, 187); -} - -/** - * A minimal CSS-only tooltip copied from: - * https://codepen.io/mildrenben/pen/rVBrpK - * - * To use, write HTML like the following: - * - *

Short

- */ - .o-tooltip--left { - position: relative; - } - - .o-tooltip--left:after { - opacity: 0; - visibility: hidden; - position: absolute; - content: attr(data-tooltip); - padding: .2em; - font-size: .8em; - left: -.2em; - background: grey; - color: white; - white-space: nowrap; - z-index: 2; - border-radius: 2px; - transform: translateX(-102%) translateY(0); - transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); -} - -.o-tooltip--left:hover:after { - display: block; - opacity: 1; - visibility: visible; - transform: translateX(-100%) translateY(0); - transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); - transition-delay: .5s; -} diff --git a/book/content/_build/html/_static/copybutton.js b/book/content/_build/html/_static/copybutton.js deleted file mode 100644 index a232a9d3..00000000 --- a/book/content/_build/html/_static/copybutton.js +++ /dev/null @@ -1,197 +0,0 @@ -// Localization support -const messages = { - 'en': { - 'copy': 'Copy', - 'copy_to_clipboard': 'Copy to clipboard', - 'copy_success': 'Copied!', - 'copy_failure': 'Failed to copy', - }, - 'es' : { - 'copy': 'Copiar', - 'copy_to_clipboard': 'Copiar al portapapeles', - 'copy_success': '¡Copiado!', - 'copy_failure': 'Error al copiar', - }, - 'de' : { - 'copy': 'Kopieren', - 'copy_to_clipboard': 'In die Zwischenablage kopieren', - 'copy_success': 'Kopiert!', - 'copy_failure': 'Fehler beim Kopieren', - }, - 'fr' : { - 'copy': 'Copier', - 'copy_to_clipboard': 'Copié dans le presse-papier', - 'copy_success': 'Copié !', - 'copy_failure': 'Échec de la copie', - }, - 'ru': { - 'copy': 'Скопировать', - 'copy_to_clipboard': 'Скопировать в буфер', - 'copy_success': 'Скопировано!', - 'copy_failure': 'Не удалось скопировать', - }, - 'zh-CN': { - 'copy': '复制', - 'copy_to_clipboard': '复制到剪贴板', - 'copy_success': '复制成功!', - 'copy_failure': '复制失败', - } -} - -let locale = 'en' -if( document.documentElement.lang !== undefined - && messages[document.documentElement.lang] !== undefined ) { - locale = document.documentElement.lang -} - -let doc_url_root = DOCUMENTATION_OPTIONS.URL_ROOT; -if (doc_url_root == '#') { - doc_url_root = ''; -} - -const path_static = `${doc_url_root}_static/`; - -/** - * Set up copy/paste for code blocks - */ - -const runWhenDOMLoaded = cb => { - if (document.readyState != 'loading') { - cb() - } else if (document.addEventListener) { - document.addEventListener('DOMContentLoaded', cb) - } else { - document.attachEvent('onreadystatechange', function() { - if (document.readyState == 'complete') cb() - }) - } -} - -const codeCellId = index => `codecell${index}` - -// Clears selected text since ClipboardJS will select the text when copying -const clearSelection = () => { - if (window.getSelection) { - window.getSelection().removeAllRanges() - } else if (document.selection) { - document.selection.empty() - } -} - -// Changes tooltip text for two seconds, then changes it back -const temporarilyChangeTooltip = (el, oldText, newText) => { - el.setAttribute('data-tooltip', newText) - el.classList.add('success') - setTimeout(() => el.setAttribute('data-tooltip', oldText), 2000) - setTimeout(() => el.classList.remove('success'), 2000) -} - -// Changes the copy button icon for two seconds, then changes it back -const temporarilyChangeIcon = (el) => { - img = el.querySelector("img"); - img.setAttribute('src', `${path_static}check-solid.svg`) - setTimeout(() => img.setAttribute('src', `${path_static}copy-button.svg`), 2000) -} - -const addCopyButtonToCodeCells = () => { - // If ClipboardJS hasn't loaded, wait a bit and try again. This - // happens because we load ClipboardJS asynchronously. - if (window.ClipboardJS === undefined) { - setTimeout(addCopyButtonToCodeCells, 250) - return - } - - // Add copybuttons to all of our code cells - const codeCells = document.querySelectorAll('div.highlight pre') - codeCells.forEach((codeCell, index) => { - const id = codeCellId(index) - codeCell.setAttribute('id', id) - - const clipboardButton = id => - `` - codeCell.insertAdjacentHTML('afterend', clipboardButton(id)) - }) - -function escapeRegExp(string) { - return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string -} - -// Callback when a copy button is clicked. Will be passed the node that was clicked -// should then grab the text and replace pieces of text that shouldn't be used in output -function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { - - var regexp; - var match; - - // Do we check for line continuation characters and "HERE-documents"? - var useLineCont = !!lineContinuationChar - var useHereDoc = !!hereDocDelim - - // create regexp to capture prompt and remaining line - if (isRegexp) { - regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') - } else { - regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') - } - - const outputLines = []; - var promptFound = false; - var gotLineCont = false; - var gotHereDoc = false; - const lineGotPrompt = []; - for (const line of textContent.split('\n')) { - match = line.match(regexp) - if (match || gotLineCont || gotHereDoc) { - promptFound = regexp.test(line) - lineGotPrompt.push(promptFound) - if (removePrompts && promptFound) { - outputLines.push(match[2]) - } else { - outputLines.push(line) - } - gotLineCont = line.endsWith(lineContinuationChar) & useLineCont - if (line.includes(hereDocDelim) & useHereDoc) - gotHereDoc = !gotHereDoc - } else if (!onlyCopyPromptLines) { - outputLines.push(line) - } else if (copyEmptyLines && line.trim() === '') { - outputLines.push(line) - } - } - - // If no lines with the prompt were found then just use original lines - if (lineGotPrompt.some(v => v === true)) { - textContent = outputLines.join('\n'); - } - - // Remove a trailing newline to avoid auto-running when pasting - if (textContent.endsWith("\n")) { - textContent = textContent.slice(0, -1) - } - return textContent -} - - -var copyTargetText = (trigger) => { - var target = document.querySelector(trigger.attributes['data-clipboard-target'].value); - return formatCopyText(target.innerText, '', false, true, true, true, '', '') -} - - // Initialize with a callback so we can modify the text before copy - const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText}) - - // Update UI with error/success messages - clipboard.on('success', event => { - clearSelection() - temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_success']) - temporarilyChangeIcon(event.trigger) - }) - - clipboard.on('error', event => { - temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_failure']) - }) -} - -runWhenDOMLoaded(addCopyButtonToCodeCells) diff --git a/book/content/_build/html/_static/copybutton_funcs.js b/book/content/_build/html/_static/copybutton_funcs.js deleted file mode 100644 index b9168c55..00000000 --- a/book/content/_build/html/_static/copybutton_funcs.js +++ /dev/null @@ -1,58 +0,0 @@ -function escapeRegExp(string) { - return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string -} - -// Callback when a copy button is clicked. Will be passed the node that was clicked -// should then grab the text and replace pieces of text that shouldn't be used in output -export function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { - - var regexp; - var match; - - // Do we check for line continuation characters and "HERE-documents"? - var useLineCont = !!lineContinuationChar - var useHereDoc = !!hereDocDelim - - // create regexp to capture prompt and remaining line - if (isRegexp) { - regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') - } else { - regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') - } - - const outputLines = []; - var promptFound = false; - var gotLineCont = false; - var gotHereDoc = false; - const lineGotPrompt = []; - for (const line of textContent.split('\n')) { - match = line.match(regexp) - if (match || gotLineCont || gotHereDoc) { - promptFound = regexp.test(line) - lineGotPrompt.push(promptFound) - if (removePrompts && promptFound) { - outputLines.push(match[2]) - } else { - outputLines.push(line) - } - gotLineCont = line.endsWith(lineContinuationChar) & useLineCont - if (line.includes(hereDocDelim) & useHereDoc) - gotHereDoc = !gotHereDoc - } else if (!onlyCopyPromptLines) { - outputLines.push(line) - } else if (copyEmptyLines && line.trim() === '') { - outputLines.push(line) - } - } - - // If no lines with the prompt were found then just use original lines - if (lineGotPrompt.some(v => v === true)) { - textContent = outputLines.join('\n'); - } - - // Remove a trailing newline to avoid auto-running when pasting - if (textContent.endsWith("\n")) { - textContent = textContent.slice(0, -1) - } - return textContent -} diff --git a/book/content/_build/html/_static/css/blank.css b/book/content/_build/html/_static/css/blank.css deleted file mode 100644 index d63edea3..00000000 --- a/book/content/_build/html/_static/css/blank.css +++ /dev/null @@ -1,2 +0,0 @@ -/* This file is intentionally left blank to override the stylesheet of the -parent theme via theme.conf. The parent style we import directly in theme.css */ diff --git a/book/content/_build/html/_static/css/index.ff1ffe594081f20da1ef19478df9384b.css b/book/content/_build/html/_static/css/index.ff1ffe594081f20da1ef19478df9384b.css deleted file mode 100644 index 62c6dbd5..00000000 --- a/book/content/_build/html/_static/css/index.ff1ffe594081f20da1ef19478df9384b.css +++ /dev/null @@ -1,6 +0,0 @@ -/*! - * Bootstrap v4.5.0 (https://getbootstrap.com/) - * Copyright 2011-2020 The Bootstrap Authors - * Copyright 2011-2020 Twitter, Inc. - * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) - */:root{--blue:#007bff;--indigo:#6610f2;--purple:#6f42c1;--pink:#e83e8c;--red:#dc3545;--orange:#fd7e14;--yellow:#ffc107;--green:#28a745;--teal:#20c997;--cyan:#17a2b8;--white:#fff;--gray:#6c757d;--gray-dark:#343a40;--primary:#007bff;--secondary:#6c757d;--success:#28a745;--info:#17a2b8;--warning:#ffc107;--danger:#dc3545;--light:#f8f9fa;--dark:#343a40;--breakpoint-xs:0;--breakpoint-sm:540px;--breakpoint-md:720px;--breakpoint-lg:960px;--breakpoint-xl:1200px;--font-family-sans-serif:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--font-family-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace}*,:after,:before{box-sizing:border-box}html{font-family:sans-serif;line-height:1.15;-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0)}article,aside,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}body{margin:0;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-size:1rem;line-height:1.5;color:#212529;text-align:left}[tabindex="-1"]:focus:not(:focus-visible){outline:0!important}hr{box-sizing:content-box;height:0;overflow:visible}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem}p{margin-top:0;margin-bottom:1rem}abbr[data-original-title],abbr[title]{text-decoration:underline;text-decoration:underline dotted;cursor:help;border-bottom:0;text-decoration-skip-ink:none}address{font-style:normal;line-height:inherit}address,dl,ol,ul{margin-bottom:1rem}dl,ol,ul{margin-top:0}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:80%}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#007bff;background-color:transparent}a:hover{color:#0056b3}a:not([href]),a:not([href]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-size:1em}pre{margin-top:0;margin-bottom:1rem;overflow:auto;-ms-overflow-style:scrollbar}figure{margin:0 0 1rem}img{border-style:none}img,svg{vertical-align:middle}svg{overflow:hidden}table{border-collapse:collapse}caption{padding-top:.75rem;padding-bottom:.75rem;color:#6c757d;text-align:left;caption-side:bottom}th{text-align:inherit}label{display:inline-block;margin-bottom:.5rem}button{border-radius:0}button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,input{overflow:visible}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{padding:0;border-style:none}input[type=checkbox],input[type=radio]{box-sizing:border-box;padding:0}textarea{overflow:auto;resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{display:block;width:100%;max-width:100%;padding:0;margin-bottom:.5rem;font-size:1.5rem;line-height:inherit;color:inherit;white-space:normal}progress{vertical-align:baseline}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:none}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}summary{display:list-item;cursor:pointer}template{display:none}[hidden]{display:none!important}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{margin-bottom:.5rem;font-weight:500;line-height:1.2}.h1,h1{font-size:2.5rem}.h2,h2{font-size:2rem}.h3,h3{font-size:1.75rem}.h4,h4{font-size:1.5rem}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:6rem}.display-1,.display-2{font-weight:300;line-height:1.2}.display-2{font-size:5.5rem}.display-3{font-size:4.5rem}.display-3,.display-4{font-weight:300;line-height:1.2}.display-4{font-size:3.5rem}hr{margin-top:1rem;margin-bottom:1rem;border-top:1px solid rgba(0,0,0,.1)}.small,small{font-size:80%;font-weight:400}.mark,mark{padding:.2em;background-color:#fcf8e3}.list-inline,.list-unstyled{padding-left:0;list-style:none}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{font-size:90%;text-transform:uppercase}.blockquote{margin-bottom:1rem;font-size:1.25rem}.blockquote-footer{display:block;font-size:80%;color:#6c757d}.blockquote-footer:before{content:"\2014\00A0"}.img-fluid,.img-thumbnail{max-width:100%;height:auto}.img-thumbnail{padding:.25rem;background-color:#fff;border:1px solid #dee2e6;border-radius:.25rem}.figure{display:inline-block}.figure-img{margin-bottom:.5rem;line-height:1}.figure-caption{font-size:90%;color:#6c757d}code{font-size:87.5%;color:#e83e8c;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:87.5%;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:100%;font-weight:700}pre{display:block;font-size:87.5%;color:#212529}pre code{font-size:inherit;color:inherit;word-break:normal}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{width:100%;padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:540px){.container{max-width:540px}}@media (min-width:720px){.container{max-width:720px}}@media (min-width:960px){.container{max-width:960px}}@media (min-width:1200px){.container{max-width:1400px}}.container-fluid,.container-lg,.container-md,.container-sm,.container-xl{width:100%;padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:540px){.container,.container-sm{max-width:540px}}@media (min-width:720px){.container,.container-md,.container-sm{max-width:720px}}@media (min-width:960px){.container,.container-lg,.container-md,.container-sm{max-width:960px}}@media (min-width:1200px){.container,.container-lg,.container-md,.container-sm,.container-xl{max-width:1400px}}.row{display:flex;flex-wrap:wrap;margin-right:-15px;margin-left:-15px}.no-gutters{margin-right:0;margin-left:0}.no-gutters>.col,.no-gutters>[class*=col-]{padding-right:0;padding-left:0}.col,.col-1,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-10,.col-11,.col-12,.col-auto,.col-lg,.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-auto,.col-md,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-md-auto,.col-sm,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-auto,.col-xl,.col-xl-1,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-auto{position:relative;width:100%;padding-right:15px;padding-left:15px}.col{flex-basis:0;flex-grow:1;min-width:0;max-width:100%}.row-cols-1>*{flex:0 0 100%;max-width:100%}.row-cols-2>*{flex:0 0 50%;max-width:50%}.row-cols-3>*{flex:0 0 33.33333%;max-width:33.33333%}.row-cols-4>*{flex:0 0 25%;max-width:25%}.row-cols-5>*{flex:0 0 20%;max-width:20%}.row-cols-6>*{flex:0 0 16.66667%;max-width:16.66667%}.col-auto{flex:0 0 auto;width:auto;max-width:100%}.col-1{flex:0 0 8.33333%;max-width:8.33333%}.col-2{flex:0 0 16.66667%;max-width:16.66667%}.col-3{flex:0 0 25%;max-width:25%}.col-4{flex:0 0 33.33333%;max-width:33.33333%}.col-5{flex:0 0 41.66667%;max-width:41.66667%}.col-6{flex:0 0 50%;max-width:50%}.col-7{flex:0 0 58.33333%;max-width:58.33333%}.col-8{flex:0 0 66.66667%;max-width:66.66667%}.col-9{flex:0 0 75%;max-width:75%}.col-10{flex:0 0 83.33333%;max-width:83.33333%}.col-11{flex:0 0 91.66667%;max-width:91.66667%}.col-12{flex:0 0 100%;max-width:100%}.order-first{order:-1}.order-last{order:13}.order-0{order:0}.order-1{order:1}.order-2{order:2}.order-3{order:3}.order-4{order:4}.order-5{order:5}.order-6{order:6}.order-7{order:7}.order-8{order:8}.order-9{order:9}.order-10{order:10}.order-11{order:11}.order-12{order:12}.offset-1{margin-left:8.33333%}.offset-2{margin-left:16.66667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.33333%}.offset-5{margin-left:41.66667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.33333%}.offset-8{margin-left:66.66667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.33333%}.offset-11{margin-left:91.66667%}@media (min-width:540px){.col-sm{flex-basis:0;flex-grow:1;min-width:0;max-width:100%}.row-cols-sm-1>*{flex:0 0 100%;max-width:100%}.row-cols-sm-2>*{flex:0 0 50%;max-width:50%}.row-cols-sm-3>*{flex:0 0 33.33333%;max-width:33.33333%}.row-cols-sm-4>*{flex:0 0 25%;max-width:25%}.row-cols-sm-5>*{flex:0 0 20%;max-width:20%}.row-cols-sm-6>*{flex:0 0 16.66667%;max-width:16.66667%}.col-sm-auto{flex:0 0 auto;width:auto;max-width:100%}.col-sm-1{flex:0 0 8.33333%;max-width:8.33333%}.col-sm-2{flex:0 0 16.66667%;max-width:16.66667%}.col-sm-3{flex:0 0 25%;max-width:25%}.col-sm-4{flex:0 0 33.33333%;max-width:33.33333%}.col-sm-5{flex:0 0 41.66667%;max-width:41.66667%}.col-sm-6{flex:0 0 50%;max-width:50%}.col-sm-7{flex:0 0 58.33333%;max-width:58.33333%}.col-sm-8{flex:0 0 66.66667%;max-width:66.66667%}.col-sm-9{flex:0 0 75%;max-width:75%}.col-sm-10{flex:0 0 83.33333%;max-width:83.33333%}.col-sm-11{flex:0 0 91.66667%;max-width:91.66667%}.col-sm-12{flex:0 0 100%;max-width:100%}.order-sm-first{order:-1}.order-sm-last{order:13}.order-sm-0{order:0}.order-sm-1{order:1}.order-sm-2{order:2}.order-sm-3{order:3}.order-sm-4{order:4}.order-sm-5{order:5}.order-sm-6{order:6}.order-sm-7{order:7}.order-sm-8{order:8}.order-sm-9{order:9}.order-sm-10{order:10}.order-sm-11{order:11}.order-sm-12{order:12}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.33333%}.offset-sm-2{margin-left:16.66667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.33333%}.offset-sm-5{margin-left:41.66667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.33333%}.offset-sm-8{margin-left:66.66667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.33333%}.offset-sm-11{margin-left:91.66667%}}@media (min-width:720px){.col-md{flex-basis:0;flex-grow:1;min-width:0;max-width:100%}.row-cols-md-1>*{flex:0 0 100%;max-width:100%}.row-cols-md-2>*{flex:0 0 50%;max-width:50%}.row-cols-md-3>*{flex:0 0 33.33333%;max-width:33.33333%}.row-cols-md-4>*{flex:0 0 25%;max-width:25%}.row-cols-md-5>*{flex:0 0 20%;max-width:20%}.row-cols-md-6>*{flex:0 0 16.66667%;max-width:16.66667%}.col-md-auto{flex:0 0 auto;width:auto;max-width:100%}.col-md-1{flex:0 0 8.33333%;max-width:8.33333%}.col-md-2{flex:0 0 16.66667%;max-width:16.66667%}.col-md-3{flex:0 0 25%;max-width:25%}.col-md-4{flex:0 0 33.33333%;max-width:33.33333%}.col-md-5{flex:0 0 41.66667%;max-width:41.66667%}.col-md-6{flex:0 0 50%;max-width:50%}.col-md-7{flex:0 0 58.33333%;max-width:58.33333%}.col-md-8{flex:0 0 66.66667%;max-width:66.66667%}.col-md-9{flex:0 0 75%;max-width:75%}.col-md-10{flex:0 0 83.33333%;max-width:83.33333%}.col-md-11{flex:0 0 91.66667%;max-width:91.66667%}.col-md-12{flex:0 0 100%;max-width:100%}.order-md-first{order:-1}.order-md-last{order:13}.order-md-0{order:0}.order-md-1{order:1}.order-md-2{order:2}.order-md-3{order:3}.order-md-4{order:4}.order-md-5{order:5}.order-md-6{order:6}.order-md-7{order:7}.order-md-8{order:8}.order-md-9{order:9}.order-md-10{order:10}.order-md-11{order:11}.order-md-12{order:12}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.33333%}.offset-md-2{margin-left:16.66667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.33333%}.offset-md-5{margin-left:41.66667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.33333%}.offset-md-8{margin-left:66.66667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.33333%}.offset-md-11{margin-left:91.66667%}}@media (min-width:960px){.col-lg{flex-basis:0;flex-grow:1;min-width:0;max-width:100%}.row-cols-lg-1>*{flex:0 0 100%;max-width:100%}.row-cols-lg-2>*{flex:0 0 50%;max-width:50%}.row-cols-lg-3>*{flex:0 0 33.33333%;max-width:33.33333%}.row-cols-lg-4>*{flex:0 0 25%;max-width:25%}.row-cols-lg-5>*{flex:0 0 20%;max-width:20%}.row-cols-lg-6>*{flex:0 0 16.66667%;max-width:16.66667%}.col-lg-auto{flex:0 0 auto;width:auto;max-width:100%}.col-lg-1{flex:0 0 8.33333%;max-width:8.33333%}.col-lg-2{flex:0 0 16.66667%;max-width:16.66667%}.col-lg-3{flex:0 0 25%;max-width:25%}.col-lg-4{flex:0 0 33.33333%;max-width:33.33333%}.col-lg-5{flex:0 0 41.66667%;max-width:41.66667%}.col-lg-6{flex:0 0 50%;max-width:50%}.col-lg-7{flex:0 0 58.33333%;max-width:58.33333%}.col-lg-8{flex:0 0 66.66667%;max-width:66.66667%}.col-lg-9{flex:0 0 75%;max-width:75%}.col-lg-10{flex:0 0 83.33333%;max-width:83.33333%}.col-lg-11{flex:0 0 91.66667%;max-width:91.66667%}.col-lg-12{flex:0 0 100%;max-width:100%}.order-lg-first{order:-1}.order-lg-last{order:13}.order-lg-0{order:0}.order-lg-1{order:1}.order-lg-2{order:2}.order-lg-3{order:3}.order-lg-4{order:4}.order-lg-5{order:5}.order-lg-6{order:6}.order-lg-7{order:7}.order-lg-8{order:8}.order-lg-9{order:9}.order-lg-10{order:10}.order-lg-11{order:11}.order-lg-12{order:12}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.33333%}.offset-lg-2{margin-left:16.66667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.33333%}.offset-lg-5{margin-left:41.66667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.33333%}.offset-lg-8{margin-left:66.66667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.33333%}.offset-lg-11{margin-left:91.66667%}}@media (min-width:1200px){.col-xl{flex-basis:0;flex-grow:1;min-width:0;max-width:100%}.row-cols-xl-1>*{flex:0 0 100%;max-width:100%}.row-cols-xl-2>*{flex:0 0 50%;max-width:50%}.row-cols-xl-3>*{flex:0 0 33.33333%;max-width:33.33333%}.row-cols-xl-4>*{flex:0 0 25%;max-width:25%}.row-cols-xl-5>*{flex:0 0 20%;max-width:20%}.row-cols-xl-6>*{flex:0 0 16.66667%;max-width:16.66667%}.col-xl-auto{flex:0 0 auto;width:auto;max-width:100%}.col-xl-1{flex:0 0 8.33333%;max-width:8.33333%}.col-xl-2{flex:0 0 16.66667%;max-width:16.66667%}.col-xl-3{flex:0 0 25%;max-width:25%}.col-xl-4{flex:0 0 33.33333%;max-width:33.33333%}.col-xl-5{flex:0 0 41.66667%;max-width:41.66667%}.col-xl-6{flex:0 0 50%;max-width:50%}.col-xl-7{flex:0 0 58.33333%;max-width:58.33333%}.col-xl-8{flex:0 0 66.66667%;max-width:66.66667%}.col-xl-9{flex:0 0 75%;max-width:75%}.col-xl-10{flex:0 0 83.33333%;max-width:83.33333%}.col-xl-11{flex:0 0 91.66667%;max-width:91.66667%}.col-xl-12{flex:0 0 100%;max-width:100%}.order-xl-first{order:-1}.order-xl-last{order:13}.order-xl-0{order:0}.order-xl-1{order:1}.order-xl-2{order:2}.order-xl-3{order:3}.order-xl-4{order:4}.order-xl-5{order:5}.order-xl-6{order:6}.order-xl-7{order:7}.order-xl-8{order:8}.order-xl-9{order:9}.order-xl-10{order:10}.order-xl-11{order:11}.order-xl-12{order:12}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.33333%}.offset-xl-2{margin-left:16.66667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.33333%}.offset-xl-5{margin-left:41.66667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.33333%}.offset-xl-8{margin-left:66.66667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.33333%}.offset-xl-11{margin-left:91.66667%}}.table{width:100%;margin-bottom:1rem;color:#212529}.table td,.table th{padding:.75rem;vertical-align:top;border-top:1px solid #dee2e6}.table thead th{vertical-align:bottom;border-bottom:2px solid #dee2e6}.table tbody+tbody{border-top:2px solid #dee2e6}.table-sm td,.table-sm th{padding:.3rem}.table-bordered,.table-bordered td,.table-bordered th{border:1px solid #dee2e6}.table-bordered thead td,.table-bordered thead th{border-bottom-width:2px}.table-borderless tbody+tbody,.table-borderless td,.table-borderless th,.table-borderless thead th{border:0}.table-striped tbody tr:nth-of-type(odd){background-color:rgba(0,0,0,.05)}.table-hover tbody tr:hover{color:#212529;background-color:rgba(0,0,0,.075)}.table-primary,.table-primary>td,.table-primary>th{background-color:#b8daff}.table-primary tbody+tbody,.table-primary td,.table-primary th,.table-primary thead th{border-color:#7abaff}.table-hover .table-primary:hover,.table-hover .table-primary:hover>td,.table-hover .table-primary:hover>th{background-color:#9fcdff}.table-secondary,.table-secondary>td,.table-secondary>th{background-color:#d6d8db}.table-secondary tbody+tbody,.table-secondary td,.table-secondary th,.table-secondary thead th{border-color:#b3b7bb}.table-hover .table-secondary:hover,.table-hover .table-secondary:hover>td,.table-hover .table-secondary:hover>th{background-color:#c8cbcf}.table-success,.table-success>td,.table-success>th{background-color:#c3e6cb}.table-success tbody+tbody,.table-success td,.table-success th,.table-success thead th{border-color:#8fd19e}.table-hover .table-success:hover,.table-hover .table-success:hover>td,.table-hover .table-success:hover>th{background-color:#b1dfbb}.table-info,.table-info>td,.table-info>th{background-color:#bee5eb}.table-info tbody+tbody,.table-info td,.table-info th,.table-info thead th{border-color:#86cfda}.table-hover .table-info:hover,.table-hover .table-info:hover>td,.table-hover .table-info:hover>th{background-color:#abdde5}.table-warning,.table-warning>td,.table-warning>th{background-color:#ffeeba}.table-warning tbody+tbody,.table-warning td,.table-warning th,.table-warning thead th{border-color:#ffdf7e}.table-hover .table-warning:hover,.table-hover .table-warning:hover>td,.table-hover .table-warning:hover>th{background-color:#ffe8a1}.table-danger,.table-danger>td,.table-danger>th{background-color:#f5c6cb}.table-danger tbody+tbody,.table-danger td,.table-danger th,.table-danger thead th{border-color:#ed969e}.table-hover .table-danger:hover,.table-hover .table-danger:hover>td,.table-hover .table-danger:hover>th{background-color:#f1b0b7}.table-light,.table-light>td,.table-light>th{background-color:#fdfdfe}.table-light tbody+tbody,.table-light td,.table-light th,.table-light thead th{border-color:#fbfcfc}.table-hover .table-light:hover,.table-hover .table-light:hover>td,.table-hover .table-light:hover>th{background-color:#ececf6}.table-dark,.table-dark>td,.table-dark>th{background-color:#c6c8ca}.table-dark tbody+tbody,.table-dark td,.table-dark th,.table-dark thead th{border-color:#95999c}.table-hover .table-dark:hover,.table-hover .table-dark:hover>td,.table-hover .table-dark:hover>th{background-color:#b9bbbe}.table-active,.table-active>td,.table-active>th,.table-hover .table-active:hover,.table-hover .table-active:hover>td,.table-hover .table-active:hover>th{background-color:rgba(0,0,0,.075)}.table .thead-dark th{color:#fff;background-color:#343a40;border-color:#454d55}.table .thead-light th{color:#495057;background-color:#e9ecef;border-color:#dee2e6}.table-dark{color:#fff;background-color:#343a40}.table-dark td,.table-dark th,.table-dark thead th{border-color:#454d55}.table-dark.table-bordered{border:0}.table-dark.table-striped tbody tr:nth-of-type(odd){background-color:hsla(0,0%,100%,.05)}.table-dark.table-hover tbody tr:hover{color:#fff;background-color:hsla(0,0%,100%,.075)}@media (max-width:539.98px){.table-responsive-sm{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-sm>.table-bordered{border:0}}@media (max-width:719.98px){.table-responsive-md{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-md>.table-bordered{border:0}}@media (max-width:959.98px){.table-responsive-lg{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-lg>.table-bordered{border:0}}@media (max-width:1199.98px){.table-responsive-xl{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-xl>.table-bordered{border:0}}.table-responsive{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive>.table-bordered{border:0}.form-control{display:block;width:100%;height:calc(1.5em + .75rem + 2px);padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#495057;background-color:#fff;background-clip:padding-box;border:1px solid #ced4da;border-radius:.25rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control::-ms-expand{background-color:transparent;border:0}.form-control:-moz-focusring{color:transparent;text-shadow:0 0 0 #495057}.form-control:focus{color:#495057;background-color:#fff;border-color:#80bdff;outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.form-control::placeholder{color:#6c757d;opacity:1}.form-control:disabled,.form-control[readonly]{background-color:#e9ecef;opacity:1}input[type=date].form-control,input[type=datetime-local].form-control,input[type=month].form-control,input[type=time].form-control{appearance:none}select.form-control:focus::-ms-value{color:#495057;background-color:#fff}.form-control-file,.form-control-range{display:block;width:100%}.col-form-label{padding-top:calc(.375rem + 1px);padding-bottom:calc(.375rem + 1px);margin-bottom:0;font-size:inherit;line-height:1.5}.col-form-label-lg{padding-top:calc(.5rem + 1px);padding-bottom:calc(.5rem + 1px);font-size:1.25rem;line-height:1.5}.col-form-label-sm{padding-top:calc(.25rem + 1px);padding-bottom:calc(.25rem + 1px);font-size:.875rem;line-height:1.5}.form-control-plaintext{display:block;width:100%;padding:.375rem 0;margin-bottom:0;font-size:1rem;line-height:1.5;color:#212529;background-color:transparent;border:solid transparent;border-width:1px 0}.form-control-plaintext.form-control-lg,.form-control-plaintext.form-control-sm{padding-right:0;padding-left:0}.form-control-sm{height:calc(1.5em + .5rem + 2px);padding:.25rem .5rem;font-size:.875rem;line-height:1.5;border-radius:.2rem}.form-control-lg{height:calc(1.5em + 1rem + 2px);padding:.5rem 1rem;font-size:1.25rem;line-height:1.5;border-radius:.3rem}select.form-control[multiple],select.form-control[size],textarea.form-control{height:auto}.form-group{margin-bottom:1rem}.form-text{display:block;margin-top:.25rem}.form-row{display:flex;flex-wrap:wrap;margin-right:-5px;margin-left:-5px}.form-row>.col,.form-row>[class*=col-]{padding-right:5px;padding-left:5px}.form-check{position:relative;display:block;padding-left:1.25rem}.form-check-input{position:absolute;margin-top:.3rem;margin-left:-1.25rem}.form-check-input:disabled~.form-check-label,.form-check-input[disabled]~.form-check-label{color:#6c757d}.form-check-label{margin-bottom:0}.form-check-inline{display:inline-flex;align-items:center;padding-left:0;margin-right:.75rem}.form-check-inline .form-check-input{position:static;margin-top:0;margin-right:.3125rem;margin-left:0}.valid-feedback{display:none;width:100%;margin-top:.25rem;font-size:80%;color:#28a745}.valid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;line-height:1.5;color:#fff;background-color:rgba(40,167,69,.9);border-radius:.25rem}.is-valid~.valid-feedback,.is-valid~.valid-tooltip,.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip{display:block}.form-control.is-valid,.was-validated .form-control:valid{border-color:#28a745;padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8'%3E%3Cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-valid:focus,.was-validated .form-control:valid:focus{border-color:#28a745;box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.custom-select.is-valid,.was-validated .custom-select:valid{border-color:#28a745;padding-right:calc(.75em + 2.3125rem);background:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5'%3E%3Cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3E%3C/svg%3E") no-repeat right .75rem center/8px 10px,url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8'%3E%3Cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E") #fff no-repeat center right 1.75rem/calc(.75em + .375rem) calc(.75em + .375rem)}.custom-select.is-valid:focus,.was-validated .custom-select:valid:focus{border-color:#28a745;box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.form-check-input.is-valid~.form-check-label,.was-validated .form-check-input:valid~.form-check-label{color:#28a745}.form-check-input.is-valid~.valid-feedback,.form-check-input.is-valid~.valid-tooltip,.was-validated .form-check-input:valid~.valid-feedback,.was-validated .form-check-input:valid~.valid-tooltip{display:block}.custom-control-input.is-valid~.custom-control-label,.was-validated .custom-control-input:valid~.custom-control-label{color:#28a745}.custom-control-input.is-valid~.custom-control-label:before,.was-validated .custom-control-input:valid~.custom-control-label:before{border-color:#28a745}.custom-control-input.is-valid:checked~.custom-control-label:before,.was-validated .custom-control-input:valid:checked~.custom-control-label:before{border-color:#34ce57;background-color:#34ce57}.custom-control-input.is-valid:focus~.custom-control-label:before,.was-validated .custom-control-input:valid:focus~.custom-control-label:before{box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.custom-control-input.is-valid:focus:not(:checked)~.custom-control-label:before,.custom-file-input.is-valid~.custom-file-label,.was-validated .custom-control-input:valid:focus:not(:checked)~.custom-control-label:before,.was-validated .custom-file-input:valid~.custom-file-label{border-color:#28a745}.custom-file-input.is-valid:focus~.custom-file-label,.was-validated .custom-file-input:valid:focus~.custom-file-label{border-color:#28a745;box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.invalid-feedback{display:none;width:100%;margin-top:.25rem;font-size:80%;color:#dc3545}.invalid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;line-height:1.5;color:#fff;background-color:rgba(220,53,69,.9);border-radius:.25rem}.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip,.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip{display:block}.form-control.is-invalid,.was-validated .form-control:invalid{border-color:#dc3545;padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545'%3E%3Ccircle cx='6' cy='6' r='4.5'/%3E%3Cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3E%3Ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-invalid:focus,.was-validated .form-control:invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.custom-select.is-invalid,.was-validated .custom-select:invalid{border-color:#dc3545;padding-right:calc(.75em + 2.3125rem);background:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5'%3E%3Cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3E%3C/svg%3E") no-repeat right .75rem center/8px 10px,url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545'%3E%3Ccircle cx='6' cy='6' r='4.5'/%3E%3Cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3E%3Ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3E%3C/svg%3E") #fff no-repeat center right 1.75rem/calc(.75em + .375rem) calc(.75em + .375rem)}.custom-select.is-invalid:focus,.was-validated .custom-select:invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.form-check-input.is-invalid~.form-check-label,.was-validated .form-check-input:invalid~.form-check-label{color:#dc3545}.form-check-input.is-invalid~.invalid-feedback,.form-check-input.is-invalid~.invalid-tooltip,.was-validated .form-check-input:invalid~.invalid-feedback,.was-validated .form-check-input:invalid~.invalid-tooltip{display:block}.custom-control-input.is-invalid~.custom-control-label,.was-validated .custom-control-input:invalid~.custom-control-label{color:#dc3545}.custom-control-input.is-invalid~.custom-control-label:before,.was-validated .custom-control-input:invalid~.custom-control-label:before{border-color:#dc3545}.custom-control-input.is-invalid:checked~.custom-control-label:before,.was-validated .custom-control-input:invalid:checked~.custom-control-label:before{border-color:#e4606d;background-color:#e4606d}.custom-control-input.is-invalid:focus~.custom-control-label:before,.was-validated .custom-control-input:invalid:focus~.custom-control-label:before{box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.custom-control-input.is-invalid:focus:not(:checked)~.custom-control-label:before,.custom-file-input.is-invalid~.custom-file-label,.was-validated .custom-control-input:invalid:focus:not(:checked)~.custom-control-label:before,.was-validated .custom-file-input:invalid~.custom-file-label{border-color:#dc3545}.custom-file-input.is-invalid:focus~.custom-file-label,.was-validated .custom-file-input:invalid:focus~.custom-file-label{border-color:#dc3545;box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.form-inline{display:flex;flex-flow:row wrap;align-items:center}.form-inline .form-check{width:100%}@media (min-width:540px){.form-inline label{justify-content:center}.form-inline .form-group,.form-inline label{display:flex;align-items:center;margin-bottom:0}.form-inline .form-group{flex:0 0 auto;flex-flow:row wrap}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-plaintext{display:inline-block}.form-inline .custom-select,.form-inline .input-group{width:auto}.form-inline .form-check{display:flex;align-items:center;justify-content:center;width:auto;padding-left:0}.form-inline .form-check-input{position:relative;flex-shrink:0;margin-top:0;margin-right:.25rem;margin-left:0}.form-inline .custom-control{align-items:center;justify-content:center}.form-inline .custom-control-label{margin-bottom:0}}.btn{display:inline-block;font-weight:400;color:#212529;text-align:center;vertical-align:middle;user-select:none;background-color:transparent;border:1px solid transparent;padding:.375rem .75rem;font-size:1rem;line-height:1.5;border-radius:.25rem;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{color:#212529;text-decoration:none}.btn.focus,.btn:focus{outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.btn.disabled,.btn:disabled{opacity:.65}.btn:not(:disabled):not(.disabled){cursor:pointer}a.btn.disabled,fieldset:disabled a.btn{pointer-events:none}.btn-primary{color:#fff;background-color:#007bff;border-color:#007bff}.btn-primary.focus,.btn-primary:focus,.btn-primary:hover{color:#fff;background-color:#0069d9;border-color:#0062cc}.btn-primary.focus,.btn-primary:focus{box-shadow:0 0 0 .2rem rgba(38,143,255,.5)}.btn-primary.disabled,.btn-primary:disabled{color:#fff;background-color:#007bff;border-color:#007bff}.btn-primary:not(:disabled):not(.disabled).active,.btn-primary:not(:disabled):not(.disabled):active,.show>.btn-primary.dropdown-toggle{color:#fff;background-color:#0062cc;border-color:#005cbf}.btn-primary:not(:disabled):not(.disabled).active:focus,.btn-primary:not(:disabled):not(.disabled):active:focus,.show>.btn-primary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(38,143,255,.5)}.btn-secondary{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary.focus,.btn-secondary:focus,.btn-secondary:hover{color:#fff;background-color:#5a6268;border-color:#545b62}.btn-secondary.focus,.btn-secondary:focus{box-shadow:0 0 0 .2rem rgba(130,138,145,.5)}.btn-secondary.disabled,.btn-secondary:disabled{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary:not(:disabled):not(.disabled).active,.btn-secondary:not(:disabled):not(.disabled):active,.show>.btn-secondary.dropdown-toggle{color:#fff;background-color:#545b62;border-color:#4e555b}.btn-secondary:not(:disabled):not(.disabled).active:focus,.btn-secondary:not(:disabled):not(.disabled):active:focus,.show>.btn-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(130,138,145,.5)}.btn-success{color:#fff;background-color:#28a745;border-color:#28a745}.btn-success.focus,.btn-success:focus,.btn-success:hover{color:#fff;background-color:#218838;border-color:#1e7e34}.btn-success.focus,.btn-success:focus{box-shadow:0 0 0 .2rem rgba(72,180,97,.5)}.btn-success.disabled,.btn-success:disabled{color:#fff;background-color:#28a745;border-color:#28a745}.btn-success:not(:disabled):not(.disabled).active,.btn-success:not(:disabled):not(.disabled):active,.show>.btn-success.dropdown-toggle{color:#fff;background-color:#1e7e34;border-color:#1c7430}.btn-success:not(:disabled):not(.disabled).active:focus,.btn-success:not(:disabled):not(.disabled):active:focus,.show>.btn-success.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(72,180,97,.5)}.btn-info{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-info.focus,.btn-info:focus,.btn-info:hover{color:#fff;background-color:#138496;border-color:#117a8b}.btn-info.focus,.btn-info:focus{box-shadow:0 0 0 .2rem rgba(58,176,195,.5)}.btn-info.disabled,.btn-info:disabled{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-info:not(:disabled):not(.disabled).active,.btn-info:not(:disabled):not(.disabled):active,.show>.btn-info.dropdown-toggle{color:#fff;background-color:#117a8b;border-color:#10707f}.btn-info:not(:disabled):not(.disabled).active:focus,.btn-info:not(:disabled):not(.disabled):active:focus,.show>.btn-info.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(58,176,195,.5)}.btn-warning{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-warning.focus,.btn-warning:focus,.btn-warning:hover{color:#212529;background-color:#e0a800;border-color:#d39e00}.btn-warning.focus,.btn-warning:focus{box-shadow:0 0 0 .2rem rgba(222,170,12,.5)}.btn-warning.disabled,.btn-warning:disabled{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-warning:not(:disabled):not(.disabled).active,.btn-warning:not(:disabled):not(.disabled):active,.show>.btn-warning.dropdown-toggle{color:#212529;background-color:#d39e00;border-color:#c69500}.btn-warning:not(:disabled):not(.disabled).active:focus,.btn-warning:not(:disabled):not(.disabled):active:focus,.show>.btn-warning.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(222,170,12,.5)}.btn-danger{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger.focus,.btn-danger:focus,.btn-danger:hover{color:#fff;background-color:#c82333;border-color:#bd2130}.btn-danger.focus,.btn-danger:focus{box-shadow:0 0 0 .2rem rgba(225,83,97,.5)}.btn-danger.disabled,.btn-danger:disabled{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger:not(:disabled):not(.disabled).active,.btn-danger:not(:disabled):not(.disabled):active,.show>.btn-danger.dropdown-toggle{color:#fff;background-color:#bd2130;border-color:#b21f2d}.btn-danger:not(:disabled):not(.disabled).active:focus,.btn-danger:not(:disabled):not(.disabled):active:focus,.show>.btn-danger.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(225,83,97,.5)}.btn-light{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light.focus,.btn-light:focus,.btn-light:hover{color:#212529;background-color:#e2e6ea;border-color:#dae0e5}.btn-light.focus,.btn-light:focus{box-shadow:0 0 0 .2rem rgba(216,217,219,.5)}.btn-light.disabled,.btn-light:disabled{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light:not(:disabled):not(.disabled).active,.btn-light:not(:disabled):not(.disabled):active,.show>.btn-light.dropdown-toggle{color:#212529;background-color:#dae0e5;border-color:#d3d9df}.btn-light:not(:disabled):not(.disabled).active:focus,.btn-light:not(:disabled):not(.disabled):active:focus,.show>.btn-light.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(216,217,219,.5)}.btn-dark{color:#fff;background-color:#343a40;border-color:#343a40}.btn-dark.focus,.btn-dark:focus,.btn-dark:hover{color:#fff;background-color:#23272b;border-color:#1d2124}.btn-dark.focus,.btn-dark:focus{box-shadow:0 0 0 .2rem rgba(82,88,93,.5)}.btn-dark.disabled,.btn-dark:disabled{color:#fff;background-color:#343a40;border-color:#343a40}.btn-dark:not(:disabled):not(.disabled).active,.btn-dark:not(:disabled):not(.disabled):active,.show>.btn-dark.dropdown-toggle{color:#fff;background-color:#1d2124;border-color:#171a1d}.btn-dark:not(:disabled):not(.disabled).active:focus,.btn-dark:not(:disabled):not(.disabled):active:focus,.show>.btn-dark.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(82,88,93,.5)}.btn-outline-primary{color:#007bff;border-color:#007bff}.btn-outline-primary:hover{color:#fff;background-color:#007bff;border-color:#007bff}.btn-outline-primary.focus,.btn-outline-primary:focus{box-shadow:0 0 0 .2rem rgba(0,123,255,.5)}.btn-outline-primary.disabled,.btn-outline-primary:disabled{color:#007bff;background-color:transparent}.btn-outline-primary:not(:disabled):not(.disabled).active,.btn-outline-primary:not(:disabled):not(.disabled):active,.show>.btn-outline-primary.dropdown-toggle{color:#fff;background-color:#007bff;border-color:#007bff}.btn-outline-primary:not(:disabled):not(.disabled).active:focus,.btn-outline-primary:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-primary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(0,123,255,.5)}.btn-outline-secondary{color:#6c757d;border-color:#6c757d}.btn-outline-secondary:hover{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-outline-secondary.focus,.btn-outline-secondary:focus{box-shadow:0 0 0 .2rem rgba(108,117,125,.5)}.btn-outline-secondary.disabled,.btn-outline-secondary:disabled{color:#6c757d;background-color:transparent}.btn-outline-secondary:not(:disabled):not(.disabled).active,.btn-outline-secondary:not(:disabled):not(.disabled):active,.show>.btn-outline-secondary.dropdown-toggle{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-outline-secondary:not(:disabled):not(.disabled).active:focus,.btn-outline-secondary:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(108,117,125,.5)}.btn-outline-success{color:#28a745;border-color:#28a745}.btn-outline-success:hover{color:#fff;background-color:#28a745;border-color:#28a745}.btn-outline-success.focus,.btn-outline-success:focus{box-shadow:0 0 0 .2rem rgba(40,167,69,.5)}.btn-outline-success.disabled,.btn-outline-success:disabled{color:#28a745;background-color:transparent}.btn-outline-success:not(:disabled):not(.disabled).active,.btn-outline-success:not(:disabled):not(.disabled):active,.show>.btn-outline-success.dropdown-toggle{color:#fff;background-color:#28a745;border-color:#28a745}.btn-outline-success:not(:disabled):not(.disabled).active:focus,.btn-outline-success:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-success.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(40,167,69,.5)}.btn-outline-info{color:#17a2b8;border-color:#17a2b8}.btn-outline-info:hover{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-outline-info.focus,.btn-outline-info:focus{box-shadow:0 0 0 .2rem rgba(23,162,184,.5)}.btn-outline-info.disabled,.btn-outline-info:disabled{color:#17a2b8;background-color:transparent}.btn-outline-info:not(:disabled):not(.disabled).active,.btn-outline-info:not(:disabled):not(.disabled):active,.show>.btn-outline-info.dropdown-toggle{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-outline-info:not(:disabled):not(.disabled).active:focus,.btn-outline-info:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-info.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(23,162,184,.5)}.btn-outline-warning{color:#ffc107;border-color:#ffc107}.btn-outline-warning:hover{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-outline-warning.focus,.btn-outline-warning:focus{box-shadow:0 0 0 .2rem rgba(255,193,7,.5)}.btn-outline-warning.disabled,.btn-outline-warning:disabled{color:#ffc107;background-color:transparent}.btn-outline-warning:not(:disabled):not(.disabled).active,.btn-outline-warning:not(:disabled):not(.disabled):active,.show>.btn-outline-warning.dropdown-toggle{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-outline-warning:not(:disabled):not(.disabled).active:focus,.btn-outline-warning:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-warning.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(255,193,7,.5)}.btn-outline-danger{color:#dc3545;border-color:#dc3545}.btn-outline-danger:hover{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-outline-danger.focus,.btn-outline-danger:focus{box-shadow:0 0 0 .2rem rgba(220,53,69,.5)}.btn-outline-danger.disabled,.btn-outline-danger:disabled{color:#dc3545;background-color:transparent}.btn-outline-danger:not(:disabled):not(.disabled).active,.btn-outline-danger:not(:disabled):not(.disabled):active,.show>.btn-outline-danger.dropdown-toggle{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-outline-danger:not(:disabled):not(.disabled).active:focus,.btn-outline-danger:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-danger.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(220,53,69,.5)}.btn-outline-light{color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:hover{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light.focus,.btn-outline-light:focus{box-shadow:0 0 0 .2rem rgba(248,249,250,.5)}.btn-outline-light.disabled,.btn-outline-light:disabled{color:#f8f9fa;background-color:transparent}.btn-outline-light:not(:disabled):not(.disabled).active,.btn-outline-light:not(:disabled):not(.disabled):active,.show>.btn-outline-light.dropdown-toggle{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:not(:disabled):not(.disabled).active:focus,.btn-outline-light:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-light.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(248,249,250,.5)}.btn-outline-dark{color:#343a40;border-color:#343a40}.btn-outline-dark:hover{color:#fff;background-color:#343a40;border-color:#343a40}.btn-outline-dark.focus,.btn-outline-dark:focus{box-shadow:0 0 0 .2rem rgba(52,58,64,.5)}.btn-outline-dark.disabled,.btn-outline-dark:disabled{color:#343a40;background-color:transparent}.btn-outline-dark:not(:disabled):not(.disabled).active,.btn-outline-dark:not(:disabled):not(.disabled):active,.show>.btn-outline-dark.dropdown-toggle{color:#fff;background-color:#343a40;border-color:#343a40}.btn-outline-dark:not(:disabled):not(.disabled).active:focus,.btn-outline-dark:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-dark.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(52,58,64,.5)}.btn-link{font-weight:400;color:#007bff;text-decoration:none}.btn-link:hover{color:#0056b3}.btn-link.focus,.btn-link:focus,.btn-link:hover{text-decoration:underline}.btn-link.disabled,.btn-link:disabled{color:#6c757d;pointer-events:none}.btn-group-lg>.btn,.btn-lg{padding:.5rem 1rem;font-size:1.25rem;line-height:1.5;border-radius:.3rem}.btn-group-sm>.btn,.btn-sm{padding:.25rem .5rem;font-size:.875rem;line-height:1.5;border-radius:.2rem}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:.5rem}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{position:relative;height:0;overflow:hidden;transition:height .35s ease}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.dropdown,.dropleft,.dropright,.dropup{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle:after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid;border-right:.3em solid transparent;border-bottom:0;border-left:.3em solid transparent}.dropdown-toggle:empty:after{margin-left:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:10rem;padding:.5rem 0;margin:.125rem 0 0;font-size:1rem;color:#212529;text-align:left;list-style:none;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.15);border-radius:.25rem}.dropdown-menu-left{right:auto;left:0}.dropdown-menu-right{right:0;left:auto}@media (min-width:540px){.dropdown-menu-sm-left{right:auto;left:0}.dropdown-menu-sm-right{right:0;left:auto}}@media (min-width:720px){.dropdown-menu-md-left{right:auto;left:0}.dropdown-menu-md-right{right:0;left:auto}}@media (min-width:960px){.dropdown-menu-lg-left{right:auto;left:0}.dropdown-menu-lg-right{right:0;left:auto}}@media (min-width:1200px){.dropdown-menu-xl-left{right:auto;left:0}.dropdown-menu-xl-right{right:0;left:auto}}.dropup .dropdown-menu{top:auto;bottom:100%;margin-top:0;margin-bottom:.125rem}.dropup .dropdown-toggle:after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:0;border-right:.3em solid transparent;border-bottom:.3em solid;border-left:.3em solid transparent}.dropup .dropdown-toggle:empty:after{margin-left:0}.dropright .dropdown-menu{top:0;right:auto;left:100%;margin-top:0;margin-left:.125rem}.dropright .dropdown-toggle:after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:0;border-bottom:.3em solid transparent;border-left:.3em solid}.dropright .dropdown-toggle:empty:after{margin-left:0}.dropright .dropdown-toggle:after{vertical-align:0}.dropleft .dropdown-menu{top:0;right:100%;left:auto;margin-top:0;margin-right:.125rem}.dropleft .dropdown-toggle:after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";display:none}.dropleft .dropdown-toggle:before{display:inline-block;margin-right:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:.3em solid;border-bottom:.3em solid transparent}.dropleft .dropdown-toggle:empty:after{margin-left:0}.dropleft .dropdown-toggle:before{vertical-align:0}.dropdown-menu[x-placement^=bottom],.dropdown-menu[x-placement^=left],.dropdown-menu[x-placement^=right],.dropdown-menu[x-placement^=top]{right:auto;bottom:auto}.dropdown-divider{height:0;margin:.5rem 0;overflow:hidden;border-top:1px solid #e9ecef}.dropdown-item{display:block;width:100%;padding:.25rem 1.5rem;clear:both;font-weight:400;color:#212529;text-align:inherit;white-space:nowrap;background-color:transparent;border:0}.dropdown-item:focus,.dropdown-item:hover{color:#16181b;text-decoration:none;background-color:#f8f9fa}.dropdown-item.active,.dropdown-item:active{color:#fff;text-decoration:none;background-color:#007bff}.dropdown-item.disabled,.dropdown-item:disabled{color:#6c757d;pointer-events:none;background-color:transparent}.dropdown-menu.show{display:block}.dropdown-header{display:block;padding:.5rem 1.5rem;margin-bottom:0;font-size:.875rem;color:#6c757d;white-space:nowrap}.dropdown-item-text{display:block;padding:.25rem 1.5rem;color:#212529}.btn-group,.btn-group-vertical{position:relative;display:inline-flex;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;flex:1 1 auto}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:1}.btn-toolbar{display:flex;flex-wrap:wrap;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group>.btn-group:not(:first-child),.btn-group>.btn:not(:first-child){margin-left:-1px}.btn-group>.btn-group:not(:last-child)>.btn,.btn-group>.btn:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:not(:first-child)>.btn,.btn-group>.btn:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.dropdown-toggle-split{padding-right:.5625rem;padding-left:.5625rem}.dropdown-toggle-split:after,.dropright .dropdown-toggle-split:after,.dropup .dropdown-toggle-split:after{margin-left:0}.dropleft .dropdown-toggle-split:before{margin-right:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-right:.375rem;padding-left:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-right:.75rem;padding-left:.75rem}.btn-group-vertical{flex-direction:column;align-items:flex-start;justify-content:center}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn-group:not(:first-child),.btn-group-vertical>.btn:not(:first-child){margin-top:-1px}.btn-group-vertical>.btn-group:not(:last-child)>.btn,.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:not(:first-child)>.btn,.btn-group-vertical>.btn:not(:first-child){border-top-left-radius:0;border-top-right-radius:0}.btn-group-toggle>.btn,.btn-group-toggle>.btn-group>.btn{margin-bottom:0}.btn-group-toggle>.btn-group>.btn input[type=checkbox],.btn-group-toggle>.btn-group>.btn input[type=radio],.btn-group-toggle>.btn input[type=checkbox],.btn-group-toggle>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:flex;flex-wrap:wrap;align-items:stretch;width:100%}.input-group>.custom-file,.input-group>.custom-select,.input-group>.form-control,.input-group>.form-control-plaintext{position:relative;flex:1 1 auto;width:1%;min-width:0;margin-bottom:0}.input-group>.custom-file+.custom-file,.input-group>.custom-file+.custom-select,.input-group>.custom-file+.form-control,.input-group>.custom-select+.custom-file,.input-group>.custom-select+.custom-select,.input-group>.custom-select+.form-control,.input-group>.form-control+.custom-file,.input-group>.form-control+.custom-select,.input-group>.form-control+.form-control,.input-group>.form-control-plaintext+.custom-file,.input-group>.form-control-plaintext+.custom-select,.input-group>.form-control-plaintext+.form-control{margin-left:-1px}.input-group>.custom-file .custom-file-input:focus~.custom-file-label,.input-group>.custom-select:focus,.input-group>.form-control:focus{z-index:3}.input-group>.custom-file .custom-file-input:focus{z-index:4}.input-group>.custom-select:not(:last-child),.input-group>.form-control:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.custom-select:not(:first-child),.input-group>.form-control:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.input-group>.custom-file{display:flex;align-items:center}.input-group>.custom-file:not(:last-child) .custom-file-label,.input-group>.custom-file:not(:last-child) .custom-file-label:after{border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.custom-file:not(:first-child) .custom-file-label{border-top-left-radius:0;border-bottom-left-radius:0}.input-group-append,.input-group-prepend{display:flex}.input-group-append .btn,.input-group-prepend .btn{position:relative;z-index:2}.input-group-append .btn:focus,.input-group-prepend .btn:focus{z-index:3}.input-group-append .btn+.btn,.input-group-append .btn+.input-group-text,.input-group-append .input-group-text+.btn,.input-group-append .input-group-text+.input-group-text,.input-group-prepend .btn+.btn,.input-group-prepend .btn+.input-group-text,.input-group-prepend .input-group-text+.btn,.input-group-prepend .input-group-text+.input-group-text{margin-left:-1px}.input-group-prepend{margin-right:-1px}.input-group-append{margin-left:-1px}.input-group-text{display:flex;align-items:center;padding:.375rem .75rem;margin-bottom:0;font-size:1rem;font-weight:400;line-height:1.5;color:#495057;text-align:center;white-space:nowrap;background-color:#e9ecef;border:1px solid #ced4da;border-radius:.25rem}.input-group-text input[type=checkbox],.input-group-text input[type=radio]{margin-top:0}.input-group-lg>.custom-select,.input-group-lg>.form-control:not(textarea){height:calc(1.5em + 1rem + 2px)}.input-group-lg>.custom-select,.input-group-lg>.form-control,.input-group-lg>.input-group-append>.btn,.input-group-lg>.input-group-append>.input-group-text,.input-group-lg>.input-group-prepend>.btn,.input-group-lg>.input-group-prepend>.input-group-text{padding:.5rem 1rem;font-size:1.25rem;line-height:1.5;border-radius:.3rem}.input-group-sm>.custom-select,.input-group-sm>.form-control:not(textarea){height:calc(1.5em + .5rem + 2px)}.input-group-sm>.custom-select,.input-group-sm>.form-control,.input-group-sm>.input-group-append>.btn,.input-group-sm>.input-group-append>.input-group-text,.input-group-sm>.input-group-prepend>.btn,.input-group-sm>.input-group-prepend>.input-group-text{padding:.25rem .5rem;font-size:.875rem;line-height:1.5;border-radius:.2rem}.input-group-lg>.custom-select,.input-group-sm>.custom-select{padding-right:1.75rem}.input-group>.input-group-append:last-child>.btn:not(:last-child):not(.dropdown-toggle),.input-group>.input-group-append:last-child>.input-group-text:not(:last-child),.input-group>.input-group-append:not(:last-child)>.btn,.input-group>.input-group-append:not(:last-child)>.input-group-text,.input-group>.input-group-prepend>.btn,.input-group>.input-group-prepend>.input-group-text{border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.input-group-append>.btn,.input-group>.input-group-append>.input-group-text,.input-group>.input-group-prepend:first-child>.btn:not(:first-child),.input-group>.input-group-prepend:first-child>.input-group-text:not(:first-child),.input-group>.input-group-prepend:not(:first-child)>.btn,.input-group>.input-group-prepend:not(:first-child)>.input-group-text{border-top-left-radius:0;border-bottom-left-radius:0}.custom-control{position:relative;display:block;min-height:1.5rem;padding-left:1.5rem}.custom-control-inline{display:inline-flex;margin-right:1rem}.custom-control-input{position:absolute;left:0;z-index:-1;width:1rem;height:1.25rem;opacity:0}.custom-control-input:checked~.custom-control-label:before{color:#fff;border-color:#007bff;background-color:#007bff}.custom-control-input:focus~.custom-control-label:before{box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.custom-control-input:focus:not(:checked)~.custom-control-label:before{border-color:#80bdff}.custom-control-input:not(:disabled):active~.custom-control-label:before{color:#fff;background-color:#b3d7ff;border-color:#b3d7ff}.custom-control-input:disabled~.custom-control-label,.custom-control-input[disabled]~.custom-control-label{color:#6c757d}.custom-control-input:disabled~.custom-control-label:before,.custom-control-input[disabled]~.custom-control-label:before{background-color:#e9ecef}.custom-control-label{position:relative;margin-bottom:0;vertical-align:top}.custom-control-label:before{pointer-events:none;background-color:#fff;border:1px solid #adb5bd}.custom-control-label:after,.custom-control-label:before{position:absolute;top:.25rem;left:-1.5rem;display:block;width:1rem;height:1rem;content:""}.custom-control-label:after{background:no-repeat 50%/50% 50%}.custom-checkbox .custom-control-label:before{border-radius:.25rem}.custom-checkbox .custom-control-input:checked~.custom-control-label:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8'%3E%3Cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26l2.974 2.99L8 2.193z'/%3E%3C/svg%3E")}.custom-checkbox .custom-control-input:indeterminate~.custom-control-label:before{border-color:#007bff;background-color:#007bff}.custom-checkbox .custom-control-input:indeterminate~.custom-control-label:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='4' height='4'%3E%3Cpath stroke='%23fff' d='M0 2h4'/%3E%3C/svg%3E")}.custom-checkbox .custom-control-input:disabled:checked~.custom-control-label:before{background-color:rgba(0,123,255,.5)}.custom-checkbox .custom-control-input:disabled:indeterminate~.custom-control-label:before{background-color:rgba(0,123,255,.5)}.custom-radio .custom-control-label:before{border-radius:50%}.custom-radio .custom-control-input:checked~.custom-control-label:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%23fff'/%3E%3C/svg%3E")}.custom-radio .custom-control-input:disabled:checked~.custom-control-label:before{background-color:rgba(0,123,255,.5)}.custom-switch{padding-left:2.25rem}.custom-switch .custom-control-label:before{left:-2.25rem;width:1.75rem;pointer-events:all;border-radius:.5rem}.custom-switch .custom-control-label:after{top:calc(.25rem + 2px);left:calc(-2.25rem + 2px);width:calc(1rem - 4px);height:calc(1rem - 4px);background-color:#adb5bd;border-radius:.5rem;transition:transform .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-switch .custom-control-label:after{transition:none}}.custom-switch .custom-control-input:checked~.custom-control-label:after{background-color:#fff;transform:translateX(.75rem)}.custom-switch .custom-control-input:disabled:checked~.custom-control-label:before{background-color:rgba(0,123,255,.5)}.custom-select{display:inline-block;width:100%;height:calc(1.5em + .75rem + 2px);padding:.375rem 1.75rem .375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#495057;vertical-align:middle;background:#fff url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5'%3E%3Cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3E%3C/svg%3E") no-repeat right .75rem center/8px 10px;border:1px solid #ced4da;border-radius:.25rem;appearance:none}.custom-select:focus{border-color:#80bdff;outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.custom-select:focus::-ms-value{color:#495057;background-color:#fff}.custom-select[multiple],.custom-select[size]:not([size="1"]){height:auto;padding-right:.75rem;background-image:none}.custom-select:disabled{color:#6c757d;background-color:#e9ecef}.custom-select::-ms-expand{display:none}.custom-select:-moz-focusring{color:transparent;text-shadow:0 0 0 #495057}.custom-select-sm{height:calc(1.5em + .5rem + 2px);padding-top:.25rem;padding-bottom:.25rem;padding-left:.5rem;font-size:.875rem}.custom-select-lg{height:calc(1.5em + 1rem + 2px);padding-top:.5rem;padding-bottom:.5rem;padding-left:1rem;font-size:1.25rem}.custom-file{display:inline-block;margin-bottom:0}.custom-file,.custom-file-input{position:relative;width:100%;height:calc(1.5em + .75rem + 2px)}.custom-file-input{z-index:2;margin:0;opacity:0}.custom-file-input:focus~.custom-file-label{border-color:#80bdff;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.custom-file-input:disabled~.custom-file-label,.custom-file-input[disabled]~.custom-file-label{background-color:#e9ecef}.custom-file-input:lang(en)~.custom-file-label:after{content:"Browse"}.custom-file-input~.custom-file-label[data-browse]:after{content:attr(data-browse)}.custom-file-label{left:0;z-index:1;height:calc(1.5em + .75rem + 2px);font-weight:400;background-color:#fff;border:1px solid #ced4da;border-radius:.25rem}.custom-file-label,.custom-file-label:after{position:absolute;top:0;right:0;padding:.375rem .75rem;line-height:1.5;color:#495057}.custom-file-label:after{bottom:0;z-index:3;display:block;height:calc(1.5em + .75rem);content:"Browse";background-color:#e9ecef;border-left:inherit;border-radius:0 .25rem .25rem 0}.custom-range{width:100%;height:1.4rem;padding:0;background-color:transparent;appearance:none}.custom-range:focus{outline:none}.custom-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem rgba(0,123,255,.25)}.custom-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem rgba(0,123,255,.25)}.custom-range:focus::-ms-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem rgba(0,123,255,.25)}.custom-range::-moz-focus-outer{border:0}.custom-range::-webkit-slider-thumb{width:1rem;height:1rem;margin-top:-.25rem;background-color:#007bff;border:0;border-radius:1rem;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;appearance:none}@media (prefers-reduced-motion:reduce){.custom-range::-webkit-slider-thumb{transition:none}}.custom-range::-webkit-slider-thumb:active{background-color:#b3d7ff}.custom-range::-webkit-slider-runnable-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:#dee2e6;border-color:transparent;border-radius:1rem}.custom-range::-moz-range-thumb{width:1rem;height:1rem;background-color:#007bff;border:0;border-radius:1rem;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;appearance:none}@media (prefers-reduced-motion:reduce){.custom-range::-moz-range-thumb{transition:none}}.custom-range::-moz-range-thumb:active{background-color:#b3d7ff}.custom-range::-moz-range-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:#dee2e6;border-color:transparent;border-radius:1rem}.custom-range::-ms-thumb{width:1rem;height:1rem;margin-top:0;margin-right:.2rem;margin-left:.2rem;background-color:#007bff;border:0;border-radius:1rem;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;appearance:none}@media (prefers-reduced-motion:reduce){.custom-range::-ms-thumb{transition:none}}.custom-range::-ms-thumb:active{background-color:#b3d7ff}.custom-range::-ms-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:transparent;border-color:transparent;border-width:.5rem}.custom-range::-ms-fill-lower,.custom-range::-ms-fill-upper{background-color:#dee2e6;border-radius:1rem}.custom-range::-ms-fill-upper{margin-right:15px}.custom-range:disabled::-webkit-slider-thumb{background-color:#adb5bd}.custom-range:disabled::-webkit-slider-runnable-track{cursor:default}.custom-range:disabled::-moz-range-thumb{background-color:#adb5bd}.custom-range:disabled::-moz-range-track{cursor:default}.custom-range:disabled::-ms-thumb{background-color:#adb5bd}.custom-control-label:before,.custom-file-label,.custom-select{transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-control-label:before,.custom-file-label,.custom-select{transition:none}}.nav{display:flex;flex-wrap:wrap;padding-left:0;margin-bottom:0;list-style:none}.nav-link{display:block;padding:.5rem 1rem}.nav-link:focus,.nav-link:hover{text-decoration:none}.nav-link.disabled{color:#6c757d;pointer-events:none;cursor:default}.nav-tabs{border-bottom:1px solid #dee2e6}.nav-tabs .nav-item{margin-bottom:-1px}.nav-tabs .nav-link{border:1px solid transparent;border-top-left-radius:.25rem;border-top-right-radius:.25rem}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{border-color:#e9ecef #e9ecef #dee2e6}.nav-tabs .nav-link.disabled{color:#6c757d;background-color:transparent;border-color:transparent}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{color:#495057;background-color:#fff;border-color:#dee2e6 #dee2e6 #fff}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.nav-pills .nav-link{border-radius:.25rem}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{color:#fff;background-color:#007bff}.nav-fill .nav-item{flex:1 1 auto;text-align:center}.nav-justified .nav-item{flex-basis:0;flex-grow:1;text-align:center}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{position:relative;padding:.5rem 1rem}.navbar,.navbar .container,.navbar .container-fluid,.navbar .container-lg,.navbar .container-md,.navbar .container-sm,.navbar .container-xl{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between}.navbar-brand{display:inline-block;padding-top:.3125rem;padding-bottom:.3125rem;margin-right:1rem;font-size:1.25rem;line-height:inherit;white-space:nowrap}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-nav{display:flex;flex-direction:column;padding-left:0;margin-bottom:0;list-style:none}.navbar-nav .nav-link{padding-right:0;padding-left:0}.navbar-nav .dropdown-menu{position:static;float:none}.navbar-text{display:inline-block;padding-top:.5rem;padding-bottom:.5rem}.navbar-collapse{flex-basis:100%;flex-grow:1;align-items:center}.navbar-toggler{padding:.25rem .75rem;font-size:1.25rem;line-height:1;background-color:transparent;border:1px solid transparent;border-radius:.25rem}.navbar-toggler:focus,.navbar-toggler:hover{text-decoration:none}.navbar-toggler-icon{display:inline-block;width:1.5em;height:1.5em;vertical-align:middle;content:"";background:no-repeat 50%;background-size:100% 100%}@media (max-width:539.98px){.navbar-expand-sm>.container,.navbar-expand-sm>.container-fluid,.navbar-expand-sm>.container-lg,.navbar-expand-sm>.container-md,.navbar-expand-sm>.container-sm,.navbar-expand-sm>.container-xl{padding-right:0;padding-left:0}}@media (min-width:540px){.navbar-expand-sm{flex-flow:row nowrap;justify-content:flex-start}.navbar-expand-sm .navbar-nav{flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-sm>.container,.navbar-expand-sm>.container-fluid,.navbar-expand-sm>.container-lg,.navbar-expand-sm>.container-md,.navbar-expand-sm>.container-sm,.navbar-expand-sm>.container-xl{flex-wrap:nowrap}.navbar-expand-sm .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-sm .navbar-toggler{display:none}}@media (max-width:719.98px){.navbar-expand-md>.container,.navbar-expand-md>.container-fluid,.navbar-expand-md>.container-lg,.navbar-expand-md>.container-md,.navbar-expand-md>.container-sm,.navbar-expand-md>.container-xl{padding-right:0;padding-left:0}}@media (min-width:720px){.navbar-expand-md{flex-flow:row nowrap;justify-content:flex-start}.navbar-expand-md .navbar-nav{flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-md>.container,.navbar-expand-md>.container-fluid,.navbar-expand-md>.container-lg,.navbar-expand-md>.container-md,.navbar-expand-md>.container-sm,.navbar-expand-md>.container-xl{flex-wrap:nowrap}.navbar-expand-md .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-md .navbar-toggler{display:none}}@media (max-width:959.98px){.navbar-expand-lg>.container,.navbar-expand-lg>.container-fluid,.navbar-expand-lg>.container-lg,.navbar-expand-lg>.container-md,.navbar-expand-lg>.container-sm,.navbar-expand-lg>.container-xl{padding-right:0;padding-left:0}}@media (min-width:960px){.navbar-expand-lg{flex-flow:row nowrap;justify-content:flex-start}.navbar-expand-lg .navbar-nav{flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-lg>.container,.navbar-expand-lg>.container-fluid,.navbar-expand-lg>.container-lg,.navbar-expand-lg>.container-md,.navbar-expand-lg>.container-sm,.navbar-expand-lg>.container-xl{flex-wrap:nowrap}.navbar-expand-lg .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-lg .navbar-toggler{display:none}}@media (max-width:1199.98px){.navbar-expand-xl>.container,.navbar-expand-xl>.container-fluid,.navbar-expand-xl>.container-lg,.navbar-expand-xl>.container-md,.navbar-expand-xl>.container-sm,.navbar-expand-xl>.container-xl{padding-right:0;padding-left:0}}@media (min-width:1200px){.navbar-expand-xl{flex-flow:row nowrap;justify-content:flex-start}.navbar-expand-xl .navbar-nav{flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-xl>.container,.navbar-expand-xl>.container-fluid,.navbar-expand-xl>.container-lg,.navbar-expand-xl>.container-md,.navbar-expand-xl>.container-sm,.navbar-expand-xl>.container-xl{flex-wrap:nowrap}.navbar-expand-xl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xl .navbar-toggler{display:none}}.navbar-expand{flex-flow:row nowrap;justify-content:flex-start}.navbar-expand>.container,.navbar-expand>.container-fluid,.navbar-expand>.container-lg,.navbar-expand>.container-md,.navbar-expand>.container-sm,.navbar-expand>.container-xl{padding-right:0;padding-left:0}.navbar-expand .navbar-nav{flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand>.container,.navbar-expand>.container-fluid,.navbar-expand>.container-lg,.navbar-expand>.container-md,.navbar-expand>.container-sm,.navbar-expand>.container-xl{flex-wrap:nowrap}.navbar-expand .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand .navbar-toggler{display:none}.navbar-light .navbar-brand,.navbar-light .navbar-brand:focus,.navbar-light .navbar-brand:hover{color:rgba(0,0,0,.9)}.navbar-light .navbar-nav .nav-link{color:rgba(0,0,0,.5)}.navbar-light .navbar-nav .nav-link:focus,.navbar-light .navbar-nav .nav-link:hover{color:rgba(0,0,0,.7)}.navbar-light .navbar-nav .nav-link.disabled{color:rgba(0,0,0,.3)}.navbar-light .navbar-nav .active>.nav-link,.navbar-light .navbar-nav .nav-link.active,.navbar-light .navbar-nav .nav-link.show,.navbar-light .navbar-nav .show>.nav-link{color:rgba(0,0,0,.9)}.navbar-light .navbar-toggler{color:rgba(0,0,0,.5);border-color:rgba(0,0,0,.1)}.navbar-light .navbar-toggler-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30'%3E%3Cpath stroke='rgba(0,0,0,0.5)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E")}.navbar-light .navbar-text{color:rgba(0,0,0,.5)}.navbar-light .navbar-text a,.navbar-light .navbar-text a:focus,.navbar-light .navbar-text a:hover{color:rgba(0,0,0,.9)}.navbar-dark .navbar-brand,.navbar-dark .navbar-brand:focus,.navbar-dark .navbar-brand:hover{color:#fff}.navbar-dark .navbar-nav .nav-link{color:hsla(0,0%,100%,.5)}.navbar-dark .navbar-nav .nav-link:focus,.navbar-dark .navbar-nav .nav-link:hover{color:hsla(0,0%,100%,.75)}.navbar-dark .navbar-nav .nav-link.disabled{color:hsla(0,0%,100%,.25)}.navbar-dark .navbar-nav .active>.nav-link,.navbar-dark .navbar-nav .nav-link.active,.navbar-dark .navbar-nav .nav-link.show,.navbar-dark .navbar-nav .show>.nav-link{color:#fff}.navbar-dark .navbar-toggler{color:hsla(0,0%,100%,.5);border-color:hsla(0,0%,100%,.1)}.navbar-dark .navbar-toggler-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30'%3E%3Cpath stroke='rgba(255,255,255,0.5)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E")}.navbar-dark .navbar-text{color:hsla(0,0%,100%,.5)}.navbar-dark .navbar-text a,.navbar-dark .navbar-text a:focus,.navbar-dark .navbar-text a:hover{color:#fff}.card{position:relative;display:flex;flex-direction:column;min-width:0;word-wrap:break-word;background-color:#fff;background-clip:border-box;border:1px solid rgba(0,0,0,.125);border-radius:.25rem}.card>hr{margin-right:0;margin-left:0}.card>.list-group{border-top:inherit;border-bottom:inherit}.card>.list-group:first-child{border-top-width:0;border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card>.list-group:last-child{border-bottom-width:0;border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card-body{flex:1 1 auto;min-height:1px;padding:1.25rem}.card-title{margin-bottom:.75rem}.card-subtitle{margin-top:-.375rem}.card-subtitle,.card-text:last-child{margin-bottom:0}.card-link:hover{text-decoration:none}.card-link+.card-link{margin-left:1.25rem}.card-header{padding:.75rem 1.25rem;margin-bottom:0;background-color:rgba(0,0,0,.03);border-bottom:1px solid rgba(0,0,0,.125)}.card-header:first-child{border-radius:calc(.25rem - 1px) calc(.25rem - 1px) 0 0}.card-header+.list-group .list-group-item:first-child{border-top:0}.card-footer{padding:.75rem 1.25rem;background-color:rgba(0,0,0,.03);border-top:1px solid rgba(0,0,0,.125)}.card-footer:last-child{border-radius:0 0 calc(.25rem - 1px) calc(.25rem - 1px)}.card-header-tabs{margin-bottom:-.75rem;border-bottom:0}.card-header-pills,.card-header-tabs{margin-right:-.625rem;margin-left:-.625rem}.card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1.25rem}.card-img,.card-img-bottom,.card-img-top{flex-shrink:0;width:100%}.card-img,.card-img-top{border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card-img,.card-img-bottom{border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card-deck .card{margin-bottom:15px}@media (min-width:540px){.card-deck{display:flex;flex-flow:row wrap;margin-right:-15px;margin-left:-15px}.card-deck .card{flex:1 0 0%;margin-right:15px;margin-bottom:0;margin-left:15px}}.card-group>.card{margin-bottom:15px}@media (min-width:540px){.card-group{display:flex;flex-flow:row wrap}.card-group>.card{flex:1 0 0%;margin-bottom:0}.card-group>.card+.card{margin-left:0;border-left:0}.card-group>.card:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.card-group>.card:not(:last-child) .card-header,.card-group>.card:not(:last-child) .card-img-top{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.card-columns .card{margin-bottom:.75rem}@media (min-width:540px){.card-columns{column-count:3;column-gap:1.25rem;orphans:1;widows:1}.card-columns .card{display:inline-block;width:100%}}.accordion>.card{overflow:hidden}.accordion>.card:not(:last-of-type){border-bottom:0;border-bottom-right-radius:0;border-bottom-left-radius:0}.accordion>.card:not(:first-of-type){border-top-left-radius:0;border-top-right-radius:0}.accordion>.card>.card-header{border-radius:0;margin-bottom:-1px}.breadcrumb{flex-wrap:wrap;padding:.75rem 1rem;margin-bottom:1rem;list-style:none;background-color:#e9ecef;border-radius:.25rem}.breadcrumb,.breadcrumb-item{display:flex}.breadcrumb-item+.breadcrumb-item{padding-left:.5rem}.breadcrumb-item+.breadcrumb-item:before{display:inline-block;padding-right:.5rem;color:#6c757d;content:"/"}.breadcrumb-item+.breadcrumb-item:hover:before{text-decoration:underline;text-decoration:none}.breadcrumb-item.active{color:#6c757d}.pagination{display:flex;padding-left:0;list-style:none;border-radius:.25rem}.page-link{position:relative;display:block;padding:.5rem .75rem;margin-left:-1px;line-height:1.25;color:#007bff;background-color:#fff;border:1px solid #dee2e6}.page-link:hover{z-index:2;color:#0056b3;text-decoration:none;background-color:#e9ecef;border-color:#dee2e6}.page-link:focus{z-index:3;outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.page-item:first-child .page-link{margin-left:0;border-top-left-radius:.25rem;border-bottom-left-radius:.25rem}.page-item:last-child .page-link{border-top-right-radius:.25rem;border-bottom-right-radius:.25rem}.page-item.active .page-link{z-index:3;color:#fff;background-color:#007bff;border-color:#007bff}.page-item.disabled .page-link{color:#6c757d;pointer-events:none;cursor:auto;background-color:#fff;border-color:#dee2e6}.pagination-lg .page-link{padding:.75rem 1.5rem;font-size:1.25rem;line-height:1.5}.pagination-lg .page-item:first-child .page-link{border-top-left-radius:.3rem;border-bottom-left-radius:.3rem}.pagination-lg .page-item:last-child .page-link{border-top-right-radius:.3rem;border-bottom-right-radius:.3rem}.pagination-sm .page-link{padding:.25rem .5rem;font-size:.875rem;line-height:1.5}.pagination-sm .page-item:first-child .page-link{border-top-left-radius:.2rem;border-bottom-left-radius:.2rem}.pagination-sm .page-item:last-child .page-link{border-top-right-radius:.2rem;border-bottom-right-radius:.2rem}.badge{display:inline-block;padding:.25em .4em;font-size:75%;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.badge{transition:none}}a.badge:focus,a.badge:hover{text-decoration:none}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.badge-pill{padding-right:.6em;padding-left:.6em;border-radius:10rem}.badge-primary{color:#fff;background-color:#007bff}a.badge-primary:focus,a.badge-primary:hover{color:#fff;background-color:#0062cc}a.badge-primary.focus,a.badge-primary:focus{outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.5)}.badge-secondary{color:#fff;background-color:#6c757d}a.badge-secondary:focus,a.badge-secondary:hover{color:#fff;background-color:#545b62}a.badge-secondary.focus,a.badge-secondary:focus{outline:0;box-shadow:0 0 0 .2rem rgba(108,117,125,.5)}.badge-success{color:#fff;background-color:#28a745}a.badge-success:focus,a.badge-success:hover{color:#fff;background-color:#1e7e34}a.badge-success.focus,a.badge-success:focus{outline:0;box-shadow:0 0 0 .2rem rgba(40,167,69,.5)}.badge-info{color:#fff;background-color:#17a2b8}a.badge-info:focus,a.badge-info:hover{color:#fff;background-color:#117a8b}a.badge-info.focus,a.badge-info:focus{outline:0;box-shadow:0 0 0 .2rem rgba(23,162,184,.5)}.badge-warning{color:#212529;background-color:#ffc107}a.badge-warning:focus,a.badge-warning:hover{color:#212529;background-color:#d39e00}a.badge-warning.focus,a.badge-warning:focus{outline:0;box-shadow:0 0 0 .2rem rgba(255,193,7,.5)}.badge-danger{color:#fff;background-color:#dc3545}a.badge-danger:focus,a.badge-danger:hover{color:#fff;background-color:#bd2130}a.badge-danger.focus,a.badge-danger:focus{outline:0;box-shadow:0 0 0 .2rem rgba(220,53,69,.5)}.badge-light{color:#212529;background-color:#f8f9fa}a.badge-light:focus,a.badge-light:hover{color:#212529;background-color:#dae0e5}a.badge-light.focus,a.badge-light:focus{outline:0;box-shadow:0 0 0 .2rem rgba(248,249,250,.5)}.badge-dark{color:#fff;background-color:#343a40}a.badge-dark:focus,a.badge-dark:hover{color:#fff;background-color:#1d2124}a.badge-dark.focus,a.badge-dark:focus{outline:0;box-shadow:0 0 0 .2rem rgba(52,58,64,.5)}.jumbotron{padding:2rem 1rem;margin-bottom:2rem;background-color:#e9ecef;border-radius:.3rem}@media (min-width:540px){.jumbotron{padding:4rem 2rem}}.jumbotron-fluid{padding-right:0;padding-left:0;border-radius:0}.alert{position:relative;padding:.75rem 1.25rem;margin-bottom:1rem;border:1px solid transparent;border-radius:.25rem}.alert-heading{color:inherit}.alert-link{font-weight:700}.alert-dismissible{padding-right:4rem}.alert-dismissible .close{position:absolute;top:0;right:0;padding:.75rem 1.25rem;color:inherit}.alert-primary{color:#004085;background-color:#cce5ff;border-color:#b8daff}.alert-primary hr{border-top-color:#9fcdff}.alert-primary .alert-link{color:#002752}.alert-secondary{color:#383d41;background-color:#e2e3e5;border-color:#d6d8db}.alert-secondary hr{border-top-color:#c8cbcf}.alert-secondary .alert-link{color:#202326}.alert-success{color:#155724;background-color:#d4edda;border-color:#c3e6cb}.alert-success hr{border-top-color:#b1dfbb}.alert-success .alert-link{color:#0b2e13}.alert-info{color:#0c5460;background-color:#d1ecf1;border-color:#bee5eb}.alert-info hr{border-top-color:#abdde5}.alert-info .alert-link{color:#062c33}.alert-warning{color:#856404;background-color:#fff3cd;border-color:#ffeeba}.alert-warning hr{border-top-color:#ffe8a1}.alert-warning .alert-link{color:#533f03}.alert-danger{color:#721c24;background-color:#f8d7da;border-color:#f5c6cb}.alert-danger hr{border-top-color:#f1b0b7}.alert-danger .alert-link{color:#491217}.alert-light{color:#818182;background-color:#fefefe;border-color:#fdfdfe}.alert-light hr{border-top-color:#ececf6}.alert-light .alert-link{color:#686868}.alert-dark{color:#1b1e21;background-color:#d6d8d9;border-color:#c6c8ca}.alert-dark hr{border-top-color:#b9bbbe}.alert-dark .alert-link{color:#040505}@keyframes progress-bar-stripes{0%{background-position:1rem 0}to{background-position:0 0}}.progress{height:1rem;line-height:0;font-size:.75rem;background-color:#e9ecef;border-radius:.25rem}.progress,.progress-bar{display:flex;overflow:hidden}.progress-bar{flex-direction:column;justify-content:center;color:#fff;text-align:center;white-space:nowrap;background-color:#007bff;transition:width .6s ease}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-size:1rem 1rem}.progress-bar-animated{animation:progress-bar-stripes 1s linear infinite}@media (prefers-reduced-motion:reduce){.progress-bar-animated{animation:none}}.media{display:flex;align-items:flex-start}.media-body{flex:1}.list-group{display:flex;flex-direction:column;padding-left:0;margin-bottom:0;border-radius:.25rem}.list-group-item-action{width:100%;color:#495057;text-align:inherit}.list-group-item-action:focus,.list-group-item-action:hover{z-index:1;color:#495057;text-decoration:none;background-color:#f8f9fa}.list-group-item-action:active{color:#212529;background-color:#e9ecef}.list-group-item{position:relative;display:block;padding:.75rem 1.25rem;background-color:#fff;border:1px solid rgba(0,0,0,.125)}.list-group-item:first-child{border-top-left-radius:inherit;border-top-right-radius:inherit}.list-group-item:last-child{border-bottom-right-radius:inherit;border-bottom-left-radius:inherit}.list-group-item.disabled,.list-group-item:disabled{color:#6c757d;pointer-events:none;background-color:#fff}.list-group-item.active{z-index:2;color:#fff;background-color:#007bff;border-color:#007bff}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{margin-top:-1px;border-top-width:1px}.list-group-horizontal{flex-direction:row}.list-group-horizontal>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal>.list-group-item.active{margin-top:0}.list-group-horizontal>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}@media (min-width:540px){.list-group-horizontal-sm{flex-direction:row}.list-group-horizontal-sm>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-sm>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-sm>.list-group-item.active{margin-top:0}.list-group-horizontal-sm>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-sm>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:720px){.list-group-horizontal-md{flex-direction:row}.list-group-horizontal-md>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-md>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-md>.list-group-item.active{margin-top:0}.list-group-horizontal-md>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-md>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:960px){.list-group-horizontal-lg{flex-direction:row}.list-group-horizontal-lg>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-lg>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-lg>.list-group-item.active{margin-top:0}.list-group-horizontal-lg>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-lg>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:1200px){.list-group-horizontal-xl{flex-direction:row}.list-group-horizontal-xl>.list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-xl>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-xl>.list-group-item.active{margin-top:0}.list-group-horizontal-xl>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-xl>.list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}.list-group-flush{border-radius:0}.list-group-flush>.list-group-item{border-width:0 0 1px}.list-group-flush>.list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{color:#004085;background-color:#b8daff}.list-group-item-primary.list-group-item-action:focus,.list-group-item-primary.list-group-item-action:hover{color:#004085;background-color:#9fcdff}.list-group-item-primary.list-group-item-action.active{color:#fff;background-color:#004085;border-color:#004085}.list-group-item-secondary{color:#383d41;background-color:#d6d8db}.list-group-item-secondary.list-group-item-action:focus,.list-group-item-secondary.list-group-item-action:hover{color:#383d41;background-color:#c8cbcf}.list-group-item-secondary.list-group-item-action.active{color:#fff;background-color:#383d41;border-color:#383d41}.list-group-item-success{color:#155724;background-color:#c3e6cb}.list-group-item-success.list-group-item-action:focus,.list-group-item-success.list-group-item-action:hover{color:#155724;background-color:#b1dfbb}.list-group-item-success.list-group-item-action.active{color:#fff;background-color:#155724;border-color:#155724}.list-group-item-info{color:#0c5460;background-color:#bee5eb}.list-group-item-info.list-group-item-action:focus,.list-group-item-info.list-group-item-action:hover{color:#0c5460;background-color:#abdde5}.list-group-item-info.list-group-item-action.active{color:#fff;background-color:#0c5460;border-color:#0c5460}.list-group-item-warning{color:#856404;background-color:#ffeeba}.list-group-item-warning.list-group-item-action:focus,.list-group-item-warning.list-group-item-action:hover{color:#856404;background-color:#ffe8a1}.list-group-item-warning.list-group-item-action.active{color:#fff;background-color:#856404;border-color:#856404}.list-group-item-danger{color:#721c24;background-color:#f5c6cb}.list-group-item-danger.list-group-item-action:focus,.list-group-item-danger.list-group-item-action:hover{color:#721c24;background-color:#f1b0b7}.list-group-item-danger.list-group-item-action.active{color:#fff;background-color:#721c24;border-color:#721c24}.list-group-item-light{color:#818182;background-color:#fdfdfe}.list-group-item-light.list-group-item-action:focus,.list-group-item-light.list-group-item-action:hover{color:#818182;background-color:#ececf6}.list-group-item-light.list-group-item-action.active{color:#fff;background-color:#818182;border-color:#818182}.list-group-item-dark{color:#1b1e21;background-color:#c6c8ca}.list-group-item-dark.list-group-item-action:focus,.list-group-item-dark.list-group-item-action:hover{color:#1b1e21;background-color:#b9bbbe}.list-group-item-dark.list-group-item-action.active{color:#fff;background-color:#1b1e21;border-color:#1b1e21}.close{float:right;font-size:1.5rem;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;opacity:.5}.close:hover{color:#000;text-decoration:none}.close:not(:disabled):not(.disabled):focus,.close:not(:disabled):not(.disabled):hover{opacity:.75}button.close{padding:0;background-color:transparent;border:0}a.close.disabled{pointer-events:none}.toast{max-width:350px;overflow:hidden;font-size:.875rem;background-color:hsla(0,0%,100%,.85);background-clip:padding-box;border:1px solid rgba(0,0,0,.1);box-shadow:0 .25rem .75rem rgba(0,0,0,.1);backdrop-filter:blur(10px);opacity:0;border-radius:.25rem}.toast:not(:last-child){margin-bottom:.75rem}.toast.showing{opacity:1}.toast.show{display:block;opacity:1}.toast.hide{display:none}.toast-header{display:flex;align-items:center;padding:.25rem .75rem;color:#6c757d;background-color:hsla(0,0%,100%,.85);background-clip:padding-box;border-bottom:1px solid rgba(0,0,0,.05)}.toast-body{padding:.75rem}.modal-open{overflow:hidden}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal{position:fixed;top:0;left:0;z-index:1050;display:none;width:100%;height:100%;overflow:hidden;outline:0}.modal-dialog{position:relative;width:auto;margin:.5rem;pointer-events:none}.modal.fade .modal-dialog{transition:transform .3s ease-out;transform:translateY(-50px)}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{transform:none}.modal.modal-static .modal-dialog{transform:scale(1.02)}.modal-dialog-scrollable{display:flex;max-height:calc(100% - 1rem)}.modal-dialog-scrollable .modal-content{max-height:calc(100vh - 1rem);overflow:hidden}.modal-dialog-scrollable .modal-footer,.modal-dialog-scrollable .modal-header{flex-shrink:0}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{display:flex;align-items:center;min-height:calc(100% - 1rem)}.modal-dialog-centered:before{display:block;height:calc(100vh - 1rem);height:min-content;content:""}.modal-dialog-centered.modal-dialog-scrollable{flex-direction:column;justify-content:center;height:100%}.modal-dialog-centered.modal-dialog-scrollable .modal-content{max-height:none}.modal-dialog-centered.modal-dialog-scrollable:before{content:none}.modal-content{position:relative;display:flex;flex-direction:column;width:100%;pointer-events:auto;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem;outline:0}.modal-backdrop{position:fixed;top:0;left:0;z-index:1040;width:100vw;height:100vh;background-color:#000}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:.5}.modal-header{display:flex;align-items:flex-start;justify-content:space-between;padding:1rem;border-bottom:1px solid #dee2e6;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px)}.modal-header .close{padding:1rem;margin:-1rem -1rem -1rem auto}.modal-title{margin-bottom:0;line-height:1.5}.modal-body{position:relative;flex:1 1 auto;padding:1rem}.modal-footer{display:flex;flex-wrap:wrap;align-items:center;justify-content:flex-end;padding:.75rem;border-top:1px solid #dee2e6;border-bottom-right-radius:calc(.3rem - 1px);border-bottom-left-radius:calc(.3rem - 1px)}.modal-footer>*{margin:.25rem}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:540px){.modal-dialog{max-width:500px;margin:1.75rem auto}.modal-dialog-scrollable{max-height:calc(100% - 3.5rem)}.modal-dialog-scrollable .modal-content{max-height:calc(100vh - 3.5rem)}.modal-dialog-centered{min-height:calc(100% - 3.5rem)}.modal-dialog-centered:before{height:calc(100vh - 3.5rem);height:min-content}.modal-sm{max-width:300px}}@media (min-width:960px){.modal-lg,.modal-xl{max-width:800px}}@media (min-width:1200px){.modal-xl{max-width:1140px}}.tooltip{position:absolute;z-index:1070;display:block;margin:0;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;font-size:.875rem;word-wrap:break-word;opacity:0}.tooltip.show{opacity:.9}.tooltip .arrow{position:absolute;display:block;width:.8rem;height:.4rem}.tooltip .arrow:before{position:absolute;content:"";border-color:transparent;border-style:solid}.bs-tooltip-auto[x-placement^=top],.bs-tooltip-top{padding:.4rem 0}.bs-tooltip-auto[x-placement^=top] .arrow,.bs-tooltip-top .arrow{bottom:0}.bs-tooltip-auto[x-placement^=top] .arrow:before,.bs-tooltip-top .arrow:before{top:0;border-width:.4rem .4rem 0;border-top-color:#000}.bs-tooltip-auto[x-placement^=right],.bs-tooltip-right{padding:0 .4rem}.bs-tooltip-auto[x-placement^=right] .arrow,.bs-tooltip-right .arrow{left:0;width:.4rem;height:.8rem}.bs-tooltip-auto[x-placement^=right] .arrow:before,.bs-tooltip-right .arrow:before{right:0;border-width:.4rem .4rem .4rem 0;border-right-color:#000}.bs-tooltip-auto[x-placement^=bottom],.bs-tooltip-bottom{padding:.4rem 0}.bs-tooltip-auto[x-placement^=bottom] .arrow,.bs-tooltip-bottom .arrow{top:0}.bs-tooltip-auto[x-placement^=bottom] .arrow:before,.bs-tooltip-bottom .arrow:before{bottom:0;border-width:0 .4rem .4rem;border-bottom-color:#000}.bs-tooltip-auto[x-placement^=left],.bs-tooltip-left{padding:0 .4rem}.bs-tooltip-auto[x-placement^=left] .arrow,.bs-tooltip-left .arrow{right:0;width:.4rem;height:.8rem}.bs-tooltip-auto[x-placement^=left] .arrow:before,.bs-tooltip-left .arrow:before{left:0;border-width:.4rem 0 .4rem .4rem;border-left-color:#000}.tooltip-inner{max-width:200px;padding:.25rem .5rem;color:#fff;text-align:center;background-color:#000;border-radius:.25rem}.popover{top:0;left:0;z-index:1060;max-width:276px;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;font-size:.875rem;word-wrap:break-word;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem}.popover,.popover .arrow{position:absolute;display:block}.popover .arrow{width:1rem;height:.5rem;margin:0 .3rem}.popover .arrow:after,.popover .arrow:before{position:absolute;display:block;content:"";border-color:transparent;border-style:solid}.bs-popover-auto[x-placement^=top],.bs-popover-top{margin-bottom:.5rem}.bs-popover-auto[x-placement^=top]>.arrow,.bs-popover-top>.arrow{bottom:calc(-.5rem - 1px)}.bs-popover-auto[x-placement^=top]>.arrow:before,.bs-popover-top>.arrow:before{bottom:0;border-width:.5rem .5rem 0;border-top-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=top]>.arrow:after,.bs-popover-top>.arrow:after{bottom:1px;border-width:.5rem .5rem 0;border-top-color:#fff}.bs-popover-auto[x-placement^=right],.bs-popover-right{margin-left:.5rem}.bs-popover-auto[x-placement^=right]>.arrow,.bs-popover-right>.arrow{left:calc(-.5rem - 1px);width:.5rem;height:1rem;margin:.3rem 0}.bs-popover-auto[x-placement^=right]>.arrow:before,.bs-popover-right>.arrow:before{left:0;border-width:.5rem .5rem .5rem 0;border-right-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=right]>.arrow:after,.bs-popover-right>.arrow:after{left:1px;border-width:.5rem .5rem .5rem 0;border-right-color:#fff}.bs-popover-auto[x-placement^=bottom],.bs-popover-bottom{margin-top:.5rem}.bs-popover-auto[x-placement^=bottom]>.arrow,.bs-popover-bottom>.arrow{top:calc(-.5rem - 1px)}.bs-popover-auto[x-placement^=bottom]>.arrow:before,.bs-popover-bottom>.arrow:before{top:0;border-width:0 .5rem .5rem;border-bottom-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=bottom]>.arrow:after,.bs-popover-bottom>.arrow:after{top:1px;border-width:0 .5rem .5rem;border-bottom-color:#fff}.bs-popover-auto[x-placement^=bottom] .popover-header:before,.bs-popover-bottom .popover-header:before{position:absolute;top:0;left:50%;display:block;width:1rem;margin-left:-.5rem;content:"";border-bottom:1px solid #f7f7f7}.bs-popover-auto[x-placement^=left],.bs-popover-left{margin-right:.5rem}.bs-popover-auto[x-placement^=left]>.arrow,.bs-popover-left>.arrow{right:calc(-.5rem - 1px);width:.5rem;height:1rem;margin:.3rem 0}.bs-popover-auto[x-placement^=left]>.arrow:before,.bs-popover-left>.arrow:before{right:0;border-width:.5rem 0 .5rem .5rem;border-left-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=left]>.arrow:after,.bs-popover-left>.arrow:after{right:1px;border-width:.5rem 0 .5rem .5rem;border-left-color:#fff}.popover-header{padding:.5rem .75rem;margin-bottom:0;font-size:1rem;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px)}.popover-header:empty{display:none}.popover-body{padding:.5rem .75rem;color:#212529}.carousel{position:relative}.carousel.pointer-event{touch-action:pan-y}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner:after{display:block;clear:both;content:""}.carousel-item{position:relative;display:none;float:left;width:100%;margin-right:-100%;backface-visibility:hidden;transition:transform .6s ease-in-out}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:block}.active.carousel-item-right,.carousel-item-next:not(.carousel-item-left){transform:translateX(100%)}.active.carousel-item-left,.carousel-item-prev:not(.carousel-item-right){transform:translateX(-100%)}.carousel-fade .carousel-item{opacity:0;transition-property:opacity;transform:none}.carousel-fade .carousel-item-next.carousel-item-left,.carousel-fade .carousel-item-prev.carousel-item-right,.carousel-fade .carousel-item.active{z-index:1;opacity:1}.carousel-fade .active.carousel-item-left,.carousel-fade .active.carousel-item-right{z-index:0;opacity:0;transition:opacity 0s .6s}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-left,.carousel-fade .active.carousel-item-right{transition:none}}.carousel-control-next,.carousel-control-prev{position:absolute;top:0;bottom:0;z-index:1;display:flex;align-items:center;justify-content:center;width:15%;color:#fff;text-align:center;opacity:.5;transition:opacity .15s ease}@media (prefers-reduced-motion:reduce){.carousel-control-next,.carousel-control-prev{transition:none}}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;text-decoration:none;outline:0;opacity:.9}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{display:inline-block;width:20px;height:20px;background:no-repeat 50%/100% 100%}.carousel-control-prev-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' width='8' height='8'%3E%3Cpath d='M5.25 0l-4 4 4 4 1.5-1.5L4.25 4l2.5-2.5L5.25 0z'/%3E%3C/svg%3E")}.carousel-control-next-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' width='8' height='8'%3E%3Cpath d='M2.75 0l-1.5 1.5L3.75 4l-2.5 2.5L2.75 8l4-4-4-4z'/%3E%3C/svg%3E")}.carousel-indicators{position:absolute;right:0;bottom:0;left:0;z-index:15;display:flex;justify-content:center;padding-left:0;margin-right:15%;margin-left:15%;list-style:none}.carousel-indicators li{box-sizing:content-box;flex:0 1 auto;width:30px;height:3px;margin-right:3px;margin-left:3px;text-indent:-999px;cursor:pointer;background-color:#fff;background-clip:padding-box;border-top:10px solid transparent;border-bottom:10px solid transparent;opacity:.5;transition:opacity .6s ease}@media (prefers-reduced-motion:reduce){.carousel-indicators li{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center}@keyframes spinner-border{to{transform:rotate(1turn)}}.spinner-border{display:inline-block;width:2rem;height:2rem;vertical-align:text-bottom;border:.25em solid;border-right:.25em solid transparent;border-radius:50%;animation:spinner-border .75s linear infinite}.spinner-border-sm{width:1rem;height:1rem;border-width:.2em}@keyframes spinner-grow{0%{transform:scale(0)}50%{opacity:1;transform:none}}.spinner-grow{display:inline-block;width:2rem;height:2rem;vertical-align:text-bottom;background-color:currentColor;border-radius:50%;opacity:0;animation:spinner-grow .75s linear infinite}.spinner-grow-sm{width:1rem;height:1rem}.align-baseline{vertical-align:baseline!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.bg-primary{background-color:#007bff!important}a.bg-primary:focus,a.bg-primary:hover,button.bg-primary:focus,button.bg-primary:hover{background-color:#0062cc!important}.bg-secondary{background-color:#6c757d!important}a.bg-secondary:focus,a.bg-secondary:hover,button.bg-secondary:focus,button.bg-secondary:hover{background-color:#545b62!important}.bg-success{background-color:#28a745!important}a.bg-success:focus,a.bg-success:hover,button.bg-success:focus,button.bg-success:hover{background-color:#1e7e34!important}.bg-info{background-color:#17a2b8!important}a.bg-info:focus,a.bg-info:hover,button.bg-info:focus,button.bg-info:hover{background-color:#117a8b!important}.bg-warning{background-color:#ffc107!important}a.bg-warning:focus,a.bg-warning:hover,button.bg-warning:focus,button.bg-warning:hover{background-color:#d39e00!important}.bg-danger{background-color:#dc3545!important}a.bg-danger:focus,a.bg-danger:hover,button.bg-danger:focus,button.bg-danger:hover{background-color:#bd2130!important}.bg-light{background-color:#f8f9fa!important}a.bg-light:focus,a.bg-light:hover,button.bg-light:focus,button.bg-light:hover{background-color:#dae0e5!important}.bg-dark{background-color:#343a40!important}a.bg-dark:focus,a.bg-dark:hover,button.bg-dark:focus,button.bg-dark:hover{background-color:#1d2124!important}.bg-white{background-color:#fff!important}.bg-transparent{background-color:transparent!important}.border{border:1px solid #dee2e6!important}.border-top{border-top:1px solid #dee2e6!important}.border-right{border-right:1px solid #dee2e6!important}.border-bottom{border-bottom:1px solid #dee2e6!important}.border-left{border-left:1px solid #dee2e6!important}.border-0{border:0!important}.border-top-0{border-top:0!important}.border-right-0{border-right:0!important}.border-bottom-0{border-bottom:0!important}.border-left-0{border-left:0!important}.border-primary{border-color:#007bff!important}.border-secondary{border-color:#6c757d!important}.border-success{border-color:#28a745!important}.border-info{border-color:#17a2b8!important}.border-warning{border-color:#ffc107!important}.border-danger{border-color:#dc3545!important}.border-light{border-color:#f8f9fa!important}.border-dark{border-color:#343a40!important}.border-white{border-color:#fff!important}.rounded-sm{border-radius:.2rem!important}.rounded{border-radius:.25rem!important}.rounded-top{border-top-left-radius:.25rem!important}.rounded-right,.rounded-top{border-top-right-radius:.25rem!important}.rounded-bottom,.rounded-right{border-bottom-right-radius:.25rem!important}.rounded-bottom,.rounded-left{border-bottom-left-radius:.25rem!important}.rounded-left{border-top-left-radius:.25rem!important}.rounded-lg{border-radius:.3rem!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:50rem!important}.rounded-0{border-radius:0!important}.clearfix:after{display:block;clear:both;content:""}.d-none{display:none!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:flex!important}.d-inline-flex{display:inline-flex!important}@media (min-width:540px){.d-sm-none{display:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:flex!important}.d-sm-inline-flex{display:inline-flex!important}}@media (min-width:720px){.d-md-none{display:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:flex!important}.d-md-inline-flex{display:inline-flex!important}}@media (min-width:960px){.d-lg-none{display:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:flex!important}.d-lg-inline-flex{display:inline-flex!important}}@media (min-width:1200px){.d-xl-none{display:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:flex!important}.d-xl-inline-flex{display:inline-flex!important}}@media print{.d-print-none{display:none!important}.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:flex!important}.d-print-inline-flex{display:inline-flex!important}}.embed-responsive{position:relative;display:block;width:100%;padding:0;overflow:hidden}.embed-responsive:before{display:block;content:""}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-21by9:before{padding-top:42.85714%}.embed-responsive-16by9:before{padding-top:56.25%}.embed-responsive-4by3:before{padding-top:75%}.embed-responsive-1by1:before{padding-top:100%}.flex-row{flex-direction:row!important}.flex-column{flex-direction:column!important}.flex-row-reverse{flex-direction:row-reverse!important}.flex-column-reverse{flex-direction:column-reverse!important}.flex-wrap{flex-wrap:wrap!important}.flex-nowrap{flex-wrap:nowrap!important}.flex-wrap-reverse{flex-wrap:wrap-reverse!important}.flex-fill{flex:1 1 auto!important}.flex-grow-0{flex-grow:0!important}.flex-grow-1{flex-grow:1!important}.flex-shrink-0{flex-shrink:0!important}.flex-shrink-1{flex-shrink:1!important}.justify-content-start{justify-content:flex-start!important}.justify-content-end{justify-content:flex-end!important}.justify-content-center{justify-content:center!important}.justify-content-between{justify-content:space-between!important}.justify-content-around{justify-content:space-around!important}.align-items-start{align-items:flex-start!important}.align-items-end{align-items:flex-end!important}.align-items-center{align-items:center!important}.align-items-baseline{align-items:baseline!important}.align-items-stretch{align-items:stretch!important}.align-content-start{align-content:flex-start!important}.align-content-end{align-content:flex-end!important}.align-content-center{align-content:center!important}.align-content-between{align-content:space-between!important}.align-content-around{align-content:space-around!important}.align-content-stretch{align-content:stretch!important}.align-self-auto{align-self:auto!important}.align-self-start{align-self:flex-start!important}.align-self-end{align-self:flex-end!important}.align-self-center{align-self:center!important}.align-self-baseline{align-self:baseline!important}.align-self-stretch{align-self:stretch!important}@media (min-width:540px){.flex-sm-row{flex-direction:row!important}.flex-sm-column{flex-direction:column!important}.flex-sm-row-reverse{flex-direction:row-reverse!important}.flex-sm-column-reverse{flex-direction:column-reverse!important}.flex-sm-wrap{flex-wrap:wrap!important}.flex-sm-nowrap{flex-wrap:nowrap!important}.flex-sm-wrap-reverse{flex-wrap:wrap-reverse!important}.flex-sm-fill{flex:1 1 auto!important}.flex-sm-grow-0{flex-grow:0!important}.flex-sm-grow-1{flex-grow:1!important}.flex-sm-shrink-0{flex-shrink:0!important}.flex-sm-shrink-1{flex-shrink:1!important}.justify-content-sm-start{justify-content:flex-start!important}.justify-content-sm-end{justify-content:flex-end!important}.justify-content-sm-center{justify-content:center!important}.justify-content-sm-between{justify-content:space-between!important}.justify-content-sm-around{justify-content:space-around!important}.align-items-sm-start{align-items:flex-start!important}.align-items-sm-end{align-items:flex-end!important}.align-items-sm-center{align-items:center!important}.align-items-sm-baseline{align-items:baseline!important}.align-items-sm-stretch{align-items:stretch!important}.align-content-sm-start{align-content:flex-start!important}.align-content-sm-end{align-content:flex-end!important}.align-content-sm-center{align-content:center!important}.align-content-sm-between{align-content:space-between!important}.align-content-sm-around{align-content:space-around!important}.align-content-sm-stretch{align-content:stretch!important}.align-self-sm-auto{align-self:auto!important}.align-self-sm-start{align-self:flex-start!important}.align-self-sm-end{align-self:flex-end!important}.align-self-sm-center{align-self:center!important}.align-self-sm-baseline{align-self:baseline!important}.align-self-sm-stretch{align-self:stretch!important}}@media (min-width:720px){.flex-md-row{flex-direction:row!important}.flex-md-column{flex-direction:column!important}.flex-md-row-reverse{flex-direction:row-reverse!important}.flex-md-column-reverse{flex-direction:column-reverse!important}.flex-md-wrap{flex-wrap:wrap!important}.flex-md-nowrap{flex-wrap:nowrap!important}.flex-md-wrap-reverse{flex-wrap:wrap-reverse!important}.flex-md-fill{flex:1 1 auto!important}.flex-md-grow-0{flex-grow:0!important}.flex-md-grow-1{flex-grow:1!important}.flex-md-shrink-0{flex-shrink:0!important}.flex-md-shrink-1{flex-shrink:1!important}.justify-content-md-start{justify-content:flex-start!important}.justify-content-md-end{justify-content:flex-end!important}.justify-content-md-center{justify-content:center!important}.justify-content-md-between{justify-content:space-between!important}.justify-content-md-around{justify-content:space-around!important}.align-items-md-start{align-items:flex-start!important}.align-items-md-end{align-items:flex-end!important}.align-items-md-center{align-items:center!important}.align-items-md-baseline{align-items:baseline!important}.align-items-md-stretch{align-items:stretch!important}.align-content-md-start{align-content:flex-start!important}.align-content-md-end{align-content:flex-end!important}.align-content-md-center{align-content:center!important}.align-content-md-between{align-content:space-between!important}.align-content-md-around{align-content:space-around!important}.align-content-md-stretch{align-content:stretch!important}.align-self-md-auto{align-self:auto!important}.align-self-md-start{align-self:flex-start!important}.align-self-md-end{align-self:flex-end!important}.align-self-md-center{align-self:center!important}.align-self-md-baseline{align-self:baseline!important}.align-self-md-stretch{align-self:stretch!important}}@media (min-width:960px){.flex-lg-row{flex-direction:row!important}.flex-lg-column{flex-direction:column!important}.flex-lg-row-reverse{flex-direction:row-reverse!important}.flex-lg-column-reverse{flex-direction:column-reverse!important}.flex-lg-wrap{flex-wrap:wrap!important}.flex-lg-nowrap{flex-wrap:nowrap!important}.flex-lg-wrap-reverse{flex-wrap:wrap-reverse!important}.flex-lg-fill{flex:1 1 auto!important}.flex-lg-grow-0{flex-grow:0!important}.flex-lg-grow-1{flex-grow:1!important}.flex-lg-shrink-0{flex-shrink:0!important}.flex-lg-shrink-1{flex-shrink:1!important}.justify-content-lg-start{justify-content:flex-start!important}.justify-content-lg-end{justify-content:flex-end!important}.justify-content-lg-center{justify-content:center!important}.justify-content-lg-between{justify-content:space-between!important}.justify-content-lg-around{justify-content:space-around!important}.align-items-lg-start{align-items:flex-start!important}.align-items-lg-end{align-items:flex-end!important}.align-items-lg-center{align-items:center!important}.align-items-lg-baseline{align-items:baseline!important}.align-items-lg-stretch{align-items:stretch!important}.align-content-lg-start{align-content:flex-start!important}.align-content-lg-end{align-content:flex-end!important}.align-content-lg-center{align-content:center!important}.align-content-lg-between{align-content:space-between!important}.align-content-lg-around{align-content:space-around!important}.align-content-lg-stretch{align-content:stretch!important}.align-self-lg-auto{align-self:auto!important}.align-self-lg-start{align-self:flex-start!important}.align-self-lg-end{align-self:flex-end!important}.align-self-lg-center{align-self:center!important}.align-self-lg-baseline{align-self:baseline!important}.align-self-lg-stretch{align-self:stretch!important}}@media (min-width:1200px){.flex-xl-row{flex-direction:row!important}.flex-xl-column{flex-direction:column!important}.flex-xl-row-reverse{flex-direction:row-reverse!important}.flex-xl-column-reverse{flex-direction:column-reverse!important}.flex-xl-wrap{flex-wrap:wrap!important}.flex-xl-nowrap{flex-wrap:nowrap!important}.flex-xl-wrap-reverse{flex-wrap:wrap-reverse!important}.flex-xl-fill{flex:1 1 auto!important}.flex-xl-grow-0{flex-grow:0!important}.flex-xl-grow-1{flex-grow:1!important}.flex-xl-shrink-0{flex-shrink:0!important}.flex-xl-shrink-1{flex-shrink:1!important}.justify-content-xl-start{justify-content:flex-start!important}.justify-content-xl-end{justify-content:flex-end!important}.justify-content-xl-center{justify-content:center!important}.justify-content-xl-between{justify-content:space-between!important}.justify-content-xl-around{justify-content:space-around!important}.align-items-xl-start{align-items:flex-start!important}.align-items-xl-end{align-items:flex-end!important}.align-items-xl-center{align-items:center!important}.align-items-xl-baseline{align-items:baseline!important}.align-items-xl-stretch{align-items:stretch!important}.align-content-xl-start{align-content:flex-start!important}.align-content-xl-end{align-content:flex-end!important}.align-content-xl-center{align-content:center!important}.align-content-xl-between{align-content:space-between!important}.align-content-xl-around{align-content:space-around!important}.align-content-xl-stretch{align-content:stretch!important}.align-self-xl-auto{align-self:auto!important}.align-self-xl-start{align-self:flex-start!important}.align-self-xl-end{align-self:flex-end!important}.align-self-xl-center{align-self:center!important}.align-self-xl-baseline{align-self:baseline!important}.align-self-xl-stretch{align-self:stretch!important}}.float-left{float:left!important}.float-right{float:right!important}.float-none{float:none!important}@media (min-width:540px){.float-sm-left{float:left!important}.float-sm-right{float:right!important}.float-sm-none{float:none!important}}@media (min-width:720px){.float-md-left{float:left!important}.float-md-right{float:right!important}.float-md-none{float:none!important}}@media (min-width:960px){.float-lg-left{float:left!important}.float-lg-right{float:right!important}.float-lg-none{float:none!important}}@media (min-width:1200px){.float-xl-left{float:left!important}.float-xl-right{float:right!important}.float-xl-none{float:none!important}}.user-select-all{user-select:all!important}.user-select-auto{user-select:auto!important}.user-select-none{user-select:none!important}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:sticky!important}.fixed-top{top:0}.fixed-bottom,.fixed-top{position:fixed;right:0;left:0;z-index:1030}.fixed-bottom{bottom:0}@supports (position:sticky){.sticky-top{position:sticky;top:0;z-index:1020}}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;overflow:visible;clip:auto;white-space:normal}.shadow-sm{box-shadow:0 .125rem .25rem rgba(0,0,0,.075)!important}.shadow{box-shadow:0 .5rem 1rem rgba(0,0,0,.15)!important}.shadow-lg{box-shadow:0 1rem 3rem rgba(0,0,0,.175)!important}.shadow-none{box-shadow:none!important}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mw-100{max-width:100%!important}.mh-100{max-height:100%!important}.min-vw-100{min-width:100vw!important}.min-vh-100{min-height:100vh!important}.vw-100{width:100vw!important}.vh-100{height:100vh!important}.m-0{margin:0!important}.mt-0,.my-0{margin-top:0!important}.mr-0,.mx-0{margin-right:0!important}.mb-0,.my-0{margin-bottom:0!important}.ml-0,.mx-0{margin-left:0!important}.m-1{margin:.25rem!important}.mt-1,.my-1{margin-top:.25rem!important}.mr-1,.mx-1{margin-right:.25rem!important}.mb-1,.my-1{margin-bottom:.25rem!important}.ml-1,.mx-1{margin-left:.25rem!important}.m-2{margin:.5rem!important}.mt-2,.my-2{margin-top:.5rem!important}.mr-2,.mx-2{margin-right:.5rem!important}.mb-2,.my-2{margin-bottom:.5rem!important}.ml-2,.mx-2{margin-left:.5rem!important}.m-3{margin:1rem!important}.mt-3,.my-3{margin-top:1rem!important}.mr-3,.mx-3{margin-right:1rem!important}.mb-3,.my-3{margin-bottom:1rem!important}.ml-3,.mx-3{margin-left:1rem!important}.m-4{margin:1.5rem!important}.mt-4,.my-4{margin-top:1.5rem!important}.mr-4,.mx-4{margin-right:1.5rem!important}.mb-4,.my-4{margin-bottom:1.5rem!important}.ml-4,.mx-4{margin-left:1.5rem!important}.m-5{margin:3rem!important}.mt-5,.my-5{margin-top:3rem!important}.mr-5,.mx-5{margin-right:3rem!important}.mb-5,.my-5{margin-bottom:3rem!important}.ml-5,.mx-5{margin-left:3rem!important}.p-0{padding:0!important}.pt-0,.py-0{padding-top:0!important}.pr-0,.px-0{padding-right:0!important}.pb-0,.py-0{padding-bottom:0!important}.pl-0,.px-0{padding-left:0!important}.p-1{padding:.25rem!important}.pt-1,.py-1{padding-top:.25rem!important}.pr-1,.px-1{padding-right:.25rem!important}.pb-1,.py-1{padding-bottom:.25rem!important}.pl-1,.px-1{padding-left:.25rem!important}.p-2{padding:.5rem!important}.pt-2,.py-2{padding-top:.5rem!important}.pr-2,.px-2{padding-right:.5rem!important}.pb-2,.py-2{padding-bottom:.5rem!important}.pl-2,.px-2{padding-left:.5rem!important}.p-3{padding:1rem!important}.pt-3,.py-3{padding-top:1rem!important}.pr-3,.px-3{padding-right:1rem!important}.pb-3,.py-3{padding-bottom:1rem!important}.pl-3,.px-3{padding-left:1rem!important}.p-4{padding:1.5rem!important}.pt-4,.py-4{padding-top:1.5rem!important}.pr-4,.px-4{padding-right:1.5rem!important}.pb-4,.py-4{padding-bottom:1.5rem!important}.pl-4,.px-4{padding-left:1.5rem!important}.p-5{padding:3rem!important}.pt-5,.py-5{padding-top:3rem!important}.pr-5,.px-5{padding-right:3rem!important}.pb-5,.py-5{padding-bottom:3rem!important}.pl-5,.px-5{padding-left:3rem!important}.m-n1{margin:-.25rem!important}.mt-n1,.my-n1{margin-top:-.25rem!important}.mr-n1,.mx-n1{margin-right:-.25rem!important}.mb-n1,.my-n1{margin-bottom:-.25rem!important}.ml-n1,.mx-n1{margin-left:-.25rem!important}.m-n2{margin:-.5rem!important}.mt-n2,.my-n2{margin-top:-.5rem!important}.mr-n2,.mx-n2{margin-right:-.5rem!important}.mb-n2,.my-n2{margin-bottom:-.5rem!important}.ml-n2,.mx-n2{margin-left:-.5rem!important}.m-n3{margin:-1rem!important}.mt-n3,.my-n3{margin-top:-1rem!important}.mr-n3,.mx-n3{margin-right:-1rem!important}.mb-n3,.my-n3{margin-bottom:-1rem!important}.ml-n3,.mx-n3{margin-left:-1rem!important}.m-n4{margin:-1.5rem!important}.mt-n4,.my-n4{margin-top:-1.5rem!important}.mr-n4,.mx-n4{margin-right:-1.5rem!important}.mb-n4,.my-n4{margin-bottom:-1.5rem!important}.ml-n4,.mx-n4{margin-left:-1.5rem!important}.m-n5{margin:-3rem!important}.mt-n5,.my-n5{margin-top:-3rem!important}.mr-n5,.mx-n5{margin-right:-3rem!important}.mb-n5,.my-n5{margin-bottom:-3rem!important}.ml-n5,.mx-n5{margin-left:-3rem!important}.m-auto{margin:auto!important}.mt-auto,.my-auto{margin-top:auto!important}.mr-auto,.mx-auto{margin-right:auto!important}.mb-auto,.my-auto{margin-bottom:auto!important}.ml-auto,.mx-auto{margin-left:auto!important}@media (min-width:540px){.m-sm-0{margin:0!important}.mt-sm-0,.my-sm-0{margin-top:0!important}.mr-sm-0,.mx-sm-0{margin-right:0!important}.mb-sm-0,.my-sm-0{margin-bottom:0!important}.ml-sm-0,.mx-sm-0{margin-left:0!important}.m-sm-1{margin:.25rem!important}.mt-sm-1,.my-sm-1{margin-top:.25rem!important}.mr-sm-1,.mx-sm-1{margin-right:.25rem!important}.mb-sm-1,.my-sm-1{margin-bottom:.25rem!important}.ml-sm-1,.mx-sm-1{margin-left:.25rem!important}.m-sm-2{margin:.5rem!important}.mt-sm-2,.my-sm-2{margin-top:.5rem!important}.mr-sm-2,.mx-sm-2{margin-right:.5rem!important}.mb-sm-2,.my-sm-2{margin-bottom:.5rem!important}.ml-sm-2,.mx-sm-2{margin-left:.5rem!important}.m-sm-3{margin:1rem!important}.mt-sm-3,.my-sm-3{margin-top:1rem!important}.mr-sm-3,.mx-sm-3{margin-right:1rem!important}.mb-sm-3,.my-sm-3{margin-bottom:1rem!important}.ml-sm-3,.mx-sm-3{margin-left:1rem!important}.m-sm-4{margin:1.5rem!important}.mt-sm-4,.my-sm-4{margin-top:1.5rem!important}.mr-sm-4,.mx-sm-4{margin-right:1.5rem!important}.mb-sm-4,.my-sm-4{margin-bottom:1.5rem!important}.ml-sm-4,.mx-sm-4{margin-left:1.5rem!important}.m-sm-5{margin:3rem!important}.mt-sm-5,.my-sm-5{margin-top:3rem!important}.mr-sm-5,.mx-sm-5{margin-right:3rem!important}.mb-sm-5,.my-sm-5{margin-bottom:3rem!important}.ml-sm-5,.mx-sm-5{margin-left:3rem!important}.p-sm-0{padding:0!important}.pt-sm-0,.py-sm-0{padding-top:0!important}.pr-sm-0,.px-sm-0{padding-right:0!important}.pb-sm-0,.py-sm-0{padding-bottom:0!important}.pl-sm-0,.px-sm-0{padding-left:0!important}.p-sm-1{padding:.25rem!important}.pt-sm-1,.py-sm-1{padding-top:.25rem!important}.pr-sm-1,.px-sm-1{padding-right:.25rem!important}.pb-sm-1,.py-sm-1{padding-bottom:.25rem!important}.pl-sm-1,.px-sm-1{padding-left:.25rem!important}.p-sm-2{padding:.5rem!important}.pt-sm-2,.py-sm-2{padding-top:.5rem!important}.pr-sm-2,.px-sm-2{padding-right:.5rem!important}.pb-sm-2,.py-sm-2{padding-bottom:.5rem!important}.pl-sm-2,.px-sm-2{padding-left:.5rem!important}.p-sm-3{padding:1rem!important}.pt-sm-3,.py-sm-3{padding-top:1rem!important}.pr-sm-3,.px-sm-3{padding-right:1rem!important}.pb-sm-3,.py-sm-3{padding-bottom:1rem!important}.pl-sm-3,.px-sm-3{padding-left:1rem!important}.p-sm-4{padding:1.5rem!important}.pt-sm-4,.py-sm-4{padding-top:1.5rem!important}.pr-sm-4,.px-sm-4{padding-right:1.5rem!important}.pb-sm-4,.py-sm-4{padding-bottom:1.5rem!important}.pl-sm-4,.px-sm-4{padding-left:1.5rem!important}.p-sm-5{padding:3rem!important}.pt-sm-5,.py-sm-5{padding-top:3rem!important}.pr-sm-5,.px-sm-5{padding-right:3rem!important}.pb-sm-5,.py-sm-5{padding-bottom:3rem!important}.pl-sm-5,.px-sm-5{padding-left:3rem!important}.m-sm-n1{margin:-.25rem!important}.mt-sm-n1,.my-sm-n1{margin-top:-.25rem!important}.mr-sm-n1,.mx-sm-n1{margin-right:-.25rem!important}.mb-sm-n1,.my-sm-n1{margin-bottom:-.25rem!important}.ml-sm-n1,.mx-sm-n1{margin-left:-.25rem!important}.m-sm-n2{margin:-.5rem!important}.mt-sm-n2,.my-sm-n2{margin-top:-.5rem!important}.mr-sm-n2,.mx-sm-n2{margin-right:-.5rem!important}.mb-sm-n2,.my-sm-n2{margin-bottom:-.5rem!important}.ml-sm-n2,.mx-sm-n2{margin-left:-.5rem!important}.m-sm-n3{margin:-1rem!important}.mt-sm-n3,.my-sm-n3{margin-top:-1rem!important}.mr-sm-n3,.mx-sm-n3{margin-right:-1rem!important}.mb-sm-n3,.my-sm-n3{margin-bottom:-1rem!important}.ml-sm-n3,.mx-sm-n3{margin-left:-1rem!important}.m-sm-n4{margin:-1.5rem!important}.mt-sm-n4,.my-sm-n4{margin-top:-1.5rem!important}.mr-sm-n4,.mx-sm-n4{margin-right:-1.5rem!important}.mb-sm-n4,.my-sm-n4{margin-bottom:-1.5rem!important}.ml-sm-n4,.mx-sm-n4{margin-left:-1.5rem!important}.m-sm-n5{margin:-3rem!important}.mt-sm-n5,.my-sm-n5{margin-top:-3rem!important}.mr-sm-n5,.mx-sm-n5{margin-right:-3rem!important}.mb-sm-n5,.my-sm-n5{margin-bottom:-3rem!important}.ml-sm-n5,.mx-sm-n5{margin-left:-3rem!important}.m-sm-auto{margin:auto!important}.mt-sm-auto,.my-sm-auto{margin-top:auto!important}.mr-sm-auto,.mx-sm-auto{margin-right:auto!important}.mb-sm-auto,.my-sm-auto{margin-bottom:auto!important}.ml-sm-auto,.mx-sm-auto{margin-left:auto!important}}@media (min-width:720px){.m-md-0{margin:0!important}.mt-md-0,.my-md-0{margin-top:0!important}.mr-md-0,.mx-md-0{margin-right:0!important}.mb-md-0,.my-md-0{margin-bottom:0!important}.ml-md-0,.mx-md-0{margin-left:0!important}.m-md-1{margin:.25rem!important}.mt-md-1,.my-md-1{margin-top:.25rem!important}.mr-md-1,.mx-md-1{margin-right:.25rem!important}.mb-md-1,.my-md-1{margin-bottom:.25rem!important}.ml-md-1,.mx-md-1{margin-left:.25rem!important}.m-md-2{margin:.5rem!important}.mt-md-2,.my-md-2{margin-top:.5rem!important}.mr-md-2,.mx-md-2{margin-right:.5rem!important}.mb-md-2,.my-md-2{margin-bottom:.5rem!important}.ml-md-2,.mx-md-2{margin-left:.5rem!important}.m-md-3{margin:1rem!important}.mt-md-3,.my-md-3{margin-top:1rem!important}.mr-md-3,.mx-md-3{margin-right:1rem!important}.mb-md-3,.my-md-3{margin-bottom:1rem!important}.ml-md-3,.mx-md-3{margin-left:1rem!important}.m-md-4{margin:1.5rem!important}.mt-md-4,.my-md-4{margin-top:1.5rem!important}.mr-md-4,.mx-md-4{margin-right:1.5rem!important}.mb-md-4,.my-md-4{margin-bottom:1.5rem!important}.ml-md-4,.mx-md-4{margin-left:1.5rem!important}.m-md-5{margin:3rem!important}.mt-md-5,.my-md-5{margin-top:3rem!important}.mr-md-5,.mx-md-5{margin-right:3rem!important}.mb-md-5,.my-md-5{margin-bottom:3rem!important}.ml-md-5,.mx-md-5{margin-left:3rem!important}.p-md-0{padding:0!important}.pt-md-0,.py-md-0{padding-top:0!important}.pr-md-0,.px-md-0{padding-right:0!important}.pb-md-0,.py-md-0{padding-bottom:0!important}.pl-md-0,.px-md-0{padding-left:0!important}.p-md-1{padding:.25rem!important}.pt-md-1,.py-md-1{padding-top:.25rem!important}.pr-md-1,.px-md-1{padding-right:.25rem!important}.pb-md-1,.py-md-1{padding-bottom:.25rem!important}.pl-md-1,.px-md-1{padding-left:.25rem!important}.p-md-2{padding:.5rem!important}.pt-md-2,.py-md-2{padding-top:.5rem!important}.pr-md-2,.px-md-2{padding-right:.5rem!important}.pb-md-2,.py-md-2{padding-bottom:.5rem!important}.pl-md-2,.px-md-2{padding-left:.5rem!important}.p-md-3{padding:1rem!important}.pt-md-3,.py-md-3{padding-top:1rem!important}.pr-md-3,.px-md-3{padding-right:1rem!important}.pb-md-3,.py-md-3{padding-bottom:1rem!important}.pl-md-3,.px-md-3{padding-left:1rem!important}.p-md-4{padding:1.5rem!important}.pt-md-4,.py-md-4{padding-top:1.5rem!important}.pr-md-4,.px-md-4{padding-right:1.5rem!important}.pb-md-4,.py-md-4{padding-bottom:1.5rem!important}.pl-md-4,.px-md-4{padding-left:1.5rem!important}.p-md-5{padding:3rem!important}.pt-md-5,.py-md-5{padding-top:3rem!important}.pr-md-5,.px-md-5{padding-right:3rem!important}.pb-md-5,.py-md-5{padding-bottom:3rem!important}.pl-md-5,.px-md-5{padding-left:3rem!important}.m-md-n1{margin:-.25rem!important}.mt-md-n1,.my-md-n1{margin-top:-.25rem!important}.mr-md-n1,.mx-md-n1{margin-right:-.25rem!important}.mb-md-n1,.my-md-n1{margin-bottom:-.25rem!important}.ml-md-n1,.mx-md-n1{margin-left:-.25rem!important}.m-md-n2{margin:-.5rem!important}.mt-md-n2,.my-md-n2{margin-top:-.5rem!important}.mr-md-n2,.mx-md-n2{margin-right:-.5rem!important}.mb-md-n2,.my-md-n2{margin-bottom:-.5rem!important}.ml-md-n2,.mx-md-n2{margin-left:-.5rem!important}.m-md-n3{margin:-1rem!important}.mt-md-n3,.my-md-n3{margin-top:-1rem!important}.mr-md-n3,.mx-md-n3{margin-right:-1rem!important}.mb-md-n3,.my-md-n3{margin-bottom:-1rem!important}.ml-md-n3,.mx-md-n3{margin-left:-1rem!important}.m-md-n4{margin:-1.5rem!important}.mt-md-n4,.my-md-n4{margin-top:-1.5rem!important}.mr-md-n4,.mx-md-n4{margin-right:-1.5rem!important}.mb-md-n4,.my-md-n4{margin-bottom:-1.5rem!important}.ml-md-n4,.mx-md-n4{margin-left:-1.5rem!important}.m-md-n5{margin:-3rem!important}.mt-md-n5,.my-md-n5{margin-top:-3rem!important}.mr-md-n5,.mx-md-n5{margin-right:-3rem!important}.mb-md-n5,.my-md-n5{margin-bottom:-3rem!important}.ml-md-n5,.mx-md-n5{margin-left:-3rem!important}.m-md-auto{margin:auto!important}.mt-md-auto,.my-md-auto{margin-top:auto!important}.mr-md-auto,.mx-md-auto{margin-right:auto!important}.mb-md-auto,.my-md-auto{margin-bottom:auto!important}.ml-md-auto,.mx-md-auto{margin-left:auto!important}}@media (min-width:960px){.m-lg-0{margin:0!important}.mt-lg-0,.my-lg-0{margin-top:0!important}.mr-lg-0,.mx-lg-0{margin-right:0!important}.mb-lg-0,.my-lg-0{margin-bottom:0!important}.ml-lg-0,.mx-lg-0{margin-left:0!important}.m-lg-1{margin:.25rem!important}.mt-lg-1,.my-lg-1{margin-top:.25rem!important}.mr-lg-1,.mx-lg-1{margin-right:.25rem!important}.mb-lg-1,.my-lg-1{margin-bottom:.25rem!important}.ml-lg-1,.mx-lg-1{margin-left:.25rem!important}.m-lg-2{margin:.5rem!important}.mt-lg-2,.my-lg-2{margin-top:.5rem!important}.mr-lg-2,.mx-lg-2{margin-right:.5rem!important}.mb-lg-2,.my-lg-2{margin-bottom:.5rem!important}.ml-lg-2,.mx-lg-2{margin-left:.5rem!important}.m-lg-3{margin:1rem!important}.mt-lg-3,.my-lg-3{margin-top:1rem!important}.mr-lg-3,.mx-lg-3{margin-right:1rem!important}.mb-lg-3,.my-lg-3{margin-bottom:1rem!important}.ml-lg-3,.mx-lg-3{margin-left:1rem!important}.m-lg-4{margin:1.5rem!important}.mt-lg-4,.my-lg-4{margin-top:1.5rem!important}.mr-lg-4,.mx-lg-4{margin-right:1.5rem!important}.mb-lg-4,.my-lg-4{margin-bottom:1.5rem!important}.ml-lg-4,.mx-lg-4{margin-left:1.5rem!important}.m-lg-5{margin:3rem!important}.mt-lg-5,.my-lg-5{margin-top:3rem!important}.mr-lg-5,.mx-lg-5{margin-right:3rem!important}.mb-lg-5,.my-lg-5{margin-bottom:3rem!important}.ml-lg-5,.mx-lg-5{margin-left:3rem!important}.p-lg-0{padding:0!important}.pt-lg-0,.py-lg-0{padding-top:0!important}.pr-lg-0,.px-lg-0{padding-right:0!important}.pb-lg-0,.py-lg-0{padding-bottom:0!important}.pl-lg-0,.px-lg-0{padding-left:0!important}.p-lg-1{padding:.25rem!important}.pt-lg-1,.py-lg-1{padding-top:.25rem!important}.pr-lg-1,.px-lg-1{padding-right:.25rem!important}.pb-lg-1,.py-lg-1{padding-bottom:.25rem!important}.pl-lg-1,.px-lg-1{padding-left:.25rem!important}.p-lg-2{padding:.5rem!important}.pt-lg-2,.py-lg-2{padding-top:.5rem!important}.pr-lg-2,.px-lg-2{padding-right:.5rem!important}.pb-lg-2,.py-lg-2{padding-bottom:.5rem!important}.pl-lg-2,.px-lg-2{padding-left:.5rem!important}.p-lg-3{padding:1rem!important}.pt-lg-3,.py-lg-3{padding-top:1rem!important}.pr-lg-3,.px-lg-3{padding-right:1rem!important}.pb-lg-3,.py-lg-3{padding-bottom:1rem!important}.pl-lg-3,.px-lg-3{padding-left:1rem!important}.p-lg-4{padding:1.5rem!important}.pt-lg-4,.py-lg-4{padding-top:1.5rem!important}.pr-lg-4,.px-lg-4{padding-right:1.5rem!important}.pb-lg-4,.py-lg-4{padding-bottom:1.5rem!important}.pl-lg-4,.px-lg-4{padding-left:1.5rem!important}.p-lg-5{padding:3rem!important}.pt-lg-5,.py-lg-5{padding-top:3rem!important}.pr-lg-5,.px-lg-5{padding-right:3rem!important}.pb-lg-5,.py-lg-5{padding-bottom:3rem!important}.pl-lg-5,.px-lg-5{padding-left:3rem!important}.m-lg-n1{margin:-.25rem!important}.mt-lg-n1,.my-lg-n1{margin-top:-.25rem!important}.mr-lg-n1,.mx-lg-n1{margin-right:-.25rem!important}.mb-lg-n1,.my-lg-n1{margin-bottom:-.25rem!important}.ml-lg-n1,.mx-lg-n1{margin-left:-.25rem!important}.m-lg-n2{margin:-.5rem!important}.mt-lg-n2,.my-lg-n2{margin-top:-.5rem!important}.mr-lg-n2,.mx-lg-n2{margin-right:-.5rem!important}.mb-lg-n2,.my-lg-n2{margin-bottom:-.5rem!important}.ml-lg-n2,.mx-lg-n2{margin-left:-.5rem!important}.m-lg-n3{margin:-1rem!important}.mt-lg-n3,.my-lg-n3{margin-top:-1rem!important}.mr-lg-n3,.mx-lg-n3{margin-right:-1rem!important}.mb-lg-n3,.my-lg-n3{margin-bottom:-1rem!important}.ml-lg-n3,.mx-lg-n3{margin-left:-1rem!important}.m-lg-n4{margin:-1.5rem!important}.mt-lg-n4,.my-lg-n4{margin-top:-1.5rem!important}.mr-lg-n4,.mx-lg-n4{margin-right:-1.5rem!important}.mb-lg-n4,.my-lg-n4{margin-bottom:-1.5rem!important}.ml-lg-n4,.mx-lg-n4{margin-left:-1.5rem!important}.m-lg-n5{margin:-3rem!important}.mt-lg-n5,.my-lg-n5{margin-top:-3rem!important}.mr-lg-n5,.mx-lg-n5{margin-right:-3rem!important}.mb-lg-n5,.my-lg-n5{margin-bottom:-3rem!important}.ml-lg-n5,.mx-lg-n5{margin-left:-3rem!important}.m-lg-auto{margin:auto!important}.mt-lg-auto,.my-lg-auto{margin-top:auto!important}.mr-lg-auto,.mx-lg-auto{margin-right:auto!important}.mb-lg-auto,.my-lg-auto{margin-bottom:auto!important}.ml-lg-auto,.mx-lg-auto{margin-left:auto!important}}@media (min-width:1200px){.m-xl-0{margin:0!important}.mt-xl-0,.my-xl-0{margin-top:0!important}.mr-xl-0,.mx-xl-0{margin-right:0!important}.mb-xl-0,.my-xl-0{margin-bottom:0!important}.ml-xl-0,.mx-xl-0{margin-left:0!important}.m-xl-1{margin:.25rem!important}.mt-xl-1,.my-xl-1{margin-top:.25rem!important}.mr-xl-1,.mx-xl-1{margin-right:.25rem!important}.mb-xl-1,.my-xl-1{margin-bottom:.25rem!important}.ml-xl-1,.mx-xl-1{margin-left:.25rem!important}.m-xl-2{margin:.5rem!important}.mt-xl-2,.my-xl-2{margin-top:.5rem!important}.mr-xl-2,.mx-xl-2{margin-right:.5rem!important}.mb-xl-2,.my-xl-2{margin-bottom:.5rem!important}.ml-xl-2,.mx-xl-2{margin-left:.5rem!important}.m-xl-3{margin:1rem!important}.mt-xl-3,.my-xl-3{margin-top:1rem!important}.mr-xl-3,.mx-xl-3{margin-right:1rem!important}.mb-xl-3,.my-xl-3{margin-bottom:1rem!important}.ml-xl-3,.mx-xl-3{margin-left:1rem!important}.m-xl-4{margin:1.5rem!important}.mt-xl-4,.my-xl-4{margin-top:1.5rem!important}.mr-xl-4,.mx-xl-4{margin-right:1.5rem!important}.mb-xl-4,.my-xl-4{margin-bottom:1.5rem!important}.ml-xl-4,.mx-xl-4{margin-left:1.5rem!important}.m-xl-5{margin:3rem!important}.mt-xl-5,.my-xl-5{margin-top:3rem!important}.mr-xl-5,.mx-xl-5{margin-right:3rem!important}.mb-xl-5,.my-xl-5{margin-bottom:3rem!important}.ml-xl-5,.mx-xl-5{margin-left:3rem!important}.p-xl-0{padding:0!important}.pt-xl-0,.py-xl-0{padding-top:0!important}.pr-xl-0,.px-xl-0{padding-right:0!important}.pb-xl-0,.py-xl-0{padding-bottom:0!important}.pl-xl-0,.px-xl-0{padding-left:0!important}.p-xl-1{padding:.25rem!important}.pt-xl-1,.py-xl-1{padding-top:.25rem!important}.pr-xl-1,.px-xl-1{padding-right:.25rem!important}.pb-xl-1,.py-xl-1{padding-bottom:.25rem!important}.pl-xl-1,.px-xl-1{padding-left:.25rem!important}.p-xl-2{padding:.5rem!important}.pt-xl-2,.py-xl-2{padding-top:.5rem!important}.pr-xl-2,.px-xl-2{padding-right:.5rem!important}.pb-xl-2,.py-xl-2{padding-bottom:.5rem!important}.pl-xl-2,.px-xl-2{padding-left:.5rem!important}.p-xl-3{padding:1rem!important}.pt-xl-3,.py-xl-3{padding-top:1rem!important}.pr-xl-3,.px-xl-3{padding-right:1rem!important}.pb-xl-3,.py-xl-3{padding-bottom:1rem!important}.pl-xl-3,.px-xl-3{padding-left:1rem!important}.p-xl-4{padding:1.5rem!important}.pt-xl-4,.py-xl-4{padding-top:1.5rem!important}.pr-xl-4,.px-xl-4{padding-right:1.5rem!important}.pb-xl-4,.py-xl-4{padding-bottom:1.5rem!important}.pl-xl-4,.px-xl-4{padding-left:1.5rem!important}.p-xl-5{padding:3rem!important}.pt-xl-5,.py-xl-5{padding-top:3rem!important}.pr-xl-5,.px-xl-5{padding-right:3rem!important}.pb-xl-5,.py-xl-5{padding-bottom:3rem!important}.pl-xl-5,.px-xl-5{padding-left:3rem!important}.m-xl-n1{margin:-.25rem!important}.mt-xl-n1,.my-xl-n1{margin-top:-.25rem!important}.mr-xl-n1,.mx-xl-n1{margin-right:-.25rem!important}.mb-xl-n1,.my-xl-n1{margin-bottom:-.25rem!important}.ml-xl-n1,.mx-xl-n1{margin-left:-.25rem!important}.m-xl-n2{margin:-.5rem!important}.mt-xl-n2,.my-xl-n2{margin-top:-.5rem!important}.mr-xl-n2,.mx-xl-n2{margin-right:-.5rem!important}.mb-xl-n2,.my-xl-n2{margin-bottom:-.5rem!important}.ml-xl-n2,.mx-xl-n2{margin-left:-.5rem!important}.m-xl-n3{margin:-1rem!important}.mt-xl-n3,.my-xl-n3{margin-top:-1rem!important}.mr-xl-n3,.mx-xl-n3{margin-right:-1rem!important}.mb-xl-n3,.my-xl-n3{margin-bottom:-1rem!important}.ml-xl-n3,.mx-xl-n3{margin-left:-1rem!important}.m-xl-n4{margin:-1.5rem!important}.mt-xl-n4,.my-xl-n4{margin-top:-1.5rem!important}.mr-xl-n4,.mx-xl-n4{margin-right:-1.5rem!important}.mb-xl-n4,.my-xl-n4{margin-bottom:-1.5rem!important}.ml-xl-n4,.mx-xl-n4{margin-left:-1.5rem!important}.m-xl-n5{margin:-3rem!important}.mt-xl-n5,.my-xl-n5{margin-top:-3rem!important}.mr-xl-n5,.mx-xl-n5{margin-right:-3rem!important}.mb-xl-n5,.my-xl-n5{margin-bottom:-3rem!important}.ml-xl-n5,.mx-xl-n5{margin-left:-3rem!important}.m-xl-auto{margin:auto!important}.mt-xl-auto,.my-xl-auto{margin-top:auto!important}.mr-xl-auto,.mx-xl-auto{margin-right:auto!important}.mb-xl-auto,.my-xl-auto{margin-bottom:auto!important}.ml-xl-auto,.mx-xl-auto{margin-left:auto!important}}.stretched-link:after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;pointer-events:auto;content:"";background-color:transparent}.text-monospace{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace!important}.text-justify{text-align:justify!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.text-left{text-align:left!important}.text-right{text-align:right!important}.text-center{text-align:center!important}@media (min-width:540px){.text-sm-left{text-align:left!important}.text-sm-right{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:720px){.text-md-left{text-align:left!important}.text-md-right{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:960px){.text-lg-left{text-align:left!important}.text-lg-right{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.text-xl-left{text-align:left!important}.text-xl-right{text-align:right!important}.text-xl-center{text-align:center!important}}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.font-weight-light{font-weight:300!important}.font-weight-lighter{font-weight:lighter!important}.font-weight-normal{font-weight:400!important}.font-weight-bold{font-weight:700!important}.font-weight-bolder{font-weight:bolder!important}.font-italic{font-style:italic!important}.text-white{color:#fff!important}.text-primary{color:#007bff!important}a.text-primary:focus,a.text-primary:hover{color:#0056b3!important}.text-secondary{color:#6c757d!important}a.text-secondary:focus,a.text-secondary:hover{color:#494f54!important}.text-success{color:#28a745!important}a.text-success:focus,a.text-success:hover{color:#19692c!important}.text-info{color:#17a2b8!important}a.text-info:focus,a.text-info:hover{color:#0f6674!important}.text-warning{color:#ffc107!important}a.text-warning:focus,a.text-warning:hover{color:#ba8b00!important}.text-danger{color:#dc3545!important}a.text-danger:focus,a.text-danger:hover{color:#a71d2a!important}.text-light{color:#f8f9fa!important}a.text-light:focus,a.text-light:hover{color:#cbd3da!important}.text-dark{color:#343a40!important}a.text-dark:focus,a.text-dark:hover{color:#121416!important}.text-body{color:#212529!important}.text-muted{color:#6c757d!important}.text-black-50{color:rgba(0,0,0,.5)!important}.text-white-50{color:hsla(0,0%,100%,.5)!important}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.text-decoration-none{text-decoration:none!important}.text-break{word-wrap:break-word!important}.text-reset{color:inherit!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}@media print{*,:after,:before{text-shadow:none!important;box-shadow:none!important}a:not(.btn){text-decoration:underline}abbr[title]:after{content:" (" attr(title) ")"}pre{white-space:pre-wrap!important}blockquote,pre{border:1px solid #adb5bd;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}@page{size:a3}.container,body{min-width:960px!important}.navbar{display:none}.badge{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #dee2e6!important}.table-dark{color:inherit}.table-dark tbody+tbody,.table-dark td,.table-dark th,.table-dark thead th{border-color:#dee2e6}.table .thead-dark th{color:inherit;border-color:#dee2e6}}html{font-size:var(--pst-font-size-base);scroll-padding-top:calc(var(--pst-header-height) + 12px)}body{padding-top:calc(var(--pst-header-height) + 20px);background-color:#fff;font-family:var(--pst-font-family-base);font-weight:400;line-height:1.65;color:rgba(var(--pst-color-text-base),1)}p{margin-bottom:1.15rem;font-size:1em;color:rgba(var(--pst-color-paragraph),1)}p.rubric{border-bottom:1px solid #c9c9c9}a{color:rgba(var(--pst-color-link),1);text-decoration:none}a:hover{color:rgba(var(--pst-color-link-hover),1);text-decoration:underline}a.headerlink{color:rgba(var(--pst-color-headerlink),1);font-size:.8em;padding:0 4px;text-decoration:none}a.headerlink:hover{background-color:rgba(var(--pst-color-headerlink),1);color:rgba(var(--pst-color-headerlink-hover),1)}.heading-style,h1,h2,h3,h4,h5,h6{margin:2.75rem 0 1.05rem;font-family:var(--pst-font-family-heading);font-weight:400;line-height:1.15}h1{margin-top:0;font-size:var(--pst-font-size-h1);color:rgba(var(--pst-color-h1),1)}h2{font-size:var(--pst-font-size-h2);color:rgba(var(--pst-color-h2),1)}h3{font-size:var(--pst-font-size-h3);color:rgba(var(--pst-color-h3),1)}h4{font-size:var(--pst-font-size-h4);color:rgba(var(--pst-color-h4),1)}h5{font-size:var(--pst-font-size-h5);color:rgba(var(--pst-color-h5),1)}h6{font-size:var(--pst-font-size-h6);color:rgba(var(--pst-color-h6),1)}.text_small,small{font-size:var(--pst-font-size-milli)}hr{border:0;border-top:1px solid #e5e5e5}code,kbd,pre,samp{font-family:var(--pst-font-family-monospace)}code{color:rgba(var(--pst-color-inline-code),1)}pre{margin:1.5em 0;padding:10px;background-color:rgba(var(--pst-color-preformatted-background),1);color:rgba(var(--pst-color-preformatted-text),1);line-height:1.2em;border:1px solid #c9c9c9;border-radius:.2rem;box-shadow:1px 1px 1px #d8d8d8}dd{margin-top:3px;margin-bottom:10px;margin-left:30px}.navbar{position:fixed;min-height:var(--pst-header-height);width:100%;padding:0}.navbar .container-xl{height:100%}@media (min-width:960px){.navbar #navbar-end>.navbar-end-item{display:inline-block}}.navbar-brand{position:relative;height:var(--pst-header-height);width:auto;padding:.5rem 0}.navbar-brand img{max-width:100%;height:100%;width:auto}.navbar-light{background:#fff!important;box-shadow:0 .125rem .25rem 0 rgba(0,0,0,.11)}.navbar-light .navbar-nav li a.nav-link{padding:0 .5rem;color:rgba(var(--pst-color-navbar-link),1)}.navbar-light .navbar-nav li a.nav-link:hover{color:rgba(var(--pst-color-navbar-link-hover),1)}.navbar-light .navbar-nav>.active>.nav-link{font-weight:600;color:rgba(var(--pst-color-navbar-link-active),1)}.navbar-header a{padding:0 15px}.admonition,div.admonition{margin:1.5625em auto;padding:0 .6rem .8rem;overflow:hidden;page-break-inside:avoid;border-left:.2rem solid;border-left-color:rgba(var(--pst-color-admonition-default),1);border-bottom-color:rgba(var(--pst-color-admonition-default),1);border-right-color:rgba(var(--pst-color-admonition-default),1);border-top-color:rgba(var(--pst-color-admonition-default),1);border-radius:.2rem;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1);transition:color .25s,background-color .25s,border-color .25s}.admonition :last-child,div.admonition :last-child{margin-bottom:0}.admonition p.admonition-title~*,div.admonition p.admonition-title~*{padding:0 1.4rem}.admonition>ol,.admonition>ul,div.admonition>ol,div.admonition>ul{margin-left:1em}.admonition>.admonition-title,div.admonition>.admonition-title{position:relative;margin:0 -.6rem;padding:.4rem .6rem .4rem 2rem;font-weight:700;background-color:rgba(var(--pst-color-admonition-default),.1)}.admonition>.admonition-title:before,div.admonition>.admonition-title:before{position:absolute;left:.6rem;width:1rem;height:1rem;color:rgba(var(--pst-color-admonition-default),1);font-family:Font Awesome\ 5 Free;font-weight:900;content:var(--pst-icon-admonition-default)}.admonition>.admonition-title+*,div.admonition>.admonition-title+*{margin-top:.4em}.admonition.attention,div.admonition.attention{border-color:rgba(var(--pst-color-admonition-attention),1)}.admonition.attention>.admonition-title,div.admonition.attention>.admonition-title{background-color:rgba(var(--pst-color-admonition-attention),.1)}.admonition.attention>.admonition-title:before,div.admonition.attention>.admonition-title:before{color:rgba(var(--pst-color-admonition-attention),1);content:var(--pst-icon-admonition-attention)}.admonition.caution,div.admonition.caution{border-color:rgba(var(--pst-color-admonition-caution),1)}.admonition.caution>.admonition-title,div.admonition.caution>.admonition-title{background-color:rgba(var(--pst-color-admonition-caution),.1)}.admonition.caution>.admonition-title:before,div.admonition.caution>.admonition-title:before{color:rgba(var(--pst-color-admonition-caution),1);content:var(--pst-icon-admonition-caution)}.admonition.warning,div.admonition.warning{border-color:rgba(var(--pst-color-admonition-warning),1)}.admonition.warning>.admonition-title,div.admonition.warning>.admonition-title{background-color:rgba(var(--pst-color-admonition-warning),.1)}.admonition.warning>.admonition-title:before,div.admonition.warning>.admonition-title:before{color:rgba(var(--pst-color-admonition-warning),1);content:var(--pst-icon-admonition-warning)}.admonition.danger,div.admonition.danger{border-color:rgba(var(--pst-color-admonition-danger),1)}.admonition.danger>.admonition-title,div.admonition.danger>.admonition-title{background-color:rgba(var(--pst-color-admonition-danger),.1)}.admonition.danger>.admonition-title:before,div.admonition.danger>.admonition-title:before{color:rgba(var(--pst-color-admonition-danger),1);content:var(--pst-icon-admonition-danger)}.admonition.error,div.admonition.error{border-color:rgba(var(--pst-color-admonition-error),1)}.admonition.error>.admonition-title,div.admonition.error>.admonition-title{background-color:rgba(var(--pst-color-admonition-error),.1)}.admonition.error>.admonition-title:before,div.admonition.error>.admonition-title:before{color:rgba(var(--pst-color-admonition-error),1);content:var(--pst-icon-admonition-error)}.admonition.hint,div.admonition.hint{border-color:rgba(var(--pst-color-admonition-hint),1)}.admonition.hint>.admonition-title,div.admonition.hint>.admonition-title{background-color:rgba(var(--pst-color-admonition-hint),.1)}.admonition.hint>.admonition-title:before,div.admonition.hint>.admonition-title:before{color:rgba(var(--pst-color-admonition-hint),1);content:var(--pst-icon-admonition-hint)}.admonition.tip,div.admonition.tip{border-color:rgba(var(--pst-color-admonition-tip),1)}.admonition.tip>.admonition-title,div.admonition.tip>.admonition-title{background-color:rgba(var(--pst-color-admonition-tip),.1)}.admonition.tip>.admonition-title:before,div.admonition.tip>.admonition-title:before{color:rgba(var(--pst-color-admonition-tip),1);content:var(--pst-icon-admonition-tip)}.admonition.important,div.admonition.important{border-color:rgba(var(--pst-color-admonition-important),1)}.admonition.important>.admonition-title,div.admonition.important>.admonition-title{background-color:rgba(var(--pst-color-admonition-important),.1)}.admonition.important>.admonition-title:before,div.admonition.important>.admonition-title:before{color:rgba(var(--pst-color-admonition-important),1);content:var(--pst-icon-admonition-important)}.admonition.note,div.admonition.note{border-color:rgba(var(--pst-color-admonition-note),1)}.admonition.note>.admonition-title,div.admonition.note>.admonition-title{background-color:rgba(var(--pst-color-admonition-note),.1)}.admonition.note>.admonition-title:before,div.admonition.note>.admonition-title:before{color:rgba(var(--pst-color-admonition-note),1);content:var(--pst-icon-admonition-note)}table.field-list{border-collapse:separate;border-spacing:10px;margin-left:1px}table.field-list th.field-name{padding:1px 8px 1px 5px;white-space:nowrap;background-color:#eee}table.field-list td.field-body p{font-style:italic}table.field-list td.field-body p>strong{font-style:normal}table.field-list td.field-body blockquote{border-left:none;margin:0 0 .3em;padding-left:30px}.table.autosummary td:first-child{white-space:nowrap}.sig{font-family:var(--pst-font-family-monospace)}.sig-inline.c-texpr,.sig-inline.cpp-texpr{font-family:unset}.sig.c .k,.sig.c .kt,.sig.c .m,.sig.c .s,.sig.c .sc,.sig.cpp .k,.sig.cpp .kt,.sig.cpp .m,.sig.cpp .s,.sig.cpp .sc{color:rgba(var(--pst-color-text-base),1)}.sig-name{color:rgba(var(--pst-color-inline-code),1)}blockquote{padding:0 1em;color:#6a737d;border-left:.25em solid #dfe2e5}dt.label>span.brackets:not(:only-child):before{content:"["}dt.label>span.brackets:not(:only-child):after{content:"]"}a.footnote-reference{vertical-align:super;font-size:small}div.deprecated{margin-bottom:10px;margin-top:10px;padding:7px;background-color:#f3e5e5;border:1px solid #eed3d7;border-radius:.5rem}div.deprecated p{color:#b94a48;display:inline}.topic{background-color:#eee}.seealso dd{margin-top:0;margin-bottom:0}.viewcode-back{font-family:var(--pst-font-family-base)}.viewcode-block:target{background-color:#f4debf;border-top:1px solid #ac9;border-bottom:1px solid #ac9}span.guilabel{border:1px solid #7fbbe3;background:#e7f2fa;font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}footer{width:100%;border-top:1px solid #ccc;padding:10px}footer .footer-item p{margin-bottom:0}.bd-search{position:relative;padding:1rem 15px;margin-right:-15px;margin-left:-15px}.bd-search .icon{position:absolute;color:#a4a6a7;left:25px;top:25px}.bd-search input{border-radius:0;border:0;border-bottom:1px solid #e5e5e5;padding-left:35px}.bd-toc{-ms-flex-order:2;order:2;height:calc(100vh - 2rem);overflow-y:auto}@supports (position:-webkit-sticky) or (position:sticky){.bd-toc{position:-webkit-sticky;position:sticky;top:calc(var(--pst-header-height) + 20px);height:calc(100vh - 5rem);overflow-y:auto}}.bd-toc .onthispage{color:#a4a6a7}.section-nav{padding-left:0;border-left:1px solid #eee;border-bottom:none}.section-nav ul{padding-left:1rem}.toc-entry,.toc-entry a{display:block}.toc-entry a{padding:.125rem 1.5rem;color:rgba(var(--pst-color-toc-link),1)}@media (min-width:1200px){.toc-entry a{padding-right:0}}.toc-entry a:hover{color:rgba(var(--pst-color-toc-link-hover),1);text-decoration:none}.bd-sidebar{padding-top:1em}@media (min-width:720px){.bd-sidebar{border-right:1px solid rgba(0,0,0,.1)}@supports (position:-webkit-sticky) or (position:sticky){.bd-sidebar{position:-webkit-sticky;position:sticky;top:calc(var(--pst-header-height) + 20px);z-index:1000;height:calc(100vh - var(--pst-header-height) - 20px)}}}.bd-sidebar.no-sidebar{border-right:0}.bd-links{padding-top:1rem;padding-bottom:1rem;margin-right:-15px;margin-left:-15px}@media (min-width:720px){.bd-links{display:block}@supports (position:-webkit-sticky) or (position:sticky){.bd-links{max-height:calc(100vh - 11rem);overflow-y:auto}}}.bd-sidenav{display:none}.bd-content{padding-top:20px}.bd-content .section{max-width:100%}.bd-content .section table{display:block;overflow:auto}.bd-toc-link{display:block;padding:.25rem 1.5rem;font-weight:600;color:rgba(0,0,0,.65)}.bd-toc-link:hover{color:rgba(0,0,0,.85);text-decoration:none}.bd-toc-item.active{margin-bottom:1rem}.bd-toc-item.active:not(:first-child){margin-top:1rem}.bd-toc-item.active>.bd-toc-link{color:rgba(0,0,0,.85)}.bd-toc-item.active>.bd-toc-link:hover{background-color:transparent}.bd-toc-item.active>.bd-sidenav{display:block}nav.bd-links p.caption{font-size:var(--pst-sidebar-caption-font-size);text-transform:uppercase;font-weight:700;position:relative;margin-top:1.25em;margin-bottom:.5em;padding:0 1.5rem;color:rgba(var(--pst-color-sidebar-caption),1)}nav.bd-links p.caption:first-child{margin-top:0}.bd-sidebar .nav{font-size:var(--pst-sidebar-font-size)}.bd-sidebar .nav ul{list-style:none;padding:0 0 0 1.5rem}.bd-sidebar .nav li>a{display:block;padding:.25rem 1.5rem;color:rgba(var(--pst-color-sidebar-link),1)}.bd-sidebar .nav li>a:hover{color:rgba(var(--pst-color-sidebar-link-hover),1);text-decoration:none;background-color:transparent}.bd-sidebar .nav li>a.reference.external:after{font-family:Font Awesome\ 5 Free;font-weight:900;content:"\f35d";font-size:.75em;margin-left:.3em}.bd-sidebar .nav .active:hover>a,.bd-sidebar .nav .active>a{font-weight:600;color:rgba(var(--pst-color-sidebar-link-active),1)}.toc-h2{font-size:.85rem}.toc-h3{font-size:.75rem}.toc-h4{font-size:.65rem}.toc-entry>.nav-link.active{font-weight:600;color:#130654;color:rgba(var(--pst-color-toc-link-active),1);background-color:transparent;border-left:2px solid rgba(var(--pst-color-toc-link-active),1)}.nav-link:hover{border-style:none}#navbar-main-elements li.nav-item i{font-size:.7rem;padding-left:2px;vertical-align:middle}.bd-toc .nav .nav{display:none}.bd-toc .nav .nav.visible,.bd-toc .nav>.active>ul{display:block}.prev-next-area{margin:20px 0}.prev-next-area p{margin:0 .3em;line-height:1.3em}.prev-next-area i{font-size:1.2em}.prev-next-area a{display:flex;align-items:center;border:none;padding:10px;max-width:45%;overflow-x:hidden;color:rgba(0,0,0,.65);text-decoration:none}.prev-next-area a p.prev-next-title{color:rgba(var(--pst-color-link),1);font-weight:600;font-size:1.1em}.prev-next-area a:hover p.prev-next-title{text-decoration:underline}.prev-next-area a .prev-next-info{flex-direction:column;margin:0 .5em}.prev-next-area a .prev-next-info .prev-next-subtitle{text-transform:capitalize}.prev-next-area a.left-prev{float:left}.prev-next-area a.right-next{float:right}.prev-next-area a.right-next div.prev-next-info{text-align:right}.alert{padding-bottom:0}.alert-info a{color:#e83e8c}#navbar-icon-links i.fa,#navbar-icon-links i.fab,#navbar-icon-links i.far,#navbar-icon-links i.fas{vertical-align:middle;font-style:normal;font-size:1.5rem;line-height:1.25}#navbar-icon-links i.fa-github-square:before{color:#333}#navbar-icon-links i.fa-twitter-square:before{color:#55acee}#navbar-icon-links i.fa-gitlab:before{color:#548}#navbar-icon-links i.fa-bitbucket:before{color:#0052cc}.tocsection{border-left:1px solid #eee;padding:.3rem 1.5rem}.tocsection i{padding-right:.5rem}.editthispage{padding-top:2rem}.editthispage a{color:var(--pst-color-sidebar-link-active)}.xr-wrap[hidden]{display:block!important}.toctree-checkbox{position:absolute;display:none}.toctree-checkbox~ul{display:none}.toctree-checkbox~label i{transform:rotate(0deg)}.toctree-checkbox:checked~ul{display:block}.toctree-checkbox:checked~label i{transform:rotate(180deg)}.bd-sidebar li{position:relative}.bd-sidebar label{position:absolute;top:0;right:0;height:30px;width:30px;cursor:pointer;display:flex;justify-content:center;align-items:center}.bd-sidebar label:hover{background:rgba(var(--pst-color-sidebar-expander-background-hover),1)}.bd-sidebar label i{display:inline-block;font-size:.75rem;text-align:center}.bd-sidebar label i:hover{color:rgba(var(--pst-color-sidebar-link-hover),1)}.bd-sidebar li.has-children>.reference{padding-right:30px}div.doctest>div.highlight span.gp,span.linenos,table.highlighttable td.linenos{user-select:none;-webkit-user-select:text;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none}.docutils.container{padding-left:unset;padding-right:unset} diff --git a/book/content/_build/html/_static/css/theme.css b/book/content/_build/html/_static/css/theme.css deleted file mode 100644 index 437e428d..00000000 --- a/book/content/_build/html/_static/css/theme.css +++ /dev/null @@ -1,120 +0,0 @@ -/* Provided by the Sphinx base theme template at build time */ -@import "../basic.css"; - -:root { - /***************************************************************************** - * Theme config - **/ - --pst-header-height: 60px; - - /***************************************************************************** - * Font size - **/ - --pst-font-size-base: 15px; /* base font size - applied at body / html level */ - - /* heading font sizes */ - --pst-font-size-h1: 36px; - --pst-font-size-h2: 32px; - --pst-font-size-h3: 26px; - --pst-font-size-h4: 21px; - --pst-font-size-h5: 18px; - --pst-font-size-h6: 16px; - - /* smaller then heading font sizes*/ - --pst-font-size-milli: 12px; - - --pst-sidebar-font-size: .9em; - --pst-sidebar-caption-font-size: .9em; - - /***************************************************************************** - * Font family - **/ - /* These are adapted from https://systemfontstack.com/ */ - --pst-font-family-base-system: -apple-system, BlinkMacSystemFont, Segoe UI, "Helvetica Neue", - Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol; - --pst-font-family-monospace-system: "SFMono-Regular", Menlo, Consolas, Monaco, - Liberation Mono, Lucida Console, monospace; - - --pst-font-family-base: var(--pst-font-family-base-system); - --pst-font-family-heading: var(--pst-font-family-base); - --pst-font-family-monospace: var(--pst-font-family-monospace-system); - - /***************************************************************************** - * Color - * - * Colors are defined in rgb string way, "red, green, blue" - **/ - --pst-color-primary: 19, 6, 84; - --pst-color-success: 40, 167, 69; - --pst-color-info: 0, 123, 255; /*23, 162, 184;*/ - --pst-color-warning: 255, 193, 7; - --pst-color-danger: 220, 53, 69; - --pst-color-text-base: 51, 51, 51; - - --pst-color-h1: var(--pst-color-primary); - --pst-color-h2: var(--pst-color-primary); - --pst-color-h3: var(--pst-color-text-base); - --pst-color-h4: var(--pst-color-text-base); - --pst-color-h5: var(--pst-color-text-base); - --pst-color-h6: var(--pst-color-text-base); - --pst-color-paragraph: var(--pst-color-text-base); - --pst-color-link: 0, 91, 129; - --pst-color-link-hover: 227, 46, 0; - --pst-color-headerlink: 198, 15, 15; - --pst-color-headerlink-hover: 255, 255, 255; - --pst-color-preformatted-text: 34, 34, 34; - --pst-color-preformatted-background: 250, 250, 250; - --pst-color-inline-code: 232, 62, 140; - - --pst-color-active-navigation: 19, 6, 84; - --pst-color-navbar-link: 77, 77, 77; - --pst-color-navbar-link-hover: var(--pst-color-active-navigation); - --pst-color-navbar-link-active: var(--pst-color-active-navigation); - --pst-color-sidebar-link: 77, 77, 77; - --pst-color-sidebar-link-hover: var(--pst-color-active-navigation); - --pst-color-sidebar-link-active: var(--pst-color-active-navigation); - --pst-color-sidebar-expander-background-hover: 244, 244, 244; - --pst-color-sidebar-caption: 77, 77, 77; - --pst-color-toc-link: 119, 117, 122; - --pst-color-toc-link-hover: var(--pst-color-active-navigation); - --pst-color-toc-link-active: var(--pst-color-active-navigation); - - /***************************************************************************** - * Icon - **/ - - /* font awesome icons*/ - --pst-icon-check-circle: '\f058'; - --pst-icon-info-circle: '\f05a'; - --pst-icon-exclamation-triangle: '\f071'; - --pst-icon-exclamation-circle: '\f06a'; - --pst-icon-times-circle: '\f057'; - --pst-icon-lightbulb: '\f0eb'; - - /***************************************************************************** - * Admonitions - **/ - - --pst-color-admonition-default: var(--pst-color-info); - --pst-color-admonition-note: var(--pst-color-info); - --pst-color-admonition-attention: var(--pst-color-warning); - --pst-color-admonition-caution: var(--pst-color-warning); - --pst-color-admonition-warning: var(--pst-color-warning); - --pst-color-admonition-danger: var(--pst-color-danger); - --pst-color-admonition-error: var(--pst-color-danger); - --pst-color-admonition-hint: var(--pst-color-success); - --pst-color-admonition-tip: var(--pst-color-success); - --pst-color-admonition-important: var(--pst-color-success); - - --pst-icon-admonition-default: var(--pst-icon-info-circle); - --pst-icon-admonition-note: var(--pst-icon-info-circle); - --pst-icon-admonition-attention: var(--pst-icon-exclamation-circle); - --pst-icon-admonition-caution: var(--pst-icon-exclamation-triangle); - --pst-icon-admonition-warning: var(--pst-icon-exclamation-triangle); - --pst-icon-admonition-danger: var(--pst-icon-exclamation-triangle); - --pst-icon-admonition-error: var(--pst-icon-times-circle); - --pst-icon-admonition-hint: var(--pst-icon-lightbulb); - --pst-icon-admonition-tip: var(--pst-icon-lightbulb); - --pst-icon-admonition-important: var(--pst-icon-exclamation-circle); - -} diff --git a/book/content/_build/html/_static/doctools.js b/book/content/_build/html/_static/doctools.js deleted file mode 100644 index 8cbf1b16..00000000 --- a/book/content/_build/html/_static/doctools.js +++ /dev/null @@ -1,323 +0,0 @@ -/* - * doctools.js - * ~~~~~~~~~~~ - * - * Sphinx JavaScript utilities for all documentation. - * - * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * - */ - -/** - * select a different prefix for underscore - */ -$u = _.noConflict(); - -/** - * make the code below compatible with browsers without - * an installed firebug like debugger -if (!window.console || !console.firebug) { - var names = ["log", "debug", "info", "warn", "error", "assert", "dir", - "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", - "profile", "profileEnd"]; - window.console = {}; - for (var i = 0; i < names.length; ++i) - window.console[names[i]] = function() {}; -} - */ - -/** - * small helper function to urldecode strings - * - * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL - */ -jQuery.urldecode = function(x) { - if (!x) { - return x - } - return decodeURIComponent(x.replace(/\+/g, ' ')); -}; - -/** - * small helper function to urlencode strings - */ -jQuery.urlencode = encodeURIComponent; - -/** - * This function returns the parsed url parameters of the - * current request. Multiple values per key are supported, - * it will always return arrays of strings for the value parts. - */ -jQuery.getQueryParameters = function(s) { - if (typeof s === 'undefined') - s = document.location.search; - var parts = s.substr(s.indexOf('?') + 1).split('&'); - var result = {}; - for (var i = 0; i < parts.length; i++) { - var tmp = parts[i].split('=', 2); - var key = jQuery.urldecode(tmp[0]); - var value = jQuery.urldecode(tmp[1]); - if (key in result) - result[key].push(value); - else - result[key] = [value]; - } - return result; -}; - -/** - * highlight a given string on a jquery object by wrapping it in - * span elements with the given class name. - */ -jQuery.fn.highlightText = function(text, className) { - function highlight(node, addItems) { - if (node.nodeType === 3) { - var val = node.nodeValue; - var pos = val.toLowerCase().indexOf(text); - if (pos >= 0 && - !jQuery(node.parentNode).hasClass(className) && - !jQuery(node.parentNode).hasClass("nohighlight")) { - var span; - var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); - if (isInSVG) { - span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); - } else { - span = document.createElement("span"); - span.className = className; - } - span.appendChild(document.createTextNode(val.substr(pos, text.length))); - node.parentNode.insertBefore(span, node.parentNode.insertBefore( - document.createTextNode(val.substr(pos + text.length)), - node.nextSibling)); - node.nodeValue = val.substr(0, pos); - if (isInSVG) { - var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); - var bbox = node.parentElement.getBBox(); - rect.x.baseVal.value = bbox.x; - rect.y.baseVal.value = bbox.y; - rect.width.baseVal.value = bbox.width; - rect.height.baseVal.value = bbox.height; - rect.setAttribute('class', className); - addItems.push({ - "parent": node.parentNode, - "target": rect}); - } - } - } - else if (!jQuery(node).is("button, select, textarea")) { - jQuery.each(node.childNodes, function() { - highlight(this, addItems); - }); - } - } - var addItems = []; - var result = this.each(function() { - highlight(this, addItems); - }); - for (var i = 0; i < addItems.length; ++i) { - jQuery(addItems[i].parent).before(addItems[i].target); - } - return result; -}; - -/* - * backward compatibility for jQuery.browser - * This will be supported until firefox bug is fixed. - */ -if (!jQuery.browser) { - jQuery.uaMatch = function(ua) { - ua = ua.toLowerCase(); - - var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || - /(webkit)[ \/]([\w.]+)/.exec(ua) || - /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || - /(msie) ([\w.]+)/.exec(ua) || - ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || - []; - - return { - browser: match[ 1 ] || "", - version: match[ 2 ] || "0" - }; - }; - jQuery.browser = {}; - jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; -} - -/** - * Small JavaScript module for the documentation. - */ -var Documentation = { - - init : function() { - this.fixFirefoxAnchorBug(); - this.highlightSearchWords(); - this.initIndexTable(); - if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) { - this.initOnKeyListeners(); - } - }, - - /** - * i18n support - */ - TRANSLATIONS : {}, - PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; }, - LOCALE : 'unknown', - - // gettext and ngettext don't access this so that the functions - // can safely bound to a different name (_ = Documentation.gettext) - gettext : function(string) { - var translated = Documentation.TRANSLATIONS[string]; - if (typeof translated === 'undefined') - return string; - return (typeof translated === 'string') ? translated : translated[0]; - }, - - ngettext : function(singular, plural, n) { - var translated = Documentation.TRANSLATIONS[singular]; - if (typeof translated === 'undefined') - return (n == 1) ? singular : plural; - return translated[Documentation.PLURALEXPR(n)]; - }, - - addTranslations : function(catalog) { - for (var key in catalog.messages) - this.TRANSLATIONS[key] = catalog.messages[key]; - this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); - this.LOCALE = catalog.locale; - }, - - /** - * add context elements like header anchor links - */ - addContextElements : function() { - $('div[id] > :header:first').each(function() { - $('\u00B6'). - attr('href', '#' + this.id). - attr('title', _('Permalink to this headline')). - appendTo(this); - }); - $('dt[id]').each(function() { - $('\u00B6'). - attr('href', '#' + this.id). - attr('title', _('Permalink to this definition')). - appendTo(this); - }); - }, - - /** - * workaround a firefox stupidity - * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075 - */ - fixFirefoxAnchorBug : function() { - if (document.location.hash && $.browser.mozilla) - window.setTimeout(function() { - document.location.href += ''; - }, 10); - }, - - /** - * highlight the search words provided in the url in the text - */ - highlightSearchWords : function() { - var params = $.getQueryParameters(); - var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; - if (terms.length) { - var body = $('div.body'); - if (!body.length) { - body = $('body'); - } - window.setTimeout(function() { - $.each(terms, function() { - body.highlightText(this.toLowerCase(), 'highlighted'); - }); - }, 10); - $('') - .appendTo($('#searchbox')); - } - }, - - /** - * init the domain index toggle buttons - */ - initIndexTable : function() { - var togglers = $('img.toggler').click(function() { - var src = $(this).attr('src'); - var idnum = $(this).attr('id').substr(7); - $('tr.cg-' + idnum).toggle(); - if (src.substr(-9) === 'minus.png') - $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); - else - $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); - }).css('display', ''); - if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { - togglers.click(); - } - }, - - /** - * helper function to hide the search marks again - */ - hideSearchWords : function() { - $('#searchbox .highlight-link').fadeOut(300); - $('span.highlighted').removeClass('highlighted'); - }, - - /** - * make the url absolute - */ - makeURL : function(relativeURL) { - return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; - }, - - /** - * get the current relative url - */ - getCurrentURL : function() { - var path = document.location.pathname; - var parts = path.split(/\//); - $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { - if (this === '..') - parts.pop(); - }); - var url = parts.join('/'); - return path.substring(url.lastIndexOf('/') + 1, path.length - 1); - }, - - initOnKeyListeners: function() { - $(document).keydown(function(event) { - var activeElementType = document.activeElement.tagName; - // don't navigate when in search box, textarea, dropdown or button - if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT' - && activeElementType !== 'BUTTON' && !event.altKey && !event.ctrlKey && !event.metaKey - && !event.shiftKey) { - switch (event.keyCode) { - case 37: // left - var prevHref = $('link[rel="prev"]').prop('href'); - if (prevHref) { - window.location.href = prevHref; - return false; - } - break; - case 39: // right - var nextHref = $('link[rel="next"]').prop('href'); - if (nextHref) { - window.location.href = nextHref; - return false; - } - break; - } - } - }); - } -}; - -// quick alias for translations -_ = Documentation.gettext; - -$(document).ready(function() { - Documentation.init(); -}); diff --git a/book/content/_build/html/_static/documentation_options.js b/book/content/_build/html/_static/documentation_options.js deleted file mode 100644 index b6922816..00000000 --- a/book/content/_build/html/_static/documentation_options.js +++ /dev/null @@ -1,12 +0,0 @@ -var DOCUMENTATION_OPTIONS = { - URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), - VERSION: '', - LANGUAGE: 'None', - COLLAPSE_INDEX: false, - BUILDER: 'html', - FILE_SUFFIX: '.html', - LINK_SUFFIX: '.html', - HAS_SOURCE: true, - SOURCELINK_SUFFIX: '', - NAVIGATION_WITH_KEYS: true -}; diff --git a/book/content/_build/html/_static/file.png b/book/content/_build/html/_static/file.png deleted file mode 100644 index a858a410..00000000 Binary files a/book/content/_build/html/_static/file.png and /dev/null differ diff --git a/book/content/_build/html/_static/images/logo_binder.svg b/book/content/_build/html/_static/images/logo_binder.svg deleted file mode 100644 index 45fecf75..00000000 --- a/book/content/_build/html/_static/images/logo_binder.svg +++ /dev/null @@ -1,19 +0,0 @@ - - - - -logo - - - - - - - - diff --git a/book/content/_build/html/_static/images/logo_colab.png b/book/content/_build/html/_static/images/logo_colab.png deleted file mode 100644 index b7560ec2..00000000 Binary files a/book/content/_build/html/_static/images/logo_colab.png and /dev/null differ diff --git a/book/content/_build/html/_static/images/logo_jupyterhub.svg b/book/content/_build/html/_static/images/logo_jupyterhub.svg deleted file mode 100644 index 60cfe9f2..00000000 --- a/book/content/_build/html/_static/images/logo_jupyterhub.svg +++ /dev/null @@ -1 +0,0 @@ -logo_jupyterhubHub diff --git a/book/content/_build/html/_static/jquery-3.5.1.js b/book/content/_build/html/_static/jquery-3.5.1.js deleted file mode 100644 index 50937333..00000000 --- a/book/content/_build/html/_static/jquery-3.5.1.js +++ /dev/null @@ -1,10872 +0,0 @@ -/*! - * jQuery JavaScript Library v3.5.1 - * https://jquery.com/ - * - * Includes Sizzle.js - * https://sizzlejs.com/ - * - * Copyright JS Foundation and other contributors - * Released under the MIT license - * https://jquery.org/license - * - * Date: 2020-05-04T22:49Z - */ -( function( global, factory ) { - - "use strict"; - - if ( typeof module === "object" && typeof module.exports === "object" ) { - - // For CommonJS and CommonJS-like environments where a proper `window` - // is present, execute the factory and get jQuery. - // For environments that do not have a `window` with a `document` - // (such as Node.js), expose a factory as module.exports. - // This accentuates the need for the creation of a real `window`. - // e.g. var jQuery = require("jquery")(window); - // See ticket #14549 for more info. - module.exports = global.document ? - factory( global, true ) : - function( w ) { - if ( !w.document ) { - throw new Error( "jQuery requires a window with a document" ); - } - return factory( w ); - }; - } else { - factory( global ); - } - -// Pass this if window is not defined yet -} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { - -// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 -// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode -// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common -// enough that all such attempts are guarded in a try block. -"use strict"; - -var arr = []; - -var getProto = Object.getPrototypeOf; - -var slice = arr.slice; - -var flat = arr.flat ? function( array ) { - return arr.flat.call( array ); -} : function( array ) { - return arr.concat.apply( [], array ); -}; - - -var push = arr.push; - -var indexOf = arr.indexOf; - -var class2type = {}; - -var toString = class2type.toString; - -var hasOwn = class2type.hasOwnProperty; - -var fnToString = hasOwn.toString; - -var ObjectFunctionString = fnToString.call( Object ); - -var support = {}; - -var isFunction = function isFunction( obj ) { - - // Support: Chrome <=57, Firefox <=52 - // In some browsers, typeof returns "function" for HTML elements - // (i.e., `typeof document.createElement( "object" ) === "function"`). - // We don't want to classify *any* DOM node as a function. - return typeof obj === "function" && typeof obj.nodeType !== "number"; - }; - - -var isWindow = function isWindow( obj ) { - return obj != null && obj === obj.window; - }; - - -var document = window.document; - - - - var preservedScriptAttributes = { - type: true, - src: true, - nonce: true, - noModule: true - }; - - function DOMEval( code, node, doc ) { - doc = doc || document; - - var i, val, - script = doc.createElement( "script" ); - - script.text = code; - if ( node ) { - for ( i in preservedScriptAttributes ) { - - // Support: Firefox 64+, Edge 18+ - // Some browsers don't support the "nonce" property on scripts. - // On the other hand, just using `getAttribute` is not enough as - // the `nonce` attribute is reset to an empty string whenever it - // becomes browsing-context connected. - // See https://github.com/whatwg/html/issues/2369 - // See https://html.spec.whatwg.org/#nonce-attributes - // The `node.getAttribute` check was added for the sake of - // `jQuery.globalEval` so that it can fake a nonce-containing node - // via an object. - val = node[ i ] || node.getAttribute && node.getAttribute( i ); - if ( val ) { - script.setAttribute( i, val ); - } - } - } - doc.head.appendChild( script ).parentNode.removeChild( script ); - } - - -function toType( obj ) { - if ( obj == null ) { - return obj + ""; - } - - // Support: Android <=2.3 only (functionish RegExp) - return typeof obj === "object" || typeof obj === "function" ? - class2type[ toString.call( obj ) ] || "object" : - typeof obj; -} -/* global Symbol */ -// Defining this global in .eslintrc.json would create a danger of using the global -// unguarded in another place, it seems safer to define global only for this module - - - -var - version = "3.5.1", - - // Define a local copy of jQuery - jQuery = function( selector, context ) { - - // The jQuery object is actually just the init constructor 'enhanced' - // Need init if jQuery is called (just allow error to be thrown if not included) - return new jQuery.fn.init( selector, context ); - }; - -jQuery.fn = jQuery.prototype = { - - // The current version of jQuery being used - jquery: version, - - constructor: jQuery, - - // The default length of a jQuery object is 0 - length: 0, - - toArray: function() { - return slice.call( this ); - }, - - // Get the Nth element in the matched element set OR - // Get the whole matched element set as a clean array - get: function( num ) { - - // Return all the elements in a clean array - if ( num == null ) { - return slice.call( this ); - } - - // Return just the one element from the set - return num < 0 ? this[ num + this.length ] : this[ num ]; - }, - - // Take an array of elements and push it onto the stack - // (returning the new matched element set) - pushStack: function( elems ) { - - // Build a new jQuery matched element set - var ret = jQuery.merge( this.constructor(), elems ); - - // Add the old object onto the stack (as a reference) - ret.prevObject = this; - - // Return the newly-formed element set - return ret; - }, - - // Execute a callback for every element in the matched set. - each: function( callback ) { - return jQuery.each( this, callback ); - }, - - map: function( callback ) { - return this.pushStack( jQuery.map( this, function( elem, i ) { - return callback.call( elem, i, elem ); - } ) ); - }, - - slice: function() { - return this.pushStack( slice.apply( this, arguments ) ); - }, - - first: function() { - return this.eq( 0 ); - }, - - last: function() { - return this.eq( -1 ); - }, - - even: function() { - return this.pushStack( jQuery.grep( this, function( _elem, i ) { - return ( i + 1 ) % 2; - } ) ); - }, - - odd: function() { - return this.pushStack( jQuery.grep( this, function( _elem, i ) { - return i % 2; - } ) ); - }, - - eq: function( i ) { - var len = this.length, - j = +i + ( i < 0 ? len : 0 ); - return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); - }, - - end: function() { - return this.prevObject || this.constructor(); - }, - - // For internal use only. - // Behaves like an Array's method, not like a jQuery method. - push: push, - sort: arr.sort, - splice: arr.splice -}; - -jQuery.extend = jQuery.fn.extend = function() { - var options, name, src, copy, copyIsArray, clone, - target = arguments[ 0 ] || {}, - i = 1, - length = arguments.length, - deep = false; - - // Handle a deep copy situation - if ( typeof target === "boolean" ) { - deep = target; - - // Skip the boolean and the target - target = arguments[ i ] || {}; - i++; - } - - // Handle case when target is a string or something (possible in deep copy) - if ( typeof target !== "object" && !isFunction( target ) ) { - target = {}; - } - - // Extend jQuery itself if only one argument is passed - if ( i === length ) { - target = this; - i--; - } - - for ( ; i < length; i++ ) { - - // Only deal with non-null/undefined values - if ( ( options = arguments[ i ] ) != null ) { - - // Extend the base object - for ( name in options ) { - copy = options[ name ]; - - // Prevent Object.prototype pollution - // Prevent never-ending loop - if ( name === "__proto__" || target === copy ) { - continue; - } - - // Recurse if we're merging plain objects or arrays - if ( deep && copy && ( jQuery.isPlainObject( copy ) || - ( copyIsArray = Array.isArray( copy ) ) ) ) { - src = target[ name ]; - - // Ensure proper type for the source value - if ( copyIsArray && !Array.isArray( src ) ) { - clone = []; - } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { - clone = {}; - } else { - clone = src; - } - copyIsArray = false; - - // Never move original objects, clone them - target[ name ] = jQuery.extend( deep, clone, copy ); - - // Don't bring in undefined values - } else if ( copy !== undefined ) { - target[ name ] = copy; - } - } - } - } - - // Return the modified object - return target; -}; - -jQuery.extend( { - - // Unique for each copy of jQuery on the page - expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), - - // Assume jQuery is ready without the ready module - isReady: true, - - error: function( msg ) { - throw new Error( msg ); - }, - - noop: function() {}, - - isPlainObject: function( obj ) { - var proto, Ctor; - - // Detect obvious negatives - // Use toString instead of jQuery.type to catch host objects - if ( !obj || toString.call( obj ) !== "[object Object]" ) { - return false; - } - - proto = getProto( obj ); - - // Objects with no prototype (e.g., `Object.create( null )`) are plain - if ( !proto ) { - return true; - } - - // Objects with prototype are plain iff they were constructed by a global Object function - Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; - return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; - }, - - isEmptyObject: function( obj ) { - var name; - - for ( name in obj ) { - return false; - } - return true; - }, - - // Evaluates a script in a provided context; falls back to the global one - // if not specified. - globalEval: function( code, options, doc ) { - DOMEval( code, { nonce: options && options.nonce }, doc ); - }, - - each: function( obj, callback ) { - var length, i = 0; - - if ( isArrayLike( obj ) ) { - length = obj.length; - for ( ; i < length; i++ ) { - if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { - break; - } - } - } else { - for ( i in obj ) { - if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { - break; - } - } - } - - return obj; - }, - - // results is for internal usage only - makeArray: function( arr, results ) { - var ret = results || []; - - if ( arr != null ) { - if ( isArrayLike( Object( arr ) ) ) { - jQuery.merge( ret, - typeof arr === "string" ? - [ arr ] : arr - ); - } else { - push.call( ret, arr ); - } - } - - return ret; - }, - - inArray: function( elem, arr, i ) { - return arr == null ? -1 : indexOf.call( arr, elem, i ); - }, - - // Support: Android <=4.0 only, PhantomJS 1 only - // push.apply(_, arraylike) throws on ancient WebKit - merge: function( first, second ) { - var len = +second.length, - j = 0, - i = first.length; - - for ( ; j < len; j++ ) { - first[ i++ ] = second[ j ]; - } - - first.length = i; - - return first; - }, - - grep: function( elems, callback, invert ) { - var callbackInverse, - matches = [], - i = 0, - length = elems.length, - callbackExpect = !invert; - - // Go through the array, only saving the items - // that pass the validator function - for ( ; i < length; i++ ) { - callbackInverse = !callback( elems[ i ], i ); - if ( callbackInverse !== callbackExpect ) { - matches.push( elems[ i ] ); - } - } - - return matches; - }, - - // arg is for internal usage only - map: function( elems, callback, arg ) { - var length, value, - i = 0, - ret = []; - - // Go through the array, translating each of the items to their new values - if ( isArrayLike( elems ) ) { - length = elems.length; - for ( ; i < length; i++ ) { - value = callback( elems[ i ], i, arg ); - - if ( value != null ) { - ret.push( value ); - } - } - - // Go through every key on the object, - } else { - for ( i in elems ) { - value = callback( elems[ i ], i, arg ); - - if ( value != null ) { - ret.push( value ); - } - } - } - - // Flatten any nested arrays - return flat( ret ); - }, - - // A global GUID counter for objects - guid: 1, - - // jQuery.support is not used in Core but other projects attach their - // properties to it so it needs to exist. - support: support -} ); - -if ( typeof Symbol === "function" ) { - jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; -} - -// Populate the class2type map -jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), -function( _i, name ) { - class2type[ "[object " + name + "]" ] = name.toLowerCase(); -} ); - -function isArrayLike( obj ) { - - // Support: real iOS 8.2 only (not reproducible in simulator) - // `in` check used to prevent JIT error (gh-2145) - // hasOwn isn't used here due to false negatives - // regarding Nodelist length in IE - var length = !!obj && "length" in obj && obj.length, - type = toType( obj ); - - if ( isFunction( obj ) || isWindow( obj ) ) { - return false; - } - - return type === "array" || length === 0 || - typeof length === "number" && length > 0 && ( length - 1 ) in obj; -} -var Sizzle = -/*! - * Sizzle CSS Selector Engine v2.3.5 - * https://sizzlejs.com/ - * - * Copyright JS Foundation and other contributors - * Released under the MIT license - * https://js.foundation/ - * - * Date: 2020-03-14 - */ -( function( window ) { -var i, - support, - Expr, - getText, - isXML, - tokenize, - compile, - select, - outermostContext, - sortInput, - hasDuplicate, - - // Local document vars - setDocument, - document, - docElem, - documentIsHTML, - rbuggyQSA, - rbuggyMatches, - matches, - contains, - - // Instance-specific data - expando = "sizzle" + 1 * new Date(), - preferredDoc = window.document, - dirruns = 0, - done = 0, - classCache = createCache(), - tokenCache = createCache(), - compilerCache = createCache(), - nonnativeSelectorCache = createCache(), - sortOrder = function( a, b ) { - if ( a === b ) { - hasDuplicate = true; - } - return 0; - }, - - // Instance methods - hasOwn = ( {} ).hasOwnProperty, - arr = [], - pop = arr.pop, - pushNative = arr.push, - push = arr.push, - slice = arr.slice, - - // Use a stripped-down indexOf as it's faster than native - // https://jsperf.com/thor-indexof-vs-for/5 - indexOf = function( list, elem ) { - var i = 0, - len = list.length; - for ( ; i < len; i++ ) { - if ( list[ i ] === elem ) { - return i; - } - } - return -1; - }, - - booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" + - "ismap|loop|multiple|open|readonly|required|scoped", - - // Regular expressions - - // http://www.w3.org/TR/css3-selectors/#whitespace - whitespace = "[\\x20\\t\\r\\n\\f]", - - // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram - identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + - "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", - - // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors - attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + - - // Operator (capture 2) - "*([*^$|!~]?=)" + whitespace + - - // "Attribute values must be CSS identifiers [capture 5] - // or strings [capture 3 or capture 4]" - "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + - whitespace + "*\\]", - - pseudos = ":(" + identifier + ")(?:\\((" + - - // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: - // 1. quoted (capture 3; capture 4 or capture 5) - "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + - - // 2. simple (capture 6) - "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + - - // 3. anything else (capture 2) - ".*" + - ")\\)|)", - - // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter - rwhitespace = new RegExp( whitespace + "+", "g" ), - rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + - whitespace + "+$", "g" ), - - rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), - rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + - "*" ), - rdescend = new RegExp( whitespace + "|>" ), - - rpseudo = new RegExp( pseudos ), - ridentifier = new RegExp( "^" + identifier + "$" ), - - matchExpr = { - "ID": new RegExp( "^#(" + identifier + ")" ), - "CLASS": new RegExp( "^\\.(" + identifier + ")" ), - "TAG": new RegExp( "^(" + identifier + "|[*])" ), - "ATTR": new RegExp( "^" + attributes ), - "PSEUDO": new RegExp( "^" + pseudos ), - "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + - whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + - whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), - "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), - - // For use in libraries implementing .is() - // We use this for POS matching in `select` - "needsContext": new RegExp( "^" + whitespace + - "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + - "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) - }, - - rhtml = /HTML$/i, - rinputs = /^(?:input|select|textarea|button)$/i, - rheader = /^h\d$/i, - - rnative = /^[^{]+\{\s*\[native \w/, - - // Easily-parseable/retrievable ID or TAG or CLASS selectors - rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, - - rsibling = /[+~]/, - - // CSS escapes - // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters - runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ), - funescape = function( escape, nonHex ) { - var high = "0x" + escape.slice( 1 ) - 0x10000; - - return nonHex ? - - // Strip the backslash prefix from a non-hex escape sequence - nonHex : - - // Replace a hexadecimal escape sequence with the encoded Unicode code point - // Support: IE <=11+ - // For values outside the Basic Multilingual Plane (BMP), manually construct a - // surrogate pair - high < 0 ? - String.fromCharCode( high + 0x10000 ) : - String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); - }, - - // CSS string/identifier serialization - // https://drafts.csswg.org/cssom/#common-serializing-idioms - rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, - fcssescape = function( ch, asCodePoint ) { - if ( asCodePoint ) { - - // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER - if ( ch === "\0" ) { - return "\uFFFD"; - } - - // Control characters and (dependent upon position) numbers get escaped as code points - return ch.slice( 0, -1 ) + "\\" + - ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; - } - - // Other potentially-special ASCII characters get backslash-escaped - return "\\" + ch; - }, - - // Used for iframes - // See setDocument() - // Removing the function wrapper causes a "Permission Denied" - // error in IE - unloadHandler = function() { - setDocument(); - }, - - inDisabledFieldset = addCombinator( - function( elem ) { - return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; - }, - { dir: "parentNode", next: "legend" } - ); - -// Optimize for push.apply( _, NodeList ) -try { - push.apply( - ( arr = slice.call( preferredDoc.childNodes ) ), - preferredDoc.childNodes - ); - - // Support: Android<4.0 - // Detect silently failing push.apply - // eslint-disable-next-line no-unused-expressions - arr[ preferredDoc.childNodes.length ].nodeType; -} catch ( e ) { - push = { apply: arr.length ? - - // Leverage slice if possible - function( target, els ) { - pushNative.apply( target, slice.call( els ) ); - } : - - // Support: IE<9 - // Otherwise append directly - function( target, els ) { - var j = target.length, - i = 0; - - // Can't trust NodeList.length - while ( ( target[ j++ ] = els[ i++ ] ) ) {} - target.length = j - 1; - } - }; -} - -function Sizzle( selector, context, results, seed ) { - var m, i, elem, nid, match, groups, newSelector, - newContext = context && context.ownerDocument, - - // nodeType defaults to 9, since context defaults to document - nodeType = context ? context.nodeType : 9; - - results = results || []; - - // Return early from calls with invalid selector or context - if ( typeof selector !== "string" || !selector || - nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { - - return results; - } - - // Try to shortcut find operations (as opposed to filters) in HTML documents - if ( !seed ) { - setDocument( context ); - context = context || document; - - if ( documentIsHTML ) { - - // If the selector is sufficiently simple, try using a "get*By*" DOM method - // (excepting DocumentFragment context, where the methods don't exist) - if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { - - // ID selector - if ( ( m = match[ 1 ] ) ) { - - // Document context - if ( nodeType === 9 ) { - if ( ( elem = context.getElementById( m ) ) ) { - - // Support: IE, Opera, Webkit - // TODO: identify versions - // getElementById can match elements by name instead of ID - if ( elem.id === m ) { - results.push( elem ); - return results; - } - } else { - return results; - } - - // Element context - } else { - - // Support: IE, Opera, Webkit - // TODO: identify versions - // getElementById can match elements by name instead of ID - if ( newContext && ( elem = newContext.getElementById( m ) ) && - contains( context, elem ) && - elem.id === m ) { - - results.push( elem ); - return results; - } - } - - // Type selector - } else if ( match[ 2 ] ) { - push.apply( results, context.getElementsByTagName( selector ) ); - return results; - - // Class selector - } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName && - context.getElementsByClassName ) { - - push.apply( results, context.getElementsByClassName( m ) ); - return results; - } - } - - // Take advantage of querySelectorAll - if ( support.qsa && - !nonnativeSelectorCache[ selector + " " ] && - ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) && - - // Support: IE 8 only - // Exclude object elements - ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) { - - newSelector = selector; - newContext = context; - - // qSA considers elements outside a scoping root when evaluating child or - // descendant combinators, which is not what we want. - // In such cases, we work around the behavior by prefixing every selector in the - // list with an ID selector referencing the scope context. - // The technique has to be used as well when a leading combinator is used - // as such selectors are not recognized by querySelectorAll. - // Thanks to Andrew Dupont for this technique. - if ( nodeType === 1 && - ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) { - - // Expand context for sibling selectors - newContext = rsibling.test( selector ) && testContext( context.parentNode ) || - context; - - // We can use :scope instead of the ID hack if the browser - // supports it & if we're not changing the context. - if ( newContext !== context || !support.scope ) { - - // Capture the context ID, setting it first if necessary - if ( ( nid = context.getAttribute( "id" ) ) ) { - nid = nid.replace( rcssescape, fcssescape ); - } else { - context.setAttribute( "id", ( nid = expando ) ); - } - } - - // Prefix every selector in the list - groups = tokenize( selector ); - i = groups.length; - while ( i-- ) { - groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + - toSelector( groups[ i ] ); - } - newSelector = groups.join( "," ); - } - - try { - push.apply( results, - newContext.querySelectorAll( newSelector ) - ); - return results; - } catch ( qsaError ) { - nonnativeSelectorCache( selector, true ); - } finally { - if ( nid === expando ) { - context.removeAttribute( "id" ); - } - } - } - } - } - - // All others - return select( selector.replace( rtrim, "$1" ), context, results, seed ); -} - -/** - * Create key-value caches of limited size - * @returns {function(string, object)} Returns the Object data after storing it on itself with - * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) - * deleting the oldest entry - */ -function createCache() { - var keys = []; - - function cache( key, value ) { - - // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) - if ( keys.push( key + " " ) > Expr.cacheLength ) { - - // Only keep the most recent entries - delete cache[ keys.shift() ]; - } - return ( cache[ key + " " ] = value ); - } - return cache; -} - -/** - * Mark a function for special use by Sizzle - * @param {Function} fn The function to mark - */ -function markFunction( fn ) { - fn[ expando ] = true; - return fn; -} - -/** - * Support testing using an element - * @param {Function} fn Passed the created element and returns a boolean result - */ -function assert( fn ) { - var el = document.createElement( "fieldset" ); - - try { - return !!fn( el ); - } catch ( e ) { - return false; - } finally { - - // Remove from its parent by default - if ( el.parentNode ) { - el.parentNode.removeChild( el ); - } - - // release memory in IE - el = null; - } -} - -/** - * Adds the same handler for all of the specified attrs - * @param {String} attrs Pipe-separated list of attributes - * @param {Function} handler The method that will be applied - */ -function addHandle( attrs, handler ) { - var arr = attrs.split( "|" ), - i = arr.length; - - while ( i-- ) { - Expr.attrHandle[ arr[ i ] ] = handler; - } -} - -/** - * Checks document order of two siblings - * @param {Element} a - * @param {Element} b - * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b - */ -function siblingCheck( a, b ) { - var cur = b && a, - diff = cur && a.nodeType === 1 && b.nodeType === 1 && - a.sourceIndex - b.sourceIndex; - - // Use IE sourceIndex if available on both nodes - if ( diff ) { - return diff; - } - - // Check if b follows a - if ( cur ) { - while ( ( cur = cur.nextSibling ) ) { - if ( cur === b ) { - return -1; - } - } - } - - return a ? 1 : -1; -} - -/** - * Returns a function to use in pseudos for input types - * @param {String} type - */ -function createInputPseudo( type ) { - return function( elem ) { - var name = elem.nodeName.toLowerCase(); - return name === "input" && elem.type === type; - }; -} - -/** - * Returns a function to use in pseudos for buttons - * @param {String} type - */ -function createButtonPseudo( type ) { - return function( elem ) { - var name = elem.nodeName.toLowerCase(); - return ( name === "input" || name === "button" ) && elem.type === type; - }; -} - -/** - * Returns a function to use in pseudos for :enabled/:disabled - * @param {Boolean} disabled true for :disabled; false for :enabled - */ -function createDisabledPseudo( disabled ) { - - // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable - return function( elem ) { - - // Only certain elements can match :enabled or :disabled - // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled - // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled - if ( "form" in elem ) { - - // Check for inherited disabledness on relevant non-disabled elements: - // * listed form-associated elements in a disabled fieldset - // https://html.spec.whatwg.org/multipage/forms.html#category-listed - // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled - // * option elements in a disabled optgroup - // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled - // All such elements have a "form" property. - if ( elem.parentNode && elem.disabled === false ) { - - // Option elements defer to a parent optgroup if present - if ( "label" in elem ) { - if ( "label" in elem.parentNode ) { - return elem.parentNode.disabled === disabled; - } else { - return elem.disabled === disabled; - } - } - - // Support: IE 6 - 11 - // Use the isDisabled shortcut property to check for disabled fieldset ancestors - return elem.isDisabled === disabled || - - // Where there is no isDisabled, check manually - /* jshint -W018 */ - elem.isDisabled !== !disabled && - inDisabledFieldset( elem ) === disabled; - } - - return elem.disabled === disabled; - - // Try to winnow out elements that can't be disabled before trusting the disabled property. - // Some victims get caught in our net (label, legend, menu, track), but it shouldn't - // even exist on them, let alone have a boolean value. - } else if ( "label" in elem ) { - return elem.disabled === disabled; - } - - // Remaining elements are neither :enabled nor :disabled - return false; - }; -} - -/** - * Returns a function to use in pseudos for positionals - * @param {Function} fn - */ -function createPositionalPseudo( fn ) { - return markFunction( function( argument ) { - argument = +argument; - return markFunction( function( seed, matches ) { - var j, - matchIndexes = fn( [], seed.length, argument ), - i = matchIndexes.length; - - // Match elements found at the specified indexes - while ( i-- ) { - if ( seed[ ( j = matchIndexes[ i ] ) ] ) { - seed[ j ] = !( matches[ j ] = seed[ j ] ); - } - } - } ); - } ); -} - -/** - * Checks a node for validity as a Sizzle context - * @param {Element|Object=} context - * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value - */ -function testContext( context ) { - return context && typeof context.getElementsByTagName !== "undefined" && context; -} - -// Expose support vars for convenience -support = Sizzle.support = {}; - -/** - * Detects XML nodes - * @param {Element|Object} elem An element or a document - * @returns {Boolean} True iff elem is a non-HTML XML node - */ -isXML = Sizzle.isXML = function( elem ) { - var namespace = elem.namespaceURI, - docElem = ( elem.ownerDocument || elem ).documentElement; - - // Support: IE <=8 - // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes - // https://bugs.jquery.com/ticket/4833 - return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" ); -}; - -/** - * Sets document-related variables once based on the current document - * @param {Element|Object} [doc] An element or document object to use to set the document - * @returns {Object} Returns the current document - */ -setDocument = Sizzle.setDocument = function( node ) { - var hasCompare, subWindow, - doc = node ? node.ownerDocument || node : preferredDoc; - - // Return early if doc is invalid or already selected - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { - return document; - } - - // Update global variables - document = doc; - docElem = document.documentElement; - documentIsHTML = !isXML( document ); - - // Support: IE 9 - 11+, Edge 12 - 18+ - // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( preferredDoc != document && - ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { - - // Support: IE 11, Edge - if ( subWindow.addEventListener ) { - subWindow.addEventListener( "unload", unloadHandler, false ); - - // Support: IE 9 - 10 only - } else if ( subWindow.attachEvent ) { - subWindow.attachEvent( "onunload", unloadHandler ); - } - } - - // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only, - // Safari 4 - 5 only, Opera <=11.6 - 12.x only - // IE/Edge & older browsers don't support the :scope pseudo-class. - // Support: Safari 6.0 only - // Safari 6.0 supports :scope but it's an alias of :root there. - support.scope = assert( function( el ) { - docElem.appendChild( el ).appendChild( document.createElement( "div" ) ); - return typeof el.querySelectorAll !== "undefined" && - !el.querySelectorAll( ":scope fieldset div" ).length; - } ); - - /* Attributes - ---------------------------------------------------------------------- */ - - // Support: IE<8 - // Verify that getAttribute really returns attributes and not properties - // (excepting IE8 booleans) - support.attributes = assert( function( el ) { - el.className = "i"; - return !el.getAttribute( "className" ); - } ); - - /* getElement(s)By* - ---------------------------------------------------------------------- */ - - // Check if getElementsByTagName("*") returns only elements - support.getElementsByTagName = assert( function( el ) { - el.appendChild( document.createComment( "" ) ); - return !el.getElementsByTagName( "*" ).length; - } ); - - // Support: IE<9 - support.getElementsByClassName = rnative.test( document.getElementsByClassName ); - - // Support: IE<10 - // Check if getElementById returns elements by name - // The broken getElementById methods don't pick up programmatically-set names, - // so use a roundabout getElementsByName test - support.getById = assert( function( el ) { - docElem.appendChild( el ).id = expando; - return !document.getElementsByName || !document.getElementsByName( expando ).length; - } ); - - // ID filter and find - if ( support.getById ) { - Expr.filter[ "ID" ] = function( id ) { - var attrId = id.replace( runescape, funescape ); - return function( elem ) { - return elem.getAttribute( "id" ) === attrId; - }; - }; - Expr.find[ "ID" ] = function( id, context ) { - if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { - var elem = context.getElementById( id ); - return elem ? [ elem ] : []; - } - }; - } else { - Expr.filter[ "ID" ] = function( id ) { - var attrId = id.replace( runescape, funescape ); - return function( elem ) { - var node = typeof elem.getAttributeNode !== "undefined" && - elem.getAttributeNode( "id" ); - return node && node.value === attrId; - }; - }; - - // Support: IE 6 - 7 only - // getElementById is not reliable as a find shortcut - Expr.find[ "ID" ] = function( id, context ) { - if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { - var node, i, elems, - elem = context.getElementById( id ); - - if ( elem ) { - - // Verify the id attribute - node = elem.getAttributeNode( "id" ); - if ( node && node.value === id ) { - return [ elem ]; - } - - // Fall back on getElementsByName - elems = context.getElementsByName( id ); - i = 0; - while ( ( elem = elems[ i++ ] ) ) { - node = elem.getAttributeNode( "id" ); - if ( node && node.value === id ) { - return [ elem ]; - } - } - } - - return []; - } - }; - } - - // Tag - Expr.find[ "TAG" ] = support.getElementsByTagName ? - function( tag, context ) { - if ( typeof context.getElementsByTagName !== "undefined" ) { - return context.getElementsByTagName( tag ); - - // DocumentFragment nodes don't have gEBTN - } else if ( support.qsa ) { - return context.querySelectorAll( tag ); - } - } : - - function( tag, context ) { - var elem, - tmp = [], - i = 0, - - // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too - results = context.getElementsByTagName( tag ); - - // Filter out possible comments - if ( tag === "*" ) { - while ( ( elem = results[ i++ ] ) ) { - if ( elem.nodeType === 1 ) { - tmp.push( elem ); - } - } - - return tmp; - } - return results; - }; - - // Class - Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) { - if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { - return context.getElementsByClassName( className ); - } - }; - - /* QSA/matchesSelector - ---------------------------------------------------------------------- */ - - // QSA and matchesSelector support - - // matchesSelector(:active) reports false when true (IE9/Opera 11.5) - rbuggyMatches = []; - - // qSa(:focus) reports false when true (Chrome 21) - // We allow this because of a bug in IE8/9 that throws an error - // whenever `document.activeElement` is accessed on an iframe - // So, we allow :focus to pass through QSA all the time to avoid the IE error - // See https://bugs.jquery.com/ticket/13378 - rbuggyQSA = []; - - if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) { - - // Build QSA regex - // Regex strategy adopted from Diego Perini - assert( function( el ) { - - var input; - - // Select is set to empty string on purpose - // This is to test IE's treatment of not explicitly - // setting a boolean content attribute, - // since its presence should be enough - // https://bugs.jquery.com/ticket/12359 - docElem.appendChild( el ).innerHTML = "" + - ""; - - // Support: IE8, Opera 11-12.16 - // Nothing should be selected when empty strings follow ^= or $= or *= - // The test attribute must be unknown in Opera but "safe" for WinRT - // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section - if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) { - rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); - } - - // Support: IE8 - // Boolean attributes and "value" are not treated correctly - if ( !el.querySelectorAll( "[selected]" ).length ) { - rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); - } - - // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ - if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { - rbuggyQSA.push( "~=" ); - } - - // Support: IE 11+, Edge 15 - 18+ - // IE 11/Edge don't find elements on a `[name='']` query in some cases. - // Adding a temporary attribute to the document before the selection works - // around the issue. - // Interestingly, IE 10 & older don't seem to have the issue. - input = document.createElement( "input" ); - input.setAttribute( "name", "" ); - el.appendChild( input ); - if ( !el.querySelectorAll( "[name='']" ).length ) { - rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + - whitespace + "*(?:''|\"\")" ); - } - - // Webkit/Opera - :checked should return selected option elements - // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked - // IE8 throws error here and will not see later tests - if ( !el.querySelectorAll( ":checked" ).length ) { - rbuggyQSA.push( ":checked" ); - } - - // Support: Safari 8+, iOS 8+ - // https://bugs.webkit.org/show_bug.cgi?id=136851 - // In-page `selector#id sibling-combinator selector` fails - if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { - rbuggyQSA.push( ".#.+[+~]" ); - } - - // Support: Firefox <=3.6 - 5 only - // Old Firefox doesn't throw on a badly-escaped identifier. - el.querySelectorAll( "\\\f" ); - rbuggyQSA.push( "[\\r\\n\\f]" ); - } ); - - assert( function( el ) { - el.innerHTML = "" + - ""; - - // Support: Windows 8 Native Apps - // The type and name attributes are restricted during .innerHTML assignment - var input = document.createElement( "input" ); - input.setAttribute( "type", "hidden" ); - el.appendChild( input ).setAttribute( "name", "D" ); - - // Support: IE8 - // Enforce case-sensitivity of name attribute - if ( el.querySelectorAll( "[name=d]" ).length ) { - rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); - } - - // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) - // IE8 throws error here and will not see later tests - if ( el.querySelectorAll( ":enabled" ).length !== 2 ) { - rbuggyQSA.push( ":enabled", ":disabled" ); - } - - // Support: IE9-11+ - // IE's :disabled selector does not pick up the children of disabled fieldsets - docElem.appendChild( el ).disabled = true; - if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { - rbuggyQSA.push( ":enabled", ":disabled" ); - } - - // Support: Opera 10 - 11 only - // Opera 10-11 does not throw on post-comma invalid pseudos - el.querySelectorAll( "*,:x" ); - rbuggyQSA.push( ",.*:" ); - } ); - } - - if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches || - docElem.webkitMatchesSelector || - docElem.mozMatchesSelector || - docElem.oMatchesSelector || - docElem.msMatchesSelector ) ) ) ) { - - assert( function( el ) { - - // Check to see if it's possible to do matchesSelector - // on a disconnected node (IE 9) - support.disconnectedMatch = matches.call( el, "*" ); - - // This should fail with an exception - // Gecko does not error, returns false instead - matches.call( el, "[s!='']:x" ); - rbuggyMatches.push( "!=", pseudos ); - } ); - } - - rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); - rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) ); - - /* Contains - ---------------------------------------------------------------------- */ - hasCompare = rnative.test( docElem.compareDocumentPosition ); - - // Element contains another - // Purposefully self-exclusive - // As in, an element does not contain itself - contains = hasCompare || rnative.test( docElem.contains ) ? - function( a, b ) { - var adown = a.nodeType === 9 ? a.documentElement : a, - bup = b && b.parentNode; - return a === bup || !!( bup && bup.nodeType === 1 && ( - adown.contains ? - adown.contains( bup ) : - a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 - ) ); - } : - function( a, b ) { - if ( b ) { - while ( ( b = b.parentNode ) ) { - if ( b === a ) { - return true; - } - } - } - return false; - }; - - /* Sorting - ---------------------------------------------------------------------- */ - - // Document order sorting - sortOrder = hasCompare ? - function( a, b ) { - - // Flag for duplicate removal - if ( a === b ) { - hasDuplicate = true; - return 0; - } - - // Sort on method existence if only one input has compareDocumentPosition - var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; - if ( compare ) { - return compare; - } - - // Calculate position if both inputs belong to the same document - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? - a.compareDocumentPosition( b ) : - - // Otherwise we know they are disconnected - 1; - - // Disconnected nodes - if ( compare & 1 || - ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { - - // Choose the first element that is related to our preferred document - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( a == document || a.ownerDocument == preferredDoc && - contains( preferredDoc, a ) ) { - return -1; - } - - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( b == document || b.ownerDocument == preferredDoc && - contains( preferredDoc, b ) ) { - return 1; - } - - // Maintain original order - return sortInput ? - ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : - 0; - } - - return compare & 4 ? -1 : 1; - } : - function( a, b ) { - - // Exit early if the nodes are identical - if ( a === b ) { - hasDuplicate = true; - return 0; - } - - var cur, - i = 0, - aup = a.parentNode, - bup = b.parentNode, - ap = [ a ], - bp = [ b ]; - - // Parentless nodes are either documents or disconnected - if ( !aup || !bup ) { - - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - /* eslint-disable eqeqeq */ - return a == document ? -1 : - b == document ? 1 : - /* eslint-enable eqeqeq */ - aup ? -1 : - bup ? 1 : - sortInput ? - ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : - 0; - - // If the nodes are siblings, we can do a quick check - } else if ( aup === bup ) { - return siblingCheck( a, b ); - } - - // Otherwise we need full lists of their ancestors for comparison - cur = a; - while ( ( cur = cur.parentNode ) ) { - ap.unshift( cur ); - } - cur = b; - while ( ( cur = cur.parentNode ) ) { - bp.unshift( cur ); - } - - // Walk down the tree looking for a discrepancy - while ( ap[ i ] === bp[ i ] ) { - i++; - } - - return i ? - - // Do a sibling check if the nodes have a common ancestor - siblingCheck( ap[ i ], bp[ i ] ) : - - // Otherwise nodes in our document sort first - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - /* eslint-disable eqeqeq */ - ap[ i ] == preferredDoc ? -1 : - bp[ i ] == preferredDoc ? 1 : - /* eslint-enable eqeqeq */ - 0; - }; - - return document; -}; - -Sizzle.matches = function( expr, elements ) { - return Sizzle( expr, null, null, elements ); -}; - -Sizzle.matchesSelector = function( elem, expr ) { - setDocument( elem ); - - if ( support.matchesSelector && documentIsHTML && - !nonnativeSelectorCache[ expr + " " ] && - ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && - ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { - - try { - var ret = matches.call( elem, expr ); - - // IE 9's matchesSelector returns false on disconnected nodes - if ( ret || support.disconnectedMatch || - - // As well, disconnected nodes are said to be in a document - // fragment in IE 9 - elem.document && elem.document.nodeType !== 11 ) { - return ret; - } - } catch ( e ) { - nonnativeSelectorCache( expr, true ); - } - } - - return Sizzle( expr, document, null, [ elem ] ).length > 0; -}; - -Sizzle.contains = function( context, elem ) { - - // Set document vars if needed - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( ( context.ownerDocument || context ) != document ) { - setDocument( context ); - } - return contains( context, elem ); -}; - -Sizzle.attr = function( elem, name ) { - - // Set document vars if needed - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( ( elem.ownerDocument || elem ) != document ) { - setDocument( elem ); - } - - var fn = Expr.attrHandle[ name.toLowerCase() ], - - // Don't get fooled by Object.prototype properties (jQuery #13807) - val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? - fn( elem, name, !documentIsHTML ) : - undefined; - - return val !== undefined ? - val : - support.attributes || !documentIsHTML ? - elem.getAttribute( name ) : - ( val = elem.getAttributeNode( name ) ) && val.specified ? - val.value : - null; -}; - -Sizzle.escape = function( sel ) { - return ( sel + "" ).replace( rcssescape, fcssescape ); -}; - -Sizzle.error = function( msg ) { - throw new Error( "Syntax error, unrecognized expression: " + msg ); -}; - -/** - * Document sorting and removing duplicates - * @param {ArrayLike} results - */ -Sizzle.uniqueSort = function( results ) { - var elem, - duplicates = [], - j = 0, - i = 0; - - // Unless we *know* we can detect duplicates, assume their presence - hasDuplicate = !support.detectDuplicates; - sortInput = !support.sortStable && results.slice( 0 ); - results.sort( sortOrder ); - - if ( hasDuplicate ) { - while ( ( elem = results[ i++ ] ) ) { - if ( elem === results[ i ] ) { - j = duplicates.push( i ); - } - } - while ( j-- ) { - results.splice( duplicates[ j ], 1 ); - } - } - - // Clear input after sorting to release objects - // See https://github.com/jquery/sizzle/pull/225 - sortInput = null; - - return results; -}; - -/** - * Utility function for retrieving the text value of an array of DOM nodes - * @param {Array|Element} elem - */ -getText = Sizzle.getText = function( elem ) { - var node, - ret = "", - i = 0, - nodeType = elem.nodeType; - - if ( !nodeType ) { - - // If no nodeType, this is expected to be an array - while ( ( node = elem[ i++ ] ) ) { - - // Do not traverse comment nodes - ret += getText( node ); - } - } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { - - // Use textContent for elements - // innerText usage removed for consistency of new lines (jQuery #11153) - if ( typeof elem.textContent === "string" ) { - return elem.textContent; - } else { - - // Traverse its children - for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { - ret += getText( elem ); - } - } - } else if ( nodeType === 3 || nodeType === 4 ) { - return elem.nodeValue; - } - - // Do not include comment or processing instruction nodes - - return ret; -}; - -Expr = Sizzle.selectors = { - - // Can be adjusted by the user - cacheLength: 50, - - createPseudo: markFunction, - - match: matchExpr, - - attrHandle: {}, - - find: {}, - - relative: { - ">": { dir: "parentNode", first: true }, - " ": { dir: "parentNode" }, - "+": { dir: "previousSibling", first: true }, - "~": { dir: "previousSibling" } - }, - - preFilter: { - "ATTR": function( match ) { - match[ 1 ] = match[ 1 ].replace( runescape, funescape ); - - // Move the given value to match[3] whether quoted or unquoted - match[ 3 ] = ( match[ 3 ] || match[ 4 ] || - match[ 5 ] || "" ).replace( runescape, funescape ); - - if ( match[ 2 ] === "~=" ) { - match[ 3 ] = " " + match[ 3 ] + " "; - } - - return match.slice( 0, 4 ); - }, - - "CHILD": function( match ) { - - /* matches from matchExpr["CHILD"] - 1 type (only|nth|...) - 2 what (child|of-type) - 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) - 4 xn-component of xn+y argument ([+-]?\d*n|) - 5 sign of xn-component - 6 x of xn-component - 7 sign of y-component - 8 y of y-component - */ - match[ 1 ] = match[ 1 ].toLowerCase(); - - if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { - - // nth-* requires argument - if ( !match[ 3 ] ) { - Sizzle.error( match[ 0 ] ); - } - - // numeric x and y parameters for Expr.filter.CHILD - // remember that false/true cast respectively to 0/1 - match[ 4 ] = +( match[ 4 ] ? - match[ 5 ] + ( match[ 6 ] || 1 ) : - 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) ); - match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); - - // other types prohibit arguments - } else if ( match[ 3 ] ) { - Sizzle.error( match[ 0 ] ); - } - - return match; - }, - - "PSEUDO": function( match ) { - var excess, - unquoted = !match[ 6 ] && match[ 2 ]; - - if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) { - return null; - } - - // Accept quoted arguments as-is - if ( match[ 3 ] ) { - match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; - - // Strip excess characters from unquoted arguments - } else if ( unquoted && rpseudo.test( unquoted ) && - - // Get excess from tokenize (recursively) - ( excess = tokenize( unquoted, true ) ) && - - // advance to the next closing parenthesis - ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { - - // excess is a negative index - match[ 0 ] = match[ 0 ].slice( 0, excess ); - match[ 2 ] = unquoted.slice( 0, excess ); - } - - // Return only captures needed by the pseudo filter method (type and argument) - return match.slice( 0, 3 ); - } - }, - - filter: { - - "TAG": function( nodeNameSelector ) { - var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); - return nodeNameSelector === "*" ? - function() { - return true; - } : - function( elem ) { - return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; - }; - }, - - "CLASS": function( className ) { - var pattern = classCache[ className + " " ]; - - return pattern || - ( pattern = new RegExp( "(^|" + whitespace + - ")" + className + "(" + whitespace + "|$)" ) ) && classCache( - className, function( elem ) { - return pattern.test( - typeof elem.className === "string" && elem.className || - typeof elem.getAttribute !== "undefined" && - elem.getAttribute( "class" ) || - "" - ); - } ); - }, - - "ATTR": function( name, operator, check ) { - return function( elem ) { - var result = Sizzle.attr( elem, name ); - - if ( result == null ) { - return operator === "!="; - } - if ( !operator ) { - return true; - } - - result += ""; - - /* eslint-disable max-len */ - - return operator === "=" ? result === check : - operator === "!=" ? result !== check : - operator === "^=" ? check && result.indexOf( check ) === 0 : - operator === "*=" ? check && result.indexOf( check ) > -1 : - operator === "$=" ? check && result.slice( -check.length ) === check : - operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : - operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : - false; - /* eslint-enable max-len */ - - }; - }, - - "CHILD": function( type, what, _argument, first, last ) { - var simple = type.slice( 0, 3 ) !== "nth", - forward = type.slice( -4 ) !== "last", - ofType = what === "of-type"; - - return first === 1 && last === 0 ? - - // Shortcut for :nth-*(n) - function( elem ) { - return !!elem.parentNode; - } : - - function( elem, _context, xml ) { - var cache, uniqueCache, outerCache, node, nodeIndex, start, - dir = simple !== forward ? "nextSibling" : "previousSibling", - parent = elem.parentNode, - name = ofType && elem.nodeName.toLowerCase(), - useCache = !xml && !ofType, - diff = false; - - if ( parent ) { - - // :(first|last|only)-(child|of-type) - if ( simple ) { - while ( dir ) { - node = elem; - while ( ( node = node[ dir ] ) ) { - if ( ofType ? - node.nodeName.toLowerCase() === name : - node.nodeType === 1 ) { - - return false; - } - } - - // Reverse direction for :only-* (if we haven't yet done so) - start = dir = type === "only" && !start && "nextSibling"; - } - return true; - } - - start = [ forward ? parent.firstChild : parent.lastChild ]; - - // non-xml :nth-child(...) stores cache data on `parent` - if ( forward && useCache ) { - - // Seek `elem` from a previously-cached index - - // ...in a gzip-friendly way - node = parent; - outerCache = node[ expando ] || ( node[ expando ] = {} ); - - // Support: IE <9 only - // Defend against cloned attroperties (jQuery gh-1709) - uniqueCache = outerCache[ node.uniqueID ] || - ( outerCache[ node.uniqueID ] = {} ); - - cache = uniqueCache[ type ] || []; - nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; - diff = nodeIndex && cache[ 2 ]; - node = nodeIndex && parent.childNodes[ nodeIndex ]; - - while ( ( node = ++nodeIndex && node && node[ dir ] || - - // Fallback to seeking `elem` from the start - ( diff = nodeIndex = 0 ) || start.pop() ) ) { - - // When found, cache indexes on `parent` and break - if ( node.nodeType === 1 && ++diff && node === elem ) { - uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; - break; - } - } - - } else { - - // Use previously-cached element index if available - if ( useCache ) { - - // ...in a gzip-friendly way - node = elem; - outerCache = node[ expando ] || ( node[ expando ] = {} ); - - // Support: IE <9 only - // Defend against cloned attroperties (jQuery gh-1709) - uniqueCache = outerCache[ node.uniqueID ] || - ( outerCache[ node.uniqueID ] = {} ); - - cache = uniqueCache[ type ] || []; - nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; - diff = nodeIndex; - } - - // xml :nth-child(...) - // or :nth-last-child(...) or :nth(-last)?-of-type(...) - if ( diff === false ) { - - // Use the same loop as above to seek `elem` from the start - while ( ( node = ++nodeIndex && node && node[ dir ] || - ( diff = nodeIndex = 0 ) || start.pop() ) ) { - - if ( ( ofType ? - node.nodeName.toLowerCase() === name : - node.nodeType === 1 ) && - ++diff ) { - - // Cache the index of each encountered element - if ( useCache ) { - outerCache = node[ expando ] || - ( node[ expando ] = {} ); - - // Support: IE <9 only - // Defend against cloned attroperties (jQuery gh-1709) - uniqueCache = outerCache[ node.uniqueID ] || - ( outerCache[ node.uniqueID ] = {} ); - - uniqueCache[ type ] = [ dirruns, diff ]; - } - - if ( node === elem ) { - break; - } - } - } - } - } - - // Incorporate the offset, then check against cycle size - diff -= last; - return diff === first || ( diff % first === 0 && diff / first >= 0 ); - } - }; - }, - - "PSEUDO": function( pseudo, argument ) { - - // pseudo-class names are case-insensitive - // http://www.w3.org/TR/selectors/#pseudo-classes - // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters - // Remember that setFilters inherits from pseudos - var args, - fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || - Sizzle.error( "unsupported pseudo: " + pseudo ); - - // The user may use createPseudo to indicate that - // arguments are needed to create the filter function - // just as Sizzle does - if ( fn[ expando ] ) { - return fn( argument ); - } - - // But maintain support for old signatures - if ( fn.length > 1 ) { - args = [ pseudo, pseudo, "", argument ]; - return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? - markFunction( function( seed, matches ) { - var idx, - matched = fn( seed, argument ), - i = matched.length; - while ( i-- ) { - idx = indexOf( seed, matched[ i ] ); - seed[ idx ] = !( matches[ idx ] = matched[ i ] ); - } - } ) : - function( elem ) { - return fn( elem, 0, args ); - }; - } - - return fn; - } - }, - - pseudos: { - - // Potentially complex pseudos - "not": markFunction( function( selector ) { - - // Trim the selector passed to compile - // to avoid treating leading and trailing - // spaces as combinators - var input = [], - results = [], - matcher = compile( selector.replace( rtrim, "$1" ) ); - - return matcher[ expando ] ? - markFunction( function( seed, matches, _context, xml ) { - var elem, - unmatched = matcher( seed, null, xml, [] ), - i = seed.length; - - // Match elements unmatched by `matcher` - while ( i-- ) { - if ( ( elem = unmatched[ i ] ) ) { - seed[ i ] = !( matches[ i ] = elem ); - } - } - } ) : - function( elem, _context, xml ) { - input[ 0 ] = elem; - matcher( input, null, xml, results ); - - // Don't keep the element (issue #299) - input[ 0 ] = null; - return !results.pop(); - }; - } ), - - "has": markFunction( function( selector ) { - return function( elem ) { - return Sizzle( selector, elem ).length > 0; - }; - } ), - - "contains": markFunction( function( text ) { - text = text.replace( runescape, funescape ); - return function( elem ) { - return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1; - }; - } ), - - // "Whether an element is represented by a :lang() selector - // is based solely on the element's language value - // being equal to the identifier C, - // or beginning with the identifier C immediately followed by "-". - // The matching of C against the element's language value is performed case-insensitively. - // The identifier C does not have to be a valid language name." - // http://www.w3.org/TR/selectors/#lang-pseudo - "lang": markFunction( function( lang ) { - - // lang value must be a valid identifier - if ( !ridentifier.test( lang || "" ) ) { - Sizzle.error( "unsupported lang: " + lang ); - } - lang = lang.replace( runescape, funescape ).toLowerCase(); - return function( elem ) { - var elemLang; - do { - if ( ( elemLang = documentIsHTML ? - elem.lang : - elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { - - elemLang = elemLang.toLowerCase(); - return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; - } - } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); - return false; - }; - } ), - - // Miscellaneous - "target": function( elem ) { - var hash = window.location && window.location.hash; - return hash && hash.slice( 1 ) === elem.id; - }, - - "root": function( elem ) { - return elem === docElem; - }, - - "focus": function( elem ) { - return elem === document.activeElement && - ( !document.hasFocus || document.hasFocus() ) && - !!( elem.type || elem.href || ~elem.tabIndex ); - }, - - // Boolean properties - "enabled": createDisabledPseudo( false ), - "disabled": createDisabledPseudo( true ), - - "checked": function( elem ) { - - // In CSS3, :checked should return both checked and selected elements - // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked - var nodeName = elem.nodeName.toLowerCase(); - return ( nodeName === "input" && !!elem.checked ) || - ( nodeName === "option" && !!elem.selected ); - }, - - "selected": function( elem ) { - - // Accessing this property makes selected-by-default - // options in Safari work properly - if ( elem.parentNode ) { - // eslint-disable-next-line no-unused-expressions - elem.parentNode.selectedIndex; - } - - return elem.selected === true; - }, - - // Contents - "empty": function( elem ) { - - // http://www.w3.org/TR/selectors/#empty-pseudo - // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), - // but not by others (comment: 8; processing instruction: 7; etc.) - // nodeType < 6 works because attributes (2) do not appear as children - for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { - if ( elem.nodeType < 6 ) { - return false; - } - } - return true; - }, - - "parent": function( elem ) { - return !Expr.pseudos[ "empty" ]( elem ); - }, - - // Element/input types - "header": function( elem ) { - return rheader.test( elem.nodeName ); - }, - - "input": function( elem ) { - return rinputs.test( elem.nodeName ); - }, - - "button": function( elem ) { - var name = elem.nodeName.toLowerCase(); - return name === "input" && elem.type === "button" || name === "button"; - }, - - "text": function( elem ) { - var attr; - return elem.nodeName.toLowerCase() === "input" && - elem.type === "text" && - - // Support: IE<8 - // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" - ( ( attr = elem.getAttribute( "type" ) ) == null || - attr.toLowerCase() === "text" ); - }, - - // Position-in-collection - "first": createPositionalPseudo( function() { - return [ 0 ]; - } ), - - "last": createPositionalPseudo( function( _matchIndexes, length ) { - return [ length - 1 ]; - } ), - - "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) { - return [ argument < 0 ? argument + length : argument ]; - } ), - - "even": createPositionalPseudo( function( matchIndexes, length ) { - var i = 0; - for ( ; i < length; i += 2 ) { - matchIndexes.push( i ); - } - return matchIndexes; - } ), - - "odd": createPositionalPseudo( function( matchIndexes, length ) { - var i = 1; - for ( ; i < length; i += 2 ) { - matchIndexes.push( i ); - } - return matchIndexes; - } ), - - "lt": createPositionalPseudo( function( matchIndexes, length, argument ) { - var i = argument < 0 ? - argument + length : - argument > length ? - length : - argument; - for ( ; --i >= 0; ) { - matchIndexes.push( i ); - } - return matchIndexes; - } ), - - "gt": createPositionalPseudo( function( matchIndexes, length, argument ) { - var i = argument < 0 ? argument + length : argument; - for ( ; ++i < length; ) { - matchIndexes.push( i ); - } - return matchIndexes; - } ) - } -}; - -Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ]; - -// Add button/input type pseudos -for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { - Expr.pseudos[ i ] = createInputPseudo( i ); -} -for ( i in { submit: true, reset: true } ) { - Expr.pseudos[ i ] = createButtonPseudo( i ); -} - -// Easy API for creating new setFilters -function setFilters() {} -setFilters.prototype = Expr.filters = Expr.pseudos; -Expr.setFilters = new setFilters(); - -tokenize = Sizzle.tokenize = function( selector, parseOnly ) { - var matched, match, tokens, type, - soFar, groups, preFilters, - cached = tokenCache[ selector + " " ]; - - if ( cached ) { - return parseOnly ? 0 : cached.slice( 0 ); - } - - soFar = selector; - groups = []; - preFilters = Expr.preFilter; - - while ( soFar ) { - - // Comma and first run - if ( !matched || ( match = rcomma.exec( soFar ) ) ) { - if ( match ) { - - // Don't consume trailing commas as valid - soFar = soFar.slice( match[ 0 ].length ) || soFar; - } - groups.push( ( tokens = [] ) ); - } - - matched = false; - - // Combinators - if ( ( match = rcombinators.exec( soFar ) ) ) { - matched = match.shift(); - tokens.push( { - value: matched, - - // Cast descendant combinators to space - type: match[ 0 ].replace( rtrim, " " ) - } ); - soFar = soFar.slice( matched.length ); - } - - // Filters - for ( type in Expr.filter ) { - if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || - ( match = preFilters[ type ]( match ) ) ) ) { - matched = match.shift(); - tokens.push( { - value: matched, - type: type, - matches: match - } ); - soFar = soFar.slice( matched.length ); - } - } - - if ( !matched ) { - break; - } - } - - // Return the length of the invalid excess - // if we're just parsing - // Otherwise, throw an error or return tokens - return parseOnly ? - soFar.length : - soFar ? - Sizzle.error( selector ) : - - // Cache the tokens - tokenCache( selector, groups ).slice( 0 ); -}; - -function toSelector( tokens ) { - var i = 0, - len = tokens.length, - selector = ""; - for ( ; i < len; i++ ) { - selector += tokens[ i ].value; - } - return selector; -} - -function addCombinator( matcher, combinator, base ) { - var dir = combinator.dir, - skip = combinator.next, - key = skip || dir, - checkNonElements = base && key === "parentNode", - doneName = done++; - - return combinator.first ? - - // Check against closest ancestor/preceding element - function( elem, context, xml ) { - while ( ( elem = elem[ dir ] ) ) { - if ( elem.nodeType === 1 || checkNonElements ) { - return matcher( elem, context, xml ); - } - } - return false; - } : - - // Check against all ancestor/preceding elements - function( elem, context, xml ) { - var oldCache, uniqueCache, outerCache, - newCache = [ dirruns, doneName ]; - - // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching - if ( xml ) { - while ( ( elem = elem[ dir ] ) ) { - if ( elem.nodeType === 1 || checkNonElements ) { - if ( matcher( elem, context, xml ) ) { - return true; - } - } - } - } else { - while ( ( elem = elem[ dir ] ) ) { - if ( elem.nodeType === 1 || checkNonElements ) { - outerCache = elem[ expando ] || ( elem[ expando ] = {} ); - - // Support: IE <9 only - // Defend against cloned attroperties (jQuery gh-1709) - uniqueCache = outerCache[ elem.uniqueID ] || - ( outerCache[ elem.uniqueID ] = {} ); - - if ( skip && skip === elem.nodeName.toLowerCase() ) { - elem = elem[ dir ] || elem; - } else if ( ( oldCache = uniqueCache[ key ] ) && - oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { - - // Assign to newCache so results back-propagate to previous elements - return ( newCache[ 2 ] = oldCache[ 2 ] ); - } else { - - // Reuse newcache so results back-propagate to previous elements - uniqueCache[ key ] = newCache; - - // A match means we're done; a fail means we have to keep checking - if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { - return true; - } - } - } - } - } - return false; - }; -} - -function elementMatcher( matchers ) { - return matchers.length > 1 ? - function( elem, context, xml ) { - var i = matchers.length; - while ( i-- ) { - if ( !matchers[ i ]( elem, context, xml ) ) { - return false; - } - } - return true; - } : - matchers[ 0 ]; -} - -function multipleContexts( selector, contexts, results ) { - var i = 0, - len = contexts.length; - for ( ; i < len; i++ ) { - Sizzle( selector, contexts[ i ], results ); - } - return results; -} - -function condense( unmatched, map, filter, context, xml ) { - var elem, - newUnmatched = [], - i = 0, - len = unmatched.length, - mapped = map != null; - - for ( ; i < len; i++ ) { - if ( ( elem = unmatched[ i ] ) ) { - if ( !filter || filter( elem, context, xml ) ) { - newUnmatched.push( elem ); - if ( mapped ) { - map.push( i ); - } - } - } - } - - return newUnmatched; -} - -function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { - if ( postFilter && !postFilter[ expando ] ) { - postFilter = setMatcher( postFilter ); - } - if ( postFinder && !postFinder[ expando ] ) { - postFinder = setMatcher( postFinder, postSelector ); - } - return markFunction( function( seed, results, context, xml ) { - var temp, i, elem, - preMap = [], - postMap = [], - preexisting = results.length, - - // Get initial elements from seed or context - elems = seed || multipleContexts( - selector || "*", - context.nodeType ? [ context ] : context, - [] - ), - - // Prefilter to get matcher input, preserving a map for seed-results synchronization - matcherIn = preFilter && ( seed || !selector ) ? - condense( elems, preMap, preFilter, context, xml ) : - elems, - - matcherOut = matcher ? - - // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, - postFinder || ( seed ? preFilter : preexisting || postFilter ) ? - - // ...intermediate processing is necessary - [] : - - // ...otherwise use results directly - results : - matcherIn; - - // Find primary matches - if ( matcher ) { - matcher( matcherIn, matcherOut, context, xml ); - } - - // Apply postFilter - if ( postFilter ) { - temp = condense( matcherOut, postMap ); - postFilter( temp, [], context, xml ); - - // Un-match failing elements by moving them back to matcherIn - i = temp.length; - while ( i-- ) { - if ( ( elem = temp[ i ] ) ) { - matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); - } - } - } - - if ( seed ) { - if ( postFinder || preFilter ) { - if ( postFinder ) { - - // Get the final matcherOut by condensing this intermediate into postFinder contexts - temp = []; - i = matcherOut.length; - while ( i-- ) { - if ( ( elem = matcherOut[ i ] ) ) { - - // Restore matcherIn since elem is not yet a final match - temp.push( ( matcherIn[ i ] = elem ) ); - } - } - postFinder( null, ( matcherOut = [] ), temp, xml ); - } - - // Move matched elements from seed to results to keep them synchronized - i = matcherOut.length; - while ( i-- ) { - if ( ( elem = matcherOut[ i ] ) && - ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) { - - seed[ temp ] = !( results[ temp ] = elem ); - } - } - } - - // Add elements to results, through postFinder if defined - } else { - matcherOut = condense( - matcherOut === results ? - matcherOut.splice( preexisting, matcherOut.length ) : - matcherOut - ); - if ( postFinder ) { - postFinder( null, results, matcherOut, xml ); - } else { - push.apply( results, matcherOut ); - } - } - } ); -} - -function matcherFromTokens( tokens ) { - var checkContext, matcher, j, - len = tokens.length, - leadingRelative = Expr.relative[ tokens[ 0 ].type ], - implicitRelative = leadingRelative || Expr.relative[ " " ], - i = leadingRelative ? 1 : 0, - - // The foundational matcher ensures that elements are reachable from top-level context(s) - matchContext = addCombinator( function( elem ) { - return elem === checkContext; - }, implicitRelative, true ), - matchAnyContext = addCombinator( function( elem ) { - return indexOf( checkContext, elem ) > -1; - }, implicitRelative, true ), - matchers = [ function( elem, context, xml ) { - var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( - ( checkContext = context ).nodeType ? - matchContext( elem, context, xml ) : - matchAnyContext( elem, context, xml ) ); - - // Avoid hanging onto element (issue #299) - checkContext = null; - return ret; - } ]; - - for ( ; i < len; i++ ) { - if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { - matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; - } else { - matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); - - // Return special upon seeing a positional matcher - if ( matcher[ expando ] ) { - - // Find the next relative operator (if any) for proper handling - j = ++i; - for ( ; j < len; j++ ) { - if ( Expr.relative[ tokens[ j ].type ] ) { - break; - } - } - return setMatcher( - i > 1 && elementMatcher( matchers ), - i > 1 && toSelector( - - // If the preceding token was a descendant combinator, insert an implicit any-element `*` - tokens - .slice( 0, i - 1 ) - .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) - ).replace( rtrim, "$1" ), - matcher, - i < j && matcherFromTokens( tokens.slice( i, j ) ), - j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), - j < len && toSelector( tokens ) - ); - } - matchers.push( matcher ); - } - } - - return elementMatcher( matchers ); -} - -function matcherFromGroupMatchers( elementMatchers, setMatchers ) { - var bySet = setMatchers.length > 0, - byElement = elementMatchers.length > 0, - superMatcher = function( seed, context, xml, results, outermost ) { - var elem, j, matcher, - matchedCount = 0, - i = "0", - unmatched = seed && [], - setMatched = [], - contextBackup = outermostContext, - - // We must always have either seed elements or outermost context - elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ), - - // Use integer dirruns iff this is the outermost matcher - dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), - len = elems.length; - - if ( outermost ) { - - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - outermostContext = context == document || context || outermost; - } - - // Add elements passing elementMatchers directly to results - // Support: IE<9, Safari - // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id - for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { - if ( byElement && elem ) { - j = 0; - - // Support: IE 11+, Edge 17 - 18+ - // IE/Edge sometimes throw a "Permission denied" error when strict-comparing - // two documents; shallow comparisons work. - // eslint-disable-next-line eqeqeq - if ( !context && elem.ownerDocument != document ) { - setDocument( elem ); - xml = !documentIsHTML; - } - while ( ( matcher = elementMatchers[ j++ ] ) ) { - if ( matcher( elem, context || document, xml ) ) { - results.push( elem ); - break; - } - } - if ( outermost ) { - dirruns = dirrunsUnique; - } - } - - // Track unmatched elements for set filters - if ( bySet ) { - - // They will have gone through all possible matchers - if ( ( elem = !matcher && elem ) ) { - matchedCount--; - } - - // Lengthen the array for every element, matched or not - if ( seed ) { - unmatched.push( elem ); - } - } - } - - // `i` is now the count of elements visited above, and adding it to `matchedCount` - // makes the latter nonnegative. - matchedCount += i; - - // Apply set filters to unmatched elements - // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` - // equals `i`), unless we didn't visit _any_ elements in the above loop because we have - // no element matchers and no seed. - // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that - // case, which will result in a "00" `matchedCount` that differs from `i` but is also - // numerically zero. - if ( bySet && i !== matchedCount ) { - j = 0; - while ( ( matcher = setMatchers[ j++ ] ) ) { - matcher( unmatched, setMatched, context, xml ); - } - - if ( seed ) { - - // Reintegrate element matches to eliminate the need for sorting - if ( matchedCount > 0 ) { - while ( i-- ) { - if ( !( unmatched[ i ] || setMatched[ i ] ) ) { - setMatched[ i ] = pop.call( results ); - } - } - } - - // Discard index placeholder values to get only actual matches - setMatched = condense( setMatched ); - } - - // Add matches to results - push.apply( results, setMatched ); - - // Seedless set matches succeeding multiple successful matchers stipulate sorting - if ( outermost && !seed && setMatched.length > 0 && - ( matchedCount + setMatchers.length ) > 1 ) { - - Sizzle.uniqueSort( results ); - } - } - - // Override manipulation of globals by nested matchers - if ( outermost ) { - dirruns = dirrunsUnique; - outermostContext = contextBackup; - } - - return unmatched; - }; - - return bySet ? - markFunction( superMatcher ) : - superMatcher; -} - -compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { - var i, - setMatchers = [], - elementMatchers = [], - cached = compilerCache[ selector + " " ]; - - if ( !cached ) { - - // Generate a function of recursive functions that can be used to check each element - if ( !match ) { - match = tokenize( selector ); - } - i = match.length; - while ( i-- ) { - cached = matcherFromTokens( match[ i ] ); - if ( cached[ expando ] ) { - setMatchers.push( cached ); - } else { - elementMatchers.push( cached ); - } - } - - // Cache the compiled function - cached = compilerCache( - selector, - matcherFromGroupMatchers( elementMatchers, setMatchers ) - ); - - // Save selector and tokenization - cached.selector = selector; - } - return cached; -}; - -/** - * A low-level selection function that works with Sizzle's compiled - * selector functions - * @param {String|Function} selector A selector or a pre-compiled - * selector function built with Sizzle.compile - * @param {Element} context - * @param {Array} [results] - * @param {Array} [seed] A set of elements to match against - */ -select = Sizzle.select = function( selector, context, results, seed ) { - var i, tokens, token, type, find, - compiled = typeof selector === "function" && selector, - match = !seed && tokenize( ( selector = compiled.selector || selector ) ); - - results = results || []; - - // Try to minimize operations if there is only one selector in the list and no seed - // (the latter of which guarantees us context) - if ( match.length === 1 ) { - - // Reduce context if the leading compound selector is an ID - tokens = match[ 0 ] = match[ 0 ].slice( 0 ); - if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && - context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { - - context = ( Expr.find[ "ID" ]( token.matches[ 0 ] - .replace( runescape, funescape ), context ) || [] )[ 0 ]; - if ( !context ) { - return results; - - // Precompiled matchers will still verify ancestry, so step up a level - } else if ( compiled ) { - context = context.parentNode; - } - - selector = selector.slice( tokens.shift().value.length ); - } - - // Fetch a seed set for right-to-left matching - i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length; - while ( i-- ) { - token = tokens[ i ]; - - // Abort if we hit a combinator - if ( Expr.relative[ ( type = token.type ) ] ) { - break; - } - if ( ( find = Expr.find[ type ] ) ) { - - // Search, expanding context for leading sibling combinators - if ( ( seed = find( - token.matches[ 0 ].replace( runescape, funescape ), - rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) || - context - ) ) ) { - - // If seed is empty or no tokens remain, we can return early - tokens.splice( i, 1 ); - selector = seed.length && toSelector( tokens ); - if ( !selector ) { - push.apply( results, seed ); - return results; - } - - break; - } - } - } - } - - // Compile and execute a filtering function if one is not provided - // Provide `match` to avoid retokenization if we modified the selector above - ( compiled || compile( selector, match ) )( - seed, - context, - !documentIsHTML, - results, - !context || rsibling.test( selector ) && testContext( context.parentNode ) || context - ); - return results; -}; - -// One-time assignments - -// Sort stability -support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; - -// Support: Chrome 14-35+ -// Always assume duplicates if they aren't passed to the comparison function -support.detectDuplicates = !!hasDuplicate; - -// Initialize against the default document -setDocument(); - -// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) -// Detached nodes confoundingly follow *each other* -support.sortDetached = assert( function( el ) { - - // Should return 1, but returns 4 (following) - return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; -} ); - -// Support: IE<8 -// Prevent attribute/property "interpolation" -// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx -if ( !assert( function( el ) { - el.innerHTML = ""; - return el.firstChild.getAttribute( "href" ) === "#"; -} ) ) { - addHandle( "type|href|height|width", function( elem, name, isXML ) { - if ( !isXML ) { - return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); - } - } ); -} - -// Support: IE<9 -// Use defaultValue in place of getAttribute("value") -if ( !support.attributes || !assert( function( el ) { - el.innerHTML = ""; - el.firstChild.setAttribute( "value", "" ); - return el.firstChild.getAttribute( "value" ) === ""; -} ) ) { - addHandle( "value", function( elem, _name, isXML ) { - if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { - return elem.defaultValue; - } - } ); -} - -// Support: IE<9 -// Use getAttributeNode to fetch booleans when getAttribute lies -if ( !assert( function( el ) { - return el.getAttribute( "disabled" ) == null; -} ) ) { - addHandle( booleans, function( elem, name, isXML ) { - var val; - if ( !isXML ) { - return elem[ name ] === true ? name.toLowerCase() : - ( val = elem.getAttributeNode( name ) ) && val.specified ? - val.value : - null; - } - } ); -} - -return Sizzle; - -} )( window ); - - - -jQuery.find = Sizzle; -jQuery.expr = Sizzle.selectors; - -// Deprecated -jQuery.expr[ ":" ] = jQuery.expr.pseudos; -jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; -jQuery.text = Sizzle.getText; -jQuery.isXMLDoc = Sizzle.isXML; -jQuery.contains = Sizzle.contains; -jQuery.escapeSelector = Sizzle.escape; - - - - -var dir = function( elem, dir, until ) { - var matched = [], - truncate = until !== undefined; - - while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { - if ( elem.nodeType === 1 ) { - if ( truncate && jQuery( elem ).is( until ) ) { - break; - } - matched.push( elem ); - } - } - return matched; -}; - - -var siblings = function( n, elem ) { - var matched = []; - - for ( ; n; n = n.nextSibling ) { - if ( n.nodeType === 1 && n !== elem ) { - matched.push( n ); - } - } - - return matched; -}; - - -var rneedsContext = jQuery.expr.match.needsContext; - - - -function nodeName( elem, name ) { - - return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); - -}; -var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); - - - -// Implement the identical functionality for filter and not -function winnow( elements, qualifier, not ) { - if ( isFunction( qualifier ) ) { - return jQuery.grep( elements, function( elem, i ) { - return !!qualifier.call( elem, i, elem ) !== not; - } ); - } - - // Single element - if ( qualifier.nodeType ) { - return jQuery.grep( elements, function( elem ) { - return ( elem === qualifier ) !== not; - } ); - } - - // Arraylike of elements (jQuery, arguments, Array) - if ( typeof qualifier !== "string" ) { - return jQuery.grep( elements, function( elem ) { - return ( indexOf.call( qualifier, elem ) > -1 ) !== not; - } ); - } - - // Filtered directly for both simple and complex selectors - return jQuery.filter( qualifier, elements, not ); -} - -jQuery.filter = function( expr, elems, not ) { - var elem = elems[ 0 ]; - - if ( not ) { - expr = ":not(" + expr + ")"; - } - - if ( elems.length === 1 && elem.nodeType === 1 ) { - return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; - } - - return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { - return elem.nodeType === 1; - } ) ); -}; - -jQuery.fn.extend( { - find: function( selector ) { - var i, ret, - len = this.length, - self = this; - - if ( typeof selector !== "string" ) { - return this.pushStack( jQuery( selector ).filter( function() { - for ( i = 0; i < len; i++ ) { - if ( jQuery.contains( self[ i ], this ) ) { - return true; - } - } - } ) ); - } - - ret = this.pushStack( [] ); - - for ( i = 0; i < len; i++ ) { - jQuery.find( selector, self[ i ], ret ); - } - - return len > 1 ? jQuery.uniqueSort( ret ) : ret; - }, - filter: function( selector ) { - return this.pushStack( winnow( this, selector || [], false ) ); - }, - not: function( selector ) { - return this.pushStack( winnow( this, selector || [], true ) ); - }, - is: function( selector ) { - return !!winnow( - this, - - // If this is a positional/relative selector, check membership in the returned set - // so $("p:first").is("p:last") won't return true for a doc with two "p". - typeof selector === "string" && rneedsContext.test( selector ) ? - jQuery( selector ) : - selector || [], - false - ).length; - } -} ); - - -// Initialize a jQuery object - - -// A central reference to the root jQuery(document) -var rootjQuery, - - // A simple way to check for HTML strings - // Prioritize #id over to avoid XSS via location.hash (#9521) - // Strict HTML recognition (#11290: must start with <) - // Shortcut simple #id case for speed - rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, - - init = jQuery.fn.init = function( selector, context, root ) { - var match, elem; - - // HANDLE: $(""), $(null), $(undefined), $(false) - if ( !selector ) { - return this; - } - - // Method init() accepts an alternate rootjQuery - // so migrate can support jQuery.sub (gh-2101) - root = root || rootjQuery; - - // Handle HTML strings - if ( typeof selector === "string" ) { - if ( selector[ 0 ] === "<" && - selector[ selector.length - 1 ] === ">" && - selector.length >= 3 ) { - - // Assume that strings that start and end with <> are HTML and skip the regex check - match = [ null, selector, null ]; - - } else { - match = rquickExpr.exec( selector ); - } - - // Match html or make sure no context is specified for #id - if ( match && ( match[ 1 ] || !context ) ) { - - // HANDLE: $(html) -> $(array) - if ( match[ 1 ] ) { - context = context instanceof jQuery ? context[ 0 ] : context; - - // Option to run scripts is true for back-compat - // Intentionally let the error be thrown if parseHTML is not present - jQuery.merge( this, jQuery.parseHTML( - match[ 1 ], - context && context.nodeType ? context.ownerDocument || context : document, - true - ) ); - - // HANDLE: $(html, props) - if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { - for ( match in context ) { - - // Properties of context are called as methods if possible - if ( isFunction( this[ match ] ) ) { - this[ match ]( context[ match ] ); - - // ...and otherwise set as attributes - } else { - this.attr( match, context[ match ] ); - } - } - } - - return this; - - // HANDLE: $(#id) - } else { - elem = document.getElementById( match[ 2 ] ); - - if ( elem ) { - - // Inject the element directly into the jQuery object - this[ 0 ] = elem; - this.length = 1; - } - return this; - } - - // HANDLE: $(expr, $(...)) - } else if ( !context || context.jquery ) { - return ( context || root ).find( selector ); - - // HANDLE: $(expr, context) - // (which is just equivalent to: $(context).find(expr) - } else { - return this.constructor( context ).find( selector ); - } - - // HANDLE: $(DOMElement) - } else if ( selector.nodeType ) { - this[ 0 ] = selector; - this.length = 1; - return this; - - // HANDLE: $(function) - // Shortcut for document ready - } else if ( isFunction( selector ) ) { - return root.ready !== undefined ? - root.ready( selector ) : - - // Execute immediately if ready is not present - selector( jQuery ); - } - - return jQuery.makeArray( selector, this ); - }; - -// Give the init function the jQuery prototype for later instantiation -init.prototype = jQuery.fn; - -// Initialize central reference -rootjQuery = jQuery( document ); - - -var rparentsprev = /^(?:parents|prev(?:Until|All))/, - - // Methods guaranteed to produce a unique set when starting from a unique set - guaranteedUnique = { - children: true, - contents: true, - next: true, - prev: true - }; - -jQuery.fn.extend( { - has: function( target ) { - var targets = jQuery( target, this ), - l = targets.length; - - return this.filter( function() { - var i = 0; - for ( ; i < l; i++ ) { - if ( jQuery.contains( this, targets[ i ] ) ) { - return true; - } - } - } ); - }, - - closest: function( selectors, context ) { - var cur, - i = 0, - l = this.length, - matched = [], - targets = typeof selectors !== "string" && jQuery( selectors ); - - // Positional selectors never match, since there's no _selection_ context - if ( !rneedsContext.test( selectors ) ) { - for ( ; i < l; i++ ) { - for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { - - // Always skip document fragments - if ( cur.nodeType < 11 && ( targets ? - targets.index( cur ) > -1 : - - // Don't pass non-elements to Sizzle - cur.nodeType === 1 && - jQuery.find.matchesSelector( cur, selectors ) ) ) { - - matched.push( cur ); - break; - } - } - } - } - - return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); - }, - - // Determine the position of an element within the set - index: function( elem ) { - - // No argument, return index in parent - if ( !elem ) { - return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; - } - - // Index in selector - if ( typeof elem === "string" ) { - return indexOf.call( jQuery( elem ), this[ 0 ] ); - } - - // Locate the position of the desired element - return indexOf.call( this, - - // If it receives a jQuery object, the first element is used - elem.jquery ? elem[ 0 ] : elem - ); - }, - - add: function( selector, context ) { - return this.pushStack( - jQuery.uniqueSort( - jQuery.merge( this.get(), jQuery( selector, context ) ) - ) - ); - }, - - addBack: function( selector ) { - return this.add( selector == null ? - this.prevObject : this.prevObject.filter( selector ) - ); - } -} ); - -function sibling( cur, dir ) { - while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} - return cur; -} - -jQuery.each( { - parent: function( elem ) { - var parent = elem.parentNode; - return parent && parent.nodeType !== 11 ? parent : null; - }, - parents: function( elem ) { - return dir( elem, "parentNode" ); - }, - parentsUntil: function( elem, _i, until ) { - return dir( elem, "parentNode", until ); - }, - next: function( elem ) { - return sibling( elem, "nextSibling" ); - }, - prev: function( elem ) { - return sibling( elem, "previousSibling" ); - }, - nextAll: function( elem ) { - return dir( elem, "nextSibling" ); - }, - prevAll: function( elem ) { - return dir( elem, "previousSibling" ); - }, - nextUntil: function( elem, _i, until ) { - return dir( elem, "nextSibling", until ); - }, - prevUntil: function( elem, _i, until ) { - return dir( elem, "previousSibling", until ); - }, - siblings: function( elem ) { - return siblings( ( elem.parentNode || {} ).firstChild, elem ); - }, - children: function( elem ) { - return siblings( elem.firstChild ); - }, - contents: function( elem ) { - if ( elem.contentDocument != null && - - // Support: IE 11+ - // elements with no `data` attribute has an object - // `contentDocument` with a `null` prototype. - getProto( elem.contentDocument ) ) { - - return elem.contentDocument; - } - - // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only - // Treat the template element as a regular one in browsers that - // don't support it. - if ( nodeName( elem, "template" ) ) { - elem = elem.content || elem; - } - - return jQuery.merge( [], elem.childNodes ); - } -}, function( name, fn ) { - jQuery.fn[ name ] = function( until, selector ) { - var matched = jQuery.map( this, fn, until ); - - if ( name.slice( -5 ) !== "Until" ) { - selector = until; - } - - if ( selector && typeof selector === "string" ) { - matched = jQuery.filter( selector, matched ); - } - - if ( this.length > 1 ) { - - // Remove duplicates - if ( !guaranteedUnique[ name ] ) { - jQuery.uniqueSort( matched ); - } - - // Reverse order for parents* and prev-derivatives - if ( rparentsprev.test( name ) ) { - matched.reverse(); - } - } - - return this.pushStack( matched ); - }; -} ); -var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); - - - -// Convert String-formatted options into Object-formatted ones -function createOptions( options ) { - var object = {}; - jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { - object[ flag ] = true; - } ); - return object; -} - -/* - * Create a callback list using the following parameters: - * - * options: an optional list of space-separated options that will change how - * the callback list behaves or a more traditional option object - * - * By default a callback list will act like an event callback list and can be - * "fired" multiple times. - * - * Possible options: - * - * once: will ensure the callback list can only be fired once (like a Deferred) - * - * memory: will keep track of previous values and will call any callback added - * after the list has been fired right away with the latest "memorized" - * values (like a Deferred) - * - * unique: will ensure a callback can only be added once (no duplicate in the list) - * - * stopOnFalse: interrupt callings when a callback returns false - * - */ -jQuery.Callbacks = function( options ) { - - // Convert options from String-formatted to Object-formatted if needed - // (we check in cache first) - options = typeof options === "string" ? - createOptions( options ) : - jQuery.extend( {}, options ); - - var // Flag to know if list is currently firing - firing, - - // Last fire value for non-forgettable lists - memory, - - // Flag to know if list was already fired - fired, - - // Flag to prevent firing - locked, - - // Actual callback list - list = [], - - // Queue of execution data for repeatable lists - queue = [], - - // Index of currently firing callback (modified by add/remove as needed) - firingIndex = -1, - - // Fire callbacks - fire = function() { - - // Enforce single-firing - locked = locked || options.once; - - // Execute callbacks for all pending executions, - // respecting firingIndex overrides and runtime changes - fired = firing = true; - for ( ; queue.length; firingIndex = -1 ) { - memory = queue.shift(); - while ( ++firingIndex < list.length ) { - - // Run callback and check for early termination - if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && - options.stopOnFalse ) { - - // Jump to end and forget the data so .add doesn't re-fire - firingIndex = list.length; - memory = false; - } - } - } - - // Forget the data if we're done with it - if ( !options.memory ) { - memory = false; - } - - firing = false; - - // Clean up if we're done firing for good - if ( locked ) { - - // Keep an empty list if we have data for future add calls - if ( memory ) { - list = []; - - // Otherwise, this object is spent - } else { - list = ""; - } - } - }, - - // Actual Callbacks object - self = { - - // Add a callback or a collection of callbacks to the list - add: function() { - if ( list ) { - - // If we have memory from a past run, we should fire after adding - if ( memory && !firing ) { - firingIndex = list.length - 1; - queue.push( memory ); - } - - ( function add( args ) { - jQuery.each( args, function( _, arg ) { - if ( isFunction( arg ) ) { - if ( !options.unique || !self.has( arg ) ) { - list.push( arg ); - } - } else if ( arg && arg.length && toType( arg ) !== "string" ) { - - // Inspect recursively - add( arg ); - } - } ); - } )( arguments ); - - if ( memory && !firing ) { - fire(); - } - } - return this; - }, - - // Remove a callback from the list - remove: function() { - jQuery.each( arguments, function( _, arg ) { - var index; - while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { - list.splice( index, 1 ); - - // Handle firing indexes - if ( index <= firingIndex ) { - firingIndex--; - } - } - } ); - return this; - }, - - // Check if a given callback is in the list. - // If no argument is given, return whether or not list has callbacks attached. - has: function( fn ) { - return fn ? - jQuery.inArray( fn, list ) > -1 : - list.length > 0; - }, - - // Remove all callbacks from the list - empty: function() { - if ( list ) { - list = []; - } - return this; - }, - - // Disable .fire and .add - // Abort any current/pending executions - // Clear all callbacks and values - disable: function() { - locked = queue = []; - list = memory = ""; - return this; - }, - disabled: function() { - return !list; - }, - - // Disable .fire - // Also disable .add unless we have memory (since it would have no effect) - // Abort any pending executions - lock: function() { - locked = queue = []; - if ( !memory && !firing ) { - list = memory = ""; - } - return this; - }, - locked: function() { - return !!locked; - }, - - // Call all callbacks with the given context and arguments - fireWith: function( context, args ) { - if ( !locked ) { - args = args || []; - args = [ context, args.slice ? args.slice() : args ]; - queue.push( args ); - if ( !firing ) { - fire(); - } - } - return this; - }, - - // Call all the callbacks with the given arguments - fire: function() { - self.fireWith( this, arguments ); - return this; - }, - - // To know if the callbacks have already been called at least once - fired: function() { - return !!fired; - } - }; - - return self; -}; - - -function Identity( v ) { - return v; -} -function Thrower( ex ) { - throw ex; -} - -function adoptValue( value, resolve, reject, noValue ) { - var method; - - try { - - // Check for promise aspect first to privilege synchronous behavior - if ( value && isFunction( ( method = value.promise ) ) ) { - method.call( value ).done( resolve ).fail( reject ); - - // Other thenables - } else if ( value && isFunction( ( method = value.then ) ) ) { - method.call( value, resolve, reject ); - - // Other non-thenables - } else { - - // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: - // * false: [ value ].slice( 0 ) => resolve( value ) - // * true: [ value ].slice( 1 ) => resolve() - resolve.apply( undefined, [ value ].slice( noValue ) ); - } - - // For Promises/A+, convert exceptions into rejections - // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in - // Deferred#then to conditionally suppress rejection. - } catch ( value ) { - - // Support: Android 4.0 only - // Strict mode functions invoked without .call/.apply get global-object context - reject.apply( undefined, [ value ] ); - } -} - -jQuery.extend( { - - Deferred: function( func ) { - var tuples = [ - - // action, add listener, callbacks, - // ... .then handlers, argument index, [final state] - [ "notify", "progress", jQuery.Callbacks( "memory" ), - jQuery.Callbacks( "memory" ), 2 ], - [ "resolve", "done", jQuery.Callbacks( "once memory" ), - jQuery.Callbacks( "once memory" ), 0, "resolved" ], - [ "reject", "fail", jQuery.Callbacks( "once memory" ), - jQuery.Callbacks( "once memory" ), 1, "rejected" ] - ], - state = "pending", - promise = { - state: function() { - return state; - }, - always: function() { - deferred.done( arguments ).fail( arguments ); - return this; - }, - "catch": function( fn ) { - return promise.then( null, fn ); - }, - - // Keep pipe for back-compat - pipe: function( /* fnDone, fnFail, fnProgress */ ) { - var fns = arguments; - - return jQuery.Deferred( function( newDefer ) { - jQuery.each( tuples, function( _i, tuple ) { - - // Map tuples (progress, done, fail) to arguments (done, fail, progress) - var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; - - // deferred.progress(function() { bind to newDefer or newDefer.notify }) - // deferred.done(function() { bind to newDefer or newDefer.resolve }) - // deferred.fail(function() { bind to newDefer or newDefer.reject }) - deferred[ tuple[ 1 ] ]( function() { - var returned = fn && fn.apply( this, arguments ); - if ( returned && isFunction( returned.promise ) ) { - returned.promise() - .progress( newDefer.notify ) - .done( newDefer.resolve ) - .fail( newDefer.reject ); - } else { - newDefer[ tuple[ 0 ] + "With" ]( - this, - fn ? [ returned ] : arguments - ); - } - } ); - } ); - fns = null; - } ).promise(); - }, - then: function( onFulfilled, onRejected, onProgress ) { - var maxDepth = 0; - function resolve( depth, deferred, handler, special ) { - return function() { - var that = this, - args = arguments, - mightThrow = function() { - var returned, then; - - // Support: Promises/A+ section 2.3.3.3.3 - // https://promisesaplus.com/#point-59 - // Ignore double-resolution attempts - if ( depth < maxDepth ) { - return; - } - - returned = handler.apply( that, args ); - - // Support: Promises/A+ section 2.3.1 - // https://promisesaplus.com/#point-48 - if ( returned === deferred.promise() ) { - throw new TypeError( "Thenable self-resolution" ); - } - - // Support: Promises/A+ sections 2.3.3.1, 3.5 - // https://promisesaplus.com/#point-54 - // https://promisesaplus.com/#point-75 - // Retrieve `then` only once - then = returned && - - // Support: Promises/A+ section 2.3.4 - // https://promisesaplus.com/#point-64 - // Only check objects and functions for thenability - ( typeof returned === "object" || - typeof returned === "function" ) && - returned.then; - - // Handle a returned thenable - if ( isFunction( then ) ) { - - // Special processors (notify) just wait for resolution - if ( special ) { - then.call( - returned, - resolve( maxDepth, deferred, Identity, special ), - resolve( maxDepth, deferred, Thrower, special ) - ); - - // Normal processors (resolve) also hook into progress - } else { - - // ...and disregard older resolution values - maxDepth++; - - then.call( - returned, - resolve( maxDepth, deferred, Identity, special ), - resolve( maxDepth, deferred, Thrower, special ), - resolve( maxDepth, deferred, Identity, - deferred.notifyWith ) - ); - } - - // Handle all other returned values - } else { - - // Only substitute handlers pass on context - // and multiple values (non-spec behavior) - if ( handler !== Identity ) { - that = undefined; - args = [ returned ]; - } - - // Process the value(s) - // Default process is resolve - ( special || deferred.resolveWith )( that, args ); - } - }, - - // Only normal processors (resolve) catch and reject exceptions - process = special ? - mightThrow : - function() { - try { - mightThrow(); - } catch ( e ) { - - if ( jQuery.Deferred.exceptionHook ) { - jQuery.Deferred.exceptionHook( e, - process.stackTrace ); - } - - // Support: Promises/A+ section 2.3.3.3.4.1 - // https://promisesaplus.com/#point-61 - // Ignore post-resolution exceptions - if ( depth + 1 >= maxDepth ) { - - // Only substitute handlers pass on context - // and multiple values (non-spec behavior) - if ( handler !== Thrower ) { - that = undefined; - args = [ e ]; - } - - deferred.rejectWith( that, args ); - } - } - }; - - // Support: Promises/A+ section 2.3.3.3.1 - // https://promisesaplus.com/#point-57 - // Re-resolve promises immediately to dodge false rejection from - // subsequent errors - if ( depth ) { - process(); - } else { - - // Call an optional hook to record the stack, in case of exception - // since it's otherwise lost when execution goes async - if ( jQuery.Deferred.getStackHook ) { - process.stackTrace = jQuery.Deferred.getStackHook(); - } - window.setTimeout( process ); - } - }; - } - - return jQuery.Deferred( function( newDefer ) { - - // progress_handlers.add( ... ) - tuples[ 0 ][ 3 ].add( - resolve( - 0, - newDefer, - isFunction( onProgress ) ? - onProgress : - Identity, - newDefer.notifyWith - ) - ); - - // fulfilled_handlers.add( ... ) - tuples[ 1 ][ 3 ].add( - resolve( - 0, - newDefer, - isFunction( onFulfilled ) ? - onFulfilled : - Identity - ) - ); - - // rejected_handlers.add( ... ) - tuples[ 2 ][ 3 ].add( - resolve( - 0, - newDefer, - isFunction( onRejected ) ? - onRejected : - Thrower - ) - ); - } ).promise(); - }, - - // Get a promise for this deferred - // If obj is provided, the promise aspect is added to the object - promise: function( obj ) { - return obj != null ? jQuery.extend( obj, promise ) : promise; - } - }, - deferred = {}; - - // Add list-specific methods - jQuery.each( tuples, function( i, tuple ) { - var list = tuple[ 2 ], - stateString = tuple[ 5 ]; - - // promise.progress = list.add - // promise.done = list.add - // promise.fail = list.add - promise[ tuple[ 1 ] ] = list.add; - - // Handle state - if ( stateString ) { - list.add( - function() { - - // state = "resolved" (i.e., fulfilled) - // state = "rejected" - state = stateString; - }, - - // rejected_callbacks.disable - // fulfilled_callbacks.disable - tuples[ 3 - i ][ 2 ].disable, - - // rejected_handlers.disable - // fulfilled_handlers.disable - tuples[ 3 - i ][ 3 ].disable, - - // progress_callbacks.lock - tuples[ 0 ][ 2 ].lock, - - // progress_handlers.lock - tuples[ 0 ][ 3 ].lock - ); - } - - // progress_handlers.fire - // fulfilled_handlers.fire - // rejected_handlers.fire - list.add( tuple[ 3 ].fire ); - - // deferred.notify = function() { deferred.notifyWith(...) } - // deferred.resolve = function() { deferred.resolveWith(...) } - // deferred.reject = function() { deferred.rejectWith(...) } - deferred[ tuple[ 0 ] ] = function() { - deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); - return this; - }; - - // deferred.notifyWith = list.fireWith - // deferred.resolveWith = list.fireWith - // deferred.rejectWith = list.fireWith - deferred[ tuple[ 0 ] + "With" ] = list.fireWith; - } ); - - // Make the deferred a promise - promise.promise( deferred ); - - // Call given func if any - if ( func ) { - func.call( deferred, deferred ); - } - - // All done! - return deferred; - }, - - // Deferred helper - when: function( singleValue ) { - var - - // count of uncompleted subordinates - remaining = arguments.length, - - // count of unprocessed arguments - i = remaining, - - // subordinate fulfillment data - resolveContexts = Array( i ), - resolveValues = slice.call( arguments ), - - // the master Deferred - master = jQuery.Deferred(), - - // subordinate callback factory - updateFunc = function( i ) { - return function( value ) { - resolveContexts[ i ] = this; - resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; - if ( !( --remaining ) ) { - master.resolveWith( resolveContexts, resolveValues ); - } - }; - }; - - // Single- and empty arguments are adopted like Promise.resolve - if ( remaining <= 1 ) { - adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, - !remaining ); - - // Use .then() to unwrap secondary thenables (cf. gh-3000) - if ( master.state() === "pending" || - isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { - - return master.then(); - } - } - - // Multiple arguments are aggregated like Promise.all array elements - while ( i-- ) { - adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); - } - - return master.promise(); - } -} ); - - -// These usually indicate a programmer mistake during development, -// warn about them ASAP rather than swallowing them by default. -var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; - -jQuery.Deferred.exceptionHook = function( error, stack ) { - - // Support: IE 8 - 9 only - // Console exists when dev tools are open, which can happen at any time - if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { - window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); - } -}; - - - - -jQuery.readyException = function( error ) { - window.setTimeout( function() { - throw error; - } ); -}; - - - - -// The deferred used on DOM ready -var readyList = jQuery.Deferred(); - -jQuery.fn.ready = function( fn ) { - - readyList - .then( fn ) - - // Wrap jQuery.readyException in a function so that the lookup - // happens at the time of error handling instead of callback - // registration. - .catch( function( error ) { - jQuery.readyException( error ); - } ); - - return this; -}; - -jQuery.extend( { - - // Is the DOM ready to be used? Set to true once it occurs. - isReady: false, - - // A counter to track how many items to wait for before - // the ready event fires. See #6781 - readyWait: 1, - - // Handle when the DOM is ready - ready: function( wait ) { - - // Abort if there are pending holds or we're already ready - if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { - return; - } - - // Remember that the DOM is ready - jQuery.isReady = true; - - // If a normal DOM Ready event fired, decrement, and wait if need be - if ( wait !== true && --jQuery.readyWait > 0 ) { - return; - } - - // If there are functions bound, to execute - readyList.resolveWith( document, [ jQuery ] ); - } -} ); - -jQuery.ready.then = readyList.then; - -// The ready event handler and self cleanup method -function completed() { - document.removeEventListener( "DOMContentLoaded", completed ); - window.removeEventListener( "load", completed ); - jQuery.ready(); -} - -// Catch cases where $(document).ready() is called -// after the browser event has already occurred. -// Support: IE <=9 - 10 only -// Older IE sometimes signals "interactive" too soon -if ( document.readyState === "complete" || - ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { - - // Handle it asynchronously to allow scripts the opportunity to delay ready - window.setTimeout( jQuery.ready ); - -} else { - - // Use the handy event callback - document.addEventListener( "DOMContentLoaded", completed ); - - // A fallback to window.onload, that will always work - window.addEventListener( "load", completed ); -} - - - - -// Multifunctional method to get and set values of a collection -// The value/s can optionally be executed if it's a function -var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { - var i = 0, - len = elems.length, - bulk = key == null; - - // Sets many values - if ( toType( key ) === "object" ) { - chainable = true; - for ( i in key ) { - access( elems, fn, i, key[ i ], true, emptyGet, raw ); - } - - // Sets one value - } else if ( value !== undefined ) { - chainable = true; - - if ( !isFunction( value ) ) { - raw = true; - } - - if ( bulk ) { - - // Bulk operations run against the entire set - if ( raw ) { - fn.call( elems, value ); - fn = null; - - // ...except when executing function values - } else { - bulk = fn; - fn = function( elem, _key, value ) { - return bulk.call( jQuery( elem ), value ); - }; - } - } - - if ( fn ) { - for ( ; i < len; i++ ) { - fn( - elems[ i ], key, raw ? - value : - value.call( elems[ i ], i, fn( elems[ i ], key ) ) - ); - } - } - } - - if ( chainable ) { - return elems; - } - - // Gets - if ( bulk ) { - return fn.call( elems ); - } - - return len ? fn( elems[ 0 ], key ) : emptyGet; -}; - - -// Matches dashed string for camelizing -var rmsPrefix = /^-ms-/, - rdashAlpha = /-([a-z])/g; - -// Used by camelCase as callback to replace() -function fcamelCase( _all, letter ) { - return letter.toUpperCase(); -} - -// Convert dashed to camelCase; used by the css and data modules -// Support: IE <=9 - 11, Edge 12 - 15 -// Microsoft forgot to hump their vendor prefix (#9572) -function camelCase( string ) { - return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); -} -var acceptData = function( owner ) { - - // Accepts only: - // - Node - // - Node.ELEMENT_NODE - // - Node.DOCUMENT_NODE - // - Object - // - Any - return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); -}; - - - - -function Data() { - this.expando = jQuery.expando + Data.uid++; -} - -Data.uid = 1; - -Data.prototype = { - - cache: function( owner ) { - - // Check if the owner object already has a cache - var value = owner[ this.expando ]; - - // If not, create one - if ( !value ) { - value = {}; - - // We can accept data for non-element nodes in modern browsers, - // but we should not, see #8335. - // Always return an empty object. - if ( acceptData( owner ) ) { - - // If it is a node unlikely to be stringify-ed or looped over - // use plain assignment - if ( owner.nodeType ) { - owner[ this.expando ] = value; - - // Otherwise secure it in a non-enumerable property - // configurable must be true to allow the property to be - // deleted when data is removed - } else { - Object.defineProperty( owner, this.expando, { - value: value, - configurable: true - } ); - } - } - } - - return value; - }, - set: function( owner, data, value ) { - var prop, - cache = this.cache( owner ); - - // Handle: [ owner, key, value ] args - // Always use camelCase key (gh-2257) - if ( typeof data === "string" ) { - cache[ camelCase( data ) ] = value; - - // Handle: [ owner, { properties } ] args - } else { - - // Copy the properties one-by-one to the cache object - for ( prop in data ) { - cache[ camelCase( prop ) ] = data[ prop ]; - } - } - return cache; - }, - get: function( owner, key ) { - return key === undefined ? - this.cache( owner ) : - - // Always use camelCase key (gh-2257) - owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; - }, - access: function( owner, key, value ) { - - // In cases where either: - // - // 1. No key was specified - // 2. A string key was specified, but no value provided - // - // Take the "read" path and allow the get method to determine - // which value to return, respectively either: - // - // 1. The entire cache object - // 2. The data stored at the key - // - if ( key === undefined || - ( ( key && typeof key === "string" ) && value === undefined ) ) { - - return this.get( owner, key ); - } - - // When the key is not a string, or both a key and value - // are specified, set or extend (existing objects) with either: - // - // 1. An object of properties - // 2. A key and value - // - this.set( owner, key, value ); - - // Since the "set" path can have two possible entry points - // return the expected data based on which path was taken[*] - return value !== undefined ? value : key; - }, - remove: function( owner, key ) { - var i, - cache = owner[ this.expando ]; - - if ( cache === undefined ) { - return; - } - - if ( key !== undefined ) { - - // Support array or space separated string of keys - if ( Array.isArray( key ) ) { - - // If key is an array of keys... - // We always set camelCase keys, so remove that. - key = key.map( camelCase ); - } else { - key = camelCase( key ); - - // If a key with the spaces exists, use it. - // Otherwise, create an array by matching non-whitespace - key = key in cache ? - [ key ] : - ( key.match( rnothtmlwhite ) || [] ); - } - - i = key.length; - - while ( i-- ) { - delete cache[ key[ i ] ]; - } - } - - // Remove the expando if there's no more data - if ( key === undefined || jQuery.isEmptyObject( cache ) ) { - - // Support: Chrome <=35 - 45 - // Webkit & Blink performance suffers when deleting properties - // from DOM nodes, so set to undefined instead - // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) - if ( owner.nodeType ) { - owner[ this.expando ] = undefined; - } else { - delete owner[ this.expando ]; - } - } - }, - hasData: function( owner ) { - var cache = owner[ this.expando ]; - return cache !== undefined && !jQuery.isEmptyObject( cache ); - } -}; -var dataPriv = new Data(); - -var dataUser = new Data(); - - - -// Implementation Summary -// -// 1. Enforce API surface and semantic compatibility with 1.9.x branch -// 2. Improve the module's maintainability by reducing the storage -// paths to a single mechanism. -// 3. Use the same single mechanism to support "private" and "user" data. -// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) -// 5. Avoid exposing implementation details on user objects (eg. expando properties) -// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 - -var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, - rmultiDash = /[A-Z]/g; - -function getData( data ) { - if ( data === "true" ) { - return true; - } - - if ( data === "false" ) { - return false; - } - - if ( data === "null" ) { - return null; - } - - // Only convert to a number if it doesn't change the string - if ( data === +data + "" ) { - return +data; - } - - if ( rbrace.test( data ) ) { - return JSON.parse( data ); - } - - return data; -} - -function dataAttr( elem, key, data ) { - var name; - - // If nothing was found internally, try to fetch any - // data from the HTML5 data-* attribute - if ( data === undefined && elem.nodeType === 1 ) { - name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); - data = elem.getAttribute( name ); - - if ( typeof data === "string" ) { - try { - data = getData( data ); - } catch ( e ) {} - - // Make sure we set the data so it isn't changed later - dataUser.set( elem, key, data ); - } else { - data = undefined; - } - } - return data; -} - -jQuery.extend( { - hasData: function( elem ) { - return dataUser.hasData( elem ) || dataPriv.hasData( elem ); - }, - - data: function( elem, name, data ) { - return dataUser.access( elem, name, data ); - }, - - removeData: function( elem, name ) { - dataUser.remove( elem, name ); - }, - - // TODO: Now that all calls to _data and _removeData have been replaced - // with direct calls to dataPriv methods, these can be deprecated. - _data: function( elem, name, data ) { - return dataPriv.access( elem, name, data ); - }, - - _removeData: function( elem, name ) { - dataPriv.remove( elem, name ); - } -} ); - -jQuery.fn.extend( { - data: function( key, value ) { - var i, name, data, - elem = this[ 0 ], - attrs = elem && elem.attributes; - - // Gets all values - if ( key === undefined ) { - if ( this.length ) { - data = dataUser.get( elem ); - - if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { - i = attrs.length; - while ( i-- ) { - - // Support: IE 11 only - // The attrs elements can be null (#14894) - if ( attrs[ i ] ) { - name = attrs[ i ].name; - if ( name.indexOf( "data-" ) === 0 ) { - name = camelCase( name.slice( 5 ) ); - dataAttr( elem, name, data[ name ] ); - } - } - } - dataPriv.set( elem, "hasDataAttrs", true ); - } - } - - return data; - } - - // Sets multiple values - if ( typeof key === "object" ) { - return this.each( function() { - dataUser.set( this, key ); - } ); - } - - return access( this, function( value ) { - var data; - - // The calling jQuery object (element matches) is not empty - // (and therefore has an element appears at this[ 0 ]) and the - // `value` parameter was not undefined. An empty jQuery object - // will result in `undefined` for elem = this[ 0 ] which will - // throw an exception if an attempt to read a data cache is made. - if ( elem && value === undefined ) { - - // Attempt to get data from the cache - // The key will always be camelCased in Data - data = dataUser.get( elem, key ); - if ( data !== undefined ) { - return data; - } - - // Attempt to "discover" the data in - // HTML5 custom data-* attrs - data = dataAttr( elem, key ); - if ( data !== undefined ) { - return data; - } - - // We tried really hard, but the data doesn't exist. - return; - } - - // Set the data... - this.each( function() { - - // We always store the camelCased key - dataUser.set( this, key, value ); - } ); - }, null, value, arguments.length > 1, null, true ); - }, - - removeData: function( key ) { - return this.each( function() { - dataUser.remove( this, key ); - } ); - } -} ); - - -jQuery.extend( { - queue: function( elem, type, data ) { - var queue; - - if ( elem ) { - type = ( type || "fx" ) + "queue"; - queue = dataPriv.get( elem, type ); - - // Speed up dequeue by getting out quickly if this is just a lookup - if ( data ) { - if ( !queue || Array.isArray( data ) ) { - queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); - } else { - queue.push( data ); - } - } - return queue || []; - } - }, - - dequeue: function( elem, type ) { - type = type || "fx"; - - var queue = jQuery.queue( elem, type ), - startLength = queue.length, - fn = queue.shift(), - hooks = jQuery._queueHooks( elem, type ), - next = function() { - jQuery.dequeue( elem, type ); - }; - - // If the fx queue is dequeued, always remove the progress sentinel - if ( fn === "inprogress" ) { - fn = queue.shift(); - startLength--; - } - - if ( fn ) { - - // Add a progress sentinel to prevent the fx queue from being - // automatically dequeued - if ( type === "fx" ) { - queue.unshift( "inprogress" ); - } - - // Clear up the last queue stop function - delete hooks.stop; - fn.call( elem, next, hooks ); - } - - if ( !startLength && hooks ) { - hooks.empty.fire(); - } - }, - - // Not public - generate a queueHooks object, or return the current one - _queueHooks: function( elem, type ) { - var key = type + "queueHooks"; - return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { - empty: jQuery.Callbacks( "once memory" ).add( function() { - dataPriv.remove( elem, [ type + "queue", key ] ); - } ) - } ); - } -} ); - -jQuery.fn.extend( { - queue: function( type, data ) { - var setter = 2; - - if ( typeof type !== "string" ) { - data = type; - type = "fx"; - setter--; - } - - if ( arguments.length < setter ) { - return jQuery.queue( this[ 0 ], type ); - } - - return data === undefined ? - this : - this.each( function() { - var queue = jQuery.queue( this, type, data ); - - // Ensure a hooks for this queue - jQuery._queueHooks( this, type ); - - if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { - jQuery.dequeue( this, type ); - } - } ); - }, - dequeue: function( type ) { - return this.each( function() { - jQuery.dequeue( this, type ); - } ); - }, - clearQueue: function( type ) { - return this.queue( type || "fx", [] ); - }, - - // Get a promise resolved when queues of a certain type - // are emptied (fx is the type by default) - promise: function( type, obj ) { - var tmp, - count = 1, - defer = jQuery.Deferred(), - elements = this, - i = this.length, - resolve = function() { - if ( !( --count ) ) { - defer.resolveWith( elements, [ elements ] ); - } - }; - - if ( typeof type !== "string" ) { - obj = type; - type = undefined; - } - type = type || "fx"; - - while ( i-- ) { - tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); - if ( tmp && tmp.empty ) { - count++; - tmp.empty.add( resolve ); - } - } - resolve(); - return defer.promise( obj ); - } -} ); -var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; - -var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); - - -var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; - -var documentElement = document.documentElement; - - - - var isAttached = function( elem ) { - return jQuery.contains( elem.ownerDocument, elem ); - }, - composed = { composed: true }; - - // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only - // Check attachment across shadow DOM boundaries when possible (gh-3504) - // Support: iOS 10.0-10.2 only - // Early iOS 10 versions support `attachShadow` but not `getRootNode`, - // leading to errors. We need to check for `getRootNode`. - if ( documentElement.getRootNode ) { - isAttached = function( elem ) { - return jQuery.contains( elem.ownerDocument, elem ) || - elem.getRootNode( composed ) === elem.ownerDocument; - }; - } -var isHiddenWithinTree = function( elem, el ) { - - // isHiddenWithinTree might be called from jQuery#filter function; - // in that case, element will be second argument - elem = el || elem; - - // Inline style trumps all - return elem.style.display === "none" || - elem.style.display === "" && - - // Otherwise, check computed style - // Support: Firefox <=43 - 45 - // Disconnected elements can have computed display: none, so first confirm that elem is - // in the document. - isAttached( elem ) && - - jQuery.css( elem, "display" ) === "none"; - }; - - - -function adjustCSS( elem, prop, valueParts, tween ) { - var adjusted, scale, - maxIterations = 20, - currentValue = tween ? - function() { - return tween.cur(); - } : - function() { - return jQuery.css( elem, prop, "" ); - }, - initial = currentValue(), - unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), - - // Starting value computation is required for potential unit mismatches - initialInUnit = elem.nodeType && - ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && - rcssNum.exec( jQuery.css( elem, prop ) ); - - if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { - - // Support: Firefox <=54 - // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) - initial = initial / 2; - - // Trust units reported by jQuery.css - unit = unit || initialInUnit[ 3 ]; - - // Iteratively approximate from a nonzero starting point - initialInUnit = +initial || 1; - - while ( maxIterations-- ) { - - // Evaluate and update our best guess (doubling guesses that zero out). - // Finish if the scale equals or crosses 1 (making the old*new product non-positive). - jQuery.style( elem, prop, initialInUnit + unit ); - if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { - maxIterations = 0; - } - initialInUnit = initialInUnit / scale; - - } - - initialInUnit = initialInUnit * 2; - jQuery.style( elem, prop, initialInUnit + unit ); - - // Make sure we update the tween properties later on - valueParts = valueParts || []; - } - - if ( valueParts ) { - initialInUnit = +initialInUnit || +initial || 0; - - // Apply relative offset (+=/-=) if specified - adjusted = valueParts[ 1 ] ? - initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : - +valueParts[ 2 ]; - if ( tween ) { - tween.unit = unit; - tween.start = initialInUnit; - tween.end = adjusted; - } - } - return adjusted; -} - - -var defaultDisplayMap = {}; - -function getDefaultDisplay( elem ) { - var temp, - doc = elem.ownerDocument, - nodeName = elem.nodeName, - display = defaultDisplayMap[ nodeName ]; - - if ( display ) { - return display; - } - - temp = doc.body.appendChild( doc.createElement( nodeName ) ); - display = jQuery.css( temp, "display" ); - - temp.parentNode.removeChild( temp ); - - if ( display === "none" ) { - display = "block"; - } - defaultDisplayMap[ nodeName ] = display; - - return display; -} - -function showHide( elements, show ) { - var display, elem, - values = [], - index = 0, - length = elements.length; - - // Determine new display value for elements that need to change - for ( ; index < length; index++ ) { - elem = elements[ index ]; - if ( !elem.style ) { - continue; - } - - display = elem.style.display; - if ( show ) { - - // Since we force visibility upon cascade-hidden elements, an immediate (and slow) - // check is required in this first loop unless we have a nonempty display value (either - // inline or about-to-be-restored) - if ( display === "none" ) { - values[ index ] = dataPriv.get( elem, "display" ) || null; - if ( !values[ index ] ) { - elem.style.display = ""; - } - } - if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { - values[ index ] = getDefaultDisplay( elem ); - } - } else { - if ( display !== "none" ) { - values[ index ] = "none"; - - // Remember what we're overwriting - dataPriv.set( elem, "display", display ); - } - } - } - - // Set the display of the elements in a second loop to avoid constant reflow - for ( index = 0; index < length; index++ ) { - if ( values[ index ] != null ) { - elements[ index ].style.display = values[ index ]; - } - } - - return elements; -} - -jQuery.fn.extend( { - show: function() { - return showHide( this, true ); - }, - hide: function() { - return showHide( this ); - }, - toggle: function( state ) { - if ( typeof state === "boolean" ) { - return state ? this.show() : this.hide(); - } - - return this.each( function() { - if ( isHiddenWithinTree( this ) ) { - jQuery( this ).show(); - } else { - jQuery( this ).hide(); - } - } ); - } -} ); -var rcheckableType = ( /^(?:checkbox|radio)$/i ); - -var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); - -var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); - - - -( function() { - var fragment = document.createDocumentFragment(), - div = fragment.appendChild( document.createElement( "div" ) ), - input = document.createElement( "input" ); - - // Support: Android 4.0 - 4.3 only - // Check state lost if the name is set (#11217) - // Support: Windows Web Apps (WWA) - // `name` and `type` must use .setAttribute for WWA (#14901) - input.setAttribute( "type", "radio" ); - input.setAttribute( "checked", "checked" ); - input.setAttribute( "name", "t" ); - - div.appendChild( input ); - - // Support: Android <=4.1 only - // Older WebKit doesn't clone checked state correctly in fragments - support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; - - // Support: IE <=11 only - // Make sure textarea (and checkbox) defaultValue is properly cloned - div.innerHTML = ""; - support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; - - // Support: IE <=9 only - // IE <=9 replaces "; - support.option = !!div.lastChild; -} )(); - - -// We have to close these tags to support XHTML (#13200) -var wrapMap = { - - // XHTML parsers do not magically insert elements in the - // same way that tag soup parsers do. So we cannot shorten - // this by omitting or other required elements. - thead: [ 1, "", "
" ], - col: [ 2, "", "
" ], - tr: [ 2, "", "
" ], - td: [ 3, "", "
" ], - - _default: [ 0, "", "" ] -}; - -wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; -wrapMap.th = wrapMap.td; - -// Support: IE <=9 only -if ( !support.option ) { - wrapMap.optgroup = wrapMap.option = [ 1, "" ]; -} - - -function getAll( context, tag ) { - - // Support: IE <=9 - 11 only - // Use typeof to avoid zero-argument method invocation on host objects (#15151) - var ret; - - if ( typeof context.getElementsByTagName !== "undefined" ) { - ret = context.getElementsByTagName( tag || "*" ); - - } else if ( typeof context.querySelectorAll !== "undefined" ) { - ret = context.querySelectorAll( tag || "*" ); - - } else { - ret = []; - } - - if ( tag === undefined || tag && nodeName( context, tag ) ) { - return jQuery.merge( [ context ], ret ); - } - - return ret; -} - - -// Mark scripts as having already been evaluated -function setGlobalEval( elems, refElements ) { - var i = 0, - l = elems.length; - - for ( ; i < l; i++ ) { - dataPriv.set( - elems[ i ], - "globalEval", - !refElements || dataPriv.get( refElements[ i ], "globalEval" ) - ); - } -} - - -var rhtml = /<|&#?\w+;/; - -function buildFragment( elems, context, scripts, selection, ignored ) { - var elem, tmp, tag, wrap, attached, j, - fragment = context.createDocumentFragment(), - nodes = [], - i = 0, - l = elems.length; - - for ( ; i < l; i++ ) { - elem = elems[ i ]; - - if ( elem || elem === 0 ) { - - // Add nodes directly - if ( toType( elem ) === "object" ) { - - // Support: Android <=4.0 only, PhantomJS 1 only - // push.apply(_, arraylike) throws on ancient WebKit - jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); - - // Convert non-html into a text node - } else if ( !rhtml.test( elem ) ) { - nodes.push( context.createTextNode( elem ) ); - - // Convert html into DOM nodes - } else { - tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); - - // Deserialize a standard representation - tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); - wrap = wrapMap[ tag ] || wrapMap._default; - tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; - - // Descend through wrappers to the right content - j = wrap[ 0 ]; - while ( j-- ) { - tmp = tmp.lastChild; - } - - // Support: Android <=4.0 only, PhantomJS 1 only - // push.apply(_, arraylike) throws on ancient WebKit - jQuery.merge( nodes, tmp.childNodes ); - - // Remember the top-level container - tmp = fragment.firstChild; - - // Ensure the created nodes are orphaned (#12392) - tmp.textContent = ""; - } - } - } - - // Remove wrapper from fragment - fragment.textContent = ""; - - i = 0; - while ( ( elem = nodes[ i++ ] ) ) { - - // Skip elements already in the context collection (trac-4087) - if ( selection && jQuery.inArray( elem, selection ) > -1 ) { - if ( ignored ) { - ignored.push( elem ); - } - continue; - } - - attached = isAttached( elem ); - - // Append to fragment - tmp = getAll( fragment.appendChild( elem ), "script" ); - - // Preserve script evaluation history - if ( attached ) { - setGlobalEval( tmp ); - } - - // Capture executables - if ( scripts ) { - j = 0; - while ( ( elem = tmp[ j++ ] ) ) { - if ( rscriptType.test( elem.type || "" ) ) { - scripts.push( elem ); - } - } - } - } - - return fragment; -} - - -var - rkeyEvent = /^key/, - rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, - rtypenamespace = /^([^.]*)(?:\.(.+)|)/; - -function returnTrue() { - return true; -} - -function returnFalse() { - return false; -} - -// Support: IE <=9 - 11+ -// focus() and blur() are asynchronous, except when they are no-op. -// So expect focus to be synchronous when the element is already active, -// and blur to be synchronous when the element is not already active. -// (focus and blur are always synchronous in other supported browsers, -// this just defines when we can count on it). -function expectSync( elem, type ) { - return ( elem === safeActiveElement() ) === ( type === "focus" ); -} - -// Support: IE <=9 only -// Accessing document.activeElement can throw unexpectedly -// https://bugs.jquery.com/ticket/13393 -function safeActiveElement() { - try { - return document.activeElement; - } catch ( err ) { } -} - -function on( elem, types, selector, data, fn, one ) { - var origFn, type; - - // Types can be a map of types/handlers - if ( typeof types === "object" ) { - - // ( types-Object, selector, data ) - if ( typeof selector !== "string" ) { - - // ( types-Object, data ) - data = data || selector; - selector = undefined; - } - for ( type in types ) { - on( elem, type, selector, data, types[ type ], one ); - } - return elem; - } - - if ( data == null && fn == null ) { - - // ( types, fn ) - fn = selector; - data = selector = undefined; - } else if ( fn == null ) { - if ( typeof selector === "string" ) { - - // ( types, selector, fn ) - fn = data; - data = undefined; - } else { - - // ( types, data, fn ) - fn = data; - data = selector; - selector = undefined; - } - } - if ( fn === false ) { - fn = returnFalse; - } else if ( !fn ) { - return elem; - } - - if ( one === 1 ) { - origFn = fn; - fn = function( event ) { - - // Can use an empty set, since event contains the info - jQuery().off( event ); - return origFn.apply( this, arguments ); - }; - - // Use same guid so caller can remove using origFn - fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); - } - return elem.each( function() { - jQuery.event.add( this, types, fn, data, selector ); - } ); -} - -/* - * Helper functions for managing events -- not part of the public interface. - * Props to Dean Edwards' addEvent library for many of the ideas. - */ -jQuery.event = { - - global: {}, - - add: function( elem, types, handler, data, selector ) { - - var handleObjIn, eventHandle, tmp, - events, t, handleObj, - special, handlers, type, namespaces, origType, - elemData = dataPriv.get( elem ); - - // Only attach events to objects that accept data - if ( !acceptData( elem ) ) { - return; - } - - // Caller can pass in an object of custom data in lieu of the handler - if ( handler.handler ) { - handleObjIn = handler; - handler = handleObjIn.handler; - selector = handleObjIn.selector; - } - - // Ensure that invalid selectors throw exceptions at attach time - // Evaluate against documentElement in case elem is a non-element node (e.g., document) - if ( selector ) { - jQuery.find.matchesSelector( documentElement, selector ); - } - - // Make sure that the handler has a unique ID, used to find/remove it later - if ( !handler.guid ) { - handler.guid = jQuery.guid++; - } - - // Init the element's event structure and main handler, if this is the first - if ( !( events = elemData.events ) ) { - events = elemData.events = Object.create( null ); - } - if ( !( eventHandle = elemData.handle ) ) { - eventHandle = elemData.handle = function( e ) { - - // Discard the second event of a jQuery.event.trigger() and - // when an event is called after a page has unloaded - return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? - jQuery.event.dispatch.apply( elem, arguments ) : undefined; - }; - } - - // Handle multiple events separated by a space - types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; - t = types.length; - while ( t-- ) { - tmp = rtypenamespace.exec( types[ t ] ) || []; - type = origType = tmp[ 1 ]; - namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); - - // There *must* be a type, no attaching namespace-only handlers - if ( !type ) { - continue; - } - - // If event changes its type, use the special event handlers for the changed type - special = jQuery.event.special[ type ] || {}; - - // If selector defined, determine special event api type, otherwise given type - type = ( selector ? special.delegateType : special.bindType ) || type; - - // Update special based on newly reset type - special = jQuery.event.special[ type ] || {}; - - // handleObj is passed to all event handlers - handleObj = jQuery.extend( { - type: type, - origType: origType, - data: data, - handler: handler, - guid: handler.guid, - selector: selector, - needsContext: selector && jQuery.expr.match.needsContext.test( selector ), - namespace: namespaces.join( "." ) - }, handleObjIn ); - - // Init the event handler queue if we're the first - if ( !( handlers = events[ type ] ) ) { - handlers = events[ type ] = []; - handlers.delegateCount = 0; - - // Only use addEventListener if the special events handler returns false - if ( !special.setup || - special.setup.call( elem, data, namespaces, eventHandle ) === false ) { - - if ( elem.addEventListener ) { - elem.addEventListener( type, eventHandle ); - } - } - } - - if ( special.add ) { - special.add.call( elem, handleObj ); - - if ( !handleObj.handler.guid ) { - handleObj.handler.guid = handler.guid; - } - } - - // Add to the element's handler list, delegates in front - if ( selector ) { - handlers.splice( handlers.delegateCount++, 0, handleObj ); - } else { - handlers.push( handleObj ); - } - - // Keep track of which events have ever been used, for event optimization - jQuery.event.global[ type ] = true; - } - - }, - - // Detach an event or set of events from an element - remove: function( elem, types, handler, selector, mappedTypes ) { - - var j, origCount, tmp, - events, t, handleObj, - special, handlers, type, namespaces, origType, - elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); - - if ( !elemData || !( events = elemData.events ) ) { - return; - } - - // Once for each type.namespace in types; type may be omitted - types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; - t = types.length; - while ( t-- ) { - tmp = rtypenamespace.exec( types[ t ] ) || []; - type = origType = tmp[ 1 ]; - namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); - - // Unbind all events (on this namespace, if provided) for the element - if ( !type ) { - for ( type in events ) { - jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); - } - continue; - } - - special = jQuery.event.special[ type ] || {}; - type = ( selector ? special.delegateType : special.bindType ) || type; - handlers = events[ type ] || []; - tmp = tmp[ 2 ] && - new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); - - // Remove matching events - origCount = j = handlers.length; - while ( j-- ) { - handleObj = handlers[ j ]; - - if ( ( mappedTypes || origType === handleObj.origType ) && - ( !handler || handler.guid === handleObj.guid ) && - ( !tmp || tmp.test( handleObj.namespace ) ) && - ( !selector || selector === handleObj.selector || - selector === "**" && handleObj.selector ) ) { - handlers.splice( j, 1 ); - - if ( handleObj.selector ) { - handlers.delegateCount--; - } - if ( special.remove ) { - special.remove.call( elem, handleObj ); - } - } - } - - // Remove generic event handler if we removed something and no more handlers exist - // (avoids potential for endless recursion during removal of special event handlers) - if ( origCount && !handlers.length ) { - if ( !special.teardown || - special.teardown.call( elem, namespaces, elemData.handle ) === false ) { - - jQuery.removeEvent( elem, type, elemData.handle ); - } - - delete events[ type ]; - } - } - - // Remove data and the expando if it's no longer used - if ( jQuery.isEmptyObject( events ) ) { - dataPriv.remove( elem, "handle events" ); - } - }, - - dispatch: function( nativeEvent ) { - - var i, j, ret, matched, handleObj, handlerQueue, - args = new Array( arguments.length ), - - // Make a writable jQuery.Event from the native event object - event = jQuery.event.fix( nativeEvent ), - - handlers = ( - dataPriv.get( this, "events" ) || Object.create( null ) - )[ event.type ] || [], - special = jQuery.event.special[ event.type ] || {}; - - // Use the fix-ed jQuery.Event rather than the (read-only) native event - args[ 0 ] = event; - - for ( i = 1; i < arguments.length; i++ ) { - args[ i ] = arguments[ i ]; - } - - event.delegateTarget = this; - - // Call the preDispatch hook for the mapped type, and let it bail if desired - if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { - return; - } - - // Determine handlers - handlerQueue = jQuery.event.handlers.call( this, event, handlers ); - - // Run delegates first; they may want to stop propagation beneath us - i = 0; - while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { - event.currentTarget = matched.elem; - - j = 0; - while ( ( handleObj = matched.handlers[ j++ ] ) && - !event.isImmediatePropagationStopped() ) { - - // If the event is namespaced, then each handler is only invoked if it is - // specially universal or its namespaces are a superset of the event's. - if ( !event.rnamespace || handleObj.namespace === false || - event.rnamespace.test( handleObj.namespace ) ) { - - event.handleObj = handleObj; - event.data = handleObj.data; - - ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || - handleObj.handler ).apply( matched.elem, args ); - - if ( ret !== undefined ) { - if ( ( event.result = ret ) === false ) { - event.preventDefault(); - event.stopPropagation(); - } - } - } - } - } - - // Call the postDispatch hook for the mapped type - if ( special.postDispatch ) { - special.postDispatch.call( this, event ); - } - - return event.result; - }, - - handlers: function( event, handlers ) { - var i, handleObj, sel, matchedHandlers, matchedSelectors, - handlerQueue = [], - delegateCount = handlers.delegateCount, - cur = event.target; - - // Find delegate handlers - if ( delegateCount && - - // Support: IE <=9 - // Black-hole SVG instance trees (trac-13180) - cur.nodeType && - - // Support: Firefox <=42 - // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) - // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click - // Support: IE 11 only - // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) - !( event.type === "click" && event.button >= 1 ) ) { - - for ( ; cur !== this; cur = cur.parentNode || this ) { - - // Don't check non-elements (#13208) - // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) - if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { - matchedHandlers = []; - matchedSelectors = {}; - for ( i = 0; i < delegateCount; i++ ) { - handleObj = handlers[ i ]; - - // Don't conflict with Object.prototype properties (#13203) - sel = handleObj.selector + " "; - - if ( matchedSelectors[ sel ] === undefined ) { - matchedSelectors[ sel ] = handleObj.needsContext ? - jQuery( sel, this ).index( cur ) > -1 : - jQuery.find( sel, this, null, [ cur ] ).length; - } - if ( matchedSelectors[ sel ] ) { - matchedHandlers.push( handleObj ); - } - } - if ( matchedHandlers.length ) { - handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); - } - } - } - } - - // Add the remaining (directly-bound) handlers - cur = this; - if ( delegateCount < handlers.length ) { - handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); - } - - return handlerQueue; - }, - - addProp: function( name, hook ) { - Object.defineProperty( jQuery.Event.prototype, name, { - enumerable: true, - configurable: true, - - get: isFunction( hook ) ? - function() { - if ( this.originalEvent ) { - return hook( this.originalEvent ); - } - } : - function() { - if ( this.originalEvent ) { - return this.originalEvent[ name ]; - } - }, - - set: function( value ) { - Object.defineProperty( this, name, { - enumerable: true, - configurable: true, - writable: true, - value: value - } ); - } - } ); - }, - - fix: function( originalEvent ) { - return originalEvent[ jQuery.expando ] ? - originalEvent : - new jQuery.Event( originalEvent ); - }, - - special: { - load: { - - // Prevent triggered image.load events from bubbling to window.load - noBubble: true - }, - click: { - - // Utilize native event to ensure correct state for checkable inputs - setup: function( data ) { - - // For mutual compressibility with _default, replace `this` access with a local var. - // `|| data` is dead code meant only to preserve the variable through minification. - var el = this || data; - - // Claim the first handler - if ( rcheckableType.test( el.type ) && - el.click && nodeName( el, "input" ) ) { - - // dataPriv.set( el, "click", ... ) - leverageNative( el, "click", returnTrue ); - } - - // Return false to allow normal processing in the caller - return false; - }, - trigger: function( data ) { - - // For mutual compressibility with _default, replace `this` access with a local var. - // `|| data` is dead code meant only to preserve the variable through minification. - var el = this || data; - - // Force setup before triggering a click - if ( rcheckableType.test( el.type ) && - el.click && nodeName( el, "input" ) ) { - - leverageNative( el, "click" ); - } - - // Return non-false to allow normal event-path propagation - return true; - }, - - // For cross-browser consistency, suppress native .click() on links - // Also prevent it if we're currently inside a leveraged native-event stack - _default: function( event ) { - var target = event.target; - return rcheckableType.test( target.type ) && - target.click && nodeName( target, "input" ) && - dataPriv.get( target, "click" ) || - nodeName( target, "a" ); - } - }, - - beforeunload: { - postDispatch: function( event ) { - - // Support: Firefox 20+ - // Firefox doesn't alert if the returnValue field is not set. - if ( event.result !== undefined && event.originalEvent ) { - event.originalEvent.returnValue = event.result; - } - } - } - } -}; - -// Ensure the presence of an event listener that handles manually-triggered -// synthetic events by interrupting progress until reinvoked in response to -// *native* events that it fires directly, ensuring that state changes have -// already occurred before other listeners are invoked. -function leverageNative( el, type, expectSync ) { - - // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add - if ( !expectSync ) { - if ( dataPriv.get( el, type ) === undefined ) { - jQuery.event.add( el, type, returnTrue ); - } - return; - } - - // Register the controller as a special universal handler for all event namespaces - dataPriv.set( el, type, false ); - jQuery.event.add( el, type, { - namespace: false, - handler: function( event ) { - var notAsync, result, - saved = dataPriv.get( this, type ); - - if ( ( event.isTrigger & 1 ) && this[ type ] ) { - - // Interrupt processing of the outer synthetic .trigger()ed event - // Saved data should be false in such cases, but might be a leftover capture object - // from an async native handler (gh-4350) - if ( !saved.length ) { - - // Store arguments for use when handling the inner native event - // There will always be at least one argument (an event object), so this array - // will not be confused with a leftover capture object. - saved = slice.call( arguments ); - dataPriv.set( this, type, saved ); - - // Trigger the native event and capture its result - // Support: IE <=9 - 11+ - // focus() and blur() are asynchronous - notAsync = expectSync( this, type ); - this[ type ](); - result = dataPriv.get( this, type ); - if ( saved !== result || notAsync ) { - dataPriv.set( this, type, false ); - } else { - result = {}; - } - if ( saved !== result ) { - - // Cancel the outer synthetic event - event.stopImmediatePropagation(); - event.preventDefault(); - return result.value; - } - - // If this is an inner synthetic event for an event with a bubbling surrogate - // (focus or blur), assume that the surrogate already propagated from triggering the - // native event and prevent that from happening again here. - // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the - // bubbling surrogate propagates *after* the non-bubbling base), but that seems - // less bad than duplication. - } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { - event.stopPropagation(); - } - - // If this is a native event triggered above, everything is now in order - // Fire an inner synthetic event with the original arguments - } else if ( saved.length ) { - - // ...and capture the result - dataPriv.set( this, type, { - value: jQuery.event.trigger( - - // Support: IE <=9 - 11+ - // Extend with the prototype to reset the above stopImmediatePropagation() - jQuery.extend( saved[ 0 ], jQuery.Event.prototype ), - saved.slice( 1 ), - this - ) - } ); - - // Abort handling of the native event - event.stopImmediatePropagation(); - } - } - } ); -} - -jQuery.removeEvent = function( elem, type, handle ) { - - // This "if" is needed for plain objects - if ( elem.removeEventListener ) { - elem.removeEventListener( type, handle ); - } -}; - -jQuery.Event = function( src, props ) { - - // Allow instantiation without the 'new' keyword - if ( !( this instanceof jQuery.Event ) ) { - return new jQuery.Event( src, props ); - } - - // Event object - if ( src && src.type ) { - this.originalEvent = src; - this.type = src.type; - - // Events bubbling up the document may have been marked as prevented - // by a handler lower down the tree; reflect the correct value. - this.isDefaultPrevented = src.defaultPrevented || - src.defaultPrevented === undefined && - - // Support: Android <=2.3 only - src.returnValue === false ? - returnTrue : - returnFalse; - - // Create target properties - // Support: Safari <=6 - 7 only - // Target should not be a text node (#504, #13143) - this.target = ( src.target && src.target.nodeType === 3 ) ? - src.target.parentNode : - src.target; - - this.currentTarget = src.currentTarget; - this.relatedTarget = src.relatedTarget; - - // Event type - } else { - this.type = src; - } - - // Put explicitly provided properties onto the event object - if ( props ) { - jQuery.extend( this, props ); - } - - // Create a timestamp if incoming event doesn't have one - this.timeStamp = src && src.timeStamp || Date.now(); - - // Mark it as fixed - this[ jQuery.expando ] = true; -}; - -// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding -// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html -jQuery.Event.prototype = { - constructor: jQuery.Event, - isDefaultPrevented: returnFalse, - isPropagationStopped: returnFalse, - isImmediatePropagationStopped: returnFalse, - isSimulated: false, - - preventDefault: function() { - var e = this.originalEvent; - - this.isDefaultPrevented = returnTrue; - - if ( e && !this.isSimulated ) { - e.preventDefault(); - } - }, - stopPropagation: function() { - var e = this.originalEvent; - - this.isPropagationStopped = returnTrue; - - if ( e && !this.isSimulated ) { - e.stopPropagation(); - } - }, - stopImmediatePropagation: function() { - var e = this.originalEvent; - - this.isImmediatePropagationStopped = returnTrue; - - if ( e && !this.isSimulated ) { - e.stopImmediatePropagation(); - } - - this.stopPropagation(); - } -}; - -// Includes all common event props including KeyEvent and MouseEvent specific props -jQuery.each( { - altKey: true, - bubbles: true, - cancelable: true, - changedTouches: true, - ctrlKey: true, - detail: true, - eventPhase: true, - metaKey: true, - pageX: true, - pageY: true, - shiftKey: true, - view: true, - "char": true, - code: true, - charCode: true, - key: true, - keyCode: true, - button: true, - buttons: true, - clientX: true, - clientY: true, - offsetX: true, - offsetY: true, - pointerId: true, - pointerType: true, - screenX: true, - screenY: true, - targetTouches: true, - toElement: true, - touches: true, - - which: function( event ) { - var button = event.button; - - // Add which for key events - if ( event.which == null && rkeyEvent.test( event.type ) ) { - return event.charCode != null ? event.charCode : event.keyCode; - } - - // Add which for click: 1 === left; 2 === middle; 3 === right - if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { - if ( button & 1 ) { - return 1; - } - - if ( button & 2 ) { - return 3; - } - - if ( button & 4 ) { - return 2; - } - - return 0; - } - - return event.which; - } -}, jQuery.event.addProp ); - -jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { - jQuery.event.special[ type ] = { - - // Utilize native event if possible so blur/focus sequence is correct - setup: function() { - - // Claim the first handler - // dataPriv.set( this, "focus", ... ) - // dataPriv.set( this, "blur", ... ) - leverageNative( this, type, expectSync ); - - // Return false to allow normal processing in the caller - return false; - }, - trigger: function() { - - // Force setup before trigger - leverageNative( this, type ); - - // Return non-false to allow normal event-path propagation - return true; - }, - - delegateType: delegateType - }; -} ); - -// Create mouseenter/leave events using mouseover/out and event-time checks -// so that event delegation works in jQuery. -// Do the same for pointerenter/pointerleave and pointerover/pointerout -// -// Support: Safari 7 only -// Safari sends mouseenter too often; see: -// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 -// for the description of the bug (it existed in older Chrome versions as well). -jQuery.each( { - mouseenter: "mouseover", - mouseleave: "mouseout", - pointerenter: "pointerover", - pointerleave: "pointerout" -}, function( orig, fix ) { - jQuery.event.special[ orig ] = { - delegateType: fix, - bindType: fix, - - handle: function( event ) { - var ret, - target = this, - related = event.relatedTarget, - handleObj = event.handleObj; - - // For mouseenter/leave call the handler if related is outside the target. - // NB: No relatedTarget if the mouse left/entered the browser window - if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { - event.type = handleObj.origType; - ret = handleObj.handler.apply( this, arguments ); - event.type = fix; - } - return ret; - } - }; -} ); - -jQuery.fn.extend( { - - on: function( types, selector, data, fn ) { - return on( this, types, selector, data, fn ); - }, - one: function( types, selector, data, fn ) { - return on( this, types, selector, data, fn, 1 ); - }, - off: function( types, selector, fn ) { - var handleObj, type; - if ( types && types.preventDefault && types.handleObj ) { - - // ( event ) dispatched jQuery.Event - handleObj = types.handleObj; - jQuery( types.delegateTarget ).off( - handleObj.namespace ? - handleObj.origType + "." + handleObj.namespace : - handleObj.origType, - handleObj.selector, - handleObj.handler - ); - return this; - } - if ( typeof types === "object" ) { - - // ( types-object [, selector] ) - for ( type in types ) { - this.off( type, selector, types[ type ] ); - } - return this; - } - if ( selector === false || typeof selector === "function" ) { - - // ( types [, fn] ) - fn = selector; - selector = undefined; - } - if ( fn === false ) { - fn = returnFalse; - } - return this.each( function() { - jQuery.event.remove( this, types, fn, selector ); - } ); - } -} ); - - -var - - // Support: IE <=10 - 11, Edge 12 - 13 only - // In IE/Edge using regex groups here causes severe slowdowns. - // See https://connect.microsoft.com/IE/feedback/details/1736512/ - rnoInnerhtml = /\s*$/g; - -// Prefer a tbody over its parent table for containing new rows -function manipulationTarget( elem, content ) { - if ( nodeName( elem, "table" ) && - nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { - - return jQuery( elem ).children( "tbody" )[ 0 ] || elem; - } - - return elem; -} - -// Replace/restore the type attribute of script elements for safe DOM manipulation -function disableScript( elem ) { - elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; - return elem; -} -function restoreScript( elem ) { - if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { - elem.type = elem.type.slice( 5 ); - } else { - elem.removeAttribute( "type" ); - } - - return elem; -} - -function cloneCopyEvent( src, dest ) { - var i, l, type, pdataOld, udataOld, udataCur, events; - - if ( dest.nodeType !== 1 ) { - return; - } - - // 1. Copy private data: events, handlers, etc. - if ( dataPriv.hasData( src ) ) { - pdataOld = dataPriv.get( src ); - events = pdataOld.events; - - if ( events ) { - dataPriv.remove( dest, "handle events" ); - - for ( type in events ) { - for ( i = 0, l = events[ type ].length; i < l; i++ ) { - jQuery.event.add( dest, type, events[ type ][ i ] ); - } - } - } - } - - // 2. Copy user data - if ( dataUser.hasData( src ) ) { - udataOld = dataUser.access( src ); - udataCur = jQuery.extend( {}, udataOld ); - - dataUser.set( dest, udataCur ); - } -} - -// Fix IE bugs, see support tests -function fixInput( src, dest ) { - var nodeName = dest.nodeName.toLowerCase(); - - // Fails to persist the checked state of a cloned checkbox or radio button. - if ( nodeName === "input" && rcheckableType.test( src.type ) ) { - dest.checked = src.checked; - - // Fails to return the selected option to the default selected state when cloning options - } else if ( nodeName === "input" || nodeName === "textarea" ) { - dest.defaultValue = src.defaultValue; - } -} - -function domManip( collection, args, callback, ignored ) { - - // Flatten any nested arrays - args = flat( args ); - - var fragment, first, scripts, hasScripts, node, doc, - i = 0, - l = collection.length, - iNoClone = l - 1, - value = args[ 0 ], - valueIsFunction = isFunction( value ); - - // We can't cloneNode fragments that contain checked, in WebKit - if ( valueIsFunction || - ( l > 1 && typeof value === "string" && - !support.checkClone && rchecked.test( value ) ) ) { - return collection.each( function( index ) { - var self = collection.eq( index ); - if ( valueIsFunction ) { - args[ 0 ] = value.call( this, index, self.html() ); - } - domManip( self, args, callback, ignored ); - } ); - } - - if ( l ) { - fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); - first = fragment.firstChild; - - if ( fragment.childNodes.length === 1 ) { - fragment = first; - } - - // Require either new content or an interest in ignored elements to invoke the callback - if ( first || ignored ) { - scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); - hasScripts = scripts.length; - - // Use the original fragment for the last item - // instead of the first because it can end up - // being emptied incorrectly in certain situations (#8070). - for ( ; i < l; i++ ) { - node = fragment; - - if ( i !== iNoClone ) { - node = jQuery.clone( node, true, true ); - - // Keep references to cloned scripts for later restoration - if ( hasScripts ) { - - // Support: Android <=4.0 only, PhantomJS 1 only - // push.apply(_, arraylike) throws on ancient WebKit - jQuery.merge( scripts, getAll( node, "script" ) ); - } - } - - callback.call( collection[ i ], node, i ); - } - - if ( hasScripts ) { - doc = scripts[ scripts.length - 1 ].ownerDocument; - - // Reenable scripts - jQuery.map( scripts, restoreScript ); - - // Evaluate executable scripts on first document insertion - for ( i = 0; i < hasScripts; i++ ) { - node = scripts[ i ]; - if ( rscriptType.test( node.type || "" ) && - !dataPriv.access( node, "globalEval" ) && - jQuery.contains( doc, node ) ) { - - if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { - - // Optional AJAX dependency, but won't run scripts if not present - if ( jQuery._evalUrl && !node.noModule ) { - jQuery._evalUrl( node.src, { - nonce: node.nonce || node.getAttribute( "nonce" ) - }, doc ); - } - } else { - DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); - } - } - } - } - } - } - - return collection; -} - -function remove( elem, selector, keepData ) { - var node, - nodes = selector ? jQuery.filter( selector, elem ) : elem, - i = 0; - - for ( ; ( node = nodes[ i ] ) != null; i++ ) { - if ( !keepData && node.nodeType === 1 ) { - jQuery.cleanData( getAll( node ) ); - } - - if ( node.parentNode ) { - if ( keepData && isAttached( node ) ) { - setGlobalEval( getAll( node, "script" ) ); - } - node.parentNode.removeChild( node ); - } - } - - return elem; -} - -jQuery.extend( { - htmlPrefilter: function( html ) { - return html; - }, - - clone: function( elem, dataAndEvents, deepDataAndEvents ) { - var i, l, srcElements, destElements, - clone = elem.cloneNode( true ), - inPage = isAttached( elem ); - - // Fix IE cloning issues - if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && - !jQuery.isXMLDoc( elem ) ) { - - // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 - destElements = getAll( clone ); - srcElements = getAll( elem ); - - for ( i = 0, l = srcElements.length; i < l; i++ ) { - fixInput( srcElements[ i ], destElements[ i ] ); - } - } - - // Copy the events from the original to the clone - if ( dataAndEvents ) { - if ( deepDataAndEvents ) { - srcElements = srcElements || getAll( elem ); - destElements = destElements || getAll( clone ); - - for ( i = 0, l = srcElements.length; i < l; i++ ) { - cloneCopyEvent( srcElements[ i ], destElements[ i ] ); - } - } else { - cloneCopyEvent( elem, clone ); - } - } - - // Preserve script evaluation history - destElements = getAll( clone, "script" ); - if ( destElements.length > 0 ) { - setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); - } - - // Return the cloned set - return clone; - }, - - cleanData: function( elems ) { - var data, elem, type, - special = jQuery.event.special, - i = 0; - - for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { - if ( acceptData( elem ) ) { - if ( ( data = elem[ dataPriv.expando ] ) ) { - if ( data.events ) { - for ( type in data.events ) { - if ( special[ type ] ) { - jQuery.event.remove( elem, type ); - - // This is a shortcut to avoid jQuery.event.remove's overhead - } else { - jQuery.removeEvent( elem, type, data.handle ); - } - } - } - - // Support: Chrome <=35 - 45+ - // Assign undefined instead of using delete, see Data#remove - elem[ dataPriv.expando ] = undefined; - } - if ( elem[ dataUser.expando ] ) { - - // Support: Chrome <=35 - 45+ - // Assign undefined instead of using delete, see Data#remove - elem[ dataUser.expando ] = undefined; - } - } - } - } -} ); - -jQuery.fn.extend( { - detach: function( selector ) { - return remove( this, selector, true ); - }, - - remove: function( selector ) { - return remove( this, selector ); - }, - - text: function( value ) { - return access( this, function( value ) { - return value === undefined ? - jQuery.text( this ) : - this.empty().each( function() { - if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { - this.textContent = value; - } - } ); - }, null, value, arguments.length ); - }, - - append: function() { - return domManip( this, arguments, function( elem ) { - if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { - var target = manipulationTarget( this, elem ); - target.appendChild( elem ); - } - } ); - }, - - prepend: function() { - return domManip( this, arguments, function( elem ) { - if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { - var target = manipulationTarget( this, elem ); - target.insertBefore( elem, target.firstChild ); - } - } ); - }, - - before: function() { - return domManip( this, arguments, function( elem ) { - if ( this.parentNode ) { - this.parentNode.insertBefore( elem, this ); - } - } ); - }, - - after: function() { - return domManip( this, arguments, function( elem ) { - if ( this.parentNode ) { - this.parentNode.insertBefore( elem, this.nextSibling ); - } - } ); - }, - - empty: function() { - var elem, - i = 0; - - for ( ; ( elem = this[ i ] ) != null; i++ ) { - if ( elem.nodeType === 1 ) { - - // Prevent memory leaks - jQuery.cleanData( getAll( elem, false ) ); - - // Remove any remaining nodes - elem.textContent = ""; - } - } - - return this; - }, - - clone: function( dataAndEvents, deepDataAndEvents ) { - dataAndEvents = dataAndEvents == null ? false : dataAndEvents; - deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; - - return this.map( function() { - return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); - } ); - }, - - html: function( value ) { - return access( this, function( value ) { - var elem = this[ 0 ] || {}, - i = 0, - l = this.length; - - if ( value === undefined && elem.nodeType === 1 ) { - return elem.innerHTML; - } - - // See if we can take a shortcut and just use innerHTML - if ( typeof value === "string" && !rnoInnerhtml.test( value ) && - !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { - - value = jQuery.htmlPrefilter( value ); - - try { - for ( ; i < l; i++ ) { - elem = this[ i ] || {}; - - // Remove element nodes and prevent memory leaks - if ( elem.nodeType === 1 ) { - jQuery.cleanData( getAll( elem, false ) ); - elem.innerHTML = value; - } - } - - elem = 0; - - // If using innerHTML throws an exception, use the fallback method - } catch ( e ) {} - } - - if ( elem ) { - this.empty().append( value ); - } - }, null, value, arguments.length ); - }, - - replaceWith: function() { - var ignored = []; - - // Make the changes, replacing each non-ignored context element with the new content - return domManip( this, arguments, function( elem ) { - var parent = this.parentNode; - - if ( jQuery.inArray( this, ignored ) < 0 ) { - jQuery.cleanData( getAll( this ) ); - if ( parent ) { - parent.replaceChild( elem, this ); - } - } - - // Force callback invocation - }, ignored ); - } -} ); - -jQuery.each( { - appendTo: "append", - prependTo: "prepend", - insertBefore: "before", - insertAfter: "after", - replaceAll: "replaceWith" -}, function( name, original ) { - jQuery.fn[ name ] = function( selector ) { - var elems, - ret = [], - insert = jQuery( selector ), - last = insert.length - 1, - i = 0; - - for ( ; i <= last; i++ ) { - elems = i === last ? this : this.clone( true ); - jQuery( insert[ i ] )[ original ]( elems ); - - // Support: Android <=4.0 only, PhantomJS 1 only - // .get() because push.apply(_, arraylike) throws on ancient WebKit - push.apply( ret, elems.get() ); - } - - return this.pushStack( ret ); - }; -} ); -var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); - -var getStyles = function( elem ) { - - // Support: IE <=11 only, Firefox <=30 (#15098, #14150) - // IE throws on elements created in popups - // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" - var view = elem.ownerDocument.defaultView; - - if ( !view || !view.opener ) { - view = window; - } - - return view.getComputedStyle( elem ); - }; - -var swap = function( elem, options, callback ) { - var ret, name, - old = {}; - - // Remember the old values, and insert the new ones - for ( name in options ) { - old[ name ] = elem.style[ name ]; - elem.style[ name ] = options[ name ]; - } - - ret = callback.call( elem ); - - // Revert the old values - for ( name in options ) { - elem.style[ name ] = old[ name ]; - } - - return ret; -}; - - -var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); - - - -( function() { - - // Executing both pixelPosition & boxSizingReliable tests require only one layout - // so they're executed at the same time to save the second computation. - function computeStyleTests() { - - // This is a singleton, we need to execute it only once - if ( !div ) { - return; - } - - container.style.cssText = "position:absolute;left:-11111px;width:60px;" + - "margin-top:1px;padding:0;border:0"; - div.style.cssText = - "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + - "margin:auto;border:1px;padding:1px;" + - "width:60%;top:1%"; - documentElement.appendChild( container ).appendChild( div ); - - var divStyle = window.getComputedStyle( div ); - pixelPositionVal = divStyle.top !== "1%"; - - // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 - reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; - - // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 - // Some styles come back with percentage values, even though they shouldn't - div.style.right = "60%"; - pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; - - // Support: IE 9 - 11 only - // Detect misreporting of content dimensions for box-sizing:border-box elements - boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; - - // Support: IE 9 only - // Detect overflow:scroll screwiness (gh-3699) - // Support: Chrome <=64 - // Don't get tricked when zoom affects offsetWidth (gh-4029) - div.style.position = "absolute"; - scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; - - documentElement.removeChild( container ); - - // Nullify the div so it wouldn't be stored in the memory and - // it will also be a sign that checks already performed - div = null; - } - - function roundPixelMeasures( measure ) { - return Math.round( parseFloat( measure ) ); - } - - var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, - reliableTrDimensionsVal, reliableMarginLeftVal, - container = document.createElement( "div" ), - div = document.createElement( "div" ); - - // Finish early in limited (non-browser) environments - if ( !div.style ) { - return; - } - - // Support: IE <=9 - 11 only - // Style of cloned element affects source element cloned (#8908) - div.style.backgroundClip = "content-box"; - div.cloneNode( true ).style.backgroundClip = ""; - support.clearCloneStyle = div.style.backgroundClip === "content-box"; - - jQuery.extend( support, { - boxSizingReliable: function() { - computeStyleTests(); - return boxSizingReliableVal; - }, - pixelBoxStyles: function() { - computeStyleTests(); - return pixelBoxStylesVal; - }, - pixelPosition: function() { - computeStyleTests(); - return pixelPositionVal; - }, - reliableMarginLeft: function() { - computeStyleTests(); - return reliableMarginLeftVal; - }, - scrollboxSize: function() { - computeStyleTests(); - return scrollboxSizeVal; - }, - - // Support: IE 9 - 11+, Edge 15 - 18+ - // IE/Edge misreport `getComputedStyle` of table rows with width/height - // set in CSS while `offset*` properties report correct values. - // Behavior in IE 9 is more subtle than in newer versions & it passes - // some versions of this test; make sure not to make it pass there! - reliableTrDimensions: function() { - var table, tr, trChild, trStyle; - if ( reliableTrDimensionsVal == null ) { - table = document.createElement( "table" ); - tr = document.createElement( "tr" ); - trChild = document.createElement( "div" ); - - table.style.cssText = "position:absolute;left:-11111px"; - tr.style.height = "1px"; - trChild.style.height = "9px"; - - documentElement - .appendChild( table ) - .appendChild( tr ) - .appendChild( trChild ); - - trStyle = window.getComputedStyle( tr ); - reliableTrDimensionsVal = parseInt( trStyle.height ) > 3; - - documentElement.removeChild( table ); - } - return reliableTrDimensionsVal; - } - } ); -} )(); - - -function curCSS( elem, name, computed ) { - var width, minWidth, maxWidth, ret, - - // Support: Firefox 51+ - // Retrieving style before computed somehow - // fixes an issue with getting wrong values - // on detached elements - style = elem.style; - - computed = computed || getStyles( elem ); - - // getPropertyValue is needed for: - // .css('filter') (IE 9 only, #12537) - // .css('--customProperty) (#3144) - if ( computed ) { - ret = computed.getPropertyValue( name ) || computed[ name ]; - - if ( ret === "" && !isAttached( elem ) ) { - ret = jQuery.style( elem, name ); - } - - // A tribute to the "awesome hack by Dean Edwards" - // Android Browser returns percentage for some values, - // but width seems to be reliably pixels. - // This is against the CSSOM draft spec: - // https://drafts.csswg.org/cssom/#resolved-values - if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { - - // Remember the original values - width = style.width; - minWidth = style.minWidth; - maxWidth = style.maxWidth; - - // Put in the new values to get a computed value out - style.minWidth = style.maxWidth = style.width = ret; - ret = computed.width; - - // Revert the changed values - style.width = width; - style.minWidth = minWidth; - style.maxWidth = maxWidth; - } - } - - return ret !== undefined ? - - // Support: IE <=9 - 11 only - // IE returns zIndex value as an integer. - ret + "" : - ret; -} - - -function addGetHookIf( conditionFn, hookFn ) { - - // Define the hook, we'll check on the first run if it's really needed. - return { - get: function() { - if ( conditionFn() ) { - - // Hook not needed (or it's not possible to use it due - // to missing dependency), remove it. - delete this.get; - return; - } - - // Hook needed; redefine it so that the support test is not executed again. - return ( this.get = hookFn ).apply( this, arguments ); - } - }; -} - - -var cssPrefixes = [ "Webkit", "Moz", "ms" ], - emptyStyle = document.createElement( "div" ).style, - vendorProps = {}; - -// Return a vendor-prefixed property or undefined -function vendorPropName( name ) { - - // Check for vendor prefixed names - var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), - i = cssPrefixes.length; - - while ( i-- ) { - name = cssPrefixes[ i ] + capName; - if ( name in emptyStyle ) { - return name; - } - } -} - -// Return a potentially-mapped jQuery.cssProps or vendor prefixed property -function finalPropName( name ) { - var final = jQuery.cssProps[ name ] || vendorProps[ name ]; - - if ( final ) { - return final; - } - if ( name in emptyStyle ) { - return name; - } - return vendorProps[ name ] = vendorPropName( name ) || name; -} - - -var - - // Swappable if display is none or starts with table - // except "table", "table-cell", or "table-caption" - // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display - rdisplayswap = /^(none|table(?!-c[ea]).+)/, - rcustomProp = /^--/, - cssShow = { position: "absolute", visibility: "hidden", display: "block" }, - cssNormalTransform = { - letterSpacing: "0", - fontWeight: "400" - }; - -function setPositiveNumber( _elem, value, subtract ) { - - // Any relative (+/-) values have already been - // normalized at this point - var matches = rcssNum.exec( value ); - return matches ? - - // Guard against undefined "subtract", e.g., when used as in cssHooks - Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : - value; -} - -function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { - var i = dimension === "width" ? 1 : 0, - extra = 0, - delta = 0; - - // Adjustment may not be necessary - if ( box === ( isBorderBox ? "border" : "content" ) ) { - return 0; - } - - for ( ; i < 4; i += 2 ) { - - // Both box models exclude margin - if ( box === "margin" ) { - delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); - } - - // If we get here with a content-box, we're seeking "padding" or "border" or "margin" - if ( !isBorderBox ) { - - // Add padding - delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); - - // For "border" or "margin", add border - if ( box !== "padding" ) { - delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); - - // But still keep track of it otherwise - } else { - extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); - } - - // If we get here with a border-box (content + padding + border), we're seeking "content" or - // "padding" or "margin" - } else { - - // For "content", subtract padding - if ( box === "content" ) { - delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); - } - - // For "content" or "padding", subtract border - if ( box !== "margin" ) { - delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); - } - } - } - - // Account for positive content-box scroll gutter when requested by providing computedVal - if ( !isBorderBox && computedVal >= 0 ) { - - // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border - // Assuming integer scroll gutter, subtract the rest and round down - delta += Math.max( 0, Math.ceil( - elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - - computedVal - - delta - - extra - - 0.5 - - // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter - // Use an explicit zero to avoid NaN (gh-3964) - ) ) || 0; - } - - return delta; -} - -function getWidthOrHeight( elem, dimension, extra ) { - - // Start with computed style - var styles = getStyles( elem ), - - // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). - // Fake content-box until we know it's needed to know the true value. - boxSizingNeeded = !support.boxSizingReliable() || extra, - isBorderBox = boxSizingNeeded && - jQuery.css( elem, "boxSizing", false, styles ) === "border-box", - valueIsBorderBox = isBorderBox, - - val = curCSS( elem, dimension, styles ), - offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); - - // Support: Firefox <=54 - // Return a confounding non-pixel value or feign ignorance, as appropriate. - if ( rnumnonpx.test( val ) ) { - if ( !extra ) { - return val; - } - val = "auto"; - } - - - // Support: IE 9 - 11 only - // Use offsetWidth/offsetHeight for when box sizing is unreliable. - // In those cases, the computed value can be trusted to be border-box. - if ( ( !support.boxSizingReliable() && isBorderBox || - - // Support: IE 10 - 11+, Edge 15 - 18+ - // IE/Edge misreport `getComputedStyle` of table rows with width/height - // set in CSS while `offset*` properties report correct values. - // Interestingly, in some cases IE 9 doesn't suffer from this issue. - !support.reliableTrDimensions() && nodeName( elem, "tr" ) || - - // Fall back to offsetWidth/offsetHeight when value is "auto" - // This happens for inline elements with no explicit setting (gh-3571) - val === "auto" || - - // Support: Android <=4.1 - 4.3 only - // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) - !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && - - // Make sure the element is visible & connected - elem.getClientRects().length ) { - - isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; - - // Where available, offsetWidth/offsetHeight approximate border box dimensions. - // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the - // retrieved value as a content box dimension. - valueIsBorderBox = offsetProp in elem; - if ( valueIsBorderBox ) { - val = elem[ offsetProp ]; - } - } - - // Normalize "" and auto - val = parseFloat( val ) || 0; - - // Adjust for the element's box model - return ( val + - boxModelAdjustment( - elem, - dimension, - extra || ( isBorderBox ? "border" : "content" ), - valueIsBorderBox, - styles, - - // Provide the current computed size to request scroll gutter calculation (gh-3589) - val - ) - ) + "px"; -} - -jQuery.extend( { - - // Add in style property hooks for overriding the default - // behavior of getting and setting a style property - cssHooks: { - opacity: { - get: function( elem, computed ) { - if ( computed ) { - - // We should always get a number back from opacity - var ret = curCSS( elem, "opacity" ); - return ret === "" ? "1" : ret; - } - } - } - }, - - // Don't automatically add "px" to these possibly-unitless properties - cssNumber: { - "animationIterationCount": true, - "columnCount": true, - "fillOpacity": true, - "flexGrow": true, - "flexShrink": true, - "fontWeight": true, - "gridArea": true, - "gridColumn": true, - "gridColumnEnd": true, - "gridColumnStart": true, - "gridRow": true, - "gridRowEnd": true, - "gridRowStart": true, - "lineHeight": true, - "opacity": true, - "order": true, - "orphans": true, - "widows": true, - "zIndex": true, - "zoom": true - }, - - // Add in properties whose names you wish to fix before - // setting or getting the value - cssProps: {}, - - // Get and set the style property on a DOM Node - style: function( elem, name, value, extra ) { - - // Don't set styles on text and comment nodes - if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { - return; - } - - // Make sure that we're working with the right name - var ret, type, hooks, - origName = camelCase( name ), - isCustomProp = rcustomProp.test( name ), - style = elem.style; - - // Make sure that we're working with the right name. We don't - // want to query the value if it is a CSS custom property - // since they are user-defined. - if ( !isCustomProp ) { - name = finalPropName( origName ); - } - - // Gets hook for the prefixed version, then unprefixed version - hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; - - // Check if we're setting a value - if ( value !== undefined ) { - type = typeof value; - - // Convert "+=" or "-=" to relative numbers (#7345) - if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { - value = adjustCSS( elem, name, ret ); - - // Fixes bug #9237 - type = "number"; - } - - // Make sure that null and NaN values aren't set (#7116) - if ( value == null || value !== value ) { - return; - } - - // If a number was passed in, add the unit (except for certain CSS properties) - // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append - // "px" to a few hardcoded values. - if ( type === "number" && !isCustomProp ) { - value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); - } - - // background-* props affect original clone's values - if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { - style[ name ] = "inherit"; - } - - // If a hook was provided, use that value, otherwise just set the specified value - if ( !hooks || !( "set" in hooks ) || - ( value = hooks.set( elem, value, extra ) ) !== undefined ) { - - if ( isCustomProp ) { - style.setProperty( name, value ); - } else { - style[ name ] = value; - } - } - - } else { - - // If a hook was provided get the non-computed value from there - if ( hooks && "get" in hooks && - ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { - - return ret; - } - - // Otherwise just get the value from the style object - return style[ name ]; - } - }, - - css: function( elem, name, extra, styles ) { - var val, num, hooks, - origName = camelCase( name ), - isCustomProp = rcustomProp.test( name ); - - // Make sure that we're working with the right name. We don't - // want to modify the value if it is a CSS custom property - // since they are user-defined. - if ( !isCustomProp ) { - name = finalPropName( origName ); - } - - // Try prefixed name followed by the unprefixed name - hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; - - // If a hook was provided get the computed value from there - if ( hooks && "get" in hooks ) { - val = hooks.get( elem, true, extra ); - } - - // Otherwise, if a way to get the computed value exists, use that - if ( val === undefined ) { - val = curCSS( elem, name, styles ); - } - - // Convert "normal" to computed value - if ( val === "normal" && name in cssNormalTransform ) { - val = cssNormalTransform[ name ]; - } - - // Make numeric if forced or a qualifier was provided and val looks numeric - if ( extra === "" || extra ) { - num = parseFloat( val ); - return extra === true || isFinite( num ) ? num || 0 : val; - } - - return val; - } -} ); - -jQuery.each( [ "height", "width" ], function( _i, dimension ) { - jQuery.cssHooks[ dimension ] = { - get: function( elem, computed, extra ) { - if ( computed ) { - - // Certain elements can have dimension info if we invisibly show them - // but it must have a current display style that would benefit - return rdisplayswap.test( jQuery.css( elem, "display" ) ) && - - // Support: Safari 8+ - // Table columns in Safari have non-zero offsetWidth & zero - // getBoundingClientRect().width unless display is changed. - // Support: IE <=11 only - // Running getBoundingClientRect on a disconnected node - // in IE throws an error. - ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? - swap( elem, cssShow, function() { - return getWidthOrHeight( elem, dimension, extra ); - } ) : - getWidthOrHeight( elem, dimension, extra ); - } - }, - - set: function( elem, value, extra ) { - var matches, - styles = getStyles( elem ), - - // Only read styles.position if the test has a chance to fail - // to avoid forcing a reflow. - scrollboxSizeBuggy = !support.scrollboxSize() && - styles.position === "absolute", - - // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) - boxSizingNeeded = scrollboxSizeBuggy || extra, - isBorderBox = boxSizingNeeded && - jQuery.css( elem, "boxSizing", false, styles ) === "border-box", - subtract = extra ? - boxModelAdjustment( - elem, - dimension, - extra, - isBorderBox, - styles - ) : - 0; - - // Account for unreliable border-box dimensions by comparing offset* to computed and - // faking a content-box to get border and padding (gh-3699) - if ( isBorderBox && scrollboxSizeBuggy ) { - subtract -= Math.ceil( - elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - - parseFloat( styles[ dimension ] ) - - boxModelAdjustment( elem, dimension, "border", false, styles ) - - 0.5 - ); - } - - // Convert to pixels if value adjustment is needed - if ( subtract && ( matches = rcssNum.exec( value ) ) && - ( matches[ 3 ] || "px" ) !== "px" ) { - - elem.style[ dimension ] = value; - value = jQuery.css( elem, dimension ); - } - - return setPositiveNumber( elem, value, subtract ); - } - }; -} ); - -jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, - function( elem, computed ) { - if ( computed ) { - return ( parseFloat( curCSS( elem, "marginLeft" ) ) || - elem.getBoundingClientRect().left - - swap( elem, { marginLeft: 0 }, function() { - return elem.getBoundingClientRect().left; - } ) - ) + "px"; - } - } -); - -// These hooks are used by animate to expand properties -jQuery.each( { - margin: "", - padding: "", - border: "Width" -}, function( prefix, suffix ) { - jQuery.cssHooks[ prefix + suffix ] = { - expand: function( value ) { - var i = 0, - expanded = {}, - - // Assumes a single number if not a string - parts = typeof value === "string" ? value.split( " " ) : [ value ]; - - for ( ; i < 4; i++ ) { - expanded[ prefix + cssExpand[ i ] + suffix ] = - parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; - } - - return expanded; - } - }; - - if ( prefix !== "margin" ) { - jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; - } -} ); - -jQuery.fn.extend( { - css: function( name, value ) { - return access( this, function( elem, name, value ) { - var styles, len, - map = {}, - i = 0; - - if ( Array.isArray( name ) ) { - styles = getStyles( elem ); - len = name.length; - - for ( ; i < len; i++ ) { - map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); - } - - return map; - } - - return value !== undefined ? - jQuery.style( elem, name, value ) : - jQuery.css( elem, name ); - }, name, value, arguments.length > 1 ); - } -} ); - - -function Tween( elem, options, prop, end, easing ) { - return new Tween.prototype.init( elem, options, prop, end, easing ); -} -jQuery.Tween = Tween; - -Tween.prototype = { - constructor: Tween, - init: function( elem, options, prop, end, easing, unit ) { - this.elem = elem; - this.prop = prop; - this.easing = easing || jQuery.easing._default; - this.options = options; - this.start = this.now = this.cur(); - this.end = end; - this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); - }, - cur: function() { - var hooks = Tween.propHooks[ this.prop ]; - - return hooks && hooks.get ? - hooks.get( this ) : - Tween.propHooks._default.get( this ); - }, - run: function( percent ) { - var eased, - hooks = Tween.propHooks[ this.prop ]; - - if ( this.options.duration ) { - this.pos = eased = jQuery.easing[ this.easing ]( - percent, this.options.duration * percent, 0, 1, this.options.duration - ); - } else { - this.pos = eased = percent; - } - this.now = ( this.end - this.start ) * eased + this.start; - - if ( this.options.step ) { - this.options.step.call( this.elem, this.now, this ); - } - - if ( hooks && hooks.set ) { - hooks.set( this ); - } else { - Tween.propHooks._default.set( this ); - } - return this; - } -}; - -Tween.prototype.init.prototype = Tween.prototype; - -Tween.propHooks = { - _default: { - get: function( tween ) { - var result; - - // Use a property on the element directly when it is not a DOM element, - // or when there is no matching style property that exists. - if ( tween.elem.nodeType !== 1 || - tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { - return tween.elem[ tween.prop ]; - } - - // Passing an empty string as a 3rd parameter to .css will automatically - // attempt a parseFloat and fallback to a string if the parse fails. - // Simple values such as "10px" are parsed to Float; - // complex values such as "rotate(1rad)" are returned as-is. - result = jQuery.css( tween.elem, tween.prop, "" ); - - // Empty strings, null, undefined and "auto" are converted to 0. - return !result || result === "auto" ? 0 : result; - }, - set: function( tween ) { - - // Use step hook for back compat. - // Use cssHook if its there. - // Use .style if available and use plain properties where available. - if ( jQuery.fx.step[ tween.prop ] ) { - jQuery.fx.step[ tween.prop ]( tween ); - } else if ( tween.elem.nodeType === 1 && ( - jQuery.cssHooks[ tween.prop ] || - tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { - jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); - } else { - tween.elem[ tween.prop ] = tween.now; - } - } - } -}; - -// Support: IE <=9 only -// Panic based approach to setting things on disconnected nodes -Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { - set: function( tween ) { - if ( tween.elem.nodeType && tween.elem.parentNode ) { - tween.elem[ tween.prop ] = tween.now; - } - } -}; - -jQuery.easing = { - linear: function( p ) { - return p; - }, - swing: function( p ) { - return 0.5 - Math.cos( p * Math.PI ) / 2; - }, - _default: "swing" -}; - -jQuery.fx = Tween.prototype.init; - -// Back compat <1.8 extension point -jQuery.fx.step = {}; - - - - -var - fxNow, inProgress, - rfxtypes = /^(?:toggle|show|hide)$/, - rrun = /queueHooks$/; - -function schedule() { - if ( inProgress ) { - if ( document.hidden === false && window.requestAnimationFrame ) { - window.requestAnimationFrame( schedule ); - } else { - window.setTimeout( schedule, jQuery.fx.interval ); - } - - jQuery.fx.tick(); - } -} - -// Animations created synchronously will run synchronously -function createFxNow() { - window.setTimeout( function() { - fxNow = undefined; - } ); - return ( fxNow = Date.now() ); -} - -// Generate parameters to create a standard animation -function genFx( type, includeWidth ) { - var which, - i = 0, - attrs = { height: type }; - - // If we include width, step value is 1 to do all cssExpand values, - // otherwise step value is 2 to skip over Left and Right - includeWidth = includeWidth ? 1 : 0; - for ( ; i < 4; i += 2 - includeWidth ) { - which = cssExpand[ i ]; - attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; - } - - if ( includeWidth ) { - attrs.opacity = attrs.width = type; - } - - return attrs; -} - -function createTween( value, prop, animation ) { - var tween, - collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), - index = 0, - length = collection.length; - for ( ; index < length; index++ ) { - if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { - - // We're done with this property - return tween; - } - } -} - -function defaultPrefilter( elem, props, opts ) { - var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, - isBox = "width" in props || "height" in props, - anim = this, - orig = {}, - style = elem.style, - hidden = elem.nodeType && isHiddenWithinTree( elem ), - dataShow = dataPriv.get( elem, "fxshow" ); - - // Queue-skipping animations hijack the fx hooks - if ( !opts.queue ) { - hooks = jQuery._queueHooks( elem, "fx" ); - if ( hooks.unqueued == null ) { - hooks.unqueued = 0; - oldfire = hooks.empty.fire; - hooks.empty.fire = function() { - if ( !hooks.unqueued ) { - oldfire(); - } - }; - } - hooks.unqueued++; - - anim.always( function() { - - // Ensure the complete handler is called before this completes - anim.always( function() { - hooks.unqueued--; - if ( !jQuery.queue( elem, "fx" ).length ) { - hooks.empty.fire(); - } - } ); - } ); - } - - // Detect show/hide animations - for ( prop in props ) { - value = props[ prop ]; - if ( rfxtypes.test( value ) ) { - delete props[ prop ]; - toggle = toggle || value === "toggle"; - if ( value === ( hidden ? "hide" : "show" ) ) { - - // Pretend to be hidden if this is a "show" and - // there is still data from a stopped show/hide - if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { - hidden = true; - - // Ignore all other no-op show/hide data - } else { - continue; - } - } - orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); - } - } - - // Bail out if this is a no-op like .hide().hide() - propTween = !jQuery.isEmptyObject( props ); - if ( !propTween && jQuery.isEmptyObject( orig ) ) { - return; - } - - // Restrict "overflow" and "display" styles during box animations - if ( isBox && elem.nodeType === 1 ) { - - // Support: IE <=9 - 11, Edge 12 - 15 - // Record all 3 overflow attributes because IE does not infer the shorthand - // from identically-valued overflowX and overflowY and Edge just mirrors - // the overflowX value there. - opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; - - // Identify a display type, preferring old show/hide data over the CSS cascade - restoreDisplay = dataShow && dataShow.display; - if ( restoreDisplay == null ) { - restoreDisplay = dataPriv.get( elem, "display" ); - } - display = jQuery.css( elem, "display" ); - if ( display === "none" ) { - if ( restoreDisplay ) { - display = restoreDisplay; - } else { - - // Get nonempty value(s) by temporarily forcing visibility - showHide( [ elem ], true ); - restoreDisplay = elem.style.display || restoreDisplay; - display = jQuery.css( elem, "display" ); - showHide( [ elem ] ); - } - } - - // Animate inline elements as inline-block - if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { - if ( jQuery.css( elem, "float" ) === "none" ) { - - // Restore the original display value at the end of pure show/hide animations - if ( !propTween ) { - anim.done( function() { - style.display = restoreDisplay; - } ); - if ( restoreDisplay == null ) { - display = style.display; - restoreDisplay = display === "none" ? "" : display; - } - } - style.display = "inline-block"; - } - } - } - - if ( opts.overflow ) { - style.overflow = "hidden"; - anim.always( function() { - style.overflow = opts.overflow[ 0 ]; - style.overflowX = opts.overflow[ 1 ]; - style.overflowY = opts.overflow[ 2 ]; - } ); - } - - // Implement show/hide animations - propTween = false; - for ( prop in orig ) { - - // General show/hide setup for this element animation - if ( !propTween ) { - if ( dataShow ) { - if ( "hidden" in dataShow ) { - hidden = dataShow.hidden; - } - } else { - dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); - } - - // Store hidden/visible for toggle so `.stop().toggle()` "reverses" - if ( toggle ) { - dataShow.hidden = !hidden; - } - - // Show elements before animating them - if ( hidden ) { - showHide( [ elem ], true ); - } - - /* eslint-disable no-loop-func */ - - anim.done( function() { - - /* eslint-enable no-loop-func */ - - // The final step of a "hide" animation is actually hiding the element - if ( !hidden ) { - showHide( [ elem ] ); - } - dataPriv.remove( elem, "fxshow" ); - for ( prop in orig ) { - jQuery.style( elem, prop, orig[ prop ] ); - } - } ); - } - - // Per-property setup - propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); - if ( !( prop in dataShow ) ) { - dataShow[ prop ] = propTween.start; - if ( hidden ) { - propTween.end = propTween.start; - propTween.start = 0; - } - } - } -} - -function propFilter( props, specialEasing ) { - var index, name, easing, value, hooks; - - // camelCase, specialEasing and expand cssHook pass - for ( index in props ) { - name = camelCase( index ); - easing = specialEasing[ name ]; - value = props[ index ]; - if ( Array.isArray( value ) ) { - easing = value[ 1 ]; - value = props[ index ] = value[ 0 ]; - } - - if ( index !== name ) { - props[ name ] = value; - delete props[ index ]; - } - - hooks = jQuery.cssHooks[ name ]; - if ( hooks && "expand" in hooks ) { - value = hooks.expand( value ); - delete props[ name ]; - - // Not quite $.extend, this won't overwrite existing keys. - // Reusing 'index' because we have the correct "name" - for ( index in value ) { - if ( !( index in props ) ) { - props[ index ] = value[ index ]; - specialEasing[ index ] = easing; - } - } - } else { - specialEasing[ name ] = easing; - } - } -} - -function Animation( elem, properties, options ) { - var result, - stopped, - index = 0, - length = Animation.prefilters.length, - deferred = jQuery.Deferred().always( function() { - - // Don't match elem in the :animated selector - delete tick.elem; - } ), - tick = function() { - if ( stopped ) { - return false; - } - var currentTime = fxNow || createFxNow(), - remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), - - // Support: Android 2.3 only - // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) - temp = remaining / animation.duration || 0, - percent = 1 - temp, - index = 0, - length = animation.tweens.length; - - for ( ; index < length; index++ ) { - animation.tweens[ index ].run( percent ); - } - - deferred.notifyWith( elem, [ animation, percent, remaining ] ); - - // If there's more to do, yield - if ( percent < 1 && length ) { - return remaining; - } - - // If this was an empty animation, synthesize a final progress notification - if ( !length ) { - deferred.notifyWith( elem, [ animation, 1, 0 ] ); - } - - // Resolve the animation and report its conclusion - deferred.resolveWith( elem, [ animation ] ); - return false; - }, - animation = deferred.promise( { - elem: elem, - props: jQuery.extend( {}, properties ), - opts: jQuery.extend( true, { - specialEasing: {}, - easing: jQuery.easing._default - }, options ), - originalProperties: properties, - originalOptions: options, - startTime: fxNow || createFxNow(), - duration: options.duration, - tweens: [], - createTween: function( prop, end ) { - var tween = jQuery.Tween( elem, animation.opts, prop, end, - animation.opts.specialEasing[ prop ] || animation.opts.easing ); - animation.tweens.push( tween ); - return tween; - }, - stop: function( gotoEnd ) { - var index = 0, - - // If we are going to the end, we want to run all the tweens - // otherwise we skip this part - length = gotoEnd ? animation.tweens.length : 0; - if ( stopped ) { - return this; - } - stopped = true; - for ( ; index < length; index++ ) { - animation.tweens[ index ].run( 1 ); - } - - // Resolve when we played the last frame; otherwise, reject - if ( gotoEnd ) { - deferred.notifyWith( elem, [ animation, 1, 0 ] ); - deferred.resolveWith( elem, [ animation, gotoEnd ] ); - } else { - deferred.rejectWith( elem, [ animation, gotoEnd ] ); - } - return this; - } - } ), - props = animation.props; - - propFilter( props, animation.opts.specialEasing ); - - for ( ; index < length; index++ ) { - result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); - if ( result ) { - if ( isFunction( result.stop ) ) { - jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = - result.stop.bind( result ); - } - return result; - } - } - - jQuery.map( props, createTween, animation ); - - if ( isFunction( animation.opts.start ) ) { - animation.opts.start.call( elem, animation ); - } - - // Attach callbacks from options - animation - .progress( animation.opts.progress ) - .done( animation.opts.done, animation.opts.complete ) - .fail( animation.opts.fail ) - .always( animation.opts.always ); - - jQuery.fx.timer( - jQuery.extend( tick, { - elem: elem, - anim: animation, - queue: animation.opts.queue - } ) - ); - - return animation; -} - -jQuery.Animation = jQuery.extend( Animation, { - - tweeners: { - "*": [ function( prop, value ) { - var tween = this.createTween( prop, value ); - adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); - return tween; - } ] - }, - - tweener: function( props, callback ) { - if ( isFunction( props ) ) { - callback = props; - props = [ "*" ]; - } else { - props = props.match( rnothtmlwhite ); - } - - var prop, - index = 0, - length = props.length; - - for ( ; index < length; index++ ) { - prop = props[ index ]; - Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; - Animation.tweeners[ prop ].unshift( callback ); - } - }, - - prefilters: [ defaultPrefilter ], - - prefilter: function( callback, prepend ) { - if ( prepend ) { - Animation.prefilters.unshift( callback ); - } else { - Animation.prefilters.push( callback ); - } - } -} ); - -jQuery.speed = function( speed, easing, fn ) { - var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { - complete: fn || !fn && easing || - isFunction( speed ) && speed, - duration: speed, - easing: fn && easing || easing && !isFunction( easing ) && easing - }; - - // Go to the end state if fx are off - if ( jQuery.fx.off ) { - opt.duration = 0; - - } else { - if ( typeof opt.duration !== "number" ) { - if ( opt.duration in jQuery.fx.speeds ) { - opt.duration = jQuery.fx.speeds[ opt.duration ]; - - } else { - opt.duration = jQuery.fx.speeds._default; - } - } - } - - // Normalize opt.queue - true/undefined/null -> "fx" - if ( opt.queue == null || opt.queue === true ) { - opt.queue = "fx"; - } - - // Queueing - opt.old = opt.complete; - - opt.complete = function() { - if ( isFunction( opt.old ) ) { - opt.old.call( this ); - } - - if ( opt.queue ) { - jQuery.dequeue( this, opt.queue ); - } - }; - - return opt; -}; - -jQuery.fn.extend( { - fadeTo: function( speed, to, easing, callback ) { - - // Show any hidden elements after setting opacity to 0 - return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() - - // Animate to the value specified - .end().animate( { opacity: to }, speed, easing, callback ); - }, - animate: function( prop, speed, easing, callback ) { - var empty = jQuery.isEmptyObject( prop ), - optall = jQuery.speed( speed, easing, callback ), - doAnimation = function() { - - // Operate on a copy of prop so per-property easing won't be lost - var anim = Animation( this, jQuery.extend( {}, prop ), optall ); - - // Empty animations, or finishing resolves immediately - if ( empty || dataPriv.get( this, "finish" ) ) { - anim.stop( true ); - } - }; - doAnimation.finish = doAnimation; - - return empty || optall.queue === false ? - this.each( doAnimation ) : - this.queue( optall.queue, doAnimation ); - }, - stop: function( type, clearQueue, gotoEnd ) { - var stopQueue = function( hooks ) { - var stop = hooks.stop; - delete hooks.stop; - stop( gotoEnd ); - }; - - if ( typeof type !== "string" ) { - gotoEnd = clearQueue; - clearQueue = type; - type = undefined; - } - if ( clearQueue ) { - this.queue( type || "fx", [] ); - } - - return this.each( function() { - var dequeue = true, - index = type != null && type + "queueHooks", - timers = jQuery.timers, - data = dataPriv.get( this ); - - if ( index ) { - if ( data[ index ] && data[ index ].stop ) { - stopQueue( data[ index ] ); - } - } else { - for ( index in data ) { - if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { - stopQueue( data[ index ] ); - } - } - } - - for ( index = timers.length; index--; ) { - if ( timers[ index ].elem === this && - ( type == null || timers[ index ].queue === type ) ) { - - timers[ index ].anim.stop( gotoEnd ); - dequeue = false; - timers.splice( index, 1 ); - } - } - - // Start the next in the queue if the last step wasn't forced. - // Timers currently will call their complete callbacks, which - // will dequeue but only if they were gotoEnd. - if ( dequeue || !gotoEnd ) { - jQuery.dequeue( this, type ); - } - } ); - }, - finish: function( type ) { - if ( type !== false ) { - type = type || "fx"; - } - return this.each( function() { - var index, - data = dataPriv.get( this ), - queue = data[ type + "queue" ], - hooks = data[ type + "queueHooks" ], - timers = jQuery.timers, - length = queue ? queue.length : 0; - - // Enable finishing flag on private data - data.finish = true; - - // Empty the queue first - jQuery.queue( this, type, [] ); - - if ( hooks && hooks.stop ) { - hooks.stop.call( this, true ); - } - - // Look for any active animations, and finish them - for ( index = timers.length; index--; ) { - if ( timers[ index ].elem === this && timers[ index ].queue === type ) { - timers[ index ].anim.stop( true ); - timers.splice( index, 1 ); - } - } - - // Look for any animations in the old queue and finish them - for ( index = 0; index < length; index++ ) { - if ( queue[ index ] && queue[ index ].finish ) { - queue[ index ].finish.call( this ); - } - } - - // Turn off finishing flag - delete data.finish; - } ); - } -} ); - -jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { - var cssFn = jQuery.fn[ name ]; - jQuery.fn[ name ] = function( speed, easing, callback ) { - return speed == null || typeof speed === "boolean" ? - cssFn.apply( this, arguments ) : - this.animate( genFx( name, true ), speed, easing, callback ); - }; -} ); - -// Generate shortcuts for custom animations -jQuery.each( { - slideDown: genFx( "show" ), - slideUp: genFx( "hide" ), - slideToggle: genFx( "toggle" ), - fadeIn: { opacity: "show" }, - fadeOut: { opacity: "hide" }, - fadeToggle: { opacity: "toggle" } -}, function( name, props ) { - jQuery.fn[ name ] = function( speed, easing, callback ) { - return this.animate( props, speed, easing, callback ); - }; -} ); - -jQuery.timers = []; -jQuery.fx.tick = function() { - var timer, - i = 0, - timers = jQuery.timers; - - fxNow = Date.now(); - - for ( ; i < timers.length; i++ ) { - timer = timers[ i ]; - - // Run the timer and safely remove it when done (allowing for external removal) - if ( !timer() && timers[ i ] === timer ) { - timers.splice( i--, 1 ); - } - } - - if ( !timers.length ) { - jQuery.fx.stop(); - } - fxNow = undefined; -}; - -jQuery.fx.timer = function( timer ) { - jQuery.timers.push( timer ); - jQuery.fx.start(); -}; - -jQuery.fx.interval = 13; -jQuery.fx.start = function() { - if ( inProgress ) { - return; - } - - inProgress = true; - schedule(); -}; - -jQuery.fx.stop = function() { - inProgress = null; -}; - -jQuery.fx.speeds = { - slow: 600, - fast: 200, - - // Default speed - _default: 400 -}; - - -// Based off of the plugin by Clint Helfers, with permission. -// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ -jQuery.fn.delay = function( time, type ) { - time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; - type = type || "fx"; - - return this.queue( type, function( next, hooks ) { - var timeout = window.setTimeout( next, time ); - hooks.stop = function() { - window.clearTimeout( timeout ); - }; - } ); -}; - - -( function() { - var input = document.createElement( "input" ), - select = document.createElement( "select" ), - opt = select.appendChild( document.createElement( "option" ) ); - - input.type = "checkbox"; - - // Support: Android <=4.3 only - // Default value for a checkbox should be "on" - support.checkOn = input.value !== ""; - - // Support: IE <=11 only - // Must access selectedIndex to make default options select - support.optSelected = opt.selected; - - // Support: IE <=11 only - // An input loses its value after becoming a radio - input = document.createElement( "input" ); - input.value = "t"; - input.type = "radio"; - support.radioValue = input.value === "t"; -} )(); - - -var boolHook, - attrHandle = jQuery.expr.attrHandle; - -jQuery.fn.extend( { - attr: function( name, value ) { - return access( this, jQuery.attr, name, value, arguments.length > 1 ); - }, - - removeAttr: function( name ) { - return this.each( function() { - jQuery.removeAttr( this, name ); - } ); - } -} ); - -jQuery.extend( { - attr: function( elem, name, value ) { - var ret, hooks, - nType = elem.nodeType; - - // Don't get/set attributes on text, comment and attribute nodes - if ( nType === 3 || nType === 8 || nType === 2 ) { - return; - } - - // Fallback to prop when attributes are not supported - if ( typeof elem.getAttribute === "undefined" ) { - return jQuery.prop( elem, name, value ); - } - - // Attribute hooks are determined by the lowercase version - // Grab necessary hook if one is defined - if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { - hooks = jQuery.attrHooks[ name.toLowerCase() ] || - ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); - } - - if ( value !== undefined ) { - if ( value === null ) { - jQuery.removeAttr( elem, name ); - return; - } - - if ( hooks && "set" in hooks && - ( ret = hooks.set( elem, value, name ) ) !== undefined ) { - return ret; - } - - elem.setAttribute( name, value + "" ); - return value; - } - - if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { - return ret; - } - - ret = jQuery.find.attr( elem, name ); - - // Non-existent attributes return null, we normalize to undefined - return ret == null ? undefined : ret; - }, - - attrHooks: { - type: { - set: function( elem, value ) { - if ( !support.radioValue && value === "radio" && - nodeName( elem, "input" ) ) { - var val = elem.value; - elem.setAttribute( "type", value ); - if ( val ) { - elem.value = val; - } - return value; - } - } - } - }, - - removeAttr: function( elem, value ) { - var name, - i = 0, - - // Attribute names can contain non-HTML whitespace characters - // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 - attrNames = value && value.match( rnothtmlwhite ); - - if ( attrNames && elem.nodeType === 1 ) { - while ( ( name = attrNames[ i++ ] ) ) { - elem.removeAttribute( name ); - } - } - } -} ); - -// Hooks for boolean attributes -boolHook = { - set: function( elem, value, name ) { - if ( value === false ) { - - // Remove boolean attributes when set to false - jQuery.removeAttr( elem, name ); - } else { - elem.setAttribute( name, name ); - } - return name; - } -}; - -jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { - var getter = attrHandle[ name ] || jQuery.find.attr; - - attrHandle[ name ] = function( elem, name, isXML ) { - var ret, handle, - lowercaseName = name.toLowerCase(); - - if ( !isXML ) { - - // Avoid an infinite loop by temporarily removing this function from the getter - handle = attrHandle[ lowercaseName ]; - attrHandle[ lowercaseName ] = ret; - ret = getter( elem, name, isXML ) != null ? - lowercaseName : - null; - attrHandle[ lowercaseName ] = handle; - } - return ret; - }; -} ); - - - - -var rfocusable = /^(?:input|select|textarea|button)$/i, - rclickable = /^(?:a|area)$/i; - -jQuery.fn.extend( { - prop: function( name, value ) { - return access( this, jQuery.prop, name, value, arguments.length > 1 ); - }, - - removeProp: function( name ) { - return this.each( function() { - delete this[ jQuery.propFix[ name ] || name ]; - } ); - } -} ); - -jQuery.extend( { - prop: function( elem, name, value ) { - var ret, hooks, - nType = elem.nodeType; - - // Don't get/set properties on text, comment and attribute nodes - if ( nType === 3 || nType === 8 || nType === 2 ) { - return; - } - - if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { - - // Fix name and attach hooks - name = jQuery.propFix[ name ] || name; - hooks = jQuery.propHooks[ name ]; - } - - if ( value !== undefined ) { - if ( hooks && "set" in hooks && - ( ret = hooks.set( elem, value, name ) ) !== undefined ) { - return ret; - } - - return ( elem[ name ] = value ); - } - - if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { - return ret; - } - - return elem[ name ]; - }, - - propHooks: { - tabIndex: { - get: function( elem ) { - - // Support: IE <=9 - 11 only - // elem.tabIndex doesn't always return the - // correct value when it hasn't been explicitly set - // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ - // Use proper attribute retrieval(#12072) - var tabindex = jQuery.find.attr( elem, "tabindex" ); - - if ( tabindex ) { - return parseInt( tabindex, 10 ); - } - - if ( - rfocusable.test( elem.nodeName ) || - rclickable.test( elem.nodeName ) && - elem.href - ) { - return 0; - } - - return -1; - } - } - }, - - propFix: { - "for": "htmlFor", - "class": "className" - } -} ); - -// Support: IE <=11 only -// Accessing the selectedIndex property -// forces the browser to respect setting selected -// on the option -// The getter ensures a default option is selected -// when in an optgroup -// eslint rule "no-unused-expressions" is disabled for this code -// since it considers such accessions noop -if ( !support.optSelected ) { - jQuery.propHooks.selected = { - get: function( elem ) { - - /* eslint no-unused-expressions: "off" */ - - var parent = elem.parentNode; - if ( parent && parent.parentNode ) { - parent.parentNode.selectedIndex; - } - return null; - }, - set: function( elem ) { - - /* eslint no-unused-expressions: "off" */ - - var parent = elem.parentNode; - if ( parent ) { - parent.selectedIndex; - - if ( parent.parentNode ) { - parent.parentNode.selectedIndex; - } - } - } - }; -} - -jQuery.each( [ - "tabIndex", - "readOnly", - "maxLength", - "cellSpacing", - "cellPadding", - "rowSpan", - "colSpan", - "useMap", - "frameBorder", - "contentEditable" -], function() { - jQuery.propFix[ this.toLowerCase() ] = this; -} ); - - - - - // Strip and collapse whitespace according to HTML spec - // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace - function stripAndCollapse( value ) { - var tokens = value.match( rnothtmlwhite ) || []; - return tokens.join( " " ); - } - - -function getClass( elem ) { - return elem.getAttribute && elem.getAttribute( "class" ) || ""; -} - -function classesToArray( value ) { - if ( Array.isArray( value ) ) { - return value; - } - if ( typeof value === "string" ) { - return value.match( rnothtmlwhite ) || []; - } - return []; -} - -jQuery.fn.extend( { - addClass: function( value ) { - var classes, elem, cur, curValue, clazz, j, finalValue, - i = 0; - - if ( isFunction( value ) ) { - return this.each( function( j ) { - jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); - } ); - } - - classes = classesToArray( value ); - - if ( classes.length ) { - while ( ( elem = this[ i++ ] ) ) { - curValue = getClass( elem ); - cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); - - if ( cur ) { - j = 0; - while ( ( clazz = classes[ j++ ] ) ) { - if ( cur.indexOf( " " + clazz + " " ) < 0 ) { - cur += clazz + " "; - } - } - - // Only assign if different to avoid unneeded rendering. - finalValue = stripAndCollapse( cur ); - if ( curValue !== finalValue ) { - elem.setAttribute( "class", finalValue ); - } - } - } - } - - return this; - }, - - removeClass: function( value ) { - var classes, elem, cur, curValue, clazz, j, finalValue, - i = 0; - - if ( isFunction( value ) ) { - return this.each( function( j ) { - jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); - } ); - } - - if ( !arguments.length ) { - return this.attr( "class", "" ); - } - - classes = classesToArray( value ); - - if ( classes.length ) { - while ( ( elem = this[ i++ ] ) ) { - curValue = getClass( elem ); - - // This expression is here for better compressibility (see addClass) - cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); - - if ( cur ) { - j = 0; - while ( ( clazz = classes[ j++ ] ) ) { - - // Remove *all* instances - while ( cur.indexOf( " " + clazz + " " ) > -1 ) { - cur = cur.replace( " " + clazz + " ", " " ); - } - } - - // Only assign if different to avoid unneeded rendering. - finalValue = stripAndCollapse( cur ); - if ( curValue !== finalValue ) { - elem.setAttribute( "class", finalValue ); - } - } - } - } - - return this; - }, - - toggleClass: function( value, stateVal ) { - var type = typeof value, - isValidValue = type === "string" || Array.isArray( value ); - - if ( typeof stateVal === "boolean" && isValidValue ) { - return stateVal ? this.addClass( value ) : this.removeClass( value ); - } - - if ( isFunction( value ) ) { - return this.each( function( i ) { - jQuery( this ).toggleClass( - value.call( this, i, getClass( this ), stateVal ), - stateVal - ); - } ); - } - - return this.each( function() { - var className, i, self, classNames; - - if ( isValidValue ) { - - // Toggle individual class names - i = 0; - self = jQuery( this ); - classNames = classesToArray( value ); - - while ( ( className = classNames[ i++ ] ) ) { - - // Check each className given, space separated list - if ( self.hasClass( className ) ) { - self.removeClass( className ); - } else { - self.addClass( className ); - } - } - - // Toggle whole class name - } else if ( value === undefined || type === "boolean" ) { - className = getClass( this ); - if ( className ) { - - // Store className if set - dataPriv.set( this, "__className__", className ); - } - - // If the element has a class name or if we're passed `false`, - // then remove the whole classname (if there was one, the above saved it). - // Otherwise bring back whatever was previously saved (if anything), - // falling back to the empty string if nothing was stored. - if ( this.setAttribute ) { - this.setAttribute( "class", - className || value === false ? - "" : - dataPriv.get( this, "__className__" ) || "" - ); - } - } - } ); - }, - - hasClass: function( selector ) { - var className, elem, - i = 0; - - className = " " + selector + " "; - while ( ( elem = this[ i++ ] ) ) { - if ( elem.nodeType === 1 && - ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { - return true; - } - } - - return false; - } -} ); - - - - -var rreturn = /\r/g; - -jQuery.fn.extend( { - val: function( value ) { - var hooks, ret, valueIsFunction, - elem = this[ 0 ]; - - if ( !arguments.length ) { - if ( elem ) { - hooks = jQuery.valHooks[ elem.type ] || - jQuery.valHooks[ elem.nodeName.toLowerCase() ]; - - if ( hooks && - "get" in hooks && - ( ret = hooks.get( elem, "value" ) ) !== undefined - ) { - return ret; - } - - ret = elem.value; - - // Handle most common string cases - if ( typeof ret === "string" ) { - return ret.replace( rreturn, "" ); - } - - // Handle cases where value is null/undef or number - return ret == null ? "" : ret; - } - - return; - } - - valueIsFunction = isFunction( value ); - - return this.each( function( i ) { - var val; - - if ( this.nodeType !== 1 ) { - return; - } - - if ( valueIsFunction ) { - val = value.call( this, i, jQuery( this ).val() ); - } else { - val = value; - } - - // Treat null/undefined as ""; convert numbers to string - if ( val == null ) { - val = ""; - - } else if ( typeof val === "number" ) { - val += ""; - - } else if ( Array.isArray( val ) ) { - val = jQuery.map( val, function( value ) { - return value == null ? "" : value + ""; - } ); - } - - hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; - - // If set returns undefined, fall back to normal setting - if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { - this.value = val; - } - } ); - } -} ); - -jQuery.extend( { - valHooks: { - option: { - get: function( elem ) { - - var val = jQuery.find.attr( elem, "value" ); - return val != null ? - val : - - // Support: IE <=10 - 11 only - // option.text throws exceptions (#14686, #14858) - // Strip and collapse whitespace - // https://html.spec.whatwg.org/#strip-and-collapse-whitespace - stripAndCollapse( jQuery.text( elem ) ); - } - }, - select: { - get: function( elem ) { - var value, option, i, - options = elem.options, - index = elem.selectedIndex, - one = elem.type === "select-one", - values = one ? null : [], - max = one ? index + 1 : options.length; - - if ( index < 0 ) { - i = max; - - } else { - i = one ? index : 0; - } - - // Loop through all the selected options - for ( ; i < max; i++ ) { - option = options[ i ]; - - // Support: IE <=9 only - // IE8-9 doesn't update selected after form reset (#2551) - if ( ( option.selected || i === index ) && - - // Don't return options that are disabled or in a disabled optgroup - !option.disabled && - ( !option.parentNode.disabled || - !nodeName( option.parentNode, "optgroup" ) ) ) { - - // Get the specific value for the option - value = jQuery( option ).val(); - - // We don't need an array for one selects - if ( one ) { - return value; - } - - // Multi-Selects return an array - values.push( value ); - } - } - - return values; - }, - - set: function( elem, value ) { - var optionSet, option, - options = elem.options, - values = jQuery.makeArray( value ), - i = options.length; - - while ( i-- ) { - option = options[ i ]; - - /* eslint-disable no-cond-assign */ - - if ( option.selected = - jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 - ) { - optionSet = true; - } - - /* eslint-enable no-cond-assign */ - } - - // Force browsers to behave consistently when non-matching value is set - if ( !optionSet ) { - elem.selectedIndex = -1; - } - return values; - } - } - } -} ); - -// Radios and checkboxes getter/setter -jQuery.each( [ "radio", "checkbox" ], function() { - jQuery.valHooks[ this ] = { - set: function( elem, value ) { - if ( Array.isArray( value ) ) { - return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); - } - } - }; - if ( !support.checkOn ) { - jQuery.valHooks[ this ].get = function( elem ) { - return elem.getAttribute( "value" ) === null ? "on" : elem.value; - }; - } -} ); - - - - -// Return jQuery for attributes-only inclusion - - -support.focusin = "onfocusin" in window; - - -var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, - stopPropagationCallback = function( e ) { - e.stopPropagation(); - }; - -jQuery.extend( jQuery.event, { - - trigger: function( event, data, elem, onlyHandlers ) { - - var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, - eventPath = [ elem || document ], - type = hasOwn.call( event, "type" ) ? event.type : event, - namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; - - cur = lastElement = tmp = elem = elem || document; - - // Don't do events on text and comment nodes - if ( elem.nodeType === 3 || elem.nodeType === 8 ) { - return; - } - - // focus/blur morphs to focusin/out; ensure we're not firing them right now - if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { - return; - } - - if ( type.indexOf( "." ) > -1 ) { - - // Namespaced trigger; create a regexp to match event type in handle() - namespaces = type.split( "." ); - type = namespaces.shift(); - namespaces.sort(); - } - ontype = type.indexOf( ":" ) < 0 && "on" + type; - - // Caller can pass in a jQuery.Event object, Object, or just an event type string - event = event[ jQuery.expando ] ? - event : - new jQuery.Event( type, typeof event === "object" && event ); - - // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) - event.isTrigger = onlyHandlers ? 2 : 3; - event.namespace = namespaces.join( "." ); - event.rnamespace = event.namespace ? - new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : - null; - - // Clean up the event in case it is being reused - event.result = undefined; - if ( !event.target ) { - event.target = elem; - } - - // Clone any incoming data and prepend the event, creating the handler arg list - data = data == null ? - [ event ] : - jQuery.makeArray( data, [ event ] ); - - // Allow special events to draw outside the lines - special = jQuery.event.special[ type ] || {}; - if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { - return; - } - - // Determine event propagation path in advance, per W3C events spec (#9951) - // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) - if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { - - bubbleType = special.delegateType || type; - if ( !rfocusMorph.test( bubbleType + type ) ) { - cur = cur.parentNode; - } - for ( ; cur; cur = cur.parentNode ) { - eventPath.push( cur ); - tmp = cur; - } - - // Only add window if we got to document (e.g., not plain obj or detached DOM) - if ( tmp === ( elem.ownerDocument || document ) ) { - eventPath.push( tmp.defaultView || tmp.parentWindow || window ); - } - } - - // Fire handlers on the event path - i = 0; - while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { - lastElement = cur; - event.type = i > 1 ? - bubbleType : - special.bindType || type; - - // jQuery handler - handle = ( - dataPriv.get( cur, "events" ) || Object.create( null ) - )[ event.type ] && - dataPriv.get( cur, "handle" ); - if ( handle ) { - handle.apply( cur, data ); - } - - // Native handler - handle = ontype && cur[ ontype ]; - if ( handle && handle.apply && acceptData( cur ) ) { - event.result = handle.apply( cur, data ); - if ( event.result === false ) { - event.preventDefault(); - } - } - } - event.type = type; - - // If nobody prevented the default action, do it now - if ( !onlyHandlers && !event.isDefaultPrevented() ) { - - if ( ( !special._default || - special._default.apply( eventPath.pop(), data ) === false ) && - acceptData( elem ) ) { - - // Call a native DOM method on the target with the same name as the event. - // Don't do default actions on window, that's where global variables be (#6170) - if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { - - // Don't re-trigger an onFOO event when we call its FOO() method - tmp = elem[ ontype ]; - - if ( tmp ) { - elem[ ontype ] = null; - } - - // Prevent re-triggering of the same event, since we already bubbled it above - jQuery.event.triggered = type; - - if ( event.isPropagationStopped() ) { - lastElement.addEventListener( type, stopPropagationCallback ); - } - - elem[ type ](); - - if ( event.isPropagationStopped() ) { - lastElement.removeEventListener( type, stopPropagationCallback ); - } - - jQuery.event.triggered = undefined; - - if ( tmp ) { - elem[ ontype ] = tmp; - } - } - } - } - - return event.result; - }, - - // Piggyback on a donor event to simulate a different one - // Used only for `focus(in | out)` events - simulate: function( type, elem, event ) { - var e = jQuery.extend( - new jQuery.Event(), - event, - { - type: type, - isSimulated: true - } - ); - - jQuery.event.trigger( e, null, elem ); - } - -} ); - -jQuery.fn.extend( { - - trigger: function( type, data ) { - return this.each( function() { - jQuery.event.trigger( type, data, this ); - } ); - }, - triggerHandler: function( type, data ) { - var elem = this[ 0 ]; - if ( elem ) { - return jQuery.event.trigger( type, data, elem, true ); - } - } -} ); - - -// Support: Firefox <=44 -// Firefox doesn't have focus(in | out) events -// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 -// -// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 -// focus(in | out) events fire after focus & blur events, -// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order -// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 -if ( !support.focusin ) { - jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { - - // Attach a single capturing handler on the document while someone wants focusin/focusout - var handler = function( event ) { - jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); - }; - - jQuery.event.special[ fix ] = { - setup: function() { - - // Handle: regular nodes (via `this.ownerDocument`), window - // (via `this.document`) & document (via `this`). - var doc = this.ownerDocument || this.document || this, - attaches = dataPriv.access( doc, fix ); - - if ( !attaches ) { - doc.addEventListener( orig, handler, true ); - } - dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); - }, - teardown: function() { - var doc = this.ownerDocument || this.document || this, - attaches = dataPriv.access( doc, fix ) - 1; - - if ( !attaches ) { - doc.removeEventListener( orig, handler, true ); - dataPriv.remove( doc, fix ); - - } else { - dataPriv.access( doc, fix, attaches ); - } - } - }; - } ); -} -var location = window.location; - -var nonce = { guid: Date.now() }; - -var rquery = ( /\?/ ); - - - -// Cross-browser xml parsing -jQuery.parseXML = function( data ) { - var xml; - if ( !data || typeof data !== "string" ) { - return null; - } - - // Support: IE 9 - 11 only - // IE throws on parseFromString with invalid input. - try { - xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); - } catch ( e ) { - xml = undefined; - } - - if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { - jQuery.error( "Invalid XML: " + data ); - } - return xml; -}; - - -var - rbracket = /\[\]$/, - rCRLF = /\r?\n/g, - rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, - rsubmittable = /^(?:input|select|textarea|keygen)/i; - -function buildParams( prefix, obj, traditional, add ) { - var name; - - if ( Array.isArray( obj ) ) { - - // Serialize array item. - jQuery.each( obj, function( i, v ) { - if ( traditional || rbracket.test( prefix ) ) { - - // Treat each array item as a scalar. - add( prefix, v ); - - } else { - - // Item is non-scalar (array or object), encode its numeric index. - buildParams( - prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", - v, - traditional, - add - ); - } - } ); - - } else if ( !traditional && toType( obj ) === "object" ) { - - // Serialize object item. - for ( name in obj ) { - buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); - } - - } else { - - // Serialize scalar item. - add( prefix, obj ); - } -} - -// Serialize an array of form elements or a set of -// key/values into a query string -jQuery.param = function( a, traditional ) { - var prefix, - s = [], - add = function( key, valueOrFunction ) { - - // If value is a function, invoke it and use its return value - var value = isFunction( valueOrFunction ) ? - valueOrFunction() : - valueOrFunction; - - s[ s.length ] = encodeURIComponent( key ) + "=" + - encodeURIComponent( value == null ? "" : value ); - }; - - if ( a == null ) { - return ""; - } - - // If an array was passed in, assume that it is an array of form elements. - if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { - - // Serialize the form elements - jQuery.each( a, function() { - add( this.name, this.value ); - } ); - - } else { - - // If traditional, encode the "old" way (the way 1.3.2 or older - // did it), otherwise encode params recursively. - for ( prefix in a ) { - buildParams( prefix, a[ prefix ], traditional, add ); - } - } - - // Return the resulting serialization - return s.join( "&" ); -}; - -jQuery.fn.extend( { - serialize: function() { - return jQuery.param( this.serializeArray() ); - }, - serializeArray: function() { - return this.map( function() { - - // Can add propHook for "elements" to filter or add form elements - var elements = jQuery.prop( this, "elements" ); - return elements ? jQuery.makeArray( elements ) : this; - } ) - .filter( function() { - var type = this.type; - - // Use .is( ":disabled" ) so that fieldset[disabled] works - return this.name && !jQuery( this ).is( ":disabled" ) && - rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && - ( this.checked || !rcheckableType.test( type ) ); - } ) - .map( function( _i, elem ) { - var val = jQuery( this ).val(); - - if ( val == null ) { - return null; - } - - if ( Array.isArray( val ) ) { - return jQuery.map( val, function( val ) { - return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; - } ); - } - - return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; - } ).get(); - } -} ); - - -var - r20 = /%20/g, - rhash = /#.*$/, - rantiCache = /([?&])_=[^&]*/, - rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, - - // #7653, #8125, #8152: local protocol detection - rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, - rnoContent = /^(?:GET|HEAD)$/, - rprotocol = /^\/\//, - - /* Prefilters - * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) - * 2) These are called: - * - BEFORE asking for a transport - * - AFTER param serialization (s.data is a string if s.processData is true) - * 3) key is the dataType - * 4) the catchall symbol "*" can be used - * 5) execution will start with transport dataType and THEN continue down to "*" if needed - */ - prefilters = {}, - - /* Transports bindings - * 1) key is the dataType - * 2) the catchall symbol "*" can be used - * 3) selection will start with transport dataType and THEN go to "*" if needed - */ - transports = {}, - - // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression - allTypes = "*/".concat( "*" ), - - // Anchor tag for parsing the document origin - originAnchor = document.createElement( "a" ); - originAnchor.href = location.href; - -// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport -function addToPrefiltersOrTransports( structure ) { - - // dataTypeExpression is optional and defaults to "*" - return function( dataTypeExpression, func ) { - - if ( typeof dataTypeExpression !== "string" ) { - func = dataTypeExpression; - dataTypeExpression = "*"; - } - - var dataType, - i = 0, - dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; - - if ( isFunction( func ) ) { - - // For each dataType in the dataTypeExpression - while ( ( dataType = dataTypes[ i++ ] ) ) { - - // Prepend if requested - if ( dataType[ 0 ] === "+" ) { - dataType = dataType.slice( 1 ) || "*"; - ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); - - // Otherwise append - } else { - ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); - } - } - } - }; -} - -// Base inspection function for prefilters and transports -function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { - - var inspected = {}, - seekingTransport = ( structure === transports ); - - function inspect( dataType ) { - var selected; - inspected[ dataType ] = true; - jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { - var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); - if ( typeof dataTypeOrTransport === "string" && - !seekingTransport && !inspected[ dataTypeOrTransport ] ) { - - options.dataTypes.unshift( dataTypeOrTransport ); - inspect( dataTypeOrTransport ); - return false; - } else if ( seekingTransport ) { - return !( selected = dataTypeOrTransport ); - } - } ); - return selected; - } - - return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); -} - -// A special extend for ajax options -// that takes "flat" options (not to be deep extended) -// Fixes #9887 -function ajaxExtend( target, src ) { - var key, deep, - flatOptions = jQuery.ajaxSettings.flatOptions || {}; - - for ( key in src ) { - if ( src[ key ] !== undefined ) { - ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; - } - } - if ( deep ) { - jQuery.extend( true, target, deep ); - } - - return target; -} - -/* Handles responses to an ajax request: - * - finds the right dataType (mediates between content-type and expected dataType) - * - returns the corresponding response - */ -function ajaxHandleResponses( s, jqXHR, responses ) { - - var ct, type, finalDataType, firstDataType, - contents = s.contents, - dataTypes = s.dataTypes; - - // Remove auto dataType and get content-type in the process - while ( dataTypes[ 0 ] === "*" ) { - dataTypes.shift(); - if ( ct === undefined ) { - ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); - } - } - - // Check if we're dealing with a known content-type - if ( ct ) { - for ( type in contents ) { - if ( contents[ type ] && contents[ type ].test( ct ) ) { - dataTypes.unshift( type ); - break; - } - } - } - - // Check to see if we have a response for the expected dataType - if ( dataTypes[ 0 ] in responses ) { - finalDataType = dataTypes[ 0 ]; - } else { - - // Try convertible dataTypes - for ( type in responses ) { - if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { - finalDataType = type; - break; - } - if ( !firstDataType ) { - firstDataType = type; - } - } - - // Or just use first one - finalDataType = finalDataType || firstDataType; - } - - // If we found a dataType - // We add the dataType to the list if needed - // and return the corresponding response - if ( finalDataType ) { - if ( finalDataType !== dataTypes[ 0 ] ) { - dataTypes.unshift( finalDataType ); - } - return responses[ finalDataType ]; - } -} - -/* Chain conversions given the request and the original response - * Also sets the responseXXX fields on the jqXHR instance - */ -function ajaxConvert( s, response, jqXHR, isSuccess ) { - var conv2, current, conv, tmp, prev, - converters = {}, - - // Work with a copy of dataTypes in case we need to modify it for conversion - dataTypes = s.dataTypes.slice(); - - // Create converters map with lowercased keys - if ( dataTypes[ 1 ] ) { - for ( conv in s.converters ) { - converters[ conv.toLowerCase() ] = s.converters[ conv ]; - } - } - - current = dataTypes.shift(); - - // Convert to each sequential dataType - while ( current ) { - - if ( s.responseFields[ current ] ) { - jqXHR[ s.responseFields[ current ] ] = response; - } - - // Apply the dataFilter if provided - if ( !prev && isSuccess && s.dataFilter ) { - response = s.dataFilter( response, s.dataType ); - } - - prev = current; - current = dataTypes.shift(); - - if ( current ) { - - // There's only work to do if current dataType is non-auto - if ( current === "*" ) { - - current = prev; - - // Convert response if prev dataType is non-auto and differs from current - } else if ( prev !== "*" && prev !== current ) { - - // Seek a direct converter - conv = converters[ prev + " " + current ] || converters[ "* " + current ]; - - // If none found, seek a pair - if ( !conv ) { - for ( conv2 in converters ) { - - // If conv2 outputs current - tmp = conv2.split( " " ); - if ( tmp[ 1 ] === current ) { - - // If prev can be converted to accepted input - conv = converters[ prev + " " + tmp[ 0 ] ] || - converters[ "* " + tmp[ 0 ] ]; - if ( conv ) { - - // Condense equivalence converters - if ( conv === true ) { - conv = converters[ conv2 ]; - - // Otherwise, insert the intermediate dataType - } else if ( converters[ conv2 ] !== true ) { - current = tmp[ 0 ]; - dataTypes.unshift( tmp[ 1 ] ); - } - break; - } - } - } - } - - // Apply converter (if not an equivalence) - if ( conv !== true ) { - - // Unless errors are allowed to bubble, catch and return them - if ( conv && s.throws ) { - response = conv( response ); - } else { - try { - response = conv( response ); - } catch ( e ) { - return { - state: "parsererror", - error: conv ? e : "No conversion from " + prev + " to " + current - }; - } - } - } - } - } - } - - return { state: "success", data: response }; -} - -jQuery.extend( { - - // Counter for holding the number of active queries - active: 0, - - // Last-Modified header cache for next request - lastModified: {}, - etag: {}, - - ajaxSettings: { - url: location.href, - type: "GET", - isLocal: rlocalProtocol.test( location.protocol ), - global: true, - processData: true, - async: true, - contentType: "application/x-www-form-urlencoded; charset=UTF-8", - - /* - timeout: 0, - data: null, - dataType: null, - username: null, - password: null, - cache: null, - throws: false, - traditional: false, - headers: {}, - */ - - accepts: { - "*": allTypes, - text: "text/plain", - html: "text/html", - xml: "application/xml, text/xml", - json: "application/json, text/javascript" - }, - - contents: { - xml: /\bxml\b/, - html: /\bhtml/, - json: /\bjson\b/ - }, - - responseFields: { - xml: "responseXML", - text: "responseText", - json: "responseJSON" - }, - - // Data converters - // Keys separate source (or catchall "*") and destination types with a single space - converters: { - - // Convert anything to text - "* text": String, - - // Text to html (true = no transformation) - "text html": true, - - // Evaluate text as a json expression - "text json": JSON.parse, - - // Parse text as xml - "text xml": jQuery.parseXML - }, - - // For options that shouldn't be deep extended: - // you can add your own custom options here if - // and when you create one that shouldn't be - // deep extended (see ajaxExtend) - flatOptions: { - url: true, - context: true - } - }, - - // Creates a full fledged settings object into target - // with both ajaxSettings and settings fields. - // If target is omitted, writes into ajaxSettings. - ajaxSetup: function( target, settings ) { - return settings ? - - // Building a settings object - ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : - - // Extending ajaxSettings - ajaxExtend( jQuery.ajaxSettings, target ); - }, - - ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), - ajaxTransport: addToPrefiltersOrTransports( transports ), - - // Main method - ajax: function( url, options ) { - - // If url is an object, simulate pre-1.5 signature - if ( typeof url === "object" ) { - options = url; - url = undefined; - } - - // Force options to be an object - options = options || {}; - - var transport, - - // URL without anti-cache param - cacheURL, - - // Response headers - responseHeadersString, - responseHeaders, - - // timeout handle - timeoutTimer, - - // Url cleanup var - urlAnchor, - - // Request state (becomes false upon send and true upon completion) - completed, - - // To know if global events are to be dispatched - fireGlobals, - - // Loop variable - i, - - // uncached part of the url - uncached, - - // Create the final options object - s = jQuery.ajaxSetup( {}, options ), - - // Callbacks context - callbackContext = s.context || s, - - // Context for global events is callbackContext if it is a DOM node or jQuery collection - globalEventContext = s.context && - ( callbackContext.nodeType || callbackContext.jquery ) ? - jQuery( callbackContext ) : - jQuery.event, - - // Deferreds - deferred = jQuery.Deferred(), - completeDeferred = jQuery.Callbacks( "once memory" ), - - // Status-dependent callbacks - statusCode = s.statusCode || {}, - - // Headers (they are sent all at once) - requestHeaders = {}, - requestHeadersNames = {}, - - // Default abort message - strAbort = "canceled", - - // Fake xhr - jqXHR = { - readyState: 0, - - // Builds headers hashtable if needed - getResponseHeader: function( key ) { - var match; - if ( completed ) { - if ( !responseHeaders ) { - responseHeaders = {}; - while ( ( match = rheaders.exec( responseHeadersString ) ) ) { - responseHeaders[ match[ 1 ].toLowerCase() + " " ] = - ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) - .concat( match[ 2 ] ); - } - } - match = responseHeaders[ key.toLowerCase() + " " ]; - } - return match == null ? null : match.join( ", " ); - }, - - // Raw string - getAllResponseHeaders: function() { - return completed ? responseHeadersString : null; - }, - - // Caches the header - setRequestHeader: function( name, value ) { - if ( completed == null ) { - name = requestHeadersNames[ name.toLowerCase() ] = - requestHeadersNames[ name.toLowerCase() ] || name; - requestHeaders[ name ] = value; - } - return this; - }, - - // Overrides response content-type header - overrideMimeType: function( type ) { - if ( completed == null ) { - s.mimeType = type; - } - return this; - }, - - // Status-dependent callbacks - statusCode: function( map ) { - var code; - if ( map ) { - if ( completed ) { - - // Execute the appropriate callbacks - jqXHR.always( map[ jqXHR.status ] ); - } else { - - // Lazy-add the new callbacks in a way that preserves old ones - for ( code in map ) { - statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; - } - } - } - return this; - }, - - // Cancel the request - abort: function( statusText ) { - var finalText = statusText || strAbort; - if ( transport ) { - transport.abort( finalText ); - } - done( 0, finalText ); - return this; - } - }; - - // Attach deferreds - deferred.promise( jqXHR ); - - // Add protocol if not provided (prefilters might expect it) - // Handle falsy url in the settings object (#10093: consistency with old signature) - // We also use the url parameter if available - s.url = ( ( url || s.url || location.href ) + "" ) - .replace( rprotocol, location.protocol + "//" ); - - // Alias method option to type as per ticket #12004 - s.type = options.method || options.type || s.method || s.type; - - // Extract dataTypes list - s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; - - // A cross-domain request is in order when the origin doesn't match the current origin. - if ( s.crossDomain == null ) { - urlAnchor = document.createElement( "a" ); - - // Support: IE <=8 - 11, Edge 12 - 15 - // IE throws exception on accessing the href property if url is malformed, - // e.g. http://example.com:80x/ - try { - urlAnchor.href = s.url; - - // Support: IE <=8 - 11 only - // Anchor's host property isn't correctly set when s.url is relative - urlAnchor.href = urlAnchor.href; - s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== - urlAnchor.protocol + "//" + urlAnchor.host; - } catch ( e ) { - - // If there is an error parsing the URL, assume it is crossDomain, - // it can be rejected by the transport if it is invalid - s.crossDomain = true; - } - } - - // Convert data if not already a string - if ( s.data && s.processData && typeof s.data !== "string" ) { - s.data = jQuery.param( s.data, s.traditional ); - } - - // Apply prefilters - inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); - - // If request was aborted inside a prefilter, stop there - if ( completed ) { - return jqXHR; - } - - // We can fire global events as of now if asked to - // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) - fireGlobals = jQuery.event && s.global; - - // Watch for a new set of requests - if ( fireGlobals && jQuery.active++ === 0 ) { - jQuery.event.trigger( "ajaxStart" ); - } - - // Uppercase the type - s.type = s.type.toUpperCase(); - - // Determine if request has content - s.hasContent = !rnoContent.test( s.type ); - - // Save the URL in case we're toying with the If-Modified-Since - // and/or If-None-Match header later on - // Remove hash to simplify url manipulation - cacheURL = s.url.replace( rhash, "" ); - - // More options handling for requests with no content - if ( !s.hasContent ) { - - // Remember the hash so we can put it back - uncached = s.url.slice( cacheURL.length ); - - // If data is available and should be processed, append data to url - if ( s.data && ( s.processData || typeof s.data === "string" ) ) { - cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; - - // #9682: remove data so that it's not used in an eventual retry - delete s.data; - } - - // Add or update anti-cache param if needed - if ( s.cache === false ) { - cacheURL = cacheURL.replace( rantiCache, "$1" ); - uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + - uncached; - } - - // Put hash and anti-cache on the URL that will be requested (gh-1732) - s.url = cacheURL + uncached; - - // Change '%20' to '+' if this is encoded form body content (gh-2658) - } else if ( s.data && s.processData && - ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { - s.data = s.data.replace( r20, "+" ); - } - - // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. - if ( s.ifModified ) { - if ( jQuery.lastModified[ cacheURL ] ) { - jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); - } - if ( jQuery.etag[ cacheURL ] ) { - jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); - } - } - - // Set the correct header, if data is being sent - if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { - jqXHR.setRequestHeader( "Content-Type", s.contentType ); - } - - // Set the Accepts header for the server, depending on the dataType - jqXHR.setRequestHeader( - "Accept", - s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? - s.accepts[ s.dataTypes[ 0 ] ] + - ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : - s.accepts[ "*" ] - ); - - // Check for headers option - for ( i in s.headers ) { - jqXHR.setRequestHeader( i, s.headers[ i ] ); - } - - // Allow custom headers/mimetypes and early abort - if ( s.beforeSend && - ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { - - // Abort if not done already and return - return jqXHR.abort(); - } - - // Aborting is no longer a cancellation - strAbort = "abort"; - - // Install callbacks on deferreds - completeDeferred.add( s.complete ); - jqXHR.done( s.success ); - jqXHR.fail( s.error ); - - // Get transport - transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); - - // If no transport, we auto-abort - if ( !transport ) { - done( -1, "No Transport" ); - } else { - jqXHR.readyState = 1; - - // Send global event - if ( fireGlobals ) { - globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); - } - - // If request was aborted inside ajaxSend, stop there - if ( completed ) { - return jqXHR; - } - - // Timeout - if ( s.async && s.timeout > 0 ) { - timeoutTimer = window.setTimeout( function() { - jqXHR.abort( "timeout" ); - }, s.timeout ); - } - - try { - completed = false; - transport.send( requestHeaders, done ); - } catch ( e ) { - - // Rethrow post-completion exceptions - if ( completed ) { - throw e; - } - - // Propagate others as results - done( -1, e ); - } - } - - // Callback for when everything is done - function done( status, nativeStatusText, responses, headers ) { - var isSuccess, success, error, response, modified, - statusText = nativeStatusText; - - // Ignore repeat invocations - if ( completed ) { - return; - } - - completed = true; - - // Clear timeout if it exists - if ( timeoutTimer ) { - window.clearTimeout( timeoutTimer ); - } - - // Dereference transport for early garbage collection - // (no matter how long the jqXHR object will be used) - transport = undefined; - - // Cache response headers - responseHeadersString = headers || ""; - - // Set readyState - jqXHR.readyState = status > 0 ? 4 : 0; - - // Determine if successful - isSuccess = status >= 200 && status < 300 || status === 304; - - // Get response data - if ( responses ) { - response = ajaxHandleResponses( s, jqXHR, responses ); - } - - // Use a noop converter for missing script - if ( !isSuccess && jQuery.inArray( "script", s.dataTypes ) > -1 ) { - s.converters[ "text script" ] = function() {}; - } - - // Convert no matter what (that way responseXXX fields are always set) - response = ajaxConvert( s, response, jqXHR, isSuccess ); - - // If successful, handle type chaining - if ( isSuccess ) { - - // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. - if ( s.ifModified ) { - modified = jqXHR.getResponseHeader( "Last-Modified" ); - if ( modified ) { - jQuery.lastModified[ cacheURL ] = modified; - } - modified = jqXHR.getResponseHeader( "etag" ); - if ( modified ) { - jQuery.etag[ cacheURL ] = modified; - } - } - - // if no content - if ( status === 204 || s.type === "HEAD" ) { - statusText = "nocontent"; - - // if not modified - } else if ( status === 304 ) { - statusText = "notmodified"; - - // If we have data, let's convert it - } else { - statusText = response.state; - success = response.data; - error = response.error; - isSuccess = !error; - } - } else { - - // Extract error from statusText and normalize for non-aborts - error = statusText; - if ( status || !statusText ) { - statusText = "error"; - if ( status < 0 ) { - status = 0; - } - } - } - - // Set data for the fake xhr object - jqXHR.status = status; - jqXHR.statusText = ( nativeStatusText || statusText ) + ""; - - // Success/Error - if ( isSuccess ) { - deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); - } else { - deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); - } - - // Status-dependent callbacks - jqXHR.statusCode( statusCode ); - statusCode = undefined; - - if ( fireGlobals ) { - globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", - [ jqXHR, s, isSuccess ? success : error ] ); - } - - // Complete - completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); - - if ( fireGlobals ) { - globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); - - // Handle the global AJAX counter - if ( !( --jQuery.active ) ) { - jQuery.event.trigger( "ajaxStop" ); - } - } - } - - return jqXHR; - }, - - getJSON: function( url, data, callback ) { - return jQuery.get( url, data, callback, "json" ); - }, - - getScript: function( url, callback ) { - return jQuery.get( url, undefined, callback, "script" ); - } -} ); - -jQuery.each( [ "get", "post" ], function( _i, method ) { - jQuery[ method ] = function( url, data, callback, type ) { - - // Shift arguments if data argument was omitted - if ( isFunction( data ) ) { - type = type || callback; - callback = data; - data = undefined; - } - - // The url can be an options object (which then must have .url) - return jQuery.ajax( jQuery.extend( { - url: url, - type: method, - dataType: type, - data: data, - success: callback - }, jQuery.isPlainObject( url ) && url ) ); - }; -} ); - -jQuery.ajaxPrefilter( function( s ) { - var i; - for ( i in s.headers ) { - if ( i.toLowerCase() === "content-type" ) { - s.contentType = s.headers[ i ] || ""; - } - } -} ); - - -jQuery._evalUrl = function( url, options, doc ) { - return jQuery.ajax( { - url: url, - - // Make this explicit, since user can override this through ajaxSetup (#11264) - type: "GET", - dataType: "script", - cache: true, - async: false, - global: false, - - // Only evaluate the response if it is successful (gh-4126) - // dataFilter is not invoked for failure responses, so using it instead - // of the default converter is kludgy but it works. - converters: { - "text script": function() {} - }, - dataFilter: function( response ) { - jQuery.globalEval( response, options, doc ); - } - } ); -}; - - -jQuery.fn.extend( { - wrapAll: function( html ) { - var wrap; - - if ( this[ 0 ] ) { - if ( isFunction( html ) ) { - html = html.call( this[ 0 ] ); - } - - // The elements to wrap the target around - wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); - - if ( this[ 0 ].parentNode ) { - wrap.insertBefore( this[ 0 ] ); - } - - wrap.map( function() { - var elem = this; - - while ( elem.firstElementChild ) { - elem = elem.firstElementChild; - } - - return elem; - } ).append( this ); - } - - return this; - }, - - wrapInner: function( html ) { - if ( isFunction( html ) ) { - return this.each( function( i ) { - jQuery( this ).wrapInner( html.call( this, i ) ); - } ); - } - - return this.each( function() { - var self = jQuery( this ), - contents = self.contents(); - - if ( contents.length ) { - contents.wrapAll( html ); - - } else { - self.append( html ); - } - } ); - }, - - wrap: function( html ) { - var htmlIsFunction = isFunction( html ); - - return this.each( function( i ) { - jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); - } ); - }, - - unwrap: function( selector ) { - this.parent( selector ).not( "body" ).each( function() { - jQuery( this ).replaceWith( this.childNodes ); - } ); - return this; - } -} ); - - -jQuery.expr.pseudos.hidden = function( elem ) { - return !jQuery.expr.pseudos.visible( elem ); -}; -jQuery.expr.pseudos.visible = function( elem ) { - return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); -}; - - - - -jQuery.ajaxSettings.xhr = function() { - try { - return new window.XMLHttpRequest(); - } catch ( e ) {} -}; - -var xhrSuccessStatus = { - - // File protocol always yields status code 0, assume 200 - 0: 200, - - // Support: IE <=9 only - // #1450: sometimes IE returns 1223 when it should be 204 - 1223: 204 - }, - xhrSupported = jQuery.ajaxSettings.xhr(); - -support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); -support.ajax = xhrSupported = !!xhrSupported; - -jQuery.ajaxTransport( function( options ) { - var callback, errorCallback; - - // Cross domain only allowed if supported through XMLHttpRequest - if ( support.cors || xhrSupported && !options.crossDomain ) { - return { - send: function( headers, complete ) { - var i, - xhr = options.xhr(); - - xhr.open( - options.type, - options.url, - options.async, - options.username, - options.password - ); - - // Apply custom fields if provided - if ( options.xhrFields ) { - for ( i in options.xhrFields ) { - xhr[ i ] = options.xhrFields[ i ]; - } - } - - // Override mime type if needed - if ( options.mimeType && xhr.overrideMimeType ) { - xhr.overrideMimeType( options.mimeType ); - } - - // X-Requested-With header - // For cross-domain requests, seeing as conditions for a preflight are - // akin to a jigsaw puzzle, we simply never set it to be sure. - // (it can always be set on a per-request basis or even using ajaxSetup) - // For same-domain requests, won't change header if already provided. - if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { - headers[ "X-Requested-With" ] = "XMLHttpRequest"; - } - - // Set headers - for ( i in headers ) { - xhr.setRequestHeader( i, headers[ i ] ); - } - - // Callback - callback = function( type ) { - return function() { - if ( callback ) { - callback = errorCallback = xhr.onload = - xhr.onerror = xhr.onabort = xhr.ontimeout = - xhr.onreadystatechange = null; - - if ( type === "abort" ) { - xhr.abort(); - } else if ( type === "error" ) { - - // Support: IE <=9 only - // On a manual native abort, IE9 throws - // errors on any property access that is not readyState - if ( typeof xhr.status !== "number" ) { - complete( 0, "error" ); - } else { - complete( - - // File: protocol always yields status 0; see #8605, #14207 - xhr.status, - xhr.statusText - ); - } - } else { - complete( - xhrSuccessStatus[ xhr.status ] || xhr.status, - xhr.statusText, - - // Support: IE <=9 only - // IE9 has no XHR2 but throws on binary (trac-11426) - // For XHR2 non-text, let the caller handle it (gh-2498) - ( xhr.responseType || "text" ) !== "text" || - typeof xhr.responseText !== "string" ? - { binary: xhr.response } : - { text: xhr.responseText }, - xhr.getAllResponseHeaders() - ); - } - } - }; - }; - - // Listen to events - xhr.onload = callback(); - errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); - - // Support: IE 9 only - // Use onreadystatechange to replace onabort - // to handle uncaught aborts - if ( xhr.onabort !== undefined ) { - xhr.onabort = errorCallback; - } else { - xhr.onreadystatechange = function() { - - // Check readyState before timeout as it changes - if ( xhr.readyState === 4 ) { - - // Allow onerror to be called first, - // but that will not handle a native abort - // Also, save errorCallback to a variable - // as xhr.onerror cannot be accessed - window.setTimeout( function() { - if ( callback ) { - errorCallback(); - } - } ); - } - }; - } - - // Create the abort callback - callback = callback( "abort" ); - - try { - - // Do send the request (this may raise an exception) - xhr.send( options.hasContent && options.data || null ); - } catch ( e ) { - - // #14683: Only rethrow if this hasn't been notified as an error yet - if ( callback ) { - throw e; - } - } - }, - - abort: function() { - if ( callback ) { - callback(); - } - } - }; - } -} ); - - - - -// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) -jQuery.ajaxPrefilter( function( s ) { - if ( s.crossDomain ) { - s.contents.script = false; - } -} ); - -// Install script dataType -jQuery.ajaxSetup( { - accepts: { - script: "text/javascript, application/javascript, " + - "application/ecmascript, application/x-ecmascript" - }, - contents: { - script: /\b(?:java|ecma)script\b/ - }, - converters: { - "text script": function( text ) { - jQuery.globalEval( text ); - return text; - } - } -} ); - -// Handle cache's special case and crossDomain -jQuery.ajaxPrefilter( "script", function( s ) { - if ( s.cache === undefined ) { - s.cache = false; - } - if ( s.crossDomain ) { - s.type = "GET"; - } -} ); - -// Bind script tag hack transport -jQuery.ajaxTransport( "script", function( s ) { - - // This transport only deals with cross domain or forced-by-attrs requests - if ( s.crossDomain || s.scriptAttrs ) { - var script, callback; - return { - send: function( _, complete ) { - script = jQuery( " -{% endmacro %} diff --git a/book/content/_build/html/base.html b/book/content/_build/html/base.html deleted file mode 100644 index ae511e59..00000000 --- a/book/content/_build/html/base.html +++ /dev/null @@ -1,349 +0,0 @@ - - - - - - - - - Base class — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - - - -
- - -
- -
-
-
-
-
- -
- -
-

Base class

-

Base class for diversity based subset selection.

-
-
-class selector.base.SelectionBase
-

Base class for selecting subset of sample points.

-
-
-select(X: numpy.ndarray, size: int, labels: Optional[numpy.ndarray] = None) numpy.ndarray
-

Return indices representing subset of sample points.

-
-
X: ndarray of shape (n_samples, n_features) or (n_samples, n_samples)

Feature matrix of n_samples samples in n_features dimensional feature space. -If fun_distance is None, this X is treated as a square pairwise distance matrix.

-
-
size: int

Number of sample points to select (i.e. size of the subset).

-
-
labels: np.ndarray, optional

Array of integers or strings representing the labels of the clusters that -each sample belongs to. If None, the samples are treated as one cluster. -If labels are provided, selection is made from each cluster.

-
-
-
-
selected: list

Indices of the selected sample points.

-
-
-
- -
-
-abstract select_from_cluster(X: numpy.ndarray, size: int, labels: Optional[numpy.ndarray] = None) numpy.ndarray
-

Return indices representing subset of sample points from one cluster.

-
-
X: ndarray of shape (n_samples, n_features) or (n_samples, n_samples)

Feature matrix of n_samples samples in n_features dimensional feature space. -If fun_distance is None, this X is treated as a square pairwise distance matrix.

-
-
size: int

Number of sample points to select (i.e. size of the subset).

-
-
labels: np.ndarray, optional

Array of integers or strings representing the labels of the clusters that -each sample belongs to. If None, the samples are treated as one cluster. -If labels are provided, selection is made from each cluster.

-
-
-
-
selected: list

Indices of the selected sample points.

-
-
-
- -
- -
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/dissimilarity.html b/book/content/_build/html/dissimilarity.html deleted file mode 100644 index 8edbd10d..00000000 --- a/book/content/_build/html/dissimilarity.html +++ /dev/null @@ -1,428 +0,0 @@ - - - - - - - - - Dissimilarity based methods — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - - - -
- - -
- -
-
-
-
-
- -
- -
-

Dissimilarity based methods

-

Module for Dissimilarity-Based Selection Methods.

-
-
-class selector.dissimilarity.MaxMin(func_distance=None)
-

Selecting samples using MaxMin algorithm.

-

MaxMin is possibly the most widely used method for dissimilarity-based -compound selection. When presented with a dataset of samples, the -initial point is chosen as the dataset’s medoid center. Next, the second -point is chosen to be that which is furthest from this initial point. -Subsequently, all following points are selected via the following -logic:

-
    -
  1. Find the minimum distance from every point to the already-selected ones.

  2. -
  3. Select the point which has the maximum distance among those calculated -in the previous step.

  4. -
-

[1] Ashton, Mark, et al., Identification of diverse database subsets using -property‐based and fragment‐based molecular descriptions, Quantitative -Structure‐Activity Relationships 21.6 (2002): 598-604.

-
-
-select_from_cluster(X, size, labels=None)
-

Return selected samples from a cluster based on MaxMin algorithm.

-
-
X: ndarray of shape (n_samples, n_features) or (n_samples, n_samples)

Feature matrix of n_samples samples in n_features dimensional feature space. -If fun_distance is None, this X is treated as a square pairwise distance matrix.

-
-
size: int

Number of sample points to select (i.e. size of the subset).

-
-
labels: np.ndarray

Indices of samples that form a cluster.

-
-
-
-
selectedlist

List of indices of selected samples.

-
-
-
- -
- -
-
-class selector.dissimilarity.MaxSum(func_distance=None)
-

Selecting samples using MaxSum algorithm.

-

Whereas the goal of the MaxMin algorithm is to maximize the minimum distance -between any pair of distinct elements in the selected subset of a dataset, -the MaxSum algorithm aims to maximize the sum of distances between all -pairs of elements in the selected subset. When presented with a dataset of -samples, the initial point is chosen as the dataset’s medoid center. Next, -the second point is chosen to be that which is furthest from this initial -point. Subsequently, all following points are selected via the following -logic:

-
    -
  1. Determine the sum of distances from every point to the already-selected ones.

  2. -
  3. Select the point which has the maximum sum of distances among those calculated -in the previous step.

  4. -
-

[1] Borodin, Allan, Hyun Chul Lee, and Yuli Ye, Max-sum diversification, monotone -submodular functions and dynamic updates, Proceedings of the 31st ACM SIGMOD-SIGACT-SIGAI -symposium on Principles of Database Systems. 2012.

-
-
-select_from_cluster(X, size, labels=None)
-

Return selected samples from a cluster based on MaxSum algorithm.

-
-
X: ndarray of shape (n_samples, n_features) or (n_samples, n_samples)

Feature matrix of n_samples samples in n_features dimensional feature space. -If fun_distance is None, this X is treated as a square pairwise distance matrix.

-
-
size: int

Number of sample points to select (i.e. size of the subset).

-
-
labels: np.ndarray

Indices of samples that form a cluster.

-
-
-
-
selectedlist

List of indices of selected samples.

-
-
-
- -
- -
-
-class selector.dissimilarity.OptiSim(r0=None, k=10, tol=0.01, eps=0, p=2, start_id=0, random_seed=42, n_iter=10)
-

Selecting samples using OptiSim algorithm.

-

The OptiSim algorithm selects samples from a dataset by first choosing the medoid center as the -initial point. Next, points are randomly chosen and added to a subsample if they exist -outside of radius r from all previously selected points (otherwise, they are discarded). Once k -number of points have been added to the subsample, the point with the greatest minimum distance -to the previously selected points is chosen. Then, the subsample is cleared and the process is -repeated.

-

[1] J. Chem. Inf. Comput. Sci. 1997, 37, 6, 1181–1188. https://doi.org/10.1021/ci970282v

-
-
-algorithm(X, max_size) list
-

Return selected samples based on OptiSim algorithm.

-
-
Xnp.ndarray

Coordinate array of samples.

-
-
max_sizeint

Maximum number of samples to select.

-
-
-
-
selectedlist

List of indices of selected samples.

-
-
-
- -
-
-select_from_cluster(X, size, labels=None)
-

Return selected samples from a cluster based on OptiSim algorithm.

-
-
Xnp.ndarray

Coordinate array of samples.

-
-
sizeint

Number of samples to be selected.

-
-
labels: np.ndarray

Indices of samples that form a cluster.

-
-
-
-
selectedlist

List of indices of selected samples.

-
-
-
- -
- -
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/genindex.html b/book/content/_build/html/genindex.html deleted file mode 100644 index 1fab8488..00000000 --- a/book/content/_build/html/genindex.html +++ /dev/null @@ -1,372 +0,0 @@ - - - - - - - - Index — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - -
- - -
- -
-
-
-
- -
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/index.html b/book/content/_build/html/index.html deleted file mode 100644 index 3157386d..00000000 --- a/book/content/_build/html/index.html +++ /dev/null @@ -1 +0,0 @@ - diff --git a/book/content/_build/html/installation.html b/book/content/_build/html/installation.html deleted file mode 100644 index 673d3fe2..00000000 --- a/book/content/_build/html/installation.html +++ /dev/null @@ -1,510 +0,0 @@ - - - - - - - - - Installation — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - - - - - -
- - - -
-
-
-
- -
- -
-

Installation

-
-

Stable releases

-
-Warning: - -

We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the “Latest git revision” section below.

-
-

The following dependencies are required to run selector properly,

- -

Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below.

-
-
-

Installation with Ana- or Miniconda:

-
    -
  1. To install selector using the conda package management system, install miniconda or anaconda first, and then:

  2. -
-
# Activate your main conda environment if it is not loaded in your .bashrc.
-# E.g. run the following if you have miniconda installed in e.g. ~/miniconda3
-source ~/miniconda3/bin/activate
-
-# Create a horton3 conda environment. (optional, recommended)
-conda create -n horton3
-source activate horton3
-
-# Install the stable release.
-conda install -c theochem qc-selector
-
-# Unstable releases
-# (Only do this if you understand the implications.)
-# Install the testing release. (beta)
-conda install -c theochem/label/test qc-selector
-# Install the development release. (alpha)
-conda install -c theochem/label/dev qc-selector
-
-
-
-
-

Installation with Pip

-
    -
  1. You can work in a virtual environment:

  2. -
-
# Create a virtual environment in ~/horton3
-# Feel free to change the path.
-python3 -m venv ~/horton3
-
-# Activate the virtual environemnt.
-source ~/horton3/bin/activate
-
-# Install the stable release in the venv horton3.
-pip3 install qc-selector
-# alternative: python3 -m pip install qc-selector
-
-# For developers, install a pre-release (alpha or beta).
-# (Only do this if you understand the implications.)
-pip3 install --pre qc-selector
-# alternative: python3 -m pip install --pre qc-selector
-
-
-
    -
  1. You can install into your {$HOME} directory without creating a virtual environment

  2. -
-
# Install the stable release in your home directory.
-pip3 install qc-selector --user
-# alternative: python3 -m pip install qc-selector --user
-
-# For developers, install a pre-release (alpha or beta).
-# (Only do this if you understand the implications.)
-pip3 install --pre qc-selector --user
-# alternative: python3 -m pip install --pre qc-selector --user
-
-
-

This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options.

-

In case the pip3 executable is not found, pip may be installed in a directory which is not included in your ${PATH} variable. This seems to be a common issue on macOS. A simple workaround is to replace pip3 by python3 -m pip.

-

In case Python and your operating system are up to date, you may also use pip instead of pip3 or python instead of python3. The 3 is only used to avoid potential confusion with Python 2. Note that the 3 is only present in names of executables, not names of -Python modules.

-
-
-

Latest git revision

-

This section shows how one can install the latest revision of selector from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, …) and so be prepared to accept them when using the following installation instructions.

-

There are two installation methods:

-
    -
  1. Quick and dirty. Of this method, there are four variants, depending on the correctness of your PATH variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section.

  2. -
-
# with env, correct PATH
-pip install git+https://github.com/theochem/selector.git
-# with env, broken PATH
-python -m pip install git+https://github.com/theochem/selector.git
-# without env, correct PATH
-pip install git+https://github.com/theochem/selector.git --user
-# without env, broken PATH
-python -m pip install git+https://github.com/theochem/selector.git --user
-
-
-
    -
  1. Slow and Smart. In addition to the four variations in the quick and dirty method, the slow and smart can be used with pip or just with setup.py. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you.

  2. -
-
# A) Clone git repo with https OR ssh:
-# The second one only works if you have ssh set up for Github
-#  A1) https
-git clone https://github.com/theochem/selector.git
-#  A2) ssh
-git clone git@github.com:theochem/selector.git
-# B) Optionally write the version string
-pip install roberto  # or any of the three other ways of running pip, see above.
-rob write-version
-# C) Actual install, 6 different methods.
-#  C1) setup.py, with env
-python setup.py install
-#  C2) pip, with env, correct PATH
-pip install .
-#  C3) pip, with env, broken PATH
-python -m pip install .
-#  C4) setup.py, without env
-python setup.py install --user
-#  C5) pip, without env, correct PATH
-pip install . --user
-#  C6) pip, without env, broken PATH
-python -m pip install . --user
-
-
-
-
-

Testing

-

The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation.

-

With Ana- or Miniconda:

-
# Install pytest in your conda env.
-conda install pytest pytest-xdist
-# Then run the tests.
-pytest --pyargs selector -n auto
-
-
-

With Pip:

-
# Install pytest in your conda env ...
-pip install pytest pytest-xdist
-# .. and refresh the virtual environment.
-# This is a venv quirk. Without it, pytest may not find IOData.
-deactivate && source ~/selector/activate
-
-# Alternatively, install pytest in your home directory.
-pip install pytest pytest-xdist --user
-
-# Finally, run the tests.
-pytest --pyargs selector -n auto
-
-
-
-
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/intro.html b/book/content/_build/html/intro.html deleted file mode 100644 index ebba4142..00000000 --- a/book/content/_build/html/intro.html +++ /dev/null @@ -1,332 +0,0 @@ - - - - - - - - - Welcome to QC-Selector’s Documentation! — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - - - -
- - -
- -
- Contents -
- -
-
-
-
-
- -
- - -
-

Welcome to QC-Selector’s Documentation!

-

selector is a free, open-source, and cross-platform Python library designed to help you effortlessly identify the most diverse subset of molecules from your dataset. Please use the following citation in any publication using selector library:

-

“QC-Selector: A Generic Python Package for Subset Selection”, Fanwang Meng, Alireza Tehrani, Valerii Chuiko, Abigail Broscius, Abdul, Hassan, Maximilian van Zyl, Marco Martínez González, Yang, Ramón Alain Miranda-Quintana, Paul W. Ayers, and Farnaz Heidar-Zadeh”

-

The selector source code is hosted on GitHub and is released under the GNU General Public License v3.0. We welcome any contributions to the selector library in accordance with our Code of Conduct; please see our Contributing Guidelines. Please report any issues you encounter while using selector library on GitHub Issues. For further information and inquiries please contact us at qcdevs@gmail.com.

-
-

Why QC-Selector?

-

In the world of chemistry, selecting the right subset of molecules is critical for a wide range of applications, including drug discovery, materials science, and molecular optimization. QC-Selector offers a cutting-edge solution to streamline this process, empowering researchers, scientists, and developers to make smarter decisions faster.

-
-
-

Key Features

-
    -
  1. Import Your Dataset: Simply import your molecule dataset in various file formats, including SDF, SMILES, and InChi, to get started.

  2. -
  3. Define Selection Criteria: Specify the desired level of diversity and other relevant parameters to tailor the subset selection to your unique requirements.

  4. -
  5. Run the Analysis: Let QC-Selector’s powerful algorithms process your dataset and efficiently select the most diverse molecules.

  6. -
  7. Export: Explore the diverse subset and export the results for further analysis and integration into your projects.

  8. -
- -
-
-
-
-
-
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/objects.inv b/book/content/_build/html/objects.inv deleted file mode 100644 index 7b7103a2..00000000 Binary files a/book/content/_build/html/objects.inv and /dev/null differ diff --git a/book/content/_build/html/partition.html b/book/content/_build/html/partition.html deleted file mode 100644 index 8a81f280..00000000 --- a/book/content/_build/html/partition.html +++ /dev/null @@ -1,420 +0,0 @@ - - - - - - - - - Partition based methods — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - - - -
- - -
- -
-
-
-
-
- -
- -
-

Partition based methods

-

Module for Partition-Based Selection Methods.

-
-
-class selector.partition.DirectedSphereExclusion(r0=None, ref_index=0, p=2.0, eps=0.0, tol=0.05, n_iter=10, random_seed=42)
-

Select samples using Directed Sphere Exclusion (DISE) algorithm.

-

In a nutshell, this algorithm iteratively excludes any sample within a given radius from -any already selected sample. The radius of the exclusion sphere is an adjustable parameter. -Compared to Sphere Exclusion algorithm, the Directed Sphere Exclusion algorithm achieves a -more evenly distributed subset selection by abandoning the random selection approach and -instead imposing a directed selection.

-

Reference sample is chosen based on the ref_index, which is excluded from the selected -subset. All samples are sorted (ascending order) based on their Minkowski p-norm distance -from the reference sample. Looping through sorted samples, the sample is selected if it is -not already excluded. If selected, all its neighboring samples within a sphere of radius r -(i.e., exclusion sphere) are excluded from being selected. When the selected number of points -is greater than specified subset size, the selection process terminates. The r0 is used -as the initial radius of exclusion sphere, however, it is optimized to select the desired -number of samples.

-

Gobbi, A., and Lee, M.-L. (2002). DISE: directed sphere exclusion. -Journal of Chemical Information and Computer Sciences, -43(1), 317–323. https://doi.org/10.1021/ci025554v

-
-
-algorithm(X, max_size)
-

Return selected samples based on directed sphere exclusion algorithm.

-
-
X: ndarray of shape (n_samples, n_features)

Feature matrix of n_samples samples in n_features dimensional space.

-
-
max_size: int

Maximum number of samples to select.

-
-
-
-
selected: list

List of indices of selected samples.

-
-
-
- -
-
-select_from_cluster(X, size, cluster_ids=None)
-

Return selected samples from a cluster based on directed sphere exclusion algorithm

-
-
X: ndarray of shape (n_samples, n_features)

Feature matrix of n_samples samples in n_features dimensional space.

-
-
size: int

Number of samples to be selected.

-
-
cluster_ids: np.ndarray

Indices of samples that form a cluster.

-
-
-
-
selected: list

List of indices of selected samples.

-
-
-
- -
- -
-
-class selector.partition.GridPartitioning(cells, grid_method='equisized_independent', max_dim=None, random_seed=42)
-

Selecting points using the Grid Partitioning algorithm.

-

Points are partitioned into grids using an algorithm (equisized independent or equisized -dependent). A point is selected from each of the grids while the number of selected points is -less than the number requested and while the grid has available points remaining, looping until -the number of requested points is satisfied. If at the end, the number of points needed is less -than the number of grids available to select from, the points are chosen from the grids with the -greatest diversity.

-

Adapted from https://doi.org/10.1016/S1093-3263(99)00016-9.

-
-
-select_from_cluster(arr, num_selected, cluster_ids=None)
-

Grid partitioning algorithm for selecting points from cluster.

-
-
arr: np.ndarray

Coordinate array of points

-
-
num_selected: int

Number of molecules that need to be selected.

-
-
cluster_ids: np.ndarray

Indices of molecules that form a cluster

-
-
-
-
selected: list

List of ids of selected molecules

-
-
-
- -
- -
-
-class selector.partition.Medoid(start_id=0, func_distance=<function Medoid.<lambda>>, scaling=10)
-

Selecting points using an algorithm adapted from KDTree.

-

Points are initially used to construct a KDTree. Eucleidean distances are used for this -algorithm. The first point selected is based on the starting_idx provided and becomes the first -query point. An approximation of the furthest point to the query point is found using -find_furthest_neighbor and is selected. find_nearest_neighbor is then done to eliminate close -neighbors to the new selected point. Medoid is then calculated from previously selected points -and is used as the new query point for find_furthest_neighbor, repeating the process. Terminates -upon selecting requested number of points or if all available points exhausted.

-

Adapted from: https://en.wikipedia.org/wiki/K-d_tree#Construction

-
-
-select_from_cluster(arr, num_selected, cluster_ids=None)
-

Main function for selecting points using the KDTree algorithm.

-
-
arr: np.ndarray

Coordinate array of points

-
-
num_selected: int

Number of molecules that need to be selected.

-
-
cluster_ids: np.ndarray

Indices of molecules that form a cluster

-
-
-
-
selected: list

List of ids of selected molecules

-
-
-
- -
- -
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/py-modindex.html b/book/content/_build/html/py-modindex.html deleted file mode 100644 index 1979a233..00000000 --- a/book/content/_build/html/py-modindex.html +++ /dev/null @@ -1,278 +0,0 @@ - - - - - - - - Python Module Index — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - -
- - -
- -
-
-
-
-
- -
- - -

Python Module Index

- -
- d -
- - - - - - - - - - - - - - - - - - - -
 
- d
- selector -
    - selector.base -
    - selector.dissimilarity -
    - selector.partition -
    - selector.utils -
- - -
- - - -
-
- -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/search.html b/book/content/_build/html/search.html deleted file mode 100644 index 2291efec..00000000 --- a/book/content/_build/html/search.html +++ /dev/null @@ -1,272 +0,0 @@ - - - - - - - - Search — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - -
- - -
- -
-
-
-
-
- -
- -

Search

- - - - -

- Searching for multiple words only shows matches that contain - all words. -

- - -
- - - -
- - - -
- -
- - -
- - - -
-
- -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/searchindex.js b/book/content/_build/html/searchindex.js deleted file mode 100644 index f817783b..00000000 --- a/book/content/_build/html/searchindex.js +++ /dev/null @@ -1 +0,0 @@ -Search.setIndex({docnames:["base","dissimilarity","installation","intro","partition","starting","utils"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":4,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,"sphinx.ext.intersphinx":1,"sphinxcontrib.bibtex":7,sphinx:56},filenames:["base.rst","dissimilarity.rst","installation.ipynb","intro.md","partition.rst","starting.ipynb","utils.rst"],objects:{"selector.base":{SelectionBase:[0,1,1,""]},"selector.base.SelectionBase":{select:[0,2,1,""],select_from_cluster:[0,2,1,""]},"selector.dissimilarity":{MaxMin:[1,1,1,""],MaxSum:[1,1,1,""],OptiSim:[1,1,1,""]},"selector.dissimilarity.MaxMin":{select_from_cluster:[1,2,1,""]},"selector.dissimilarity.MaxSum":{select_from_cluster:[1,2,1,""]},"selector.dissimilarity.OptiSim":{algorithm:[1,2,1,""],select_from_cluster:[1,2,1,""]},"selector.partition":{DirectedSphereExclusion:[4,1,1,""],GridPartitioning:[4,1,1,""],Medoid:[4,1,1,""]},"selector.partition.DirectedSphereExclusion":{algorithm:[4,2,1,""],select_from_cluster:[4,2,1,""]},"selector.partition.GridPartitioning":{select_from_cluster:[4,2,1,""]},"selector.partition.Medoid":{select_from_cluster:[4,2,1,""]},"selector.utils":{optimize_radius:[6,3,1,""]},selector:{base:[0,0,0,"-"],dissimilarity:[1,0,0,"-"],partition:[4,0,0,"-"],utils:[6,0,0,"-"]}},objnames:{"0":["py","module","Python module"],"1":["py","class","Python class"],"2":["py","method","Python method"],"3":["py","function","Python function"]},objtypes:{"0":"py:module","1":"py:class","2":"py:method","3":"py:function"},terms:{"0":[1,2,3,4,5],"00016":4,"01":1,"05":4,"1":[1,2,4,5],"10":[1,4,5],"100":5,"1016":4,"1021":[1,4],"11":5,"1181":1,"1188":1,"12":5,"13":5,"14":5,"15":5,"150":5,"1997":1,"2":[1,2,4,5],"20":5,"2002":[1,4],"2012":1,"21":[1,2],"2d":5,"3":[2,5],"317":4,"31st":1,"323":4,"3263":4,"37":1,"4":[2,5],"42":[1,4,5],"43":4,"5":[2,5],"598":1,"6":[1,2,5],"604":1,"7":5,"8":[2,5],"9":[4,5],"99":4,"abstract":0,"break":2,"case":2,"class":[1,4,6],"default":5,"do":2,"export":3,"final":2,"float":5,"function":[1,4,5,6],"gonz\u00e1lez":3,"import":[3,5],"int":[0,1,4,5,6],"mart\u00ednez":3,"new":4,"public":3,"ram\u00f3n":3,"return":[0,1,4,5,6],"true":5,"try":2,"while":[3,4],A:[2,3,4],By:5,For:[2,3,5],If:[0,1,2,4,5,6],In:[2,3,4,5],OR:2,Of:2,The:[1,2,3,4,5],Then:[1,2],There:2,These:2,To:2,With:2,a1:2,a2:2,abandon:4,abdul:3,abigail:3,abov:2,accept:2,accord:3,achiev:4,acm:1,activ:[1,2],actual:2,ad:1,adapt:4,addit:[2,5],adjust:4,after:2,again:2,aim:1,al:1,alain:3,algorithm:[1,3,4,6],alireza:3,all:[1,4],allan:1,alpha:2,alreadi:[1,4],also:2,altern:2,among:1,an:4,anaconda:2,analysi:3,ani:[1,2,3,4,5],api:2,applic:3,approach:4,approxim:4,ar:[0,1,2,4],argument:5,arr:[4,5],arr_dist:5,arr_dist_clust:5,arrai:[0,1,4],ascend:4,ashton:1,auto:2,automat:2,avail:4,avoid:2,axi:5,ayer:3,b:2,bashrc:2,becom:4,been:1,being:4,belo:5,belong:0,below:2,best:2,beta:2,between:[1,5],bin:2,black:5,bool:5,borodin:1,bound:5,box:5,broken:2,brosciu:3,bug:2,build:2,c1:2,c2:2,c3:2,c4:2,c5:2,c6:2,c:[2,5],calcul:[1,4],can:[2,5],cannot:6,cell:4,center:[1,5],center_box:5,chang:2,chem:1,chemic:4,chemistri:3,choos:1,chosen:[1,4],chuiko:3,chul:1,ci025554v:4,ci970282v:1,citat:3,class_label:5,class_labels_clust:5,clean:2,clear:1,clone:2,close:4,closest:6,cluster:[0,1,4,6],cluster_id:[4,6],cluster_on:5,cluster_std:5,cluster_thre:5,cluster_two:5,code:3,com:[2,3,5],come:2,common:2,compar:4,comparison:2,compound:1,comput:[1,4,5],conda:2,conduct:3,confus:2,construct:4,contact:3,contribut:3,converg:6,coord:5,coordin:[1,4],coords_clust:5,correct:[2,6],cov:2,creat:2,criteria:3,critic:3,cross:3,cut:3,d_tree:4,databas:1,dataset:[1,3,5],date:2,deactiv:2,decis:3,def:5,defin:3,depend:[2,4],descript:1,design:3,desir:[3,4],detail:2,determin:1,dev:2,develop:[2,3],deviat:5,differ:[2,5],dimension:[0,1,4,6],direct:4,directedsphereexclus:[4,5,6],directori:2,dirti:2,disabl:5,discard:1,discoveri:3,dise:4,dissim_func:5,dissimilarityselect:5,dist:5,distanc:[0,1,4,5],distinct:1,distribut:4,divers:[0,1,3,4,5],selector:[0,1,2,3,4,5,6],diversif:1,doc:2,doi:[1,4],don:2,done:4,dpi:5,drug:3,due:2,dynam:1,e:[0,1,2,4,6],each:[0,4,5],easi:5,edg:[2,3],effici:3,effortlessli:3,element:1,elimin:4,els:5,empow:3,en:4,encount:3,end:4,enjoi:2,enumer:5,env:2,environ:2,environemnt:2,ep:[1,4],equis:4,equisized_depend:5,equisized_independ:[4,5],et:1,eucleidean:4,euclidean:5,evenli:4,everi:1,exampl:5,exclud:4,exclus:[4,6],execut:2,exhaust:4,exist:1,experiment:2,explain:2,explor:3,fals:5,fanwang:3,far:2,farnaz:3,faster:3,featur:[0,1,4,5,6],feel:2,figur:5,file:3,find:[1,2],find_furthest_neighbor:4,find_nearest_neighbor:4,first:[1,2,4,5],follow:[1,2,3],form:[1,4,6],format:3,found:[2,4],four:2,fragment:1,free:[2,3],from:[0,1,2,3,4,5,6],fun_dist:[0,1],func_dist:[1,4],further:3,furthest:[1,4],g:2,gener:3,generate_synthetic_data:5,get:[2,3],git:5,github:[2,3,5],given:4,gmail:3,gnu:3,go:5,goal:1,gobbi:4,graph_data:5,greater:4,greatest:[1,4],grid:4,grid_method:[4,5],grid_part:5,grid_partit:5,gridpartit:[4,5],guidelin:3,ha:[1,4],harder:2,hassan:3,have:[1,2,5],heidar:3,help:3,home:2,horton3:2,host:3,how:[2,5],howev:4,hstack:5,html:5,http:[1,2,4,5],hyun:1,i:[0,1,4,5,6],id:4,ideal:2,identif:1,identifi:3,implic:2,impos:4,inchi:3,includ:[2,3],independ:4,indic:[0,1,4,6],inf:1,inform:[3,4],initi:[1,4],inquiri:3,instal:5,instanc:6,instead:[2,4],instruct:2,integ:[0,5],integr:3,iodata:2,issu:[2,3],iter:[4,6],its:4,j:1,journal:4,just:2,k:[1,4],kdtree:4,keyword:5,kind:2,kwarg:5,l:4,label:[0,1,2,5],labels_mock:5,lambda:[4,5],latter:5,learn:5,lee:[1,4],less:4,let:3,level:3,librari:3,licens:3,list:[0,1,4,6],live:2,load:2,logic:1,loop:4,m:[2,4],machin:2,maco:2,made:0,mai:2,main:[2,4],make:[2,3,5],make_blob:5,manag:2,manual:2,marco:3,mark:1,materi:3,matplotlib:5,matrix:[0,1,4,5,6],max:1,max_dim:4,max_siz:[1,4],maxim:1,maximilian:3,maximum:[1,4],maxmin:1,maxsum:1,medoid:[1,4],membership:5,meng:3,method:2,metric:5,miniconda3:2,minimum:1,minkowski:4,miranda:3,mocked_cluster_coord:5,modul:[1,2,4,5,6],mol_id:5,molecul:[3,4],molecular:[1,3],monoton:1,more:[2,4],most:[1,3],n:2,n_cluster:5,n_featur:[0,1,4,5,6],n_iter:[1,4],n_sampl:[0,1,4,5,6],name:2,ndarrai:[0,1,4,5,6],need:[2,4],neighbor:4,next:1,none:[0,1,4,5,6],norm:4,normal:[2,5],note:2,np:[0,1,4,5,6],num_select:[4,5],number:[0,1,4,5,6],numpi:[0,2,5],nutshel:4,obj:6,object:6,obtain:6,obviou:5,offer:3,onc:1,one:[0,2,5],ones:1,onli:2,open:3,oper:2,optim:[3,4,6],optimize_radiu:6,option:[0,2,5],optisim:[1,6],order:4,org:[1,2,4,5],other:[2,3],otherwis:1,our:3,outsid:1,own:2,p:[1,4],packag:[2,3],pair:1,pairwis:[0,1,5],pairwise_dist:5,paramet:[3,4,5],path:2,pattern:5,paul:3,pick:2,pip3:2,pip:5,platform:3,pleas:[3,5],plt:5,point:[0,1,4,5,6],possibl:[1,6],potenti:2,power:3,pre:2,prepar:2,presenc:2,present:[1,2],previou:[1,2],previous:[1,4],principl:1,proceed:1,process:[1,3,4],project:[2,3],properli:2,properti:1,protocol:2,provid:[0,4],py:2,pyarg:2,pylint:5,pypi:2,pyplot:5,pytest:2,python3:2,python:[2,3],qc:[2,5],qcdev:3,quantit:1,queri:4,quick:2,quintana:3,quirk:2,r0:[1,4],r:[1,4,5],radiu:[1,4,6],random:[4,5],random_se:[1,4,5],random_st:5,randomli:[1,5],rang:[3,5],rdkit:5,recommend:2,ref_index:4,refer:[4,5],refresh:2,relationship:1,releas:3,relev:3,remain:4,repeat:[1,4],replac:2,repo:2,report:3,repositori:2,repres:[0,5],request:4,requir:[2,3],research:3,result:3,return_cent:5,right:3,risk:2,rob:2,roberto:2,run:[2,3],s1093:4,s:1,sampl:[0,1,4,5,6],satisfi:4,scale:4,scatter:5,scenario:2,sci:1,scienc:[3,4],scientist:3,scikit:5,scipi:2,sdf:3,search:6,second:[1,2],section:2,see:[2,3],seed:5,seem:2,seen:5,select:[0,1,3,4,6],select_from_clust:[0,1,4],selected_id3:5,selected_id4:5,selected_id5:5,selected_id6:5,selected_id7:5,selected_id8:5,selected_id:5,selected_ids1:5,selected_ids2:5,selected_ids3:5,selected_ids4:5,selected_ids5:5,selected_ids6:5,selected_mock:5,selectionbas:0,selector:[2,5],set:2,setup:2,shape:[0,1,4,6],show:[2,5],shuffl:5,sigact:1,sigai:1,sigmod:1,simpl:2,simplest:2,simpli:3,size:[0,1,4,5,6],sklearn:5,slow:2,smart:2,smarter:3,smile:3,so:2,solut:3,some:2,sort:4,sourc:[2,3],space:[0,1,4,6],specifi:[3,4],sphere:[4,6],sphere_exclus:5,squar:[0,1],ssh:2,stabl:5,standard:5,start:[2,3],start_id:[1,4],starting_idx:[4,5],state:5,step:1,str:5,streamlin:3,string:[0,2],structur:1,submodular:1,subsampl:1,subsequ:1,subset:[0,1,3,4,5,6],sudden:2,sum:1,support:5,symmetr:5,symposium:1,syn_data:5,synthstic:5,system:[1,2],t:2,tailor:3,tehrani:3,termin:4,text:5,than:4,thei:[1,2],them:2,theochem:[2,5],thi:[0,1,2,3,4,5],those:1,three:2,through:4,tol:[1,4],treat:[0,1],tupl:5,tutori:5,two:[2,5],type:5,under:3,understand:2,union:5,uniqu:3,unstabl:2,until:[2,4],up:2,updat:1,upon:4,us:[1,2,3,4,5,6],user:2,v3:3,valerii:3,van:3,variabl:2,variant:2,variat:2,variou:3,venv:2,version:2,via:1,virtual:2,visual:5,vstack:5,w0632:5,w:3,wai:2,warn:2,we:[2,3,5],when:[1,2,4,5],where:5,wherea:1,whether:5,which:[1,2,4],whichev:2,wide:[1,3],wiki:4,wikipedia:4,within:4,without:2,work:[2,5],workaround:2,world:3,write:2,www:2,x:[0,1,4,5,6],xdist:2,y:5,yang:3,ye:1,yet:2,you:[2,3],your:[2,3],yuli:1,zadeh:3,zyl:3},titles:["Base class","Dissimilarity based methods","Installation","Welcome to QC-Selector\u2019s Documentation!","Partition based methods","Getting started","Utilities"],titleterms:{"class":0,adapt:5,algorithm:5,ana:2,ar:5,assum:5,base:[0,1,4,5],brute:5,cluster:5,data:5,demo:5,depend:5,direct:5,dissimilar:[1,5],document:3,equis:5,exclus:5,featur:3,gener:5,get:5,git:2,grid:5,independ:5,instal:2,k:5,kei:3,latest:2,maxmin:5,maxsum:5,method:[1,4,5],miniconda:2,minmax:5,optimiz:5,optisim:5,partit:[4,5],pip:2,qc:3,releas:2,revis:2,run:5,s:3,select:5,selector:3,sphere:5,stabl:2,start:5,strength:5,synthet:5,test:2,util:6,welcom:3,why:3,without:5}}) diff --git a/book/content/_build/html/starting.html b/book/content/_build/html/starting.html deleted file mode 100644 index 32a514a5..00000000 --- a/book/content/_build/html/starting.html +++ /dev/null @@ -1,811 +0,0 @@ - - - - - - - - - Getting started — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- - -
-
- -
- -
-

Getting started

-
-

Demo - Dissimilarity Based Selection Synthetic Data

-

In this tutorial, we are going to show how the QC-Selector work with 2D synthetic data. Each axis represents one feature. For each example, we will have two different synthetic datasets where the first one can be seen as randomly generated data points and the latter generates data points belonging to different clusters. By using 2D feature data points, it makes visualization easy.

-
-
-

Generating Synthetic Data

-
-
-
# install the selector module
-!pip install git+https://github.com/theochem/Selector
-!pip install rdkit
-
-
-
-
-
-
-
import selector
-import matplotlib.pyplot as plt
-import numpy as np
-from typing import Any, Tuple, Union
-from sklearn.datasets import make_blobs
-from sklearn.metrics import pairwise_distances
-
-def generate_synthetic_data(n_samples: int = 100,
-                            n_features: int = 2,
-                            n_clusters: int = 2,
-                            cluster_std: float = 1.0,
-                            center_box: Tuple[float, float] = (-10.0, 10.0),
-                            metric: str = "euclidean",
-                            shuffle: bool = True,
-                            random_state: int = 42,
-                            pairwise_dist: bool = False,
-                            **kwargs: Any,
-                            ) -> Union[Tuple[np.ndarray, np.ndarray],
-                                       Tuple[np.ndarray, np.ndarray, np.ndarray]]:
-    """Generate synthetic data.
-
-    Parameters
-    ----------
-    n_samples : int, optional
-        The number of samples. Default=100.
-    n_features : int, optional
-        The number of features. Default=2.
-    n_clusters : int, optional
-        The number of clusters. Default=2.
-    cluster_std : float, optional
-        The standard deviation of the clusters. Default=1.0.
-    center_box : tuple[float, float], optional
-        The bounding box for each cluster center when centers are generated at random.
-        Default=(-10.0, 10.0).
-    metric : str, optional
-        The metric used for computing pairwise distances. For the supported
-        distance matrix, please refer to
-        https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html.
-        Default="euclidean".
-    shuffle : bool, optional
-        Whether to shuffle the samples. Default=True.
-    random_state : int, optional
-        The random state used for generating synthetic data. Default=42.
-    pairwise_dist : bool, optional
-        If True, then compute and return the pairwise distances between samples. Default=False.
-    **kwargs : Any, optional
-            Additional keyword arguments for the scikit-learn `pairwise_distances` function.
-
-    Returns
-    -------
-    syn_data : np.ndarray
-        The synthetic data.
-    class_labels : np.ndarray
-        The integer labels for cluster membership of each sample.
-    dist: np.ndarray
-        The symmetric pairwise distances between samples.
-
-    """
-    # pylint: disable=W0632
-    syn_data, class_labels = make_blobs(n_samples=n_samples,
-                                        n_features=n_features,
-                                        centers=n_clusters,
-                                        cluster_std=cluster_std,
-                                        center_box=center_box,
-                                        shuffle=shuffle,
-                                        random_state=random_state,
-                                        return_centers=False,
-                                        )
-    if pairwise_dist:
-        dist = pairwise_distances(X=syn_data,
-                                  Y=None,
-                                  metric=metric,
-                                  **kwargs,
-                                  )
-        return syn_data, class_labels, dist
-    else:
-        return syn_data, class_labels
-
-
-
-
-
-
-
coords, class_labels, arr_dist = generate_synthetic_data(n_samples=100,
-                                                         n_features=2,
-                                                         n_clusters=1,
-                                                         pairwise_dist=True,
-                                                         metric="euclidean",
-                                                         random_state=42)
-
-coords_cluster, class_labels_cluster, arr_dist_cluster = generate_synthetic_data(n_samples=100,
-                                                         n_features=2,
-                                                         n_clusters=3,
-                                                         pairwise_dist=True,
-                                                         metric="euclidean",
-                                                         random_state=42)
-def graph_data(coords, selected=None, reference=False):
-    plt.figure(dpi=150)
-    plt.scatter(coords[:, 0], coords[:, 1])
-    if selected:
-        for i, mol_id in enumerate(selected):
-            plt.scatter(coords[mol_id, 0], coords[mol_id, 1], c='r')
-            plt.text(coords[mol_id,0], coords[mol_id,1], str(i+1))
-    if reference:
-        plt.scatter(coords[0, 0], coords[0, 1], c='black')
-    plt.show()
-
-
-
-
-
-
-
graph_data(coords)
-graph_data(coords_cluster)
-
-
-
-
-_images/starting_6_0.png -_images/starting_6_1.png -
-
-
-
-

Running Dissimilarity Algorithms

-
-

Brute Strength - MaxMin

-
-
-
# MaxMin method
-from selector.methods.partition import *
-from selector.methods.dissimilarity import *
-
-# diverse subset selection from randomly generated data points
-selector = MaxMin()
-selected_ids1 = selector.select(arr=arr_dist, size=12)
-
-# diverse subset selection from data points with obvious patterns (different clusters)
-selector = MaxMin()
-selected_ids2 = selector.select(arr=arr_dist_cluster, labels=class_labels_cluster, size=12)
-
-
-
-
-
-
-
graph_data(coords,selected_ids1)
-graph_data(coords_cluster,selected_ids2)
-
-
-
-
-_images/starting_10_0.png -_images/starting_10_1.png -
-
-
-
-

Adapted Optimizable K-Dissimilarity Selection (OptiSim)

-
-
-
# diverse subset selection from randomly generated data points
-selected_id3 = OptiSim().select(coords, 12)
-# diverse subset selection from data points with obvious patterns (different clusters)
-selected_id4 = OptiSim().select(coords_cluster, size=12, labels=class_labels_cluster)
-
-graph_data(coords,selected_id3)
-graph_data(coords_cluster,selected_id4)
-
-
-
-
-_images/starting_12_0.png -_images/starting_12_1.png -
-
-
-
-

Directed Sphere Exclusion

-
-
-
# diverse subset selection from randomly generated data points
-selected_id5 = DirectedSphereExclusion().select(coords, 12)
-# diverse subset selection from data points with obvious patterns (different clusters)
-selected_id6 = DirectedSphereExclusion().select(coords_cluster, size=12, labels=class_labels_cluster)
-
-graph_data(coords,selected_id5)
-graph_data(coords_cluster,selected_id6)
-
-
-
-
-_images/starting_14_0.png -_images/starting_14_1.png -
-
-
-
-

Grid Partitioning Method

-
-
-
# diverse subset selection from randomly generated data points
-selected_id7 = GridPartitioning(2, "equisized_independent").select(coords, 12)
-# diverse subset selection from data points with obvious patterns (different clusters)
-selected_id8 = GridPartitioning(2, "equisized_independent").select(coords_cluster,
-                                                                   size=12,
-                                                                   labels=class_labels_cluster)
-
-graph_data(coords,selected_id7)
-graph_data(coords_cluster,selected_id8)
-# 20, 5, 3, "equisized_independent"
-
-
-
-
-_images/starting_16_0.png -_images/starting_16_1.png -
-
-
-
-
-

MinMax selection with clusters, but without assuming there are clusters

-
-
-
selector = MaxMin()
-selected_ids = selector.select(arr=arr_dist_cluster, size=15)
-graph_data(coords_cluster, selected_ids)
-
-
-
-
-_images/starting_18_0.png -
-
-
-
-
import numpy as np
-from sklearn.metrics import pairwise_distances
-np.random.seed(42)
-cluster_one = np.random.normal(0, 1, (3,2))
-cluster_two = np.random.normal(10, 1, (6,2))
-cluster_three = np.random.normal(20, 1, (7,2))
-labels_mocked = np.hstack([[0 for i in range(3)],
-                          [1 for i in range(6)],
-                          [2 for i in range(7)]])
-
-mocked_cluster_coords = np.vstack([cluster_one, cluster_two, cluster_three])
-selector = MaxMin(lambda x: pairwise_distances(x, metric='euclidean'))
-selected_mocked = selector.select(mocked_cluster_coords, size=15, labels=labels_mocked)
-
-graph_data(mocked_cluster_coords, selected_mocked)
-
-selected_mocked
-
-
-
-
-_images/starting_19_0.png -
[0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 10, 11, 9, 13]
-
-
-
-
-
-

Brute Strength - maxsum

-
-
-
selector = DissimilaritySelection(num_selected=12,
-                                  arr_dist=arr_dist,
-                                  random_seed=42,
-                                  method="maxsum")
-selector.starting_idx = 0
-selected_ids2 = selector.select()
-
-
-
-
-
-
-
graph_data(selected_ids2)
-
-
-
-
-_images/starting_22_0.png -
-
-
-
-

Grid Partitioning - Equisized Independent

-
-
-
selector = DissimilaritySelection(features=coords,
-                                  num_selected=12,
-                                  arr_dist=arr_dist,
-                                  grid_method="grid_partioning",
-                                  random_seed=42)
-selector.starting_idx = 0
-selected_ids3 = selector.select()
-
-
-
-
-
-
-
graph_data(selected_ids3)
-
-
-
-
-_images/starting_25_0.png -
-
-
-
-

Grid Partitioning - Equisized Dependent

-
-
-
selector = DissimilaritySelection(num_selected=12,
-                                  features = coords,
-                                  random_seed=42,
-                                  dissim_func="grid_partitioning",
-                                  grid_method="equisized_dependent")
-selector.starting_idx = 0
-selected_ids4 = selector.select()
-
-
-
-
-
-
-
graph_data(selected_ids4)
-
-
-
-
-_images/starting_28_0.png -
-
-
-
-

Directed Sphere Exclusion

-
-
-
selector = DissimilaritySelection(num_selected=12,
-                                  features=coords,
-                                  dissim_func="sphere_exclusion",
-                                  random_seed=42)
-selector.starting_idx = 0
-selected_ids5 = selector.select()
-
-
-
-
-
-
-
graph_data(selected_ids5, True)
-
-
-
-
-_images/starting_31_0.png -
-
-
-
-

Optisim

-
-
-
selector = DissimilaritySelection(num_selected=12,
-                                  features=coords,
-                                  dissim_func="optisim",
-                                  random_seed=42)
-selector.starting_idx = 0
-selected_ids6 = selector.select()
-
-
-
-
-
-
-
graph_data(selected_ids6)
-
-
-
-
-_images/starting_34_0.png -
-
-
-
-
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/html/utils.html b/book/content/_build/html/utils.html deleted file mode 100644 index 1ade8993..00000000 --- a/book/content/_build/html/utils.html +++ /dev/null @@ -1,316 +0,0 @@ - - - - - - - - - Utilities — Ayers Lab - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
-
- -
- - - - - - - - - - - - - - - - -
- - -
- -
-
-
-
-
- -
- -
-

Utilities

-

Module for Selection Utilities.

-
-
-selector.utils.optimize_radius(obj, X, size, cluster_ids=None)
-

Algorithm that uses sphere exclusion for selecting points from cluster.

-

Iteratively searches for the optimal radius to obtain the correct number -of selected samples. If the radius cannot converge to return size points, -the function returns the closest number of samples to size as possible.

-
-
obj: object

Instance of DirectedSphereExclusion or OptiSim selection class.

-
-
X: ndarray of shape (n_samples, n_features)

Feature matrix of n_samples samples in n_features dimensional space.

-
-
size: int

Number of sample points to select (i.e. size of the subset).

-
-
cluster_ids: np.ndarray

Indices of points that form a cluster.

-
-
-
-
selected: list

List of indices of selected samples.

-
-
-
- -
- - - - -
- - - - - -
-
-
-
-

- - By The QC-Dev Community with the support of Digital Research Alliance of Canada and The Jupyter Book Community
- - © Copyright 2022-2023.
-

-
-
-
- - -
-
- - - - - diff --git a/book/content/_build/jupyter_execute/installation.ipynb b/book/content/_build/jupyter_execute/installation.ipynb deleted file mode 100644 index 225ccd26..00000000 --- a/book/content/_build/jupyter_execute/installation.ipynb +++ /dev/null @@ -1,192 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f1be9e2f", - "metadata": {}, - "source": [ - "# Installation\n", - "\n", - "## Stable releases\n", - "\n", - "
\n", - "Warning:\n", - "\n", - " \n", - "We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the “Latest git revision” section below.\n", - "
\n", - "\n", - "The following dependencies are required to run selector properly,\n", - "\n", - "* Python >= 3.6: http://www.python.org/ \n", - "* NumPy >= 1.21.5: http://www.numpy.org/\n", - "* SciPy >= 1.5.0: http://www.scipy.org/\n", - "* PyTest >= 5.3.4: https://docs.pytest.org/\n", - "* PyTest-Cov >= 2.8.0: https://pypi.org/project/pytest-cov\n", - "\n", - "Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below.\n", - "\n", - "\n", - "## Installation with Ana- or Miniconda:\n", - "\n", - "1. To install selector using the conda package management system, install [miniconda](https://conda.io/miniconda.html) or [anaconda](https://www.anaconda.com/download) first, and then:\n", - "\n", - "```\n", - "# Activate your main conda environment if it is not loaded in your .bashrc.\n", - "# E.g. run the following if you have miniconda installed in e.g. ~/miniconda3\n", - "source ~/miniconda3/bin/activate\n", - "\n", - "# Create a horton3 conda environment. (optional, recommended)\n", - "conda create -n horton3\n", - "source activate horton3\n", - "\n", - "# Install the stable release.\n", - "conda install -c theochem qc-selector\n", - "\n", - "# Unstable releases\n", - "# (Only do this if you understand the implications.)\n", - "# Install the testing release. (beta)\n", - "conda install -c theochem/label/test qc-selector\n", - "# Install the development release. (alpha)\n", - "conda install -c theochem/label/dev qc-selector\n", - "```\n", - "\n", - "## Installation with Pip\n", - "\n", - "1. You can work in a [virtual environment](https://docs.python.org/3/tutorial/venv.html):\n", - "\n", - "```\n", - "# Create a virtual environment in ~/horton3\n", - "# Feel free to change the path.\n", - "python3 -m venv ~/horton3\n", - "\n", - "# Activate the virtual environemnt.\n", - "source ~/horton3/bin/activate\n", - "\n", - "# Install the stable release in the venv horton3.\n", - "pip3 install qc-selector\n", - "# alternative: python3 -m pip install qc-selector\n", - "\n", - "# For developers, install a pre-release (alpha or beta).\n", - "# (Only do this if you understand the implications.)\n", - "pip3 install --pre qc-selector\n", - "# alternative: python3 -m pip install --pre qc-selector\n", - "```\n", - "\n", - "\n", - "2. You can install into your `{$HOME}` directory without creating a virtual environment\n", - "\n", - "```\n", - "# Install the stable release in your home directory.\n", - "pip3 install qc-selector --user\n", - "# alternative: python3 -m pip install qc-selector --user\n", - "\n", - "# For developers, install a pre-release (alpha or beta).\n", - "# (Only do this if you understand the implications.)\n", - "pip3 install --pre qc-selector --user\n", - "# alternative: python3 -m pip install --pre qc-selector --user\n", - "```\n", - "\n", - "This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options.\n", - " \n", - "In case the `pip3` executable is not found, pip may be installed in a directory which is not included in your `${PATH}` variable. This seems to be a common issue on macOS. A simple workaround is to replace `pip3` by `python3 -m pip`.\n", - "\n", - "In case Python and your operating system are up to date, you may also use `pip` instead of `pip3` or `python` instead of `python3`. The `3` is only used to avoid potential confusion with Python 2. Note that the `3` is only present in names of executables, not names of \n", - "Python modules.\n", - "\n", - "## Latest git revision\n", - "\n", - "This section shows how one can install the latest revision of selector from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, …) and so be prepared to accept them when using the following installation instructions.\n", - "\n", - "There are two installation methods:\n", - "\n", - "1. **Quick and dirty.** Of this method, there are four variants, depending on the correctness of your `PATH` variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section.\n", - "```\n", - "# with env, correct PATH\n", - "pip install git+https://github.com/theochem/Selector.git\n", - "# with env, broken PATH\n", - "python -m pip install git+https://github.com/theochem/Selector.git\n", - "# without env, correct PATH\n", - "pip install git+https://github.com/theochem/Selector.git --user\n", - "# without env, broken PATH\n", - "python -m pip install git+https://github.com/theochem/Selector.git --user\n", - "```\n", - "\n", - "2. **Slow and Smart.** In addition to the four variations in the quick and dirty method, the slow and smart can be used with `pip` or just with `setup.py`. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you.\n", - "```\n", - "# A) Clone git repo with https OR ssh:\n", - "# The second one only works if you have ssh set up for Github\n", - "# A1) https\n", - "git clone https://github.com/theochem/Selector.git\n", - "# A2) ssh\n", - "git clone git@github.com:theochem/Selector.git\n", - "# B) Optionally write the version string\n", - "pip install roberto # or any of the three other ways of running pip, see above.\n", - "rob write-version\n", - "# C) Actual install, 6 different methods.\n", - "# C1) setup.py, with env\n", - "python setup.py install\n", - "# C2) pip, with env, correct PATH\n", - "pip install .\n", - "# C3) pip, with env, broken PATH\n", - "python -m pip install .\n", - "# C4) setup.py, without env\n", - "python setup.py install --user\n", - "# C5) pip, without env, correct PATH\n", - "pip install . --user\n", - "# C6) pip, without env, broken PATH\n", - "python -m pip install . --user\n", - "```\n", - "\n", - "\n", - "## Testing\n", - "\n", - "The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation.\n", - "\n", - "With Ana- or Miniconda:\n", - "```\n", - "# Install pytest in your conda env.\n", - "conda install pytest pytest-xdist\n", - "# Then run the tests.\n", - "pytest --pyargs selector -n auto\n", - "```\n", - "\n", - "With Pip:\n", - "```\n", - "# Install pytest in your conda env ...\n", - "pip install pytest pytest-xdist\n", - "# .. and refresh the virtual environment.\n", - "# This is a venv quirk. Without it, pytest may not find IOData.\n", - "deactivate && source ~/selector/activate\n", - "\n", - "# Alternatively, install pytest in your home directory.\n", - "pip install pytest pytest-xdist --user\n", - "\n", - "# Finally, run the tests.\n", - "pytest --pyargs selector -n auto\n", - "```" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/book/content/_build/jupyter_execute/installation.py b/book/content/_build/jupyter_execute/installation.py deleted file mode 100644 index a539e56c..00000000 --- a/book/content/_build/jupyter_execute/installation.py +++ /dev/null @@ -1,162 +0,0 @@ -#!/usr/bin/env python - -# # Installation -# -# ## Stable releases -# -#
-# Warning: -# -# -# We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the “Latest git revision” section below. -#
-# -# The following dependencies are required to run selector properly, -# -# * Python >= 3.6: http://www.python.org/ -# * NumPy >= 1.21.5: http://www.numpy.org/ -# * SciPy >= 1.5.0: http://www.scipy.org/ -# * PyTest >= 5.3.4: https://docs.pytest.org/ -# * PyTest-Cov >= 2.8.0: https://pypi.org/project/pytest-cov -# -# Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below. -# -# -# ## Installation with Ana- or Miniconda: -# -# 1. To install selector using the conda package management system, install [miniconda](https://conda.io/miniconda.html) or [anaconda](https://www.anaconda.com/download) first, and then: -# -# ``` -# # Activate your main conda environment if it is not loaded in your .bashrc. -# # E.g. run the following if you have miniconda installed in e.g. ~/miniconda3 -# source ~/miniconda3/bin/activate -# -# # Create a horton3 conda environment. (optional, recommended) -# conda create -n horton3 -# source activate horton3 -# -# # Install the stable release. -# conda install -c theochem qc-selector -# -# # Unstable releases -# # (Only do this if you understand the implications.) -# # Install the testing release. (beta) -# conda install -c theochem/label/test qc-selector -# # Install the development release. (alpha) -# conda install -c theochem/label/dev qc-selector -# ``` -# -# ## Installation with Pip -# -# 1. You can work in a [virtual environment](https://docs.python.org/3/tutorial/venv.html): -# -# ``` -# # Create a virtual environment in ~/horton3 -# # Feel free to change the path. -# python3 -m venv ~/horton3 -# -# # Activate the virtual environemnt. -# source ~/horton3/bin/activate -# -# # Install the stable release in the venv horton3. -# pip3 install qc-selector -# # alternative: python3 -m pip install qc-selector -# -# # For developers, install a pre-release (alpha or beta). -# # (Only do this if you understand the implications.) -# pip3 install --pre qc-selector -# # alternative: python3 -m pip install --pre qc-selector -# ``` -# -# -# 2. You can install into your `{$HOME}` directory without creating a virtual environment -# -# ``` -# # Install the stable release in your home directory. -# pip3 install qc-selector --user -# # alternative: python3 -m pip install qc-selector --user -# -# # For developers, install a pre-release (alpha or beta). -# # (Only do this if you understand the implications.) -# pip3 install --pre qc-selector --user -# # alternative: python3 -m pip install --pre qc-selector --user -# ``` -# -# This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options. -# -# In case the `pip3` executable is not found, pip may be installed in a directory which is not included in your `${PATH}` variable. This seems to be a common issue on macOS. A simple workaround is to replace `pip3` by `python3 -m pip`. -# -# In case Python and your operating system are up to date, you may also use `pip` instead of `pip3` or `python` instead of `python3`. The `3` is only used to avoid potential confusion with Python 2. Note that the `3` is only present in names of executables, not names of -# Python modules. -# -# ## Latest git revision -# -# This section shows how one can install the latest revision of selector from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, …) and so be prepared to accept them when using the following installation instructions. -# -# There are two installation methods: -# -# 1. **Quick and dirty.** Of this method, there are four variants, depending on the correctness of your `PATH` variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section. -# ``` -# # with env, correct PATH -# pip install git+https://github.com/theochem/Selector.git -# # with env, broken PATH -# python -m pip install git+https://github.com/theochem/Selector.git -# # without env, correct PATH -# pip install git+https://github.com/theochem/Selector.git --user -# # without env, broken PATH -# python -m pip install git+https://github.com/theochem/Selector.git --user -# ``` -# -# 2. **Slow and Smart.** In addition to the four variations in the quick and dirty method, the slow and smart can be used with `pip` or just with `setup.py`. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you. -# ``` -# # A) Clone git repo with https OR ssh: -# # The second one only works if you have ssh set up for Github -# # A1) https -# git clone https://github.com/theochem/Selector.git -# # A2) ssh -# git clone git@github.com:theochem/Selector.git -# # B) Optionally write the version string -# pip install roberto # or any of the three other ways of running pip, see above. -# rob write-version -# # C) Actual install, 6 different methods. -# # C1) setup.py, with env -# python setup.py install -# # C2) pip, with env, correct PATH -# pip install . -# # C3) pip, with env, broken PATH -# python -m pip install . -# # C4) setup.py, without env -# python setup.py install --user -# # C5) pip, without env, correct PATH -# pip install . --user -# # C6) pip, without env, broken PATH -# python -m pip install . --user -# ``` -# -# -# ## Testing -# -# The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation. -# -# With Ana- or Miniconda: -# ``` -# # Install pytest in your conda env. -# conda install pytest pytest-xdist -# # Then run the tests. -# pytest --pyargs selector -n auto -# ``` -# -# With Pip: -# ``` -# # Install pytest in your conda env ... -# pip install pytest pytest-xdist -# # .. and refresh the virtual environment. -# # This is a venv quirk. Without it, pytest may not find IOData. -# deactivate && source ~/selector/activate -# -# # Alternatively, install pytest in your home directory. -# pip install pytest pytest-xdist --user -# -# # Finally, run the tests. -# pytest --pyargs selector -n auto -# ``` diff --git a/book/content/_build/jupyter_execute/starting.ipynb b/book/content/_build/jupyter_execute/starting.ipynb deleted file mode 100644 index 495a3ee2..00000000 --- a/book/content/_build/jupyter_execute/starting.ipynb +++ /dev/null @@ -1,827 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "bc778cac", - "metadata": {}, - "source": [ - "# Getting started\n", - "## Demo - Dissimilarity Based Selection Synthetic Data" - ] - }, - { - "cell_type": "markdown", - "id": "073d04b2", - "metadata": {}, - "source": [ - "In this tutorial, we are going to show how the `QC-Selector` work with 2D synthetic data. Each axis represents one feature. For each example, we will have two different synthetic datasets where the first one can be seen as randomly generated data points and the latter generates data points belonging to different clusters. By using 2D feature data points, it makes visualization easy." - ] - }, - { - "cell_type": "markdown", - "id": "edfc38fb", - "metadata": {}, - "source": [ - "## Generating Synthetic Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "feb64be2", - "metadata": {}, - "outputs": [], - "source": [ - "# install the selector module\n", - "!pip install git+https://github.com/theochem/Selector\n", - "!pip install rdkit" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "6b21c8c6", - "metadata": {}, - "outputs": [], - "source": [ - "import selector\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from typing import Any, Tuple, Union\n", - "from sklearn.datasets import make_blobs\n", - "from sklearn.metrics import pairwise_distances\n", - "\n", - "def generate_synthetic_data(n_samples: int = 100,\n", - " n_features: int = 2,\n", - " n_clusters: int = 2,\n", - " cluster_std: float = 1.0,\n", - " center_box: Tuple[float, float] = (-10.0, 10.0),\n", - " metric: str = \"euclidean\",\n", - " shuffle: bool = True,\n", - " random_state: int = 42,\n", - " pairwise_dist: bool = False,\n", - " **kwargs: Any,\n", - " ) -> Union[Tuple[np.ndarray, np.ndarray],\n", - " Tuple[np.ndarray, np.ndarray, np.ndarray]]:\n", - " \"\"\"Generate synthetic data.\n", - "\n", - " Parameters\n", - " ----------\n", - " n_samples : int, optional\n", - " The number of samples. Default=100.\n", - " n_features : int, optional\n", - " The number of features. Default=2.\n", - " n_clusters : int, optional\n", - " The number of clusters. Default=2.\n", - " cluster_std : float, optional\n", - " The standard deviation of the clusters. Default=1.0.\n", - " center_box : tuple[float, float], optional\n", - " The bounding box for each cluster center when centers are generated at random.\n", - " Default=(-10.0, 10.0).\n", - " metric : str, optional\n", - " The metric used for computing pairwise distances. For the supported\n", - " distance matrix, please refer to\n", - " https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html.\n", - " Default=\"euclidean\".\n", - " shuffle : bool, optional\n", - " Whether to shuffle the samples. Default=True.\n", - " random_state : int, optional\n", - " The random state used for generating synthetic data. Default=42.\n", - " pairwise_dist : bool, optional\n", - " If True, then compute and return the pairwise distances between samples. Default=False.\n", - " **kwargs : Any, optional\n", - " Additional keyword arguments for the scikit-learn `pairwise_distances` function.\n", - "\n", - " Returns\n", - " -------\n", - " syn_data : np.ndarray\n", - " The synthetic data.\n", - " class_labels : np.ndarray\n", - " The integer labels for cluster membership of each sample.\n", - " dist: np.ndarray\n", - " The symmetric pairwise distances between samples.\n", - "\n", - " \"\"\"\n", - " # pylint: disable=W0632\n", - " syn_data, class_labels = make_blobs(n_samples=n_samples,\n", - " n_features=n_features,\n", - " centers=n_clusters,\n", - " cluster_std=cluster_std,\n", - " center_box=center_box,\n", - " shuffle=shuffle,\n", - " random_state=random_state,\n", - " return_centers=False,\n", - " )\n", - " if pairwise_dist:\n", - " dist = pairwise_distances(X=syn_data,\n", - " Y=None,\n", - " metric=metric,\n", - " **kwargs,\n", - " )\n", - " return syn_data, class_labels, dist\n", - " else:\n", - " return syn_data, class_labels" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "12c42ad7", - "metadata": {}, - "outputs": [], - "source": [ - "coords, class_labels, arr_dist = generate_synthetic_data(n_samples=100,\n", - " n_features=2,\n", - " n_clusters=1,\n", - " pairwise_dist=True,\n", - " metric=\"euclidean\",\n", - " random_state=42)\n", - "\n", - "coords_cluster, class_labels_cluster, arr_dist_cluster = generate_synthetic_data(n_samples=100,\n", - " n_features=2,\n", - " n_clusters=3,\n", - " pairwise_dist=True,\n", - " metric=\"euclidean\",\n", - " random_state=42)\n", - "def graph_data(coords, selected=None, reference=False):\n", - " plt.figure(dpi=150)\n", - " plt.scatter(coords[:, 0], coords[:, 1])\n", - " if selected:\n", - " for i, mol_id in enumerate(selected):\n", - " plt.scatter(coords[mol_id, 0], coords[mol_id, 1], c='r')\n", - " plt.text(coords[mol_id,0], coords[mol_id,1], str(i+1))\n", - " if reference:\n", - " plt.scatter(coords[0, 0], coords[0, 1], c='black')\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0ae728a4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_6_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_6_1.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(coords)\n", - "graph_data(coords_cluster)" - ] - }, - { - "cell_type": "markdown", - "id": "ff524176", - "metadata": {}, - "source": [ - "## Running Dissimilarity Algorithms" - ] - }, - { - "cell_type": "markdown", - "id": "38c88220", - "metadata": {}, - "source": [ - "### Brute Strength - MaxMin" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "27e5864f", - "metadata": {}, - "outputs": [], - "source": [ - "# MaxMin method\n", - "from selector.methods.partition import *\n", - "from selector.methods.dissimilarity import *\n", - "\n", - "# diverse subset selection from randomly generated data points\n", - "selector = MaxMin()\n", - "selected_ids1 = selector.select(arr=arr_dist, size=12)\n", - "\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selector = MaxMin()\n", - "selected_ids2 = selector.select(arr=arr_dist_cluster, labels=class_labels_cluster, size=12)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "76e8e320", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_10_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_10_1.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(coords,selected_ids1)\n", - "graph_data(coords_cluster,selected_ids2)" - ] - }, - { - "cell_type": "markdown", - "id": "0fb215f3", - "metadata": {}, - "source": [ - "### Adapted Optimizable K-Dissimilarity Selection (OptiSim)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "aaac7176", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_12_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_12_1.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# diverse subset selection from randomly generated data points\n", - "selected_id3 = OptiSim().select(coords, 12)\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selected_id4 = OptiSim().select(coords_cluster, size=12, labels=class_labels_cluster)\n", - "\n", - "graph_data(coords,selected_id3)\n", - "graph_data(coords_cluster,selected_id4)" - ] - }, - { - "cell_type": "markdown", - "id": "3dddc3d6", - "metadata": {}, - "source": [ - "### Directed Sphere Exclusion" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "3cfc8fbf", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_14_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_14_1.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# diverse subset selection from randomly generated data points\n", - "selected_id5 = DirectedSphereExclusion().select(coords, 12)\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selected_id6 = DirectedSphereExclusion().select(coords_cluster, size=12, labels=class_labels_cluster)\n", - "\n", - "graph_data(coords,selected_id5)\n", - "graph_data(coords_cluster,selected_id6)" - ] - }, - { - "cell_type": "markdown", - "id": "abfa0f31", - "metadata": {}, - "source": [ - "### Grid Partitioning Method" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "c9927492", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_16_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_16_1.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# diverse subset selection from randomly generated data points\n", - "selected_id7 = GridPartitioning(2, \"equisized_independent\").select(coords, 12)\n", - "# diverse subset selection from data points with obvious patterns (different clusters)\n", - "selected_id8 = GridPartitioning(2, \"equisized_independent\").select(coords_cluster, \n", - " size=12, \n", - " labels=class_labels_cluster)\n", - "\n", - "graph_data(coords,selected_id7)\n", - "graph_data(coords_cluster,selected_id8)\n", - "# 20, 5, 3, \"equisized_independent\"" - ] - }, - { - "cell_type": "markdown", - "id": "9e67816c", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## MinMax selection with clusters, but without assuming there are clusters" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e79d09a6", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_18_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "selector = MaxMin()\n", - "selected_ids = selector.select(arr=arr_dist_cluster, size=15)\n", - "graph_data(coords_cluster, selected_ids)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "9d5ab489", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_19_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 10, 11, 9, 13]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "from sklearn.metrics import pairwise_distances\n", - "np.random.seed(42)\n", - "cluster_one = np.random.normal(0, 1, (3,2))\n", - "cluster_two = np.random.normal(10, 1, (6,2))\n", - "cluster_three = np.random.normal(20, 1, (7,2))\n", - "labels_mocked = np.hstack([[0 for i in range(3)],\n", - " [1 for i in range(6)],\n", - " [2 for i in range(7)]])\n", - "\n", - "mocked_cluster_coords = np.vstack([cluster_one, cluster_two, cluster_three])\n", - "selector = MaxMin(lambda x: pairwise_distances(x, metric='euclidean'))\n", - "selected_mocked = selector.select(mocked_cluster_coords, size=15, labels=labels_mocked)\n", - "\n", - "graph_data(mocked_cluster_coords, selected_mocked)\n", - "\n", - "selected_mocked" - ] - }, - { - "cell_type": "markdown", - "id": "b230dd49", - "metadata": {}, - "source": [ - "### Brute Strength - maxsum" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3b4efad5", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " arr_dist=arr_dist,\n", - " random_seed=42,\n", - " method=\"maxsum\")\n", - "selector.starting_idx = 0\n", - "selected_ids2 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "c393e1ed", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_22_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids2)" - ] - }, - { - "cell_type": "markdown", - "id": "07a66848", - "metadata": {}, - "source": [ - "### Grid Partitioning - Equisized Independent" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "10c2afd0", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(features=coords,\n", - " num_selected=12,\n", - " arr_dist=arr_dist,\n", - " grid_method=\"grid_partioning\",\n", - " random_seed=42)\n", - "selector.starting_idx = 0\n", - "selected_ids3 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "d910c193", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_25_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids3)" - ] - }, - { - "cell_type": "markdown", - "id": "30157fdb", - "metadata": {}, - "source": [ - "### Grid Partitioning - Equisized Dependent" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "df78a5e9", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " features = coords,\n", - " random_seed=42,\n", - " dissim_func=\"grid_partitioning\",\n", - " grid_method=\"equisized_dependent\")\n", - "selector.starting_idx = 0\n", - "selected_ids4 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "69c111e4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_28_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids4)" - ] - }, - { - "cell_type": "markdown", - "id": "bbae7222", - "metadata": {}, - "source": [ - "### Directed Sphere Exclusion" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "a6f80d02", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " features=coords,\n", - " dissim_func=\"sphere_exclusion\",\n", - " random_seed=42)\n", - "selector.starting_idx = 0\n", - "selected_ids5 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "70060bc3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_31_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids5, True)" - ] - }, - { - "cell_type": "markdown", - "id": "cf8b3965", - "metadata": {}, - "source": [ - "### Optisim" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "735df074", - "metadata": {}, - "outputs": [], - "source": [ - "selector = DissimilaritySelection(num_selected=12,\n", - " features=coords,\n", - " dissim_func=\"optisim\",\n", - " random_seed=42)\n", - "selector.starting_idx = 0\n", - "selected_ids6 = selector.select()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "363b36d1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "filenames": { - "image/png": "/Users/valeriichuiko/Desktop/projects/selector/book/content/_build/jupyter_execute/starting_34_0.png" - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "graph_data(selected_ids6)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/book/content/_build/jupyter_execute/starting.py b/book/content/_build/jupyter_execute/starting.py deleted file mode 100644 index cbfc3b2f..00000000 --- a/book/content/_build/jupyter_execute/starting.py +++ /dev/null @@ -1,340 +0,0 @@ -#!/usr/bin/env python - -# # Getting started -# ## Demo - Dissimilarity Based Selection Synthetic Data - -# In this tutorial, we are going to show how the `QC-Selector` work with 2D synthetic data. Each axis represents one feature. For each example, we will have two different synthetic datasets where the first one can be seen as randomly generated data points and the latter generates data points belonging to different clusters. By using 2D feature data points, it makes visualization easy. - -# ## Generating Synthetic Data - -# In[ ]: - - -# install the selector module -from selector.methods.dissimilarity import * -from selector.methods.partition import * -from sklearn.metrics import pairwise_distances -from sklearn.datasets import make_blobs -from typing import Any, Tuple, Union -import numpy as np -import matplotlib.pyplot as plt -import selector - -get_ipython().system("pip install git+https://github.com/theochem/Selector") -get_ipython().system("pip install rdkit") - - -# In[1]: - - -def generate_synthetic_data( - n_samples: int = 100, - n_features: int = 2, - n_clusters: int = 2, - cluster_std: float = 1.0, - center_box: Tuple[float, float] = (-10.0, 10.0), - metric: str = "euclidean", - shuffle: bool = True, - random_state: int = 42, - pairwise_dist: bool = False, - **kwargs: Any, -) -> Union[Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray, np.ndarray]]: - """Generate synthetic data. - - Parameters - ---------- - n_samples : int, optional - The number of samples. Default=100. - n_features : int, optional - The number of features. Default=2. - n_clusters : int, optional - The number of clusters. Default=2. - cluster_std : float, optional - The standard deviation of the clusters. Default=1.0. - center_box : tuple[float, float], optional - The bounding box for each cluster center when centers are generated at random. - Default=(-10.0, 10.0). - metric : str, optional - The metric used for computing pairwise distances. For the supported - distance matrix, please refer to - https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html. - Default="euclidean". - shuffle : bool, optional - Whether to shuffle the samples. Default=True. - random_state : int, optional - The random state used for generating synthetic data. Default=42. - pairwise_dist : bool, optional - If True, then compute and return the pairwise distances between samples. Default=False. - **kwargs : Any, optional - Additional keyword arguments for the scikit-learn `pairwise_distances` function. - - Returns - ------- - syn_data : np.ndarray - The synthetic data. - class_labels : np.ndarray - The integer labels for cluster membership of each sample. - dist: np.ndarray - The symmetric pairwise distances between samples. - - """ - # pylint: disable=W0632 - syn_data, class_labels = make_blobs( - n_samples=n_samples, - n_features=n_features, - centers=n_clusters, - cluster_std=cluster_std, - center_box=center_box, - shuffle=shuffle, - random_state=random_state, - return_centers=False, - ) - if pairwise_dist: - dist = pairwise_distances( - X=syn_data, - Y=None, - metric=metric, - **kwargs, - ) - return syn_data, class_labels, dist - else: - return syn_data, class_labels - - -# In[2]: - - -coords, class_labels, arr_dist = generate_synthetic_data( - n_samples=100, - n_features=2, - n_clusters=1, - pairwise_dist=True, - metric="euclidean", - random_state=42, -) - -coords_cluster, class_labels_cluster, arr_dist_cluster = generate_synthetic_data( - n_samples=100, - n_features=2, - n_clusters=3, - pairwise_dist=True, - metric="euclidean", - random_state=42, -) - - -def graph_data(coords, selected=None, reference=False): - plt.figure(dpi=150) - plt.scatter(coords[:, 0], coords[:, 1]) - if selected: - for i, mol_id in enumerate(selected): - plt.scatter(coords[mol_id, 0], coords[mol_id, 1], c="r") - plt.text(coords[mol_id, 0], coords[mol_id, 1], str(i + 1)) - if reference: - plt.scatter(coords[0, 0], coords[0, 1], c="black") - plt.show() - - -# In[3]: - - -graph_data(coords) -graph_data(coords_cluster) - - -# ## Running Dissimilarity Algorithms - -# ### Brute Strength - MaxMin - -# In[8]: - - -# MaxMin method - -# diverse subset selection from randomly generated data points -selector = MaxMin() -selected_ids1 = selector.select(arr=arr_dist, size=12) - -# diverse subset selection from data points with obvious patterns (different clusters) -selector = MaxMin() -selected_ids2 = selector.select(arr=arr_dist_cluster, labels=class_labels_cluster, size=12) - - -# In[9]: - - -graph_data(coords, selected_ids1) -graph_data(coords_cluster, selected_ids2) - - -# ### Adapted Optimizable K-Dissimilarity Selection (OptiSim) - -# In[12]: - - -# diverse subset selection from randomly generated data points -selected_id3 = OptiSim().select(coords, 12) -# diverse subset selection from data points with obvious patterns (different clusters) -selected_id4 = OptiSim().select(coords_cluster, size=12, labels=class_labels_cluster) - -graph_data(coords, selected_id3) -graph_data(coords_cluster, selected_id4) - - -# ### Directed Sphere Exclusion - -# In[13]: - - -# diverse subset selection from randomly generated data points -selected_id5 = DirectedSphereExclusion().select(coords, 12) -# diverse subset selection from data points with obvious patterns (different clusters) -selected_id6 = DirectedSphereExclusion().select( - coords_cluster, size=12, labels=class_labels_cluster -) - -graph_data(coords, selected_id5) -graph_data(coords_cluster, selected_id6) - - -# ### Grid Partitioning Method - -# In[15]: - - -# diverse subset selection from randomly generated data points -selected_id7 = GridPartitioning(2, "equisized_independent").select(coords, 12) -# diverse subset selection from data points with obvious patterns (different clusters) -selected_id8 = GridPartitioning(2, "equisized_independent").select( - coords_cluster, size=12, labels=class_labels_cluster -) - -graph_data(coords, selected_id7) -graph_data(coords_cluster, selected_id8) -# 20, 5, 3, "equisized_independent" - - -# ## MinMax selection with clusters, but without assuming there are clusters - -# In[16]: - - -selector = MaxMin() -selected_ids = selector.select(arr=arr_dist_cluster, size=15) -graph_data(coords_cluster, selected_ids) - - -# In[12]: - - -np.random.seed(42) -cluster_one = np.random.normal(0, 1, (3, 2)) -cluster_two = np.random.normal(10, 1, (6, 2)) -cluster_three = np.random.normal(20, 1, (7, 2)) -labels_mocked = np.hstack([[0 for i in range(3)], [1 for i in range(6)], [2 for i in range(7)]]) - -mocked_cluster_coords = np.vstack([cluster_one, cluster_two, cluster_three]) -selector = MaxMin(lambda x: pairwise_distances(x, metric="euclidean")) -selected_mocked = selector.select(mocked_cluster_coords, size=15, labels=labels_mocked) - -graph_data(mocked_cluster_coords, selected_mocked) - -selected_mocked - - -# ### Brute Strength - maxsum - -# In[6]: - - -selector = DissimilaritySelection( - num_selected=12, arr_dist=arr_dist, random_seed=42, method="maxsum" -) -selector.starting_idx = 0 -selected_ids2 = selector.select() - - -# In[7]: - - -graph_data(selected_ids2) - - -# ### Grid Partitioning - Equisized Independent - -# In[8]: - - -selector = DissimilaritySelection( - features=coords, - num_selected=12, - arr_dist=arr_dist, - grid_method="grid_partioning", - random_seed=42, -) -selector.starting_idx = 0 -selected_ids3 = selector.select() - - -# In[9]: - - -graph_data(selected_ids3) - - -# ### Grid Partitioning - Equisized Dependent - -# In[10]: - - -selector = DissimilaritySelection( - num_selected=12, - features=coords, - random_seed=42, - dissim_func="grid_partitioning", - grid_method="equisized_dependent", -) -selector.starting_idx = 0 -selected_ids4 = selector.select() - - -# In[11]: - - -graph_data(selected_ids4) - - -# ### Directed Sphere Exclusion - -# In[12]: - - -selector = DissimilaritySelection( - num_selected=12, features=coords, dissim_func="sphere_exclusion", random_seed=42 -) -selector.starting_idx = 0 -selected_ids5 = selector.select() - - -# In[13]: - - -graph_data(selected_ids5, True) - - -# ### Optisim - -# In[14]: - - -selector = DissimilaritySelection( - num_selected=12, features=coords, dissim_func="optisim", random_seed=42 -) -selector.starting_idx = 0 -selected_ids6 = selector.select() - - -# In[15]: - - -graph_data(selected_ids6) diff --git a/book/content/_build/jupyter_execute/starting_10_0.png b/book/content/_build/jupyter_execute/starting_10_0.png deleted file mode 100644 index 8ab8c1c3..00000000 Binary files a/book/content/_build/jupyter_execute/starting_10_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_10_1.png b/book/content/_build/jupyter_execute/starting_10_1.png deleted file mode 100644 index abe312fa..00000000 Binary files a/book/content/_build/jupyter_execute/starting_10_1.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_12_0.png b/book/content/_build/jupyter_execute/starting_12_0.png deleted file mode 100644 index d5712e97..00000000 Binary files a/book/content/_build/jupyter_execute/starting_12_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_12_1.png b/book/content/_build/jupyter_execute/starting_12_1.png deleted file mode 100644 index a483a143..00000000 Binary files a/book/content/_build/jupyter_execute/starting_12_1.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_14_0.png b/book/content/_build/jupyter_execute/starting_14_0.png deleted file mode 100644 index 833413f8..00000000 Binary files a/book/content/_build/jupyter_execute/starting_14_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_14_1.png b/book/content/_build/jupyter_execute/starting_14_1.png deleted file mode 100644 index 7ad6fe4b..00000000 Binary files a/book/content/_build/jupyter_execute/starting_14_1.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_16_0.png b/book/content/_build/jupyter_execute/starting_16_0.png deleted file mode 100644 index d3e63fc6..00000000 Binary files a/book/content/_build/jupyter_execute/starting_16_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_16_1.png b/book/content/_build/jupyter_execute/starting_16_1.png deleted file mode 100644 index 733c0ce6..00000000 Binary files a/book/content/_build/jupyter_execute/starting_16_1.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_18_0.png b/book/content/_build/jupyter_execute/starting_18_0.png deleted file mode 100644 index d19cdc00..00000000 Binary files a/book/content/_build/jupyter_execute/starting_18_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_19_0.png b/book/content/_build/jupyter_execute/starting_19_0.png deleted file mode 100644 index f8688f21..00000000 Binary files a/book/content/_build/jupyter_execute/starting_19_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_22_0.png b/book/content/_build/jupyter_execute/starting_22_0.png deleted file mode 100644 index 26f5fb5a..00000000 Binary files a/book/content/_build/jupyter_execute/starting_22_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_25_0.png b/book/content/_build/jupyter_execute/starting_25_0.png deleted file mode 100644 index 26f5fb5a..00000000 Binary files a/book/content/_build/jupyter_execute/starting_25_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_28_0.png b/book/content/_build/jupyter_execute/starting_28_0.png deleted file mode 100644 index 145e218f..00000000 Binary files a/book/content/_build/jupyter_execute/starting_28_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_31_0.png b/book/content/_build/jupyter_execute/starting_31_0.png deleted file mode 100644 index ea3944fd..00000000 Binary files a/book/content/_build/jupyter_execute/starting_31_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_34_0.png b/book/content/_build/jupyter_execute/starting_34_0.png deleted file mode 100644 index ffe80ceb..00000000 Binary files a/book/content/_build/jupyter_execute/starting_34_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_6_0.png b/book/content/_build/jupyter_execute/starting_6_0.png deleted file mode 100644 index cbc67e93..00000000 Binary files a/book/content/_build/jupyter_execute/starting_6_0.png and /dev/null differ diff --git a/book/content/_build/jupyter_execute/starting_6_1.png b/book/content/_build/jupyter_execute/starting_6_1.png deleted file mode 100644 index 86407139..00000000 Binary files a/book/content/_build/jupyter_execute/starting_6_1.png and /dev/null differ diff --git a/book/content/_config.yml b/book/content/_config.yml index e3de6dda..5f8c4cfa 100644 --- a/book/content/_config.yml +++ b/book/content/_config.yml @@ -56,7 +56,7 @@ launch_buttons: thebe : true colab_url: "https://colab.research.google.com" -copyright: "2022-2023" +copyright: "2022-2024" html: use_issues_button: true diff --git a/book/content/_toc.yml b/book/content/_toc.yml index 3668a34a..106e208d 100644 --- a/book/content/_toc.yml +++ b/book/content/_toc.yml @@ -2,15 +2,22 @@ # Learn more at https://jupyterbook.org/customize/toc.html format: jb-book -root: intro +root: intro.md parts: - - caption: Quick Start + - caption: Tutorial chapters: - - file: installation.ipynb - - file: starting.ipynb + - file: installation.md + - file: tutorial_distance_based.ipynb + - file: tutorial_partition_based.ipynb + - file: tutorial_diversity_measures.ipynb + - file: tutorial_similarity_based.ipynb - caption: API chapters: - - file: base.rst - - file: dissimilarity.rst - - file: partition.rst - - file: utils.rst + - file: api_methods_base.rst + - file: api_methods_distance.rst + - file: api_methods_partition.rst + - file: api_methods_similarity.rst + - file: api_methods_utils.rst + - file: api_measures_converter.rst + - file: api_measures_diversity.rst + - file: api_measures_similarity.rst diff --git a/book/content/api_measures.rst b/book/content/api_measures.rst deleted file mode 100644 index ed0fc4be..00000000 --- a/book/content/api_measures.rst +++ /dev/null @@ -1,4 +0,0 @@ -Distance based methods -====================== -.. automodule:: selector.distance - :members: diff --git a/book/content/api_measures_converter.rst b/book/content/api_measures_converter.rst new file mode 100644 index 00000000..0a4422aa --- /dev/null +++ b/book/content/api_measures_converter.rst @@ -0,0 +1,10 @@ +.. _measures.converter: + +:mod:`selector.measures.converter` +================================== + +.. automodule:: selector.measures.converter + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_measures_diversity.rst b/book/content/api_measures_diversity.rst new file mode 100644 index 00000000..1e85f9c4 --- /dev/null +++ b/book/content/api_measures_diversity.rst @@ -0,0 +1,10 @@ +.. _measures.diversity: + +:mod:`selector.measures.diversity` +================================== + +.. automodule:: selector.measures.diversity + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_measures_similarity.rst b/book/content/api_measures_similarity.rst new file mode 100644 index 00000000..b08561ef --- /dev/null +++ b/book/content/api_measures_similarity.rst @@ -0,0 +1,10 @@ +.. _measures.similarity: + +:mod:`selector.measures.similarity` +================================== + +.. automodule:: selector.measures.similarity + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_methods.rst b/book/content/api_methods.rst deleted file mode 100644 index 389a914f..00000000 --- a/book/content/api_methods.rst +++ /dev/null @@ -1,4 +0,0 @@ -Base class -========== -.. automodule:: selector.methods.base - :members: diff --git a/book/content/api_methods_base.rst b/book/content/api_methods_base.rst new file mode 100644 index 00000000..0a31a391 --- /dev/null +++ b/book/content/api_methods_base.rst @@ -0,0 +1,10 @@ +.. _methods.base: + +:mod:`selector.methods.base` +============================ + +.. automodule:: selector.methods.base + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_methods_distance.rst b/book/content/api_methods_distance.rst new file mode 100644 index 00000000..514c78c1 --- /dev/null +++ b/book/content/api_methods_distance.rst @@ -0,0 +1,10 @@ +.. _methods.distance: + +:mod:`selector.methods.distance` +================================ + +.. automodule:: selector.methods.distance + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_methods_partition.rst b/book/content/api_methods_partition.rst new file mode 100644 index 00000000..dd94544e --- /dev/null +++ b/book/content/api_methods_partition.rst @@ -0,0 +1,10 @@ +.. _methods.partition: + +:mod:`selector.methods.partition` +================================= + +.. automodule:: selector.methods.partition + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_methods_similarity.rst b/book/content/api_methods_similarity.rst new file mode 100644 index 00000000..19ad23cd --- /dev/null +++ b/book/content/api_methods_similarity.rst @@ -0,0 +1,10 @@ +.. _methods.similarity: + +:mod:`selector.methods.similarity` +================================== + +.. automodule:: selector.methods.similarity + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/api_methods_utils.rst b/book/content/api_methods_utils.rst new file mode 100644 index 00000000..ad1d5391 --- /dev/null +++ b/book/content/api_methods_utils.rst @@ -0,0 +1,10 @@ +.. _methods.utils: + +:mod:`selector.methods.utils` +============================ + +.. automodule:: selector.methods.utils + :members: + :undoc-members: + :inherited-members: + :private-members: diff --git a/book/content/installation.ipynb b/book/content/installation.ipynb deleted file mode 100644 index 551288dc..00000000 --- a/book/content/installation.ipynb +++ /dev/null @@ -1,202 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f1be9e2f", - "metadata": {}, - "source": [ - "# Installation\n", - "\n", - "## Stable Releases\n", - "\n", - "
\n", - "Warning:\n", - "\n", - " \n", - "We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the “Latest Git Revision” section below.\n", - "
\n", - "\n", - "The following dependencies are required to run selector properly,\n", - "\n", - "* Python >= 3.6: http://www.python.org/ \n", - "* NumPy >= 1.21.5: http://www.numpy.org/\n", - "* SciPy >= 1.5.0: http://www.scipy.org/\n", - "* PyTest >= 5.3.4: https://docs.pytest.org/\n", - "* PyTest-Cov >= 2.8.0: https://pypi.org/project/pytest-cov\n", - "\n", - "Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below.\n", - "\n", - "\n", - "## Installation with Anaconda or Miniconda:\n", - "\n", - "1. To install selector using the conda package management system, install [miniconda](https://conda.io/miniconda.html) or [anaconda](https://www.anaconda.com/download) first, and then:\n", - "\n", - "```\n", - "# Activate your main conda environment if it is not loaded in your .bashrc.\n", - "# E.g. run the following if you have miniconda installed in e.g. ~/miniconda3\n", - "source ~/miniconda3/bin/activate\n", - "\n", - "# Create a horton3 conda environment. (optional, recommended)\n", - "conda create -n horton3\n", - "source activate horton3\n", - "\n", - "# Install the stable release.\n", - "conda install -c theochem qc-selector\n", - "\n", - "# Unstable releases\n", - "# (Only do this if you understand the implications.)\n", - "# Install the testing release. (beta)\n", - "conda install -c theochem/label/test qc-selector\n", - "# Install the development release. (alpha)\n", - "conda install -c theochem/label/dev qc-selector\n", - "```\n", - "\n", - "Please note, it is also possible to install use [`mamba`](https://mamba.readthedocs.io/en/latest/#) instead of `conda` for faster Python package environment management.\n", - "\n", - "## Installation with `pip`\n", - "\n", - "1. You can work in a [virtual environment](https://docs.python.org/3/tutorial/venv.html):\n", - "\n", - "```\n", - "# Create a virtual environment in ~/horton3\n", - "# Feel free to change the path.\n", - "python3 -m venv ~/horton3\n", - "\n", - "# Activate the virtual environemnt.\n", - "source ~/horton3/bin/activate\n", - "\n", - "# Install the stable release in the venv horton3.\n", - "pip3 install qc-selector\n", - "# alternative: python3 -m pip install qc-selector\n", - "\n", - "# For developers, install a pre-release (alpha or beta).\n", - "# (Only do this if you understand the implications.)\n", - "pip3 install --pre qc-selector\n", - "# alternative: python3 -m pip install --pre qc-selector\n", - "```\n", - "\n", - "\n", - "2. You can install into your `{$HOME}` directory without creating a virtual environment\n", - "\n", - "```\n", - "# Install the stable release in your home directory.\n", - "pip3 install qc-selector --user\n", - "# alternative: python3 -m pip install qc-selector --user\n", - "\n", - "# For developers, install a pre-release (alpha or beta).\n", - "# (Only do this if you understand the implications.)\n", - "pip3 install --pre qc-selector --user\n", - "# alternative: python3 -m pip install --pre qc-selector --user\n", - "```\n", - "\n", - "This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options.\n", - " \n", - "In case the `pip3` executable is not found, pip may be installed in a directory which is not included in your `${PATH}` variable. This seems to be a common issue on macOS. A simple workaround is to replace `pip3` by `python3 -m pip`.\n", - "\n", - "In case Python and your operating system are up to date, you may also use `pip` instead of `pip3` or `python` instead of `python3`. The `3` is only used to avoid potential confusion with Python 2. Note that the `3` is only present in names of executables, not names of \n", - "Python modules.\n", - "\n", - "## Latest git revision\n", - "\n", - "This section shows how one can install the latest revision of `selector` from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, …) and so be prepared to accept them when using the following installation instructions.\n", - "\n", - "There are two installation methods:\n", - "\n", - "1. **Quick and dirty.** Of this method, there are four variants, depending on the correctness of your `PATH` variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section.\n", - "```\n", - "# with env, correct PATH\n", - "pip install git+https://github.com/theochem/Selector.git\n", - "# with env, broken PATH\n", - "python -m pip install git+https://github.com/theochem/Selector.git\n", - "# without env, correct PATH\n", - "pip install git+https://github.com/theochem/Selector.git --user\n", - "# without env, broken PATH\n", - "python -m pip install git+https://github.com/theochem/Selector.git --user\n", - "```\n", - "\n", - "2. **Slow and Smart.** In addition to the four variations in the quick and dirty method, the slow and smart can be used with `pip` or just with `setup.py`. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you.\n", - "```\n", - "# A) Clone git repo with https OR ssh:\n", - "# The second one only works if you have ssh set up for Github\n", - "# A1) https\n", - "git clone https://github.com/theochem/Selector.git\n", - "# A2) ssh\n", - "git clone git@github.com:theochem/Selector.git\n", - "# B) Optionally write the version string\n", - "pip install roberto # or any of the three other ways of running pip, see above.\n", - "rob write-version\n", - "# C) Actual install, 6 different methods.\n", - "# C1) setup.py, with env\n", - "python setup.py install\n", - "# C2) pip, with env, correct PATH\n", - "pip install .\n", - "# C3) pip, with env, broken PATH\n", - "python -m pip install .\n", - "# C4) setup.py, without env\n", - "python setup.py install --user\n", - "# C5) pip, without env, correct PATH\n", - "pip install . --user\n", - "# C6) pip, without env, broken PATH\n", - "python -m pip install . --user\n", - "```\n", - "\n", - "\n", - "## Testing\n", - "\n", - "The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation.\n", - "\n", - "With Ana- or Miniconda:\n", - "```\n", - "# Install pytest in your conda env.\n", - "conda install pytest pytest-xdist\n", - "# Then run the tests.\n", - "pytest --pyargs selector -n auto\n", - "```\n", - "\n", - "With Pip:\n", - "```\n", - "# Install pytest in your conda env ...\n", - "pip install pytest pytest-xdist\n", - "# .. and refresh the virtual environment.\n", - "# This is a venv quirk. Without it, pytest may not find IOData.\n", - "deactivate && source ~/selector/activate\n", - "\n", - "# Alternatively, install pytest in your home directory.\n", - "pip install pytest pytest-xdist --user\n", - "\n", - "# Finally, run the tests.\n", - "pytest --pyargs selector -n auto\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b52d35f6-a533-440f-b053-42d9bfbb99db", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/book/content/installation.md b/book/content/installation.md new file mode 100644 index 00000000..889896be --- /dev/null +++ b/book/content/installation.md @@ -0,0 +1,58 @@ +# Installation + +## Stable Releases + +
+Warning: + +We are preparing a 1.0 release. Until then, we can install the beta relase with PyPI, +https://pypi.org/project/qc-selector/. +
+ +The following dependencies are required to run selector properly, + +* Python >= 3.9: http://www.python.org/ +* NumPy >= 1.21.2: http://www.numpy.org/ +* SciPy >= 1.11.1: http://www.scipy.org/ +* bitarray >= 2.5.1: https://pypi.org/project/bitarray/ + +Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below. + +It is recommended to install `selector` within a virtual environment. To create a virtual +environment, we can use the `venv` module (Python 3.3+, +https://docs.python.org/3/tutorial/venv.html), `miniconda` (https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html), or +`pipenv` (https://pipenv.pypa.io/en/latest/). We use `miniconda` in the following example to create a virtual environment: + +```bash + # Create and activate qcdevs conda environment (optional, but recommended) + conda create -n qcdevs python=3.11 + conda activate qcdevs + +``` + +To install `selector` with `pip`, we can install the latest stable release from the Python Package Index (PyPI) as follows: + +```bash + # Install the stable release. + pip install qc-selector +``` + +## Prebuilt Wheels + +To download the prebuilt wheel files, visit the [PyPI page](https://pypi.org/project/qc-selector/) +and [GitHub Releases](https://github.com/theochem/Selector/releases). + +```bash + # install the prebuilt wheel file + pip install qc_selector-0.0.2b10-py3-none-any.whl +``` + +## Development Version + +In addition, we can install the latest development version from the GitHub repository as follows: + +```bash + # install the latest development version + pip install git+https://github.com/theochem/Selector.git + +```