From 48e011a33cbba295511442044620e39166bc2346 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 3 Sep 2024 16:41:31 +0000 Subject: [PATCH] Deploy dev from f933989 --- dev/.buildinfo | 4 - .../jacobian.ipynb | 72 ++++---- .../overview.ipynb | 42 ++--- .../how-to-use.ipynb | 136 +++++++------- dev/_images/how-to-use_5_0.png | Bin 15946 -> 15946 bytes dev/_images/how-to-use_6_0.png | Bin 15946 -> 15946 bytes dev/_images/how-to-use_9_0.png | Bin 15946 -> 15946 bytes dev/_modules/choclo/dipole/_forward.html | 99 +++++----- dev/_modules/choclo/point/_forward.html | 85 ++++----- dev/_modules/choclo/point/_kernels.html | 85 ++++----- dev/_modules/choclo/prism/_gravity.html | 105 +++++------ dev/_modules/choclo/prism/_kernels.html | 86 ++++----- dev/_modules/choclo/prism/_magnetic.html | 116 ++++++------ dev/_modules/choclo/utils.html | 85 ++++----- dev/_modules/index.html | 85 ++++----- .../locales/ar/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/bg/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/bn/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/ca/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/cs/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/da/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/de/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/el/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/eo/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/es/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/et/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/fi/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/fr/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/hr/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/id/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/it/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/iw/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ja/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ko/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/lt/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/lv/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ml/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/mr/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/ms/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/nl/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/no/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/pl/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/pt/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ro/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ru/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/sk/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/sl/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/sr/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/sv/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ta/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/te/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/tg/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/th/LC_MESSAGES/booktheme.po | 60 +++---- .../locales/tl/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/tr/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/uk/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/ur/LC_MESSAGES/booktheme.po | 54 +++--- .../locales/vi/LC_MESSAGES/booktheme.po | 64 +++---- .../locales/zh_CN/LC_MESSAGES/booktheme.po | 60 +++---- .../locales/zh_TW/LC_MESSAGES/booktheme.po | 64 +++---- dev/_static/pygments.css | 138 +++++++------- dev/_static/scripts/bootstrap.js | 2 +- dev/_static/scripts/bootstrap.js.LICENSE.txt | 4 +- dev/_static/scripts/bootstrap.js.map | 2 +- dev/_static/scripts/pydata-sphinx-theme.js | 2 +- .../scripts/pydata-sphinx-theme.js.map | 2 +- dev/_static/scripts/sphinx-book-theme.js | 2 +- dev/_static/scripts/sphinx-book-theme.js.map | 2 +- dev/_static/styles/bootstrap.css | 6 +- dev/_static/styles/bootstrap.css.map | 2 +- dev/_static/styles/pydata-sphinx-theme.css | 2 +- .../styles/pydata-sphinx-theme.css.map | 2 +- dev/_static/styles/sphinx-book-theme.css | 3 +- dev/_static/styles/sphinx-book-theme.css.map | 1 + .../vendor/fontawesome/6.5.1/css/all.min.css | 5 - .../vendor/fontawesome/6.5.1/js/all.min.js | 2 - .../6.5.1/webfonts/fa-brands-400.woff2 | Bin 117372 -> 0 bytes .../6.5.1/webfonts/fa-regular-400.woff2 | Bin 25452 -> 0 bytes .../6.5.1/webfonts/fa-solid-900.woff2 | Bin 156496 -> 0 bytes .../6.5.1/webfonts/fa-v4compatibility.woff2 | Bin 4792 -> 0 bytes .../fontawesome/{6.5.1 => 6.5.2}/LICENSE.txt | 4 +- .../vendor/fontawesome/6.5.2/css/all.min.css | 5 + .../vendor/fontawesome/6.5.2/js/all.min.js | 2 + .../js/all.min.js.LICENSE.txt | 4 +- .../webfonts/fa-brands-400.ttf | Bin 207972 -> 209128 bytes .../6.5.2/webfonts/fa-brands-400.woff2 | Bin 0 -> 117852 bytes .../webfonts/fa-regular-400.ttf | Bin 68004 -> 67860 bytes .../6.5.2/webfonts/fa-regular-400.woff2 | Bin 0 -> 25392 bytes .../webfonts/fa-solid-900.ttf | Bin 419720 -> 420332 bytes .../6.5.2/webfonts/fa-solid-900.woff2 | Bin 0 -> 156400 bytes .../webfonts/fa-v4compatibility.ttf | Bin 10832 -> 10832 bytes .../6.5.2/webfonts/fa-v4compatibility.woff2 | Bin 0 -> 4792 bytes dev/_static/webpack-macros.html | 24 +-- .../choclo.constants.GRAVITATIONAL_CONST.html | 87 ++++----- ...onstants.VACUUM_MAGNETIC_PERMEABILITY.html | 87 ++++----- .../generated/choclo.dipole.magnetic_e.html | 131 ++++++++------ .../choclo.dipole.magnetic_field.html | 141 ++++++++------- .../generated/choclo.dipole.magnetic_n.html | 131 ++++++++------ .../generated/choclo.dipole.magnetic_u.html | 131 ++++++++------ dev/api/generated/choclo.point.gravity_e.html | 119 ++++++------ .../generated/choclo.point.gravity_ee.html | 119 ++++++------ .../generated/choclo.point.gravity_en.html | 119 ++++++------ .../generated/choclo.point.gravity_eu.html | 119 ++++++------ dev/api/generated/choclo.point.gravity_n.html | 119 ++++++------ .../generated/choclo.point.gravity_nn.html | 119 ++++++------ .../generated/choclo.point.gravity_nu.html | 119 ++++++------ .../generated/choclo.point.gravity_pot.html | 119 ++++++------ dev/api/generated/choclo.point.gravity_u.html | 119 ++++++------ .../generated/choclo.point.gravity_uu.html | 119 ++++++------ dev/api/generated/choclo.point.kernel_e.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_ee.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_en.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_eu.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_n.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_nn.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_nu.html | 121 +++++++------ .../generated/choclo.point.kernel_pot.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_u.html | 121 +++++++------ dev/api/generated/choclo.point.kernel_uu.html | 121 +++++++------ dev/api/generated/choclo.prism.gravity_e.html | 128 +++++++------ .../generated/choclo.prism.gravity_ee.html | 128 +++++++------ .../generated/choclo.prism.gravity_en.html | 128 +++++++------ .../generated/choclo.prism.gravity_eu.html | 128 +++++++------ dev/api/generated/choclo.prism.gravity_n.html | 128 +++++++------ .../generated/choclo.prism.gravity_nn.html | 128 +++++++------ .../generated/choclo.prism.gravity_nu.html | 128 +++++++------ .../generated/choclo.prism.gravity_pot.html | 128 +++++++------ dev/api/generated/choclo.prism.gravity_u.html | 128 +++++++------ .../generated/choclo.prism.gravity_uu.html | 128 +++++++------ dev/api/generated/choclo.prism.kernel_e.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_ee.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_en.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_eu.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_n.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_nn.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_nu.html | 118 ++++++------ .../generated/choclo.prism.kernel_pot.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_u.html | 118 ++++++------ dev/api/generated/choclo.prism.kernel_uu.html | 118 ++++++------ .../generated/choclo.prism.magnetic_e.html | 152 +++++++++------- .../choclo.prism.magnetic_field.html | 170 ++++++++++-------- .../generated/choclo.prism.magnetic_n.html | 152 +++++++++------- .../generated/choclo.prism.magnetic_u.html | 152 +++++++++------- .../choclo.utils.distance_cartesian.html | 116 ++++++------ .../choclo.utils.distance_spherical.html | 116 ++++++------ .../choclo.utils.distance_spherical_core.html | 131 ++++++++------ dev/api/index.html | 111 ++++++------ dev/changes.html | 87 ++++----- dev/citing.html | 85 ++++----- dev/compatibility.html | 90 +++++----- dev/genindex.html | 85 ++++----- dev/index.html | 87 ++++----- dev/install.html | 87 ++++----- dev/overview.html | 87 ++++----- dev/py-modindex.html | 85 ++++----- dev/references.html | 85 ++++----- dev/search.html | 85 ++++----- dev/searchindex.js | 2 +- dev/user_guide/how-to-use.html | 95 +++++----- dev/user_guide/jacobian.html | 89 ++++----- dev/versions.html | 85 ++++----- 161 files changed, 6288 insertions(+), 5512 deletions(-) delete mode 100644 dev/.buildinfo create mode 100644 dev/_static/styles/sphinx-book-theme.css.map delete mode 100644 dev/_static/vendor/fontawesome/6.5.1/css/all.min.css delete mode 100644 dev/_static/vendor/fontawesome/6.5.1/js/all.min.js delete mode 100644 dev/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2 delete mode 100644 dev/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2 delete mode 100644 dev/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2 delete mode 100644 dev/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.woff2 rename dev/_static/vendor/fontawesome/{6.5.1 => 6.5.2}/LICENSE.txt (98%) create mode 100644 dev/_static/vendor/fontawesome/6.5.2/css/all.min.css create mode 100644 dev/_static/vendor/fontawesome/6.5.2/js/all.min.js rename dev/_static/vendor/fontawesome/{6.5.1 => 6.5.2}/js/all.min.js.LICENSE.txt (55%) rename dev/_static/vendor/fontawesome/{6.5.1 => 6.5.2}/webfonts/fa-brands-400.ttf (92%) create mode 100644 dev/_static/vendor/fontawesome/6.5.2/webfonts/fa-brands-400.woff2 rename dev/_static/vendor/fontawesome/{6.5.1 => 6.5.2}/webfonts/fa-regular-400.ttf (95%) create mode 100644 dev/_static/vendor/fontawesome/6.5.2/webfonts/fa-regular-400.woff2 rename dev/_static/vendor/fontawesome/{6.5.1 => 6.5.2}/webfonts/fa-solid-900.ttf (93%) create mode 100644 dev/_static/vendor/fontawesome/6.5.2/webfonts/fa-solid-900.woff2 rename dev/_static/vendor/fontawesome/{6.5.1 => 6.5.2}/webfonts/fa-v4compatibility.ttf (86%) create mode 100644 dev/_static/vendor/fontawesome/6.5.2/webfonts/fa-v4compatibility.woff2 diff --git a/dev/.buildinfo b/dev/.buildinfo deleted file mode 100644 index 413af91c..00000000 --- a/dev/.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: ae1045c498c66a33c6f771d201259237 -tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/dev/_downloads/0cd804d4bb1b789ed7d110b2910079bf/jacobian.ipynb b/dev/_downloads/0cd804d4bb1b789ed7d110b2910079bf/jacobian.ipynb index a8d32351..47695d3a 100644 --- a/dev/_downloads/0cd804d4bb1b789ed7d110b2910079bf/jacobian.ipynb +++ b/dev/_downloads/0cd804d4bb1b789ed7d110b2910079bf/jacobian.ipynb @@ -3,13 +3,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "2500c9b6", + "id": "b71758f3", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:06.950899Z", - "iopub.status.busy": "2024-04-09T23:04:06.950709Z", - "iopub.status.idle": "2024-04-09T23:04:07.178029Z", - "shell.execute_reply": "2024-04-09T23:04:07.177505Z" + "iopub.execute_input": "2024-09-03T16:41:06.162005Z", + "iopub.status.busy": "2024-09-03T16:41:06.161810Z", + "iopub.status.idle": "2024-09-03T16:41:06.369650Z", + "shell.execute_reply": "2024-09-03T16:41:06.369020Z" } }, "outputs": [], @@ -51,13 +51,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "fe350546", + "id": "493218e4", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:07.180687Z", - "iopub.status.busy": "2024-04-09T23:04:07.180235Z", - "iopub.status.idle": "2024-04-09T23:04:07.184143Z", - "shell.execute_reply": "2024-04-09T23:04:07.183627Z" + "iopub.execute_input": "2024-09-03T16:41:06.372313Z", + "iopub.status.busy": "2024-09-03T16:41:06.371884Z", + "iopub.status.idle": "2024-09-03T16:41:06.375619Z", + "shell.execute_reply": "2024-09-03T16:41:06.375063Z" } }, "outputs": [], @@ -73,13 +73,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "b995118d", + "id": "14d66880", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:07.186263Z", - "iopub.status.busy": "2024-04-09T23:04:07.185809Z", - "iopub.status.idle": "2024-04-09T23:04:07.189221Z", - "shell.execute_reply": "2024-04-09T23:04:07.188650Z" + "iopub.execute_input": "2024-09-03T16:41:06.377767Z", + "iopub.status.busy": "2024-09-03T16:41:06.377412Z", + "iopub.status.idle": "2024-09-03T16:41:06.380448Z", + "shell.execute_reply": "2024-09-03T16:41:06.379948Z" } }, "outputs": [], @@ -97,13 +97,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "c4fa5a0b", + "id": "0a4b113f", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:07.191162Z", - "iopub.status.busy": "2024-04-09T23:04:07.190973Z", - "iopub.status.idle": "2024-04-09T23:04:08.803317Z", - "shell.execute_reply": "2024-04-09T23:04:08.802722Z" + "iopub.execute_input": "2024-09-03T16:41:06.382470Z", + "iopub.status.busy": "2024-09-03T16:41:06.382118Z", + "iopub.status.idle": "2024-09-03T16:41:07.894461Z", + "shell.execute_reply": "2024-09-03T16:41:07.893901Z" } }, "outputs": [ @@ -138,13 +138,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "f57f1c76", + "id": "9e834c53", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:08.805751Z", - "iopub.status.busy": "2024-04-09T23:04:08.805365Z", - "iopub.status.idle": "2024-04-09T23:04:08.809047Z", - "shell.execute_reply": "2024-04-09T23:04:08.808473Z" + "iopub.execute_input": "2024-09-03T16:41:07.896961Z", + "iopub.status.busy": "2024-09-03T16:41:07.896567Z", + "iopub.status.idle": "2024-09-03T16:41:07.899811Z", + "shell.execute_reply": "2024-09-03T16:41:07.899321Z" } }, "outputs": [], @@ -159,13 +159,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "8b375b53", + "id": "f41b80e2", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:08.811265Z", - "iopub.status.busy": "2024-04-09T23:04:08.810931Z", - "iopub.status.idle": "2024-04-09T23:04:08.815370Z", - "shell.execute_reply": "2024-04-09T23:04:08.814823Z" + "iopub.execute_input": "2024-09-03T16:41:07.901860Z", + "iopub.status.busy": "2024-09-03T16:41:07.901520Z", + "iopub.status.idle": "2024-09-03T16:41:07.905812Z", + "shell.execute_reply": "2024-09-03T16:41:07.905329Z" } }, "outputs": [], @@ -201,13 +201,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "415c499b", + "id": "6129c693", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:08.817476Z", - "iopub.status.busy": "2024-04-09T23:04:08.817147Z", - "iopub.status.idle": "2024-04-09T23:04:09.430025Z", - "shell.execute_reply": "2024-04-09T23:04:09.429399Z" + "iopub.execute_input": "2024-09-03T16:41:07.907807Z", + "iopub.status.busy": "2024-09-03T16:41:07.907479Z", + "iopub.status.idle": "2024-09-03T16:41:08.495404Z", + "shell.execute_reply": "2024-09-03T16:41:08.494832Z" } }, "outputs": [ @@ -244,7 +244,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.12.5" } }, "nbformat": 4, diff --git a/dev/_downloads/313b8b90999108adb84ffcf2515619aa/overview.ipynb b/dev/_downloads/313b8b90999108adb84ffcf2515619aa/overview.ipynb index fd2595a4..9adb72e7 100644 --- a/dev/_downloads/313b8b90999108adb84ffcf2515619aa/overview.ipynb +++ b/dev/_downloads/313b8b90999108adb84ffcf2515619aa/overview.ipynb @@ -3,13 +3,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "501994f0", + "id": "8db9dbd4", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:42.097278Z", - "iopub.status.busy": "2024-04-09T23:03:42.096756Z", - "iopub.status.idle": "2024-04-09T23:03:43.012995Z", - "shell.execute_reply": "2024-04-09T23:03:43.012458Z" + "iopub.execute_input": "2024-09-03T16:40:41.389517Z", + "iopub.status.busy": "2024-09-03T16:40:41.389314Z", + "iopub.status.idle": "2024-09-03T16:40:42.354444Z", + "shell.execute_reply": "2024-09-03T16:40:42.353819Z" } }, "outputs": [ @@ -60,13 +60,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "47ec0eb8", + "id": "86360617", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:43.015288Z", - "iopub.status.busy": "2024-04-09T23:03:43.015026Z", - "iopub.status.idle": "2024-04-09T23:03:44.614929Z", - "shell.execute_reply": "2024-04-09T23:03:44.614340Z" + "iopub.execute_input": "2024-09-03T16:40:42.357529Z", + "iopub.status.busy": "2024-09-03T16:40:42.356847Z", + "iopub.status.idle": "2024-09-03T16:40:43.942965Z", + "shell.execute_reply": "2024-09-03T16:40:43.942324Z" } }, "outputs": [ @@ -117,13 +117,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "e0bb0545", + "id": "49338630", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:44.617217Z", - "iopub.status.busy": "2024-04-09T23:03:44.616823Z", - "iopub.status.idle": "2024-04-09T23:03:44.745362Z", - "shell.execute_reply": "2024-04-09T23:03:44.744852Z" + "iopub.execute_input": "2024-09-03T16:40:43.945150Z", + "iopub.status.busy": "2024-09-03T16:40:43.944953Z", + "iopub.status.idle": "2024-09-03T16:40:44.075118Z", + "shell.execute_reply": "2024-09-03T16:40:44.074533Z" } }, "outputs": [ @@ -167,13 +167,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "16967645", + "id": "5bc8b5b1", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:44.747571Z", - "iopub.status.busy": "2024-04-09T23:03:44.747194Z", - "iopub.status.idle": "2024-04-09T23:03:45.295297Z", - "shell.execute_reply": "2024-04-09T23:03:45.294670Z" + "iopub.execute_input": "2024-09-03T16:40:44.077446Z", + "iopub.status.busy": "2024-09-03T16:40:44.077092Z", + "iopub.status.idle": "2024-09-03T16:40:44.622075Z", + "shell.execute_reply": "2024-09-03T16:40:44.621469Z" } }, "outputs": [ @@ -219,7 +219,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.12.5" } }, "nbformat": 4, diff --git a/dev/_downloads/903b89fd3874d64d371a9beff7139999/how-to-use.ipynb b/dev/_downloads/903b89fd3874d64d371a9beff7139999/how-to-use.ipynb index 59961227..e2e6b5e5 100644 --- a/dev/_downloads/903b89fd3874d64d371a9beff7139999/how-to-use.ipynb +++ b/dev/_downloads/903b89fd3874d64d371a9beff7139999/how-to-use.ipynb @@ -3,13 +3,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "fb41903d", + "id": "8b856562", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:46.669477Z", - "iopub.status.busy": "2024-04-09T23:03:46.669281Z", - "iopub.status.idle": "2024-04-09T23:03:47.821106Z", - "shell.execute_reply": "2024-04-09T23:03:47.820505Z" + "iopub.execute_input": "2024-09-03T16:40:45.996151Z", + "iopub.status.busy": "2024-09-03T16:40:45.995900Z", + "iopub.status.idle": "2024-09-03T16:40:47.144931Z", + "shell.execute_reply": "2024-09-03T16:40:47.144310Z" } }, "outputs": [ @@ -45,13 +45,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "3b2bd03e", + "id": "a5e1a20f", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:47.823444Z", - "iopub.status.busy": "2024-04-09T23:03:47.823092Z", - "iopub.status.idle": "2024-04-09T23:03:47.826527Z", - "shell.execute_reply": "2024-04-09T23:03:47.826087Z" + "iopub.execute_input": "2024-09-03T16:40:47.147248Z", + "iopub.status.busy": "2024-09-03T16:40:47.146943Z", + "iopub.status.idle": "2024-09-03T16:40:47.150636Z", + "shell.execute_reply": "2024-09-03T16:40:47.150067Z" } }, "outputs": [], @@ -68,13 +68,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "954d7562", + "id": "de19f20f", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:47.828554Z", - "iopub.status.busy": "2024-04-09T23:03:47.828196Z", - "iopub.status.idle": "2024-04-09T23:03:47.831595Z", - "shell.execute_reply": "2024-04-09T23:03:47.831141Z" + "iopub.execute_input": "2024-09-03T16:40:47.152834Z", + "iopub.status.busy": "2024-09-03T16:40:47.152470Z", + "iopub.status.idle": "2024-09-03T16:40:47.155925Z", + "shell.execute_reply": "2024-09-03T16:40:47.155429Z" } }, "outputs": [], @@ -90,13 +90,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "33723071", + "id": "f748e755", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:47.833720Z", - "iopub.status.busy": "2024-04-09T23:03:47.833356Z", - "iopub.status.idle": "2024-04-09T23:03:47.837025Z", - "shell.execute_reply": "2024-04-09T23:03:47.836563Z" + "iopub.execute_input": "2024-09-03T16:40:47.158232Z", + "iopub.status.busy": "2024-09-03T16:40:47.157759Z", + "iopub.status.idle": "2024-09-03T16:40:47.161711Z", + "shell.execute_reply": "2024-09-03T16:40:47.161251Z" } }, "outputs": [], @@ -122,13 +122,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "356b1cae", + "id": "dfe2b12e", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:47.838946Z", - "iopub.status.busy": "2024-04-09T23:03:47.838613Z", - "iopub.status.idle": "2024-04-09T23:03:47.848447Z", - "shell.execute_reply": "2024-04-09T23:03:47.847851Z" + "iopub.execute_input": "2024-09-03T16:40:47.163713Z", + "iopub.status.busy": "2024-09-03T16:40:47.163349Z", + "iopub.status.idle": "2024-09-03T16:40:47.172979Z", + "shell.execute_reply": "2024-09-03T16:40:47.172387Z" } }, "outputs": [], @@ -139,19 +139,19 @@ { "cell_type": "code", "execution_count": 6, - "id": "f7eebccd", + "id": "9fed8cf0", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:47.850425Z", - "iopub.status.busy": "2024-04-09T23:03:47.850096Z", - "iopub.status.idle": "2024-04-09T23:03:48.604498Z", - "shell.execute_reply": "2024-04-09T23:03:48.603897Z" + "iopub.execute_input": "2024-09-03T16:40:47.175310Z", + "iopub.status.busy": "2024-09-03T16:40:47.174853Z", + "iopub.status.idle": "2024-09-03T16:40:48.052707Z", + "shell.execute_reply": "2024-09-03T16:40:48.052077Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,19 +176,19 @@ { "cell_type": "code", "execution_count": 7, - "id": "55917e3b", + "id": "5b27b81a", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:48.606768Z", - "iopub.status.busy": "2024-04-09T23:03:48.606354Z", - "iopub.status.idle": "2024-04-09T23:03:49.220877Z", - "shell.execute_reply": "2024-04-09T23:03:49.220273Z" + "iopub.execute_input": "2024-09-03T16:40:48.055105Z", + "iopub.status.busy": "2024-09-03T16:40:48.054657Z", + "iopub.status.idle": "2024-09-03T16:40:48.607527Z", + "shell.execute_reply": "2024-09-03T16:40:48.606882Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -242,13 +242,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "028036e8", + "id": "be33eaf5", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:49.223171Z", - "iopub.status.busy": "2024-04-09T23:03:49.222810Z", - "iopub.status.idle": "2024-04-09T23:03:54.842374Z", - "shell.execute_reply": "2024-04-09T23:03:54.841795Z" + "iopub.execute_input": "2024-09-03T16:40:48.609749Z", + "iopub.status.busy": "2024-09-03T16:40:48.609541Z", + "iopub.status.idle": "2024-09-03T16:40:54.095400Z", + "shell.execute_reply": "2024-09-03T16:40:54.094857Z" } }, "outputs": [ @@ -256,7 +256,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "6.94 ms ± 221 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + "6.77 ms ± 163 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" ] } ], @@ -267,13 +267,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "dd6817b0", + "id": "4994cbbb", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:54.844706Z", - "iopub.status.busy": "2024-04-09T23:03:54.844338Z", - "iopub.status.idle": "2024-04-09T23:03:58.872339Z", - "shell.execute_reply": "2024-04-09T23:03:58.871795Z" + "iopub.execute_input": "2024-09-03T16:40:54.097728Z", + "iopub.status.busy": "2024-09-03T16:40:54.097358Z", + "iopub.status.idle": "2024-09-03T16:40:58.151707Z", + "shell.execute_reply": "2024-09-03T16:40:58.151046Z" } }, "outputs": [ @@ -281,7 +281,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "496 µs ± 2.4 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" + "500 μs ± 10.9 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" ] } ], @@ -292,19 +292,19 @@ { "cell_type": "code", "execution_count": 10, - "id": "f280ecc2", + "id": "2c410529", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:58.874518Z", - "iopub.status.busy": "2024-04-09T23:03:58.874138Z", - "iopub.status.idle": "2024-04-09T23:03:59.630445Z", - "shell.execute_reply": "2024-04-09T23:03:59.629887Z" + "iopub.execute_input": "2024-09-03T16:40:58.153989Z", + "iopub.status.busy": "2024-09-03T16:40:58.153784Z", + "iopub.status.idle": "2024-09-03T16:40:58.862573Z", + "shell.execute_reply": "2024-09-03T16:40:58.861931Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -356,13 +356,13 @@ { "cell_type": "code", "execution_count": 11, - "id": "50c0f457", + "id": "8bff40fd", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:03:59.632733Z", - "iopub.status.busy": "2024-04-09T23:03:59.632355Z", - "iopub.status.idle": "2024-04-09T23:04:03.645941Z", - "shell.execute_reply": "2024-04-09T23:04:03.645398Z" + "iopub.execute_input": "2024-09-03T16:40:58.864990Z", + "iopub.status.busy": "2024-09-03T16:40:58.864617Z", + "iopub.status.idle": "2024-09-03T16:41:02.874161Z", + "shell.execute_reply": "2024-09-03T16:41:02.873529Z" } }, "outputs": [ @@ -370,7 +370,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "494 µs ± 1.68 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" + "494 μs ± 383 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" ] } ], @@ -381,13 +381,13 @@ { "cell_type": "code", "execution_count": 12, - "id": "090d94e8", + "id": "1de8675c", "metadata": { "execution": { - "iopub.execute_input": "2024-04-09T23:04:03.648080Z", - "iopub.status.busy": "2024-04-09T23:04:03.647687Z", - "iopub.status.idle": "2024-04-09T23:04:05.386261Z", - "shell.execute_reply": "2024-04-09T23:04:05.385703Z" + "iopub.execute_input": "2024-09-03T16:41:02.876404Z", + "iopub.status.busy": "2024-09-03T16:41:02.876207Z", + "iopub.status.idle": "2024-09-03T16:41:04.617092Z", + "shell.execute_reply": "2024-09-03T16:41:04.616515Z" } }, "outputs": [ @@ -395,7 +395,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "214 µs ± 4.39 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" + "214 μs ± 6.92 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" ] } ], @@ -420,7 +420,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.12.5" } }, "nbformat": 4, diff --git a/dev/_images/how-to-use_5_0.png b/dev/_images/how-to-use_5_0.png index 319079571991a4b01db215365bd9cc93975f5a49..7e9c261204fd125382aadb786b22d7a41c2cc7fb 100644 GIT binary patch delta 43 ycmX?AbE;;7n}VgDk&Z$}Nl8JmmA-y%Vo5Nl8JmmA-y%Vo5Nl8JmmA-y%Vo5Nl8JmmA-y%Vo5 document.documentElement.dataset.mode = localStorage.getItem("mode") || ""; - document.documentElement.dataset.theme = localStorage.getItem("theme") || "light"; + document.documentElement.dataset.theme = localStorage.getItem("theme") || ""; - - - + + + - - - - + + + + - + @@ -40,9 +40,9 @@ - - - + + + @@ -50,7 +50,7 @@ - + @@ -68,27 +68,23 @@ - +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + +
+ Back to top - + id="pst-primary-sidebar-checkbox"/> + - + id="pst-secondary-sidebar-checkbox"/> +
@@ -110,8 +106,13 @@ Ctrl+K
+ +
+ +
+ -
+
@@ -137,6 +138,8 @@
+ + elements (which change the URL) not inside the collapsible element\n if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {\n event.preventDefault();\n }\n for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {\n Collapse.getOrCreateInstance(element, {\n toggle: false\n }).toggle();\n }\n});\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Collapse);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap dropdown.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$a = 'dropdown';\nconst DATA_KEY$6 = 'bs.dropdown';\nconst EVENT_KEY$6 = `.${DATA_KEY$6}`;\nconst DATA_API_KEY$3 = '.data-api';\nconst ESCAPE_KEY$2 = 'Escape';\nconst TAB_KEY$1 = 'Tab';\nconst ARROW_UP_KEY$1 = 'ArrowUp';\nconst ARROW_DOWN_KEY$1 = 'ArrowDown';\nconst RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button\n\nconst EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;\nconst EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;\nconst EVENT_SHOW$5 = `show${EVENT_KEY$6}`;\nconst EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;\nconst EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;\nconst EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;\nconst EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;\nconst CLASS_NAME_SHOW$6 = 'show';\nconst CLASS_NAME_DROPUP = 'dropup';\nconst CLASS_NAME_DROPEND = 'dropend';\nconst CLASS_NAME_DROPSTART = 'dropstart';\nconst CLASS_NAME_DROPUP_CENTER = 'dropup-center';\nconst CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';\nconst SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle=\"dropdown\"]:not(.disabled):not(:disabled)';\nconst SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;\nconst SELECTOR_MENU = '.dropdown-menu';\nconst SELECTOR_NAVBAR = '.navbar';\nconst SELECTOR_NAVBAR_NAV = '.navbar-nav';\nconst SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';\nconst PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';\nconst PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';\nconst PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';\nconst PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';\nconst PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';\nconst PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';\nconst PLACEMENT_TOPCENTER = 'top';\nconst PLACEMENT_BOTTOMCENTER = 'bottom';\nconst Default$9 = {\n autoClose: true,\n boundary: 'clippingParents',\n display: 'dynamic',\n offset: [0, 2],\n popperConfig: null,\n reference: 'toggle'\n};\nconst DefaultType$9 = {\n autoClose: '(boolean|string)',\n boundary: '(string|element)',\n display: 'string',\n offset: '(array|string|function)',\n popperConfig: '(null|object|function)',\n reference: '(string|element|object)'\n};\n\n/**\n * Class definition\n */\n\nclass Dropdown extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._popper = null;\n this._parent = this._element.parentNode; // dropdown wrapper\n // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/\n this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent);\n this._inNavbar = this._detectNavbar();\n }\n\n // Getters\n static get Default() {\n return Default$9;\n }\n static get DefaultType() {\n return DefaultType$9;\n }\n static get NAME() {\n return NAME$a;\n }\n\n // Public\n toggle() {\n return this._isShown() ? this.hide() : this.show();\n }\n show() {\n if (isDisabled(this._element) || this._isShown()) {\n return;\n }\n const relatedTarget = {\n relatedTarget: this._element\n };\n const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);\n if (showEvent.defaultPrevented) {\n return;\n }\n this._createPopper();\n\n // If this is a touch-enabled device we add extra\n // empty mouseover listeners to the body's immediate children;\n // only needed because of broken event delegation on iOS\n // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html\n if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.on(element, 'mouseover', noop);\n }\n }\n this._element.focus();\n this._element.setAttribute('aria-expanded', true);\n this._menu.classList.add(CLASS_NAME_SHOW$6);\n this._element.classList.add(CLASS_NAME_SHOW$6);\n EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);\n }\n hide() {\n if (isDisabled(this._element) || !this._isShown()) {\n return;\n }\n const relatedTarget = {\n relatedTarget: this._element\n };\n this._completeHide(relatedTarget);\n }\n dispose() {\n if (this._popper) {\n this._popper.destroy();\n }\n super.dispose();\n }\n update() {\n this._inNavbar = this._detectNavbar();\n if (this._popper) {\n this._popper.update();\n }\n }\n\n // Private\n _completeHide(relatedTarget) {\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);\n if (hideEvent.defaultPrevented) {\n return;\n }\n\n // If this is a touch-enabled device we remove the extra\n // empty mouseover listeners we added for iOS support\n if ('ontouchstart' in document.documentElement) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.off(element, 'mouseover', noop);\n }\n }\n if (this._popper) {\n this._popper.destroy();\n }\n this._menu.classList.remove(CLASS_NAME_SHOW$6);\n this._element.classList.remove(CLASS_NAME_SHOW$6);\n this._element.setAttribute('aria-expanded', 'false');\n Manipulator.removeDataAttribute(this._menu, 'popper');\n EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);\n }\n _getConfig(config) {\n config = super._getConfig(config);\n if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {\n // Popper virtual elements require a getBoundingClientRect method\n throw new TypeError(`${NAME$a.toUpperCase()}: Option \"reference\" provided type \"object\" without a required \"getBoundingClientRect\" method.`);\n }\n return config;\n }\n _createPopper() {\n if (typeof Popper === 'undefined') {\n throw new TypeError('Bootstrap\\'s dropdowns require Popper (https://popper.js.org)');\n }\n let referenceElement = this._element;\n if (this._config.reference === 'parent') {\n referenceElement = this._parent;\n } else if (isElement(this._config.reference)) {\n referenceElement = getElement(this._config.reference);\n } else if (typeof this._config.reference === 'object') {\n referenceElement = this._config.reference;\n }\n const popperConfig = this._getPopperConfig();\n this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig);\n }\n _isShown() {\n return this._menu.classList.contains(CLASS_NAME_SHOW$6);\n }\n _getPlacement() {\n const parentDropdown = this._parent;\n if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {\n return PLACEMENT_RIGHT;\n }\n if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {\n return PLACEMENT_LEFT;\n }\n if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {\n return PLACEMENT_TOPCENTER;\n }\n if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {\n return PLACEMENT_BOTTOMCENTER;\n }\n\n // We need to trim the value because custom properties can also include spaces\n const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';\n if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {\n return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;\n }\n return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;\n }\n _detectNavbar() {\n return this._element.closest(SELECTOR_NAVBAR) !== null;\n }\n _getOffset() {\n const {\n offset\n } = this._config;\n if (typeof offset === 'string') {\n return offset.split(',').map(value => Number.parseInt(value, 10));\n }\n if (typeof offset === 'function') {\n return popperData => offset(popperData, this._element);\n }\n return offset;\n }\n _getPopperConfig() {\n const defaultBsPopperConfig = {\n placement: this._getPlacement(),\n modifiers: [{\n name: 'preventOverflow',\n options: {\n boundary: this._config.boundary\n }\n }, {\n name: 'offset',\n options: {\n offset: this._getOffset()\n }\n }]\n };\n\n // Disable Popper if we have a static display or Dropdown is in Navbar\n if (this._inNavbar || this._config.display === 'static') {\n Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove\n defaultBsPopperConfig.modifiers = [{\n name: 'applyStyles',\n enabled: false\n }];\n }\n return {\n ...defaultBsPopperConfig,\n ...execute(this._config.popperConfig, [defaultBsPopperConfig])\n };\n }\n _selectMenuItem({\n key,\n target\n }) {\n const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element));\n if (!items.length) {\n return;\n }\n\n // if target isn't included in items (e.g. when expanding the dropdown)\n // allow cycling to get the last item in case key equals ARROW_UP_KEY\n getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus();\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Dropdown.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n });\n }\n static clearMenus(event) {\n if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) {\n return;\n }\n const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);\n for (const toggle of openToggles) {\n const context = Dropdown.getInstance(toggle);\n if (!context || context._config.autoClose === false) {\n continue;\n }\n const composedPath = event.composedPath();\n const isMenuTarget = composedPath.includes(context._menu);\n if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {\n continue;\n }\n\n // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu\n if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {\n continue;\n }\n const relatedTarget = {\n relatedTarget: context._element\n };\n if (event.type === 'click') {\n relatedTarget.clickEvent = event;\n }\n context._completeHide(relatedTarget);\n }\n }\n static dataApiKeydownHandler(event) {\n // If not an UP | DOWN | ESCAPE key => not a dropdown command\n // If input/textarea && if key is other than ESCAPE => not a dropdown command\n\n const isInput = /input|textarea/i.test(event.target.tagName);\n const isEscapeEvent = event.key === ESCAPE_KEY$2;\n const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);\n if (!isUpOrDownEvent && !isEscapeEvent) {\n return;\n }\n if (isInput && !isEscapeEvent) {\n return;\n }\n event.preventDefault();\n\n // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/\n const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode);\n const instance = Dropdown.getOrCreateInstance(getToggleButton);\n if (isUpOrDownEvent) {\n event.stopPropagation();\n instance.show();\n instance._selectMenuItem(event);\n return;\n }\n if (instance._isShown()) {\n // else is escape and we check if it is shown\n event.stopPropagation();\n instance.hide();\n getToggleButton.focus();\n }\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);\nEventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);\nEventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);\nEventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);\nEventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {\n event.preventDefault();\n Dropdown.getOrCreateInstance(this).toggle();\n});\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Dropdown);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/backdrop.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$9 = 'backdrop';\nconst CLASS_NAME_FADE$4 = 'fade';\nconst CLASS_NAME_SHOW$5 = 'show';\nconst EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;\nconst Default$8 = {\n className: 'modal-backdrop',\n clickCallback: null,\n isAnimated: false,\n isVisible: true,\n // if false, we use the backdrop helper without adding any element to the dom\n rootElement: 'body' // give the choice to place backdrop under different elements\n};\n\nconst DefaultType$8 = {\n className: 'string',\n clickCallback: '(function|null)',\n isAnimated: 'boolean',\n isVisible: 'boolean',\n rootElement: '(element|string)'\n};\n\n/**\n * Class definition\n */\n\nclass Backdrop extends Config {\n constructor(config) {\n super();\n this._config = this._getConfig(config);\n this._isAppended = false;\n this._element = null;\n }\n\n // Getters\n static get Default() {\n return Default$8;\n }\n static get DefaultType() {\n return DefaultType$8;\n }\n static get NAME() {\n return NAME$9;\n }\n\n // Public\n show(callback) {\n if (!this._config.isVisible) {\n execute(callback);\n return;\n }\n this._append();\n const element = this._getElement();\n if (this._config.isAnimated) {\n reflow(element);\n }\n element.classList.add(CLASS_NAME_SHOW$5);\n this._emulateAnimation(() => {\n execute(callback);\n });\n }\n hide(callback) {\n if (!this._config.isVisible) {\n execute(callback);\n return;\n }\n this._getElement().classList.remove(CLASS_NAME_SHOW$5);\n this._emulateAnimation(() => {\n this.dispose();\n execute(callback);\n });\n }\n dispose() {\n if (!this._isAppended) {\n return;\n }\n EventHandler.off(this._element, EVENT_MOUSEDOWN);\n this._element.remove();\n this._isAppended = false;\n }\n\n // Private\n _getElement() {\n if (!this._element) {\n const backdrop = document.createElement('div');\n backdrop.className = this._config.className;\n if (this._config.isAnimated) {\n backdrop.classList.add(CLASS_NAME_FADE$4);\n }\n this._element = backdrop;\n }\n return this._element;\n }\n _configAfterMerge(config) {\n // use getElement() with the default \"body\" to get a fresh Element on each instantiation\n config.rootElement = getElement(config.rootElement);\n return config;\n }\n _append() {\n if (this._isAppended) {\n return;\n }\n const element = this._getElement();\n this._config.rootElement.append(element);\n EventHandler.on(element, EVENT_MOUSEDOWN, () => {\n execute(this._config.clickCallback);\n });\n this._isAppended = true;\n }\n _emulateAnimation(callback) {\n executeAfterTransition(callback, this._getElement(), this._config.isAnimated);\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/focustrap.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$8 = 'focustrap';\nconst DATA_KEY$5 = 'bs.focustrap';\nconst EVENT_KEY$5 = `.${DATA_KEY$5}`;\nconst EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;\nconst EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;\nconst TAB_KEY = 'Tab';\nconst TAB_NAV_FORWARD = 'forward';\nconst TAB_NAV_BACKWARD = 'backward';\nconst Default$7 = {\n autofocus: true,\n trapElement: null // The element to trap focus inside of\n};\n\nconst DefaultType$7 = {\n autofocus: 'boolean',\n trapElement: 'element'\n};\n\n/**\n * Class definition\n */\n\nclass FocusTrap extends Config {\n constructor(config) {\n super();\n this._config = this._getConfig(config);\n this._isActive = false;\n this._lastTabNavDirection = null;\n }\n\n // Getters\n static get Default() {\n return Default$7;\n }\n static get DefaultType() {\n return DefaultType$7;\n }\n static get NAME() {\n return NAME$8;\n }\n\n // Public\n activate() {\n if (this._isActive) {\n return;\n }\n if (this._config.autofocus) {\n this._config.trapElement.focus();\n }\n EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop\n EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event));\n EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));\n this._isActive = true;\n }\n deactivate() {\n if (!this._isActive) {\n return;\n }\n this._isActive = false;\n EventHandler.off(document, EVENT_KEY$5);\n }\n\n // Private\n _handleFocusin(event) {\n const {\n trapElement\n } = this._config;\n if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {\n return;\n }\n const elements = SelectorEngine.focusableChildren(trapElement);\n if (elements.length === 0) {\n trapElement.focus();\n } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {\n elements[elements.length - 1].focus();\n } else {\n elements[0].focus();\n }\n }\n _handleKeydown(event) {\n if (event.key !== TAB_KEY) {\n return;\n }\n this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/scrollBar.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';\nconst SELECTOR_STICKY_CONTENT = '.sticky-top';\nconst PROPERTY_PADDING = 'padding-right';\nconst PROPERTY_MARGIN = 'margin-right';\n\n/**\n * Class definition\n */\n\nclass ScrollBarHelper {\n constructor() {\n this._element = document.body;\n }\n\n // Public\n getWidth() {\n // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes\n const documentWidth = document.documentElement.clientWidth;\n return Math.abs(window.innerWidth - documentWidth);\n }\n hide() {\n const width = this.getWidth();\n this._disableOverFlow();\n // give padding to element to balance the hidden scrollbar width\n this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width);\n // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth\n this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width);\n this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width);\n }\n reset() {\n this._resetElementAttributes(this._element, 'overflow');\n this._resetElementAttributes(this._element, PROPERTY_PADDING);\n this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);\n this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);\n }\n isOverflowing() {\n return this.getWidth() > 0;\n }\n\n // Private\n _disableOverFlow() {\n this._saveInitialAttribute(this._element, 'overflow');\n this._element.style.overflow = 'hidden';\n }\n _setElementAttributes(selector, styleProperty, callback) {\n const scrollbarWidth = this.getWidth();\n const manipulationCallBack = element => {\n if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {\n return;\n }\n this._saveInitialAttribute(element, styleProperty);\n const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);\n element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);\n };\n this._applyManipulationCallback(selector, manipulationCallBack);\n }\n _saveInitialAttribute(element, styleProperty) {\n const actualValue = element.style.getPropertyValue(styleProperty);\n if (actualValue) {\n Manipulator.setDataAttribute(element, styleProperty, actualValue);\n }\n }\n _resetElementAttributes(selector, styleProperty) {\n const manipulationCallBack = element => {\n const value = Manipulator.getDataAttribute(element, styleProperty);\n // We only want to remove the property if the value is `null`; the value can also be zero\n if (value === null) {\n element.style.removeProperty(styleProperty);\n return;\n }\n Manipulator.removeDataAttribute(element, styleProperty);\n element.style.setProperty(styleProperty, value);\n };\n this._applyManipulationCallback(selector, manipulationCallBack);\n }\n _applyManipulationCallback(selector, callBack) {\n if (isElement(selector)) {\n callBack(selector);\n return;\n }\n for (const sel of SelectorEngine.find(selector, this._element)) {\n callBack(sel);\n }\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap modal.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$7 = 'modal';\nconst DATA_KEY$4 = 'bs.modal';\nconst EVENT_KEY$4 = `.${DATA_KEY$4}`;\nconst DATA_API_KEY$2 = '.data-api';\nconst ESCAPE_KEY$1 = 'Escape';\nconst EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;\nconst EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;\nconst EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;\nconst EVENT_SHOW$4 = `show${EVENT_KEY$4}`;\nconst EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;\nconst EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;\nconst EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;\nconst EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;\nconst EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;\nconst EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;\nconst CLASS_NAME_OPEN = 'modal-open';\nconst CLASS_NAME_FADE$3 = 'fade';\nconst CLASS_NAME_SHOW$4 = 'show';\nconst CLASS_NAME_STATIC = 'modal-static';\nconst OPEN_SELECTOR$1 = '.modal.show';\nconst SELECTOR_DIALOG = '.modal-dialog';\nconst SELECTOR_MODAL_BODY = '.modal-body';\nconst SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle=\"modal\"]';\nconst Default$6 = {\n backdrop: true,\n focus: true,\n keyboard: true\n};\nconst DefaultType$6 = {\n backdrop: '(boolean|string)',\n focus: 'boolean',\n keyboard: 'boolean'\n};\n\n/**\n * Class definition\n */\n\nclass Modal extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);\n this._backdrop = this._initializeBackDrop();\n this._focustrap = this._initializeFocusTrap();\n this._isShown = false;\n this._isTransitioning = false;\n this._scrollBar = new ScrollBarHelper();\n this._addEventListeners();\n }\n\n // Getters\n static get Default() {\n return Default$6;\n }\n static get DefaultType() {\n return DefaultType$6;\n }\n static get NAME() {\n return NAME$7;\n }\n\n // Public\n toggle(relatedTarget) {\n return this._isShown ? this.hide() : this.show(relatedTarget);\n }\n show(relatedTarget) {\n if (this._isShown || this._isTransitioning) {\n return;\n }\n const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {\n relatedTarget\n });\n if (showEvent.defaultPrevented) {\n return;\n }\n this._isShown = true;\n this._isTransitioning = true;\n this._scrollBar.hide();\n document.body.classList.add(CLASS_NAME_OPEN);\n this._adjustDialog();\n this._backdrop.show(() => this._showElement(relatedTarget));\n }\n hide() {\n if (!this._isShown || this._isTransitioning) {\n return;\n }\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);\n if (hideEvent.defaultPrevented) {\n return;\n }\n this._isShown = false;\n this._isTransitioning = true;\n this._focustrap.deactivate();\n this._element.classList.remove(CLASS_NAME_SHOW$4);\n this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());\n }\n dispose() {\n EventHandler.off(window, EVENT_KEY$4);\n EventHandler.off(this._dialog, EVENT_KEY$4);\n this._backdrop.dispose();\n this._focustrap.deactivate();\n super.dispose();\n }\n handleUpdate() {\n this._adjustDialog();\n }\n\n // Private\n _initializeBackDrop() {\n return new Backdrop({\n isVisible: Boolean(this._config.backdrop),\n // 'static' option will be translated to true, and booleans will keep their value,\n isAnimated: this._isAnimated()\n });\n }\n _initializeFocusTrap() {\n return new FocusTrap({\n trapElement: this._element\n });\n }\n _showElement(relatedTarget) {\n // try to append dynamic modal\n if (!document.body.contains(this._element)) {\n document.body.append(this._element);\n }\n this._element.style.display = 'block';\n this._element.removeAttribute('aria-hidden');\n this._element.setAttribute('aria-modal', true);\n this._element.setAttribute('role', 'dialog');\n this._element.scrollTop = 0;\n const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);\n if (modalBody) {\n modalBody.scrollTop = 0;\n }\n reflow(this._element);\n this._element.classList.add(CLASS_NAME_SHOW$4);\n const transitionComplete = () => {\n if (this._config.focus) {\n this._focustrap.activate();\n }\n this._isTransitioning = false;\n EventHandler.trigger(this._element, EVENT_SHOWN$4, {\n relatedTarget\n });\n };\n this._queueCallback(transitionComplete, this._dialog, this._isAnimated());\n }\n _addEventListeners() {\n EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {\n if (event.key !== ESCAPE_KEY$1) {\n return;\n }\n if (this._config.keyboard) {\n this.hide();\n return;\n }\n this._triggerBackdropTransition();\n });\n EventHandler.on(window, EVENT_RESIZE$1, () => {\n if (this._isShown && !this._isTransitioning) {\n this._adjustDialog();\n }\n });\n EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => {\n // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks\n EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => {\n if (this._element !== event.target || this._element !== event2.target) {\n return;\n }\n if (this._config.backdrop === 'static') {\n this._triggerBackdropTransition();\n return;\n }\n if (this._config.backdrop) {\n this.hide();\n }\n });\n });\n }\n _hideModal() {\n this._element.style.display = 'none';\n this._element.setAttribute('aria-hidden', true);\n this._element.removeAttribute('aria-modal');\n this._element.removeAttribute('role');\n this._isTransitioning = false;\n this._backdrop.hide(() => {\n document.body.classList.remove(CLASS_NAME_OPEN);\n this._resetAdjustments();\n this._scrollBar.reset();\n EventHandler.trigger(this._element, EVENT_HIDDEN$4);\n });\n }\n _isAnimated() {\n return this._element.classList.contains(CLASS_NAME_FADE$3);\n }\n _triggerBackdropTransition() {\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);\n if (hideEvent.defaultPrevented) {\n return;\n }\n const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;\n const initialOverflowY = this._element.style.overflowY;\n // return if the following background transition hasn't yet completed\n if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {\n return;\n }\n if (!isModalOverflowing) {\n this._element.style.overflowY = 'hidden';\n }\n this._element.classList.add(CLASS_NAME_STATIC);\n this._queueCallback(() => {\n this._element.classList.remove(CLASS_NAME_STATIC);\n this._queueCallback(() => {\n this._element.style.overflowY = initialOverflowY;\n }, this._dialog);\n }, this._dialog);\n this._element.focus();\n }\n\n /**\n * The following methods are used to handle overflowing modals\n */\n\n _adjustDialog() {\n const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;\n const scrollbarWidth = this._scrollBar.getWidth();\n const isBodyOverflowing = scrollbarWidth > 0;\n if (isBodyOverflowing && !isModalOverflowing) {\n const property = isRTL() ? 'paddingLeft' : 'paddingRight';\n this._element.style[property] = `${scrollbarWidth}px`;\n }\n if (!isBodyOverflowing && isModalOverflowing) {\n const property = isRTL() ? 'paddingRight' : 'paddingLeft';\n this._element.style[property] = `${scrollbarWidth}px`;\n }\n }\n _resetAdjustments() {\n this._element.style.paddingLeft = '';\n this._element.style.paddingRight = '';\n }\n\n // Static\n static jQueryInterface(config, relatedTarget) {\n return this.each(function () {\n const data = Modal.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config](relatedTarget);\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {\n const target = SelectorEngine.getElementFromSelector(this);\n if (['A', 'AREA'].includes(this.tagName)) {\n event.preventDefault();\n }\n EventHandler.one(target, EVENT_SHOW$4, showEvent => {\n if (showEvent.defaultPrevented) {\n // only register focus restorer if modal will actually get shown\n return;\n }\n EventHandler.one(target, EVENT_HIDDEN$4, () => {\n if (isVisible(this)) {\n this.focus();\n }\n });\n });\n\n // avoid conflict when clicking modal toggler while another one is open\n const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);\n if (alreadyOpen) {\n Modal.getInstance(alreadyOpen).hide();\n }\n const data = Modal.getOrCreateInstance(target);\n data.toggle(this);\n});\nenableDismissTrigger(Modal);\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Modal);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap offcanvas.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$6 = 'offcanvas';\nconst DATA_KEY$3 = 'bs.offcanvas';\nconst EVENT_KEY$3 = `.${DATA_KEY$3}`;\nconst DATA_API_KEY$1 = '.data-api';\nconst EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;\nconst ESCAPE_KEY = 'Escape';\nconst CLASS_NAME_SHOW$3 = 'show';\nconst CLASS_NAME_SHOWING$1 = 'showing';\nconst CLASS_NAME_HIDING = 'hiding';\nconst CLASS_NAME_BACKDROP = 'offcanvas-backdrop';\nconst OPEN_SELECTOR = '.offcanvas.show';\nconst EVENT_SHOW$3 = `show${EVENT_KEY$3}`;\nconst EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;\nconst EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;\nconst EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;\nconst EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;\nconst EVENT_RESIZE = `resize${EVENT_KEY$3}`;\nconst EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;\nconst EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;\nconst SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle=\"offcanvas\"]';\nconst Default$5 = {\n backdrop: true,\n keyboard: true,\n scroll: false\n};\nconst DefaultType$5 = {\n backdrop: '(boolean|string)',\n keyboard: 'boolean',\n scroll: 'boolean'\n};\n\n/**\n * Class definition\n */\n\nclass Offcanvas extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._isShown = false;\n this._backdrop = this._initializeBackDrop();\n this._focustrap = this._initializeFocusTrap();\n this._addEventListeners();\n }\n\n // Getters\n static get Default() {\n return Default$5;\n }\n static get DefaultType() {\n return DefaultType$5;\n }\n static get NAME() {\n return NAME$6;\n }\n\n // Public\n toggle(relatedTarget) {\n return this._isShown ? this.hide() : this.show(relatedTarget);\n }\n show(relatedTarget) {\n if (this._isShown) {\n return;\n }\n const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {\n relatedTarget\n });\n if (showEvent.defaultPrevented) {\n return;\n }\n this._isShown = true;\n this._backdrop.show();\n if (!this._config.scroll) {\n new ScrollBarHelper().hide();\n }\n this._element.setAttribute('aria-modal', true);\n this._element.setAttribute('role', 'dialog');\n this._element.classList.add(CLASS_NAME_SHOWING$1);\n const completeCallBack = () => {\n if (!this._config.scroll || this._config.backdrop) {\n this._focustrap.activate();\n }\n this._element.classList.add(CLASS_NAME_SHOW$3);\n this._element.classList.remove(CLASS_NAME_SHOWING$1);\n EventHandler.trigger(this._element, EVENT_SHOWN$3, {\n relatedTarget\n });\n };\n this._queueCallback(completeCallBack, this._element, true);\n }\n hide() {\n if (!this._isShown) {\n return;\n }\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);\n if (hideEvent.defaultPrevented) {\n return;\n }\n this._focustrap.deactivate();\n this._element.blur();\n this._isShown = false;\n this._element.classList.add(CLASS_NAME_HIDING);\n this._backdrop.hide();\n const completeCallback = () => {\n this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);\n this._element.removeAttribute('aria-modal');\n this._element.removeAttribute('role');\n if (!this._config.scroll) {\n new ScrollBarHelper().reset();\n }\n EventHandler.trigger(this._element, EVENT_HIDDEN$3);\n };\n this._queueCallback(completeCallback, this._element, true);\n }\n dispose() {\n this._backdrop.dispose();\n this._focustrap.deactivate();\n super.dispose();\n }\n\n // Private\n _initializeBackDrop() {\n const clickCallback = () => {\n if (this._config.backdrop === 'static') {\n EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);\n return;\n }\n this.hide();\n };\n\n // 'static' option will be translated to true, and booleans will keep their value\n const isVisible = Boolean(this._config.backdrop);\n return new Backdrop({\n className: CLASS_NAME_BACKDROP,\n isVisible,\n isAnimated: true,\n rootElement: this._element.parentNode,\n clickCallback: isVisible ? clickCallback : null\n });\n }\n _initializeFocusTrap() {\n return new FocusTrap({\n trapElement: this._element\n });\n }\n _addEventListeners() {\n EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {\n if (event.key !== ESCAPE_KEY) {\n return;\n }\n if (this._config.keyboard) {\n this.hide();\n return;\n }\n EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);\n });\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Offcanvas.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config](this);\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {\n const target = SelectorEngine.getElementFromSelector(this);\n if (['A', 'AREA'].includes(this.tagName)) {\n event.preventDefault();\n }\n if (isDisabled(this)) {\n return;\n }\n EventHandler.one(target, EVENT_HIDDEN$3, () => {\n // focus on trigger when it is closed\n if (isVisible(this)) {\n this.focus();\n }\n });\n\n // avoid conflict when clicking a toggler of an offcanvas, while another is open\n const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);\n if (alreadyOpen && alreadyOpen !== target) {\n Offcanvas.getInstance(alreadyOpen).hide();\n }\n const data = Offcanvas.getOrCreateInstance(target);\n data.toggle(this);\n});\nEventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {\n for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {\n Offcanvas.getOrCreateInstance(selector).show();\n }\n});\nEventHandler.on(window, EVENT_RESIZE, () => {\n for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {\n if (getComputedStyle(element).position !== 'fixed') {\n Offcanvas.getOrCreateInstance(element).hide();\n }\n }\n});\nenableDismissTrigger(Offcanvas);\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Offcanvas);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/sanitizer.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n// js-docs-start allow-list\nconst ARIA_ATTRIBUTE_PATTERN = /^aria-[\\w-]*$/i;\nconst DefaultAllowlist = {\n // Global attributes allowed on any supplied element below.\n '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],\n a: ['target', 'href', 'title', 'rel'],\n area: [],\n b: [],\n br: [],\n col: [],\n code: [],\n div: [],\n em: [],\n hr: [],\n h1: [],\n h2: [],\n h3: [],\n h4: [],\n h5: [],\n h6: [],\n i: [],\n img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],\n li: [],\n ol: [],\n p: [],\n pre: [],\n s: [],\n small: [],\n span: [],\n sub: [],\n sup: [],\n strong: [],\n u: [],\n ul: []\n};\n// js-docs-end allow-list\n\nconst uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);\n\n/**\n * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation\n * contexts.\n *\n * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38\n */\n// eslint-disable-next-line unicorn/better-regex\nconst SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i;\nconst allowedAttribute = (attribute, allowedAttributeList) => {\n const attributeName = attribute.nodeName.toLowerCase();\n if (allowedAttributeList.includes(attributeName)) {\n if (uriAttributes.has(attributeName)) {\n return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue));\n }\n return true;\n }\n\n // Check if a regular expression validates the attribute.\n return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName));\n};\nfunction sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {\n if (!unsafeHtml.length) {\n return unsafeHtml;\n }\n if (sanitizeFunction && typeof sanitizeFunction === 'function') {\n return sanitizeFunction(unsafeHtml);\n }\n const domParser = new window.DOMParser();\n const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');\n const elements = [].concat(...createdDocument.body.querySelectorAll('*'));\n for (const element of elements) {\n const elementName = element.nodeName.toLowerCase();\n if (!Object.keys(allowList).includes(elementName)) {\n element.remove();\n continue;\n }\n const attributeList = [].concat(...element.attributes);\n const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);\n for (const attribute of attributeList) {\n if (!allowedAttribute(attribute, allowedAttributes)) {\n element.removeAttribute(attribute.nodeName);\n }\n }\n }\n return createdDocument.body.innerHTML;\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/template-factory.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$5 = 'TemplateFactory';\nconst Default$4 = {\n allowList: DefaultAllowlist,\n content: {},\n // { selector : text , selector2 : text2 , }\n extraClass: '',\n html: false,\n sanitize: true,\n sanitizeFn: null,\n template: '
'\n};\nconst DefaultType$4 = {\n allowList: 'object',\n content: 'object',\n extraClass: '(string|function)',\n html: 'boolean',\n sanitize: 'boolean',\n sanitizeFn: '(null|function)',\n template: 'string'\n};\nconst DefaultContentType = {\n entry: '(string|element|function|null)',\n selector: '(string|element)'\n};\n\n/**\n * Class definition\n */\n\nclass TemplateFactory extends Config {\n constructor(config) {\n super();\n this._config = this._getConfig(config);\n }\n\n // Getters\n static get Default() {\n return Default$4;\n }\n static get DefaultType() {\n return DefaultType$4;\n }\n static get NAME() {\n return NAME$5;\n }\n\n // Public\n getContent() {\n return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean);\n }\n hasContent() {\n return this.getContent().length > 0;\n }\n changeContent(content) {\n this._checkContent(content);\n this._config.content = {\n ...this._config.content,\n ...content\n };\n return this;\n }\n toHtml() {\n const templateWrapper = document.createElement('div');\n templateWrapper.innerHTML = this._maybeSanitize(this._config.template);\n for (const [selector, text] of Object.entries(this._config.content)) {\n this._setContent(templateWrapper, text, selector);\n }\n const template = templateWrapper.children[0];\n const extraClass = this._resolvePossibleFunction(this._config.extraClass);\n if (extraClass) {\n template.classList.add(...extraClass.split(' '));\n }\n return template;\n }\n\n // Private\n _typeCheckConfig(config) {\n super._typeCheckConfig(config);\n this._checkContent(config.content);\n }\n _checkContent(arg) {\n for (const [selector, content] of Object.entries(arg)) {\n super._typeCheckConfig({\n selector,\n entry: content\n }, DefaultContentType);\n }\n }\n _setContent(template, content, selector) {\n const templateElement = SelectorEngine.findOne(selector, template);\n if (!templateElement) {\n return;\n }\n content = this._resolvePossibleFunction(content);\n if (!content) {\n templateElement.remove();\n return;\n }\n if (isElement(content)) {\n this._putElementInTemplate(getElement(content), templateElement);\n return;\n }\n if (this._config.html) {\n templateElement.innerHTML = this._maybeSanitize(content);\n return;\n }\n templateElement.textContent = content;\n }\n _maybeSanitize(arg) {\n return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;\n }\n _resolvePossibleFunction(arg) {\n return execute(arg, [this]);\n }\n _putElementInTemplate(element, templateElement) {\n if (this._config.html) {\n templateElement.innerHTML = '';\n templateElement.append(element);\n return;\n }\n templateElement.textContent = element.textContent;\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap tooltip.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$4 = 'tooltip';\nconst DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);\nconst CLASS_NAME_FADE$2 = 'fade';\nconst CLASS_NAME_MODAL = 'modal';\nconst CLASS_NAME_SHOW$2 = 'show';\nconst SELECTOR_TOOLTIP_INNER = '.tooltip-inner';\nconst SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;\nconst EVENT_MODAL_HIDE = 'hide.bs.modal';\nconst TRIGGER_HOVER = 'hover';\nconst TRIGGER_FOCUS = 'focus';\nconst TRIGGER_CLICK = 'click';\nconst TRIGGER_MANUAL = 'manual';\nconst EVENT_HIDE$2 = 'hide';\nconst EVENT_HIDDEN$2 = 'hidden';\nconst EVENT_SHOW$2 = 'show';\nconst EVENT_SHOWN$2 = 'shown';\nconst EVENT_INSERTED = 'inserted';\nconst EVENT_CLICK$1 = 'click';\nconst EVENT_FOCUSIN$1 = 'focusin';\nconst EVENT_FOCUSOUT$1 = 'focusout';\nconst EVENT_MOUSEENTER = 'mouseenter';\nconst EVENT_MOUSELEAVE = 'mouseleave';\nconst AttachmentMap = {\n AUTO: 'auto',\n TOP: 'top',\n RIGHT: isRTL() ? 'left' : 'right',\n BOTTOM: 'bottom',\n LEFT: isRTL() ? 'right' : 'left'\n};\nconst Default$3 = {\n allowList: DefaultAllowlist,\n animation: true,\n boundary: 'clippingParents',\n container: false,\n customClass: '',\n delay: 0,\n fallbackPlacements: ['top', 'right', 'bottom', 'left'],\n html: false,\n offset: [0, 6],\n placement: 'top',\n popperConfig: null,\n sanitize: true,\n sanitizeFn: null,\n selector: false,\n template: '
' + '
' + '
' + '
',\n title: '',\n trigger: 'hover focus'\n};\nconst DefaultType$3 = {\n allowList: 'object',\n animation: 'boolean',\n boundary: '(string|element)',\n container: '(string|element|boolean)',\n customClass: '(string|function)',\n delay: '(number|object)',\n fallbackPlacements: 'array',\n html: 'boolean',\n offset: '(array|string|function)',\n placement: '(string|function)',\n popperConfig: '(null|object|function)',\n sanitize: 'boolean',\n sanitizeFn: '(null|function)',\n selector: '(string|boolean)',\n template: 'string',\n title: '(string|element|function)',\n trigger: 'string'\n};\n\n/**\n * Class definition\n */\n\nclass Tooltip extends BaseComponent {\n constructor(element, config) {\n if (typeof Popper === 'undefined') {\n throw new TypeError('Bootstrap\\'s tooltips require Popper (https://popper.js.org)');\n }\n super(element, config);\n\n // Private\n this._isEnabled = true;\n this._timeout = 0;\n this._isHovered = null;\n this._activeTrigger = {};\n this._popper = null;\n this._templateFactory = null;\n this._newContent = null;\n\n // Protected\n this.tip = null;\n this._setListeners();\n if (!this._config.selector) {\n this._fixTitle();\n }\n }\n\n // Getters\n static get Default() {\n return Default$3;\n }\n static get DefaultType() {\n return DefaultType$3;\n }\n static get NAME() {\n return NAME$4;\n }\n\n // Public\n enable() {\n this._isEnabled = true;\n }\n disable() {\n this._isEnabled = false;\n }\n toggleEnabled() {\n this._isEnabled = !this._isEnabled;\n }\n toggle() {\n if (!this._isEnabled) {\n return;\n }\n this._activeTrigger.click = !this._activeTrigger.click;\n if (this._isShown()) {\n this._leave();\n return;\n }\n this._enter();\n }\n dispose() {\n clearTimeout(this._timeout);\n EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);\n if (this._element.getAttribute('data-bs-original-title')) {\n this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'));\n }\n this._disposePopper();\n super.dispose();\n }\n show() {\n if (this._element.style.display === 'none') {\n throw new Error('Please use show on visible elements');\n }\n if (!(this._isWithContent() && this._isEnabled)) {\n return;\n }\n const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));\n const shadowRoot = findShadowRoot(this._element);\n const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);\n if (showEvent.defaultPrevented || !isInTheDom) {\n return;\n }\n\n // TODO: v6 remove this or make it optional\n this._disposePopper();\n const tip = this._getTipElement();\n this._element.setAttribute('aria-describedby', tip.getAttribute('id'));\n const {\n container\n } = this._config;\n if (!this._element.ownerDocument.documentElement.contains(this.tip)) {\n container.append(tip);\n EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));\n }\n this._popper = this._createPopper(tip);\n tip.classList.add(CLASS_NAME_SHOW$2);\n\n // If this is a touch-enabled device we add extra\n // empty mouseover listeners to the body's immediate children;\n // only needed because of broken event delegation on iOS\n // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html\n if ('ontouchstart' in document.documentElement) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.on(element, 'mouseover', noop);\n }\n }\n const complete = () => {\n EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));\n if (this._isHovered === false) {\n this._leave();\n }\n this._isHovered = false;\n };\n this._queueCallback(complete, this.tip, this._isAnimated());\n }\n hide() {\n if (!this._isShown()) {\n return;\n }\n const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));\n if (hideEvent.defaultPrevented) {\n return;\n }\n const tip = this._getTipElement();\n tip.classList.remove(CLASS_NAME_SHOW$2);\n\n // If this is a touch-enabled device we remove the extra\n // empty mouseover listeners we added for iOS support\n if ('ontouchstart' in document.documentElement) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.off(element, 'mouseover', noop);\n }\n }\n this._activeTrigger[TRIGGER_CLICK] = false;\n this._activeTrigger[TRIGGER_FOCUS] = false;\n this._activeTrigger[TRIGGER_HOVER] = false;\n this._isHovered = null; // it is a trick to support manual triggering\n\n const complete = () => {\n if (this._isWithActiveTrigger()) {\n return;\n }\n if (!this._isHovered) {\n this._disposePopper();\n }\n this._element.removeAttribute('aria-describedby');\n EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));\n };\n this._queueCallback(complete, this.tip, this._isAnimated());\n }\n update() {\n if (this._popper) {\n this._popper.update();\n }\n }\n\n // Protected\n _isWithContent() {\n return Boolean(this._getTitle());\n }\n _getTipElement() {\n if (!this.tip) {\n this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());\n }\n return this.tip;\n }\n _createTipElement(content) {\n const tip = this._getTemplateFactory(content).toHtml();\n\n // TODO: remove this check in v6\n if (!tip) {\n return null;\n }\n tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);\n // TODO: v6 the following can be achieved with CSS only\n tip.classList.add(`bs-${this.constructor.NAME}-auto`);\n const tipId = getUID(this.constructor.NAME).toString();\n tip.setAttribute('id', tipId);\n if (this._isAnimated()) {\n tip.classList.add(CLASS_NAME_FADE$2);\n }\n return tip;\n }\n setContent(content) {\n this._newContent = content;\n if (this._isShown()) {\n this._disposePopper();\n this.show();\n }\n }\n _getTemplateFactory(content) {\n if (this._templateFactory) {\n this._templateFactory.changeContent(content);\n } else {\n this._templateFactory = new TemplateFactory({\n ...this._config,\n // the `content` var has to be after `this._config`\n // to override config.content in case of popover\n content,\n extraClass: this._resolvePossibleFunction(this._config.customClass)\n });\n }\n return this._templateFactory;\n }\n _getContentForTemplate() {\n return {\n [SELECTOR_TOOLTIP_INNER]: this._getTitle()\n };\n }\n _getTitle() {\n return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title');\n }\n\n // Private\n _initializeOnDelegatedTarget(event) {\n return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());\n }\n _isAnimated() {\n return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);\n }\n _isShown() {\n return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);\n }\n _createPopper(tip) {\n const placement = execute(this._config.placement, [this, tip, this._element]);\n const attachment = AttachmentMap[placement.toUpperCase()];\n return Popper.createPopper(this._element, tip, this._getPopperConfig(attachment));\n }\n _getOffset() {\n const {\n offset\n } = this._config;\n if (typeof offset === 'string') {\n return offset.split(',').map(value => Number.parseInt(value, 10));\n }\n if (typeof offset === 'function') {\n return popperData => offset(popperData, this._element);\n }\n return offset;\n }\n _resolvePossibleFunction(arg) {\n return execute(arg, [this._element]);\n }\n _getPopperConfig(attachment) {\n const defaultBsPopperConfig = {\n placement: attachment,\n modifiers: [{\n name: 'flip',\n options: {\n fallbackPlacements: this._config.fallbackPlacements\n }\n }, {\n name: 'offset',\n options: {\n offset: this._getOffset()\n }\n }, {\n name: 'preventOverflow',\n options: {\n boundary: this._config.boundary\n }\n }, {\n name: 'arrow',\n options: {\n element: `.${this.constructor.NAME}-arrow`\n }\n }, {\n name: 'preSetPlacement',\n enabled: true,\n phase: 'beforeMain',\n fn: data => {\n // Pre-set Popper's placement attribute in order to read the arrow sizes properly.\n // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement\n this._getTipElement().setAttribute('data-popper-placement', data.state.placement);\n }\n }]\n };\n return {\n ...defaultBsPopperConfig,\n ...execute(this._config.popperConfig, [defaultBsPopperConfig])\n };\n }\n _setListeners() {\n const triggers = this._config.trigger.split(' ');\n for (const trigger of triggers) {\n if (trigger === 'click') {\n EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => {\n const context = this._initializeOnDelegatedTarget(event);\n context.toggle();\n });\n } else if (trigger !== TRIGGER_MANUAL) {\n const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);\n const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);\n EventHandler.on(this._element, eventIn, this._config.selector, event => {\n const context = this._initializeOnDelegatedTarget(event);\n context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;\n context._enter();\n });\n EventHandler.on(this._element, eventOut, this._config.selector, event => {\n const context = this._initializeOnDelegatedTarget(event);\n context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);\n context._leave();\n });\n }\n }\n this._hideModalHandler = () => {\n if (this._element) {\n this.hide();\n }\n };\n EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);\n }\n _fixTitle() {\n const title = this._element.getAttribute('title');\n if (!title) {\n return;\n }\n if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {\n this._element.setAttribute('aria-label', title);\n }\n this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility\n this._element.removeAttribute('title');\n }\n _enter() {\n if (this._isShown() || this._isHovered) {\n this._isHovered = true;\n return;\n }\n this._isHovered = true;\n this._setTimeout(() => {\n if (this._isHovered) {\n this.show();\n }\n }, this._config.delay.show);\n }\n _leave() {\n if (this._isWithActiveTrigger()) {\n return;\n }\n this._isHovered = false;\n this._setTimeout(() => {\n if (!this._isHovered) {\n this.hide();\n }\n }, this._config.delay.hide);\n }\n _setTimeout(handler, timeout) {\n clearTimeout(this._timeout);\n this._timeout = setTimeout(handler, timeout);\n }\n _isWithActiveTrigger() {\n return Object.values(this._activeTrigger).includes(true);\n }\n _getConfig(config) {\n const dataAttributes = Manipulator.getDataAttributes(this._element);\n for (const dataAttribute of Object.keys(dataAttributes)) {\n if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {\n delete dataAttributes[dataAttribute];\n }\n }\n config = {\n ...dataAttributes,\n ...(typeof config === 'object' && config ? config : {})\n };\n config = this._mergeConfigObj(config);\n config = this._configAfterMerge(config);\n this._typeCheckConfig(config);\n return config;\n }\n _configAfterMerge(config) {\n config.container = config.container === false ? document.body : getElement(config.container);\n if (typeof config.delay === 'number') {\n config.delay = {\n show: config.delay,\n hide: config.delay\n };\n }\n if (typeof config.title === 'number') {\n config.title = config.title.toString();\n }\n if (typeof config.content === 'number') {\n config.content = config.content.toString();\n }\n return config;\n }\n _getDelegateConfig() {\n const config = {};\n for (const [key, value] of Object.entries(this._config)) {\n if (this.constructor.Default[key] !== value) {\n config[key] = value;\n }\n }\n config.selector = false;\n config.trigger = 'manual';\n\n // In the future can be replaced with:\n // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])\n // `Object.fromEntries(keysWithDifferentValues)`\n return config;\n }\n _disposePopper() {\n if (this._popper) {\n this._popper.destroy();\n this._popper = null;\n }\n if (this.tip) {\n this.tip.remove();\n this.tip = null;\n }\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Tooltip.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n });\n }\n}\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Tooltip);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap popover.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$3 = 'popover';\nconst SELECTOR_TITLE = '.popover-header';\nconst SELECTOR_CONTENT = '.popover-body';\nconst Default$2 = {\n ...Tooltip.Default,\n content: '',\n offset: [0, 8],\n placement: 'right',\n template: '
' + '
' + '

' + '
' + '
',\n trigger: 'click'\n};\nconst DefaultType$2 = {\n ...Tooltip.DefaultType,\n content: '(null|string|element|function)'\n};\n\n/**\n * Class definition\n */\n\nclass Popover extends Tooltip {\n // Getters\n static get Default() {\n return Default$2;\n }\n static get DefaultType() {\n return DefaultType$2;\n }\n static get NAME() {\n return NAME$3;\n }\n\n // Overrides\n _isWithContent() {\n return this._getTitle() || this._getContent();\n }\n\n // Private\n _getContentForTemplate() {\n return {\n [SELECTOR_TITLE]: this._getTitle(),\n [SELECTOR_CONTENT]: this._getContent()\n };\n }\n _getContent() {\n return this._resolvePossibleFunction(this._config.content);\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Popover.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n });\n }\n}\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Popover);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap scrollspy.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$2 = 'scrollspy';\nconst DATA_KEY$2 = 'bs.scrollspy';\nconst EVENT_KEY$2 = `.${DATA_KEY$2}`;\nconst DATA_API_KEY = '.data-api';\nconst EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;\nconst EVENT_CLICK = `click${EVENT_KEY$2}`;\nconst EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;\nconst CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';\nconst CLASS_NAME_ACTIVE$1 = 'active';\nconst SELECTOR_DATA_SPY = '[data-bs-spy=\"scroll\"]';\nconst SELECTOR_TARGET_LINKS = '[href]';\nconst SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';\nconst SELECTOR_NAV_LINKS = '.nav-link';\nconst SELECTOR_NAV_ITEMS = '.nav-item';\nconst SELECTOR_LIST_ITEMS = '.list-group-item';\nconst SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;\nconst SELECTOR_DROPDOWN = '.dropdown';\nconst SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';\nconst Default$1 = {\n offset: null,\n // TODO: v6 @deprecated, keep it for backwards compatibility reasons\n rootMargin: '0px 0px -25%',\n smoothScroll: false,\n target: null,\n threshold: [0.1, 0.5, 1]\n};\nconst DefaultType$1 = {\n offset: '(number|null)',\n // TODO v6 @deprecated, keep it for backwards compatibility reasons\n rootMargin: 'string',\n smoothScroll: 'boolean',\n target: 'element',\n threshold: 'array'\n};\n\n/**\n * Class definition\n */\n\nclass ScrollSpy extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n\n // this._element is the observablesContainer and config.target the menu links wrapper\n this._targetLinks = new Map();\n this._observableSections = new Map();\n this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;\n this._activeTarget = null;\n this._observer = null;\n this._previousScrollData = {\n visibleEntryTop: 0,\n parentScrollTop: 0\n };\n this.refresh(); // initialize\n }\n\n // Getters\n static get Default() {\n return Default$1;\n }\n static get DefaultType() {\n return DefaultType$1;\n }\n static get NAME() {\n return NAME$2;\n }\n\n // Public\n refresh() {\n this._initializeTargetsAndObservables();\n this._maybeEnableSmoothScroll();\n if (this._observer) {\n this._observer.disconnect();\n } else {\n this._observer = this._getNewObserver();\n }\n for (const section of this._observableSections.values()) {\n this._observer.observe(section);\n }\n }\n dispose() {\n this._observer.disconnect();\n super.dispose();\n }\n\n // Private\n _configAfterMerge(config) {\n // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case\n config.target = getElement(config.target) || document.body;\n\n // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only\n config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;\n if (typeof config.threshold === 'string') {\n config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value));\n }\n return config;\n }\n _maybeEnableSmoothScroll() {\n if (!this._config.smoothScroll) {\n return;\n }\n\n // unregister any previous listeners\n EventHandler.off(this._config.target, EVENT_CLICK);\n EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {\n const observableSection = this._observableSections.get(event.target.hash);\n if (observableSection) {\n event.preventDefault();\n const root = this._rootElement || window;\n const height = observableSection.offsetTop - this._element.offsetTop;\n if (root.scrollTo) {\n root.scrollTo({\n top: height,\n behavior: 'smooth'\n });\n return;\n }\n\n // Chrome 60 doesn't support `scrollTo`\n root.scrollTop = height;\n }\n });\n }\n _getNewObserver() {\n const options = {\n root: this._rootElement,\n threshold: this._config.threshold,\n rootMargin: this._config.rootMargin\n };\n return new IntersectionObserver(entries => this._observerCallback(entries), options);\n }\n\n // The logic of selection\n _observerCallback(entries) {\n const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`);\n const activate = entry => {\n this._previousScrollData.visibleEntryTop = entry.target.offsetTop;\n this._process(targetElement(entry));\n };\n const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;\n const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;\n this._previousScrollData.parentScrollTop = parentScrollTop;\n for (const entry of entries) {\n if (!entry.isIntersecting) {\n this._activeTarget = null;\n this._clearActiveClass(targetElement(entry));\n continue;\n }\n const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;\n // if we are scrolling down, pick the bigger offsetTop\n if (userScrollsDown && entryIsLowerThanPrevious) {\n activate(entry);\n // if parent isn't scrolled, let's keep the first visible item, breaking the iteration\n if (!parentScrollTop) {\n return;\n }\n continue;\n }\n\n // if we are scrolling up, pick the smallest offsetTop\n if (!userScrollsDown && !entryIsLowerThanPrevious) {\n activate(entry);\n }\n }\n }\n _initializeTargetsAndObservables() {\n this._targetLinks = new Map();\n this._observableSections = new Map();\n const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);\n for (const anchor of targetLinks) {\n // ensure that the anchor has an id and is not disabled\n if (!anchor.hash || isDisabled(anchor)) {\n continue;\n }\n const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element);\n\n // ensure that the observableSection exists & is visible\n if (isVisible(observableSection)) {\n this._targetLinks.set(decodeURI(anchor.hash), anchor);\n this._observableSections.set(anchor.hash, observableSection);\n }\n }\n }\n _process(target) {\n if (this._activeTarget === target) {\n return;\n }\n this._clearActiveClass(this._config.target);\n this._activeTarget = target;\n target.classList.add(CLASS_NAME_ACTIVE$1);\n this._activateParents(target);\n EventHandler.trigger(this._element, EVENT_ACTIVATE, {\n relatedTarget: target\n });\n }\n _activateParents(target) {\n // Activate dropdown parents\n if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {\n SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);\n return;\n }\n for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {\n // Set triggered links parents as active\n // With both
+ +
+ +
+ -
+
@@ -139,6 +140,8 @@
+ +

+