diff --git a/.buildinfo b/.buildinfo new file mode 100644 index 000000000..a53413005 --- /dev/null +++ b/.buildinfo @@ -0,0 +1,4 @@ +# 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: 9d07f5f3b0222b1686d473f94bc7f2b2 +tags: d77d1c0d9ca2f4c8421862c7c5a0d620 diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/_downloads/6229be9f124258df1996707054f6100a/backup.sh b/_downloads/6229be9f124258df1996707054f6100a/backup.sh new file mode 100644 index 000000000..0483ea712 --- /dev/null +++ b/_downloads/6229be9f124258df1996707054f6100a/backup.sh @@ -0,0 +1,73 @@ +#!/usr/bin/env bash +# +# 目的： 使用 rsync 命令备份指定目录 +# 作者： 姚家园、田冬冬 +# 最近修改日期： 2021年2月2日 +# +# 免责声明： +# 本脚本完全基于编写者在自己的计算机上备份文件的经验总结， +# 并不具备普遍适用性，仅供读者参考。 +# + +source="${HOME}" # 源目录 +backup="/mnt/seismo-learn/backup" # 备份目录（通常为移动硬盘的挂载目录） +log="${backup}/backup.log" # 备份目录下的备份日志 + +# 检查源目录 +if [ ! -d "${source}" ]; then # 源目录不存在，退出程序 + echo "[${source}] does not exist!" + exit +elif [ -z "$(ls ${source})" ]; then # 源目录是空目录，退出程序 + echo "[${source}] is empty!" + exit +fi + +# 列出需要备份的目录 +dirs=( ${source}/* ) # 备份源目录下所有子目录（不含隐藏目录和文件） +# dirs=( # 仅备份源目录下部分子目录 +# "${source}/src" +# "${source}/software" +# "${source}/codes" +# ) + +# 若备份目录不存在，则新建 +mkdir -p "${backup}" + +# 备份开始时间 +echo "## Backup begins at $(date +%F-%H:%M:%S)" >> "${log}" + +# 按序备份每个目录 +for dir in "${dirs[@]}"; do + echo -e "------------------------------------------\n" + echo -e "Backup ${dir}\n" + echo "Backup ${dir} at $(date +%F-%H:%M:%S)" >> "${log}" + rsync -av --delete "${dir}" "${backup}" +done + +# 备份结束时间 +echo -e "## Backup ends at $(date +%F-%H:%M:%S)\n\n" >> "${log}" + +# 检查备份目录下是否存在源目录下已删除的目录 +echo -e "\n++++++++++++++++++++++++++++++++++++++++++++\n" +echo -e "Backup is finished! Begin to check!\n" +flag=1 +dirs_backup=( ${backup}/* ) +for dir_backup in "${dirs_backup[@]}"; do + # 忽略备份日志 + dir_name=$(basename "${dir_backup}") + if [ "${dir_backup}" = "${log}" ]; then + continue + fi + + # 备份目录下存在源目录下已删除的目录 + if [ ! -d "${source}/${dir_name}" ]; then + echo "[${dir_name}] is deleted in [${source}] but is still in [${backup}]." + flag=0 + fi +done + +if [ ${flag} = 0 ]; then + echo "You may choose to delete them in [${backup}] later." +else + echo "Backup is successful!" +fi diff --git a/_downloads/fd344f99eea0ea4fffd8cb2335867dd1/backup.bat b/_downloads/fd344f99eea0ea4fffd8cb2335867dd1/backup.bat new file mode 100644 index 000000000..7f8fd4c1f --- /dev/null +++ b/_downloads/fd344f99eea0ea4fffd8cb2335867dd1/backup.bat @@ -0,0 +1,37 @@ +REM +REM Ŀģ ʹ robocopy ָĿ¼ +REM ߣ ־Զ +REM ޸ڣ 202127 +REM +REM +REM űȫڱдԼļϱļľܽᣬ +REM ߱ձԣ߲ο +REM + +REM ԴĿ¼ͱĿ¼ +REM D:\directoryD:\롢D:\ Ŀ : ҪݵԴĿ¼ +REM F:\backup : Ŀ¼ + +REM robocopy ѡ +REM /mir : Ŀ¼Ϊ Ŀ¼ɾĿ¼ԴĿ¼вڵļĿ¼ +REM /mt[:n] : ʹ n ߳̽ж̸߳ƣĬֵΪ 8n Ϊ 1ô 128 +REM 磬/mt ʾ 8 ̣߳/mt:4 ʾ 4 ߳ +REM Բο https://docs.microsoft.com/zh-cn/windows-server/administration/windows-commands/robocopy +REM ˽ robocopy ĸ÷磬Ҳʹб D õ +REM һЩѡ /R:10 /W:10 /A-:H /XD Config.Msi $RECYCLE.BIN + +REM ע +REM 1. űдģҪ ANSI ʽ롣 +REM 2. Ŀ¼ڿո񣬱ţ "D:\ Ŀ" + +echo " D:\directory F:\backup\directory" +robocopy D:\directory F:\backup\directory /mir /mt +pause + +echo " D:\ F:\backup\" +robocopy D:\ F:\backup\ /mir /mt +pause + +echo " D:\ Ŀ F:\backup\ Ŀ" +robocopy "D:\ Ŀ" "F:\backup\ Ŀ" /mir /mt +pause diff --git a/_images/az-baz.png b/_images/az-baz.png new file mode 100644 index 000000000..02a8c9519 Binary files /dev/null and b/_images/az-baz.png differ diff --git a/_images/body-wave-propagation.jpg b/_images/body-wave-propagation.jpg new file mode 100644 index 000000000..de2e4bca1 Binary files /dev/null and b/_images/body-wave-propagation.jpg differ diff --git a/_images/catalog-analysis_13_0.png b/_images/catalog-analysis_13_0.png new file mode 100644 index 000000000..58eec0b1f Binary files /dev/null and b/_images/catalog-analysis_13_0.png differ diff --git a/_images/catalog-analysis_15_0.png b/_images/catalog-analysis_15_0.png new file mode 100644 index 000000000..a1be7454c Binary files /dev/null and b/_images/catalog-analysis_15_0.png differ diff --git a/_images/catalog-analysis_7_0.png b/_images/catalog-analysis_7_0.png new file mode 100644 index 000000000..e65e0af29 Binary files /dev/null and b/_images/catalog-analysis_7_0.png differ diff --git a/_images/catalog-analysis_9_0.png b/_images/catalog-analysis_9_0.png new file mode 100644 index 000000000..e98eaba64 Binary files /dev/null and b/_images/catalog-analysis_9_0.png differ diff --git a/_images/catalog_11_0.png b/_images/catalog_11_0.png new file mode 100644 index 000000000..34b15bc00 Binary files /dev/null and b/_images/catalog_11_0.png differ diff --git a/_images/catalog_15_0.png b/_images/catalog_15_0.png new file mode 100644 index 000000000..9f649c253 Binary files /dev/null and b/_images/catalog_15_0.png differ diff --git a/_images/data-transimission.jpg b/_images/data-transimission.jpg new file mode 100644 index 000000000..f797409e9 Binary files /dev/null and b/_images/data-transimission.jpg differ diff --git a/_images/earthquake-depth.jpg b/_images/earthquake-depth.jpg new file mode 100644 index 000000000..d63590f2d Binary files /dev/null and b/_images/earthquake-depth.jpg differ diff --git a/_images/earthquake-distribution.jpg b/_images/earthquake-distribution.jpg new file mode 100644 index 000000000..d3b968012 Binary files /dev/null and b/_images/earthquake-distribution.jpg differ diff --git a/_images/earthquake-energy.jpg b/_images/earthquake-energy.jpg new file mode 100644 index 000000000..52cf1a9dc Binary files /dev/null and b/_images/earthquake-energy.jpg differ diff --git a/_images/earthquake-gr-law.jpg b/_images/earthquake-gr-law.jpg new file mode 100644 index 000000000..2b357cdde Binary files /dev/null and b/_images/earthquake-gr-law.jpg differ diff --git a/_images/epicenter-hypocenter.gif b/_images/epicenter-hypocenter.gif new file mode 100644 index 000000000..8385cb358 Binary files /dev/null and b/_images/epicenter-hypocenter.gif differ diff --git a/_images/fedora-setup-01.jpg b/_images/fedora-setup-01.jpg new file mode 100644 index 000000000..69d7b00a3 Binary files /dev/null and b/_images/fedora-setup-01.jpg differ diff --git a/_images/fedora-setup-02.jpg b/_images/fedora-setup-02.jpg new file mode 100644 index 000000000..f96994557 Binary files /dev/null and b/_images/fedora-setup-02.jpg differ diff --git a/_images/fedora-setup-03.jpg b/_images/fedora-setup-03.jpg new file mode 100644 index 000000000..fdcf982a1 Binary files /dev/null and b/_images/fedora-setup-03.jpg differ diff --git a/_images/fedora-setup-04.jpg b/_images/fedora-setup-04.jpg new file mode 100644 index 000000000..cb451352d Binary files /dev/null and b/_images/fedora-setup-04.jpg differ diff --git a/_images/fedora-setup-05.jpg b/_images/fedora-setup-05.jpg new file mode 100644 index 000000000..33b111b8d Binary files /dev/null and b/_images/fedora-setup-05.jpg differ diff --git a/_images/fedora-setup-06.jpg b/_images/fedora-setup-06.jpg new file mode 100644 index 000000000..d9beac296 Binary files /dev/null and b/_images/fedora-setup-06.jpg differ diff --git a/_images/fedora-setup-07.jpg b/_images/fedora-setup-07.jpg new file mode 100644 index 000000000..921ba1fc1 Binary files /dev/null and b/_images/fedora-setup-07.jpg differ diff --git a/_images/fedora-setup-08.jpg b/_images/fedora-setup-08.jpg new file mode 100644 index 000000000..6ceb3193f Binary files /dev/null and b/_images/fedora-setup-08.jpg differ diff --git a/_images/fedora-setup-09.jpg b/_images/fedora-setup-09.jpg new file mode 100644 index 000000000..1bb1a9b76 Binary files /dev/null and b/_images/fedora-setup-09.jpg differ diff --git a/_images/fedora-setup-10.jpg b/_images/fedora-setup-10.jpg new file mode 100644 index 000000000..17fa9b3cd Binary files /dev/null and b/_images/fedora-setup-10.jpg differ diff --git a/_images/fedora-setup-11.jpg b/_images/fedora-setup-11.jpg new file mode 100644 index 000000000..7219dd336 Binary files /dev/null and b/_images/fedora-setup-11.jpg differ diff --git a/_images/fedora-setup-12.jpg b/_images/fedora-setup-12.jpg new file mode 100644 index 000000000..017253c40 Binary files /dev/null and b/_images/fedora-setup-12.jpg differ diff --git a/_images/fedora-setup-13.jpg b/_images/fedora-setup-13.jpg new file mode 100644 index 000000000..40f351303 Binary files /dev/null and b/_images/fedora-setup-13.jpg differ diff --git a/_images/gmap-1.jpg b/_images/gmap-1.jpg new file mode 100644 index 000000000..150c92a37 Binary files /dev/null and b/_images/gmap-1.jpg differ diff --git a/_images/gmap-2.jpg b/_images/gmap-2.jpg new file mode 100644 index 000000000..a04883262 Binary files /dev/null and b/_images/gmap-2.jpg differ diff --git a/_images/gmap-3.jpg b/_images/gmap-3.jpg new file mode 100644 index 000000000..c06eab8bd Binary files /dev/null and b/_images/gmap-3.jpg differ diff --git a/_images/jupyter-notebook-1.jpg b/_images/jupyter-notebook-1.jpg new file mode 100644 index 000000000..2fb6da7ac Binary files /dev/null and b/_images/jupyter-notebook-1.jpg differ diff --git a/_images/jupyter-notebook-2.jpg b/_images/jupyter-notebook-2.jpg new file mode 100644 index 000000000..30e984b6a Binary files /dev/null and b/_images/jupyter-notebook-2.jpg differ diff --git a/_images/jupyter-notebook-3.jpg b/_images/jupyter-notebook-3.jpg new file mode 100644 index 000000000..4187fc12e Binary files /dev/null and b/_images/jupyter-notebook-3.jpg differ diff --git a/_images/jupyter-notebook-4.jpg b/_images/jupyter-notebook-4.jpg new file mode 100644 index 000000000..f4f85df52 Binary files /dev/null and b/_images/jupyter-notebook-4.jpg differ diff --git a/_images/jupyter-notebook-5.jpg b/_images/jupyter-notebook-5.jpg new file mode 100644 index 000000000..00084e872 Binary files /dev/null and b/_images/jupyter-notebook-5.jpg differ diff --git a/_images/linux-file-system-tree.png b/_images/linux-file-system-tree.png new file mode 100644 index 000000000..10626c5e2 Binary files /dev/null and b/_images/linux-file-system-tree.png differ diff --git a/_images/mda-1.jpg b/_images/mda-1.jpg new file mode 100644 index 000000000..2fbab1cec Binary files /dev/null and b/_images/mda-1.jpg differ diff --git a/_images/phase-name.jpg b/_images/phase-name.jpg new file mode 100644 index 000000000..79bdc4c76 Binary files /dev/null and b/_images/phase-name.jpg differ diff --git a/_images/prem.jpg b/_images/prem.jpg new file mode 100644 index 000000000..a2f1b554c Binary files /dev/null and b/_images/prem.jpg differ diff --git a/_images/seismic-waveform.png b/_images/seismic-waveform.png new file mode 100644 index 000000000..1ee5dd9e9 Binary files /dev/null and b/_images/seismic-waveform.png differ diff --git a/_images/seismograph.jpg b/_images/seismograph.jpg new file mode 100644 index 000000000..71198b99c Binary files /dev/null and b/_images/seismograph.jpg differ diff --git a/_images/seismology-overview.jpg b/_images/seismology-overview.jpg new file mode 100644 index 000000000..1467ca2c9 Binary files /dev/null and b/_images/seismology-overview.jpg differ diff --git a/_images/station_11_0.png b/_images/station_11_0.png new file mode 100644 index 000000000..044f745c5 Binary files /dev/null and b/_images/station_11_0.png differ diff --git a/_images/station_9_0.png b/_images/station_9_0.png new file mode 100644 index 000000000..bec3f4ee2 Binary files /dev/null and b/_images/station_9_0.png differ diff --git a/_images/surface-wave-propagation.jpg b/_images/surface-wave-propagation.jpg new file mode 100644 index 000000000..52bda3ab2 Binary files /dev/null and b/_images/surface-wave-propagation.jpg differ diff --git a/_images/travel-time-curve.jpg b/_images/travel-time-curve.jpg new file mode 100644 index 000000000..c8aeaeb8e Binary files /dev/null and b/_images/travel-time-curve.jpg differ diff --git a/_images/ubuntu-setup-1.jpg b/_images/ubuntu-setup-1.jpg new file mode 100644 index 000000000..98b9939e4 Binary files /dev/null and b/_images/ubuntu-setup-1.jpg differ diff --git a/_images/ubuntu-setup-2.jpg b/_images/ubuntu-setup-2.jpg new file mode 100644 index 000000000..ccf9bd790 Binary files /dev/null and b/_images/ubuntu-setup-2.jpg differ diff --git a/_images/ubuntu-setup-3.jpg b/_images/ubuntu-setup-3.jpg new file mode 100644 index 000000000..8a2b02eb6 Binary files /dev/null and b/_images/ubuntu-setup-3.jpg differ diff --git a/_images/ubuntu-setup-4.jpg b/_images/ubuntu-setup-4.jpg new file mode 100644 index 000000000..b371f9809 Binary files /dev/null and b/_images/ubuntu-setup-4.jpg differ diff --git a/_images/ubuntu-setup-5.jpg b/_images/ubuntu-setup-5.jpg new file mode 100644 index 000000000..0ae79fcd8 Binary files /dev/null and b/_images/ubuntu-setup-5.jpg differ diff --git a/_images/ubuntu-setup-6.jpg b/_images/ubuntu-setup-6.jpg new file mode 100644 index 000000000..1a299285d Binary files /dev/null and b/_images/ubuntu-setup-6.jpg differ diff --git a/_images/ubuntu-setup-7.jpg b/_images/ubuntu-setup-7.jpg new file mode 100644 index 000000000..aff5a9017 Binary files /dev/null and b/_images/ubuntu-setup-7.jpg differ diff --git a/_images/ubuntu-setup-8.jpg b/_images/ubuntu-setup-8.jpg new file mode 100644 index 000000000..eb7d7052d Binary files /dev/null and b/_images/ubuntu-setup-8.jpg differ diff --git a/_images/ubuntu-setup-9.jpg b/_images/ubuntu-setup-9.jpg new file mode 100644 index 000000000..69d74be01 Binary files /dev/null and b/_images/ubuntu-setup-9.jpg differ diff --git a/_images/usgs-catalog-1.jpg b/_images/usgs-catalog-1.jpg new file mode 100644 index 000000000..5329e9f3b Binary files /dev/null and b/_images/usgs-catalog-1.jpg differ diff --git a/_images/usgs-catalog-2.jpg b/_images/usgs-catalog-2.jpg new file mode 100644 index 000000000..d187633b4 Binary files /dev/null and b/_images/usgs-catalog-2.jpg differ diff --git a/_images/usgs-catalog-3.jpg b/_images/usgs-catalog-3.jpg new file mode 100644 index 000000000..50cdc0e30 Binary files /dev/null and b/_images/usgs-catalog-3.jpg differ diff --git a/_images/usgs-catalog-4.jpg b/_images/usgs-catalog-4.jpg new file mode 100644 index 000000000..29f0c54ee Binary files /dev/null and b/_images/usgs-catalog-4.jpg differ diff --git a/_images/ventoy-1.jpg b/_images/ventoy-1.jpg new file mode 100644 index 000000000..210da90a6 Binary files /dev/null and b/_images/ventoy-1.jpg differ diff --git a/_images/ventoy-2.jpg b/_images/ventoy-2.jpg new file mode 100644 index 000000000..b7fd92f61 Binary files /dev/null and b/_images/ventoy-2.jpg differ diff --git a/_images/ventoy-3.jpg b/_images/ventoy-3.jpg new file mode 100644 index 000000000..006040bc0 Binary files /dev/null and b/_images/ventoy-3.jpg differ diff --git a/_images/ventoy-4.jpg b/_images/ventoy-4.jpg new file mode 100644 index 000000000..d28fba5c5 Binary files /dev/null and b/_images/ventoy-4.jpg differ diff --git a/_images/ventoy-5.jpg b/_images/ventoy-5.jpg new file mode 100644 index 000000000..d94773423 Binary files /dev/null and b/_images/ventoy-5.jpg differ diff --git a/_images/waveform_13_0.png b/_images/waveform_13_0.png new file mode 100644 index 000000000..44c7058a2 Binary files /dev/null and b/_images/waveform_13_0.png differ diff --git a/_images/waveform_17_0.png b/_images/waveform_17_0.png new file mode 100644 index 000000000..ab6b6daa2 Binary files /dev/null and b/_images/waveform_17_0.png differ diff --git a/_images/waveform_21_0.png b/_images/waveform_21_0.png new file mode 100644 index 000000000..6882ce44e Binary files /dev/null and b/_images/waveform_21_0.png differ diff --git a/_images/waveform_9_0.png b/_images/waveform_9_0.png new file mode 100644 index 000000000..cb8180466 Binary files /dev/null and b/_images/waveform_9_0.png differ diff --git a/_images/workflow.jpg b/_images/workflow.jpg new file mode 100644 index 000000000..e6e6c9a96 Binary files /dev/null and b/_images/workflow.jpg differ diff --git a/_sources/best-practices/backup-Linux.md b/_sources/best-practices/backup-Linux.md new file mode 100644 index 000000000..c43e17ffc --- /dev/null +++ b/_sources/best-practices/backup-Linux.md @@ -0,0 +1,82 @@ +# Linux 数据备份 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-10-01 +- 预计阅读时间: 20 分钟 + +--- + +新买的移动硬盘的文件系统一般是 NTFS 或 exFAT。推荐将移动硬盘文件系统 +设置为 Linux 系统的常见格式 ext4，用于 Linux 下的文件备份。 +该格式在 Ubuntu、Debian、Fedora、CentOS 等 Linux 发行版下，可以保持文件权限。 +在 Linux 系统下，可以使用 `mkfs` 命令将移动硬盘设置为 Linux 文件系统。还可以 +使用 `e2label` 命令为移动硬盘设置卷标。 + +## rsync + +使用 `rsync` 命令进行备份十分方便。假设用户名为 seismo-learn，移动硬盘下的备份目录 +为 {file}`/mnt/seismo-learn/backup/` 。使用以下命令可以将家目录下的所有子目录和文件 +完整同步到备份目录下，此时备份目录是家目录的一个镜像: + +``` +$ rsync -av --delete /home/seismo-learn/ /mnt/seismo-learn/backup/ +``` + +:::{important} +以上命令中家目录 {file}`/home/seismo-learn/` 最后的斜杠非常重要。若没有这个斜杠 +（{file}`/home/seismo-learn`），则会把家目录本身同步到备份目录下， +即产生 {file}`/mnt/seismo-learn/backup/seismo-learn` 目录。 +::: + +`rsync` 命令的特色在于增量备份。这意味着只有第一次备份的时候需要花比较多的时间来 +同步文件，之后再使用该命令进行备份只会同步有改动的文件。假如一周只修改了一个文件， +那么同步的过程会在瞬间完成。 + +读者可以参考 Bash 脚本 {download}`backup.sh`。点击下载后，修改源目录、 +备份目录以及想要备份的子目录。然后按以下命令，修改文件权限为可执行， +并将脚本移至 {file}`~/bin` 目录下，就可以运行了: + +``` +# 修改可执行权限 +$ chmod +x backup.sh + +# 移动至 ~/bin/ 目录 +$ mv backup.sh ~/bin + +# 执行命令开始备份 +$ backup.sh +``` + +## DejaDup + +[DejaDup](https://wiki.gnome.org/Apps/DejaDup) 是一款很好的图形界面备份工具。 + +安装 DejaDup： + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install deja-dup +``` +::: + +:::{tab-item} CentOS +:sync: centos + +``` +$ sudo yum install deja-dup +``` +::: + +:::{tab-item} Ubuntu/Debian +:sync: ubuntu-debian + +``` +$ sudo apt update +$ sudo apt install deja-dup +``` +::: +:::: diff --git a/_sources/best-practices/backup-Windows.md b/_sources/best-practices/backup-Windows.md new file mode 100644 index 000000000..75f62c76f --- /dev/null +++ b/_sources/best-practices/backup-Windows.md @@ -0,0 +1,36 @@ +# Windows 数据备份 + +- 本节贡献者: {{赵志远}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-10-01 +- 预计阅读时间: 20 分钟 + +--- + +## robocopy + +使用 Windows 自带的 [robocopy](https://docs.microsoft.com/zh-cn/windows-server/administration/windows-commands/robocopy) +命令进行增量备份。这意味着只有第一次备份的时候需要花比较多的时间来同步文件，之后再使用该命令进行备份 +只会同步有改动的文件。假设要备份整个 D 盘，移动硬盘下的备份目录为 {file}`F:\\backup`。 +打开 CMD 或 PowerShell，使用以下命令可以将 D 盘同步到备份目录下，此时备份目录是 D 盘的一个镜像: + +``` +$ robocopy D:\ F:\backup /mir /mt /R:10 /W:10 /A-:H /XD Config.Msi $RECYCLE.BIN +``` + +:::{important} +以上命令中 D 盘盘符后的反斜杠（{file}`D:\\`）非常重要，省略的话可能无法备份整个 D 盘。 + +`/XD` 选项后的目录（如 {file}`Config.Msi`、{file}`$RECYCLE.BIN`） +在备份时被忽略。读者可以根据自己的实际情况把无法备份或者不想备份的目录添加到此选项后。 +::: + +读者可以参考 Batch 脚本 {download}`backup.bat`。点击下载后，修改源目录、备份目录以及想要 +备份的子目录。然后，双击该 Batch 脚本即可直接运行。也可以打开 CMD 或 PowerShell， +再输入 Batch 脚本名以运行脚本。 + +## Backup + +:::{warning} +本节尚未开始编写。读者可以参考 +使用 Windows 10 Backup，欢迎提供反馈。 +::: diff --git a/_sources/best-practices/backup-macOS.md b/_sources/best-practices/backup-macOS.md new file mode 100644 index 000000000..59aaf264a --- /dev/null +++ b/_sources/best-practices/backup-macOS.md @@ -0,0 +1,23 @@ +# macOS 数据备份 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-10-01 +- 预计阅读时间: 20 分钟 + +--- + +## Time Machine + +macOS 下最好用的备份工具当属 Time Machine（时间机器），其可以增量备份 macOS 下的文件， +能恢复到之前任意备份时刻的状态，并且操作简单。当然也可以使用 `rsync` 命令进行备份， +与 Linux 下相同。推荐使用 Time Machine 进行备份。 + +首先插入一块备用硬盘，按下 {kbd}`Command` + {kbd}`空格`，搜索“Disk Utility”并按下 +{kbd}`Enter` 键以打开磁盘工具。将移动硬盘格式化成 APFS（加密）格式，这也是 macOS Big Sur（11.x） +的默认格式。读者可以根据自身情况选择分区大小，推荐至少是 macOS 本身硬盘空间的两倍。 + +点击左上角的 Apple 图标，在“系统偏好设置”中，打开“时间机器”。选中“在菜单栏中显示时间机器”。 +点击“选择备份磁盘”，从可用磁盘列表中选择之前格式化的硬盘分区，然后选择“使用磁盘”即可。 +时间机器会立即开始备份。首次备份可能需要很长时间，之后只会同步有改动的文件。下次插入备份硬盘， +直接从菜单栏的时间机器菜单中选择“立即备份”即开始增量备份。可以选择“进入时间机器”，查看备份内容。 +如需还原备份文件，请参考官方支持[从备份恢复 Mac](https://support.apple.com/zh-cn/HT203981)。 diff --git a/_sources/best-practices/backup.md b/_sources/best-practices/backup.md new file mode 100644 index 000000000..da82c2901 --- /dev/null +++ b/_sources/best-practices/backup.md @@ -0,0 +1,48 @@ +# 数据备份 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2021-10-01 +- 预计阅读时间: 5 分钟 + +--- + +**备份！备份！备份！** + +尽管不经常发生，但电脑随时可能会坏掉或被盗，电脑硬盘也随时可能会出问题， +也可能不小心使用一个命令（如 `rm -r *`）把几个月的工作误删了。所以，备份非常重要， +不进行必要的备份是十分危险的。笔者和一些同行多次体验过数据误删或硬盘损坏 +又未备份带来的痛苦。 + +如果**文件非常重要**，丢失后**恢复难度极大**，或**恢复时间极长**， +强烈推荐备份一下。例如，毕业论文、脚本、代码、电脑配置文件、无法再次获取的数据、 +经过长时间处理得到的资料。 + +:::{warning} +日常科研工作中，电脑硬盘经常进行大量的读写操作，直接影响硬盘的寿命。我们的 +经验表明，电脑硬盘的平均寿命大约为 5 年。当然，硬盘的品质和使用情况不同， +其寿命也有所不同。 +::: + +备份策略简单概括有两种：（1）备份家目录或其部分子目录；（2）全盘备份。 + +不同备份策略的主要区别在于备份所需的硬盘空间和时间，以及电脑硬盘摔坏带来的损失。 +移动硬盘是最常见的备份设备，其特点是携带方便、价格便宜。近几年，移动硬盘发展迅速， +市场上常见的移动硬盘，其存储空间大小有 1 TB 到 5 TB（单价从 300 到 800 块左右）， +基本可以满足日常科研的备份需求。一般而言，第一次备份需要较长时间，后续的备份往往 +只同步改动过的文件，所需时间较短。考虑以上两点因素以及硬盘摔坏带来的精神和身体上的损失， +我们推荐备份家目录或者至少备份家目录下重要的子目录。有需求的用户可以考虑全盘备份。 + +有效的文件备份并不是简单的复制和同步文件。复制存储在同一个硬盘中的文件不是备份，硬盘 +一旦出现问题所有的文件都可能丢失。和计算机放在一块的移动硬盘可能因为火灾、盗窃等 +原因一起丢失。有效备份方案的几个核心特性是：版本控制、删除重复文件、安全性。 +对备份实施版本控制保证了用户可以从任何备份过的历史版本中恢复文件。删除源文件中的重复文件， +可以减少存储开销。在安全性方面，应该考虑他人需要什么工具和信息或者发生什么意外 +才会完全删除源文件和备份。此外，不要盲目信任备份方案，应该经常检查备份是否可以用来恢复文件。 + +除了使用移动硬盘备份文件以外，还可以将部分文件同时备份到云端，多一份保障。例如，将程序和脚本等 +推送到 [GitHub](https://github.com/) 上，将部分文件同步到网盘（如百度网盘、 +OneDrive、Google Drive、Dropbox、iCloud 等）。需要注意，若误删本地文件， +云端可能会同步这些“更改”；一些应用可能有时或永久无法登录，造成云端备份文件暂时或永久性丢失。 +因此，最好把云端备份当作本地移动硬盘备份的补充，而不是重要文件的唯一备份。 + +建议每隔一段时间（如每周）做一次备份。放假前、出差开会前，也建议备份一下。 diff --git a/_sources/best-practices/file-organization.md b/_sources/best-practices/file-organization.md new file mode 100644 index 000000000..9ec995611 --- /dev/null +++ b/_sources/best-practices/file-organization.md @@ -0,0 +1,155 @@ +# 文件管理 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-01-12 +- 预计阅读时间: 20 分钟 + +--- + +采用合理的策略管理电脑文件是非常重要的。不合理的文件管理方式会使你花费更多的时间 +去寻找文件，拖慢你的科研进度，还可能导致文件的大量冗余与误删。 +这一节，我们总结了自己在科研工作中关于文件组织与管理的经验，供读者参考。 + +本文主要面向 Linux 和 macOS 用户，下面提到的**家目录**在 Linux 下指的是 {file}`/home/用户名`， +在 macOS 下指的是 {file}`/Users/用户名`。 + +## 基本原则 + +本文的文件组织与管理遵循如下几条基本原则： + +1. 保持家目录干净整洁 +2. 所有科研相关的文档、代码、图片等均放在家目录的子目录下 +3. 家目录下的每个子目录都有特定的用途，用于放置特定的文件 + +## 目录结构 + +根据以上原则，推荐在家目录下建立如下子目录： + +- Linux 或 macOS 系统在安装后自动创建的常见目录： + + - [](Desktop) + - [](Documents) + - [](Downloads) + +- 为了满足日常科研需求，在家目录下新建的、用于存储科研相关文件的目录 + + - [](ref:software) + - [](src) + - [](codes) + - [](opt) + - [](bin) + - [](data) + - [](projects) + - [](workspace) + +- 根据需求创建的其他目录 + +## 目录用途 + +根据原则 3，家目录下的每个子目录应有特定的用途。下面将详细阐述每个子目录的用途， +以及哪些文件应该放在哪个子目录下。 + +(ref:software)= +### software + +该目录用于放置从网络上下载的软件包（如 SAC、GMT、TauP 等）的原始压缩包， +相当于一个备份。若压缩包数目较少，则所有软件压缩包都放在该目录下； +若压缩包数目很多，可以考虑根据软件的用途对软件进行分类，放在该目录的不同子目录下。 +同时建议在该目录下建一个 README 文件，记录软件的名称、用途、 +官方下载地址以及下载日期等。 + +(src)= +### src + +该目录用于放置别人提供的科研相关的软件源码，每个软件对应 {file}`~/src` 目录下的 +一个子目录。比如 fk、gCAP、distaz、GMT 等软件的源码都放在这里。 + +(codes)= +### codes + +该目录用于放置自己写的具有**通用性**的软件包。这些软件包可以实现某类特定的 +功能，且不局限于某一个特定的科研项目。 + +(opt)= +### opt + +推荐将地震学相关软件安装到 {file}`~/opt` 目录下，而不要安装到 +{file}`/opt/` 或 {file}`/usr/local` 下。 + +该目录下可放置两类科研相关软件： + +1. 无需编译即可直接使用的软件，如 SAC、TauP、SOD 等 +2. 需要编译并指定安装位置的软件，如 GMT + +(bin)= +### bin + +{file}`~/bin` 目录用于存放一些简单的可执行文件和工具型脚本。 +将该目录的路径加入到环境变量 **PATH** 中，则可以在终端或脚本中直接调用 +这些可执行文件与脚本。 + +可以基于如下原则决定是否要将某个可执行文件或脚本放在该目录下： + +1. 若某个软件包只提供了单个可执行文件，则可放在该目录下 +2. 若某个软件包的源码经过编译得到了单个可执行文件，则可将源码置于 {file}`~/src` + 目录下，而将可执行文件复制到 {file}`~/bin` 目录下，如 `distaz` +3. 自己写的一些常用工具型脚本（如定时备份脚本），可放在该目录下 +4. 某些软件安装在其他路径，但只需要用到其中一个命令（如 Matlab）。此时可以在 + 该目录下创建指向该命令的软链接。这样就不需要将该软件的安装路径添加到环境变量中了。 + +(data)= +### data + +顾名思义，该目录主要用于保存一些基本不会改变的“数据”文件，比如地震波形数据、 +中国国界线数据、中国断层数据、地震目录等。这些数据可以被多个不同的科研项目 +共用。 + +(projects)= +### projects + +该目录用于放置科研项目相关的文件，每个子目录对应一个科研项目。子目录下包含一个 +科研项目相关的数据、代码、脚本、图片、结果等。例如： + +- {file}`~/projects/NorthChina_MTZ` 是一个关于华北地区地幔过渡带的科研项目 +- {file}`~/projects/GlobalICB` 是一个关于全球内核边界结构的科研项目 + +(Desktop)= +### Desktop + +很多人习惯于将大量文件或当前在做的科研项目目录放在桌面上，这些都是不建议的方式。 + +桌面可以认为是另一个临时的文件夹。桌面上可以放置自己当前正在处理的一些文件， +比如正在做的幻灯片、正在填写的表格。一旦完成后，应将这些文件整理移动到其他目录下。 + +为了方便快速打开自己的科研项目目录，可以在桌面上建立一个指向当前在研项目 +（位于 {file}`~/projects` 目录的子目录下）的软链接/快捷方式。当这一科研项目 +已经做完后，即可从桌面上删除该软链接/快捷方式，而 {file}`~/projects` 目录下的 +项目目录则可以保持不动。 + +(Documents)= +### Documents + +用于存放个人文档。可自行根据自己的需求进一步创建子目录。 + +考虑到其他软件，如 Matlab、Zoom 等，也会在 {file}`~/Documents` 目录里创建子目录并 +写文件，读者也可以考虑不使用 {file}`~/Documents` 目录，而自行在家目录下建立其他 +用于存放个人文档的目录，比如目录 {file}`~/research` 用于存放科研相关的文档， +目录 {file}`~/life` 用于存放私人文档。 + +(Downloads)= +### Downloads + +这是浏览器下载的默认目录。该目录仅作为临时存放文件的地方。 +应不定期（比如每隔几天）清理不需要的文件，并将需要的文件（文章、软件包、图片等） +移动到相应的目录下。 + +(workspace)= +### workspace + +用于做临时测试或做一些简单实验的目录。 + +日常科研中，有时忘了某个语法或某个命令，需要做一些测试检查自己的代码是否正确； +或者需要试某个命令的不同参数，看看结果上有什么差异；或者新下载了某个软件包， +想要随便跑一跑看看是否是自己所需要的。此时，可以到专门的目录 {file}`~/workspace` +做这些测试。这样的好处在于，避免向自己的家目录、科研项目目录或其他目录下写入 +临时测试文件，同时在清理临时文件时也更加方便且不必担心误删其他重要文件。 diff --git a/_sources/best-practices/intro.md b/_sources/best-practices/intro.md new file mode 100644 index 000000000..ad9e62f4a --- /dev/null +++ b/_sources/best-practices/intro.md @@ -0,0 +1,10 @@ +# 简介 + +这一部分介绍我们在日常科研工作中整理和总结的一些经验，供读者参考。 + +欢迎地震学新手在实践中尝试这些经验总结，并再次整理、总结和分享。 +最后形成实践→整理→总结→再实践→再整理→再总结的良性循环。 + +> **实践是检验真理的唯一标准！** +> +> **整理和总结是提高科研生产率的有效催化剂！** diff --git a/_sources/best-practices/software-installation.md b/_sources/best-practices/software-installation.md new file mode 100644 index 000000000..6fdb8d479 --- /dev/null +++ b/_sources/best-practices/software-installation.md @@ -0,0 +1,92 @@ +# 软件安装 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-01-12 +- 预计阅读时间: 10 分钟 + +--- + +## 安装方式 + +Linux 或 macOS 系统下安装软件通常有如下几种方式： + +1. 使用系统自带的应用商店（App Store）在图形界面下安装软件 +2. 使用软件包管理器通过命令行安装软件。例如，Ubuntu/Debian 的 `apt`、 + Fedora 的 `dnf`、macOS 的 `brew`。这些软件包管理器既可以安装 + 官方源提供的软件，也可以安装可信赖的第三方源提供的软件 +3. 直接下载闭源软件或商业软件提供的二进制包进行安装，如 Linux 下的 `deb` + 和 `rpm`、macOS 下的 `dmg` +4. 某个编程语言的包，通常可以使用该编程语言自带的包管理工具进行安装，比如 + Python 语言的包管理器 `conda` 和 `pip` +5. 某些软件提供了二进制的压缩包，则解压后直接放在某个目录，然后修改环境变量 + **PATH** 即可使用 +6. 下载软件源码、编译并安装 + +绝大多数非科研类开源软件都可以通过方式 1–3 安装；多数闭源软件或商业软件 +都可以通过方式 1–3 和方式 5 安装；对于地震学科研软件而言， +通常可以通过方式 4（很多地震学软件是用 Python 语言写的，因而可以通过 `conda` +或 `pip` 安装）、方式 5 或方式 6 进行安装。 + +方式 1–4 会将软件安装到默认的位置，通常用户无法控制，也无需关心其具体安装位置。 +而对于方式 5 和 6，用户可选择将软件安装到任意位置。为了便于安装与管理科研 +相关软件，我们总结了如下实践经验。 + +## 安装路径 + +软件安装相关的路径如下： + +- {file}`~/software/`：存放软件的原始压缩包 +- {file}`~/opt/`：解压即用的软件、需源码编译并安装的软件 +- {file}`~/src/`：需源码编译的软件（含需源码编译并安装软件的源码目录） +- {file}`~/bin/`：简单的小工具软件，如单个源码文件编译链接后生成的可执行文件、 + 单个可执行文件以及工具型脚本 +- {file}`/opt/`：大多数闭源软件或商业软件、某些与地震学科研无关的软件、ARM 架构 + macOS 下的 Homebrew + +### 软件包 + +软件的原始压缩包可以保存在 {file}`~/software/` 目录下，相当于做一个备份， +如 {file}`~/software/TauP-2.4.5.tgz`。 + +### 解压即用的软件 + +某些软件提供了二进制包，可以解压即用，可安装在 {file}`~/opt/` 的子目录下， +如 {file}`~/opt/TauP`。 + +### 从源码编译的软件 + +需要从源码编译的软件，可将源码目录放在 {file}`~/src/` 的子目录下，如 {file}`~/src/fk`、 +{file}`~/src/GMT`、{file}`~/src/distaz`。 + +若该软件不需安装，则编译链接后生成的可执行文件在该软件目录下或其子目录 {file}`bin` 下， +如 {file}`~/src/fk`、{file}`~/src/CPS/bin`。如果该软件只是一个简单的小工具， +比如单个源码文件或单个可执行文件，则可以将生成的可执行文件复制至 {file}`~/bin/` 目录下， +如 {file}`~/bin/distaz`。 + +若该软件编译后需要安装，可安装在 {file}`~/opt/` 的子目录下，如 {file}`~/opt/GMT`。 + +### 闭源或商业软件 + +大多数闭源软件或商业软件可安装到 {file}`/opt/` 的子目录下，如 Matlab、Intel 编译器等。 +一般这也是闭源软件或商业软件的默认安装路径。某些与地震学科研无关的软件，比如 +文献管理软件 Mendeley 和 Zotero 均可安装到任意路径，也建议安装到 {file}`/opt/` 目录下。 + +## 关于 ~/opt/ 的说明 + +这里推荐将科研相关软件安装到 {file}`~/opt/` 目录下，而不是更常见的 {file}`/opt/` +或 {file}`/usr/local/` 目录，主要是基于如下几点考虑： + +- 某些包管理器使用了这些目录，比如非 ARM 架构 macOS 下的 Homebrew 的软件安装路径是 + {file}`/usr/local/`，macOS 的 MacPorts 的软件安装路径是 {file}`/opt/local/`。 + 历史上，该目录主要用于放置在本地编译并另行安装的程序，避免和 {file}`/usr/` + 目录下的系统自带版本冲突 +- {file}`/opt/` 目录一般用于安装非系统自带的、第三方预先编译并发行的独立软件包。 + 例如，某些闭源或商业软件（如 Matlab、Google Chrome、Google Earth）默认将软件 + 安装到 {file}`/opt/` 目录下。ARM 架构 macOS 下的 Homebrew 也被安装到该目录下 +- 地震学科研软件与其他软件属于不同的两类软件，因而将二者放在不同的目录下更合理 +- 对于使用服务器的用户而言，通常没有权限在 {file}`/opt/` 或 {file}`/usr/local/` 等 + 目录安装软件，因而服务器用户必须在家目录下安装软件。设定软件安装在 {file}`~/opt/` + 下使得用户在个人电脑和服务器上可以有完全相同的目录结构 +- 将所有科研相关软件的源码及二进制文件都放在家目录下，使得备份和还原变得更简单 + +基于以上理由，推荐将地震学科研软件安装在 {file}`~/opt/` 目录下。 diff --git a/_sources/best-practices/software.md b/_sources/best-practices/software.md new file mode 100644 index 000000000..4ab225c0f --- /dev/null +++ b/_sources/best-practices/software.md @@ -0,0 +1,179 @@ +# 高效率软件 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-11-20 +- 预计阅读时间: 10 分钟 + +--- + +这一节推荐一些可以提高日常效率的软件，供读者参考。 + +## dos2unix & unix2dos + +Windows 和 Linux/macOS 系统下，[文本文件的换行符](https://www.ruanyifeng.com/blog/2006/04/post_213.html)是不同的。 +`dos2unix` 和 `unix2dos` 是可以实现换行符转换的命令行工具。 +`dos2unix` 可以将 Windows 系统下的换行符转换为 Linux/macOS 系统下的换行符， +`unix2dos` 则反之。 + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install dos2unix +``` +::: + +:::{tab-item} Ubuntu +:sync: ubuntu + +``` +$ sudo apt install dos2unix +``` +::: + +:::{tab-item} macOS +:sync: macos + +``` +$ brew install dos2unix unix2dos +``` +::: +:::: + +## tldr + +[tldr](https://tldr.sh/) 是一个提供命令的常用用法和示例的命令行工具， +其功能与 UNIX 下的 `man` 命令相似，但其提供的输出更简单、更易读。 +使用如下命令安装 `tldr`： + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install tldr +``` +::: + +:::{tab-item} Ubuntu +:sync: ubuntu + +``` +$ sudo apt install tldr +``` +::: + +:::{tab-item} macOS +:sync: macos + +``` +$ brew install tldr +``` +::: +:::: + +## ack + +[ack](https://beyondgrep.com/) 是一个字符搜索工具，与 `grep` 命令类似。 +其专为搜索源代码设计，因而在日常编程中更加简单易用。使用如下命令安装 `ack`。 + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install ack +``` +::: + +:::{tab-item} Ubuntu +:sync: ubuntu + +``` +$ sudo apt install ack +``` +::: + +:::{tab-item} macOS +:sync: macos + +``` +$ brew install ack +``` +::: +:::: + +## 解压软件 + +Fedora/Ubuntu/macOS 系统自带的压缩解压工具可以识别并打开 Linux 下的常见压缩格式 +（如 `.tar.gz`、`.tar.bz2` 等），也支持 Windows 和 macOS 下的常见压缩格式 +（如 `.zip` 和 `.7z`），但默认不支持 `.rar` 格式。 +推荐安装解压软件 [The Unarchiver](https://theunarchiver.com/)，其支持几乎 +所有压缩格式。安装后即可通过双击直接解压 `.rar` 文件。 + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install unar +``` +::: + +:::{tab-item} Ubuntu +:sync: ubuntu + +``` +$ sudo apt install unar +``` +::: + +:::{tab-item} macOS +:sync: macos + +``` +$ brew install --cask the-unarchiver +``` +::: +:::: + +### 终端 + +Fedora/Ubuntu/macOS 自带了终端模拟器 Terminal，使用起来中规中矩。 +日常科研经常需要开好几个终端，切换和管理起来比较麻烦。 + +Linux 下的 [Terminator](https://gnome-terminator.org/) 和 +macOS 下的 [iTerm2](https://iterm2.com/) 相比于自带 Terminal 具有更多的功能， +比如支持水平和垂直分割窗格以及终端快速切换。 + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install terminator +``` +::: + +:::{tab-item} Ubuntu +:sync: ubuntu + +``` +$ sudo apt install terminator +``` +::: + +:::{tab-item} macOS +:sync: macos + +``` +$ brew install --cask iterm2 +``` +::: +:::: diff --git a/_sources/best-practices/vscode.md b/_sources/best-practices/vscode.md new file mode 100644 index 000000000..033338395 --- /dev/null +++ b/_sources/best-practices/vscode.md @@ -0,0 +1,113 @@ +# VS Code 使用教程 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2021-09-28 +- 预计花费时间: 30 分钟 + +--- + +:::{warning} +本节正在编写中，尚未完成。 +::: + +## 安装中文语言包 + +VS Code 的界面默认显示语言是英文，可以安装中文语言包。点击菜单栏“查看”后选择 +“命令面板”（快捷键：{kbd}`Ctrl` + {kbd}`Shift` + {kbd}`p`），接着输入 +“configure display language”并按 {kbd}`Enter` 键，然后选择“安装其他语言”。 +这时界面会跳转到插件商店并自动搜索其他语言，一般第一个就是中文， +即 “Chinese (Simplified) Language Pack for Visual Studio Code”，点击安装就行了。 +安装完之后自动重启，界面就变成中文了。 + +## 连接远程计算机 + +编辑远程计算机文件的传统方法是先使用 ssh 命令登录到远程计算机，然后在远程计算机中 +使用 vim 编辑器编辑文件。 + +现在，我们可以借助 VS Code 扩展包 Remote - SSH，使用 VS Code 编辑远程文件， +这极大地提高编辑效率。这里简要介绍如何安装和使用该扩展包，可以参考 VS Code +官方文档 [ssh](https://code.visualstudio.com/docs/remote/ssh) 了解详细用法。 + +1. 安装 Remote - SSH 扩展包 + + 在“扩展”中，搜索“Remote - SSH”，点击安装。 + + 安装完之后，左下角导航栏会多一个类似 `><` 的远程连接图标。之后可以通过 + 点击该图标来使用该扩展包。 + +2. 配置远程计算机的 SSH 主机 + + 一般情况下，远程计算机已安装 SSH 服务器，本地计算机已安装 SSH 客户端。 + 我们还需要配置基于密钥的认证，这也是 VS Code 官方推荐的认证方式。以下 + 命令假设本地和远程计算机都是 Linux 或 macOS 系统，远程计算机的 IP 地址是 + 192.168.1.100，用户在远程计算机中的用户名是 seismo-learn。 + 可以参考 [SSH 教程：SSH 密钥登录](https://wangdoc.com/ssh/key.html) + 进一步学习更详细的配置过程。 + + 本地计算机下，运行以下命令生成 SSH 密钥: + + ``` + $ ssh-keygen -t rsa -f ~/.ssh/id_rsa-remote-ssh + ``` + + 该命令产生的一对 SSH 密钥分别位于 {file}`~/.ssh/id_rsa-remote-ssh` 和 + {file}`~/.ssh/id_rsa-remote-ssh.pub` 文件中。 + 前者是私钥文件，不能泄露；后者是公钥文件，需要告诉远程计算机。 + + 运行以下命令将公钥复制到远程计算机中（需用户输入远程计算机的密码）: + + ``` + $ ssh-copy-id -i ~/.ssh/id_rsa-remote-ssh.pub seismo-learn@192.168.1.100 + ``` + + 该命令会把本地的公钥以追加的方式复制到远程计算机的 {file}`~/.ssh/authorized_keys` + 文件中，并给远程计算机中的用户家目录、{file}`~/.ssh` 目录以及 {file}`~/.ssh/authorized_keys` + 设置合适的权限。若远程计算机或本地计算机是 Windows 系统，请参考 + [Quick start: Using SSH keys](https://code.visualstudio.com/docs/remote/troubleshooting#_quick-start-using-ssh-keys) + 进行配置。 + + 在终端中输入以下命令，验证是否配置是否成功（即可以登录远程计算机）: + + ``` + $ ssh seismo-learn@192.168.1.100 + ``` + +3. 编辑远程文件 + + 点击左下角的远程连接图标，选择“Remote-SSH: Connect to Host”，输入 + 便可使用 VS Code 编辑远程计算机中的文件了。 + +4. 退出远程连接 + + 文件编辑完毕后，选择菜单栏“文件”中的“关闭远程连接”，或者直接关闭 VS Code， + 就可以退出远程连接。 + +:::{tip} +如果需要经常连接远程计算机，可以使用 SSH 配置文件。 + +在活动栏中选择“远程资源管理器”，点击“配置”后选择 {file}`~/.ssh/config` +配置文件，按照以下格式添加相关信息到该文件中: + +``` +Host seismology + User seismo-learn + HostName 192.168.1.100 + IdentityFile ~/.ssh/id_rsa-remote-ssh +``` + +第一列是关键词，如 Host、User、HostName、IdentityFile，第二列是对应的值。 +seismology 是用户自定义的远程主机标识，其他三个值同上文。可以按照该格式， +向该文件中添加多个远程计算机。 + +点击左下角的远程连接图标，选择“Remote-SSH: Connect to Host”，点击“seismology” +就可以登录远程计算机了。也可以通过“远程资源管理器”，点击“seismology”登录远程计算机。 +::: + +:::{tip} +如果远程计算机使用的 Shell 是 Bash，本地计算机是 Zsh，可能遇到无法启动 +VS Code 的终端的问题。此时，需要修改一下配置文件以正确启动终端。 + +打开命令面板，输入 Remote-SSH: Settings，搜索 terminal.integrated.shell.linux， +将 "/bin/zsh" 改为 "/bin/bash" 即可。详情请参考 +[microsoft/vscode-remote-release issues #38](https://github.com/microsoft/vscode-remote-release/issues/38) +::: diff --git a/_sources/best-practices/zsh.md b/_sources/best-practices/zsh.md new file mode 100644 index 000000000..32a857f7c --- /dev/null +++ b/_sources/best-practices/zsh.md @@ -0,0 +1,256 @@ +# Zsh 及其配置 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-01-21 +- 预计阅读时间: 20 分钟 + +--- + +Linux 下有很多 Shell，最常见的是 Bash，此外还有 Zsh、csh、ksh。推荐使用 Zsh。 + +Zsh 有如下特点： + +- 语法基本完全兼容于 Bash，一般用户完全体会不到其区别 +- Zsh 提供命令补全特性，比 Bash 的补全要更好用 +- 可配置性强 + +## 安装 Zsh + +在终端键入 `zsh --version`，若显示 Zsh 版本号，则表示 Zsh +已安装。否则需要安装 Zsh。 + +自 macOS Catalina（10.15）开始，macOS 系统默认的 Shell 已由 Bash 变为 Zsh。 + +Linux 用户可以使用如下命令安装 Zsh： + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install zsh +``` +::: + +:::{tab-item} CentOS +:sync: centos + +``` +$ sudo yum install zsh +``` +::: + +:::{tab-item} Ubuntu/Debian +:sync: ubuntu-debian + +``` +$ sudo apt install zsh +``` +::: +:::: + +通过如下命令设置默认 Shell 为 Zsh: + +``` +$ chsh -s $(which zsh) +``` + +`chsh` 命令修改的是登陆 Shell，因而需要退出当前用户并重新登陆， +用户的默认 Shell 就从 Bash 变成 Zsh 了。打开新的终端并键入 +`echo $SHELL`，查看当前 Shell，会显示 {file}`/bin/zsh`。 + +:::::{dropdown} chsh: command not found 错误 +:color: info +:icon: info + +若出现 `chsh: command not found` 错误，则需要安装 util-linux-user: + +::::{tab-set} + +:::{tab-item} Fedora +:sync: fedora + +``` +$ sudo dnf install util-linux-user +``` +::: + +:::{tab-item} CentOS +:sync: centos + +``` +$ sudo yum install util-linux-user +``` +::: +:::: +::::: + +Zsh 的配置文件为 {file}`~/.zshrc`。因而切换到 Zsh 后， +所有的 Shell 配置都不用写到 {file}`~/.bashrc`，而要写到 {file}`~/.zshrc` 中。 + +## Oh My Zsh + +Zsh 稍作配置会更加方便好用。[Oh My Zsh](https://ohmyz.sh/) 是由 Oh My Zsh 社区 +维护的一套 Zsh 配置文件，使用起来非常方便。一般用户直接使用该配置即可。 + +安装 Oh My Zsh: + +``` +$ sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" +``` + +该命令会创建 {file}`~/.oh-my-zsh` 目录，下载 Oh My Zsh 到该目录下，生成默认的 Zsh 配置文件 +{file}`~/.zshrc`，并备份老的配置到类似 {file}`~/.zshrc.pre-oh-my-zsh` 的文件中。 + +:::{note} +GitHub 在国内访问不畅，以上安装命令可能会由于网络问题而失败。若以上命令失败， +可直接打开脚本链接 ， +复制脚本内容到文本编辑器中（如 Visual Studio Code），保存到本地某目录下 +（如 {file}`~/Downloads` 目录）。然后进入该目录，运行脚本即可: + +``` +$ cd ~/Downloads +$ sh install.sh +``` +::: + +之后可以根据个人习惯修改配置文件 {file}`~/.zshrc`，如[设置主题](https://github.com/ohmyzsh/ohmyzsh#themes)、[启用插件](https://github.com/ohmyzsh/ohmyzsh#plugins) 等。 + +### 设置主题 + +修改配置文件 {file}`~/.zshrc` 中的变量 **ZSH_THEME** 即可使用不同的主题。例如， +可以设置: + +``` +ZSH_THEME="bira" +``` + +打开新的终端即可查看主题效果。 + +Oh My Zsh 自带了很多主题，位于 {file}`~/.oh-my-zsh/themes` 目录下，可以在线[预览主题效果](https://github.com/ohmyzsh/ohmyzsh/wiki/Themes)。 +用户也可以使用[外部主题](https://github.com/ohmyzsh/ohmyzsh/wiki/External-themes)。 + +### 启用插件 + +直接修改配置文件 {file}`~/.zshrc` 中的变量 **plugins** 便可启用插件: + +``` +plugins=( + sudo + extract + autojump + zsh-autosuggestions + zsh-syntax-highlighting +) +``` + +Oh My Zsh 自带了很多插件，位于 {file}`~/.oh-my-zsh/plugins` 目录下，也可以[在线查询](https://github.com/ohmyzsh/ohmyzsh/wiki/Plugins-Overview)。 +这里推荐几个常用的自带插件。 + +- [sudo 插件](https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/sudo)： + 按两下 {kbd}`ESC` 即可在当前命令前加上 `sudo` + +- [extract 插件](https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/extract)： + 使用 `x abc.zip` 语法即可解压几乎所有压缩文件，如 `.tar.gz`、`.tar.bz2`、`.zip`、 + `.7z`、`.rar` 等 + +- [autojump 插件](https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/autojump)： + 非常智能的目录快速切换工具 + + ``` + $ pwd + /home/seismo-learn + $ cd Desktop + $ cd /opt + $ cd /usr/local + + # 用 j 命令迅速从 /usr/local 跳转到与 des 匹配的目录，这里只有 Desktop 可以匹配 + $ j des + $ pwd + /home/seismo-learn/Desktop + ``` + + 启用 autojump 插件前，需提前安装 [autojump](https://github.com/wting/autojump): + + ::::{tab-set} + + :::{tab-item} Fedora + :sync: fedora + + ``` + $ sudo dnf install autojump-zsh + ``` + ::: + + :::{tab-item} CentOS + :sync: centos + + ``` + $ sudo yum install autojump-zsh + ``` + ::: + + :::{tab-item} Ubuntu/Debian + :sync: ubuntu-debian + + ``` + # 安装后，还要根据 /usr/share/doc/autojump/README.Debian 里的要求做进一步设置 + $ sudo apt install autojump + ``` + ::: + + :::{tab-item} macOS + :sync: macos + + ``` + $ brew install autojump + ``` + ::: + :::: + +除了 Oh My Zsh 自带的插件，还可以使用第三方插件，只需提前安装即可。这里推荐几个常用的。 + +- [zsh-autosuggestions 插件](https://github.com/zsh-users/zsh-autosuggestions)： + 命令自动补全插件，当输入命令的几个字母，它会自动根据历史输入进行自动补全 + + ``` + $ git clone https://github.com/zsh-users/zsh-autosuggestions ~/.oh-my-zsh/custom/plugins/zsh-autosuggestions + ``` + +- [zsh-syntax-highlighting 插件](https://github.com/zsh-users/zsh-syntax-highlighting)： + 高亮 Zsh 可用命令 + + ``` + $ git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ~/.oh-my-zsh/custom/plugins/zsh-syntax-highlighting + ``` + + 该插件需要位于配置文件 {file}`~/.zshrc` 中的插件列表的最后一位: + + ``` + plugins=([plugins...] zsh-syntax-highlighting) + ``` + + :::{note} + 某些主题下，一些插件可能无法正常使用。 + ::: + +## 从 Bash 迁移到 Zsh + +Linux 下通常使用 Bash 作为默认 Shell，因而很多软件的配置信息都会写在 +Bash 配置文件 `~/.bashrc` 中。将默认 Shell 切换到 Zsh 后，还需要将 Bash +配置文件中的软件配置迁移到 Zsh 中。 + +由于 Zsh 兼容 Bash 语法，对于大多数软件的配置，都可以直接从 `~/.bashrc` +复制粘贴到 `~/.zshrc` 中。 + +对于 Anaconda/Miniconda 用户，需要在 Bash 环境中重新执行 `conda` 初始化设置，即: + +``` +# 进入 bash 环境 +$ bash +# 在 bash 环境下执行 conda 初始化 +$ conda init zsh +# 返回 zsh 环境 +$ exit +``` diff --git a/_sources/bibliography.md b/_sources/bibliography.md new file mode 100644 index 000000000..d0fbdc939 --- /dev/null +++ b/_sources/bibliography.md @@ -0,0 +1,5 @@ +参考文献 +======== + +```{bibliography} +``` diff --git a/_sources/computer/command-line.md b/_sources/computer/command-line.md new file mode 100644 index 000000000..ba4f306a1 --- /dev/null +++ b/_sources/computer/command-line.md @@ -0,0 +1,79 @@ +# 命令行 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2021-03-01 +- 预计花费时间: 20 分钟 + +--- + +## 命令行与图形界面 + +地震学科研中，大部分时间使用的是命令行界面（**CLI**, **C**ommand **L**ine **I**nterface）， +有时也使用图形界面（**GUI**, **G**raphical **U**ser **I**nterface）。 +命令行基本以操作键盘为主，图形界面一般同时操作鼠标和键盘。图形界面上手简单， +各种常用功能显式可见，但是推荐在日常科研中使用和掌握命令行，原因如下： + +- 命令行更加高效。操作键盘比在键盘和鼠标之间来回切换更快 +- 命令行操作可编写成脚本，并重复使用，而图形界面下操作重复的时间成本较高 +- 命令行有时是唯一的选择。例如，登录远程服务器时，很少有图形化界面可供使用 +- 图形界面占用更多的系统资源 + +近几年，一些图形界面工具发展迅速，有时使用图形界面会更方便。例如，[Visual Studio Code](https://code.visualstudio.com/) +是当前最流行的图形界面文本编辑器之一，使用其进行编程或编辑文本十分高效。 + +## 终端 + +命令行一般需使用终端（Terminal）输入指令。日常使用的终端更确切的称谓应该是 +终端模拟器（Terminal Emulator）。用户可以在桌面或菜单栏中找到并点击 +“Terminal” 图标以启动终端，然后输入命令并按下 {kbd}`Enter` 键即可执行相应的命令: + +``` +# 使用 echo 命令输出 Hello World~ +$ echo "Hello World~" + +# 使用 exit 命令退出终端 +$ exit +``` + +## Shell + +从终端程序输入的指令，会被一个称为 Shell（壳）的程序接收，并进一步交给系统执行。 +几乎所有的 Linux 发行版都提供了一个叫 Bash 的 Shell，此外还有 Zsh、csh、ksh 等 Shell。 +熟悉 Linux 系统之后，推荐参考{doc}`《Zsh 及其配置实践经验》`安装和使用 Zsh。 + +打开终端后，通常会看到类似如下 Shell 提示符: + +``` +[seismo-learn@earth ~] $ +``` + +上例中的提示符由 seismo-learn（用户名）、@ 符号、earth（主机名）、~（表示家目录） +以及 \$ 美元符号组成。在不同的 Linux 发行版或不同的用户设置下，该提示符的样式有所不同。 + +接着就可以在终端中输入各种命令，Shell 会获取命令并交给系统执行: + +``` +# 查看变量 SHELL 的值，即当前 Shell 程序的名字 +[seismo-learn@earth ~] $ echo $SHELL +/bin/bash +``` + +为了简洁，本教程中的所有命令行只使用 `$` 符号表示 Shell 提示符。因而上面的示例 +在本教程中会写作: + +``` +# 查看变量 SHELL 的值，即当前 Shell 程序的名字 +$ echo $SHELL +/bin/bash +``` + +其中，以 `#` 符号开头的行为注释行，用于解释接下来的命令，用户无需输入。 +以 `$` 符号开头的行为命令行，用户需要在终端中键入该命令以执行。 +不以 `#` 符号和 `$` 符号开头的行，则为命令的输出信息（例如 `/bin/bash`）。 + +:::{tip} +1. 使用向上、向下箭头按键可以获取之前输入的命令 +2. 按住鼠标左键并拖动选中文本，或直接双击一个单词，就可以复制选中的文本或单词， + 随后按下鼠标中键，就可以将文本粘贴到光标所在的位置 +3. 输入命令或路径时按下 {kbd}`Tab` 键可自动补全 +::: diff --git a/_sources/computer/commands.md b/_sources/computer/commands.md new file mode 100644 index 000000000..e2fc99ddf --- /dev/null +++ b/_sources/computer/commands.md @@ -0,0 +1,623 @@ +# Linux 常用命令 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2021-04-04 +- 预计花费时间: 120 分钟 + +--- + +Linux/macOS 下有成百上千个命令，每个命令都有众多选项。一开始上手 Linux/macOS， +如果要学习这么多命令会让人发狂，而且根本记不住。其实，**命令不是背出来的而是用出来的**。 +我们只需要掌握少数常用命令的常用用法，遇到不熟悉的命令或用法再查询和学习即可。 +这一节就介绍一些常用命令的常用用法。用户可以通过如下方式查询更多命令及其用法。 + +1. 使用 [tldr](https://tldr.sh/) 命令查询 [**推荐**] + + `tldr` 是由社区维护的简化版的命令帮助文档。其以实例的方式展示了 + 大多数常用命令的常见用法，但某些命令可能还未编写。例如 `tldr mkdir` + 将显示 `mkdir` 命令的简单用法。 + +2. 使用 UNIX 提供的 `man` 命令查询 + + `man` 提供了命令的完整语法，因而通常比较冗长。例如 `man mkdir` 将 + 显示 `mkdir` 命令的完整语法。 + +3. 网页搜索相关命令 + + - 使用 Google 搜索 + - 在网站 中查询 + +___ + +::::{grid} 2 2 2 4 +:gutter: 4 4 3 3 + +:::{grid-item-card} 文件查看 +- [](cat) +- [](head) +- [](less) +- [](tail) +::: + +:::{grid-item-card} 文件处理 +- [](diff) +- [](gawk) +- [](grep) +- [](sed) +- [](sort) +- [](uniq) +- [](wc) +::: + +:::{grid-item-card} 文件搜索 +- [](find) +- [](locate) +::: + +:::{grid-item-card} 文件传输 +- [](rsync) +- [](scp) +::: + +:::{grid-item-card} 文件下载 +- [](wget) +::: + +:::{grid-item-card} 压缩与解压 +- [](tar) +::: + +:::{grid-item-card} 系统管理 +- [](df) +- [](du) +- [](sudo) +- [](top) +::: + +:::{grid-item-card} 远程登录 +- [](ssh) +::: +:::: + +(cat)= +## cat + +`cat` 命令的命名来源于 con**cat**enate（拼接）。该命令可以输出某个文件的 +内容，或将多个文件拼接起来: + +``` +# 将一个文件的内容输出到终端 +$ cat file + +# 输出文件内容并显示行号 +$ cat -n file + +# 将文件 file1 和 file2 拼接到一个文件 target_file 中 +$ cat file1 file2 > target_file +``` + +(diff)= +## diff + +`diff` 命令的命名来自 **diff**erence。该命令可以用来逐行比较两个文件的异同。 +我们用以下两个示例文件展示其用法: + +文件 {file}`file1` 中包含如下三行内容： +``` +seismo-learn +seismology +software +``` + +文件 {file}`file2` 中包含如下三行内容： +``` +seismo-learn +seismology101 +software +``` + +使用 `diff` 命令比较 {file}`file1` 和 {file}`file2` 的异同。结果显示，两个文件 +第二行不同，其他行是相同的: +``` +$ diff file1 file2 +2c2 +< seismology +--- +> seismology101 +``` + +(df)= +## df + +`df` 命令的命名来自 **d**isk **f**ree（可使用的硬盘空间）。 +该命令可以获取硬盘总空间、已使用空间、剩余空间等信息。 + +``` +$ df -h +Filesystem Size Used Avail Use% Mounted on +/dev/mapper/cl_ivantjuawinata-root 100G 86G 15G 86% / +devtmpfs 7.8G 0 7.8G 0% /dev +tmpfs 7.8G 114M 7.7G 2% /run +/dev/mapper/cl_ivantjuawinata-home 1.1T 904G 149G 86% /home +``` + +从输出中可以得知，{file}`/home` 分区总硬盘空间为 1.1 TB，已使用 904 GB，剩余 149 GB。 + +(du)= +## du + +`du` 命令的名字来自 **d**isk **u**sage（硬盘使用情况）。该命令用于查看 +文件和目录占用的硬盘空间。 + +查看当前目录所占硬盘空间（也可以在最后指定想查看的目录名）: + +``` +# 默认显示当前目录及其所有子目录所占硬盘空间 +$ du -h + +# 设置目录深度为 0，即只显示当前目录所占硬盘空间，不显示其任何子目录 +$ du -h -d 0 + +# 设置目录深度为 1，即只显示当前目录及其一级子目录所占硬盘空间 +$ du -h -d 1 +``` + +查看指定文件所占硬盘空间: + +``` +$ du -h file1.txt +``` + +(find)= +## find + +`find` 命令用来查找指定目录下的子目录和文件，并对找到的目录和文件执行特定操作。 +该命令功能强大，更多功能可以参考 [find 命令](https://man.linuxde.net/find/)。 + +``` +# 列出 ~/src 目录及其子目录下的所有目录和文件 +$ find ~/src + +# 查找 ~/src 目录及其子目录下以 .c 结尾的目录和文件 +$ find ~/src -name "*.c" + +# 查找 ~/src 目录及其子目录下以 .c 结尾的文件 +$ find ~/src -type f -name "*.c" +``` + +使用 `-delete` 选项可以直接删除查找的文件或目录: + +``` +# 查找 ~/src 目录及其子目录下以 .pyc 结尾的文件，并删除 +$ find ~/src -type f -name "*.pyc" -delete +``` + +`find` 的 `-exec` 选项可以调用其他系统命令直接对查找的结果进行处理: + +``` +# 递归查找 ~/src 目录以 .c 结尾的文件，并执行 grep 命令找出文件中含 seismo-learn 的行 +$ find ~/src -type f -name "*.c" -exec grep seismo-learn {} + +``` + +这个例子中，`{}` 与 `-exec` 选项结合，表示查找到的文件。我们还可以用 `-ok` +来代替 `-exec` 选项，二者的区别是 `-ok` 选项在执行后面的命令前会给出提示， +输入 {kbd}`y` 才会执行，输入 {kbd}`n` 则不执行。 + +(gawk)= +## gawk + +`awk` 命令的命名起源于其三位作者的姓氏首字母。该命令可以选择标准输入、其他命令的 +输出或文件中的特定字段并进行操作。它依次扫描每一行，并读取里面的每一个字段。 +可以参考 +[Bash 脚本教程: awk](https://www.bookstack.cn/read/bash-tutorial/docs-archives-commands-awk.md) +学习其更多用法。 + +`gawk` 是 GNU 版本的 `awk` 命令。通常建议直接使用 `gawk` 而非 `awk`， +尽管在 Linux 系统下，`awk` 命令一般是指向 `gawk` 命令的软链接。 + +``` +# 将一个文件的每一行输出到标准输出。 $0 表示当前行 +$ gawk '{print $0}' file + +# 将一个文件的每一行的第 1 个和第 3 个字段输出到标准输出（字段的默认分隔符是空格和制表符） +$ gawk '{print $1,$3}' file + +# 同上，但跳过第 1-2 行，从第 3 行开始。FNR 为当前行的行数 +$ gawk 'FNR>2 {print $1,$3}' file + +# 将 /etc/passwd 每一行的第 1 个和第 3 个字段输出到标准输出，并设置字段分隔符为冒号 +$ gawk -F ':' '{print $1,$3}' /etc/passwd + +# 同上，并输出每一行的行号 +$ gawk -F ':' '{print NR,$1,$3}' /etc/passwd +``` + +(grep)= +## grep + +`grep` 命令的命名来自 **g**lobally search a **re**gular expression and **p**rint +（以正则表达式进行全局搜索并输出）。它是一个强大的文本搜索工具，可以搜索文件中 +与指定模式匹配的行并输出: + +``` +# 搜索并输出 /etc/passwd 中含有 root 的行 +$ grep root /etc/passwd + +# 同上，并显示行号 +$ grep -n root /etc/passwd + +# 搜索并输出 /etc/passwd 中不含有 root 的行 +$ grep -v root /etc/passwd +``` + +(head)= +## head + +`head` 命令用于输出文件开头部分的内容: + +``` +# 输出 /etc/passwd 的前 10 行 +$ head /etc/passwd + +# 输出 /etc/passwd 的前 5 行 +$ head -n 5 /etc/passwd +``` + +(less)= +## less + +`less` 命令可以用来浏览文件内容，其与 `cat` 功能相似，但允许用户向前或向后浏览文件： +按 {kbd}`PageUp` 键向上翻页，用 {kbd}`PageDown` 键向下翻页， +按 {kbd}`Enter` 键或向下方向键则向下移动，用向上方向键则向上移动， +按 {kbd}`q` 键退出浏览。 + +``` +# 浏览 /etc/passwd +$ less /etc/passwd + +# 同上，并显示行号 +$ less -N /etc/passwd +``` + +(locate)= +## locate + +`locate` 命令可以用于查找目录和文件。该命令比 [](find) 命令快得多，原因在于它 +不搜索具体目录，而是直接搜索含有本地所有文件信息的数据库: + +``` +# 搜索名称含 passwd 的目录或文件 +$ locate passwd + +# 搜索名称含 /etc/sh 的目录或文件（包括了 /etc 目录下所有以 sh 开头的目录或文件） +$ locate /etc/sh + +# 搜索名称含 ~/Des 的目录或文件（包括了家目录下，所有以 Des 开头的目录或文件） +$ locate ~/Des + +# 同上，但忽略大小写 +$ locate -i ~/des +``` + +该命令所需的数据库是系统自动创建的，每天自动更新。因此，`locate` 命令查不到 +最新变动过的文件。可以执行 `updatedb` 命令手动更新数据库，但是 `updatedb` +命令的执行过程较长: + +``` +# Linux +$ sudo updatedb + +# macOS 系统可以使用以下命令 +$ sudo /usr/libexec/locate.updatedb +``` + +(rsync)= +## rsync + +`rsync` 命令的命名来自 **r**emote **sync**hronization（远程同步）。该命名 +可以用于同步文件，可以是两个本地目录之间，也可以是本地计算机与远程计算机之间。 +与其他文件传输工具（如 [](scp)）不同，`rsync` 命令仅传输有变动的部分。因此， +同步速度更快，常用于文件备份。可以参考 +[SSH 教程：rsync 命令](https://wangdoc.com/ssh/rsync.html) +进一步学习其用法。 + +以下示例假设源目录是 {file}`~/Downloads/source`，目标目录是 {file}`~/workspace/destination`， +远程电脑的 IP 地址是 192.168.1.100，用户名是 seismo-learn。 + +同步两个本地目录: + +``` +# 将源目录同步到目标目录下。~/workspace/destination/source 成为源目录的一个镜像 +$ rsync -av --delete ~/Downloads/source ~/workspace/destination + +# 将源目录下的文件和目录同步到目标目录下。~/workspace/destination 成为源目录的一个镜像 +# 该命令与上一命令相比，在源目录的结尾多了一个反斜杠 "/" +$ rsync -av --delete ~/Downloads/source/ ~/workspace/destination + +# 若只想查看命令执行效果，不真的执行命令，可以使用 -n 选项。例如 +$ rsync -anv ~/Downloads/source ~/workspace/destination +``` + +同步本地源目录到远程计算机的目标目录下: + +``` +$ rsync -av --delete ~/Downloads/source seismo-learn@192.168.1.100:~/workspace/destination +``` + +同步远程计算机的源目录本地目标目录下: + +``` +$ rsync -av --delete seismo-learn@192.168.1.100:~/Downloads/source ~/workspace/destination +``` + +具体解释以下几个常用选项： + +- `-a` 选项表示以归档方式传输文件，并保持所有文件属性 +- `-v` 选项表示将执行过程输出到终端，用于查看哪些内容正在被同步 +- `--delete` 选项表示删除目标目录下那些不存在于源目录下的文件和目录， + 实现源目录和目标目录的同步 +- `-n` 选项表示不执行命令，但模拟执行结果，可用于检测命令的运行是否符合预期 + +(scp)= +## scp + +`scp` 命令的命名来源于 **s**ecure **c**o**p**y（安全复制），可用于本地 +和远程计算机之间传输文件。该命令基于 [](ssh) 进行安全的远程文件传输，因此传输是加密的。 +虽然 `scp` 传输速度不如 [](rsync) 命令，但是它不占系统资源。当需要传输大量小文件时， +使用 [](rsync) 命名会导致硬盘 I/O（输入/输出）非常高，而 `scp` 基本不影响系统 +正常使用。可以参考 +[SSH 教程：scp 命令](https://wangdoc.com/ssh/scp.html) +进一步学习其用法。 + +以下命令假定远程电脑的 IP 地址是 192.168.1.100，用户名是 seismo-learn: + +``` +# 复制远程文件或目录 /home/seismo-learn/file-or-folder 到本地目录 ~/Downloads 下 +$ scp -r seismo-learn@192.168.1.100:/home/seismo-learn/file-or-folder ~/Downloads/ + +# 上传本地文件或目录 ~/Downloads/file-or-folder 到远程目录 home/seismo-learn/folder2 +$ scp -r ~/Downloads/file-or-folder seismo-learn@192.168.1.100:/home/seismo-learn/folder2/ +``` + +(sed)= +## sed + +`sed` 命令的名字来源于 **s**tream **ed**itor（流编辑器）。该命令可以用于 +对输入流（文件或管道）执行基本的文本转换。它会把当前处理的行存储在临时缓冲区中 +再进行处理，处理完成后再把缓冲区的内容送往屏幕。接着处理下一行，直到文件末尾。 +因此默认情况下，文件内容并没有改变: + +``` +# 将 file 中每一行的第一个 book 替换成 books +$ sed 's/book/books/' file + +# 将 file 中每一行的所有的 book 都替换成 books +$ sed 's/book/books/g' file + +# 以上命令只是将转换后的文本内容输出出来，并未改变文件本身。可以使用 -i 选项直接改变文件 +$ sed -i 's/book/books/g' file + +# 以上命令使用斜杠 / 当定界符，也可以使用任意定界符，比如 # +$ sed 's#book#books#' file +$ sed 's#book#books#g' file +$ sed -i 's#book#books#g' file +``` + +需要注意，macOS 提供的 BSD `sed` 的语法很不同。建议 macOS 用户使用 Homebrew +安装 `gnu-sed`，并将以上命令替换为 `gsed`。 + +(sort)= +## sort + +`sort` 命令可以将文件内容进行排序，并输出排序结果。该命令将文件的每一行作为 +一个单位，相互比较。默认的比较原则是从首字符向后，依次按 ASCII 码值进行比较， +最后将他们按排序结果输出。 + +``` +# 按 ASCII 码值进行升序排序 +$ sort seismo-learn-sort.txt + +# 按 ASCII 码值进行降序排序 +$ sort -r seismo-learn-sort.txt + +# 按 ASCII 码值进行升序排序，并忽略相同行（即重复行只统计一次） +$ sort -u seismo-learn-sort.txt + +# 按 ASCII 码值进行降序排序，并忽略相同行 +$ sort -u -r seismo-learn-sort.txt +# 不同选项也可以写在一块 +# sort -ur seismo-learn-sort.txt + +# 按数值大小进行升序排序 +$ sort -n seismo-learn-sort.txt + +# 按第三列 ASCII 码值进行升序排列 +$ sort -k3,3 seismo-learn-sort.txt + +# 按第三列的数值大小进行升序排列 +$ sort -k3,3n seismo-learn-sort.txt + +# 按第三列的数值大小进行降序排列 +$ sort -k3,3nr seismo-learn-sort.txt +``` + +(ssh)= +## ssh + +`ssh` 命令的命名源于 **S**ecure **Sh**ell（安全外壳协议，简称 SSH）， +该协议是一种加密的网络传输协议。使用 `ssh` 命令可以登录到远程计算机中。 +常用于登录服务器提交计算任务。可以参考 +[SSH 教程：SSH 基本知识](https://wangdoc.com/ssh/key.html) +进一步学习其用法。 + +若远程计算机的 IP 地址是 192.168.1.100，用户名是 seismo-learn: + +``` +# 登录远程计算机 +$ ssh seismo-learn@192.168.1.100 + +# 登录远程计算机并打开图形界面（需要配置远程计算上的 ssh 服务器配置） +$ ssh -X seismo-learn@192.168.1.100 +``` + +(sudo)= +## sudo + +用户可以随意对家目录下的文件进行任何读、写以及删除等操作，但却无法对根目录下的 +文件进行类似操作。这是因为 Linux 下有严格的权限机制，只允许 root 用户（即管理员） +对根目录下的文件进行操作，以防止一般用户的操作对系统造成破坏。有些时候， +为安装软件或者修改系统配置文件，需要临时获取 root 用户权限。此时可以在需要执行的 +命令前加上 `sudo`。例如，在 Fedora 下使用 dnf 命令安装 GNU Fortran: + +``` +$ sudo dnf install gcc-gfortran +``` + +(tail)= +## tail + +`tail` 命令用于输出文件尾部内容: + +``` +# 输出 /etc/passwd 的后 10 行 +$ tail /etc/passwd + +# 输出 /etc/passwd 的后 5 行 +$ tail -n 5 /etc/passwd +``` + +(tar)= +## tar + +`tar` 命令的名字来自 **t**ape **ar**chive（磁带存档），因为该命令最初被 +用来在磁带上创建档案。该命令可以把一大堆文件和目录打包成一个文件，并且可以 +对该文件进行压缩。这对于备份文件或将几个文件组合成一个文件以便于网络传输是非常有用的。 + +首先要弄清两个概念：打包和压缩。打包是指将一大堆文件或目录打包成一个文件，而压缩 +则是将一个大文件通过一些压缩算法变成一个小文件。Linux 中的很多压缩程序只能压缩 +单个文件，若想压缩一大堆文件，首先得将这一大堆文件打成一个包（使用 `tar` 命令）， +再用压缩程序进行压缩（使用 `gzip` 或 `bzip2` 命令）。使用 `tar` 命令时， +可以直接选择压缩打包的文件，无需再单独使用压缩程序进行压缩。 + +``` +# 将 file1 和 file2 打包并用 gzip 命令进行压缩，文件命名为 seismo-learn.tar.gz。 +$ tar -zcvf seismo-learn.tar.gz file1 file2 + +# 打包并用 bzip2 命令进行压缩。一般用 .tar.bz2 或 .tbz 来作文件标识 +$ tar -jcvf seism-learn.tar.bz2 file1 file2 + +# 列出压缩包中的文件和目录 +$ tar -tvf seismo-learn.tar.gz + +# 解压一个压缩包，默认解压到当前目录下 +$ tar -xvf seismo-learn.tar.gz + +# 解压到 bak 目录下（该目录必须存在） +$ mkdir bak +$ tar -xvf seismo-learn.tar.gz -C bak +``` + +以上查看和解压命令也适用于 {file}`.tar` 和 {file}`tar.bz2` 压缩包格式。 + +以上示例使用的 `-v` 选项会显示指令执行过程，若不想显示执行过程，可以不使用该选项。 + +(top)= +## top + +`top` 命令的名字来自 **t**able **o**f **p**rocesses（进程表）。 +该命令可以实时动态地查看系统的整体运行情况，是一个综合了多方信息， +监测系统性能和运行信息的实用工具。 + +``` +$ top +top - 14:31:52 up 29 days, 14:02, 5 users, load average: 0.32, 0.51, 0.49 +Tasks: 328 total, 1 running, 327 sleeping, 0 stopped, 0 zombie +%Cpu(s): 1.0 us, 0.5 sy, 0.0 ni, 98.6 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st +KiB Mem : 16320540 total, 2548620 free, 6057748 used, 7714172 buff/cache +KiB Swap: 17821692 total, 17444092 free, 377600 used. 8252436 avail Mem + + PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND +120901 seismo-learn 20 0 5027300 88404 45736 S 2.0 0.5 0:20.05 chrome + 2158 seismo-learn 20 0 4355124 444384 57984 S 1.0 2.7 1581:35 gnome-shell +148103 seismo-learn 20 0 911924 82504 26180 S 1.0 0.5 4:04.09 terminator +``` + +`top` 命令执行过程中可以使用的一些单字母或数字的交互命令: + +- `q`：退出命令 +- `1`：显示每个 CPU 的状态 + +(uniq)= +## uniq + +`uniq` 命令的命名源于 **uniq**ue（唯一），可以用于忽略或查询文件中的重复行。 +如果重复行不相邻，则该命令不起作用。所以，`uniq` 命令一般与 [](sort) 命令结合使用。 +以下命令假设示例文件已经按行排序，即重复行相邻。 + +``` +# 输出 file 中非重复和重复行，但重复行只输出一次 +$ uniq file +# 以上命令等同于以下命令 +$ sort -u file + +# 同上，同时输出各行在文件中出现的次数 +$ uniq -c file + +# 只输出 file 中非重复的行 +$ uniq -u file + +# 只输出 file 中重复的行 +$ uniq -d file +``` + +若重复行在文件中不相邻，可以使用 [](sort) 命令先对文件进行排序: + +``` +$ sort file | uniq +# 以上命令等同于以下命令 +$ sort -c file + +$ sort file | uniq -c +$ sort file | uniq -u +$ sort file | uniq -d +``` + +(wc)= +## wc + +`wc` 命令的名字来自 **w**ord **c**ount（字数）。该命令可以输出文件或标准输入的 +行数、单词数以及字节数: + +``` +# 输出统计 /etc/passwd 的行数、单词数以及字节数 +$ wc /etc/passwd + 119 321 7579 /etc/passwd +``` + +从输出中可以得知，{file}`/etc/passwd` 有 119 行、321 个单词以及 7579 个字节。 + +使用 `-l`、`-w` 或 `-c` 选项，可以分别只输出行数、单词数或字节数。例如， +只输出 {file}`/etc/passwd` 的行数: + +``` +$ wc -l /etc/passwd +``` + +(wget)= +## wget + +`wget` 命令的名字来自 **W**orld **W**ide **W**eb **get**（万维网获取）。 +该命令可以用来从网络上下载文件，支持断点续传。 +类似的命令还有 `curl`，可以参考 [curl 用法指南](https://www.ruanyifeng.com/blog/2019/09/curl-reference.html) +学习其基本用法。 + +``` +# 下载以下网址对应的单个文件（即 distaz.c 代码） +$ wget http://www.seis.sc.edu/software/distaz/distaz.c + +# 下载并以不同的文件名保存 +$ wget -O distaz-rename.c http://www.seis.sc.edu/software/distaz/distaz.c + +# 继续一个未完成的下载任务，这对下载大文件时突然中断非常有帮助 +$ wget -c http://www.seis.sc.edu/software/distaz/distaz.c +``` diff --git a/_sources/computer/environment-variable.md b/_sources/computer/environment-variable.md new file mode 100644 index 000000000..9f3bd443c --- /dev/null +++ b/_sources/computer/environment-variable.md @@ -0,0 +1,80 @@ +# 环境变量 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2021-02-22 +- 预计花费时间: 10 分钟 + +--- + +当用户登录 Linux 系统后，Shell 程序启动并读取一系列配置文件，这些文件设置了可供所有用户共享的 Shell 环境。 +然后，Shell 会读取用户家目录下的配置文件，这些配置文件定义了用户个人的 Shell 环境。 +Shell 配置文件的名字和读取顺序在不同的 Shell 中或不同情况的 Shell 会话下，有所区别。 +Shell 环境由环境变量、Shell 变量、Shell 函数和别名等组成，这一节主要介绍常见环境变量及其常用配置方法。 + +| 环境变量 | 说明 | +|:---|:---| +| **HOME** | 当前用户的家目录 | +| **LD_LIBRARY_PATH** | 程序加载运行期间，动态链接库的查找路径 | +| **PATH** | 由冒号分开的用于搜索可执行程序名的目录列表 | +| **PS1** | Shell 提示符 | +| **PWD** | 当前工作目录 | +| **SHELL** | Shell 程序的名字 | +| **USER** | 当前用户的用户名 | + +在终端中输入命令名后，Shell 需要先找到该命令，才能交给系统执行。不同命令所在目录并不相同， +常见的命令目录有 {file}`/bin`、{file}`/usr/bin`、{file}`/usr/local/bin` 等。 +此外，大多数闭源软件或商业软件默认安装在 {file}`/opt` 目录下，用户也可能会将一些常用工具放在 {file}`~/bin` 目录下。 +因此，Shell 需要知道去哪些目录下搜索用户输入的命令。而 **PATH** 环境变量则定义了用于搜索可执行程序名的目录列表。 +多个目录之间由冒号分隔。在终端中输入命令名后，Shell 会依次在该目录列表下搜索命令。 + +登录系统后，**PATH** 变量已经设置了默认值。前文中，在终端输入命令名后，Shell 正是到这些目录下去搜索并找到命令的。 + +``` +# 使用 echo 命令查看 PATH 环境变量（变量前加美元符号 $ 表示读取变量值） +$ echo $PATH +/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin +``` + +:::{dropdown} 查看命令所在目录 +:color: info +:icon: info + +可以使用 `which` 或 `whereis` 命令查询命令所在目录: + +``` +$ which cat +/usr/bin/cat + +$ whereis cat +cat: /usr/bin/cat /usr/share/man/man1/cat.1.gz /usr/share/man/man1p/cat.1p.gz +``` +::: + +若某命令所在目录不在 **PATH** 变量中，Shell 将无法将其找到交给系统执行。可以通过修改配置文件将目录永久加入到 **PATH** 变量中。 +Bash 常见的配置文件有 {file}`/etc/profile`、{file}`~/.bash_profile`、{file}`~/.bashrc` 等， +一般通过修改 {file}`~/.bashrc` 文件来设置和更新个人 Shell 环境。使用 Zsh 的读者可以修改 {file}`~/.zshrc` +来设置和更新个人 Shell 环境。例如，添加 {file}`~/bin` 目录到搜索目录列表的末尾: + +``` +# 在 ~/.bashrc 文件中添加一行命令 export PATH=$PATH:$HOME/bin +$ echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc +``` + +以上命令在 {file}`~/.bashrc` 配置文件最后添加了一行 `export PATH=$PATH:$HOME/bin`。其中，`export` 命令用于新增、 +修改或删除环境变量，**HOME** 环境变量表示用户的家目录，即 {file}`~`。假设用户名是 seismo-learn，家目录便是 +{file}`/home/seismo-learn`。因此，该行的作用是将 {file}`/home/seismo-learn/bin` 目录添加到搜索目录列表的末尾， +更新 **PATH** 变量: + +``` +# 打开一个新的终端，查看 PATH 变量 +$ echo $PATH +/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin:/home/seismo-learn/bin +``` + +修改配置文件后，打开新的终端，Shell 环境就会更新。需要注意的是，当前终端的 Shell 环境并没有更新。 +可以在当前终端中使用 `source` 命令重新加载（即读取并执行）配置文件，当前 Shell 环境也会更新: + +``` +# 重新加载 ~/.bashrc +$ source ~/.bashrc +``` diff --git a/_sources/computer/fedora-setup.md b/_sources/computer/fedora-setup.md new file mode 100644 index 000000000..8aa6eae0d --- /dev/null +++ b/_sources/computer/fedora-setup.md @@ -0,0 +1,262 @@ +# Fedora 配置指南 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-04-24 +- 预计花费时间: 120 分钟 + +--- + +:::{note} +本节内容适用于 **Fedora 38 Workstation**，不一定适用于其他 Fedora 版本。 +建议用户访问 [Fedora 官网](https://getfedora.org/) 下载并安装 Fedora +最新版本，也欢迎用户帮助我们更新本文以适配 Fedora 最新版本。 +::: + +## 安装系统 + +### 下载系统镜像 + +访问 [Fedora 官网](https://getfedora.org/) 并下载 Fedora Workstation 镜像文件， +一般选择 x86_64 版本。 + +**Fedora 38 Workstation x86_64** 的 ISO 镜像文件（约 2 GB）下载链接： + +- [官方镜像](https://download.fedoraproject.org/pub/fedora/linux/releases/38/Workstation/x86_64/iso/Fedora-Workstation-Live-x86_64-38-1.6.iso) +- [中科大镜像](https://mirrors.ustc.edu.cn/fedora/releases/38/Workstation/x86_64/iso/Fedora-Workstation-Live-x86_64-38-1.6.iso) [**推荐国内用户使用**] + +### 制作 USB 启动盘 + +:::{warning} +制作 USB 启动盘时会格式化 U 盘！请确保 U 盘中无重要文件！ +::: + +准备一个 4 GB 以上容量的 U 盘，并使用 [Ventoy](https://ventoy.net/cn/) 制作 USB 启动盘。 +Ventoy 可以在 Windows 和 Linux 下使用，详细用法见 [官方文档](https://ventoy.net/cn/doc_start.html)。 +下面以图解形式演示如何在 Windows 下使用 Ventoy 制作 USB 启动盘。 + +::::{card-carousel} 1 +:::{card} 1. 启动 Ventoy2Disk.exe 程序 +![](ventoy-1.jpg) +::: +:::{card} 2. 将 Ventoy 写入 USB 盘 +![](ventoy-2.jpg) +::: +:::{card} 3. USB 启动盘制作成功 +![](ventoy-3.jpg) +::: +:::{card} 4. 制作成功后的显示界面 +![](ventoy-4.jpg) +::: +:::{card} 5. 将 Linux ISO 镜像文件复制到 U 盘中 +![](ventoy-5.jpg) +::: +:::: + +1. 从 [Ventoy 下载页面](https://ventoy.net/cn/download.html) 下载 Ventoy 软件包。 + 解压后，执行其中的 {file}`Ventoy2Disk.exe` 程序，程序启动后界面如图 1 所示。 + Ventoy 程序自动找到了用于制作启动盘的 32 GB U 盘 +2. 点击“安装”会将 Ventoy 安装到 U 盘中，此时 U 盘会被格式化。请务必确保选中的是 + 目标 U 盘，且 U 盘中无其它重要文件 +3. Ventoy 成功安装后，会弹出成功安装的对话框，点击确定 +4. Ventoy 界面显示，安装包内 Ventoy 版本和设备内部 Ventoy 版本相同，表明 USB + 启动盘制作成功 +5. 退出 Ventoy2Disk 程序。在“我的电脑”中找到名为 Ventoy 的 U 盘，并将已下载好的 + Linux ISO 镜像文件复制到 U 盘中即可 + +### 进入 Live 系统 + +将制作好的 USB 启动盘插入要安装 Fedora 系统的计算机上，开机启动， +按下 {kbd}`F10` 或 {kbd}`F12` 进入 BIOS，并使计算机优先从 USB 盘启动。 +正确启动后，则会进入系统启动引导程序，按向上向下键选中“Start Fedora-Workstation-Live 38” +以进入 Fedora 的 Live 系统。 + +:::{note} +Live 系统是指安装在 USB 启动盘中的操作系统。用户可以在 Live 系统中进行 +任何操作以体验该系统。 +::: + +:::{tip} +1. 不同型号的电脑进入 BIOS 的方法可能不同，请自行查询。 +2. 若计算机无法从 USB 盘启动，则可能是由于计算机的“安全启动”设置导致的， + 可以尝试进入 BIOS 设置，并在 BIOS 设置内关闭“安全启动”。 +3. 如果尝试多次都无法正确从 USB 启动，则可能是 USB 启动盘制作失败，请尝试重新制作启动盘。 +::: + +### 开始安装 + +:::{warning} +以下安装步骤假定用户想要将 Fedora 系统作为电脑的**唯一**系统， +电脑中原有的 Windows 或其它 Linux 系统会被彻底覆盖。 +如果用户想要安装双系统（即同时安装 Windows + Linux），请参考网络上的 +其他文档。 +::: + +读者可参考下面的图解步骤和对应的说明安装操作系统（图解步骤是基于 Fedora 36 的， +但同样适用于 Fedora 38）。 + +::::{card-carousel} 1 +:::{card} 1. 点击 “Install to Hard Drive” 以开始安装 +![](fedora-setup-01.jpg) +::: +:::{card} 2. 选择安装过程使用的语言 +![](fedora-setup-02.jpg) +::: +:::{card} 3. 安装信息摘要界面 +![](fedora-setup-03.jpg) +::: +:::{card} 4. 选择硬盘及分区设置 +![](fedora-setup-04.jpg) +::: +:::{card} 5. 手动分区 +![](fedora-setup-05.jpg) +::: +:::{card} 6. 分区结果及微调 +![](fedora-setup-06.jpg) +::: +:::{card} 7. 接受更改，对硬盘进行分区操作 +![](fedora-setup-07.jpg) +::: +:::{card} 8. 安装系统，并等待安装完成 +![](fedora-setup-08.jpg) +::: +:::{card} 9. 重启系统后的欢迎界面 +![](fedora-setup-09.jpg) +::: +:::{card} 10. 设置用户密码 +![](fedora-setup-10.jpg) +::: +:::{card} 11. 设置用户名 +![](fedora-setup-11.jpg) +::: +:::{card} 12. 启动第三方软件源 +![](fedora-setup-12.jpg) +::: +:::{card} 13. 配置完成 +![](fedora-setup-13.jpg) +::: +:::: + +1. 进入 Live 系统后，选择 “Install to Hard Drive” 以启动安装程序 +2. 选择安装过程中使用的语言。可以选择“中文”→“简体中文（中国）” 或 + “English”→“English (Unite States)”。选择完毕后点击下方的“继续”按钮进入下一步 +3. “安装信息摘要”界面，有三个设置项，可分别设置键盘布局、日期与时间以及要 + 安装系统的硬盘及分区。键盘布局、日期与时间都有默认值，一般无需修改 +4. 选择“安装目的地”，进入系统硬盘和分区的设置页面。在“设备选择”中，选择要将系统 + 安装到哪个硬盘。如果计算机有多个硬盘，可以将多个硬盘都选中，被选中的硬盘会有 + 一个“对号”符号。需要注意，不要选中 USB 启动盘对应的 U 盘。在“存储设置”中，可以 + 选择“自动”让安装程序进行自动分区，也可以选择“自定义”以人工设置分区。本教程中 + 选择更灵活的“自定义”分区方式 +5. 在“手动分区”页面，分区方案选择“标准分区”，然后点击“点击这里自动创建它们”， + 以自动创建分区 +6. 系统一般会创建三个分区，`/` （根分区）、`/boot`（boot 分区）和 `/home`（Home 分区）。 + 不了解 Linux 的用户可以直接点击“完成”按钮。有一定 Linux 基础知识且有特定 + 需求的用户，可以在自动分区的基础上进一步新增分区或修改分区的硬盘大小， + 修改完成后点击“完成”按钮即可 +7. 点击“完成”按钮后会弹出“分区更改摘要”对话框，点击“接受更改”则系统会对硬盘 + 进行分区操作 +8. 分区结束后点击“完成”按钮，则回到图 3 所示的“安装信息摘要”界面。点击“开始安装” + 按钮即进入正式安装的过程。等待安装完成，点击“完成安装”，并重启计算机。 + 重启计算机时，记得拔出 USB 启动盘，以免计算机在重启后再次进入 Live 系统。 + +9. 重启计算机后，会看到如图 9 所示的欢迎界面 +10. 设置用户密码 +11. 设置账户名称。注意用户名只能是英文 +12. 启用第三方软件源，以便可以直接安装更多的软件 +13. 配置完成。开始使用 Fedora 系统 + +### 更新系统 + +当已安装的软件有可用的更新，或 Fedora 系统可升级至新版本时， +Fedora 会弹出提醒通知。建议用户及时更新系统及已安装的软件。 + +:::{warning} +更新系统前，特别是大版本更新（如 Fedora 35 更新为 Fedora 36）， +最好先进行一次备份（可以参考{doc}`/best-practices/backup`）。 +::: + +:::{note} +本节接下来介绍的大部分软件都通过命令行安装。在桌面或菜单栏中找到并点击 +“Terminal” 图标以启动终端，然后在终端中输入命令并按下 {kbd}`Enter` 键 +即可执行相应的命令。 +::: + +## 系统软件 + +Fedora 系统自带了“软件中心”，可用于查找、安装、卸载和管理软件包，但一般建议使用 +命令行工具 `dnf` 安装和管理软件。 + +:::{note} +`dnf` 会从 Fedora 软件源下载软件包。 +国内用户可以参考 将默认软件源镜像 +替换为中科大镜像，以加快软件下载速度。 + +注意：在替换软件源镜像后要执行 `sudo dnf makecache` 更新本地缓存的软件包元数据。 +::: + +`dnf` 的详细用法请阅读 [dnf 参考文档](https://dnf.readthedocs.io/en/latest/index.html)， +这里只介绍一些常用命令: + +``` +# 更新本地软件包元数据缓存 +$ sudo dnf makecache + +# 检查并升级所有已经安装的软件 +$ sudo dnf upgrade + +# 检查并升级某软件 +$ sudo dnf upgrade xxx + +# 搜索软件 +$ dnf search xxx + +# 安装软件 +$ sudo dnf install xxx + +# 卸载软件 +$ sudo dnf remove xxx +``` + +:::{tip} +Linux 用户也可以访问 网站查询软件包。 +该网站支持多种 Linux 发行版和多个官方及第三方软件仓库， +且为每个软件包提供了丰富的元信息、依赖和被依赖关系、包含的文件、 +安装方式以及更新历史等信息。 +::: + +## 编程开发环境 + +### C/C++ + +[GCC](https://gcc.gnu.org/) 系列的 C/C++ 编译器是 Linux 下最常用的 +C/C++ 编译器，其提供了 `gcc` 和 `g++` 命令: + +``` +$ sudo dnf install gcc gcc-c++ +``` + +### Fortran + +[GNU Fortran](https://gcc.gnu.org/fortran/) 编译器是 Linux 下最常用的 +Fortran 编译器，其提供了 `gfortran` 命令: + +``` +$ sudo dnf install gcc-gfortran +``` + +### Java + +运行 Java 程序需要安装 Java 运行环境，即 OpenJDK： + +``` +$ sudo dnf install java-latest-openjdk +``` + +### git + +[git](https://git-scm.com/) 是目前最流行的版本控制工具，推荐在科研过程中 +使用 git 管理自己编写的代码和文件。一般情况下系统已经安装了该软件。如果没安装， +可以使用如下命令安装: + +``` +$ sudo dnf install git +``` diff --git a/_sources/computer/file-operations.md b/_sources/computer/file-operations.md new file mode 100644 index 000000000..5212793f2 --- /dev/null +++ b/_sources/computer/file-operations.md @@ -0,0 +1,354 @@ +# 文件操作 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2021-04-23 +- 预计花费时间: 30 分钟 + +--- + +## 熟悉 Linux 文件系统 + +:::{figure} linux-file-system-tree.* +:align: center + +Linux 文件系统树 +::: + +Linux 文件系统就像一颗树一样，从 {file}`/` 目录开始，这个特殊的目录称为根目录。 +根目录下一般有 {file}`/home`、{file}`/root`、{file}`/bin`、 +{file}`/usr`、{file}`/lib`、{file}`/opt` 等目录。 + +- {file}`/home` 目录：用户的家目录，存储用户自己的文件 +- {file}`/bin` 目录：存储必须的程序和命令，所有用户都可用 +- {file}`/usr` 目录：大多数软件的安装位置 +- {file}`/opt` 目录：某些闭源或商业软件（如 Matlab、Google Chrome、Google Earth） + 默认将软件安装到此目录下 + +日常科研中，大多数情况下只在 {file}`/home` 目录下工作。假设用户名是 seismo-learn， +该用户的家目录便是 {file}`/home/seismo-learn`。macOS 下的家目录是 {file}`/Users/seismo-learn`。 +在 Linux/macOS 系统下，可用 {file}`~` 代表家目录。Linux 系统安装后，自动创建的家目录下的目录有 +{file}`~/Desktop`、{file}`~/Documents`、{file}`~/Downloads` 等。熟悉 Linux 文件系统后 +可以参考{doc}`《文件管理实践经验》`和 +{doc}`《软件安装实践经验》`进一步组织与管理家目录， +以提高工作效率。 + +## 操作文件与目录 + +接下来将通过一系列命令熟悉和掌握 Linux 系统下文件和目录的常用操作。 +读者应打开终端，根据下面的教程自行输入命令（不要复制粘贴！），记住并理解每个 +命令的作用。这一小节中，假设用户名是 seismo-learn，读者根据自己的情况自行修改。 + +### 查看文件和目录 + +`ls` （list，即列表）命令用于显示当前目录下的文件和目录。 + +``` +# 使用 pwd（print working directory，即打印当前工作目录）命令查看当前所在目录 +# 可以看出，启动终端后，默认进入家目录 +$ pwd +/home/seismo-learn + +# 查看当前目录（即家目录）下的子目录和文件 +$ ls +Desktop Documents Downloads +# 查看 ~/Desktop 目录 +$ ls Desktop +# 查看 /etc/passwd 文件 +$ ls /etc/passwd +``` + +### 切换目录 + +`cd`（change directory，即切换目录）命令进入用于在目录之间切换。 + +``` +# 切换至根目录 +$ cd / +# 查看根目录中的子目录和文件 +$ ls +bin etc lib mnt proc run srv tmp var +boot dev home lib64 media opt root sbin sys usr +# 切换回家目录（以下任一操作均可） +$ cd /home/seismo-learn +$ cd ~ +$ cd + +# 确认已经切换回家目录下 +$ pwd +/home/seismo-learn +``` + +### 新建文件和目录 + +`mkdir` （make directory，即创建目录）命令可以用于新建目录，`touch` 命令可以 +用于创建一个新的空文件。 + +``` +# 进入家目录 +$ cd ~ +# 使用 mkdir 命令新建目录 +$ mkdir codes software +$ ls +codes Desktop Documents Downloads software +# 建立 workspace 目录，并在该目录下建立 source 目录 +# 需要使用 -p 选项，表示自动创建不存在的中间层目录 +$ mkdir -p workspace/source +$ ls workspace/ +source + +# 进入 workspace 目录 +$ cd workspace +# 使用 touch 命令创建新文件 hello-world.txt 和 seismo-learn.txt +$ touch hello-world.txt seismo-learn.txt +$ ls +hello-world.txt seismo-learn.txt source +``` + +### 复制文件和目录 + +`cp`（copy，即复制）命令可以用于复制文件和目录。 + +:::{note} +以下所有操作都假设读者已经切换到 {file}`~/workspace` 目录下了，即: + +``` +# 进入 ~/workspace 目录 +$ cd ~/workspace +``` +::: + +``` +# 使用 cp 命令复制 hello-world.txt 文件到同一目录下，并重命名为 hello-world-cp.txt +$ cp hello-world.txt hello-world-cp.txt +$ ls +hello-world-cp.txt hello-world.txt seismo-learn.txt source +# 复制 hello-world.txt 和 seismo-learn.txt 文件到 source 目录下 +$ cp hello-world.txt seismo-learn.txt source +$ ls source +hello-world.txt seismo-learn.txt + +# 复制 source 目录为同一目录下的 destination 目录（目标目录不存在） +$ cp -r source destination +$ ls +destination hello-world-cp.txt hello-world.txt seismo-learn.txt source +$ ls destination +hello-world.txt seismo-learn.txt +# 复制 source 目录到同一目录下的 destination 目录下（目标目录已存在） +$ cp -r source destination +$ ls destination +hello-world.txt seismo-learn.txt source +``` + +### 移动文件和目录 + +`mv` （move，即移动）命令可以用于移动文件和目录。 + +``` +# 使用 mv 命令移动 hello-world.txt 文件同一目录下，并重命名为 hello-world-mv.txt +$ mv hello-world.txt hello-world-mv.txt +$ ls +destination hello-world-cp.txt hello-world-mv.txt seismo-learn.txt source +# 移动 hello-world-cp.txt 和 hello-world-mv.txt 文件到 source 目录下 +$ mv hello-world-cp.txt hello-world-mv.txt source +ls +destination seismo-learn.txt source +$ ls source +hello-world-cp.txt hello-world.txt hello-world-mv.txt seismo-learn.txt + +# 移动 source 目录为同一目录下的 source-mv 目录（相当于重命名） +$ mv source source-mv +$ ls +destination seismo-learn.txt source-mv +# 移动 source-mv 目录到同一目录下的 destination 目录下 +$ mv source-mv destination +$ ls +destination seismo-learn.txt +$ ls destination +hello-world.txt seismo-learn.txt source source-mv +``` + +### 删除文件和目录 + +`rm`（remove，即删除）命令 可以用于删除文件和目录。 + +``` +# 使用 rm 命令删除 seismo-learn.txt 文件 +$ rm seismo-learn.txt +$ ls +destination +# 删除 destination 目录 +## rm 命令无法直接删除文件夹，直接使用 rm 命令删除文件夹会出现如下报错 +$ rm destination/ +rm: destination/: is a directory +## 需要使用 -r 选项（recursive，表示递归） +$ rm -r destination +$ ls + +# 新建 tmp 目录 +$ mkdir tmp +$ ls +tmp +# 使用 rmdir（remove directory，即删除目录）命令删除空目录 tmp。目录不为空时则不删除 +$ rmdir tmp +$ ls +``` + +:::{warning} +使用 `rm` 命令删除的文件会被直接删除，并不会被放在回收站里。 +因而执行 `rm` 命令时一定要小心再小心，不要误删重要文件。 +可以先把要删除的文件移动到某目录下（如 {file}`~/trash`），之后统一删除； +也可以考虑使用其他命令行工具管理回收站 +（如 [trash-cli](https://github.com/andreafrancia/trash-cli)）。 +::: + +### 创建软链接 + +软链接，也叫符号链接，类似于 Windows 下的快捷方式。Linux 下可以使用 `ln` （link，即链接） +命令为文件和目录建立软链接: + +``` +# 在当前目录下，为文件 /etc/passwd 建立软链接 +$ ln -s /etc/passwd +# 使用 ls -l 命令查看，会发现在当前目录下生成了一个 passwd 文件，其指向源文件 /etc/passwd +$ ls -l +total 0 +lrwxr-xr-x 1 seismo-learn seismo-learn 11 Oct 4 21:55 passwd -> /etc/passwd +# 默认情况下，软链接与源文件同名。可以重新指定软链接的文件名 +$ ln -s /etc/passwd mylocalpasswd +$ ls -l +total 0 +lrwxr-xr-x 1 seismo-learn seismo-learn 11 Oct 4 21:59 mylocalpasswd -> /etc/passwd +lrwxr-xr-x 1 seismo-learn seismo-learn 11 Oct 4 21:55 passwd -> /etc/passwd + +# 在当前目录下，为文件夹 /usr/lib 建立软链接 +$ ln -s /usr/lib mylibdir +$ ls -l +total 0 +lrwxr-xr-x 1 seismo-learn seismo-learn 8B Oct 4 22:04 mylibdir -> /usr/lib +lrwxr-xr-x 1 seismo-learn seismo-learn 11B Oct 4 21:59 mylocalpasswd -> /etc/passwd +lrwxr-xr-x 1 seismo-learn seismo-learn 11B Oct 4 21:55 passwd -> /etc/passwd +# 可以直接对软链接进行各种操作 +$ ls mylibdir/ + +# 删除软链接。源文件不受影响 +$ rm mylibdir passwd mylocalpasswd +``` + +## 隐藏文件和隐藏目录 + +Linux 中，以 `.` 开头的文件和目录是隐藏文件或隐藏目录。所谓隐藏，是指在一般情况下， +在文件浏览器或执行 `ls` 命令时不会显示这些文件或目录。 + +下面使用 `touch` 和 `mkdir` 命令创建一个隐藏文件和一个隐藏目录： +``` +# 创建隐藏文件 +$ touch .hidden-example-file.txt +# 创建隐藏目录 +$ mkdir .hidden-example-dir +``` + +使用 `ls` 命令查看当前目录的内容，隐藏文件和隐藏目录不会被显示： +``` +$ ls +``` +想要显示隐藏文件和隐藏目录，需要使用 `-a` 选项： +``` +$ ls -a +. .. .hidden-example-dir .hidden-example-file.txt +``` + +:::{note} +`.` 和 `..` 的具体含义会在下面一节介绍。 +::: + +在文件浏览器中，可以勾选“Show Hidden Files”选项以显示隐藏文件和隐藏目录， +也可以直接使用快捷键 {kbd}`Ctrl` + {kbd}`H`。 + +## 文件路径 + +访问文件或目录需要指定文件或目录的路径。Linux 下有两种表示路径的方式：绝对路径和相对路径。 + +顾名思义，绝对路径是从根目录 {file}`/` 开始算起的路径。例如，家目录是 {file}`/home`， +用户 seismo-learn 的家目录是 {file}`/home/seismo-learn`，该用户的桌面目录的路径是 +{file}`/home/seismo-learn/Desktop`。日常科研中，用户的计算机一般只有用户自己在使用， +因此提到家目录时一般特指 {file}`/home/seismo-learn`，而不是指 {file}`/home`。 +因为大多数情况下，我们都在用户的家目录下操作计算机，因此就给这个目录一个特殊的别称 +{file}`~`，其和 {file}`/home/seismo-learn` 是一回事。 + +有时进入到某个目录中，使用绝对路径并不方便。例如，当前位于 {file}`~/projects/NorthChina-MTZ/data` +目录中，如果想进入 {file}`~/projects/NorthChina-MTZ/figures` 目录下，使用绝对路径要 +输入很多字母。为了解决这个问题，Linux 文件系统定义了两个特殊的路径： + +- {file}`.`：当前目录 +- {file}`..`：当前目录的上一级目录 + +利用这两个特殊路径，可以使用相对路径访问其他目录下的文件和目录。例如， + +- {file}`./Beijing`：当前目录下的 {file}`Beijing` 目录，即 {file}`~/projects/NorthChina-MTZ/data/Beijing`。 + 当前路径也可以省略，即 {file}`Beijing` +- {file}`./Beijing/IC-BJT.sac`：当前目录下的 {file}`Beijing` 目录下的 {file}`IC-BJT.sac` 文件， + 即 {file}`~/projects/NorthChina-MTZ/data/Beijing/IC-BJT.sac`。 + 当前路径也可以省略，即 {file}`Beijing/IC-BJT.sac` +- {file}`..`：上一层目录，即 {file}`~/projects/NorthChina-MTZ` 目录 +- {file}`../..`：上一层的上一层目录，即 {file}`~/projects` 目录 +- {file}`../figures`：上一层目录下的 {file}`figures` 目录，即 {file}`~/projects/NorthChina-MTZ/figures` 目录 +- {file}`../figures/fig1.pdf`：上一层目录下的 {file}`figures` 目录下的 {file}`fig1.pdf` 文件， + 即 {file}`~/projects/NorthChina-MTZ/figures/fig1.pdf` + +## 文件权限 + +Linux 下每个文件和目录都有自己的权限，使用 `ls -l` 命令可以查看文件或目录的权限: + +``` +# 进入 ~/workspace 目录，并新建 hello-world.sh 文件和 source 目录 +$ cd ~/workspace +$ touch hello-world.sh +$ mkdir source + +# 使用 ls 命令的 -l 选项可以查看 ~/workspace 目录下的所有文件和目录的详细信息 +$ ls -l +total 0 +-rw-r--r-- 1 seismo-learn seismo-learn 0 Feb 7 22:07 hello-world.sh +drwxr-xr-x 2 seismo-learn seismo-learn 6 Feb 7 22:07 source +``` + +`ls -l` 的输出中，第一列为文件权限位，第三列和第四列分别表示文件所属用户和用户组。 +此处，文件 {file}`hello-world.txt` 和目录 {file}`source` 属于用户 seismo-learn， +且属于用户组 seismo-learn（对于个人计算机而言，用户组通常有且仅有一个用户， +因而用户组与用户同名）。 + +第一列文件权限位总共包含了 10 位信息（如 `-rw-r--r--`），从左到右的含义分别是： + +- 第一位：文件类型（例如，`-` 表示普通文件，`d` 表示目录） +- 第二到第四位：文件所属用户的权限 +- 第五到第七位：文件所属用户组的权限 +- 第八到第十位：其他人的权限 + +每种权限（即文件所属用户的权限、文件所属用户组的权限、其他人的权限） +包含三位信息，第一位 `r` 代表可读取（read），第二位 `w` 代表可写入（write）， +第三位 `x` 代表可执行（execute，对于目录而言表示可以进入该目录），`-` 代表没有对应的权限。 + +从文件的权限位可以看出，用户 seismo-learn 可以读写文件 {file}`hello-world.sh`， +但不可直接执行该文件，对 {file}`source` 目录拥有可读、可写、可执行的权限。 + +除了用字母 `rwx` 表示权限外，还可以用数字表示权限。4 代表可读，2 代表可写， +1 代表可执行。因为 $4+2+1=7$，所以 7 代表可读、可写、可执行。以此类推， +6 代表可读、可写、不可执行，5 代表可读、不可写、可执行， +4 代表可读、不可写、不可执行。 + +使用 `chmod`（change mode，即变更模式）命令可以修改文件或目录的权限: + +``` +# 修改 hello-world.sh 权限 +# 所属用户可读可写不可执行、所属用户组可读可写不可执行、其他人所属用户可读不可写不可执行 +$ chmod 664 hello-world.sh +$ ls -l hello-world.sh +-rw-rw-r-- 1 seismo-learn seismo-learn 0 Feb 7 22:37 hello-world.sh + +# 增加 hello-world.sh 的可执行属性 +$ chmod +x hello-world.sh +-rwxrwxr-x 1 seismo-learn seismo-learn 0 Feb 7 22:37 hello-world.sh + +# 当文件有可执行权限后，即可通过 ./文件名 的方式直接执行该文件 +$ ./hello-world.sh +``` diff --git a/_sources/computer/linux101.md b/_sources/computer/linux101.md new file mode 100644 index 000000000..60bc37191 --- /dev/null +++ b/_sources/computer/linux101.md @@ -0,0 +1,22 @@ +# Linux 入门 + +本章主要介绍 Linux 系统的入门基础。熟悉和掌握本章内容后，基本就可以在 Linux/macOS 系统上 +开展日常研究工作了。若想深入了解 Linux，可以阅读其它更系统的学习资源。工作中若遇到问题， +可以使用 Google 搜索或查询如下学习资源： + +1. Linux 101 + + - 主页： + - 作者：[中国科学技术大学 Linux 用户协会](https://github.com/ustclug) + - 内容：系统地介绍了 Linux 基础 + +2. Bash 脚本教程 + + - 主页： + + - （仅包含 Bash 脚本部分） + - （包含 Bash 脚本和 Linux 基础） + + - 作者：[阮一峰](https://github.com/ruanyf) + + - 内容：系统地介绍了 Bash 脚本以及部分 Linux 基础 diff --git a/_sources/computer/macos-setup.md b/_sources/computer/macos-setup.md new file mode 100644 index 000000000..01fb86b82 --- /dev/null +++ b/_sources/computer/macos-setup.md @@ -0,0 +1,250 @@ +# macOS 配置指南 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者）、{{王亮}}（作者） +- 最近更新日期: 2023-07-03 +- 预计花费时间: 120 分钟 + +--- + +:::{warning} +本节内容基于作者在 macOS Monterey (12) 上的配置经验，可能适用于 +macOS Ventura (13) 和 macOS Big Sur (11)，但不一定适用于更老的 macOS 版本。 +欢迎用户帮助我们更新本文以适配 macOS 最新版本。 +::: + +## 安装系统 + +第一次启动 Mac 电脑后，经过简单的设置，就得到了一个可供日常使用的 macOS 系统。 + +macOS 系统的更新也十分简单。当有新版本发布以后，在“系统偏好设置”的“软件更新”中 +直接更新即可。 + +:::{warning} +更新系统前，特别是大版本更新（如 macOS 11 更新为 macOS 12）， +最好先备份一下（可以参考{doc}`/best-practices/backup`）。 +::: + +:::{note} +本节接下来介绍的大部分软件都通过命令行安装。按下 {kbd}`Command` + {kbd}`空格`， +输入 “Terminal” 并按下 {kbd}`Enter` 键以启动终端， +然后在终端中输入命令并按下 {kbd}`Enter` 键即可执行相应的命令。 +::: + +## 系统软件 + +经过简单设置后的 macOS 系统，尚不能满足日常科研与编程开发的需求，还需要做 +进一步的配置。 + +### Command Line Tools for Xcode + +[Xcode](https://developer.apple.com/cn/xcode/) 是 macOS 下的集成开发环境（IDE）， +类似于 Windows 下的 [Microsoft Visual Studio](https://visualstudio.microsoft.com/)。 +Command Line Tools for Xcode 是 Xcode 的一部分，其包含了常用的命令行开发工具， +比如 C/C++ 编译器（`gcc`、`g++`）、`make`、`git` 等，是 macOS 下编程开发的必需软件。 + +执行如下命令，并在弹出的窗口中点击 “Install” 以安装 Command Line Tools for Xcode: + +``` +$ xcode-select --install +``` + +此处安装的 Command Line Tools for Xcode 可能不是最新版。点击桌面左上角的 Apple 图标， +在“系统偏好设置”的“软件更新”中查看是否有相关更新。如果有，则升级到最新版。 +macOS 系统更新后，有时需重新安装 Command Line Tools for Xcode，再次执行以上命令即可。 + +### Homebrew + +[Homebrew](https://brew.sh/zh-cn/) 是 macOS 下最流行的第三方软件包管理器。 +安装 Homebrew 后，即可通过命令行安装日常与科研工作所需的大多数软件和库文件。 + +#### 安装 Homebrew + +Homebrew 的安装脚本及相关资源托管在 [GitHub](https://github.com/) 上。 +国内可能由于网络问题无法访问 GitHub，进而导致无法安装 Homebrew 或安装 +其他软件速度太慢。因而，Homebrew 的安装说明分为国内和国外两个版本。 +读者应根据自己所处的地理位置使用相应的安装说明。 + +打开终端，执行如下命令，并根据终端提示进行操作，以安装 Homebrew。 +::::{tab-set} +:::{tab-item} 国内用户 +``` +$ /bin/bash -c "$(curl -fsSL https://gitee.com/ineo6/homebrew-install/raw/master/install.sh)" +``` +::: + +:::{tab-item} 国外用户 +``` +$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" +``` +::: +:::: + +:::{note} +针对国内用户的 Homebrew 安装和配置指南来自于 。 +::: + +:::{note} +Homebrew 以及通过 Homebrew 安装的所有软件包都会被安装到特定目录下， +通常是 {file}`/usr/local/homebrew` 目录。而在 Apple M1/M2 芯片的 Mac 下， +这一目录为 {file}`/opt/homebrew/`。 +::: + +#### 使用 Homebrew + +安装好 Homebrew 后，即可以使用 Homebrew 提供的 `brew` 命令。 +`brew` 的详细用法见[官方文档](https://docs.brew.sh/Manpage)。此处仅列出一些常用的用法: + +``` +# 模糊搜索与 wget 相关的软件 +$ brew search wget + +# 安装 wget 软件包 +$ brew install wget + +# 安装 QQ +$ brew install qq + +# 升级某个软件 +$ brew upgrade xxx + +# 卸载某个软件 +$ brew uninstall xxx +``` + +:::{tip} +Homebrew 用户也可以访问网站 查看和搜索可安装的软件包。 +::: + +:::{dropdown} Homebrew 相关名词解释 +:color: info +:icon: info + +使用 Homebrew 时会碰到很多名词。这里做简单解释， +更详细的解释请查看[官方文档](https://docs.brew.sh/Formula-Cookbook#homebrew-terminology)。 + +`brew` + +: Homebrew 提供的命令，用于查询、安装、卸载、升级以及管理软件包。 + +Formula + +: 软件的描述文件，包含了软件的基本信息和编译安装方法。 + Homebrew 根据 Formula 提供的信息，即可编译或安装软件。 + 每个软件对应一个 Formula。例如，git 对应的 Formula 是 + {file}`/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core/Formula/git.rb`。 + +Bottle + +: 预先编译好的二进制软件包。使用 Bottle 安装软件， + 比从源码编译和安装更快。如果一个软件仓库包含预编译的软件包，使用 `brew install` + 时会自动使用它。 + +Tap + +: 一个含有一系列软件的 git 仓库。使用 + [brew tap](https://docs.brew.sh/Taps#the-brew-tap-command) + 命令查看已启用的仓库列表或启用仓库。已启用的仓库位于 + {file}`/usr/local/Homebrew/Library/Taps/homebrew/` 目录。 + 默认启用的软件仓库有 [homebrew-core](https://github.com/Homebrew/homebrew-core) + 和 [homebrew-cask](https://github.com/Homebrew/homebrew-cask)。 + 其中，homebrew-core 是内置核心仓库， + homebrew-cask 仓库则含有各种 macOS 系统下带图形界面的应用程序。 + +Cellar + +: 所有软件的安装目录，即 {file}`/usr/local/Cellar`。 + +Keg + +: 某一软件的安装目录，如 {file}`/usr/local/Cellar/git/2.30.0`。 +::: + +## 编程开发环境 + +### C/C++ + +Command Line Tools for Xcode 已经提供了 C/C++ 编译器和相关工具，因而无需单独安装 +C/C++ 编译器。 + +:::{dropdown} GCC 编译器 +:color: info +:icon: info + +Command Line Tools for Xcode 提供的 C/C++ 编译器本质上是 +[Apple Clang](https://opensource.apple.com/source/clang/clang-23/clang/tools/clang/docs/UsersManual.html) 编译器， +其与 [GCC](https://gcc.gnu.org/) 编译器有差异，但足以满足日常科研中编译 C/C++ 程序的需求。 +因而一般用户无需再安装 GCC 编译器。 + +由于特殊原因需要安装 GCC 编译器的用户（例如需要使用 GCC 特有的功能和选项）， +可以使用如下命令安装: + +``` +$ brew install gcc +``` + +通过 Homebrew 安装的 GCC 提供了命令 `gcc-13` 和 `g++-13` +（`13` 是 GCC 的主版本号）以避免替换 Command Line Tools for Xcode 提供的 `gcc` 和 `g++` 命令。 +用户如果想使用 GCC 编译器，可以在编译代码时显式指定使用 `gcc-13` 和 `g++-13` 命令， +或者在 Homebrew 的 bin 目录下创建软链接: + +``` +$ cd $(brew --prefix)/bin/ +$ ln -s gcc-13 gcc +$ ln -s g++-13 g++ +``` + +打开一个新终端后，使用的 `gcc` 和 `g++` 命令则默认是 GCC 编译器。 +删除软链接后，默认使用的又是 Apple Clang 编译器了。 +::: + +### Fortran + +[GNU Fortran](https://gcc.gnu.org/fortran/) 编译器是 macOS 下最常用的 +Fortran 编译器，其提供了 `gfortran` 命令: + +``` +$ brew install gfortran +``` + +### Java + +运行 Java 程序需要安装 Java 运行环境，即 OpenJDK: + +``` +$ brew install openjdk +$ sudo ln -sfn $(brew --prefix)/opt/openjdk/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk.jdk +``` + +### git + +[git](https://git-scm.com/) 是目前最流行的版本控制工具，推荐在科研过程中使用 +git 管理自己编写的代码和文件。Command Line Tools for Xcode 中已经安装了 Apple 版 +的 git，其与原版 git 有一些区别。可以用如下命令安装原版的 git: + +``` +$ brew install git +``` + +### GNU 实用工具 + +macOS 下自带了很多实用工具，如 `sed`、`grep` 等（位于 {file}`/usr/bin/` 目录下）。 +需要注意，这些实用工具是由 [BSD](https://www.bsd.org/) 提供的，而 Linux 系统下的 +实用工具则是由 [GNU](https://www.gnu.org/) 提供的。 +BSD 和 GNU 实用工具的命令行语法有相似之处，但也有差异。 +由于网络上的大部分文档介绍的都是 GNU 实用工具的用法，因而 macOS 用户在使用网络上的 +命令时可能会出现错误。这一点可以通过安装 GNU 实用工具来解决: + +``` +# 此处仅安装常用的 GNU 实用工具 +$ brew install findutils gawk gnu-sed gnu-tar grep +``` + +Homebrew 将 GNU 实用工具安装在 {file}`/usr/local/bin` 或 {file}`/opt/homebrew/bin` 目录下， +但在所有工具的名称前加上了前缀 `g`，以避免替换 macOS 系统自带的 BSD 实用工具，即 `sed` 是 BSD 提供的， +而 `gsed` 是 GNU 提供的。一般情况下，建议使用 BSD 工具（无前缀 `g`）， +在遇到不兼容的情况下，可以考虑使用 GNU 工具（有前缀 `g`），但在写脚本时， +要额外注意脚本的可移植性。 + +## 扩展阅读 + +- [GNU 与 BSD 实用工具的用法区别](https://ponderthebits.com/2017/01/know-your-tools-linux-gnu-vs-mac-bsd-command-line-utilities-grep-strings-sed-and-find/) diff --git a/_sources/computer/operating-system.md b/_sources/computer/operating-system.md new file mode 100644 index 000000000..8a188edb5 --- /dev/null +++ b/_sources/computer/operating-system.md @@ -0,0 +1,68 @@ +# 选择操作系统 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者） +- 最近更新日期: 2021-03-19 +- 预计阅读时间: 5 分钟 + +---- + +个人电脑有三种常见的操作系统：Microsoft Windows、macOS 和 Linux。 +从市场占有率上看，Microsoft Windows 用户数目远远多于 macOS 和 Linux 用户。 +然而，大多数地震学科研工作者都使用 Linux 或 macOS 作为日常科研的主要操作系统。 +其原因主要有如下几点： + +1. Linux 和 macOS 上可以更容易地获取和使用编程所需的开发工具 +2. 大多数地震学相关的程序/代码都是在 Linux 上编写的，且仅在 Linux 和 macOS 上可以使用 +3. Linux 和 macOS 自带了对数据做基本处理的命令行工具 +4. 高性能计算服务器几乎都只使用 Linux 系统 + +对于地震学初学者，**建议使用 Linux 或 macOS 系统**，除非非常确定自己的科研工作并不需要用到 +别人提供的代码，或者有足够的知识和能力在 Windows 系统下编译和使用别人的代码。 + +## Linux + +Linux 有[上百个不同的发行版](https://distrowatch.com/)， +绝大多数都可以免费获取与安装。比较流行的发行版有 +[Ubuntu](https://ubuntu.com/)、[Debian](https://www.debian.org/)、 +[Fedora](https://getfedora.org/)、[CentOS](https://www.centos.org/) 等。 +有经验的读者可以根据自己的喜好自行选择合适的 Linux 发行版。 + +对于不了解 Linux 的读者，**推荐使用 Fedora 或 Ubuntu 系统**，可以分别参考 +《{doc}`/computer/fedora-setup`》和《{doc}`/computer/ubuntu-setup`》 +来安装和配置系统，以满足科研工作的需求。 + +:::{note} +选择 **CentOS** 的读者应使用 [CentOS Stream](https://www.centos.org/centos-stream/)， +而非 [CentOS Linux](https://www.centos.org/centos-linux/)。 +Red Hat 在 2020 年 12 月宣布将停止 CentOS Linux 项目。 +CentOS Linux 8 已于 2021 年末停止维护； +CentOS Linux 7 也将于 2024 年 6 月 30 日停止更新。 +详情请阅读 [CentOS 博客](https://blog.centos.org/2020/12/future-is-centos-stream/)。 +::: + +## macOS + +Mac 笔记本（MacBook Air、MacBook Pro）或台式机（iMac、Mac mini、Mac Pro）自带的 +macOS 系统可以满足科研工作的大部分需求。 +**对于以 Mac 笔记本或 Mac 台式机作为科研主力机器的读者，建议直接使用 macOS 系统**。 +可以参考《{doc}`/computer/macos-setup`》对 macOS 系统进行配置，以满足科研工作的需求。 + +## Microsoft Windows + +如前所述，地震学科研工作不建议使用 Windows 系统，而建议使用 Linux 系统。 +对于科研工作需要 Linux 系统而日常办公需要 Windows 系统的情况，通常有如下几种 +解决办法： + +1. 在电脑上同时安装 Windows 和 Linux 双系统 +2. 在 Windows 系统中安装虚拟机软件，并在虚拟机中安装和使用 Linux 系统 +3. 在 Windows 系统中使用“适用于 Linux 的 Windows 子系统”（Windows Subsystem for Linux，即 WSL） + +**推荐 Windows 10/11 用户使用 WSL**。 +WSL 是微软官方开发的一个在 Windows 10/11 上运行原生 Linux 二进制可执行文件的兼容层。 +通过 WSL，可以在 Windows 10/11 上安装主流 Linux 发行版，并原生运行 Linux 下的 +大多数命令行工具和应用程序。 + +与安装双系统相比，WSL 安装简便且可以在多系统之间无缝切换。 +与使用虚拟机相比，WSL 在启动速度、消耗资源以及性能利用上有较大优势。 +因此，对于绝大多数 Windows 10/11 用户，WSL 是比双系统和虚拟机更好的选择。 +可以参考《{doc}`/computer/wsl-setup`》来安装并配置 WSL，以满足科研工作的需求。 diff --git a/_sources/computer/setup.md b/_sources/computer/setup.md new file mode 100644 index 000000000..5b283bc4b --- /dev/null +++ b/_sources/computer/setup.md @@ -0,0 +1,6 @@ +# 配置操作系统 + +这一节介绍如何安装和配置一些常见的操作系统，以满足日常科研工作的需求。 + +```{tableofcontents} +``` diff --git a/_sources/computer/shell.md b/_sources/computer/shell.md new file mode 100644 index 000000000..176edb329 --- /dev/null +++ b/_sources/computer/shell.md @@ -0,0 +1,292 @@ +# Shell 基础 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2023-04-08 +- 预计花费时间: 60 分钟 + +--- + +## Shell 扩展 + +Shell 接收到用户输入的命令后，会以空格为分隔符将输入的命令拆分成一个个词元（token）。 +如果词元中存在特殊字符，Shell 会先扩展这些特殊字符。扩展完成后，Shell 才会把命令 +交给系统执行。需要注意，**扩展是由 Shell 负责的，与所执行的命令无关**。命令本身 +并不扩展参数，收到什么参数就原样执行。 + +例如，用户在终端键入 `cd ~` 后，Shell 先将该命令拆分成 `cd` 和 `~` 两个词元， +然后把 `~` 这个特殊字符扩展成用户的家目录路径（如 `/home/seismo-learn`）， +最后交给系统执行，即 `cd /home/seismo-learn`。系统执行完命令后，用户所在目 +录就切换到家目录下了。 + +:::{note} +本文只介绍 Shell 扩展的一些常见用法，可以参考 +[Bash 的模式扩展](https://wangdoc.com/bash/expansion.html#startend-%E6%89%A9%E5%B1%95) +学习详细用法。 + +在网络上的部分教程或文档中，Shell 扩展（expansion）也被称为模式匹配（pattern matching） +或通配符（wildcards 或 globbing）。通常来说，这些名词指代的都是这一节所介绍的内容。 +::: + +下表中列出了 Shell 中最常用的扩展字符： + +| 扩展字符 | 作用 | 示例 | +|:---|:---|:---| +| ~ | 匹配当前用户的家目录 | 例如 /home/seismo-learn | +| ? | 匹配任意单个字符（不能匹配零个字符） | ?.txt 匹配 a.txt、b.txt 等文件名 | +| \* | 匹配任意数量字符（能匹配零个字符） | \*.txt 匹配 a.txt、b.txt、ab.txt 等文件名 | +| [...] | 匹配方括号中的任意一个字符 | [abc].txt 匹配 a.txt、b.txt 以及 c.txt 文件名 | +| [*start*-*end*] | 方括号扩展的简写模式，匹配一个连续的范围 | [a-z] 表示所有小写字母，[0-9] 等同于 [0123456789] | +| [^...] | 匹配不在方括号里面的任意一个字符 | [^ab]c.txt 匹配 cc.txt、dc.txt 等文件名 | + +### 字符 `?` 扩展 + +字符 `?` 可以匹配任意**单个**字符。 + +假如当前目录下有 {file}`filea.txt`、{file}`fileb.txt` 和 {file}`fileab.txt` 三个文件。 +在命令中使用 `file?.txt` 时，Shell 会对 `file?.txt` 进行扩展。由于字符 `?` 可以 +匹配任意单个字符，因而 `file?.txt` 会匹配到文件 {file}`filea.txt` 和 {file}`fileb.txt`： +``` +$ ls file?.txt +filea.txt fileb.txt +``` +同理，`file??.txt` 可以匹配文件 {file}`fileab.txt`： +``` +$ ls file??.txt +fileab.txt +``` + +### 字符 `*` 扩展 + +字符 `*` 可以匹配任意数量（零个或多个）的任意字符。 + +假如当前目录下有 {file}`filea.txt`、{file}`fileb.txt` 和 {file}`fileab.txt` 三个文件。 +使用 `*.txt` 可以匹配所有以 `.txt` 结尾的文件： +``` +$ ls *.txt +filea.txt fileb.txt fileab.txt +``` + +使用 `filea*.txt` 可以匹配到以 `filea` 开头并以 `.txt` 结尾的文件： +``` +$ ls filea*.txt +filea.txt fileab.txt +``` + +使用 `*b*` 可以匹配文件名中包括字符 `b` 的文件： +``` +$ ls *b* +fileb.txt fileab.txt +``` + +### 方括号 `[...]` 扩展 + +方括号 `[...]` 可以用于匹配方括号内的任意单个字符。 + +假如当前目录下有 {file}`filea.txt`、{file}`fileb.txt` 和 {file}`filec.txt` 三个文件。 +使用 `file[ab].txt` 则会匹配到 {file}`filea.txt` 和 {file}`fileb.txt` 两个文件： +``` +$ ls file[ab].txt +filea.txt fileb.txt +``` +使用 `file[cd].txt` 则只能匹配到 {file}`filec.txt` 这一个文件： +``` +$ ls file[cd].txt +filec.txt +``` +方括号里还可以用破折号 `-` 指定连续范围内的多个字符。例如 `[a-z]` 表示从 a 到 z +的所有小写字母，`[A-Z]` 表示从 A 到 Z 的所有大小字母，`[0-9]` 表示数字 0 到 9， +`[a-zA-Z0-9]` 则表示所有字母和数字。例如，使用 `file[a-c].txt` 可以匹配到三个文件： +``` +$ ls file[a-c].txt +filea.txt fileb.txt filec.txt +``` + +### 多种扩展字符的组合 + +不同的扩展字符组合在一起使用可以实现更复杂的匹配功能。 + +若当前目录下存在文件 {file}`filea.txt`、{file}`fileaaa.txt`、{file}`filebbb.txt` +和 {file}`fileabc.txt`，则通配符 `file[a-b]b?.txt` 会匹配到 {file}`filebbb.txt` +和 {file}`fileabc.txt` 两个文件： +``` +$ ls file[a-b]b?.txt +fileabc.txt filebbb.txt +``` + +:::{warning} +其他 Shell （如 Zsh, csh, ksh）的扩展语法可能稍微不同，以上示例可能不适用。 +::: + +## 标准输入输出与重定向 + +一般情况下，命令从标准输入（stdin）读取输入，并将产生的输出发送到到标准输出（stdout）， +默认的标准输入和标准输出都是终端。此外，还有标准错误（stderr），用于输出命令运行的 +状态和错误信息，其默认也是终端。一般用 0、1、2 分别表示标准输入、标准输出和标准错误。 + +在下面的示例中，`echo` 命令从终端（即标准输入）获取了输入 `"Hello World"`， +并将输出 `Hello World` 发送到终端（即标准输出）: + +``` +# 使用 echo 命令输出 Hello World 到终端 +$ echo "Hello World" +Hello World +``` + +使用重定向，可以修改标准输入、标准输出以及标准错误，以达到从文件中读取输入，以及 +输出到文件的目的。 + +### 标准输出重定向 + +以 `echo` 命令为例的重定向输出到文件: + +``` +# 输出 Hello World 到 output_file 文件中（文件不存在则新建该文件） +$ echo "Hello World" > output_file +# 使用 cat 命令查看 output_file 的内容 +$ cat output_file +Hello World + +# 输出 Rewrite it 到 output_file 文件中（文件存在则覆盖该文件原有内容） +$ echo "Rewrite it" > output_file +$ cat output_file +Rewrite it + +# 输出 Append it 到 output_file 文件中（文件不存在则新建该文件；存在则添加到文件末尾） +$ echo "append it" >> output_file +$ cat output_file +Rewrite it +Append it +``` + +### 标准输入重定向 + +以 `cat` 命令为例的从文件中读取输入: + +``` +# 键入 cat 命令 +$ cat + +# 没指定任何参数时，该命令会从标准输入读入数据，即正在等待我们从终端输入中 +# 在终端输入 Hello World 并按 Enter 键，最后按 Ctrl + D 结束输入 +$ cat +Hello World +Hello World + +# 重定向标准输入从 output_file 读如内容 +$ cat < output_file +Rewrite it +Append it +``` + +从文件中读如输入，并输出到文件: + +``` +# 查看 output_file 文件内容，并输出到 output_file2 文件中 +$ cat < output_file > output_file2 +$ cat output_file2 +Rewrite it +Append it +``` + +上例子中 `cat` 命令后面直接跟文件名时，跟加 `<` 和文件名，结果一样。 + +### 标准错误重定向 + +标准错误可以用 `2>` 和 `2>>` 重定向输出到文件中，数字 2 和 `>` 与 `>>` +之间没有空格: + +``` +# 使用 cat 命令查看 out_file 的内容。该文件不存在，因此会输出出错信息到终端 +$ cat out_file +cat: out_file: No such file or directory + +# 输出出错信息到 err_file（文件不存在则新建该文件；存在则覆盖该文件原有内容） +$ cat out_file 2> err_file +$ cat err_file +cat: out_file: No such file or directory + +# 输出出错信息到 err_file（文件不存在则新建该文件；存在则添加到文件末尾） +$ cat out_file 2>> err_file +$ cat err_file +cat: out_file: No such file or directory +cat: out_file: No such file or directory +``` + +使用 `2>&1` 可以将标准错误合并到标准输出（注意重定向的顺序非常重要，标准错误的 +重定向 `2>&1` 必须总是出现在标准输出重定向之后，否则不起作用）: + +``` +# 将命令输出和出错信息都写入到 out_err_file 文件中 +$ cat out_file > out_err_file 2>&1 +cat: out_file: No such file or directory + +# 将命令输出和出错信息以追加的形式都写入到 out_err_file 文件中 +$ cat out_file >> out_err_file 2>&1 +cat: out_file: No such file or directory +cat: out_file: No such file or directory +``` + +可以使用 `&>` 和 `&>>` 这以精简方法来执行这种联合的重定向: + +``` +# 将命令输出和出错信息都写入到 out_err_file 文件中 +$ cat out_file &> out_err_file +cat: out_file: No such file or directory + +# 将命令输出和出错信息以追加的形式都写入到 out_err_file 文件中 +$ cat out_file &>> out_err_file +cat: out_file: No such file or directory +cat: out_file: No such file or directory +``` + +:::{tip} +有时，我们不想要命令的输出结果（标准输出或标准错误）。此时可以将输出重定向到 +{file}`/dev/null` 文件。此文件是系统设备，叫做位存储桶，可以接受输入，并且 +对输入不做任何处理。例如: + +``` +$ cat out_file 2> /dev/null +``` +::: + +### 输入多行字符串 + +Here 文档（here document）是一种输入多行字符串的方法，格式如下: + +``` +<< token +text +token +``` + +它的格式分成开始标记 `<< token`、字符串 `text` 和结束标记 `token`。 +开始标记由两个小于号加上 Here 文档的名称（名称可以随意取，通常用 `EOF` 或 `END`） +组成，后面必须是一个换行符。结束标记是单独一行且顶格写的 Here 文档名称，若不顶格， +结束标记不起作用。两者之间就是多行字符串的内容。 + +``` +# 使用 cat 命令输入三行数字 +$ cat << EOF +1 2 +3 4 +5 6 +EOF +# 以上命令的输出是 +1 2 +3 4 +5 6 +``` + +## 管道 + +管道（pipe）操作符 `|` 可以将一个命令的标准输出送至另一个命令的标准输入。 +管道不会处理标准错误。 + +``` +# echo 命令输出的 Hello World 被管道操作符交给 wc 命令当作输入来统计字数 +$ echo "Hello World" | wc -w +2 + +# 可以无限多次使用管道。使用 cat 命令将上例的输出重定向写入 pipe.dat 文件中 +$ echo "Hello World" | wc -w | cat > pipe.dat +``` diff --git a/_sources/computer/ubuntu-setup.md b/_sources/computer/ubuntu-setup.md new file mode 100644 index 000000000..d5591b42d --- /dev/null +++ b/_sources/computer/ubuntu-setup.md @@ -0,0 +1,236 @@ +# Ubuntu 配置指南 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2022-05-29 +- 预计花费时间: 120 分钟 + +--- + +:::{note} +本节内容适用于 **Ubuntu Desktop 22.04 LTS**，不一定适用于其他 Ubuntu 版本。 +建议用户总是选择 Ubuntu 最新的长期支持版（目前是 Ubuntu 22.04 LTS）或最新版本 +（目前是 Ubuntu 23.04），也欢迎用户帮助我们更新本文以适配 Ubuntu 最新版本。 +::: + +## 安装系统 + +### 下载系统镜像 + +访问 [Ubuntu 官网](https://ubuntu.com/) 并下载 Ubuntu Desktop 镜像文件， +一般选择 AMD64（x86_64）版本。 + +**Ubuntu Desktop 22.04 LTS AMD64** 的 ISO 镜像文件（约 2.9 GB）下载链接： + +- [官方镜像](https://releases.ubuntu.com/22.04/ubuntu-22.04.3-desktop-amd64.iso) +- [中科大镜像](https://mirrors.ustc.edu.cn/ubuntu-releases/22.04/ubuntu-22.04.3-desktop-amd64.iso) [**推荐国内用户使用**] + +### 制作 USB 启动盘 + +:::{warning} +制作 USB 启动盘时会格式化 U 盘！请确保 U 盘中无重要文件！ +::: + +准备一个 4 GB 以上容量的 U 盘，并使用 [Ventoy](https://ventoy.net/cn/) 制作 USB 启动盘。 +Ventoy 可以在 Windows 和 Linux 下使用，详细用法见 [官方文档](https://ventoy.net/cn/doc_start.html)。 +下面以图解形式演示如何在 Windows 下使用 Ventoy 制作 USB 启动盘。 + +::::{card-carousel} 1 +:::{card} 1. 启动 Ventoy2Disk.exe 程序 +![](ventoy-1.jpg) +::: +:::{card} 2. 将 Ventoy 写入 USB 盘 +![](ventoy-2.jpg) +::: +:::{card} 3. USB 启动盘制作成功 +![](ventoy-3.jpg) +::: +:::{card} 4. 制作成功后的显示界面 +![](ventoy-4.jpg) +::: +:::{card} 5. 将 Linux ISO 镜像文件复制到 U 盘中 +![](ventoy-5.jpg) +::: +:::: + +1. 从 [Ventoy 下载页面](https://ventoy.net/cn/download.html) 下载 Ventoy 软件包。 + 解压后，执行其中的 {file}`Ventoy2Disk.exe` 程序，程序启动后界面如图 1 所示。 + Ventoy 程序自动找到了用于制作启动盘的 32 GB U 盘 +2. 点击“安装”会将 Ventoy 安装到 U 盘中，此时 U 盘会被格式化。请务必确保选中的是 + 目标 U 盘，且 U 盘中无其它重要文件 +3. Ventoy 成功安装后，会弹出成功安装的对话框，点击确定 +4. Ventoy 界面显示，安装包内 Ventoy 版本和设备内部 Ventoy 版本相同，表明 USB + 启动盘制作成功 +5. 退出 Ventoy2Disk 程序。在“我的电脑”中找到名为 Ventoy 的 U 盘，并将已下载好的 + Linux ISO 镜像文件复制到 U 盘中即可 + +### 进入 Live 系统 + +将制作好的 USB 启动盘插入要安装 Ubuntu 系统的计算机上，开机启动， +按下 {kbd}`F10` 或 {kbd}`F12` 进入 BIOS，并使计算机优先从 USB 盘启动。 +正确启动后，则会进入系统启动引导程序，按向上向下键选中“Ubuntu”以进入 Ubuntu 的 Live 系统。 + +:::{note} +Live 系统是指安装在 USB 启动盘中的操作系统。用户可以在 Live 系统中进行 +任何操作以体验该系统。 +::: + +:::{tip} +1. 不同型号的电脑进入 BIOS 的方法可能不同，请自行查询。 +2. 若计算机无法从 USB 盘启动，则可能是由于计算机的“安全启动”设置导致的， + 可以尝试进入 BIOS 设置，并在 BIOS 设置内关闭“安全启动”。 +3. 如果尝试多次都无法正确从 USB 启动，则可能是 USB 启动盘制作失败，请尝试重新制作启动盘。 +::: + +### 开始安装 + +:::{warning} +以下安装步骤假定用户想要将 Ubuntu 系统作为电脑的**唯一**系统， +电脑中原有的 Windows 或其它 Linux 系统会被彻底覆盖。 +如果用户想要安装双系统（即同时安装 Windows + Linux），请参考网络上的 +其他文档。 +::: + +读者可参考下面的图解步骤和对应的说明安装操作系统。 + +::::{card-carousel} 1 +:::{card} 1. 欢迎界面 +![](ubuntu-setup-1.jpg) +::: +:::{card} 2. 选择安装过程中使用的语言 +![](ubuntu-setup-2.jpg) +::: +:::{card} 3. 设置键盘布局 +![](ubuntu-setup-3.jpg) +::: +:::{card} 4. 设置要安装的软件 +![](ubuntu-setup-4.jpg) +::: +:::{card} 5. 设置安装类型 +![](ubuntu-setup-5.jpg) +::: +:::{card} 6. 对硬盘进行分区操作 +![](ubuntu-setup-6.jpg) +::: +:::{card} 7. 设置时区 +![](ubuntu-setup-7.jpg) +::: +:::{card} 8. 设置用户名与密码 +![](ubuntu-setup-8.jpg) +::: +:::{card} 9. 等待安装完成 +![](ubuntu-setup-9.jpg) +::: +:::: + +1. 进入欢迎界面，左侧可以选择安装过程中使用的语言 +2. 选择“中文（简体）”，点击“安装 Ubuntu”即开始安装 +3. 选择键盘布局，汉语或 “English(US)”均可 +4. 选择“正常安装”，建议勾选“安装 Ubuntu 时下载更新”和“为图形或无线硬件， + 以及其他媒体格式安装第三方软件” +5. 在“安装类型”界面，选择“清除整个硬盘并安装 Ubuntu”，安装程序会进行自动分区。 + 有经验的用户也可以选择“其他选项”自定义分区，但需要了解 Linux 的分区操作。 + 对于一般用户而言，建议使用默认的自动分区 +6. 单击“现在安装”，选择“继续”以将改动写入磁盘 +7. 选择时区（例如“上海”） +8. 输入账户信息和密码信息。注意用户名只能是英文 +9. 等待安装完成。完成后点击“现在重启”以重启计算机。 + +重启计算机时，记得拔出 USB 启动盘，以免再次进入 USB 安装镜像。 + +### 更新系统 + +当已安装的软件有可用的更新，或 Ubuntu 系统可升级至新版本时， +Ubuntu 会弹出提醒通知。建议用户及时更新系统及安装的软件。 + +:::{warning} +更新系统前，特别是大版本更新（如 Ubuntu 20.04 更新为 Ubuntu 20.10）， +最好先进行一次备份（可以参考{doc}`/best-practices/backup`）。 +::: + +:::{note} +本节接下来介绍的大部分软件都通过命令行安装。在桌面或菜单栏中找到并点击 +“Terminal” 图标以启动终端，然后在终端中输入命令并按下 {kbd}`Enter` 键 +即可执行相应的命令。 +::: + +## 系统软件 + +Ubuntu 系统自带了“软件中心”，可用于查找、安装、卸载和管理软件包，但一般建议使用 +命令行工具 `apt` 安装和管理软件。 + +:::{note} +`apt` 会从 Ubuntu 软件源下载软件包。 +国内用户可以参考 将默认软件源镜像 +替换为中科大镜像，以加快软件下载速度。 + +注意：在替换软件源镜像后要执行 `sudo apt update` 更新本地缓存的软件包元数据。 +::: + +`apt` 的详细用法请阅读 [apt 帮助文档](http://manpages.ubuntu.com/manpages/focal/man8/apt.8.html)， +这里只介绍一些常用命令: + +``` +# 更新本地软件包元数据 +$ sudo apt update + +# 检查并升级所有已经安装的软件 +$ sudo apt upgrade + +# 搜索软件 +$ apt search xxx + +# 安装或升级软件 +$ sudo apt install xxx + +# 检查并升级某软件 +$ sudo apt --only-upgrade install xxx + +# 卸载软件 +$ sudo apt remove xxx （保留配置文件） +$ sudo apt purge xxx （删除配置文件） +``` + +:::{tip} +Linux 用户也可以访问 网站查询软件包。 +该网站支持多种 Linux 发行版和多个官方及第三方软件仓库， +且为每个软件包提供了丰富的元信息、依赖和被依赖关系、包含的文件、 +安装方式以及更新历史等信息。 +::: + +## 编程开发环境 + +### C/C++ + +[GCC](https://gcc.gnu.org/) 系列的 C/C++ 编译器是 Linux 下最常用的 +C/C++ 编译器，其提供了 `gcc` 和 `g++` 命令: + +``` +$ sudo apt install gcc g++ +``` + +### Fortran + +[GNU Fortran](https://gcc.gnu.org/fortran/) 编译器是 Linux 下最常用的 +Fortran 编译器，其提供了 `gfortran` 命令: + +``` +$ sudo apt install gfortran +``` + +### Java + +运行 Java 程序需要安装 Java 运行环境，即 OpenJDK: + +``` +$ sudo apt install default-jdk +``` + +### git + +[git](https://git-scm.com/) 是目前最流行的版本控制工具，推荐在科研过程中 +使用 git 管理自己编写的代码和文件。一般情况下系统已经安装了该软件。如果没安装， +可以使用如下命令安装: + +``` +$ sudo apt install git +``` diff --git a/_sources/computer/wsl-setup.md b/_sources/computer/wsl-setup.md new file mode 100644 index 000000000..0cf831629 --- /dev/null +++ b/_sources/computer/wsl-setup.md @@ -0,0 +1,212 @@ +# WSL 配置指南 + +- 本节贡献者: {{赵志远}}（作者）、{{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-04-24 +- 预计花费时间: 120 分钟 + +--- + +## 简介 + +[WSL](https://docs.microsoft.com/zh-cn/windows/wsl/) +（Windows Subsystem for Linux，适用于 Linux 的 Windows 子系统） +可以让用户直接在 Windows 10/11 上运行 Linux 环境（包括大多数命令行工具和应用程序）， +且不会产生传统虚拟机或双系统的开销。 + +:::{note} +接下来的大部分命令是在命令行中执行的。 + +使用 Windows 系统时，同时按下 {kbd}`win` + {kbd}`R` 键，在打开的运行对话框中 +输入 “cmd” 以启动“命令提示符”（即 CMD）。在 CMD 中输入命令并按下 {kbd}`Enter` 键 +即可执行相应的命令。 + +使用 Linux 系统时，在桌面或菜单栏中找到并点击 “Terminal” 图标以启动终端， +然后在终端中输入命令并按下 {kbd}`Enter` 键即可执行相应的命令。 +::: + +## 安装 + +### 检查 Windows 版本 + +WSL 只能在 Windows 10 的较高版本或 Windows 11 上安装。因而，在安装 WSL 前，需要 +先检查当前 Windows 系统的版本号是否满足 WSL 的要求。 + +按下 {kbd}`win` + {kbd}`R` 键，在打开的运行对话框中键入 `winver`，然后选择“确定”， +则会弹出“关于 Windows”对话框，会看到类似“版本 21H2 （OS 内部版本 19044）”的字样。 +其中，21H2 是 Windows 版本号，19044 是系统内部版本号。 + +:::{note} +本配置指南的内容仅适用于 Windows 10 版本 21H2 及更高版本（内部版本 19044 及更高 +版本）或 Windows 11。低版本 Windows 用户请自行升级到更高版本。 +::: + +### 安装 WSL + +1. 在 Windows 系统的搜索框中直接输入命令 `cmd` +2. 在搜索结果中的“命令提示符”上单击右键，选择“管理员身份运行” +3. 在打开的“命令提示符”窗口中，输入如下命令： + ``` + $ wsl --install + ``` + 此命令将启动 WSL 并默认安装 Ubuntu 22.04 LTS +4. 待安装完成后，重启计算机 + +更详细的安装步骤、常见问题的解决办法以及旧版本 Windows 下的安装方法可以参考 +[官方安装指南](https://docs.microsoft.com/zh-cn/windows/wsl/install)。 + +:::{note} +WSL 默认安装的 Linux 发行版是 Ubuntu 22.04 LTS，但也支持安装其它 Linux 发行版。 +可以使用如下命令查看可安装的 Linux 发行版列表： +``` +$ wsl --list --online +``` +可以使用如下命令安装指定的 Linux 发行版（其中 `` 为要安装的 +Linux 发行版的名称）： +``` +$ wsl --install -d +``` + +WSL 目前不支持直接安装 Fedora 发行版。想在 WSL 上安装 Fedora 的读者可以参考 +[英文指南](https://fedoramagazine.org/wsl-fedora-33/)或[中文指南](https://suiahae.me/Using-Fedora-33-on-Windows-10-WSL2/)。 +指南中所使用的 Fedora 33 已经过时。请访问 Fedora 官方仓库下载 +[Fedora 38](https://github.com/fedora-cloud/docker-brew-fedora/tree/38/x86_64)（Fedora 最新版本） +镜像文件，并按照指南进行操作。 +::: + +## 配置 Linux + +打开 CMD，运行 `bash` 命令即可启动并进入 WSL 提供的 Linux 环境： +``` +$ bash +``` + +通过 WSL 安装 Linux 系统后，还需要对 Linux 系统进行配置。 +Ubuntu 和 Fedora 用户可以分别参考《{doc}`/computer/ubuntu-setup`》和 +《{doc}`/computer/fedora-setup`》对系统进行配置，以满足科研工作的需求。 + +:::{warning} +配置 Linux 系统时，切记要跳过“安装系统”一节，只需配置**系统软件**和**编程开发环境**。 +否则，整个电脑的 Windows 系统将会被覆盖。 +::: + +使用 `exit` 命令可以退出 Linux 环境： +``` +$ exit +``` + +:::{note} +新版本 Windows 中安装的 WSL 已经直接支持图形界面，无需做额外配置。 +如果无法正常启动图形界面，则可能需要先安装与显卡匹配的驱动程序。 +详情参考[在 WSL 上运行 Linux GUI 应用](https://learn.microsoft.com/zh-cn/windows/wsl/tutorials/gui-apps)。 +::: + +## WSL 常用命令 + +WSL 提供了命令 `wsl` 来管理 WSL。打开 CMD 后，即可在 CMD 中执行 `wsl` 命令。 +下面的命令假定已通过 WSL 安装 Ubuntu 22.04 LTS，且其名称为 Ubuntu。 + +查看 `wsl` 命令的完整帮助文档： +``` +$ wsl --help +``` + +列出所有已安装的 Linux 发行版的状态： +``` +$ wsl --list --online +``` + +检查 WSL 状态： +``` +$ wsl --status +``` + +停止正在运行的 Linux 发行版： +``` +$ wsl --terminate Ubuntu +``` + +注销并卸载某个 Linux 发行版： +``` +$ wsl --unregister Ubuntu +``` + +开启 WSL 后，Linux 发行版的默认安装位置是 C 盘。为了避免占用 C 盘的大量空间， +可以将已安装的 Linux 发行版导出备份，再导入还原到其它盘，最后删除 C 盘上的发行版。 +这样做的另一个好处是导入时用户就能得到 WSL 的真实路径。打开 CMD，执行如下命令: +``` +# 导出 Linux 发行版，可做为备份 +# 在 D 盘中新建备份目录，命名为 WSLBAK +$ mkdir D:\WSLBAK +# 导出到备份目录下，命名为 20210117bak.tar +$ wsl --export Ubuntu D:\WSLBAK\20210117bak.tar +# 导入并还原之前备份的 Linux 发行版 +# 此例中选择在 D 盘中新建还原目录，命名为 Ubuntu22.04 +$ mkdir D:\WSLDIR\Ubuntu22.04 +# 导入并还原之前的备份，将此发行版命名为 Ubuntu22.04 +$ wsl --import Ubuntu22.04 D:\WSLDIR\Ubuntu22.04 D:\WSLBAK\20210117bak.tar +# 删除 C 盘里名为 Ubuntu 的发行版，以释放 C 盘空间 +$ wsl --unregister Ubuntu +``` + +## 跨系统文件互访 + +WSL 有 WSL1 和 WSL2 两个版本。WSL2 是安装 Linux 发行版时的默认版本，其在各方面都优于 WSL1。 +但在跨系统访问文件方面（即在 Windows 下访问 WSL 中的文件或在 WSL 下访问 Windows 中的文件）， +WSL1 的速度要远远快于 WSL2。因而，在使用 WSL2 时，建议尽量将处理的文件放在 WSL 中， +以避免跨系统访问文件。 + +对于有经常跨系统操作文件的需求，可以使用如下命令将 Linux 发行版（假定名为 Ubuntu）从 WSL2 转换为 WSL1： +``` +$ wsl --set-version Ubuntu 1 +``` +同样的，也可以使用如下命令将 Linux 发行版（假定名为 Ubuntu）从 WSL1 转换为 WSL2： +``` +$ wsl --set-version Ubuntu 2 +``` + +### WSL 访问 Windows + +Windows 系统的硬盘挂载在 WSL 的 `/mnt` 路径下，用户可以在 WSL 终端中 +输入 `cd /mnt/d` 命令进入 Windows 系统的 D 盘，然后便可编辑和运行 D 盘中的文件。 + +### Windows 访问 WSL + +在 Windows 下搜索、打开和编辑 WSL 下的文件和目录的方式有以下两种： + +1. 在 Windows 资源管理器的地址栏中输入 `\\wsl$`，会显示所有已安装的 WSL 目录， + 然后根据需要找到文件进行操作 +2. 进入 WSL，在终端输入 `cd ~ && explorer.exe .`，会在 Windows 下打开 + 家目录，根据需要找到文件进行操作 + +在 Windows 下访问 WSL 文件系统时，文件和目录的路径有两种表示方式： +真实路径和 UNC 路径，后者指类似 `\\wsl$` 这种格式的路径。 + +WSL1 支持真实路径访问，但 WSL2 不支持真实路径访问。 + +Windows 的 CMD 不支持 UNC 路径，所以使用 CMD 时，只能用 +真实路径访问 WSL1 文件系统，无法用 UNC 路径访问 WSL1 文件系统，也无法用真实路径 +和 UNC 路径访问 WSL2 文件系统。 + +Windows 的应用程序可以使用真实路径访问 WSL1 文件系统，某些支持 UNC 路径的 +软件（如 MATLAB）还可以通过 UNC 路径访问 WSL1 或 WSL2 文件系统。 + +因此，如果想使用 Windows 的 CMD 以及应用程序编译或运行 WSL 中的文件， +需要先把 Linux 发行版切换到 WSL1 版本，进入 WSL 后新建一个名字独特的文件夹， +然后在 Windows 中对该文件夹进行定位，从而确定其真实的路径。 + +:::{note} +推荐在 Windows 中安装 [Everything](https://www.voidtools.com/zh-cn/) +实现文件夹和文件的快速定位。 + +推荐使用 [Windows Terminal](https://docs.microsoft.com/zh-cn/windows/terminal/)， +可直接在 Microsoft Store 中安装。界面美观、操作方便， +支持同时开启多个 CMD 以及 WSL，随意切换无卡顿。可完全替代 CMD。 + +推荐使用 [Visual Studio Code](https://code.visualstudio.com/)，并安装插件 +[Remote - WSL](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl)。 +使用 VSCode 可以直接编辑和运行 WSL 里的文件，且不会因为跨文件系统工作使性能下降。 +::: + +## 扩展阅读 + +- [比较 WSL2 和 WSL1](https://learn.microsoft.com/zh-cn/windows/wsl/compare-versions) diff --git a/_sources/exercises/analysis.md b/_sources/exercises/analysis.md new file mode 100644 index 000000000..787566afb --- /dev/null +++ b/_sources/exercises/analysis.md @@ -0,0 +1,4 @@ +# 数据分析 + +这一节介绍地震学数据的常见分析方法。 + diff --git a/_sources/exercises/catalog-analysis.ipynb b/_sources/exercises/catalog-analysis.ipynb new file mode 100644 index 000000000..563b89d39 --- /dev/null +++ b/_sources/exercises/catalog-analysis.ipynb @@ -0,0 +1,336 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7136e4d2", + "metadata": {}, + "source": [ + "# 分析地震目录\n", + "\n", + "- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿）\n", + "- 最近更新日期: 2022-07-31\n", + "- 预计花费时间: 15 分钟\n", + "\n", + "---\n", + "\n", + "在获取地震目录之后，通常还需要对地震目录做一些简单的绘图和分析。这一节演示如何\n", + "绘制最简单的地震深度直方图、地震震级直方图以及震级-频次关系图。\n", + "\n", + "首先，需要把地震目录准备好。这里我们选择下载 2000–2010 年间震级大于 4.8 级，\n", + "震源深度大于 50 km 的地震。这一地震目录中共计约 7000 个地震：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "06c2b30b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6980 Event(s) in Catalog:\n", + "2009-12-31T17:42:15.960000Z | -19.747, -177.753 | 5.4 mwc | manual\n", + "2009-12-31T09:06:01.250000Z | -7.499, +127.930 | 5.1 mb | manual\n", + "...\n", + "2000-01-02T12:14:39.090000Z | -17.943, -178.476 | 5.5 mwc | manual\n", + "2000-01-01T05:24:35.290000Z | +36.874, +69.947 | 5.1 mwc | manual\n", + "To see all events call 'print(CatalogObject.__str__(print_all=True))'\n" + ] + } + ], + "source": [ + "from obspy.clients.fdsn import Client\n", + "\n", + "client = Client(\"USGS\")\n", + "cat = client.get_events(\n", + " starttime=\"2000-01-01\",\n", + " endtime=\"2010-01-01\",\n", + " minmagnitude=4.8,\n", + " mindepth=50,\n", + ")\n", + "print(cat)" + ] + }, + { + "cell_type": "markdown", + "id": "0628b2f8", + "metadata": {}, + "source": [ + "为了进一步对数据做处理以及绘图，我们还需要导入 [NumPy](https://numpy.org/)\n", + "和 [Matplotlib](https://matplotlib.org/) 模块：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1575ea7c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "4fe79c1b", + "metadata": {}, + "source": [ + "## 地震深度分布直方图\n", + "\n", + "为了绘制地震深度直方图，我们先从地震目录中提取出地震深度信息，并保存到数组 `depth` 中。\n", + "需要注意的是，ObsPy 的地震目录中地震深度的单位为 m，所以需要除以 1000.0 将深度单位\n", + "转换为 km。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9d2f89ae", + "metadata": {}, + "outputs": [], + "source": [ + "depth = np.array([event.origins[0].depth / 1000 for event in cat])" + ] + }, + { + "cell_type": "markdown", + "id": "1b8f5433", + "metadata": {}, + "source": [ + "我们可以使用 Matplotlib 的 {meth}`~matplotlib.axes.Axes.hist()` 函数绘制直方图：\n", + "这里我们设置的直方的最小值为 50，最大值 700，间隔为 10，同时设置了 Y 轴以对数方式显示。\n", + "从图中可以明显看到地震深度随着深度的变化：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ac6edccd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGwCAYAAACgi8/jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvMUlEQVR4nO3deXgUVb7G8bezEBJDwp5FVkHBCAQhOBKRISgggldkFPQquzoMQRDECDIjyyjg6CAXbUDcWMYrOrIoisQoyCJuBCJLGBQJhoHEDCBJiBogqfuHD30nJDCpTjWdVH0/z9OP9Knqql8fInmfU+dUuQzDMAQAAGBDAf4uAAAAwFcIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLaC/F2AP5WWluro0aOqU6eOXC6Xv8sBAACVYBiGCgsLFRsbq4CAi4/ZODroHD16VE2bNvV3GQAAwAuHDx9WkyZNLrqPo4NOnTp1JP3aUREREX6uBgAAVEZBQYGaNm3q+T1+MY4OOucuV0VERBB0AACoYSoz7YTJyAAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLaC/F1AVRUWFqpnz546c+aMSkpKNG7cOD3wwAP+LkuS1GLy+xfcdmhOv0tYCQAAzlTjg05YWJg2bdqksLAw/fTTT2rXrp0GDhyoBg0a+Ls0AADgZzX+0lVgYKDCwsIkSb/88otKSkpkGIafqwIAANWB34PO5s2bddtttyk2NlYul0tr1qwpt8+CBQvUsmVL1a5dW507d9aWLVvKbD958qTi4+PVpEkTpaSkqGHDhpeoegAAUJ35PegUFRUpPj5eL7zwQoXb33zzTT388MOaOnWqdu7cqRtvvFF9+/ZVdna2Z5+6devq66+/VlZWlv73f/9XP/zww6UqHwAAVGN+Dzp9+/bVk08+qYEDB1a4fe7cuRo1apTuv/9+XX311Zo3b56aNm2qhQsXlts3KipKHTp00ObNmys8VnFxsQoKCsq8AACAffk96FzM6dOnlZ6ert69e5dp7927t7Zt2yZJ+uGHHzyBpaCgQJs3b1abNm0qPN7s2bMVGRnpeTVt2tS3XwAAAPhVtQ46x44dU0lJiaKiosq0R0VFKTc3V5L0z3/+U927d1d8fLy6deumsWPHqkOHDhUeb8qUKcrPz/e8Dh8+7PPvAAAA/KdGLC93uVxl3huG4Wnr3LmzMjIyKnWckJAQhYSEWF0eAACopqr1iE7Dhg0VGBjoGb05Jy8vr9woDwAAwPmqddCpVauWOnfurLS0tDLtaWlpSkxM9FNVAACgpvD7patTp07pwIEDnvdZWVnKyMhQ/fr11axZM02cOFFDhgxRQkKCunbtqsWLFys7O1ujR4/2Y9UAAKAm8HvQ2b59u5KSkjzvJ06cKEkaNmyYlixZosGDB+v48eOaOXOmcnJy1K5dO61bt07Nmzf3+pxut1tut1slJSVVrh8AAFRfLsPBz0soKChQZGSk8vPzFRERYfnxeagnAADWM/P7u1rP0QEAAKgKgg4AALAtgg4AALAtgg4AALAtgg4AALAtvy8v94fqsLycFVkAAPieI0d0kpOTlZmZqa+++srfpQAAAB9yZNABAADOQNABAAC2RdABAAC2RdABAAC2RdABAAC2RdABAAC25cig43a7FRcXpy5duvi7FAAA4EOODDrcRwcAAGdwZNABAADOQNABAAC2RdABAAC2RdABAAC2RdABAAC2RdABAAC2RdABAAC25cigww0DAQBwBkcGHW4YCACAMzgy6AAAAGcg6AAAANsi6AAAANsi6AAAANsi6AAAANsK8ncBKK/F5PcvuO3QnH6XsBIAAGo2RnQAAIBtEXQAAIBtEXQAAIBtOTLo8AgIAACcwZFBh0dAAADgDI4MOgAAwBkIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLZ4BIRD8FgJAIATMaIDAABsi6ADAABsi6ADAABsi6ADAABsi8nINQyTigEAqDxGdAAAgG05Mujw9HIAAJzBkUGHp5cDAOAMjgw6AADAGQg6AADAtgg6AADAtlhebiMXW3oOAIATMaIDAABsixEdcBNCAIBtMaIDAABsi6ADAABsi6ADAABsi6ADAABsi6ADAABsi1VXuChWZAEAajJGdAAAgG0RdAAAgG0RdAAAgG05Mui43W7FxcWpS5cu/i4FAAD4kCODTnJysjIzM/XVV1/5uxQAAOBDjgw6AADAGQg6AADAtgg6AADAtgg6AADAtgg6AADAtgg6AADAtgg6AADAtnioJ7zGAz8BANWd6RGdpUuX6v33//8XXEpKiurWravExER9//33lhYHAABQFaaDzqxZsxQaGipJ+uyzz/TCCy/oL3/5ixo2bKgJEyZYXiAAAIC3TF+6Onz4sFq3bi1JWrNmje688049+OCDuuGGG9SjRw+r6wMAAPCa6RGd8PBwHT9+XJL04Ycf6uabb5Yk1a5dWz///LO11QEAAFSB6RGdXr166f7779e1116rb775Rv36/TrpdO/evWrRooXV9QEAAHjN9IiO2+1W165d9a9//UsrV65UgwYNJEnp6em65557LC8QAADAW6ZHdOrWrasXXnihXPuMGTMsKQgAAMAqXt0wcMuWLbrvvvuUmJioI0eOSJKWL1+urVu3WlocAABAVZgOOitXrlSfPn0UGhqqHTt2qLi4WJJUWFioWbNmWV4gAACAt0xfunryySe1aNEiDR06VCtWrPC0JyYmaubMmZYWh5qLuyYDAKoD0yM6+/fvV/fu3cu1R0RE6OTJk1bUBAAAYAnTQScmJkYHDhwo175161ZdccUVlhQFAABgBdNB5/e//73Gjx+vL774Qi6XS0ePHtXrr7+uSZMmacyYMb6oEQAAwCum5+ikpKQoPz9fSUlJ+uWXX9S9e3eFhIRo0qRJGjt2rC9qBAAA8IrpoHP69Gk99dRTmjp1qjIzM1VaWqq4uDiFh4fr2LFjatiwoS/qtJTb7Zbb7VZJSYm/SwEAAD5k+tLVoEGDVFpaqrCwMCUkJOi6665TeHi4fvjhhxrzUM/k5GRlZmbqq6++8ncpAADAh0wHnZycHI0aNapcW48ePdS2bVvLCgMAAKgq00Fn3bp1+vLLLzVhwgRJ0pEjR9SjRw+1b99eb731luUFAgAAeMv0HJ0GDRooNTVV3bp1kyS9//776tSpk15//XUFBHj1RAk4zMVuJihxQ0EAgHVMBx1JatKkidLS0tStWzf16tVLy5cvl8vlsro2AACAKqlU0KlXr16FQeann37S2rVr1aBBA0/biRMnrKsOAACgCioVdObNm+fjMgAAAKxXqaAzbNgwX9cBAABgOa/m6Jzz888/68yZM2XaIiIiqlQQAACAVUwvkyoqKtLYsWPVuHFjhYeHq169emVeAAAA1YXpoJOSkqINGzZowYIFCgkJ0csvv6wZM2YoNjZWy5Yt80WNAAAAXjF96Wrt2rVatmyZevTooZEjR+rGG29U69at1bx5c73++uu69957fVEnAACAaaZHdE6cOKGWLVtK+nU+zrnl5N26ddPmzZutrQ4AAKAKTAedK664QocOHZIkxcXFeR77sHbtWtWtW9fK2gAAAKrEdNAZMWKEvv76a0nSlClTPHN1JkyYoEcffdTyAgEAALxleo7OuYd5SlJSUpL+8Y9/aPv27WrVqpXi4+MtLQ4AAKAqqnQfHUlq1qyZmjVrZkUtAAAAljIddGbOnHnR7U888YTXxQAAAFjJdNBZvXp1mfdnzpxRVlaWgoKC1KpVK4IOAACoNkwHnZ07d5ZrKygo0PDhw3XHHXdYUhQAAIAVXIZhGFYcaM+ePerfv79n6XlNUFBQoMjISOXn5/vkGV0tJr9v+TGd7tCcfv4uAQDgZ2Z+f5teXn4hJ0+eVH5+vlWHAwAAqDLTl67mz59f5r1hGMrJydHy5ct1yy23WFYYAABAVZkOOs8991yZ9wEBAWrUqJGGDRumKVOmWFYYUJGLXQ7kshYA4Hymg05WVpYv6gAAALCcZXN0AAAAqhvTIzp33HGHXC5XpfZdtWqV6YIAAACsYnpEJzIyUh9//LG2b9/uaUtPT9eGDRsUERGhyMhIzwsAAMCfTI/oREVFadCgQVq0aJECAwMlSSUlJRozZowiIiL0zDPPWF4kAACAN0yP6Lz66quaNGmSJ+RIUmBgoCZOnKhXX33V0uIAAACqwvSIztmzZ7Vv3z61adOmTPu+fftUWlpqWWHApcKSdQCwL9NBZ8SIERo5cqQOHDig66+/XpL0+eefa86cORoxYoTlBQIAAHjLdNB59tlnFR0dreeee045OTmSpJiYGKWkpOiRRx6xvEAAAABvmQ46AQEBSklJUUpKigoKCiTJJw/EBAAAqCrTQeffEXAAAEB1ZnrV1Q8//KAhQ4YoNjZWQUFBCgwMLPO61A4fPqwePXooLi5OHTp00N///vdLXgMAAKieTI/oDB8+XNnZ2frTn/6kmJiYSt8l2VeCgoI0b948dezYUXl5eerUqZNuvfVWXXbZZX6tCwAA+J/poLN161Zt2bJFHTt29EE55sXExCgmJkaS1LhxY9WvX18nTpwg6AAAAPNBp2nTpjIMw7ICNm/erGeeeUbp6enKycnR6tWrNWDAgDL7LFiwQM8884xycnJ0zTXXaN68ebrxxhvLHWv79u0qLS1V06ZNLasPNQf3wwEAnM900Jk3b54mT56sF198US1atKhyAUVFRYqPj9eIESP0u9/9rtz2N998Uw8//LAWLFigG264QS+++KL69u2rzMxMNWvWzLPf8ePHNXToUL388ssXPFdxcbGKi4s978+tGoP9XSwEAQDsy2VUYnimXr16ZebiFBUV6ezZswoLC1NwcHCZfU+cOOF9MS5XuRGd3/zmN+rUqZMWLlzoabv66qs1YMAAzZ49W9KvAaZXr1564IEHNGTIkAsef/r06ZoxY0a59vz8fJ+sIOOXa83HSBAAVD8FBQWKjIys1O/vSo3ozJs3z4q6TDt9+rTS09M1efLkMu29e/fWtm3bJEmGYWj48OHq2bPnRUOOJE2ZMkUTJ070vC8oKOAyFwAANlapoDNs2DBf11GhY8eOqaSkRFFRUWXao6KilJubK0n69NNP9eabb6pDhw5as2aNJGn58uVq3759ueOFhIQoJCTE53UDAIDqwfQcncDAQOXk5Khx48Zl2o8fP67GjRurpKTEsuLOOX8Ju2EYnrZu3brxMFEAAFAh0zcMvNCUnuLiYtWqVavKBf27hg0bKjAw0DN6c05eXl65UR4AAIDzVXpEZ/78+ZJ+HV15+eWXFR4e7tlWUlKizZs3q23btpYWV6tWLXXu3FlpaWm64447PO1paWm6/fbbLT0XAACwn0oHneeee07SryM6ixYtKvO4h1q1aqlFixZatGiR6QJOnTqlAwcOeN5nZWUpIyND9evXV7NmzTRx4kQNGTJECQkJ6tq1qxYvXqzs7GyNHj3a9LkAAICzVDroZGVlSZKSkpK0evVq1a1b15ICtm/frqSkJM/7c6uihg0bpiVLlmjw4ME6fvy4Zs6cqZycHLVr107r1q1T8+bNvT6n2+2W2+32yXwiAABQfVTqPjrnnDlzRm3atNF7772nuLg4X9Z1SZhZh+8N7qNT83EfHQCofsz8/jY1GTk4OFjFxcV+f5AnAABAZZhedfXQQw/p6aef1tmzZ31RDwAAgGVM30fniy++0Mcff6wPP/xQ7du3L/eU8FWrVllWHAAAQFWYDjp169at8OGbAAAA1Y3poPPaa6/5og4AAADLmQ46dsDycgDApXSxVbis7vQtr4LO22+/rbfeekvZ2dk6ffp0mW07duywpDBfSk5OVnJysmd5GgAAsCfTq67mz5+vESNGqHHjxtq5c6euu+46NWjQQAcPHlTfvn19USMAAIBXTI/oLFiwQIsXL9Y999yjpUuXKiUlRVdccYWeeOIJnThxwhc1An7DcDMA1GymR3Sys7OVmJgoSQoNDVVhYaEkaciQIXrjjTesrQ4AAKAKTAed6OhoHT9+XJLUvHlzff7555J+fRaWiadJAAAA+JzpoNOzZ0+tXbtWkjRq1ChNmDBBvXr10uDBg3XHHXdYXiAAAIC3TM/RWbx4sUpLSyVJo0ePVv369bV161bddtttGj16tOUFAgAAeMt00AkICFBAwP8PBA0aNEiDBg2ytChf4z46AAA4g1f30dmyZYtefPFFfffdd3r77bd1+eWXa/ny5WrZsqW6detmdY2W4z46AFAzsPIRVWV6js7KlSvVp08fhYaGaufOnSouLpYkFRYWatasWZYXCAAA4C3TQefJJ5/UokWL9NJLLyk4ONjTnpiYWCPuigwAAJzD9KWr/fv3q3v37uXaIyIidPLkSStqAmoEhtQBoPozPaITExOjAwcOlGvfunWrrrjiCkuKAgAAsILpoPP73/9e48eP1xdffCGXy6WjR4/q9ddf16RJkzRmzBhf1AgAAOAV05euUlJSlJ+fr6SkJP3yyy/q3r27QkJCNGnSJI0dO9YXNQIAAHjFq+XlTz31lKZOnarMzEyVlpYqLi5O4eHhVtcGAABQJV4FHUkKCwtTQkKClbVcMtwwEAAAZzA9R8cOkpOTlZmZqa+++srfpQAAAB9yZNABAADO4PWlKwAAaiLugeUslQo6nTp10scff6x69epp5syZmjRpksLCwnxdGwAAXrlYmPH2c4SgmqlSl6727dunoqIiSdKMGTN06tQpnxYFAABghUqN6HTs2FEjRoxQt27dZBiGnn322QsuJ3/iiScsLRAAAMBblQo6S5Ys0bRp0/Tee+/J5XLpgw8+UFBQ+Y+6XC6CDgDgkvD28hScpVJBp02bNlqxYoUkKSAgQB9//LEaN27s08IAAACqyvSqq9LSUl/UAQBAjcXoUvXl1fLy7777TvPmzdO+ffvkcrl09dVXa/z48WrVqpXV9QEAaghWLKE6Mn3DwNTUVMXFxenLL79Uhw4d1K5dO33xxRe65pprlJaW5osaLed2uxUXF6cuXbr4uxQAAOBDpkd0Jk+erAkTJmjOnDnl2h977DH16tXLsuJ8JTk5WcnJySooKFBkZKS/ywEAAD5iekRn3759GjVqVLn2kSNHKjMz05KiAAAArGA66DRq1EgZGRnl2jMyMliJBQAAqhXTl64eeOABPfjggzp48KASExPlcrm0detWPf3003rkkUd8USMAAIBXTAedP/3pT6pTp47++te/asqUKZKk2NhYTZ8+XePGjbO8QAAAAG+ZDjoul0sTJkzQhAkTVFhYKEmqU6eO5YUBAABUlVf30TmHgAMAAKqzKgUdABXjxmkAUD2YXnUFAABQUxB0AACAbZkKOmfOnFFSUpK++eYbX9UDAABgGVNzdIKDg7Vnzx65XC5f1QMAcBie/A1fMn3paujQoXrllVd8Ucslw0M9AQBwBtOrrk6fPq2XX35ZaWlpSkhI0GWXXVZm+9y5cy0rzld4qCcAAM5gOujs2bNHnTp1kqRyc3W4pAUAAKoT00Fn48aNvqgDAIBqjblENZPXy8sPHDig1NRU/fzzz5IkwzAsKwoAAMAKpoPO8ePHddNNN+mqq67SrbfeqpycHEnS/fffz9PLAQBAtWI66EyYMEHBwcHKzs5WWFiYp33w4MFav369pcUBAABUhek5Oh9++KFSU1PVpEmTMu1XXnmlvv/+e8sKAwAAqCrTQaeoqKjMSM45x44dU0hIiCVFAQDshYm88BfTl666d++uZcuWed67XC6VlpbqmWeeUVJSkqXFAQAAVIXpEZ1nnnlGPXr00Pbt23X69GmlpKRo7969OnHihD799FNf1AgAAOAV0yM6cXFx2rVrl6677jr16tVLRUVFGjhwoHbu3KlWrVr5okYAAACvmB7RkaTo6GjNmDHD6loAANUcc21Q03gVdH788Ue98sor2rdvn1wul66++mqNGDFC9evXt7o+AAAAr5m+dLVp0ya1bNlS8+fP148//qgTJ05o/vz5atmypTZt2uSLGgEAALxiekQnOTlZgwYN0sKFCxUYGChJKikp0ZgxY5ScnKw9e/ZYXiQAAE50sUuFh+b0u4SV1FymR3S+++47PfLII56QI0mBgYGaOHGivvvuO0uLAwAAqArTIzqdOnXSvn371KZNmzLt+/btU8eOHa2qy6fcbrfcbrdKSkr8XQoAVDtMOIadVCro7Nq1y/PncePGafz48Tpw4ICuv/56SdLnn38ut9utOXPm+KZKiyUnJys5OVkFBQWKjIz0dzkAAMBHKhV0OnbsKJfLJcMwPG0pKSnl9vvv//5vDR482LrqAAAAqqBSQScrK8vXdQAAAFiuUkGnefPmvq4DAADAcl7dMPDIkSP69NNPlZeXp9LS0jLbxo0bZ0lhgBOxlBQArGU66Lz22msaPXq0atWqpQYNGsjlcnm2uVwugg4AAKg2TAedJ554Qk888YSmTJmigADTt+EB4CVGewDAPNNJ5aefftLdd99NyAEAANWe6RGdUaNG6e9//7smT57si3oAAHAUbtDoW6aDzuzZs9W/f3+tX79e7du3V3BwcJntc+fOtaw4AACAqjAddGbNmqXU1FTPIyDOn4wM4NKz+/wdu38/AL5jOujMnTtXr776qoYPH+6DcgAAAKxjekZxSEiIbrjhBl/UAgAAYCnTIzrjx4/X888/r/nz5/uiHgCoFrhcBtiD6aDz5ZdfasOGDXrvvfd0zTXXlJuMvGrVKsuKAwAAqArTQadu3boaOHCgL2oBgBqB0R6g5vDqERAAAAA1Abc3BgAAtmV6RKdly5YXvV/OwYMHq1QQAJjBZSQAF2M66Dz88MNl3p85c0Y7d+7U+vXr9eijj1pVFwAAQJV5tby8Im63W9u3b69yQQAAAFaxbI5O3759tXLlSqsOBwAAUGWWBZ23335b9evXt+pwAAAAVWb60tW1115bZjKyYRjKzc3Vv/71Ly1YsMDS4gAAAKrCdNAZMGBAmfcBAQFq1KiRevToobZt21pVl0+53W653W6VlJT4uxQ40MVWCV1qTl+xVJ3+LgD4humgM23aNF/UcUklJycrOTlZBQUFioyM9Hc5AADAR7hhIAAAsK1Kj+gEBARc9EaBkuRyuXT27NkqFwUAduT0S4WAP1Q66KxevfqC27Zt26bnn39ehmFYUhQAAIAVKh10br/99nJt//jHPzRlyhStXbtW9957r/785z9bWhwAAEBVmJ6MLElHjx7VtGnTtHTpUvXp00cZGRlq166d1bUBqKa4BAP4H/8fVo6pycj5+fl67LHH1Lp1a+3du1cff/yx1q5dS8gBAADVUqVHdP7yl7/o6aefVnR0tN54440KL2UBAABUJ5UOOpMnT1ZoaKhat26tpUuXaunSpRXut2rVKsuKA1B1NeWmeDWlTgA1S6WDztChQ//j8nIAAIDqpNJBZ8mSJT4sAwAAwHrcGRkAANiWV8vLAdgfc2bsjb9fOAUjOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLYIOgAAwLa4jw6AS+ZS37uFe8UAYEQHAADYFkEHAADYFkEHAADYFnN0AMBC3s4LutjnDs3p5205gOMxogMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLycgAANiMt5Pi7TjxnREdAABgWwQdAABgWwQdAABgWwQdAABgW0xGBmApnhhuPW/vmszfBWCTEZ077rhD9erV05133unvUgAAQDVii6Azbtw4LVu2zN9lAACAasYWQScpKUl16tTxdxkAAKCa8XvQ2bx5s2677TbFxsbK5XJpzZo15fZZsGCBWrZsqdq1a6tz587asmXLpS8UAADUOH4POkVFRYqPj9cLL7xQ4fY333xTDz/8sKZOnaqdO3fqxhtvVN++fZWdnW36XMXFxSooKCjzAgAA9uX3VVd9+/ZV3759L7h97ty5GjVqlO6//35J0rx585SamqqFCxdq9uzZps41e/ZszZgxo0r1AgDgRN6u/vM3v4/oXMzp06eVnp6u3r17l2nv3bu3tm3bZvp4U6ZMUX5+vud1+PBhq0oFAADVkN9HdC7m2LFjKikpUVRUVJn2qKgo5ebmet736dNHO3bsUFFRkZo0aaLVq1erS5cu5Y4XEhKikJAQn9cNAACqh2oddM5xuVxl3huGUaYtNTX1UpcEAABqgGp96aphw4YKDAwsM3ojSXl5eeVGeQAAAM5XrYNOrVq11LlzZ6WlpZVpT0tLU2Jiop+qAgAANYXfL12dOnVKBw4c8LzPyspSRkaG6tevr2bNmmnixIkaMmSIEhIS1LVrVy1evFjZ2dkaPXq01+d0u91yu90qKSmx4isAgN/wPCvg4vwedLZv366kpCTP+4kTJ0qShg0bpiVLlmjw4ME6fvy4Zs6cqZycHLVr107r1q1T8+bNvT5ncnKykpOTVVBQoMjIyCp/BwAAUD35Pej06NFDhmFcdJ8xY8ZozJgxl6giAABgF9V6jg4AAEBVEHQAAIBtEXQAAIBtEXQAAIBtOTLouN1uxcXFVfiYCAAAYB+ODDrJycnKzMzUV1995e9SAACADzky6AAAAGcg6AAAANsi6AAAANsi6AAAANsi6AAAANsi6AAAANvy+0M9/cHtdsvtdqukpMTfpQAAUG20mPy+v0uwnCNHdLiPDgAAzuDIoAMAAJyBoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGzLkUHH7XYrLi5OXbp08XcpAADAhxwZdLgzMgAAzuDIoAMAAJyBoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGyLoAMAAGzLkUGHR0AAAOAMjgw6PAICAABncGTQAQAAzkDQAQAAtkXQAQAAtkXQAQAAtkXQAQAAtkXQAQAAtkXQAQAAtkXQAQAAtkXQAQAAtkXQAQAAtkXQAQAAthXk7wL8we12y+12q6SkxN+lAABQ47WY/P4Ftx2a0+8SVlKeI0d0eKgnAADO4MigAwAAnIGgAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbIugAwAAbCvI3wX4k2EYkqSCggKfHL+0+CefHBcAgJrCF79jzx3z3O/xi3F00CksLJQkNW3a1M+VAABgT5HzfHfswsJCRUZGXnQfl1GZOGRTpaWlOnr0qOrUqSOXy+XvcnymoKBATZs21eHDhxUREeHvcqoV+qZi9MuF0TcVo18ujL6pWFX6xTAMFRYWKjY2VgEBF5+F4+gRnYCAADVp0sTfZVwyERER/E92AfRNxeiXC6NvKka/XBh9UzFv++U/jeScw2RkAABgWwQdAABgWwQdBwgJCdG0adMUEhLi71KqHfqmYvTLhdE3FaNfLoy+qdil6hdHT0YGAAD2xogOAACwLYIOAACwLYIOAACwLYIOAACwLYJODbV582bddtttio2Nlcvl0po1a8psNwxD06dPV2xsrEJDQ9WjRw/t3bu3zD7FxcV66KGH1LBhQ1122WX6r//6L/3zn/+8hN/CerNnz1aXLl1Up04dNW7cWAMGDND+/fvL7OPUvlm4cKE6dOjguTlX165d9cEHH3i2O7Vfzjd79my5XC49/PDDnjan9s306dPlcrnKvKKjoz3bndovknTkyBHdd999atCggcLCwtSxY0elp6d7tju1b1q0aFHuZ8blcik5OVmSn/rFQI20bt06Y+rUqcbKlSsNScbq1avLbJ8zZ45Rp04dY+XKlcbu3buNwYMHGzExMUZBQYFnn9GjRxuXX365kZaWZuzYscNISkoy4uPjjbNnz17ib2OdPn36GK+99pqxZ88eIyMjw+jXr5/RrFkz49SpU559nNo37777rvH+++8b+/fvN/bv3288/vjjRnBwsLFnzx7DMJzbL//uyy+/NFq0aGF06NDBGD9+vKfdqX0zbdo045prrjFycnI8r7y8PM92p/bLiRMnjObNmxvDhw83vvjiCyMrK8v46KOPjAMHDnj2cWrf5OXllfl5SUtLMyQZGzduNAzDP/1C0LGB84NOaWmpER0dbcyZM8fT9ssvvxiRkZHGokWLDMMwjJMnTxrBwcHGihUrPPscOXLECAgIMNavX3/Jave1vLw8Q5KxadMmwzDom/PVq1fPePnll+kXwzAKCwuNK6+80khLSzN++9vfeoKOk/tm2rRpRnx8fIXbnNwvjz32mNGtW7cLbndy35xv/PjxRqtWrYzS0lK/9QuXrmwoKytLubm56t27t6ctJCREv/3tb7Vt2zZJUnp6us6cOVNmn9jYWLVr186zjx3k5+dLkurXry+JvjmnpKREK1asUFFRkbp27Uq/SEpOTla/fv108803l2l3et98++23io2NVcuWLXX33Xfr4MGDkpzdL++++64SEhJ01113qXHjxrr22mv10ksvebY7uW/+3enTp/W3v/1NI0eOlMvl8lu/EHRsKDc3V5IUFRVVpj0qKsqzLTc3V7Vq1VK9evUuuE9NZxiGJk6cqG7duqldu3aS6Jvdu3crPDxcISEhGj16tFavXq24uDjH98uKFSu0Y8cOzZ49u9w2J/fNb37zGy1btkypqal66aWXlJubq8TERB0/ftzR/XLw4EEtXLhQV155pVJTUzV69GiNGzdOy5Ytk+Tsn5l/t2bNGp08eVLDhw+X5L9+cfTTy+3O5XKVeW8YRrm281Vmn5pi7Nix2rVrl7Zu3Vpum1P7pk2bNsrIyNDJkye1cuVKDRs2TJs2bfJsd2K/HD58WOPHj9eHH36o2rVrX3A/J/ZN3759PX9u3769unbtqlatWmnp0qW6/vrrJTmzX0pLS5WQkKBZs2ZJkq699lrt3btXCxcu1NChQz37ObFv/t0rr7yivn37KjY2tkz7pe4XRnRs6NyqiPPTb15enidJR0dH6/Tp0/rxxx8vuE9N9tBDD+ndd9/Vxo0b1aRJE0+70/umVq1aat26tRISEjR79mzFx8frf/7nfxzdL+np6crLy1Pnzp0VFBSkoKAgbdq0SfPnz1dQUJDnuzmxb8532WWXqX379vr2228d/TMTExOjuLi4Mm1XX321srOzJfHvjCR9//33+uijj3T//fd72vzVLwQdG2rZsqWio6OVlpbmaTt9+rQ2bdqkxMRESVLnzp0VHBxcZp+cnBzt2bPHs09NZBiGxo4dq1WrVmnDhg1q2bJlme1O7puKGIah4uJiR/fLTTfdpN27dysjI8PzSkhI0L333quMjAxdccUVju2b8xUXF2vfvn2KiYlx9M/MDTfcUO62Fd98842aN28uiX9nJOm1115T48aN1a9fP0+b3/rFqynM8LvCwkJj586dxs6dOw1Jxty5c42dO3ca33//vWEYvy7hi4yMNFatWmXs3r3buOeeeypcwtekSRPjo48+Mnbs2GH07Nmzxi9t/MMf/mBERkYan3zySZkljj/99JNnH6f2zZQpU4zNmzcbWVlZxq5du4zHH3/cCAgIMD788EPDMJzbLxX591VXhuHcvnnkkUeMTz75xDh48KDx+eefG/379zfq1KljHDp0yDAM5/bLl19+aQQFBRlPPfWU8e233xqvv/66ERYWZvztb3/z7OPUvjEMwygpKTGaNWtmPPbYY+W2+aNfCDo11MaNGw1J5V7Dhg0zDOPX5Y3Tpk0zoqOjjZCQEKN79+7G7t27yxzj559/NsaOHWvUr1/fCA0NNfr3729kZ2f74dtYp6I+kWS89tprnn2c2jcjR440mjdvbtSqVcto1KiRcdNNN3lCjmE4t18qcn7QcWrfnLvHSXBwsBEbG2sMHDjQ2Lt3r2e7U/vFMAxj7dq1Rrt27YyQkBCjbdu2xuLFi8tsd3LfpKamGpKM/fv3l9vmj35xGYZheDcWBAAAUL0xRwcAANgWQQcAANgWQQcAANgWQQcAANgWQQcAANgWQQcAANgWQQcAANgWQQcAANgWQQeALRw6dEgul0sZGRmmP7thwwa1bdtWpaWlkqTp06erY8eO1hYoqUuXLlq1apXlxwVwYQQdAFU2fPhwuVwuuVwuBQcHKyoqSr169dKrr77qCQ9Wn2/AgAGWHS8lJUVTp05VQIBv/0n805/+pMmTJ/ukTwBUjKADwBK33HKLcnJydOjQIX3wwQdKSkrS+PHj1b9/f509e9bf5V3Qtm3b9O233+quu+7y+bn69eun/Px8paam+vxcAH5F0AFgiZCQEEVHR+vyyy9Xp06d9Pjjj+udd97RBx98oCVLlnj2y8/P14MPPqjGjRsrIiJCPXv21Ndff+3Zfu6y0YsvvqimTZsqLCxMd911l06ePOnZvnTpUr3zzjueUaRPPvnE8/mDBw8qKSlJYWFhio+P12effXbRulesWKHevXurdu3aF9wnKytLrVu31h/+8AeVlpZqyZIlqlu3rt577z21adNGYWFhuvPOO1VUVKSlS5eqRYsWqlevnh566CGVlJR4jhMYGKhbb71Vb7zxhrnOBeA1gg4An+nZs6fi4+M981IMw1C/fv2Um5urdevWKT09XZ06ddJNN92kEydOeD534MABvfXWW1q7dq3Wr1+vjIwMJScnS5ImTZqkQYMGeUaQcnJylJiY6Pns1KlTNWnSJGVkZOiqq67SPffcc9ERpc2bNyshIeGC2/fs2aMbbrhBd911lxYuXOi5vPXTTz9p/vz5WrFihdavX69PPvlEAwcO1Lp167Ru3TotX75cixcv1ttvv13meNddd522bNlivjMBeCXI3wUAsLe2bdtq165dkqSNGzdq9+7dysvLU0hIiCTp2Wef1Zo1a/T222/rwQcflCT98ssvWrp0qZo0aSJJev7559WvXz/99a9/VXR0tEJDQ1VcXKzo6Ohy55s0aZL69esnSZoxY4auueYaHThwQG3btq2wvkOHDik2NrbCbZ999pn69++vKVOmaNKkSWW2nTlzRgsXLlSrVq0kSXfeeaeWL1+uH374QeHh4YqLi1NSUpI2btyowYMHez53+eWXKzs7W6WlpT6fEwSAER0APmYYhlwulyQpPT1dp06dUoMGDRQeHu55ZWVl6bvvvvN8plmzZp6QI0ldu3ZVaWmp9u/f/x/P16FDB8+fY2JiJEl5eXkX3P/nn3+u8LJVdna2br75Zv3xj38sF3IkKSwszBNyJCkqKkotWrRQeHh4mbbzzx0aGqrS0lIVFxf/x+8CoOoY0QHgU/v27VPLli0lSaWlpYqJiSkzp+acunXrXvAY54LSuf9eTHBwcLnPXWyVU8OGDfXjjz+Wa2/UqJFiY2O1YsUKjRo1ShERERc8z7lzVdR2/rlPnDihsLAwhYaG/sfvAqDqGNEB4DMbNmzQ7t279bvf/U6S1KlTJ+Xm5iooKEitW7cu82rYsKHnc9nZ2Tp69Kjn/WeffaaAgABdddVVkqRatWqVmeRbFddee60yMzPLtYeGhuq9995T7dq11adPHxUWFlpyvj179qhTp06WHAvAf0bQAWCJ4uJi5ebm6siRI9qxY4dmzZql22+/Xf3799fQoUMlSTfffLO6du2qAQMGKDU1VYcOHdK2bdv0xz/+Udu3b/ccq3bt2ho2bJi+/vprbdmyRePGjdOgQYM8c3JatGihXbt2af/+/Tp27JjOnDnjdd19+vTR1q1bK9x22WWX6f3331dQUJD69u2rU6dOeX2ec7Zs2aLevXtX+TgAKoegA8AS69evV0xMjFq0aKFbbrlFGzdu1Pz58/XOO+8oMDBQ0q+XctatW6fu3btr5MiRuuqqq3T33Xfr0KFDioqK8hyrdevWGjhwoG699Vb17t1b7dq104IFCzzbH3jgAbVp00YJCQlq1KiRPv30U6/rvu+++5SZmXnB+T/h4eH64IMPZBiGbr31VhUVFXl9riNHjmjbtm0aMWKE18cAYI7LMAzD30UAwDnTp0/XmjVrvHqUg7dSUlKUn5+vF1980afnefTRR5Wfn6/Fixf79DwA/h8jOgAcb+rUqWrevLll834upHHjxvrzn//s03MAKItVVwAcLzIyUo8//rjPz/Poo4/6/BwAyuLSFQAAsC0uXQEAANsi6AAAANsi6AAAANsi6AAAANsi6AAAANsi6AAAANsi6AAAANsi6AAAANv6P0nCi0DKkfeaAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/catalog-analysis_7_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.hist(depth, bins=np.arange(50, 700, 10), log=True)\n", + "ax.set_xlabel(\"Depth (km)\")\n", + "ax.set_ylabel(\"Number of earthquakes\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0999fe1a", + "metadata": {}, + "source": [ + "## 地震震级直方图\n", + "\n", + "同理，从地震目录中提取出地震震级信息，保存到数组 `mag` 中并绘图。从图中可以明显看到，\n", + "震级越小地震数目越多：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "162e96a8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/catalog-analysis_9_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "mag = np.array([event.magnitudes[0].mag for event in cat])\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.hist(mag, bins=np.arange(4.5, 8, 0.1))\n", + "ax.set_xlabel(\"Magnitude\")\n", + "ax.set_ylabel(\"Number of earthquakes\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0cc6d220", + "metadata": {}, + "source": [ + "## 地震震级-频度关系\n", + "\n", + "地震震级-频度关系应符合 Gutenberg–Richter 定律。为了绘制地震震级-频度关系，\n", + "首先需要计算得到 GR 定律里的 $N$，即大于等于某个特定震级 $M$ 的地震数目。\n", + "这里，我们选择 $M$ 的取值范围为 4.0 到 8.0，间隔为 0.1。计算 $N$ 的方法有很多，下面的\n", + "方法使用了 Python 的列表表达式以及 {func}`numpy.sum()` 函数来实现：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a7810f99", + "metadata": {}, + "outputs": [], + "source": [ + "mw = np.arange(4.0, 8.0, 0.1)\n", + "counts = np.array([(mag >= m).sum() for m in mw])" + ] + }, + { + "cell_type": "markdown", + "id": "2d8ea2e3", + "metadata": {}, + "source": [ + "绘图脚本如下，注意图中 Y 轴是对数坐标。从图中可以明显看到 $\\log_{10}N$ 与 $M$ 在 4.8 - 7.6 级\n", + "之间存在线性关系。由于我们使用的地震目录里只有 4.8 级以上的地震，所以在 4.7 级以下偏离了线性关系，而大地震由于数目太少也偏离了线性关系。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6d0617e9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/catalog-analysis_13_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.semilogy(mw, counts, \"o\")\n", + "ax.set_xlabel(\"Magnitude\")\n", + "ax.set_ylabel(\"Cumulative Number of earthquakes\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9802c615", + "metadata": {}, + "source": [ + "更进一步，我们可以对 4.8-7.6 级之间的数据进行线性拟合，得到 GR 定律中的系数 $a$ 和 $b$。\n", + "这里我们采用 {data}`numpy.logical_and` 函数找到数组 `mw` 中所有满足条件的元素的索引，\n", + "并使用 NumPy 的布尔索引功能筛选出满足条件的震级 `mw[idx]` 和对应的 `counts[idx]`，再\n", + "使用 {func}`numpy.polyfit` 函数拟合一元一次多项式，最后绘图：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a49d823f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/catalog-analysis_15_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "idx = np.logical_and(mw >= 4.8, mw <= 7.5)\n", + "# fitting y = p[0] * x + p[1]\n", + "p = np.polyfit(mw[idx], np.log10(counts[idx]), 1)\n", + "N_pred = 10 ** (mw * p[0] + p[1])\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.semilogy(mw, counts, \"o\")\n", + "ax.semilogy(mw, N_pred, color=\"red\", label=f\"$\\log_{{10}} N={p[1]:.2f}{p[0]:.2f}M$\")\n", + "ax.legend()\n", + "ax.set_xlabel(\"Magnitude\")\n", + "ax.set_ylabel(\"Cumulative Number of earthquakes\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst", + "format_version": 0.13, + "jupytext_version": "1.13.0" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "source_map": [ + 12, + 27, + 38, + 42, + 45, + 53, + 55, + 60, + 66, + 73, + 81, + 89, + 92, + 96, + 102, + 108 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_sources/exercises/catalog-analysis.md b/_sources/exercises/catalog-analysis.md new file mode 100644 index 000000000..9f29fdb10 --- /dev/null +++ b/_sources/exercises/catalog-analysis.md @@ -0,0 +1,121 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.13.0 +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# 分析地震目录 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2022-07-31 +- 预计花费时间: 15 分钟 + +--- + +在获取地震目录之后，通常还需要对地震目录做一些简单的绘图和分析。这一节演示如何 +绘制最简单的地震深度直方图、地震震级直方图以及震级-频次关系图。 + +首先，需要把地震目录准备好。这里我们选择下载 2000–2010 年间震级大于 4.8 级， +震源深度大于 50 km 的地震。这一地震目录中共计约 7000 个地震： +```{code-cell} ipython3 +from obspy.clients.fdsn import Client + +client = Client("USGS") +cat = client.get_events( + starttime="2000-01-01", + endtime="2010-01-01", + minmagnitude=4.8, + mindepth=50, +) +print(cat) +``` + +为了进一步对数据做处理以及绘图，我们还需要导入 [NumPy](https://numpy.org/) +和 [Matplotlib](https://matplotlib.org/) 模块： +```{code-cell} ipython3 +import matplotlib.pyplot as plt +import numpy as np +``` + +## 地震深度分布直方图 + +为了绘制地震深度直方图，我们先从地震目录中提取出地震深度信息，并保存到数组 `depth` 中。 +需要注意的是，ObsPy 的地震目录中地震深度的单位为 m，所以需要除以 1000.0 将深度单位 +转换为 km。 + +```{code-cell} ipython3 +depth = np.array([event.origins[0].depth / 1000 for event in cat]) +``` + +我们可以使用 Matplotlib 的 {meth}`~matplotlib.axes.Axes.hist()` 函数绘制直方图： +这里我们设置的直方的最小值为 50，最大值 700，间隔为 10，同时设置了 Y 轴以对数方式显示。 +从图中可以明显看到地震深度随着深度的变化： +```{code-cell} ipython3 +fig, ax = plt.subplots() +ax.hist(depth, bins=np.arange(50, 700, 10), log=True) +ax.set_xlabel("Depth (km)") +ax.set_ylabel("Number of earthquakes") +plt.show() +``` + +## 地震震级直方图 + +同理，从地震目录中提取出地震震级信息，保存到数组 `mag` 中并绘图。从图中可以明显看到， +震级越小地震数目越多： + +```{code-cell} ipython3 +mag = np.array([event.magnitudes[0].mag for event in cat]) + +fig, ax = plt.subplots() +ax.hist(mag, bins=np.arange(4.5, 8, 0.1)) +ax.set_xlabel("Magnitude") +ax.set_ylabel("Number of earthquakes") +plt.show() +``` + +## 地震震级-频度关系 + +地震震级-频度关系应符合 Gutenberg–Richter 定律。为了绘制地震震级-频度关系， +首先需要计算得到 GR 定律里的 $N$，即大于等于某个特定震级 $M$ 的地震数目。 +这里，我们选择 $M$ 的取值范围为 4.0 到 8.0，间隔为 0.1。计算 $N$ 的方法有很多，下面的 +方法使用了 Python 的列表表达式以及 {func}`numpy.sum()` 函数来实现： +```{code-cell} ipython3 +mw = np.arange(4.0, 8.0, 0.1) +counts = np.array([(mag >= m).sum() for m in mw]) +``` + +绘图脚本如下，注意图中 Y 轴是对数坐标。从图中可以明显看到 $\log_{10}N$ 与 $M$ 在 4.8 - 7.6 级 +之间存在线性关系。由于我们使用的地震目录里只有 4.8 级以上的地震，所以在 4.7 级以下偏离了线性关系，而大地震由于数目太少也偏离了线性关系。 +```{code-cell} ipython3 +fig, ax = plt.subplots() +ax.semilogy(mw, counts, "o") +ax.set_xlabel("Magnitude") +ax.set_ylabel("Cumulative Number of earthquakes") +plt.show() +``` + +更进一步，我们可以对 4.8-7.6 级之间的数据进行线性拟合，得到 GR 定律中的系数 $a$ 和 $b$。 +这里我们采用 {data}`numpy.logical_and` 函数找到数组 `mw` 中所有满足条件的元素的索引， +并使用 NumPy 的布尔索引功能筛选出满足条件的震级 `mw[idx]` 和对应的 `counts[idx]`，再 +使用 {func}`numpy.polyfit` 函数拟合一元一次多项式，最后绘图： +```{code-cell} ipython3 +idx = np.logical_and(mw >= 4.8, mw <= 7.5) +# fitting y = p[0] * x + p[1] +p = np.polyfit(mw[idx], np.log10(counts[idx]), 1) +N_pred = 10 ** (mw * p[0] + p[1]) + +fig, ax = plt.subplots() +ax.semilogy(mw, counts, "o") +ax.semilogy(mw, N_pred, color="red", label=f"$\log_{{10}} N={p[1]:.2f}{p[0]:.2f}M$") +ax.legend() +ax.set_xlabel("Magnitude") +ax.set_ylabel("Cumulative Number of earthquakes") +plt.show() +``` diff --git a/_sources/exercises/catalog.ipynb b/_sources/exercises/catalog.ipynb new file mode 100644 index 000000000..c2a0a6b78 --- /dev/null +++ b/_sources/exercises/catalog.ipynb @@ -0,0 +1,799 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "34569af6", + "metadata": {}, + "source": [ + "# 地震目录\n", + "\n", + "- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿）\n", + "- 最近更新日期: 2022-07-31\n", + "- 预计花费时间: 90 分钟\n", + "\n", + "---\n", + "\n", + "地震目录中包括了海量地震的信息，而通常用户只需要使用其中的一小部分，因而需要对\n", + "地震目录进行筛选。对地震目录进行筛选的准则一般有如下几条：\n", + "\n", + "- 根据地震发震时刻筛选\n", + "- 根据震中位置（即震中经纬度）筛选\n", + "- 根据震源深度筛选\n", + "- 根据地震震级筛选\n", + "\n", + "这一节介绍如何筛选、下载与使用地震目录。\n", + "\n", + "## 在线搜索和查看地震目录\n", + "\n", + "USGS 提供了可用于在线搜索和查看地震目录的网页工具。用户既可以手动筛选和下载\n", + "地震目录，也可以方便直观地查看地震分布情况。下面演示如何使用 USGS 网站在线搜索\n", + "和查看地震目录。\n", + "\n", + "1. 访问 USGS 地震目录网站: [https://earthquake.usgs.gov/earthquakes/search/](https://earthquake.usgs.gov/earthquakes/search/)，\n", + " 会看到如下搜索界面：\n", + "\n", + " :::{figure} usgs-catalog-1.jpg\n", + " :align: center\n", + " :alt: \"USGS 地震目录基本选项\"\n", + " :width: 100%\n", + " :::\n", + "\n", + " 搜索界面分为左中右三栏：\n", + "\n", + " - 左侧栏设置震级搜索范围，可以选择 2.5 级以上或 4.5 级以上地震，也可以自定义\n", + " 地震震级最小值和最大值\n", + " - 中间栏设置发震时刻搜索范围，可以选择最近 7 天或最近 30 天，也可以自定义\n", + " 发震时刻范围的开始时间和结束时间（UTC 时间）\n", + " - 右侧栏设置震中区域范围，可以选择全球地震、美国及周边地震，也可以在地图上\n", + " 选中一个矩形区域\n", + "\n", + "2. 在“高级选项”中可进一步对地震目录做筛选：\n", + "\n", + " :::{figure} usgs-catalog-2.jpg\n", + " :align: center\n", + " :alt: \"USGS 地震目录高级选项\"\n", + " :width: 100%\n", + " :::\n", + "\n", + " - **Geographic Region** 可以设置地震震中的范围，有两种设置方式：\n", + " 1. 指定经纬度范围限定一个矩形区域，North 必须大于 South，East 必须大于 West\n", + " 2. 指定中心点的经纬度和半径值（单位为 km）来限定一个圆形区域\n", + " - **Depth (km)** 用于限定地震的深度范围，深度单位为 km。\n", + " - **Review Status** 用于限定地震信息的审核状态。一般来说，经人工审核的地震信息\n", + " 更加准确，但由于人工审核需要一定的时间，因而最近几小时或几天的地震信息可能\n", + " 没有被人工审核过。而自动确定的地震信息实时性更好，但地震位置和震级等信息可能\n", + " 不太准确。\n", + " - 除此之外，还可以进一步限制事件类型、事件影响力、地震目录来源、地震信息贡献者以及地震产品\n", + " 类型等。读者可以自行探索。\n", + "\n", + "3. 在“输出选项”中可以设置要以什么格式输出地震目录：\n", + "\n", + " :::{figure} usgs-catalog-3.jpg\n", + " :align: center\n", + " :alt: \"USGS 地震目录输出选项\"\n", + " :width: 50%\n", + " :::\n", + "\n", + " USGS 网站支持输出多种格式的地震目录：\n", + "\n", + " - **Map & List**：在地图中显示地震目录，适合直观地查看地震分布情况\n", + " - **CSV**：CSV 格式，可以用 Excel 打开，也可以用 Python 的 [pandas](https://pandas.pydata.org/)\n", + " 模块处理\n", + " - **KML**：Google Earth KML 格式，可以在 Google Earth 中直接打开\n", + " - **QuakeML**: 地震学领域定义的标准地震目录格式，ObsPy 可以直接读取\n", + " - **GeoJSON**: 一种地理空间数据交换格式，多种软件和 Python 模块均可读取\n", + "\n", + "4. 所有选项选择完毕后，点击”Search“按钮，即可以根据指定的格式输出地震目录。\n", + "\n", + "读者可以尝试筛选出 2022 年上半年（1-6 月）全球震级大于 5.0 级、深度大于 70 km 的地震，并选择\n", + "以“Map & List”的方式输出。点击“Search”按钮后，会在浏览器中打开在线地图并展示地震分布。\n", + "左侧为地震列表，右侧为地震分布。读者可自行探索该界面中的各个按钮，以了解其更多功能。\n", + "\n", + ":::{figure} usgs-catalog-4.jpg\n", + ":align: center\n", + ":alt: \"USGS 地震目录在线地图\"\n", + ":width: 100%\n", + ":::\n", + "\n", + "## 使用 ObsPy 下载地震目录\n", + "\n", + "USGS 提供的在线工具可以很直观地下载地震目录并查看地震分布，但是却不够自动化。\n", + "ObsPy 提供了从不同的地震数据中心筛选和下载地震目录的功能，并可以对得到的地震目录进行\n", + "进一步分析和处理。\n", + "\n", + "下面演示如何使用 ObsPy 的 {meth}`Client.get_events() `\n", + "函数筛选和下载地震目录。\n", + "\n", + "首先，需要导入 ObsPy 中地震数据中心数据下载客户端 {class}`~obspy.clients.fdsn.client.Client`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "78030df4", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy.clients.fdsn import Client" + ] + }, + { + "cell_type": "markdown", + "id": "056c23df", + "metadata": {}, + "source": [ + "接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。\n", + "ObsPy 的 `Client` 支持多个地震数据中心。这里我们选择使用 USGS 地震数据中心：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f45c6980", + "metadata": {}, + "outputs": [], + "source": [ + "client = Client(\"USGS\")" + ] + }, + { + "cell_type": "markdown", + "id": "0c73cb0d", + "metadata": {}, + "source": [ + "{func}`Client.get_events() ` 函数\n", + "可以根据指定的参数对地震目录做筛选并下载。\n", + "下面我们将获取 2020 年上半年全球震级大于 5.0 级的地震：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e78c3de4", + "metadata": {}, + "outputs": [], + "source": [ + "cat = client.get_events(\n", + " starttime=\"2020-01-01\",\n", + " endtime=\"2020-07-01\",\n", + " minmagnitude=5.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "da67abed", + "metadata": {}, + "source": [ + "{func}`Client.get_events() ` 函数会根据\n", + "指定的参数向 USGS 地震数据中心发起请求，并返回筛选后的地震目录。其返回值是 {class}`~obspy.core.event.Catalog` 类型，\n", + "并被保存在变量 `cat` 中。\n", + "\n", + "下面我们看看变量 `cat` 中的内容：\n", + "`````{margin}\n", + "````{tip}\n", + "由于地震数目太多，默认没有打印所有地震的信息。如果想要打印所有地震的信息，可以\n", + "使用 `for` 循环语句对变量 `cat` 中的所有事件进行打印：\n", + "```python\n", + "for event in cat:\n", + " print(event)\n", + "```\n", + "````\n", + "`````" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5595c59c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "735 Event(s) in Catalog:\n", + "2020-06-30T22:10:09.644000Z | -19.543, +169.223 | 5.1 mb | manual\n", + "2020-06-30T09:24:23.549000Z | +38.154, -117.958 | 5.0 ml | manual\n", + "...\n", + "2020-01-01T03:53:29.023000Z | +52.637, +159.161 | 5.0 mb | manual\n", + "2020-01-01T00:28:20.289000Z | -5.324, +152.551 | 5.1 mb | manual\n", + "To see all events call 'print(CatalogObject.__str__(print_all=True))'\n" + ] + } + ], + "source": [ + "print(cat)" + ] + }, + { + "cell_type": "markdown", + "id": "219fa83b", + "metadata": {}, + "source": [ + "从输出中可以看到，该地震目录中包括了 735 个地震，并打印了若干个地震的基本信息。\n", + "\n", + "下面我们进一步限制震源深度最小值为 70 km。加上这一限制后，满足条件的地震只有 140 个。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f76f70b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "140 Event(s) in Catalog:\n", + "2020-06-30T22:10:09.644000Z | -19.543, +169.223 | 5.1 mb | manual\n", + "2020-06-24T15:38:34.463000Z | -1.602, -77.527 | 5.1 mww | manual\n", + "...\n", + "2020-01-04T07:18:18.092000Z | -36.855, +176.951 | 5.1 mww | manual\n", + "2020-01-03T15:28:54.137000Z | +11.739, -86.286 | 5.5 mww | manual\n", + "To see all events call 'print(CatalogObject.__str__(print_all=True))'\n" + ] + } + ], + "source": [ + "cat = client.get_events(\n", + " starttime=\"2020-01-01\",\n", + " endtime=\"2020-07-01\",\n", + " minmagnitude=5.0,\n", + " mindepth=70,\n", + ")\n", + "print(cat)" + ] + }, + { + "cell_type": "markdown", + "id": "bb3d1179", + "metadata": {}, + "source": [ + "{class}`~obspy.core.event.Catalog` 类提供了用于绘制地震分布的\n", + "{meth}`Catalog.plot() ` 函数，\n", + "可以直观地查看地震的分布情况。默认情况下，用圆圈表示地震，圆圈的大小代表地震\n", + "震级大小，圆圈的颜色代表地震的深度。\n", + "````{margin}\n", + "```{note}\n", + "{meth}`Catalog.plot() ` 函数会绘制地震分布图并返回一个\n", + "{class}`~matplotlib.figure.Figure` 的实例。\n", + "由于 Jupyter Notebook 会自动显示函数的返回值，因而在 Jupyter Notebook 中，地震分布图会绘制两次，\n", + "一次由 `cat.plot()` 函数主动绘制，一次由 Jupyter Notebook 显示函数返回值（即 Figure 实例）时绘制。\n", + "因而，此处的代码中在 `cat.plot()` 的后面加上了分号 `;`，使得 Jupyter Notebook 不会看到返回的\n", + "Figure 实例。\n", + "```\n", + "````" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1bcc25e4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/catalog_11_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "cat.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "2b1e1e5d", + "metadata": {}, + "source": [ + "假如我们只关心日本周边的地震，我们在数据申请时可以进一步限制地震震中的经纬度范围。下面的代码限定了\n", + "地震的纬度范围为 30°-45°，经度范围为 130°-145°：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ee471501", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7 Event(s) in Catalog:\n", + "2020-05-31T21:02:11.329000Z | +36.203, +140.365 | 5.2 mww | manual\n", + "2020-05-30T18:13:48.078000Z | +42.480, +143.809 | 5.6 mww | manual\n", + "2020-05-24T09:36:14.771000Z | +31.399, +140.097 | 5.2 mww | manual\n", + "2020-05-13T05:56:28.624000Z | +42.742, +139.004 | 5.0 mww | manual\n", + "2020-05-05T16:57:08.845000Z | +35.559, +140.055 | 5.1 mww | manual\n", + "2020-03-17T15:10:32.414000Z | +42.319, +138.352 | 5.0 mb | manual\n", + "2020-02-12T10:37:18.660000Z | +37.322, +141.381 | 5.2 mww | manual\n" + ] + } + ], + "source": [ + "cat = client.get_events(\n", + " starttime=\"2020-01-01\",\n", + " endtime=\"2020-07-01\",\n", + " minmagnitude=5.0,\n", + " mindepth=70,\n", + " minlatitude=30,\n", + " maxlatitude=45,\n", + " minlongitude=130,\n", + " maxlongitude=145,\n", + ")\n", + "print(cat)" + ] + }, + { + "cell_type": "markdown", + "id": "1cf080a9", + "metadata": {}, + "source": [ + "经过这样的筛选之后，满足条件的地震目录只剩下了 9 个。\n", + "\n", + "在绘制下面的地震分布图时，我们使用了 `projection=\"local\"` 参数以绘制区域地图，并使用\n", + "`resolution=\"i\"` 参数设置地图中使用的海岸线精度。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1136c32c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/catalog_15_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "cat.plot(projection=\"local\", resolution=\"i\");" + ] + }, + { + "cell_type": "markdown", + "id": "1b192570", + "metadata": {}, + "source": [ + "## 地震目录的读与写\n", + "\n", + "通过 {meth}`Client.get_events() ` 函数\n", + "得到的地震目录保存在变量 `cat` 中。当 Python 脚本退出时，所有变量都会被销毁，变量中储存的地震目录信息\n", + "也会消失，因而需要及时将地震目录保存起来。\n", + "\n", + "{meth}`Catalog.write() ` 函数用于将地震目录保存到磁盘文件中。\n", + "下面的代码将地震目录以 QuakeML 格式保存到文件 {file}`japan-earthquakes.xml` 中：" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2242889c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/runner/micromamba/envs/seismo-learn/lib/python3.11/site-packages/obspy/io/quakeml/core.py:1112: UserWarning: 'quakeml:earthquake.usgs.gov/fdsnws/event/1/query?starttime=2020-01-01T00%3A00%3A00.000000&endtime=2020-07-01T00%3A00%3A00.000000&minlatitude=30.0&maxlatitude=45.0&minlongitude=130.0&maxlongitude=145.0&mindepth=70.0&minmagnitude=5.0' is not a valid QuakeML URI. It will be in the final file but note that the file will not be a valid QuakeML file.\n", + " warnings.warn(msg % obj.id)\n" + ] + } + ], + "source": [ + "cat.write(\"japan-earthquakes.xml\", format=\"QUAKEML\")" + ] + }, + { + "cell_type": "markdown", + "id": "1cf0b73c", + "metadata": {}, + "source": [ + "在需要时，随时可以使用 {func}`read_events() ` 函数读入\n", + "磁盘文件中的地震目录。该函数值返回 {class}`~obspy.core.event.Catalog` 类型：" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "51aca46e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7 Event(s) in Catalog:\n", + "2020-05-31T21:02:11.329000Z | +36.203, +140.365 | 5.2 mww | manual\n", + "2020-05-30T18:13:48.078000Z | +42.480, +143.809 | 5.6 mww | manual\n", + "2020-05-24T09:36:14.771000Z | +31.399, +140.097 | 5.2 mww | manual\n", + "2020-05-13T05:56:28.624000Z | +42.742, +139.004 | 5.0 mww | manual\n", + "2020-05-05T16:57:08.845000Z | +35.559, +140.055 | 5.1 mww | manual\n", + "2020-03-17T15:10:32.414000Z | +42.319, +138.352 | 5.0 mb | manual\n", + "2020-02-12T10:37:18.660000Z | +37.322, +141.381 | 5.2 mww | manual\n" + ] + } + ], + "source": [ + "from obspy import read_events\n", + "\n", + "cat = read_events(\"japan-earthquakes.xml\")\n", + "print(cat)" + ] + }, + { + "cell_type": "markdown", + "id": "60d7f3ed", + "metadata": {}, + "source": [ + "## 深入理解和使用 {class}`~obspy.core.event.Catalog` 类\n", + "\n", + "上面提到，{meth}`Client.get_events() `\n", + "和 {func}`read_events() ` 的返回值都是\n", + "{class}`~obspy.core.event.Catalog` 类型。\n", + "\n", + "事实上，{class}`~obspy.core.event.Catalog` 类是 ObsPy 中最核心的类之一，用于储存\n", + "地震目录信息。下图展示了 {class}`~obspy.core.event.Catalog` 类的属性及其层级关系：\n", + "\n", + ":::{figure} https://docs.obspy.org/_images/Event.png\n", + ":align: center\n", + ":alt: \"ObsPy 的 Catalog 类\"\n", + ":width: 100%\n", + "\n", + "ObsPy 的{class}`~obspy.core.event.Catalog` 类。引自 [ObsPy 网站](https://docs.obspy.org/_images/Event.png)。\n", + ":::\n", + "\n", + "{class}`~obspy.core.event.Catalog` 类可以当作一个列表。\n", + "像常规列表一样，我们可以对 {class}`~obspy.core.event.Catalog` 类里的地震事件进行循环：\n", + "````{margin}\n", + "```{note}\n", + "`for event in cat:` 会输出所有地震的信息。为了节省空间，这里只输出了前两个地震的信息。\n", + "```\n", + "````" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d9ec2f52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Event:\t2020-05-31T21:02:11.329000Z | +36.203, +140.365 | 5.2 mww | manual\n", + "\n", + "\t resource_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/fdsnws/event/1/query?eventid=us6000a3az&format=quakeml\")\n", + "\t event_type: 'earthquake'\n", + "\t creation_info: CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 58, 40000))\n", + "\t preferred_origin_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml\")\n", + "\t preferred_magnitude_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml#magnitude\")\n", + "\t ---------\n", + "\t event_descriptions: 1 Elements\n", + "\t origins: 1 Elements\n", + "\t magnitudes: 1 Elements\n", + "Event:\t2020-05-30T18:13:48.078000Z | +42.480, +143.809 | 5.6 mww | manual\n", + "\n", + "\t resource_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/fdsnws/event/1/query?eventid=us6000a2rt&format=quakeml\")\n", + "\t event_type: 'earthquake'\n", + "\t creation_info: CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 54, 40000))\n", + "\t preferred_origin_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a2rt/us/1597522794040/product.xml\")\n", + "\t preferred_magnitude_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a2rt/us/1597522794040/product.xml#magnitude\")\n", + "\t ---------\n", + "\t event_descriptions: 1 Elements\n", + "\t origins: 1 Elements\n", + "\t magnitudes: 1 Elements\n" + ] + } + ], + "source": [ + "for event in cat[0:2]:\n", + " print(event)" + ] + }, + { + "cell_type": "markdown", + "id": "f5422b10", + "metadata": {}, + "source": [ + "{class}`~obspy.core.event.Catalog` 列表里的每个元素都是 {class}`~obspy.core.event.Event` 类型。\n", + "下面以第一个事件为例，看看 {class}`~obspy.core.event.Event` 类里的内容：" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0938bd98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Event:\t2020-05-31T21:02:11.329000Z | +36.203, +140.365 | 5.2 mww | manual\n", + "\n", + "\t resource_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/fdsnws/event/1/query?eventid=us6000a3az&format=quakeml\")\n", + "\t event_type: 'earthquake'\n", + "\t creation_info: CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 58, 40000))\n", + "\t preferred_origin_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml\")\n", + "\t preferred_magnitude_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml#magnitude\")\n", + "\t ---------\n", + "\t event_descriptions: 1 Elements\n", + "\t origins: 1 Elements\n", + "\t magnitudes: 1 Elements\n" + ] + } + ], + "source": [ + "event = cat[0]\n", + "print(event)" + ] + }, + { + "cell_type": "markdown", + "id": "7f677d45", + "metadata": {}, + "source": [ + "从中可以看出，{class}`~obspy.core.event.Event` 类有很多属性。在这一节里，\n", + "我们重点关注 `origins` 和 `magnitudes`。\n", + "\n", + "{class}`~obspy.core.event.Event` 的 `origins` 属性也是一个列表，其元素是 {class}`~obspy.core.event.origin.Origin` 类型。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a910c0d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Origin(resource_id=ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml\"), time=UTCDateTime(2020, 5, 31, 21, 2, 11, 329000), longitude=140.3648, latitude=36.2034, depth=98610.0 [uncertainty=3700.0], quality=OriginQuality(used_phase_count=135, standard_error=0.7, azimuthal_gap=52.0, minimum_distance=0.143), origin_uncertainty=OriginUncertainty(horizontal_uncertainty=5800.0, preferred_description='horizontal uncertainty'), evaluation_mode='manual', creation_info=CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 58, 40000)))]\n" + ] + } + ], + "source": [ + "print(event.origins)" + ] + }, + { + "cell_type": "markdown", + "id": "1254867c", + "metadata": {}, + "source": [ + "`event.origins` 之所以是一个列表，是因为，对于任意一个地震，可能有多个机构或多种不同方法给出多个不同的震源信息。\n", + "在这个例子中，`event.origins` 中只包含了一个元素（即一个震源信息）。" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8029eeea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Origin\n", + "\t resource_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml\")\n", + "\t time: UTCDateTime(2020, 5, 31, 21, 2, 11, 329000)\n", + "\t longitude: 140.3648\n", + "\t latitude: 36.2034\n", + "\t depth: 98610.0 [uncertainty=3700.0]\n", + "\t quality: OriginQuality(used_phase_count=135, standard_error=0.7, azimuthal_gap=52.0, minimum_distance=0.143)\n", + "\t origin_uncertainty: OriginUncertainty(horizontal_uncertainty=5800.0, preferred_description='horizontal uncertainty')\n", + "\t evaluation_mode: 'manual'\n", + "\t creation_info: CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 58, 40000))\n" + ] + } + ], + "source": [ + "origin = event.origins[0]\n", + "print(origin)" + ] + }, + { + "cell_type": "markdown", + "id": "dd7f3b05", + "metadata": {}, + "source": [ + "从上面的输出中可以看到，{class}`~obspy.core.event.origin.Origin` 类的属性中包含了我们关心的震源\n", + "信息。比如，可以通过下面的代码，输出地震震源的发震时刻、纬度、经度和深度信息：\n", + "````{margin}\n", + "```{note}\n", + "ObsPy 中震源深度的单位为 m，而有些地震目录中深度的单位为 km。在使用时需要格外注意。\n", + "```\n", + "````" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "10d793fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2020-05-31T21:02:11.329000Z 36.2034 140.3648 98610.0\n" + ] + } + ], + "source": [ + "print(origin.time, origin.latitude, origin.longitude, origin.depth)" + ] + }, + { + "cell_type": "markdown", + "id": "c7fc6cf6", + "metadata": {}, + "source": [ + "同样的，{class}`~obspy.core.event.Event` 的 `magnitudes` 属性也是一个列表，\n", + "其元素是 {class}`~obspy.core.event.magnitude.Magnitude` 类型。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7ca265f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Magnitude(resource_id=ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml#magnitude\"), mag=5.2 [uncertainty=0.062], magnitude_type='mww', origin_id=ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml\"), station_count=25, evaluation_mode='manual', creation_info=CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 58, 40000)))]\n" + ] + } + ], + "source": [ + "print(event.magnitudes)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b01cad65", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Magnitude\n", + "\t resource_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml#magnitude\")\n", + "\t mag: 5.2 [uncertainty=0.062]\n", + "\t magnitude_type: 'mww'\n", + "\t origin_id: ResourceIdentifier(id=\"quakeml:earthquake.usgs.gov/product/origin/us6000a3az/us/1597522798040/product.xml\")\n", + "\t station_count: 25\n", + "\t evaluation_mode: 'manual'\n", + "\t creation_info: CreationInfo(agency_id='us', creation_time=UTCDateTime(2020, 8, 15, 20, 19, 58, 40000))\n" + ] + } + ], + "source": [ + "mag = event.magnitudes[0]\n", + "print(mag)" + ] + }, + { + "cell_type": "markdown", + "id": "8d411391", + "metadata": {}, + "source": [ + "下面的代码将输出地震震级和震级类型信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6b5fc36b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.2 mww\n" + ] + } + ], + "source": [ + "print(mag.mag, mag.magnitude_type)" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst", + "format_version": 0.13, + "jupytext_version": "1.13.0" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "source_map": [ + 12, + 115, + 117, + 121, + 123, + 128, + 134, + 151, + 153, + 157, + 165, + 181, + 183, + 187, + 199, + 204, + 206, + 216, + 218, + 222, + 227, + 253, + 256, + 260, + 263, + 269, + 271, + 275, + 278, + 287, + 289, + 293, + 296, + 299, + 301 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_sources/exercises/catalog.md b/_sources/exercises/catalog.md new file mode 100644 index 000000000..bc4591335 --- /dev/null +++ b/_sources/exercises/catalog.md @@ -0,0 +1,303 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.13.0 +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# 地震目录 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2022-07-31 +- 预计花费时间: 90 分钟 + +--- + +地震目录中包括了海量地震的信息，而通常用户只需要使用其中的一小部分，因而需要对 +地震目录进行筛选。对地震目录进行筛选的准则一般有如下几条： + +- 根据地震发震时刻筛选 +- 根据震中位置（即震中经纬度）筛选 +- 根据震源深度筛选 +- 根据地震震级筛选 + +这一节介绍如何筛选、下载与使用地震目录。 + +## 在线搜索和查看地震目录 + +USGS 提供了可用于在线搜索和查看地震目录的网页工具。用户既可以手动筛选和下载 +地震目录，也可以方便直观地查看地震分布情况。下面演示如何使用 USGS 网站在线搜索 +和查看地震目录。 + +1. 访问 USGS 地震目录网站: [https://earthquake.usgs.gov/earthquakes/search/](https://earthquake.usgs.gov/earthquakes/search/)， + 会看到如下搜索界面： + + :::{figure} usgs-catalog-1.jpg + :align: center + :alt: "USGS 地震目录基本选项" + :width: 100% + ::: + + 搜索界面分为左中右三栏： + + - 左侧栏设置震级搜索范围，可以选择 2.5 级以上或 4.5 级以上地震，也可以自定义 + 地震震级最小值和最大值 + - 中间栏设置发震时刻搜索范围，可以选择最近 7 天或最近 30 天，也可以自定义 + 发震时刻范围的开始时间和结束时间（UTC 时间） + - 右侧栏设置震中区域范围，可以选择全球地震、美国及周边地震，也可以在地图上 + 选中一个矩形区域 + +2. 在“高级选项”中可进一步对地震目录做筛选： + + :::{figure} usgs-catalog-2.jpg + :align: center + :alt: "USGS 地震目录高级选项" + :width: 100% + ::: + + - **Geographic Region** 可以设置地震震中的范围，有两种设置方式： + 1. 指定经纬度范围限定一个矩形区域，North 必须大于 South，East 必须大于 West + 2. 指定中心点的经纬度和半径值（单位为 km）来限定一个圆形区域 + - **Depth (km)** 用于限定地震的深度范围，深度单位为 km。 + - **Review Status** 用于限定地震信息的审核状态。一般来说，经人工审核的地震信息 + 更加准确，但由于人工审核需要一定的时间，因而最近几小时或几天的地震信息可能 + 没有被人工审核过。而自动确定的地震信息实时性更好，但地震位置和震级等信息可能 + 不太准确。 + - 除此之外，还可以进一步限制事件类型、事件影响力、地震目录来源、地震信息贡献者以及地震产品 + 类型等。读者可以自行探索。 + +3. 在“输出选项”中可以设置要以什么格式输出地震目录： + + :::{figure} usgs-catalog-3.jpg + :align: center + :alt: "USGS 地震目录输出选项" + :width: 50% + ::: + + USGS 网站支持输出多种格式的地震目录： + + - **Map & List**：在地图中显示地震目录，适合直观地查看地震分布情况 + - **CSV**：CSV 格式，可以用 Excel 打开，也可以用 Python 的 [pandas](https://pandas.pydata.org/) + 模块处理 + - **KML**：Google Earth KML 格式，可以在 Google Earth 中直接打开 + - **QuakeML**: 地震学领域定义的标准地震目录格式，ObsPy 可以直接读取 + - **GeoJSON**: 一种地理空间数据交换格式，多种软件和 Python 模块均可读取 + +4. 所有选项选择完毕后，点击”Search“按钮，即可以根据指定的格式输出地震目录。 + +读者可以尝试筛选出 2022 年上半年（1-6 月）全球震级大于 5.0 级、深度大于 70 km 的地震，并选择 +以“Map & List”的方式输出。点击“Search”按钮后，会在浏览器中打开在线地图并展示地震分布。 +左侧为地震列表，右侧为地震分布。读者可自行探索该界面中的各个按钮，以了解其更多功能。 + +:::{figure} usgs-catalog-4.jpg +:align: center +:alt: "USGS 地震目录在线地图" +:width: 100% +::: + +## 使用 ObsPy 下载地震目录 + +USGS 提供的在线工具可以很直观地下载地震目录并查看地震分布，但是却不够自动化。 +ObsPy 提供了从不同的地震数据中心筛选和下载地震目录的功能，并可以对得到的地震目录进行 +进一步分析和处理。 + +下面演示如何使用 ObsPy 的 {meth}`Client.get_events() ` +函数筛选和下载地震目录。 + +首先，需要导入 ObsPy 中地震数据中心数据下载客户端 {class}`~obspy.clients.fdsn.client.Client`: + +```{code-cell} ipython3 +from obspy.clients.fdsn import Client +``` + +接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。 +ObsPy 的 `Client` 支持多个地震数据中心。这里我们选择使用 USGS 地震数据中心： +```{code-cell} ipython3 +client = Client("USGS") +``` + +{func}`Client.get_events() ` 函数 +可以根据指定的参数对地震目录做筛选并下载。 +下面我们将获取 2020 年上半年全球震级大于 5.0 级的地震： +```{code-cell} ipython3 +cat = client.get_events( + starttime="2020-01-01", + endtime="2020-07-01", + minmagnitude=5.0 +) +``` + +{func}`Client.get_events() ` 函数会根据 +指定的参数向 USGS 地震数据中心发起请求，并返回筛选后的地震目录。其返回值是 {class}`~obspy.core.event.Catalog` 类型， +并被保存在变量 `cat` 中。 + +下面我们看看变量 `cat` 中的内容： +`````{margin} +````{tip} +由于地震数目太多，默认没有打印所有地震的信息。如果想要打印所有地震的信息，可以 +使用 `for` 循环语句对变量 `cat` 中的所有事件进行打印： +```python +for event in cat: + print(event) +``` +```` +````` +```{code-cell} ipython3 +print(cat) +``` +从输出中可以看到，该地震目录中包括了 735 个地震，并打印了若干个地震的基本信息。 + +下面我们进一步限制震源深度最小值为 70 km。加上这一限制后，满足条件的地震只有 140 个。 +```{code-cell} ipython3 +cat = client.get_events( + starttime="2020-01-01", + endtime="2020-07-01", + minmagnitude=5.0, + mindepth=70, +) +print(cat) +``` + +{class}`~obspy.core.event.Catalog` 类提供了用于绘制地震分布的 +{meth}`Catalog.plot() ` 函数， +可以直观地查看地震的分布情况。默认情况下，用圆圈表示地震，圆圈的大小代表地震 +震级大小，圆圈的颜色代表地震的深度。 +````{margin} +```{note} +{meth}`Catalog.plot() ` 函数会绘制地震分布图并返回一个 +{class}`~matplotlib.figure.Figure` 的实例。 +由于 Jupyter Notebook 会自动显示函数的返回值，因而在 Jupyter Notebook 中，地震分布图会绘制两次， +一次由 `cat.plot()` 函数主动绘制，一次由 Jupyter Notebook 显示函数返回值（即 Figure 实例）时绘制。 +因而，此处的代码中在 `cat.plot()` 的后面加上了分号 `;`，使得 Jupyter Notebook 不会看到返回的 +Figure 实例。 +``` +```` +```{code-cell} ipython3 +cat.plot(); +``` + +假如我们只关心日本周边的地震，我们在数据申请时可以进一步限制地震震中的经纬度范围。下面的代码限定了 +地震的纬度范围为 30°-45°，经度范围为 130°-145°： +```{code-cell} ipython3 +cat = client.get_events( + starttime="2020-01-01", + endtime="2020-07-01", + minmagnitude=5.0, + mindepth=70, + minlatitude=30, + maxlatitude=45, + minlongitude=130, + maxlongitude=145, +) +print(cat) +``` +经过这样的筛选之后，满足条件的地震目录只剩下了 9 个。 + +在绘制下面的地震分布图时，我们使用了 `projection="local"` 参数以绘制区域地图，并使用 +`resolution="i"` 参数设置地图中使用的海岸线精度。 +```{code-cell} ipython3 +cat.plot(projection="local", resolution="i"); +``` + +## 地震目录的读与写 + +通过 {meth}`Client.get_events() ` 函数 +得到的地震目录保存在变量 `cat` 中。当 Python 脚本退出时，所有变量都会被销毁，变量中储存的地震目录信息 +也会消失，因而需要及时将地震目录保存起来。 + +{meth}`Catalog.write() ` 函数用于将地震目录保存到磁盘文件中。 +下面的代码将地震目录以 QuakeML 格式保存到文件 {file}`japan-earthquakes.xml` 中： +```{code-cell} ipython3 +cat.write("japan-earthquakes.xml", format="QUAKEML") +``` + +在需要时，随时可以使用 {func}`read_events() ` 函数读入 +磁盘文件中的地震目录。该函数值返回 {class}`~obspy.core.event.Catalog` 类型： +```{code-cell} ipython3 +from obspy import read_events + +cat = read_events("japan-earthquakes.xml") +print(cat) +``` + +## 深入理解和使用 {class}`~obspy.core.event.Catalog` 类 + +上面提到，{meth}`Client.get_events() ` +和 {func}`read_events() ` 的返回值都是 +{class}`~obspy.core.event.Catalog` 类型。 + +事实上，{class}`~obspy.core.event.Catalog` 类是 ObsPy 中最核心的类之一，用于储存 +地震目录信息。下图展示了 {class}`~obspy.core.event.Catalog` 类的属性及其层级关系： + +:::{figure} https://docs.obspy.org/_images/Event.png +:align: center +:alt: "ObsPy 的 Catalog 类" +:width: 100% + +ObsPy 的{class}`~obspy.core.event.Catalog` 类。引自 [ObsPy 网站](https://docs.obspy.org/_images/Event.png)。 +::: + +{class}`~obspy.core.event.Catalog` 类可以当作一个列表。 +像常规列表一样，我们可以对 {class}`~obspy.core.event.Catalog` 类里的地震事件进行循环： +````{margin} +```{note} +`for event in cat:` 会输出所有地震的信息。为了节省空间，这里只输出了前两个地震的信息。 +``` +```` +```{code-cell} ipython3 +for event in cat[0:2]: + print(event) +``` + +{class}`~obspy.core.event.Catalog` 列表里的每个元素都是 {class}`~obspy.core.event.Event` 类型。 +下面以第一个事件为例，看看 {class}`~obspy.core.event.Event` 类里的内容： +```{code-cell} ipython3 +event = cat[0] +print(event) +``` + +从中可以看出，{class}`~obspy.core.event.Event` 类有很多属性。在这一节里， +我们重点关注 `origins` 和 `magnitudes`。 + +{class}`~obspy.core.event.Event` 的 `origins` 属性也是一个列表，其元素是 {class}`~obspy.core.event.origin.Origin` 类型。 +```{code-cell} ipython3 +print(event.origins) +``` + +`event.origins` 之所以是一个列表，是因为，对于任意一个地震，可能有多个机构或多种不同方法给出多个不同的震源信息。 +在这个例子中，`event.origins` 中只包含了一个元素（即一个震源信息）。 +```{code-cell} ipython3 +origin = event.origins[0] +print(origin) +``` + +从上面的输出中可以看到，{class}`~obspy.core.event.origin.Origin` 类的属性中包含了我们关心的震源 +信息。比如，可以通过下面的代码，输出地震震源的发震时刻、纬度、经度和深度信息： +````{margin} +```{note} +ObsPy 中震源深度的单位为 m，而有些地震目录中深度的单位为 km。在使用时需要格外注意。 +``` +```` +```{code-cell} ipython3 +print(origin.time, origin.latitude, origin.longitude, origin.depth) +``` + +同样的，{class}`~obspy.core.event.Event` 的 `magnitudes` 属性也是一个列表， +其元素是 {class}`~obspy.core.event.magnitude.Magnitude` 类型。 +```{code-cell} ipython3 +print(event.magnitudes) +``` +```{code-cell} ipython3 +mag = event.magnitudes[0] +print(mag) +``` +下面的代码将输出地震震级和震级类型信息： +```{code-cell} ipython3 +print(mag.mag, mag.magnitude_type) +``` diff --git a/_sources/exercises/cross-correlation.md b/_sources/exercises/cross-correlation.md new file mode 100644 index 000000000..7e0cbc6ca --- /dev/null +++ b/_sources/exercises/cross-correlation.md @@ -0,0 +1 @@ +# 互相关 diff --git a/_sources/exercises/distaz.ipynb b/_sources/exercises/distaz.ipynb new file mode 100644 index 000000000..1fdf591c1 --- /dev/null +++ b/_sources/exercises/distaz.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "619081cf", + "metadata": {}, + "source": [ + "# 震中距、方位角与反方位角\n", + "\n", + "震中距、方位角和反方位角是由地震和台站位置决定的参数，其在地震数据筛选和分析中\n", + "经常会用到。\n", + "\n", + "## 震中距\n", + "\n", + "一般来说，球面上任意两点都可以和球心确定唯一的大圆（*great circle*）。\n", + "在大圆上，连接这两点的弧有两条，较短的叫优弧（*minor arc*），较长的叫\n", + "劣弧（*major arc*）。\n", + "\n", + "震中距是震中与台站位置沿大圆弧的连线的优弧的长度。\n", + "\n", + "```{note}\n", + "震中距的单位一般为 km 或度（°）。km 常用于近震，度常用于远震。\n", + "\n", + "假设地球是完美球体，半径 $R_0$ 为 6371 km：\n", + "\n", + "$$ 1° = \\frac{\\pi*R_0}{180} km \\approx 111.19492 km $$\n", + "\n", + "$$ 1 km = \\frac{180}{\\pi*R_0}° \\approx 0.00899° $$\n", + "```\n", + "\n", + "## 方位角和反方位角\n", + "\n", + "方位角（azimuth，常简写为 az）是震中到台站的连线与地理北向的顺时针夹角，而反方位角\n", + "（back azimuth，常简写为 baz）指台站到震中的连线与地理北向的顺时针夹角。\n", + "\n", + "```{figure} az-baz.*\n", + ":alt: 震中距、方位角、反方位角示意图\n", + ":width: 50.0%\n", + ":align: center\n", + "\n", + "震中距、方位角、反方位角示意图\n", + "```\n", + "\n", + "需要注意的是，由于地球是个球体，方位角和反方位角一般并不是相差 180°。\n", + "例如，地震和台站分别位于（0°N，0°E）和（40°N，120°E）时，方位角约为 46°，\n", + "反方位角约为 290°，二者相差 244°。\n", + "\n", + "## 使用 ObsPy 计算\n", + "\n", + "ObsPy 提供了若干个函数，用于计算震中距、方位角和反方位角等参数。\n", + "\n", + "假定地震位于 (0°, 0°) 处，台站位于 (20°, 10°) 处：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "abbbca3b", + "metadata": {}, + "outputs": [], + "source": [ + "evla, evlo, stla, stlo = 0, 0, 20, 10" + ] + }, + { + "cell_type": "markdown", + "id": "f3aa6897", + "metadata": {}, + "source": [ + "ObsPy 的 {func}`obspy.geodetics.base.locations2degrees` 函数可以用于计算完美球体\n", + "地球表面任意两点的距离，其返回值单位为度。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f7545753", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22.268744495296882\n" + ] + } + ], + "source": [ + "from obspy.geodetics import locations2degrees\n", + "\n", + "dist = locations2degrees(0, 0, 20, 10)\n", + "print(dist)" + ] + }, + { + "cell_type": "markdown", + "id": "a90b11be", + "metadata": {}, + "source": [ + "{func}`obspy.geodetics.base.gps2dist_azimuth` 函数可以计算震中距、方位角和反方位角，\n", + "且其计算时采用的是 WGS84 椭球，因而具有更高的准确性：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a59f2517", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2466421.0675597396 25.651618610049262 207.4193805941954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2095/1144524644.py:3: DeprecationWarning: `alltrue` is deprecated as of NumPy 1.25.0, and will be removed in NumPy 2.0. Please use `all` instead.\n", + " dist, az, baz = gps2dist_azimuth(evla, evlo, stla, stlo)\n" + ] + } + ], + "source": [ + "from obspy.geodetics import gps2dist_azimuth\n", + "\n", + "dist, az, baz = gps2dist_azimuth(evla, evlo, stla, stlo)\n", + "print(dist, az, baz)" + ] + }, + { + "cell_type": "markdown", + "id": "c8a9711a", + "metadata": {}, + "source": [ + "{func}`obspy.geodetics.base.gps2dist_azimuth` 函数返回的距离以米为单位，可使用\n", + "{func}`obspy.geodetics.base.kilometers2degrees` 函数将其转换成以度为单位：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "66e9d084", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22.18105755349615\n" + ] + } + ], + "source": [ + "from obspy.geodetics import kilometers2degrees\n", + "\n", + "gcarc = kilometers2degrees(dist / 1000.0)\n", + "print(gcarc)" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst", + "format_version": 0.13, + "jupytext_version": "1.13.0" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "source_map": [ + 12, + 59, + 61, + 65, + 70, + 74, + 79, + 83 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_sources/exercises/distaz.md b/_sources/exercises/distaz.md new file mode 100644 index 000000000..01d4d9bca --- /dev/null +++ b/_sources/exercises/distaz.md @@ -0,0 +1,88 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.13.0 +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# 震中距、方位角与反方位角 + +震中距、方位角和反方位角是由地震和台站位置决定的参数，其在地震数据筛选和分析中 +经常会用到。 + +## 震中距 + +一般来说，球面上任意两点都可以和球心确定唯一的大圆（*great circle*）。 +在大圆上，连接这两点的弧有两条，较短的叫优弧（*minor arc*），较长的叫 +劣弧（*major arc*）。 + +震中距是震中与台站位置沿大圆弧的连线的优弧的长度。 + +```{note} +震中距的单位一般为 km 或度（°）。km 常用于近震，度常用于远震。 + +假设地球是完美球体，半径 $R_0$ 为 6371 km： + +$$ 1° = \frac{\pi*R_0}{180} km \approx 111.19492 km $$ + +$$ 1 km = \frac{180}{\pi*R_0}° \approx 0.00899° $$ +``` + +## 方位角和反方位角 + +方位角（azimuth，常简写为 az）是震中到台站的连线与地理北向的顺时针夹角，而反方位角 +（back azimuth，常简写为 baz）指台站到震中的连线与地理北向的顺时针夹角。 + +```{figure} az-baz.* +:alt: 震中距、方位角、反方位角示意图 +:width: 50.0% +:align: center + +震中距、方位角、反方位角示意图 +``` + +需要注意的是，由于地球是个球体，方位角和反方位角一般并不是相差 180°。 +例如，地震和台站分别位于（0°N，0°E）和（40°N，120°E）时，方位角约为 46°， +反方位角约为 290°，二者相差 244°。 + +## 使用 ObsPy 计算 + +ObsPy 提供了若干个函数，用于计算震中距、方位角和反方位角等参数。 + +假定地震位于 (0°, 0°) 处，台站位于 (20°, 10°) 处： +```{code-cell} ipython3 +evla, evlo, stla, stlo = 0, 0, 20, 10 +``` + +ObsPy 的 {func}`obspy.geodetics.base.locations2degrees` 函数可以用于计算完美球体 +地球表面任意两点的距离，其返回值单位为度。 +```{code-cell} ipython3 +from obspy.geodetics import locations2degrees + +dist = locations2degrees(0, 0, 20, 10) +print(dist) +``` + +{func}`obspy.geodetics.base.gps2dist_azimuth` 函数可以计算震中距、方位角和反方位角， +且其计算时采用的是 WGS84 椭球，因而具有更高的准确性： +```{code-cell} ipython3 +from obspy.geodetics import gps2dist_azimuth + +dist, az, baz = gps2dist_azimuth(evla, evlo, stla, stlo) +print(dist, az, baz) +``` + +{func}`obspy.geodetics.base.gps2dist_azimuth` 函数返回的距离以米为单位，可使用 +{func}`obspy.geodetics.base.kilometers2degrees` 函数将其转换成以度为单位： +```{code-cell} ipython3 +from obspy.geodetics import kilometers2degrees + +gcarc = kilometers2degrees(dist / 1000.0) +print(gcarc) +``` diff --git a/_sources/exercises/download.md b/_sources/exercises/download.md new file mode 100644 index 000000000..fbfddb27e --- /dev/null +++ b/_sources/exercises/download.md @@ -0,0 +1,9 @@ +# 数据下载 + +这一节介绍地震学数据的常见下载方法。 + +地震学数据主要分为三大类： + +- {doc}`地震事件目录 ` +- {doc}`台站元信息及仪器响应 ` +- {doc}`地震波形数据 ` diff --git a/_sources/exercises/filter.md b/_sources/exercises/filter.md new file mode 100644 index 000000000..905a9fab0 --- /dev/null +++ b/_sources/exercises/filter.md @@ -0,0 +1 @@ +# 滤波 diff --git a/_sources/exercises/intro.md b/_sources/exercises/intro.md new file mode 100644 index 000000000..3ec40e095 --- /dev/null +++ b/_sources/exercises/intro.md @@ -0,0 +1,27 @@ +# 简介 + +日常地震学科研工作中，使用地震学数据开展研究前，往往需要先获取观测资料，并做预处理和分析。 +经处理和分析得到的可靠数据可用于研究震源、地震学成像以及探索地球深部等。因此，这一部分将介绍 +日常地震学科研工作中的常用工作流程，主要以实际工作中会用到的代码为主。 +目的是帮助地震学新手快速熟悉地震学数据下载、处理以及分析的基础代码，然后直接可以开展实际科研工作。 + +地震台站记录到的地震图会实时或隔一段时间后传输至数据中心（**Data Center**）， +如 [Incorporated Research Institutions for Seismology (IRIS)](https://www.iris.edu/hq/)。 +一般情况下，地震学科研工作者直接可以从数据中心下载到公开的波形数据（time series data）。 +此外，一些数据中心也会提供地震目录（catalog）和台站元数据（medadata）。 + +:::{figure} workflow.jpg +:align: center +:alt: "地震学观测的获取和处理流程示意图。" +:width: 95% + +地震学观测的获取和处理流程示意图。 +::: + +以下是地震学数据实战常见流程： + +- 首先，我们可以通过 [FDSN Web Services](https://www.fdsn.org/webservices/) + 向数据中心申请和下载波形资料。得易于 ObsPy、SOD 等软件，现在的资料申请和下载十分简便、易学 +- 接着，我们可以利用 ObsPy、SAC 等软件对下载的数据进行预处理，如格式转换、去除仪器响应、滤波等 +- 然后，我们可以对处理好的数据进行分析，如拾取震相走时与振幅、分析波形的时频特征等 +- 最后，我们就可以利用提取到的数据信息开展深入的地震学研究，如震源定位、体波走时层析成像等 diff --git a/_sources/exercises/particle-motion.md b/_sources/exercises/particle-motion.md new file mode 100644 index 000000000..40e48a414 --- /dev/null +++ b/_sources/exercises/particle-motion.md @@ -0,0 +1,7 @@ +# 质点运动轨迹 + +## P 波质点运动轨迹 + +## S 波质点运动轨迹 + +## Rayleigh 面波质点运动轨迹 diff --git a/_sources/exercises/phases.md b/_sources/exercises/phases.md new file mode 100644 index 000000000..6ba091ed3 --- /dev/null +++ b/_sources/exercises/phases.md @@ -0,0 +1,19 @@ +# 震相 + +## 震相走时 + +## 射线路径 + +## 射线参数 + +## 出射角与入射角 + +射线从震源出射时，与垂直方向的角度。例如，从震源正下方出射的射线的出射角为 0°。 + +射线入射到台站时，与垂直方向的角度。例如，从台站正下方入射的射线的入射角为 0°。 + +```{note} +不同软件对出射角和入射角的定义可能会有区别。例如，`taup_time` 定义出射角为 +射线从震源出射时与**垂直向下**方向的夹角，而入射角为射线入射到台站时 +与**垂直向上**方向的夹角。 +``` diff --git a/_sources/exercises/preprocessing.md b/_sources/exercises/preprocessing.md new file mode 100644 index 000000000..80ce4aaa4 --- /dev/null +++ b/_sources/exercises/preprocessing.md @@ -0,0 +1,7 @@ +# 数据预处理 + +## 去均值/线性趋势 + +## 两端尖灭 + +## 去仪器响应 diff --git a/_sources/exercises/prerequisite.ipynb b/_sources/exercises/prerequisite.ipynb new file mode 100644 index 000000000..bba90e298 --- /dev/null +++ b/_sources/exercises/prerequisite.ipynb @@ -0,0 +1,105 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a0454d20", + "metadata": {}, + "source": [ + "# 准备工作\n", + "\n", + "- 本节贡献者: {{田冬冬}}（作者）\n", + "- 最近更新日期: 2022-06-12\n", + "- 预计花费时间: 10 分钟\n", + "\n", + "---\n", + "\n", + "这一章，我们将使用 Python 语言和 [ObsPy 软件包](https://docs.obspy.org/)\n", + "学习并掌握地震学数据的获取、处理和分析。在开始本章内容之前，读者应：\n", + "\n", + "- 阅读《{doc}`/programming/python`》一节，并安装 Miniconda\n", + "- 掌握 Python 的基本语法并了解如何执行 Python 代码\n", + "\n", + "## 安装依赖包\n", + "\n", + "本章中的地震学实践需要使用如下 Python 包：\n", + "\n", + "- [ObsPy](https://docs.obspy.org/): 用于地震数据获取、处理和分析\n", + "- [cartopy](https://scitools.org.uk/cartopy/): 用于绘制地图\n", + "- [JupyterLab](https://jupyterlab.readthedocs.io/): 基于浏览器的交互式开发环境\n", + "\n", + "通过如下命令安装所需依赖包：\n", + "\n", + "```\n", + "$ conda install obspy cartopy jupyterlab\n", + "```\n", + "\n", + "## 检查当前环境\n", + "\n", + "开启一个终端，在终端中键入 `jupyter lab` 命令来启动 JupyterLab。\n", + "在 JupyterLab 中新建一个 Notebook，并在 Notebook 中执行如下命令以检查当前环境。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "94c98aeb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ObsPy version: 1.4.0\n", + "Matplotlib version: 3.7.2\n", + "NumPy version: 1.25.1\n", + "cartopy version: 0.21.1\n" + ] + } + ], + "source": [ + "import obspy\n", + "import matplotlib\n", + "import numpy\n", + "import cartopy\n", + "\n", + "print(\"ObsPy version:\", obspy.__version__)\n", + "print(\"Matplotlib version:\", matplotlib.__version__)\n", + "print(\"NumPy version:\", numpy.__version__)\n", + "print(\"cartopy version:\", cartopy.__version__)" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst", + "format_version": 0.13, + "jupytext_version": "1.13.0" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "source_map": [ + 12, + 47 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_sources/exercises/prerequisite.md b/_sources/exercises/prerequisite.md new file mode 100644 index 000000000..7baa2d1c9 --- /dev/null +++ b/_sources/exercises/prerequisite.md @@ -0,0 +1,57 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.13.0 +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# 准备工作 + +- 本节贡献者: {{田冬冬}}（作者） +- 最近更新日期: 2022-06-12 +- 预计花费时间: 10 分钟 + +--- + +这一章，我们将使用 Python 语言和 [ObsPy 软件包](https://docs.obspy.org/) +学习并掌握地震学数据的获取、处理和分析。在开始本章内容之前，读者应： + +- 阅读《{doc}`/programming/python`》一节，并安装 Miniconda +- 掌握 Python 的基本语法并了解如何执行 Python 代码 + +## 安装依赖包 + +本章中的地震学实践需要使用如下 Python 包： + +- [ObsPy](https://docs.obspy.org/): 用于地震数据获取、处理和分析 +- [cartopy](https://scitools.org.uk/cartopy/): 用于绘制地图 +- [JupyterLab](https://jupyterlab.readthedocs.io/): 基于浏览器的交互式开发环境 + +通过如下命令安装所需依赖包： + +``` +$ conda install obspy cartopy jupyterlab +``` + +## 检查当前环境 + +开启一个终端，在终端中键入 `jupyter lab` 命令来启动 JupyterLab。 +在 JupyterLab 中新建一个 Notebook，并在 Notebook 中执行如下命令以检查当前环境。 + +```{code-cell} ipython3 +import obspy +import matplotlib +import numpy +import cartopy + +print("ObsPy version:", obspy.__version__) +print("Matplotlib version:", matplotlib.__version__) +print("NumPy version:", numpy.__version__) +print("cartopy version:", cartopy.__version__) +``` diff --git a/_sources/exercises/process.md b/_sources/exercises/process.md new file mode 100644 index 000000000..ae32308bf --- /dev/null +++ b/_sources/exercises/process.md @@ -0,0 +1,4 @@ +# 数据处理 + +这一节介绍地震学数据的常见处理流程。 + diff --git a/_sources/exercises/rotate.md b/_sources/exercises/rotate.md new file mode 100644 index 000000000..376377f43 --- /dev/null +++ b/_sources/exercises/rotate.md @@ -0,0 +1 @@ +# 分量旋转 diff --git a/_sources/exercises/software.md b/_sources/exercises/software.md new file mode 100644 index 000000000..59cc55b7b --- /dev/null +++ b/_sources/exercises/software.md @@ -0,0 +1,81 @@ +# 常用软件 + +- 本节贡献者: {{ 姚家园 }}（作者）、{{ 田冬冬 }}（审稿） +- 最近更新日期: 2021-05-30 +- 预计阅读时间: 30 分钟 + +--- + +日常地震学科研工作中，经常需要使用他人开发的软件来完成数据处理与分析、绘图以及科学计算等。 +本节介绍一些地震学常用软件，读者需要在后面的练习以及日常的科研工作中，反复使用和思考方能完全掌握这些软件。 + +:::{note} +阅读本教程时，推荐地震学新手先参考以下中文教程中的安装部分在计算机上安装这些软件。 +《{doc}`地震学实践 `》这一章则会通过简单实例展示一些基本用法。 + +阅读完本教程后，再详细阅读各软件的中文和官方教程。 +一般而言，只需阅读中文教程中的入门教程，即可入门和开展科研工作。 +之后可以阅读中文教程中的进阶教程以及官方教程，深入学习和掌握这些软件。 +::: + +## ObsPy + +ObsPy 是地震学数据处理的 Python 软件包，极大促进了地震学应用程序的快速开发。 +其可以用来读写多种地震学数据格式，下载地震目录、台站元数据和波形数据，以及处理和分析波形数据等， +满足了日常科研中与地震学数据相关的大部分需求。 + +可以说正是因为 ObsPy 的出世，地震学科研工作者才可以喊出“**人生苦短，我用 Python！**”。 + +- 主页： +- 官方教程： +- 中文教程： + +## SOD + +SOD，全称是 Standing Order for Data，可以自动筛选并下载地震目录、台站元数据和波形数据， +并对波形数据做预处理。其具有高度可定制化的特点，可以满足日常科研中地震学数据下载的大部分需求。 + +虽然从零开始学习 SOD 的语法较难，但中文教程将持续维护开源且易懂的 SOD 脚本，读者一般只需 +复制并做简单修改即可使用。 + +- 主页： +- 中文教程： + +## SAC + +SAC，全称 Seismic Analysis Code，是天然地震学领域使用最广泛的数据分析软件包之一。 +我们推荐使用中文手册学习 SAC。至少在某些章节，中文手册比官方手册更好。 +中文手册提供了更多有关数据处理的详细说明，以帮助初学者正确使用 SAC 和学习地震学数据处理基础。 + +SAC 拥有图形界面，方便实时查看结果。SAC 历史悠久，仍有许多开源代码和用户使用 SAC。 +推荐用户学习和掌握 SAC 的基础用法。 + +- 主页： +- 官方教程： +- 中文教程： + +## GMT + +GMT，全称 Generic Mapping Tools，中文一般译为“通用制图工具”， +是地球科学最广泛使用的制图软件之一，其具有强大的绘图功能和数据处理功能。 + +[PyGMT](https://www.pygmt.org/latest/) 是 GMT 官方维护的 GMT 的 Python 接口， +目前仍在快速开发中。 + +- 主页： +- 官方教程： +- 中文教程： + +## TauP + +TauP 用于计算一维球状分层模型下地震震相的走时和路径。 + +- 主页： +- 官方教程： +- 中文教程： + +:::{note} +TauP 是基于 Linux 命令行的软件，用户直接在终端执行一条命令即可得到结果。 +ObsPy 提供了 [TauP 的 Python 接口](https://docs.obspy.org/packages/obspy.taup.html)， +方便用户在自己的 Python 代码中调用。 +::: diff --git a/_sources/exercises/station.ipynb b/_sources/exercises/station.ipynb new file mode 100644 index 000000000..30935d56e --- /dev/null +++ b/_sources/exercises/station.ipynb @@ -0,0 +1,593 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "75644eb3", + "metadata": {}, + "source": [ + "# 地震台站\n", + "\n", + "- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿）\n", + "- 最近更新日期: 2023-04-29\n", + "- 预计花费时间: 60 分钟\n", + "\n", + "---\n", + "\n", + "全球地震台站有成千上万个，通常在某个具体研究中只需要符合特定要求的台站，因而需要对地震台站进行筛选。\n", + "这一节介绍如何筛选公开地震台站并获取台站信息。\n", + "\n", + "## 使用 IRIS GMAP 筛选台站\n", + "\n", + "```{note}\n", + "IRIS GMAP 使用了 Google 地图服务，因而需要科学上网才能正常访问。\n", + "```\n", + "\n", + "IRIS GMAP 是一个由 IRIS 提供的地震台站网页搜索工具，可以方便地查看全球地震台站分布以及台站的\n", + "详细信息。下面演示 IRIS GMAP 的基本使用方法。\n", + "\n", + "访问 IRIS GMAP 网站 [https://ds.iris.edu/gmap/](https://ds.iris.edu/gmap/)，\n", + "会看到如下界面：界面左侧为功能栏，可以使用不同的准则筛选地震台站；\n", + "右侧为显示区，用于显示符合筛选条件的地震台站。\n", + "\n", + "左侧功能栏中，支持以多种不同的方式对地震台站进行筛选：指定台网名、台站名、位置码、通道名；指定时间范围；指定台站位置范围（矩形区域或圆形区域）；指定地震数据中心。\n", + "\n", + ":::{figure} gmap-1.jpg\n", + ":align: center\n", + ":alt: \"IRIS GMAP 界面\"\n", + ":width: 90%\n", + "\n", + "IRIS GMAP 界面\n", + ":::\n", + "\n", + "例如，想筛选所有 `IU` 台网的宽频带地震台站，则可以在 **Network** 框中输入 `IU`，\n", + "在 **Channel** 框中输入 `BH?`（此处的问号为通配符），然后点击上方的 **Update Map**\n", + "按钮，界面右侧便会显示出所有满足筛选条件的台站。右侧上方为地图区域，圆圈标记了\n", + "台站的位置；下方为列表区域，会显示台网名、台站名、台站位置以及台站的开始和结束时间。\n", + "\n", + ":::{figure} gmap-2.jpg\n", + ":align: center\n", + ":alt: \"IRIS GMAP 显示 IU 台网的宽频带台站\"\n", + ":width: 90%\n", + "\n", + "IRIS GMAP 显示 IU 台网的宽频带台站\n", + ":::\n", + "\n", + "可以更进一步查看每个台站的详细信息。以位于美国新墨西哥州的地震台站 `IU.ANMO` 为例，\n", + "点击 `IU.ANMO` 台站对应的圆圈或下方列表区域的该台，会出现如下图所示的提示框：\n", + "\n", + ":::{figure} gmap-3.jpg\n", + ":align: center\n", + ":alt: \"IRIS GMAP 查看 IU.ANMO 台站的基本信息\"\n", + ":width: 90%\n", + "\n", + "IRIS GMAP 查看 IU.ANMO 台站的基本信息\n", + ":::\n", + "可以看到，`IU.ANMO` 台站位于美国新墨西哥州 Albuquerque 市，台站开始运行的时间为 \n", + "2002 年 11 月 19 日，结束运行的时间为 2599 年 12 月 31 日（这一“未来”结束时间\n", + "表示台站依然在长期运行中）。\n", + "\n", + "点击提示框中的 “More Information”链接，则会跳转到 [IRIS MDA](https://ds.iris.edu/mda) 中\n", + "该台站所对应的页面（即 https://ds.iris.edu/mda/IU/ANMO/?starttime=2002-11-19&endtime=2599-12-31)。\n", + "该页面不仅列出了台站的基本信息，还列出了台站所使用的地震仪器及其基本参数。\n", + "\n", + ":::{figure} mda-1.jpg\n", + ":align: center\n", + ":alt: \"IRIS MDA 中查看 IU.ANMO 台站的基本信息\"\n", + ":width: 90%\n", + "\n", + "IRIS MDA 中查看 IU.ANMO 台站的基本信息\n", + ":::\n", + "\n", + "## 使用 ObsPy 下载地震台站信息\n", + "\n", + "IRIS GMAP 作为一个在线工具可以很直观地查看台站分布和基本信息，但却不适合数据\n", + "自动化处理。ObsPy 提供了从不同的地震数据中心筛选和下载台站基本信息的功能。\n", + "\n", + "下面演示如何使用 ObsPy 的 {meth}`Client.get_stations() `\n", + "函数筛选和下载地震台站信息。\n", + "\n", + "首先，需要导入 ObsPy 中地震数据中心数据下载客户端 {class}`~obspy.clients.fdsn.client.Client`：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f67b1d91", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy.clients.fdsn import Client" + ] + }, + { + "cell_type": "markdown", + "id": "d8db8781", + "metadata": {}, + "source": [ + "接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。\n", + "ObsPy 的 `Client` 支持多个地震数据中心。这里我们选择使用 IRIS 地震数据中心：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c3a711df", + "metadata": {}, + "outputs": [], + "source": [ + "client = Client(\"IRIS\")" + ] + }, + { + "cell_type": "markdown", + "id": "423051b0", + "metadata": {}, + "source": [ + "{meth}`Client.get_stations() `\n", + "函数可以根据指定的参数获取地震台站信息。这里我们想要获得 `IU` 台网中所有台站名以 `A` 开头的\n", + "宽频带三分量（`BH*`）台站，并同时获取台站的仪器响应信息（`level=\"response\"`）：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b806b05", + "metadata": {}, + "outputs": [], + "source": [ + "inv = client.get_stations(\n", + " network=\"IU\", \n", + " station=\"A*\",\n", + " channel=\"BH*\",\n", + " starttime=\"2002-01-01\",\n", + " endtime=\"2002-01-02\",\n", + " level=\"response\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0170339b", + "metadata": {}, + "source": [ + "该函数会向 IRIS 地震数据中心发起请求，并返回符合条件的地震台站信息。其返回值是\n", + "{class}`~obspy.core.inventory.inventory.Inventory` 类型，并被保存到变量 `inv` 中。\n", + "下面我们看看变量 `inv` 中的内容：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2fe37c54", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inventory created at 2023-10-02T06:39:16.339500Z\n", + "\tCreated by: IRIS WEB SERVICE: fdsnws-station | version: 1.1.52\n", + "\t\t http://service.iris.edu/fdsnws/station/1/query?starttime=2002-01-...\n", + "\tSending institution: IRIS-DMC (IRIS-DMC)\n", + "\tContains:\n", + "\t\tNetworks (1):\n", + "\t\t\tIU\n", + "\t\tStations (3):\n", + "\t\t\tIU.ADK (Adak, Aleutian Islands, Alaska)\n", + "\t\t\tIU.AFI (Afiamalu, Samoa)\n", + "\t\t\tIU.ANMO (Albuquerque, New Mexico, USA)\n", + "\t\tChannels (15):\n", + "\t\t\tIU.ADK.00.BHZ, IU.ADK.00.BHN, IU.ADK.00.BHE, IU.AFI.00.BHZ, \n", + "\t\t\tIU.AFI.00.BHN, IU.AFI.00.BHE, IU.AFI.10.BHZ, IU.AFI.10.BHN, \n", + "\t\t\tIU.AFI.10.BHE, IU.ANMO.00.BHZ, IU.ANMO.00.BH1, IU.ANMO.00.BH2, \n", + "\t\t\tIU.ANMO.10.BHZ, IU.ANMO.10.BH1, IU.ANMO.10.BH2\n" + ] + } + ], + "source": [ + "print(inv)" + ] + }, + { + "cell_type": "markdown", + "id": "c9bc98d1", + "metadata": {}, + "source": [ + "可以看到，返回的变量 `inv` 中包含了满足条件的 1 个台网、3 个台站、15 个通道的信息。\n", + "\n", + "{class}`~obspy.core.inventory.inventory.Inventory` 类提供的\n", + "{meth}`Inventory.plot() ` 函数\n", + "可以用于快速绘制地震台站分布图：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "776a68e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/station_9_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "inv.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "6d730e0f", + "metadata": {}, + "source": [ + "{meth}`Inventory.plot_response() ` \n", + "函数可以用于绘制仪器响应。下面的函数绘制了 `inv` 中所有 `BHZ` 分量的仪器响应，并设置了仪器响应图的\n", + "最小频率为 0.001 Hz：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "235edd9d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/station_11_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "inv.plot_response(min_freq=0.001, channel=\"BHZ\");" + ] + }, + { + "cell_type": "markdown", + "id": "90a14868", + "metadata": {}, + "source": [ + "## 台站信息的读和写\n", + "\n", + "通过 {meth}`Client.get_stations() `\n", + "获得的台站信息可以保存为多种不同格式。下面的代码将台站信息以 StationXML 格式保存到文件 \n", + "`stations.xml` 中：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0e82b4ca", + "metadata": {}, + "outputs": [], + "source": [ + "inv.write(\"stations.xml\", format=\"STATIONXML\")" + ] + }, + { + "cell_type": "markdown", + "id": "a0694a88", + "metadata": {}, + "source": [ + "在需要时，随时可以使用 {func}`read_inventory() ` \n", + "函数读入磁盘文件中的台站信息。该函数值返回 {class}`~obspy.core.inventory.inventory.Inventory` 类型：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e239b361", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy import read_inventory\n", + "inv = read_inventory(\"stations.xml\")" + ] + }, + { + "cell_type": "markdown", + "id": "105d619f", + "metadata": {}, + "source": [ + "## 深入理解和使用 {class}`~obspy.core.inventory.inventory.Inventory` 类\n", + "\n", + "上面提到，{meth}`Client.get_stations() `\n", + "和 {func}`read_inventory() ` 的返回值都是 \n", + "{class}`~obspy.core.inventory.inventory.Inventory` 类型。\n", + "事实上，{class}`~obspy.core.inventory.inventory.Inventory` 类是 ObsPy 中最核心的类之一，用于储存地震台站信息。\n", + "下图展示了 {class}`~obspy.core.inventory.inventory.Inventory` 类的属性及其层级关系：\n", + "{class}`~obspy.core.inventory.inventory.Inventory` 类可以看做是 \n", + "{class}`~obspy.core.inventory.network.Network` 类的列表;\n", + "{class}`~obspy.core.inventory.network.Network` 类可以看做是 \n", + "{class}`~obspy.core.inventory.station.Station` 类的列表;\n", + "{class}`~obspy.core.inventory.station.Station` 类可以看做是 \n", + "{class}`~obspy.core.inventory.channel.Channel` 类的列表。\n", + "\n", + ":::{figure} https://docs.obspy.org/_images/Inventory.png\n", + ":align: center\n", + ":alt: \"ObsPy 的 Inventory 类\"\n", + ":width: 100%\n", + "\n", + "ObsPy 的 {class}`~obspy.core.inventory.inventory.Inventory` 类。引自 [ObsPy 网站](https://docs.obspy.org/_images/Inventory.png)。\n", + ":::\n", + "\n", + "### {class}`~obspy.core.inventory.inventory.Inventory` 类\n", + "\n", + "可以对 {class}`~obspy.core.inventory.inventory.Inventory` 进行列表相关的操作，\n", + "下面对 `inv` 进行循环并打印每个元素（即 `Network` 类）的值：" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4d0361a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Network IU (Global Seismograph Network - IRIS/USGS (GSN))\n", + "\tStation Count: 3/128 (Selected/Total)\n", + "\t1988-01-01T00:00:00.000000Z - --\n", + "\tAccess: open\n", + "\tContains:\n", + "\t\tStations (3):\n", + "\t\t\tIU.ADK (Adak, Aleutian Islands, Alaska)\n", + "\t\t\tIU.AFI (Afiamalu, Samoa)\n", + "\t\t\tIU.ANMO (Albuquerque, New Mexico, USA)\n", + "\t\tChannels (15):\n", + "\t\t\tIU.ADK.00.BHZ, IU.ADK.00.BHN, IU.ADK.00.BHE, IU.AFI.00.BHZ, \n", + "\t\t\tIU.AFI.00.BHN, IU.AFI.00.BHE, IU.AFI.10.BHZ, IU.AFI.10.BHN, \n", + "\t\t\tIU.AFI.10.BHE, IU.ANMO.00.BHZ, IU.ANMO.00.BH1, IU.ANMO.00.BH2, \n", + "\t\t\tIU.ANMO.10.BHZ, IU.ANMO.10.BH1, IU.ANMO.10.BH2\n" + ] + } + ], + "source": [ + "for net in inv:\n", + " print(net)" + ] + }, + { + "cell_type": "markdown", + "id": "4d66a124", + "metadata": {}, + "source": [ + "### {class}`~obspy.core.inventory.network.Network` 类\n", + "\n", + "{class}`~obspy.core.inventory.network.Network` 类提供了很多台网相关的属性和函数。\n", + "例如，下面的代码会输出第一个台网的代码、总台站数以及 `inv` 中实际包含的台站数目：" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1a1f8b7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IU 128 3\n" + ] + } + ], + "source": [ + "net = inv[0]\n", + "print(net.code, net.total_number_of_stations, net.selected_number_of_stations)" + ] + }, + { + "cell_type": "markdown", + "id": "4494f2d8", + "metadata": {}, + "source": [ + "可以对 {class}`~obspy.core.inventory.network.Network` 进行列表相关的操作，\n", + "这里我们取其第一个台站并查看其信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2cfd6477", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Station ADK (Adak, Aleutian Islands, Alaska)\n", + "\tStation Code: ADK\n", + "\tChannel Count: 3/103 (Selected/Total)\n", + "\t1993-09-21T00:00:00.000000Z - 2009-02-14T00:00:00.000000Z\n", + "\tAccess: open \n", + "\tLatitude: 51.8823, Longitude: -176.6842, Elevation: 130.0 m\n", + "\tAvailable Channels:\n", + "\t .00.BH[ZNE] 20.0 Hz 1999-02-11 to 2003-05-23\n", + "\n" + ] + } + ], + "source": [ + "sta = net[0]\n", + "print(sta)" + ] + }, + { + "cell_type": "markdown", + "id": "80d62d8a", + "metadata": {}, + "source": [ + "### {class}`~obspy.core.inventory.station.Station` 类\n", + "\n", + "{class}`~obspy.core.inventory.station.Station` 类也提供了很多台站相关的属性和函数。\n", + "例如，下面的代码输出了当前台站的台站代码、经纬度、高程、台站的总通道数目和当前 `inv` 中包含的\n", + "通道数目：" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0d88e797", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ADK 51.8823 -176.6842 130.0\n", + "103 3\n" + ] + } + ], + "source": [ + "print(sta.code, sta.latitude, sta.longitude, sta.elevation)\n", + "print(sta.total_number_of_channels, sta.selected_number_of_channels)" + ] + }, + { + "cell_type": "markdown", + "id": "b9a6120b", + "metadata": {}, + "source": [ + "可以对 {class}`~obspy.core.inventory.station.Station` 进行列表相关的操作，\n", + "这里我们取该台站的第一个通道并查看其信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e9eee18f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channel 'BHE', Location '00' \n", + "\tTime range: 1999-02-11T00:00:00.000000Z - 2003-05-23T08:40:00.000000Z\n", + "\tLatitude: 51.8823, Longitude: -176.6842, Elevation: 130.0 m, Local Depth: 0.0 m\n", + "\tAzimuth: 90.00 degrees from north, clockwise\n", + "\tDip: 0.00 degrees down from horizontal\n", + "\tChannel types: CONTINUOUS, GEOPHYSICAL\n", + "\tSampling Rate: 20.00 Hz\n", + "\tSensor (Description): None (Streckeisen STS-1H/VBB Seismometer)\n", + "\tResponse information available\n" + ] + } + ], + "source": [ + "chn = sta[0]\n", + "print(chn)" + ] + }, + { + "cell_type": "markdown", + "id": "6fb5d875", + "metadata": {}, + "source": [ + "### {class}`~obspy.core.inventory.channel.Channel` 类\n", + "\n", + "{class}`~obspy.core.inventory.channel.Channel` 类也提供了很多通道相关的属性和函数。\n", + "例如，下面的代码输出了当前通道的方位角、倾角、位置码和采样率等信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "14846d16", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90.0 0.0 00 20.0\n" + ] + } + ], + "source": [ + "print(chn.azimuth, chn.dip, chn.location_code, chn.sample_rate)" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst", + "format_version": 0.13, + "jupytext_version": "1.13.0" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "source_map": [ + 12, + 96, + 98, + 102, + 104, + 109, + 118, + 122, + 124, + 131, + 133, + 138, + 140, + 147, + 149, + 153, + 156, + 184, + 187, + 193, + 196, + 200, + 203, + 210, + 213, + 217, + 220, + 226 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_sources/exercises/station.md b/_sources/exercises/station.md new file mode 100644 index 000000000..c5954b859 --- /dev/null +++ b/_sources/exercises/station.md @@ -0,0 +1,228 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.13.0 +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# 地震台站 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-04-29 +- 预计花费时间: 60 分钟 + +--- + +全球地震台站有成千上万个，通常在某个具体研究中只需要符合特定要求的台站，因而需要对地震台站进行筛选。 +这一节介绍如何筛选公开地震台站并获取台站信息。 + +## 使用 IRIS GMAP 筛选台站 + +```{note} +IRIS GMAP 使用了 Google 地图服务，因而需要科学上网才能正常访问。 +``` + +IRIS GMAP 是一个由 IRIS 提供的地震台站网页搜索工具，可以方便地查看全球地震台站分布以及台站的 +详细信息。下面演示 IRIS GMAP 的基本使用方法。 + +访问 IRIS GMAP 网站 [https://ds.iris.edu/gmap/](https://ds.iris.edu/gmap/)， +会看到如下界面：界面左侧为功能栏，可以使用不同的准则筛选地震台站； +右侧为显示区，用于显示符合筛选条件的地震台站。 + +左侧功能栏中，支持以多种不同的方式对地震台站进行筛选：指定台网名、台站名、位置码、通道名；指定时间范围；指定台站位置范围（矩形区域或圆形区域）；指定地震数据中心。 + +:::{figure} gmap-1.jpg +:align: center +:alt: "IRIS GMAP 界面" +:width: 90% + +IRIS GMAP 界面 +::: + +例如，想筛选所有 `IU` 台网的宽频带地震台站，则可以在 **Network** 框中输入 `IU`， +在 **Channel** 框中输入 `BH?`（此处的问号为通配符），然后点击上方的 **Update Map** +按钮，界面右侧便会显示出所有满足筛选条件的台站。右侧上方为地图区域，圆圈标记了 +台站的位置；下方为列表区域，会显示台网名、台站名、台站位置以及台站的开始和结束时间。 + +:::{figure} gmap-2.jpg +:align: center +:alt: "IRIS GMAP 显示 IU 台网的宽频带台站" +:width: 90% + +IRIS GMAP 显示 IU 台网的宽频带台站 +::: + +可以更进一步查看每个台站的详细信息。以位于美国新墨西哥州的地震台站 `IU.ANMO` 为例， +点击 `IU.ANMO` 台站对应的圆圈或下方列表区域的该台，会出现如下图所示的提示框： + +:::{figure} gmap-3.jpg +:align: center +:alt: "IRIS GMAP 查看 IU.ANMO 台站的基本信息" +:width: 90% + +IRIS GMAP 查看 IU.ANMO 台站的基本信息 +::: +可以看到，`IU.ANMO` 台站位于美国新墨西哥州 Albuquerque 市，台站开始运行的时间为 +2002 年 11 月 19 日，结束运行的时间为 2599 年 12 月 31 日（这一“未来”结束时间 +表示台站依然在长期运行中）。 + +点击提示框中的 “More Information”链接，则会跳转到 [IRIS MDA](https://ds.iris.edu/mda) 中 +该台站所对应的页面（即 https://ds.iris.edu/mda/IU/ANMO/?starttime=2002-11-19&endtime=2599-12-31)。 +该页面不仅列出了台站的基本信息，还列出了台站所使用的地震仪器及其基本参数。 + +:::{figure} mda-1.jpg +:align: center +:alt: "IRIS MDA 中查看 IU.ANMO 台站的基本信息" +:width: 90% + +IRIS MDA 中查看 IU.ANMO 台站的基本信息 +::: + +## 使用 ObsPy 下载地震台站信息 + +IRIS GMAP 作为一个在线工具可以很直观地查看台站分布和基本信息，但却不适合数据 +自动化处理。ObsPy 提供了从不同的地震数据中心筛选和下载台站基本信息的功能。 + +下面演示如何使用 ObsPy 的 {meth}`Client.get_stations() ` +函数筛选和下载地震台站信息。 + +首先，需要导入 ObsPy 中地震数据中心数据下载客户端 {class}`~obspy.clients.fdsn.client.Client`： +```{code-cell} ipython3 +from obspy.clients.fdsn import Client +``` + +接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。 +ObsPy 的 `Client` 支持多个地震数据中心。这里我们选择使用 IRIS 地震数据中心： +```{code-cell} ipython3 +client = Client("IRIS") +``` + +{meth}`Client.get_stations() ` +函数可以根据指定的参数获取地震台站信息。这里我们想要获得 `IU` 台网中所有台站名以 `A` 开头的 +宽频带三分量（`BH*`）台站，并同时获取台站的仪器响应信息（`level="response"`）： +```{code-cell} ipython3 +inv = client.get_stations( + network="IU", + station="A*", + channel="BH*", + starttime="2002-01-01", + endtime="2002-01-02", + level="response" +) +``` +该函数会向 IRIS 地震数据中心发起请求，并返回符合条件的地震台站信息。其返回值是 +{class}`~obspy.core.inventory.inventory.Inventory` 类型，并被保存到变量 `inv` 中。 +下面我们看看变量 `inv` 中的内容： +```{code-cell} ipython3 +print(inv) +``` +可以看到，返回的变量 `inv` 中包含了满足条件的 1 个台网、3 个台站、15 个通道的信息。 + +{class}`~obspy.core.inventory.inventory.Inventory` 类提供的 +{meth}`Inventory.plot() ` 函数 +可以用于快速绘制地震台站分布图： + +```{code-cell} ipython3 +inv.plot(); +``` + +{meth}`Inventory.plot_response() ` +函数可以用于绘制仪器响应。下面的函数绘制了 `inv` 中所有 `BHZ` 分量的仪器响应，并设置了仪器响应图的 +最小频率为 0.001 Hz： +```{code-cell} ipython3 +inv.plot_response(min_freq=0.001, channel="BHZ"); +``` + +## 台站信息的读和写 + +通过 {meth}`Client.get_stations() ` +获得的台站信息可以保存为多种不同格式。下面的代码将台站信息以 StationXML 格式保存到文件 +`stations.xml` 中： +```{code-cell} ipython3 +inv.write("stations.xml", format="STATIONXML") +``` +在需要时，随时可以使用 {func}`read_inventory() ` +函数读入磁盘文件中的台站信息。该函数值返回 {class}`~obspy.core.inventory.inventory.Inventory` 类型： + +```{code-cell} ipython3 +from obspy import read_inventory +inv = read_inventory("stations.xml") +``` + +## 深入理解和使用 {class}`~obspy.core.inventory.inventory.Inventory` 类 + +上面提到，{meth}`Client.get_stations() ` +和 {func}`read_inventory() ` 的返回值都是 +{class}`~obspy.core.inventory.inventory.Inventory` 类型。 +事实上，{class}`~obspy.core.inventory.inventory.Inventory` 类是 ObsPy 中最核心的类之一，用于储存地震台站信息。 +下图展示了 {class}`~obspy.core.inventory.inventory.Inventory` 类的属性及其层级关系： +{class}`~obspy.core.inventory.inventory.Inventory` 类可以看做是 +{class}`~obspy.core.inventory.network.Network` 类的列表; +{class}`~obspy.core.inventory.network.Network` 类可以看做是 +{class}`~obspy.core.inventory.station.Station` 类的列表; +{class}`~obspy.core.inventory.station.Station` 类可以看做是 +{class}`~obspy.core.inventory.channel.Channel` 类的列表。 + +:::{figure} https://docs.obspy.org/_images/Inventory.png +:align: center +:alt: "ObsPy 的 Inventory 类" +:width: 100% + +ObsPy 的 {class}`~obspy.core.inventory.inventory.Inventory` 类。引自 [ObsPy 网站](https://docs.obspy.org/_images/Inventory.png)。 +::: + +### {class}`~obspy.core.inventory.inventory.Inventory` 类 + +可以对 {class}`~obspy.core.inventory.inventory.Inventory` 进行列表相关的操作， +下面对 `inv` 进行循环并打印每个元素（即 `Network` 类）的值： +```{code-cell} ipython3 +for net in inv: + print(net) +``` + +### {class}`~obspy.core.inventory.network.Network` 类 + +{class}`~obspy.core.inventory.network.Network` 类提供了很多台网相关的属性和函数。 +例如，下面的代码会输出第一个台网的代码、总台站数以及 `inv` 中实际包含的台站数目： +```{code-cell} ipython3 +net = inv[0] +print(net.code, net.total_number_of_stations, net.selected_number_of_stations) +``` + +可以对 {class}`~obspy.core.inventory.network.Network` 进行列表相关的操作， +这里我们取其第一个台站并查看其信息： +```{code-cell} ipython3 +sta = net[0] +print(sta) +``` + +### {class}`~obspy.core.inventory.station.Station` 类 + +{class}`~obspy.core.inventory.station.Station` 类也提供了很多台站相关的属性和函数。 +例如，下面的代码输出了当前台站的台站代码、经纬度、高程、台站的总通道数目和当前 `inv` 中包含的 +通道数目： +```{code-cell} ipython3 +print(sta.code, sta.latitude, sta.longitude, sta.elevation) +print(sta.total_number_of_channels, sta.selected_number_of_channels) +``` + +可以对 {class}`~obspy.core.inventory.station.Station` 进行列表相关的操作， +这里我们取该台站的第一个通道并查看其信息： +```{code-cell} ipython3 +chn = sta[0] +print(chn) +``` + +### {class}`~obspy.core.inventory.channel.Channel` 类 + +{class}`~obspy.core.inventory.channel.Channel` 类也提供了很多通道相关的属性和函数。 +例如，下面的代码输出了当前通道的方位角、倾角、位置码和采样率等信息： +```{code-cell} ipython3 +print(chn.azimuth, chn.dip, chn.location_code, chn.sample_rate) +``` \ No newline at end of file diff --git a/_sources/exercises/waveform.ipynb b/_sources/exercises/waveform.ipynb new file mode 100644 index 000000000..6c56e8854 --- /dev/null +++ b/_sources/exercises/waveform.ipynb @@ -0,0 +1,580 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4e0d537d", + "metadata": {}, + "source": [ + "# 地震波形数据\n", + "\n", + "- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿）\n", + "- 最近更新日期: 2023-05-10\n", + "- 预计花费时间: 60 分钟\n", + "\n", + "---\n", + "\n", + "地震波形数据是地震学中最重要的数据。这一节介绍如何使用 ObsPy 下载地震波形数据。\n", + "\n", + "首先，需要导入 ObsPy 中地震数据中心数据下载客户端 {class}`~obspy.clients.fdsn.client.Client`\n", + "以及用于处理时间的类 {class}`~obspy.core.utcdatetime.UTCDateTime`：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6acad118", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy.clients.fdsn import Client\n", + "from obspy import UTCDateTime" + ] + }, + { + "cell_type": "markdown", + "id": "c13f018c", + "metadata": {}, + "source": [ + "接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。\n", + "ObsPy 的 `Client` 支持多个地震数据中心，这里我们选择使用\n", + "[IRIS 地震数据中心](https://ds.iris.edu/ds/nodes/dmc/)：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7bb957b8", + "metadata": {}, + "outputs": [], + "source": [ + "client = Client(\"IRIS\")" + ] + }, + { + "cell_type": "markdown", + "id": "5f5cdaac", + "metadata": {}, + "source": [ + "我们以 2022 年 9 月 22 日发生在墨西哥的一个 Mw 6.8 级地震为例，申请该地震相关的\n", + "波形数据。该地震的基本信息为：\n", + "\n", + "- 发震时刻：2022-09-22 06:16:09 UTC\n", + "- 经度：102.9518° W\n", + "- 纬度：18.247° N\n", + "- 深度：20.0 km\n", + "- 震级：mww 6.8\n", + "\n", + "该地震的详细信息见 。\n", + "\n", + "## 下载单个波形数据\n", + "\n", + "下载波形数据时需要提供两个最基本的信息：\n", + "\n", + "- 下载哪个地震台站哪个通道的数据，即需要指定台网（`network`）、台站（`station`）、\n", + " 位置码（`location`）和通道码（`channel`）\n", + "- 下载哪个时间段的数据，即指定数据开始时间（`starttime`）和结束时间（`endtime`）\n", + "\n", + "下面的代码使用 {meth}`Client.get_waveforms() `\n", + "函数申请了 `IU.ANMO` 台站的宽频带垂直分量（即 `BHZ` 通道）的波形数据。数据开始时间为\n", + "2022-09-22T06:18:00（即发震后约两分钟），结束时间为 2022-09-22T06:30:00，\n", + "数据总长度为 12 分钟（即 720 秒）。\n", + "```{margin}\n", + "这里先假定我们已知台站 `IU.ANMO` 存在位置码为 `00`、通道码为 `BHZ` 的通道。\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5beb5afb", + "metadata": {}, + "outputs": [], + "source": [ + "starttime=UTCDateTime(\"2022-09-22T06:18:00\") # 定义开始时间\n", + "st = client.get_waveforms(\n", + " network=\"IU\", # 指定台网名\n", + " station=\"ANMO\", # 指定台站名\n", + " location=\"00\", # 指定位置码\n", + " channel=\"BHZ\", # 指定通道码\n", + " starttime=starttime, # 指定开始时间\n", + " endtime=starttime + 720 # 指定结束时间\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c01e69d4", + "metadata": {}, + "source": [ + "函数的返回值为 {class}`~obspy.core.stream.Stream` 类型，赋值给变量 `st`。\n", + "使用 `print` 函数可以显示变量 `st` 的值：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "52ab463d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 Trace(s) in Stream:\n", + "IU.ANMO.00.BHZ | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n" + ] + } + ], + "source": [ + "print(st)" + ] + }, + { + "cell_type": "markdown", + "id": "001d8048", + "metadata": {}, + "source": [ + "可以看到{class}`~obspy.core.stream.Stream` 类型的变量 `st` 中包含了一个波形\n", + "（即 一个 {class}`~obspy.core.trace.Trace`），该波形对应的 ID 为 `IU.ANMO.00.BHZ`，\n", + "数据采样率为 40 Hz，共计 28800 个数据点。\n", + "\n", + "{class}`~obspy.core.stream.Stream` 类提供了 {meth}`Stream.plot() `\n", + "函数可以用于绘制波形。波形图的横轴为时间，纵轴为振幅：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "085a62af", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/waveform_9_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "st.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "e41ac010", + "metadata": {}, + "source": [ + "## 下载多个波形数据\n", + "\n", + "`network`、`station`、`location` 和 `channel` 参数支持使用 UNIX 通配符，\n", + "以实现一次性下载多个波形数据的目的。通配符 `?` 表示匹配单个字符，通配符 `*`\n", + "表示匹配零个或多个字符。\n", + "\n", + "下面的代码中 `channel` 参数指定为 `BH?` 以下载宽频带三分量数据：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "af041ab7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3 Trace(s) in Stream:\n", + "IU.ANMO.00.BH1 | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n", + "IU.ANMO.00.BH2 | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n", + "IU.ANMO.00.BHZ | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n" + ] + } + ], + "source": [ + "st = client.get_waveforms(\n", + " network=\"IU\",\n", + " station=\"ANMO\",\n", + " location=\"00\",\n", + " channel=\"BH?\", # \"BH?\" 表示下载三分量数据\n", + " starttime=starttime,\n", + " endtime=starttime + 720\n", + ")\n", + "print(st)" + ] + }, + { + "cell_type": "markdown", + "id": "d0f19475", + "metadata": {}, + "source": [ + "函数返回的 {class}`~obspy.core.stream.Stream` 中包含三个 {class}`~obspy.core.trace.Trace`。\n", + "其中 `BHZ` 为垂直分量，`BH1` 和 `BH2` 为两个水平分量。绘图结果如下：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e254b8f2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/waveform_13_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "st.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "a5453744", + "metadata": {}, + "source": [ + "除了支持通配符外，这四个参数还支持用逗号分隔的代码列表。例如：\n", + "\n", + "- `network=\"IU,IC\"` 表示同时匹配 `IU` 和 `IC` 两个台网\n", + "- `station=\"ANMO,HKT,TUC\"` 表示匹配三个台站名\n", + "- `location=\"--,00,01\"` 表示匹配多个位置码，其中 `--` 表示位置码为空值\n", + "- `channel=\"BH?,SH?,LH?\"` 表示匹配宽频带、短周期和长周期三分量\n", + "\n", + "下面的代码中同时下载了三个台站的宽频带垂直分量的波形数据：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "996f313c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3 Trace(s) in Stream:\n", + "IU.ANMO.00.BHZ | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n", + "IU.HKT.00.BHZ | 2022-09-22T06:18:00.019539Z - 2022-09-22T06:29:59.994539Z | 40.0 Hz, 28800 samples\n", + "IU.TUC.00.BHZ | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n" + ] + } + ], + "source": [ + "st = client.get_waveforms(\n", + " network=\"IU\",\n", + " station=\"ANMO,HKT,TUC\", # IU 台网的三个台站\n", + " location=\"00\",\n", + " channel=\"BHZ\",\n", + " starttime=starttime,\n", + " endtime=starttime + 720\n", + ")\n", + "print(st)" + ] + }, + { + "cell_type": "markdown", + "id": "6593aff8", + "metadata": {}, + "source": [ + "函数返回的 {class}`~obspy.core.stream.Stream` 中包含三个 {class}`~obspy.core.trace.Trace`。\n", + "绘图如下。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e66e2774", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/waveform_17_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "st.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "6bcf5ddb", + "metadata": {}, + "source": [ + "## 批量下载多个波形数据\n", + "\n", + "上面的示例中，虽然使用 {meth}`Client.get_waveforms() `\n", + "可以一次性下载多个波形数据，但通配符本身不够灵活，且所有数据必须拥有相同的开始时间\n", + "和结束时间。\n", + "\n", + "{meth}`Client.get_waveforms_bulk() ` 函数\n", + "可以以更灵活的方式批量下载多个波形数据。该函数中最重要的参数是 `bulk` 参数。\n", + "该参数可以用多种不同的方式指定，包括：\n", + "\n", + "- 列表。列表的每个元素为格式为 `(network, station, location, channel, starttime, endtime)` 的元组\n", + "- 符合 [FDSN Web Service 文档](https://www.fdsn.org/webservices/)所要求的请求字符串或文件\n", + "\n", + "这里我们只介绍第一种方式。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "82b1d427", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 Trace(s) in Stream:\n", + "II.PFO.00.BHZ | 2022-09-22T06:19:40.019538Z - 2022-09-22T06:37:59.994538Z | 40.0 Hz, 44000 samples\n", + "IU.ANMO.00.BHZ | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:29:59.994538Z | 40.0 Hz, 28800 samples\n", + "IU.HKT.00.BH1 | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:31:19.994538Z | 40.0 Hz, 32000 samples\n", + "IU.HKT.00.BH2 | 2022-09-22T06:18:00.019538Z - 2022-09-22T06:31:19.994538Z | 40.0 Hz, 32000 samples\n", + "IU.HKT.00.BHZ | 2022-09-22T06:18:00.019539Z - 2022-09-22T06:31:19.994539Z | 40.0 Hz, 32000 samples\n" + ] + } + ], + "source": [ + "bulk = [\n", + " (\"IU\", \"ANMO\", \"00\", \"BHZ\", starttime, starttime + 720),\n", + " (\"IU\", \"HKT\", \"00\", \"BH?\", starttime, starttime + 800),\n", + " (\"II\", \"PFO\", \"00\", \"BHZ\", starttime + 100, starttime + 1200),\n", + "]\n", + "st = client.get_waveforms_bulk(bulk)\n", + "print(st)" + ] + }, + { + "cell_type": "markdown", + "id": "7e2952fc", + "metadata": {}, + "source": [ + "在这个示例中，我们申请了 `IU.ANMO.00.BHZ`、`IU.HKT.00.BH?` 和 `II.PFO.00.BHZ` 的\n", + "波形数据，且每个波形数据的开始时间和结束时间均不同，最终申请得到 5 个波形数据。\n", + "绘图结果如下：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8622b3d6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "filenames": { + "image/png": "/home/runner/work/seismology101/seismology101/_build/jupyter_execute/exercises/waveform_21_0.png" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "st.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "bd936992", + "metadata": {}, + "source": [ + "## 下载大量波形数据\n", + "\n", + "上面的示例已经可以灵活地一次性下载多个地震波形数据，但要求用户必须自行准备 `bulk` 参数，\n", + "即用户需要首先获取地震和台站信息并对其进行筛选，然后自行构建 `bulk` 参数。在需要\n", + "下载大量波形数据时相对比较繁琐。\n", + "\n", + "为了更方便地下载大量波形数据，ObsPy 提供了 {mod}`obspy.clients.fdsn.mass_downloader` 模块。\n", + "{mod}`~obspy.clients.fdsn.mass_downloader` 模块主要包含了三部分：\n", + "\n", + "- {mod}`~obspy.clients.fdsn.mass_downloader.domain`：根据位置信息筛选台站\n", + "- {class}`~obspy.clients.fdsn.mass_downloader.restrictions.Restrictions`：用于设置波形数据的相关参数\n", + "- {class}`~obspy.clients.fdsn.mass_downloader.mass_downloader.MassDownloader`：用于下载数据\n", + "\n", + "下面通过两个示例介绍 {mod}`~obspy.clients.fdsn.mass_downloader` 模块的基本用法。\n", + "更详细的用法参见官方文档。\n", + "\n", + "### 下载地震波形数据\n", + "\n", + "下面的示例展示了如何使用 {class}`~obspy.clients.fdsn.mass_downloader.mass_downloader.MassDownloader`\n", + "下载单个地震多台站的波形数据：\n", + "```\n", + "import obspy\n", + "from obspy.clients.fdsn.mass_downloader import CircularDomain, \\\n", + " Restrictions, MassDownloader\n", + "\n", + "origin_time = obspy.UTCDateTime(2011, 3, 11, 5, 47, 32)\n", + "\n", + "# 使用 CircularDomain 限定使用震中 30 到 40 度范围内的台站\n", + "domain = CircularDomain(\n", + " latitude=18.247,\n", + " longitude=-102.9518,\n", + " minradius=30.0,\n", + " maxradius=40.0\n", + ")\n", + "\n", + "# Restriction 用于对波形进行进一步筛选\n", + "restrictions = Restrictions(\n", + " # 设置波形的开始时间和结束时间\n", + " starttime=origin_time,\n", + " endtime=origin_time + 1200,\n", + " # 丢弃所有数据中包含 gap（即存在中断）的数据\n", + " reject_channels_with_gaps=True,\n", + " # 实际获得的数据长度不小于数据申请的时间段长度的 95%\n", + " minimum_length=0.95,\n", + " # 通道优先级。当一个台站同时有 HH? 和 BH？数据时，优先下载 HH？数据\n", + " channel_priorities=[\"HH?\", \"BH?\"]\n", + ")\n", + "\n", + "# 初始化\n", + "mdl = MassDownloader()\n", + "# 将数据下载到 waveforms 目录下，台站元数据下载到 stations 目录下\n", + "mdl.download(\n", + " domain,\n", + " restrictions,\n", + " mseed_storage=\"waveforms\",\n", + " stationxml_storage=\"stations\"\n", + ")\n", + "```\n", + "\n", + "### 下载连续波形数据\n", + "\n", + "下面的示例展示了如何使用 {class}`~obspy.clients.fdsn.mass_downloader.mass_downloader.MassDownloader`\n", + "下载连续波形数据：\n", + "```\n", + "import obspy\n", + "from obspy.clients.fdsn.mass_downloader import RectangularDomain, \\\n", + " Restrictions, MassDownloader\n", + "\n", + "# 限制台站位于一个矩形区域内\n", + "domain = RectangularDomain(\n", + " minlatitude=30,\n", + " maxlatitude=50,\n", + " minlongitude=5,\n", + " maxlongitude=35\n", + ")\n", + "\n", + "restrictions = Restrictions(\n", + " # 设置数据的开始时间和结束时间\n", + " starttime=obspy.UTCDateTime(2012, 1, 1),\n", + " endtime=obspy.UTCDateTime(2013, 1, 1),\n", + " # 将数据分块，每块的长度为 86400 秒。即一天的数据保存到一个文件中\n", + " chunklength_in_sec=86400,\n", + " # 设置要下载的数据的 network, station, location 和 channel 信息\n", + " network=\"BW\", station=\"A*\", location=\"\", channel=\"EH*\",\n", + " # 不删除存在数据中断的数据\n", + " reject_channels_with_gaps=False,\n", + " # 不限制数据的最小长度\n", + " minimum_length=0.0,\n", + ")\n", + "\n", + "mdl = MassDownloader(providers=[\"LMU\", \"GFZ\"]) # 设置地震数据中心列表\n", + "mdl.download(\n", + " domain,\n", + " restrictions,\n", + " mseed_storage=\"waveforms\",\n", + " stationxml_storage=\"stations\"\n", + ")\n", + "```\n", + "\n", + "## 其他地震数据申请软件\n", + "\n", + "除了 ObsPy 外，还存在很多其他地震数据申请软件，包括但不限于：\n", + "\n", + "- [SOD](http://www.seis.sc.edu/sod/)\n", + "- [Wilber 3](https://ds.iris.edu/wilber3)\n", + "- [irisFetch.m](https://ds.iris.edu/ds/nodes/dmc/manuals/irisfetchm/)\n", + "\n", + "不同的软件各有其利弊，读者亦可了解并学习这些软件，并根据具体需求使用合适的软件。" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst", + "format_version": 0.13, + "jupytext_version": "1.13.0" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "source_map": [ + 12, + 26, + 29, + 34, + 36, + 64, + 74, + 77, + 79, + 86, + 88, + 97, + 107, + 110, + 112, + 122, + 132, + 135, + 137, + 153, + 161, + 165, + 167 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_sources/exercises/waveform.md b/_sources/exercises/waveform.md new file mode 100644 index 000000000..d8acd543a --- /dev/null +++ b/_sources/exercises/waveform.md @@ -0,0 +1,276 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.13.0 +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# 地震波形数据 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-05-10 +- 预计花费时间: 60 分钟 + +--- + +地震波形数据是地震学中最重要的数据。这一节介绍如何使用 ObsPy 下载地震波形数据。 + +首先，需要导入 ObsPy 中地震数据中心数据下载客户端 {class}`~obspy.clients.fdsn.client.Client` +以及用于处理时间的类 {class}`~obspy.core.utcdatetime.UTCDateTime`： +```{code-cell} ipython3 +from obspy.clients.fdsn import Client +from obspy import UTCDateTime +``` + +接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。 +ObsPy 的 `Client` 支持多个地震数据中心，这里我们选择使用 +[IRIS 地震数据中心](https://ds.iris.edu/ds/nodes/dmc/)： +```{code-cell} ipython3 +client = Client("IRIS") +``` + +我们以 2022 年 9 月 22 日发生在墨西哥的一个 Mw 6.8 级地震为例，申请该地震相关的 +波形数据。该地震的基本信息为： + +- 发震时刻：2022-09-22 06:16:09 UTC +- 经度：102.9518° W +- 纬度：18.247° N +- 深度：20.0 km +- 震级：mww 6.8 + +该地震的详细信息见 。 + +## 下载单个波形数据 + +下载波形数据时需要提供两个最基本的信息： + +- 下载哪个地震台站哪个通道的数据，即需要指定台网（`network`）、台站（`station`）、 + 位置码（`location`）和通道码（`channel`） +- 下载哪个时间段的数据，即指定数据开始时间（`starttime`）和结束时间（`endtime`） + +下面的代码使用 {meth}`Client.get_waveforms() ` +函数申请了 `IU.ANMO` 台站的宽频带垂直分量（即 `BHZ` 通道）的波形数据。数据开始时间为 +2022-09-22T06:18:00（即发震后约两分钟），结束时间为 2022-09-22T06:30:00， +数据总长度为 12 分钟（即 720 秒）。 +```{margin} +这里先假定我们已知台站 `IU.ANMO` 存在位置码为 `00`、通道码为 `BHZ` 的通道。 +``` +```{code-cell} ipython3 +starttime=UTCDateTime("2022-09-22T06:18:00") # 定义开始时间 +st = client.get_waveforms( + network="IU", # 指定台网名 + station="ANMO", # 指定台站名 + location="00", # 指定位置码 + channel="BHZ", # 指定通道码 + starttime=starttime, # 指定开始时间 + endtime=starttime + 720 # 指定结束时间 +) +``` +函数的返回值为 {class}`~obspy.core.stream.Stream` 类型，赋值给变量 `st`。 +使用 `print` 函数可以显示变量 `st` 的值： +```{code-cell} ipython3 +print(st) +``` +可以看到{class}`~obspy.core.stream.Stream` 类型的变量 `st` 中包含了一个波形 +（即 一个 {class}`~obspy.core.trace.Trace`），该波形对应的 ID 为 `IU.ANMO.00.BHZ`， +数据采样率为 40 Hz，共计 28800 个数据点。 + +{class}`~obspy.core.stream.Stream` 类提供了 {meth}`Stream.plot() ` +函数可以用于绘制波形。波形图的横轴为时间，纵轴为振幅： +```{code-cell} ipython3 +st.plot(); +``` + +## 下载多个波形数据 + +`network`、`station`、`location` 和 `channel` 参数支持使用 UNIX 通配符， +以实现一次性下载多个波形数据的目的。通配符 `?` 表示匹配单个字符，通配符 `*` +表示匹配零个或多个字符。 + +下面的代码中 `channel` 参数指定为 `BH?` 以下载宽频带三分量数据： +```{code-cell} ipython3 +st = client.get_waveforms( + network="IU", + station="ANMO", + location="00", + channel="BH?", # "BH?" 表示下载三分量数据 + starttime=starttime, + endtime=starttime + 720 +) +print(st) +``` +函数返回的 {class}`~obspy.core.stream.Stream` 中包含三个 {class}`~obspy.core.trace.Trace`。 +其中 `BHZ` 为垂直分量，`BH1` 和 `BH2` 为两个水平分量。绘图结果如下： +```{code-cell} ipython3 +st.plot(); +``` + +除了支持通配符外，这四个参数还支持用逗号分隔的代码列表。例如： + +- `network="IU,IC"` 表示同时匹配 `IU` 和 `IC` 两个台网 +- `station="ANMO,HKT,TUC"` 表示匹配三个台站名 +- `location="--,00,01"` 表示匹配多个位置码，其中 `--` 表示位置码为空值 +- `channel="BH?,SH?,LH?"` 表示匹配宽频带、短周期和长周期三分量 + +下面的代码中同时下载了三个台站的宽频带垂直分量的波形数据： +```{code-cell} ipython3 +st = client.get_waveforms( + network="IU", + station="ANMO,HKT,TUC", # IU 台网的三个台站 + location="00", + channel="BHZ", + starttime=starttime, + endtime=starttime + 720 +) +print(st) +``` +函数返回的 {class}`~obspy.core.stream.Stream` 中包含三个 {class}`~obspy.core.trace.Trace`。 +绘图如下。 +```{code-cell} ipython3 +st.plot(); +``` + +## 批量下载多个波形数据 + +上面的示例中，虽然使用 {meth}`Client.get_waveforms() ` +可以一次性下载多个波形数据，但通配符本身不够灵活，且所有数据必须拥有相同的开始时间 +和结束时间。 + +{meth}`Client.get_waveforms_bulk() ` 函数 +可以以更灵活的方式批量下载多个波形数据。该函数中最重要的参数是 `bulk` 参数。 +该参数可以用多种不同的方式指定，包括： + +- 列表。列表的每个元素为格式为 `(network, station, location, channel, starttime, endtime)` 的元组 +- 符合 [FDSN Web Service 文档](https://www.fdsn.org/webservices/)所要求的请求字符串或文件 + +这里我们只介绍第一种方式。 +```{code-cell} ipython3 +bulk = [ + ("IU", "ANMO", "00", "BHZ", starttime, starttime + 720), + ("IU", "HKT", "00", "BH?", starttime, starttime + 800), + ("II", "PFO", "00", "BHZ", starttime + 100, starttime + 1200), +] +st = client.get_waveforms_bulk(bulk) +print(st) +``` +在这个示例中，我们申请了 `IU.ANMO.00.BHZ`、`IU.HKT.00.BH?` 和 `II.PFO.00.BHZ` 的 +波形数据，且每个波形数据的开始时间和结束时间均不同，最终申请得到 5 个波形数据。 +绘图结果如下： +```{code-cell} ipython3 +st.plot(); +``` + +## 下载大量波形数据 + +上面的示例已经可以灵活地一次性下载多个地震波形数据，但要求用户必须自行准备 `bulk` 参数， +即用户需要首先获取地震和台站信息并对其进行筛选，然后自行构建 `bulk` 参数。在需要 +下载大量波形数据时相对比较繁琐。 + +为了更方便地下载大量波形数据，ObsPy 提供了 {mod}`obspy.clients.fdsn.mass_downloader` 模块。 +{mod}`~obspy.clients.fdsn.mass_downloader` 模块主要包含了三部分： + +- {mod}`~obspy.clients.fdsn.mass_downloader.domain`：根据位置信息筛选台站 +- {class}`~obspy.clients.fdsn.mass_downloader.restrictions.Restrictions`：用于设置波形数据的相关参数 +- {class}`~obspy.clients.fdsn.mass_downloader.mass_downloader.MassDownloader`：用于下载数据 + +下面通过两个示例介绍 {mod}`~obspy.clients.fdsn.mass_downloader` 模块的基本用法。 +更详细的用法参见官方文档。 + +### 下载地震波形数据 + +下面的示例展示了如何使用 {class}`~obspy.clients.fdsn.mass_downloader.mass_downloader.MassDownloader` +下载单个地震多台站的波形数据： +``` +import obspy +from obspy.clients.fdsn.mass_downloader import CircularDomain, \ + Restrictions, MassDownloader + +origin_time = obspy.UTCDateTime(2011, 3, 11, 5, 47, 32) + +# 使用 CircularDomain 限定使用震中 30 到 40 度范围内的台站 +domain = CircularDomain( + latitude=18.247, + longitude=-102.9518, + minradius=30.0, + maxradius=40.0 +) + +# Restriction 用于对波形进行进一步筛选 +restrictions = Restrictions( + # 设置波形的开始时间和结束时间 + starttime=origin_time, + endtime=origin_time + 1200, + # 丢弃所有数据中包含 gap（即存在中断）的数据 + reject_channels_with_gaps=True, + # 实际获得的数据长度不小于数据申请的时间段长度的 95% + minimum_length=0.95, + # 通道优先级。当一个台站同时有 HH? 和 BH？数据时，优先下载 HH？数据 + channel_priorities=["HH?", "BH?"] +) + +# 初始化 +mdl = MassDownloader() +# 将数据下载到 waveforms 目录下，台站元数据下载到 stations 目录下 +mdl.download( + domain, + restrictions, + mseed_storage="waveforms", + stationxml_storage="stations" +) +``` + +### 下载连续波形数据 + +下面的示例展示了如何使用 {class}`~obspy.clients.fdsn.mass_downloader.mass_downloader.MassDownloader` +下载连续波形数据： +``` +import obspy +from obspy.clients.fdsn.mass_downloader import RectangularDomain, \ + Restrictions, MassDownloader + +# 限制台站位于一个矩形区域内 +domain = RectangularDomain( + minlatitude=30, + maxlatitude=50, + minlongitude=5, + maxlongitude=35 +) + +restrictions = Restrictions( + # 设置数据的开始时间和结束时间 + starttime=obspy.UTCDateTime(2012, 1, 1), + endtime=obspy.UTCDateTime(2013, 1, 1), + # 将数据分块，每块的长度为 86400 秒。即一天的数据保存到一个文件中 + chunklength_in_sec=86400, + # 设置要下载的数据的 network, station, location 和 channel 信息 + network="BW", station="A*", location="", channel="EH*", + # 不删除存在数据中断的数据 + reject_channels_with_gaps=False, + # 不限制数据的最小长度 + minimum_length=0.0, +) + +mdl = MassDownloader(providers=["LMU", "GFZ"]) # 设置地震数据中心列表 +mdl.download( + domain, + restrictions, + mseed_storage="waveforms", + stationxml_storage="stations" +) +``` + +## 其他地震数据申请软件 + +除了 ObsPy 外，还存在很多其他地震数据申请软件，包括但不限于： + +- [SOD](http://www.seis.sc.edu/sod/) +- [Wilber 3](https://ds.iris.edu/wilber3) +- [irisFetch.m](https://ds.iris.edu/ds/nodes/dmc/manuals/irisfetchm/) + +不同的软件各有其利弊，读者亦可了解并学习这些软件，并根据具体需求使用合适的软件。 diff --git a/_sources/index.md b/_sources/index.md new file mode 100644 index 000000000..904951427 --- /dev/null +++ b/_sources/index.md @@ -0,0 +1,75 @@ +# 地震“学”科研入门教程 + +欢迎阅读由[地震“学”小组](https://github.com/orgs/seismo-learn/people)撰写的 +《[地震“学”科研入门教程](https://seismo-learn.org/seismology101/)》。 + +:::::{grid} 2 3 3 4 + +::::{grid-item-card} [田冬冬](https://github.com/seisman) +:margin: 0 0 0 0 +:text-align: center +:img-top: https://avatars.githubusercontent.com/u/3974108?v=4 + ++++ +{bdg-primary}`创始人` {bdg-secondary}`核心贡献者` +:::: + +::::{grid-item-card} [姚家园](https://github.com/core-man) +:margin: 0 0 0 0 +:text-align: center +:img-top: https://avatars.githubusercontent.com/u/50591376?v=4 + ++++ +{bdg-primary}`创始人` {bdg-secondary}`核心贡献者` +:::: + +::::{grid-item-card} [赵志远](https://github.com/zhaozhiyuan1989) +:margin: 0 0 0 0 +:text-align: center +:img-top: https://avatars.githubusercontent.com/u/23535406?v=4 + ++++ +{bdg-success}`贡献者` +:::: + +::::{grid-item-card} [王亮](https://github.com/wangliang1989) +:margin: 0 0 0 0 +:text-align: center +:img-top: https://avatars.githubusercontent.com/u/12059719?v=4 + ++++ +{bdg-success}`贡献者` +:::: +::::: + +```{rubric} 目标与受众 +``` +本教程主要面向地震学新手，包括地震学专业的高年级本科生、低年级研究生以及 +其他刚接触地震学的科研人员。 + +本教程的主要目的是帮助地震学新手快速入门，以尽快开展实际的科研工作。其既可以 +作为地震学新手的入门自学材料，也可以作为地震学研究组的入门培训材料。 + +```{rubric} 教程内容 +``` +本教程主要包括五部分内容： + +1. **计算机基础**：Linux 操作系统的基础知识和常用操作 +2. **编程基础**：科研工作中常用的编程语言和编程技能 +3. **地震学基础**：开展科研工作前必须了解的地震学基础知识 +4. **地震学实践**：通过实践掌握基本的地震学数据处理 +5. **实践经验**：日常科研工作中的一些实践经验 + +```{rubric} 反馈与建议 +``` +欢迎地震学新手在阅读本教程的过程中给予反馈，也欢迎地震学专家提出意见和建议， +这些都将帮助我们进一步改进和完善本教程，造福更多的地震学新手。 +请通过如下方式给予反馈： + +1. {octicon}`comment-discussion` [留言参与讨论](https://github.com/orgs/seismo-learn/discussions) +2. {octicon}`issue-opened` 在教程源码仓库下[提交 Issue](https://github.com/seismo-learn/seismology101/issues) +3. {octicon}`git-pull-request` 修改文档并[提交 Pull Request](https://github.com/seismo-learn/seismology101/pulls) + +```{rubric} 免责声明 +``` +本教程的所有内容完全基于撰写者在地震学科研过程中的理解与体会，仅供读者参考。 diff --git a/_sources/programming/bash.md b/_sources/programming/bash.md new file mode 100644 index 000000000..882f3b72b --- /dev/null +++ b/_sources/programming/bash.md @@ -0,0 +1,104 @@ +# Bash 脚本 + +- 本节作者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2023-02-27 +- 预计阅读时间: 15 分钟 + +--- + +## Bash 简介 + +Bash（全称 **B**ourne-**A**gain **SH**ell）是 GNU 开发的一个 Shell。 +Bash 是目前绝大多数 Linux 发行版的默认 Shell。 + +打开终端，使用如下命令可以查看本机的 Bash 版本: +``` +$ bash --version +GNU bash，version 5.0.3(1)-release (x86_64-pc-linux-gnu) +``` + +这一节中，我们不介绍具体的 Bash 语法，而是介绍如何编写和执行 Bash 脚本。 +{doc}`/computer/linux101` 一节中已经简要介绍了 Bash 语法， +本节的最后也列出了一些 Bash 学习资源，读者可根据需要自行学习。 + +## Bash 脚本 + +按照 Bash 语法规则编写的含有一系列指令的文本文件即称之为 Bash 脚本。 +Bash 脚本一般以 `.sh` 作为后缀。 + +打开文本编辑器，新建一个文本文件，在文件中编写如下内容，并将其保存成名为 +{file}`hello-world.sh` 的文件，则得到一个简单的 Bash 脚本。 + +```bash +#!/usr/bin/env bash +# +# 输出 Hello world! +# + +# 使用 echo 命令输出 Hello world +echo Hello world! # 这也是注释 + +# 每一句指令以换行或分号隔开 +echo Hello; echo world! + +# 有些命令比较长，写成多行会有利于阅读和编辑 +# 每行结尾加上反斜杠，Bash 会将下一行跟当前行一起解释 +echo Hello world! \ +This is seismo-learn. +``` + +Bash 脚本的第一行通常用于指定脚本解释器。这一行以 Shebang 字符 `#!` 开头，故而 +也称之为 Shebang 行。Shebang 行不是必须的，但是建议加上这行。 + +Shebang 字符后紧跟着脚本解释器的路径。`/usr/bin/env bash` 可以在环境变量 +**PATH** 指定的目录中自动寻找 Bash 解释器并返回其路径。 + +```{note} +你可能也会见到 Shebang 行的另一种写法 `#!/bin/bash`。 +Bash 解释器一般位于 {file}`/bin` 目录下，因而这种写法也是可行的。 +但某些特殊的 Linux 系统的 Bash 解释器可能不在 {file}`/bin` 目录下，使得脚本 +在这些特殊的系统上无法正常运行，因而不推荐使用这种写法。 +而 `env` 命令总在 {file}`/usr/bin` 目录下，所以 `#!/usr/bin/env bash` +这种写法总可以正确找到 Bash 解释器。 +``` + +Shebang 行之后的所有行都是 Bash 脚本的实际代码，其中 `#` 表示注释，可以放在行首， +也可以放在行尾。所有注释都会被 Bash 解释器自动忽略。 + +## 运行 Bash 脚本 + +在终端中，可以直接用 `bash scriptname.sh` 的形式运行 Bash 脚本： +``` +$ bash hello-world.sh +``` + +当脚本中已经显式地指定了 Bash 解释器（即存在 Shebang 行）时，可以使用 `chmod` +命令给脚本添加可执行权限： +``` +$ chmod +x hello-world.sh +``` +此时可以直接执行 Bash 脚本： +``` +$ ./hello-world.sh +``` + +执行结果为： + +``` +Hello world! +Hello +world! +Hello world! This is seismo-learn. +``` + +拥有 Shebang 行和可执行权限的脚本，在调用时还需要指定脚本的路径， +如 `./hello-world.sh` 代表该脚本位于当前目录。如果将脚本放在环境变量 **PATH** +指定的目录中，就不需要指定路径了，因为 Bash 会自动到这些目录中寻找是否存在同名的 +可执行文件。可以参考{doc}`/computer/environment-variable`一节 +设置环境变量 **PATH**。 + +## 扩展阅读 + +- [Bash 脚本教程](https://wangdoc.com/bash/)（全面、系统） +- [Bash 脚本基础](https://101.lug.ustc.edu.cn/Ch06/#bash-usage)（简要） +- [X 分钟速成 Bash](https://learnxinyminutes.com/docs/zh-cn/bash-cn/)（简要） diff --git a/_sources/programming/c.md b/_sources/programming/c.md new file mode 100644 index 000000000..dffc050b9 --- /dev/null +++ b/_sources/programming/c.md @@ -0,0 +1,26 @@ +# C 语言 + +:::{warning} +本节正在编写中。 +::: + +## C 语言简介 + +## 简单的 C 源码示例 + +## 编译 C 源码 + +## 复杂的 C 源码示例 + +## 编译与链接 + +## Makefile + +## 扩展阅读 + +- [C 语言教程](https://wangdoc.com/clang/) +- [C 语言教程](https://www.runoob.com/cprogramming/c-tutorial.html)（较全面、系统） +- [X 分钟速成 C](https://learnxinyminutes.com/docs/zh-cn/c-cn/)（简要） +- [Building programs](https://fortran-lang.org/learn/building_programs)（简要） +- [跟我一起写 Makefile](https://seisman.github.io/how-to-write-makefile/)（较全面、系统） +- [X 分钟速成 make](https://learnxinyminutes.com/docs/zh-cn/make-cn/)（简要） diff --git a/_sources/programming/editor.md b/_sources/programming/editor.md new file mode 100644 index 000000000..fcd952e6c --- /dev/null +++ b/_sources/programming/editor.md @@ -0,0 +1,28 @@ +# 文本编辑器 + +- 本节作者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2022-03-23 +- 预计阅读时间: 30 分钟 + +--- + +不管是编辑文本文件、脚本还是程序源码，都需使用一个叫做**编辑器**的程序。 +各个操作系统都内置了一款文本编辑器，Windows 下是记事本（Notepad）， +macOS 下是 TextEdit，Linux 一般是 Gedit。这些文本编辑器只有最基本的文本编辑功能。 +日常科研中，我们很多时间都花在编写代码和文本文件上，因而需要使用一个更强大、 +更高效的文本编辑器，以提升编写效率。 + +对于刚接触编辑器的读者，**推荐**在日常科研中使用微软开发的编辑器 +[Visual Studio Code](https://code.visualstudio.com/) （一般写作 VS Code）， +其具有强大的功能且支持丰富的插件以扩展更多功能，是目前最流行的代码编辑器。 + +## 安装 VS Code + +VS Code 下载地址： + +根据当前操作系统，下载对应的安装包，双击安装即可。 + +## 使用 VS Code + +建议在日常科研中随时根据个人习惯，去配置 VS Code、安装和使用扩展包等。 +更多的配置和使用技巧见 {doc}`/best-practices/vscode`。 diff --git a/_sources/programming/git.md b/_sources/programming/git.md new file mode 100644 index 000000000..3edcd8281 --- /dev/null +++ b/_sources/programming/git.md @@ -0,0 +1,10 @@ +# Git 与代码管理 + +:::{warning} +本章尚未开始编写。读者可以参考以下资料学习，欢迎提供反馈： + +- [Pro Git](https://git-scm.com/book/zh/)（全面、系统） +- [git 教程](https://www.liaoxuefeng.com/wiki/896043488029600)（较全面、系统） +- [X 分钟速成 git](https://learnxinyminutes.com/docs/zh-cn/git-cn/)（简要） +- [Pull Request 流程](https://seismo-learn.org/contributing/pull-request/)（简要） +::: diff --git a/_sources/programming/intro.md b/_sources/programming/intro.md new file mode 100644 index 000000000..64c1175ee --- /dev/null +++ b/_sources/programming/intro.md @@ -0,0 +1,62 @@ +# 简介 + +- 本节作者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2022-03-12 +- 预计阅读时间: 5 分钟 + +--- + +## 为什么要学编程？ + +几乎所有高校在大一都开设了类似《C 语言程序设计》这门课，想必你对 C 语言以及 +编程都已经有了一些了解。编程本质上就是人将某个问题的解决思路写成 +计算机能够读懂的指令，计算机则执行指令帮助人解决问题。 + +地震学是一门基于观测数据的科学。地震学科研中需要对大量观测数据进行处理和分析， +并作一些理论计算，因而需要通过编程让计算机辅助完成数据处理或科学计算。 + +## 编程语言有哪些？ + +世界上存在的编程语言有几百个，其中用的比较多的大概有十几个。 +编程语言根据执行方式的差异大致可以分为两大类： + +编译型语言 + +: 编译型语言是指需要使用特定的**编译器**将源代码编译成在当前系统上可执行的 + 二进制文件，再通过运行该二进制文件以执行代码。 + C、C++、Fortran 和 Java 等是常见的编译型语言。 + +解释型语言 + +: 解释型语言是指需要使用特定的**解释器**读取源代码并立即执行代码。 + Python 和 Matlab 等是常见的解释型语言。 + + 一般将解释型语言编写的源代码称为脚本（script），所以解释型语言也称为**脚本语言**。 + 实际上，脚本就是包含一系列指令的文本文件。解释器读取这个文件， + 立即依次执行脚本里的所有命令、函数以及表达式等。 + +两种语言都有各自的优缺点。一般而言，编译型语言编写的代码运行速度更快，但需要 +花费更多的时间编写代码，还需要先编译才能使用，因而需要掌握编译方法。解释型语言 +更易于编写，开源的软件库和模块更多，不需要编译即可执行，但一般代码执行速度慢。 + +## 我该学习那种编程语言？ + +**地震学科研工作者需至少掌握一门脚本语言，同时推荐学习一门编译型语言**。对于脚本语言， +推荐使用目前在地震学领域最流行的 Python 语言，其官方模块、第三方模块和软件包众多， +基本可以满足日常科研工作需求。而使用哪种编译型语言并不重要，熟悉掌握一门编译型语言， +其他编译型语言也就可以很快地学会和上手了。 + +日常的数据处理和简单的科学计算可以使用脚本语言快速实现，以便迅速上手和开展研究。如果需要 +更高的计算效率，可以使用编译型语言编写代码。因此，完成一个项目往往是同时使用这两类编程语言 +来编写代码。有时候还可以用脚本语言快速、便捷地实现一个任务的一部分，然后调用使用编译型语言 +书写的需求计算效率的另外一部分的代码来加速计算。 + +需要注意的是，在本教程中我们将 Linux 和 macOS 系统的 Shell 也归为脚本语言。严格说来， +Shell 其实本身只是一个空壳，具有最基本的条件判断和循环功能。借助 Linux 和 macOS 系统的 +命令行工具，如 `awk`、`sort`、`grep`，其可以用来做日常的数据处理、 +字符串处理等。Shell 脚本一般仅适合用几行就可以搞定的简单程序，更复杂的情况建议使用其他 +脚本语言来完成。我们以一种常见的 Shell 来讲述其基本语法和用途，即 Bash，其他常见的 Shell +还有 Zsh、csh 等。 + +日常编程除了直接编写代码，往往还需要写 README 文件和记一些笔记，有时还要写代码的参考文档。 +因此，推荐学习一种标记语言以便更简洁、更高效地完成上述事务。推荐学习 Markdown 标记语言。 diff --git a/_sources/programming/languages.md b/_sources/programming/languages.md new file mode 100644 index 000000000..3024e9b6c --- /dev/null +++ b/_sources/programming/languages.md @@ -0,0 +1,6 @@ +# 编程语言 + +这一节简要介绍几种常见的编程语言以及 Markdown 标记语言。 + +```{tableofcontents} +``` diff --git a/_sources/programming/markdown.md b/_sources/programming/markdown.md new file mode 100644 index 000000000..a5b05ed1b --- /dev/null +++ b/_sources/programming/markdown.md @@ -0,0 +1,40 @@ +# Markdown + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2021-02-26 +- 预计花费时间: 30 分钟 + +--- + +[Markdown](https://daringfireball.net/projects/markdown/) 是一种轻量级标记语言， +使用语法简单的纯文本格式来编写文档，帮助人们专注于写作本身而不用关注文档格式。 + +Markdown 编写的文档易于转成 HTML、PDF、LaTeX、Word 等多种格式，且大多数编辑器支持实时渲染。 +因此，其常用于写 README、记笔记、写论文、写书、写网页等。Markdown 编写的文档后缀为一般为 +{file}`.md`。 + +Markdown 有很多特色语法，如以下常用语法： + +- 标题 +- 格式化文字：斜体、加粗、斜体加粗等 +- 超链接 +- 列表 +- 代码 +- 表格 +- 图片 +- 数学公式 + +网上有很多优秀的 Markdown 教程，因此本教程对 Markdown 语法不做详细介绍。推荐参考以下资料 +中的一个学习以上常用语法： + +- [Markdown 语法](https://help.coding.net/docs/management/markdown.html) +- [Mastering Markdown](https://guides.github.com/features/mastering-markdown/) +- [Markdown Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) + +VS Code 编辑器的 Markdown 语言扩展支持实时预览 Markdown 文档。也可以使用 Markdown +在线编辑器熟悉和测试其语法： + +- +- + +推荐使用 [pandoc](https://pandoc.org/) 将 Markdown 文档转成其他格式，如 PDF、LaTeX。 diff --git a/_sources/programming/python.md b/_sources/programming/python.md new file mode 100644 index 000000000..b0c4fe7f9 --- /dev/null +++ b/_sources/programming/python.md @@ -0,0 +1,349 @@ +# Python 语言 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2022-06-24 +- 预计花费时间: 60 分钟 + +--- + +## 简介 + +[Python](https://www.python.org/) 是一种广泛使用的通用编程语言，其具有语法简单、 +功能强大等优点，是目前地震学科研最常用的编程语言之一。 + +这一节中，我们不介绍具体的 Python 语法，而是着重介绍如何安装和管理 Python、 +如何编写并执行 Python 脚本等。这一节的最后列出了一些免费的 Python 学习资源， +读者可根据需要自行学习。 + +## 安装 Miniconda + +Python 是一种解释型语言，需要专门的解释器去执行 Python 代码。 +尽管 Linux/macOS 系统内置了 Python 解释器，但是建议用户不要使用它， +以免误操作破坏系统内置 Python， 造成系统出现问题。 +**建议用户安装 Miniconda， 使用其提供的 `conda` 命令管理和安装 Python 及其模块。** + +:::{dropdown} Python、Anaconda 和 Miniconda 的区别与联系 +:color: info +:icon: info + +在安装和使用 Miniconda 前，读者有必要了解 Python、Anaconda 和 Miniconda 三者 +之间的区别与联系： + +Python 解释器 +: 从 [Python 官方网站](https://www.python.org/downloads/) 下载的 Python 安装包 + 只提供了一个 Python 解释器，仅包含 Python 的核心模块和库，是运行 Python + 脚本所必需的。使用官方的 Python 安装包相当于安装了 Python 解释器 + 核心模块/库。 + +Anaconda +: [Anaconda](https://www.anaconda.com/) 是一个 Python **发行版**，不仅提供了 + Python 解释器，还内置了很多 Python 开发工具与众多科学计算相关的库，形成了 + 一个可以开箱即用的 Python 科学计算环境，省去了自行配置科学计算环境的麻烦。 + Anaconda 还提供了强大的软件包管理工具 `conda`，可以方便地安装模块和管理环境。 + 安装 Anaconda 相当于安装了 Python 解释器 + 核心模块/库 + 数百个科学计算相关模块 + 包管理器 `conda`。 + + 尽管 Anaconda 有很多优点，其也有明显的缺点： + - 安装包非常大（超过 500 MB） + - 安装过程耗时长（一般超过 5 分钟） + - 安装后占用大量硬盘空间（一般超过 3 GB） + - 安装了很多平时用不到的模块，进而导致安装新模块时会可能出现版本冲突 + +Miniconda +: [Miniconda](https://docs.conda.io/en/latest/miniconda.html) 是 Anaconda 的精简版。 + 它继承了 Anaconda 的优点，同时避免了 Anaconda 的臃肿。其安装包只有约 50 MB，安装 + 通常也只需要数十秒。安装 Miniconda 相当于安装了 Python 解释器 + 核心模块/库 + 包管理器 `conda`。 +::: + +下面展示了如何在 Linux 系统下安装 Miniconda。其它操作系统下的安装说明以及具体使用方法可以参考 +{doc}`地震“学”软件中 Anaconda 相关内容 `。 + +1. 下载 Miniconda + + 下载地址：[Miniconda3-latest-Linux-x86_64.sh](https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh) + +2. 安装 Miniconda + + ``` + $ bash Miniconda3-latest-Linux-x86_64.sh + ``` + + Miniconda 默认会安装到 {file}`${HOME}/miniconda3` 下，在安装过程中可以 + 设置为其他路径。 + + 安装通常只需要十几秒，在安装的最后会出现： + + Do you wish the installer to initialize Miniconda3 + by running conda init? [yes|no] + [no] >>> + + 输入 `yes` 则安装包会向当前 SHELL 的配置文件写入 `conda` 初始化语句。 + +3. 测试安装 + + 打开一个新的终端，在终端中输入 `python`，输出中看到 **Anaconda, Inc.** + 字样即代表成功安装 Miniconda 并启动了 Python 解释器： + + $ python + Python 3.9.12 (main, Apr 5 2022, 01:53:17) + [GCC 7.5.0] :: Anaconda, Inc. on linux + Type "help", "copyright", "credits" or "license" for more information. + >>> + + 在提示符 `>>>` 后输入 `quit()` 后按下 {kbd}`Enter` 键退出 Python 解释器。 + +## 初识 Python + +打开终端，输入 `python` 就会进入 Python 解释器的交互模式： + +``` +$ python +Python 3.9.12 (main, Apr 5 2022, 01:53:17) +[GCC 7.5.0] :: Anaconda, Inc. on linux +Type "help", "copyright", "credits" or "license" for more information. +>>> +``` + +进入 Python 解释器后，首先会显示 Python 版本信息、版权声明以及帮助信息， +然后会显示符号 `>>>`。`>>>` 是 Python 解释器在交互模式下的主提示符，提示用户 +可以在 `>>>` 后输入 Python 指令。 + +在 `>>>` 提示符后输入 `1 + 2` 并按下 {kbd}`Enter` 键将指令 `1 + 2` 传给 Python +解释器。解释器接收指令后会执行指令，输出结果 `3`，并再次显示主提示符 +`>>>` 等待用户的下一次输入。 +```python +>>> 1 + 2 +3 +>>> +``` +:::{tip} +Python 解释器交互模式可以当做一个快捷的计算器来使用！ +::: + +下面继续看一个稍复杂点的例子。给变量 `x` 赋值，然后紧跟着一个判断语句 +“如果 x 的值大于 0，则打印字符串 Hello world!”。 +```python +>>> x = 5 +>>> if x > 0: +... print("Hello world!") +... +Hello world! +>>> +``` +这个判断语句无法在一行写完，因而需要写成多行语句。 +在主提示符后输入 `if x > 0:` 并按下 {kbd}`Enter` 键，会显示符号 `...`。 +`...` 是 Python 解释器在交互模式下的次提示符，用于表明多行语句还没写完，需要继续输入。 +在次提示符 `...` 后不输入指令而直接键入 {kbd}`Enter`，表示该代码块已结束。 +Python 解释器会对输入的多行语句进行解释，并输出字符串“Hello world!”。 +:::{note} +C 语言使用大括号 `{ }` 划分代码块，而 Python 中使用缩进划分代码块！ +因而上面的例子中 `print` 前需要用空格缩进（通常是 4 个空格）。 +::: + +在主提示符 `>>>` 后输入 `quit()` 或者按下 {kbd}`Ctrl` + {kbd}`D` 键 +即可退出 Python 解释器的交互模式。 +```python +>>> quit() +``` + +## Python 脚本 + +虽然在 Python 解释器的交互模式下可以执行 Python 代码，但写长代码非常不方便， +其代码编辑功能很弱，也不具备代码补全功能。更重要的是，退出交互模式后， +之前写的 Python 代码不会保存，下次想要执行相同代码时只能重写。 +因而，通常都不会在 Python 解释器的交互模式下写代码，而是将 Python 代码写到 Python 脚本中。 + +Python 脚本其实就是一个包含了一系列 Python 指令的文本文件，后缀通常是 `.py`， +在终端中可以通过 `python xxxx.py` 的方式执行 Python 脚本（`xxxx.py` 是 Python +脚本的文件名）。 + +下面以一个简单的 Python 脚本作为示例。启动文本编辑器，新建一个文件，将以下 +Python 代码写到文件中： +```python +x = 5 +if x > 0: + print("Hello world!") +``` +将文件保存为后缀 `.py` 的文件（比如 {file}`first-script.py`），即得到了 +一个可执行的 Python 脚本。打开终端，切换到 Python 脚本所在的目录，执行如下命令来运行脚本： +``` +$ python first-script.py +Hello world! +``` + +## 安装 Python 包 + +Python 语言的一大特色是其功能强大的标准库和第三方软件包（也称模块或库）。 +Python 解释器内置了所有标准库，安装解释器后就可以直接使用标准库， +而第三方包需要先安装才能使用。 + +:::{admonition} `pip` 与 `conda` + +学习如何安装 Python 包之前，有必要先了解 `pip` 和 `conda`，以及它们之间的区别与联系: + +[`pip`](https://pip.pypa.io/) +: `pip` 是 Python 官方提供的包管理器，可以安装 [Python 包索引网站](https://pypi.org/) 上的 + Python 包，也可用于从源码安装 Python 包。 + +[`conda`](https://docs.conda.io/) +: `conda` 是 Anaconda/Miniconda 提供的包管理器，不仅可以安装 Python 包， + 还可以安装其他语言写的包（理论上可以安装任何软件）。它的另一个重要功能是管理 Python 环境， + 可用于在一个系统内安装多个不同版本的 Python 解释器或包。 +::: + +**推荐优先使用 `conda` 安装和管理 Python 包。对于无法使用 `conda` 安装的包，再使用 `pip` 安装。** + +在使用 `conda` 前，还需要对 `conda` 做简单配置： +``` +# 增加 conda-forge 通道，可以安装更多的软件包 +$ conda config --add channels conda-forge +# 设置通道优先级为 strict，以避免混用 conda-forge 和 main +$ conda config --set channel_priority true +# 显示通道的 URL +$ conda config --set show_channel_urls true +# 配置使用国内清华源以加快软件下载速度 +$ conda config --add default_channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main +$ conda config --set 'custom_channels.conda-forge' https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud +``` + +设置 `conda` 使用更快的 libmamab solver： +``` +$ conda install -n base conda-libmamba-solver +$ conda config --set solver libmamba +``` + +使用 `conda` 安装软件很简单，直接 `conda install` 加上要安装的软件包名称即可。 +`conda` 可安装的软件包位于 [Anaconda 网站](https://anaconda.org/)。 + +读者可以执行如下命令，安装本节余下内容会用到的几个 Python 包： +``` +$ conda install numpy matplotlib jupyterlab +``` + +对于 [Anaconda 网站](https://anaconda.org/) 没有的包，则只能使用 `pip` 安装。 + +## Jupyter Notebook + +前面介绍了如何在 Python 解释器交互模式执行 Python 代码，也介绍了如何将 Python +代码写成脚本并执行。这两种方式各有优缺点：交互模式下编写代码不方便， +但是可以一句一句执行代码，随时检查某个语句的输出或某个变量的值。 +编写 Python 脚本可以在编辑器中完成，因而写代码更加高效，但执行 Python 脚本时 +只能从头到尾执行，每次修改代码后都需要重新执行脚本里的所有代码，因而调试起来很费时。 + +[JupyterLab](https://jupyter.org/) 是一个基于网页的交互式开发环境， +已经成为当前最流行的 Python 开发环境。它将两种方式的优点结合起来， +可以高效地编辑代码、单步执行代码、随时查看变量值、支持丰富的可视化输出。 +JupyterLab 对应的文件称之为 Notebook，其文件后缀是 `.ipynb`。 +下面将通过实例展示如何使用 JupyterLab。 + +打开终端，键入命令 `jupyter-lab`，启动 JupyterLab。 + +```bash +$ jupyter-lab +``` + +JupyterLab 会在浏览器中打开一个标签页，显示启动界面。如下图所示， +启动界面有若干图标，可以用于创建 Notebook、纯文本文件、Markdown 文件 +或 Python 文件，还可以在浏览器中打开一个终端。 +![](jupyter-notebook-1.jpg) + +点击“Notebook”下的图标创建一个空白的 Notebook，文件名默认为 `Untitled.ipynb`。 +如下图所示，左侧为文件浏览器，右侧为新建的 Notebook，光标所在的矩形区域称之为单元格（cell）， +可以用于输入 Python 代码。在单元格中输入代码， +按下 {kbd}`Shift` + {kbd}`Enter` 执行单元格中的代码。 + +![](jupyter-notebook-2.jpg) + +下面的两行代码会导入 NumPy 和 Matplotlib 包。将这两行代码复制到 Notebook 的 +单元格中，按下 {kbd}`Shift` + {kbd}`Enter` 执行： +```python +import matplotlib.pyplot as plt +import numpy as np +``` + +下面的代码设置 `t` 取值为 0 到 2.0，间隔为 0.05， +然后利用函数 {math}`s = \sin(2 \pi t)` 生成了一系列点。 +将这两行代码复制到 Notebook 的单元格中，按下 +{kbd}`Shift` + {kbd}`Enter` 执行： +```python +t = np.arange(0.0, 2.0, 0.05) +s = np.sin(2 * np.pi * t) +``` + +想要看看变量 `t` 的值？很简单，在单元格中输入变量 `t`，按下 {kbd}`Shift` + {kbd}`Enter`， +Notebook 会直接显示该变量的值。如下图所示，可以看出，变量 `t` 是一个数组，其 +最小值是 0，间隔是 0.05，最大值是 1.95（不包括 2.0）： + +![](jupyter-notebook-3.jpg) + +下面的代码将以变量 `t` 作为自变量（X 轴）、以变量 `s` 作为因变量（Y轴）绘制该函数。 +将代码复制到单元格中，按下 {kbd}`Shift` + {kbd}`Enter` 执行： +```python +fig, ax = plt.subplots() +ax.plot(t, s) +plt.show() +``` + +执行效果如下图所示，绘图结果直接在 Notebook 里显示，非常直观。 + +![](jupyter-notebook-4.jpg) + +对画出来的图片效果不太满意，想要进一步微调图片的显示效果？下面的两行代码会 +给图片加上网格线，并设置刻度颜色、大小、宽度。 +```python +ax.grid(True, linestyle='-.') +ax.tick_params(labelcolor='r', labelsize='medium', width=3) +``` +将上面两行代码复制到前一单元格中的 `plt.show()` 语句之前，按下 {kbd}`Shift` + {kbd}`Enter` 执行， +效果如下图所示： + +![](jupyter-notebook-5.jpg) + +可以看到，修改后的代码被执行，并显示了修改后的图片。在执行修改后的代码时， +变量 `t` 和 `s` 依然有效，不需要重新执行之前单元格中的代码。 +实际上，只要 Kernel 没有重启，Notebook 中的变量就不会被销毁，因而可以很方便地 +多次修改并调试某个单元格的代码。 + +:::{tip} +在 Notebook 中写代码时，可以随时用快捷键 {kbd}`Ctrl` + {kbd}`S` （Linux 或 Windows） +或 {kbd}`Command` + {kbd}`S` （macOS）保存 Notebook。所有代码、输出以及图片都会被保存在 +`.ipynb` 文件中。 +::: + +:::{tip} +Notebook 在交互式开发代码时很方便。但通常我们会想要将代码保存为 Python 脚本， +更加方便执行。在 JupyterLab 中点击菜单“File”→“Save and export Notebook as”→ +“Executable Script” 即可将 Notebook 转换为 Python 脚本。 +::: + +JupyterLab 除了可以编辑 Notebook 外，还可以编辑 Markdown 文件，也可以打开终端 +执行命令，还支持多个功能强大的插件。更多的功能，留待读者自行探索。 + +## 其他 Python IDE/开发环境 + +除了上面介绍的 JupyterLab 外，还有其他方便、实用的 Python IDE/开发环境， +例如： + +- [Visual Studio Code](https://code.visualstudio.com/docs/python/python-tutorial) + - [在 Visual Studio Code 里交互式编辑和运行 Jupyter Notebooks](https://code.visualstudio.com/docs/datascience/jupyter-notebooks) + - [在 Visual Studio Code 里交互式编辑和运行 Python 脚本](https://code.visualstudio.com/docs/python/jupyter-support-py) +- [PyCharm](https://www.jetbrains.com/pycharm/) +- [Spyder](https://www.spyder-ide.org/) + +有兴趣的读者可以尝试不同的 Python IDE/开发环境并根据自己的喜好选择。 + +## 扩展阅读 + +下面列出一些 Python 以及常用科学计算模块的相关学习资源： + +- [Python](https://www.python.org/) + - [Python 官方文档](https://docs.python.org/zh-cn/3/)（全面、系统） + - [廖雪峰的 Python 教程](https://www.liaoxuefeng.com/wiki/1016959663602400)（较全面、系统） +- [NumPy](https://numpy.org/) + - [NumPy 官方文档](https://numpy.org/doc/stable/) + - [A Visual Intro to NumPy and Data Representation](https://jalammar.github.io/visual-numpy/)（简要、形象地介绍 NumPy 数据结构） +- [Matplotlib](https://matplotlib.org/) + - [Matplotlib 官方教程](https://matplotlib.org/stable/tutorials/) + - [Scientific Visualization: Python + Matplotlib](https://github.com/rougier/scientific-visualization-book) +- [pandas](https://pandas.pydata.org/) + - [Pandas 官方教程](https://pandas.pydata.org/docs/user_guide/) +- [SciPy](https://scipy.org/) + - [SciPy 官方教程](https://docs.scipy.org/doc/scipy/tutorial/) diff --git a/_sources/seismology/data-format.md b/_sources/seismology/data-format.md new file mode 100644 index 000000000..502ab0634 --- /dev/null +++ b/_sources/seismology/data-format.md @@ -0,0 +1,65 @@ +# 波形数据格式 + +- 本节贡献者: {{ 田冬冬 }}（作者）、{{ 姚家园 }}（作者） +- 最近更新日期: 2021-01-05 +- 预计阅读时间: 10 分钟 + +--- + +日常科研中，经常会接触不同格式的波形数据，最常见的是 SAC 和 miniSEED 格式。 +每种数据格式都有各自的优点和缺点。例如，SAC 格式有利于数据处理和分析， +但不利于大批量数据的存储和交换。miniSEED 格式有利于波形数据的存档和交换， +近几年也常用于数据处理和分析，因此，miniSEED 格式是目前地震学领域**最流行**的波形数据格式。 + +## SAC + +SAC 格式由 [SAC](https://ds.iris.edu/ds/nodes/dmc/software/downloads/SAC/) +（Seismic Analysis Codes）软件定义，但许多其他软件也支持该格式。每个 SAC 文件包含头段区 +和时间序列数据区，其中头段区定义了与台站、事件、走时以及用户自定义信息等相关的变量。 + +SAC 是一款常用的地震学波形处理和分析软件，同时，SAC 格式的数据中可以保存一些元数据和事件信息， +使得 SAC 格式是日常科研中的常用数据格式。但若选择该格式来存储数据，则需要很大的硬盘空间。 + +## miniSEED + +SEED 全称 Standard for the Exchange of Earthquake Data（地震数据交换标准）， +主要用于地震学时间序列数据和相关元数据的归档和交换。最新的 SEED 标准是 2012 年发布的 +[SEED v2.4](http://www.fdsn.org/pdf/SEEDManual_V2.4.pdf)。 +虽然该格式包含了完备的地震学观测数据，但一般需要利用 +[rdseed](https://github.com/iris-edu-legacy/rdseed) 软件 +转换成其他格式，再进行数据处理和分析。 +IRIS 自 2020 年 1 月开始不再提供 SEED 格式的数据下载支持， +详情可阅读 [IRIS 数据服务通讯](http://www.iris.washington.edu/ds/newsletter/vol21/no1/509/retirement-of-full-seed-data-volumes-from-iris-dmc/)。 +IRIS 也已[不再维护 rdseed 软件](https://ds.iris.edu/ds/nodes/dmc/manuals/rdseed/)。 + +:::{note} +除了 rdseed 外，ObsPy 也可以将 SEED 格式转换成其他格式。 +其 [read](https://docs.obspy.org/packages/autogen/obspy.core.stream.read.html) 函数 +可以读取 SEED 里的时间序列数据，然后利用 [write](https://docs.obspy.org/packages/autogen/obspy.core.stream.Stream.write.html) +方法转换成其他格式。 +其 [xseed](https://docs.obspy.org/master/packages/obspy.io.xseed.html) 模块的 +[Parser](https://docs.obspy.org/master/packages/autogen/obspy.io.xseed.parser.Parser.html) 类 +可以读取 SEED 里的元数据，并转换成其他格式。 +::: + +miniSEED 是 SEED 格式的子集，一般用于地震学时间序列数据的归档和交换。 +其包含的时间序列的元数据非常有限，一般只有时间序列标识和简单的运行状况标识， +不包含台站地理坐标、仪器响应以及其他解释数据所需的信息。 + +近几年，由于地震学数据处理和分析软件的快速发展 +（如 [ObsPy](https://github.com/obspy/obspy/wiki)）， +miniseed 格式也常用于数据处理和分析。此时，所需的元数据要从一定格式的 +元数据文件中提取。例如，目前比较流行的组合方式是 miniSEED 格式的时间序列数据和 +[StationXML](https://www.fdsn.org/xml/station/) 格式的元数据。 + +## 格式转换 + +不同波形数据格式经常要互相转换，以实现不同的目的。 + +- [ObsPy](https://github.com/obspy/obspy/wiki) 软件提供的[波形数据读写模块](https://docs.obspy.org/master/packages/index.html)几乎可以实现目前所有波形数据格式的互相转换。 +- [mseed2sac](https://github.com/iris-edu/mseed2sac) 软件可以 + 将 miniSEED 格式转成 SAC 格式。 + +## 参考文档 + +- diff --git a/_sources/seismology/intro.md b/_sources/seismology/intro.md new file mode 100644 index 000000000..e11c522df --- /dev/null +++ b/_sources/seismology/intro.md @@ -0,0 +1,124 @@ +# 简介 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2021-10-28 +- 预计阅读时间: 10 分钟 + +--- + +地球科学的研究对象主要包括： +地球的固体部分（固体地球）、地球表面上下的水（水圈）、生态系统（生物圈）、大气层（大气圈） +以及地球至太阳的行星际空间。使用物理方法研究地球的学科称为地球物理学， +而固体地球物理学则是其中研究固体地球的分支学科。固体地球物理学的研究方法有很多， +如遥感、GPS、重力、电磁、地震波、地热等，不同方法代表了不同专业方向。 +因此，从整个地球科学研究的角度来看，地震学只是一个 +很窄的专业方向，同时又是非常重要的研究手段。本章将介绍地震学的基础入门知识。 + +## 地震学是什么？ + +Keiiti Aki 和 Paul G. Richards 编写的经典地震学教材《Quantitative Seismology》（第二版）{cite}`Aki2002` +对地震学的定义如下： + +> **Seismology** is the scientific study of mechanical vibrations of the Earth. +> Quantitative seismology is based on data called seismograms, +> which are recordings of the vibrations, +> which in turn may be caused artificially by man-made explosions, +> or caused naturally by earthquakes and volcanic eruptions. +> +> 地震学是研究地球机械振动的科学。定量地震学基于记录着这些振动的观测资料，即地震图。 +> 这些振动可能是由人工爆炸等人为因素引起的，也可能是地震和火山喷发等自然活动造成的。 + +地震学是研究地球机械振动的科学。产生这些振动的源可能是地震、火山喷发、海浪、台风或飓风、 +人工爆炸、交通活动等，一般称为[**震源**](seismic-source.md)（seismic source）， +也常被称为**地震事件**（seismic event）或**事件**（event）。 +震源激发的地球机械振动以[**地震波**](seismic-wave.md)（seismic wave）的形式 +在地球内部传播，并被布设在地表或地下的[**地震仪**](seismograph.md)（seismograph）记录下来。 +地震仪加上一些辅助设备则构成了[**地震台站**](station.md)（seismic station）或**台站**（station）。 +地震仪记录的地球机械振动称为[**地震图**](seismogram.md)（seismogram）。 +地震图包含了具有不同特征的[**地震震相**](seismic-phase.md)，是地震学的主要研究工具。 + +:::{figure} seismology-overview.jpg +:align: center +:alt: 地震激发的地震波路径和波形 +:width: 95% + +1994 年 1 月 17 日，美国加利福尼亚州 Northridge 地震激发的地震波的传播路径和观测波形。 +引自 [Exploring the Earth Using Seismology](https://www.iris.edu/hq/inclass/fact-sheet/exploring_earth_using_seismology)。 +::: + +1994 年 1 月 17 日，美国加利福尼亚州 Northridge 附近发生了 [6.7 级地震](https://earthquake.usgs.gov/earthquakes/eventpage/ci3144585/)， +其释放出的能量相当于将近 20 亿千克高爆炸药。该地震产生的地震波经过地球内部传播后， +被世界各地的地震台站记录到。上图左侧展示了不同地震波在地下的传播路径，右侧展示了地震波到达 +地表后，全球台站记录到的地表振动，即地震图。 + +因此，地震图携带了震源和地球内部结构的信息。地震学家正是通过分析地震图来研究产生这些振动的 +震源以及地球内部结构。地球平均半径约为 6371 公里，现在很难直接观测地球内部， +历史上最深的钻探深度也不过只有十多公里。因此，地震学是目前人类探测地球深部结构的主要手段， +许多重大的地球内部发现都是地震学首先研究报道的。 + +地震学研究的基本原理包括震源和地震波理论两个部分。前者主要关于震源和地震波的激发， +后者主要关于地震波如何在地下传播。地震学理论背后的大部分物理知识不过是牛顿第二定律 $F=ma$， +当然实际问题的复杂性促使了地震学家利用复杂的数学技巧以及高性能计算机。一般而言，地震学 +是观测驱动的学科，仪器和数据可用性的改进常常会导致地震学理论和地球内部结构研究的重大突破。 + +## 地震学早期大事记 + +地震学是一个相对年轻的学科，从二十世纪初才逐渐开始定量化的研究。 + +在早期，地震波理论的发展领先地震学观测： + +- 1660 年，Robert Hooke 提出了著名的胡克定律（Hooke's law），指出 + 弹簧在发生弹性形变时，弹簧的弹力 {math}`F` 和弹簧的长度变化 {math}`x` + 成正比，即 {math}`F=kx`，其中 {math}`k` 是弹性系数 +- 1687 年，Isaac Newton 在其《自然哲学的数学原理》一书中提出了牛顿第二定律，即 {math}`F=ma` +- 1821 年，Claude-Louis Navier 和 George Stokes 提出了弹性介质的一般性平衡方程 + 和运动方程 +- 1830 年，Siméon Poisson 提出弹性介质内部存在两种以不同速度传播的波，即横波和纵波 +- 1885 年，Lord Rayleigh 预测弹性介质中存在沿着固体表面传播的面波，即 Rayleigh 面波 {cite}`Rayleigh1885` +- 1911 年，Augustus Love 指出在速度随深度变化的弹性介质中存在另一种沿着固体表面传播的面波，即 Love 波 + +从十九世纪后期开始，地震学观测技术开始逐渐发展起来，极大地促进了地震学的发展。 +以下介绍地震学观测技术的早期进展： + +- 1875 年，Filippo Cecchi 制作了第一个带时间记录的地震仪。随后，地震仪器不断改善和发展 +- 1889 年，E. Von Rebeur-Paschwitz 报告了在德国波兹坦记录到的日本地震的波形。这是 + 人类第一个远震记录波形 {cite}`Rebeur-Paschwitz1889` +- 1898 年，E. Wiechert 研究了第一台有粘滞阻尼的地震计，可提供在整个地震持续时间内 + 有用的记录 +- 20 世纪初，B. B. Galitzen 制作了第一台电磁地震仪。现代地震仪均是电磁地震仪， + 相比于早期的纯力学设计的仪器，其有很多优势 +- 1961 年，全球标准化地震台网（world-wide standardized seismograph network，WWSSN）建立 +- 1969 年至 1972 年间，阿波罗登月计划陆续在月球上布设了一些月震仪以监测月震和研究月球结构 +- 20 世纪 60 年代开始，计算机的发展极大地改变了地震学研究。1976 年开始，地震学 + 观测资料开始以数字形式存储和获取 +- 20 世纪 80 和 90 年代，全球台站空白区域新增加了地震台，全球许多地震台升级为宽频带地震仪。 + 地震仪的改进与观测资料的长期积累使得地震学得以快速发展 + +随着观测的不断增加，人们对于地震的认知也在不断加深： + +- 1911 年，Harry Reid 在调查 1906 年美国旧金山大地震时发现圣安德列斯断层产生水平移动， + 并提出“弹性回跳假说”以解释地震成因 +- 1928 年，Kiyoo Wadati 发现了深度大于 300 km 的地震（现在称之为深震） +- 1935 年，Charles F. Richter 提出了地方震级的概念，用于定量描述地震的大小 +- 1967-1969 年，全球地震活动性进一步支持了 Alfred L. Wegener 于 1912 年提出的大陆漂移假说 +- 1977 年，Hiroo Kanamori 提出了矩震级的概念 + +在地震学理论和观测的早期发展过程中，地球内部结构也取得了一系列重大突破： + +- 1906 年，Richard Oldham 报道地球存在地核 {cite}`Oldham1906` +- 1909 年，Andrija Mohorovičić 报道地壳和地幔存在速度间断面（现在称为 Moho 面） +- 1914 年，Beno Gutenberg 报道地幔和液态地核的边界深度为 2900 公里， + 非常接近当今的估计值 2889 公里 +- 1936 年，Inge Lehmann 发现固态内核（之前认为地核全是液态的） +- 1940 年，Harold Jeffreys 和 K. E. Bullen 发表了他们最终版本的地震波走时表， + 简称 JB 走时表。该走时表至今仍在使用，并且与当今模型仅差几秒 + + +## 扩展阅读 + +- A Treatise on the Mathematical Theory of Elasticity {cite}`Love1892`: Augustus Love 在 1892 年出版的经典教材， + 详细介绍了弹性理论的发展史 +- [History of Seismology](https://www.iris.edu/hq/inclass/poster/history_of_seismology): 地震学发展史的海报 +- Ben-Menahem, A. (1995). A concise history of mainstream seismology: Origins, legacy, and perspectives. + Bulletin of the Seismological Society of America, 85(4), 1202–1225. + diff --git a/_sources/seismology/resources.md b/_sources/seismology/resources.md new file mode 100644 index 000000000..c9bfd1565 --- /dev/null +++ b/_sources/seismology/resources.md @@ -0,0 +1,34 @@ +# 学习资料 + +本教程只是地震学初学者的入门读物，阅读完本教程后还需参考一些系统和全面的资料进行深入学习。 +推荐以下参考资料： + +- 《[Introduction to Seismology](https://www.cambridge.org/us/academic/subjects/earth-and-environmental-science/solid-earth-geophysics/introduction-seismology-3rd-edition?format=HB&isbn=9781316635742)》 + （第三版） + + - 作者：[Peter Shearer](https://igppweb.ucsd.edu/~shearer/mahi/) + - 难度：浅显易懂，非常适合初学者，如大三、大四本科生 + +- 《[An Introduction to Seismology, Earthquakes, and Earth Structure](https://www.wiley.com/en-us/An+Introduction+to+Seismology%2C+Earthquakes%2C+and+Earth+Structure-p-9780865420786)》 + + - 作者：[Seth Stein](https://www.earth.northwestern.edu/our-people/faculty/stein-seth.html) + 和 [Michael Wysession](https://eps.wustl.edu/people/michael-e-wysession) + - 难度：难度适中，有很多简单和实用的公式推导，适合初学者以及地震学研究生 + +- 《[Foundations of Modern Global Seismology](https://www.elsevier.com/books/foundations-of-modern-global-seismology/ammon/978-0-12-815679-7)》 + + - 作者：[Charles Ammon](https://www.geosc.psu.edu/directory/charles-ammon)、 + [Aaron Velasco](https://expertise.utep.edu/profiles/aavelasco)、 + [Thorne Lay](https://websites.pmc.ucsc.edu/~seisweb/thorne_lay/) 和 Terry Wallace + - 难度：较难，适合有一定地震学和数理基础的研究生 + +- 《[Quantitative Seismology](https://www.ldeo.columbia.edu/~richards/Aki_Richards.html)》（第二版） + + - 作者：[Keiiti Aki](https://doi.org/10.1785/gssrl.76.5.551) + 和 [Paul G. Richards](https://www.ldeo.columbia.edu/user/richards) + - 难度：很难，大量公式推导，被称为地震学圣经，适合高年级研究生以及地震学学者 + +- 《[Theoretical Global Seismology](https://press.princeton.edu/books/paperback/9780691001241/theoretical-global-seismology)》 + + - 作者：F. A. Dahlen 和 [Jeroen Tromp](https://geosciences.princeton.edu/people/jeroen-tromp) + - 难度：很难，大量公式推导，注重面波和自由震荡理论，适合高年级研究生以及地震学学者 diff --git a/_sources/seismology/seismic-phase.md b/_sources/seismology/seismic-phase.md new file mode 100644 index 000000000..18a97d68a --- /dev/null +++ b/_sources/seismology/seismic-phase.md @@ -0,0 +1,118 @@ +# 地震震相 + +- 本节贡献者: {{ 姚家园 }}（作者）、{{ 田冬冬 }}（作者） +- 最近更新日期: 2023-03-01 +- 预计阅读时间: 30 分钟 + +--- + +地震体波是在地球内部传播的机械波。与光类似，地震波在遇到介质界面时也会出现反射、 +折射和衍射等现象。与光不同的是，地震波既有横波（S 波）又有纵波（P 波）， +地震波在介质界面发生反射或折射时还会发生波的转换，即横波可以转换为纵波，纵波也 +可以转换为横波。地震波在地球内部传播时，会遇到地球内部的多个界面，并在界面处 +发生反射、折射以及横波/纵波的互相转换。因而，震源激发的地震波在地球内部传播时 +会有很多可能的传播路径，沿着不同路径传播的地震波走时也不同，在观测记录上表现为 +不同特征的信号，称之为地震震相（seismic phase）。 + +## 地球圈层结构 + +在介绍地震震相之间，有必要先介绍地球的分层结构。 + +固体地球的半径约为 6371 公里，具有明显的圈层结构。地球从外到内可以分为如下几个圈层： + +- 地壳（crust）：地球的最表层，大陆地壳的平均厚度为 30-50 km，大洋地壳的平均厚度约为 6 km +- 地幔（mantle）：地壳以下的固态岩石层，最大深度为 2891 km +- 外核（outer core）：液态铁合金层，深度范围为 2891 到 5150 km +- 内核（inner core）：固态铁合金层，半径约 1221 km + +各个圈层之间的分界面为： + +- 地壳与地幔的界面：莫霍洛维奇间断面（**Moho**rovičić discontinuity），或简称莫霍面（Moho discontinuity） +- 地幔和外核的界面：核幔边界（**c**ore-**m**antle **b**oundary，简写 CMB） +- 外核与内核的界面：内核边界（**i**nner-**c**ore **b**oundary，简写 ICB） + +不同圈层中，介质的 P 波和 S 波速度以及密度也随着深度而变化： + +- 在 Moho 面附近，地震波速度猛然增加 +- 在地幔中，410 公里和 660 公里附近存在两个速度间断面，地震波速度在间断面附近突然增加。 + 这两个间断面分别称为 410 间断面（410-km discontinuity）和 660 间断面（660-km discontinuity）， + 二者之间的区域称为地幔转换带（mantle transition zone） +- 在 660 公里至地幔底部的深部区域，地震波速度平缓增加 +- 在核幔边界，P 波速度从大约 14 km/s 骤降至大约 8 km/s，S 波速度从大约 7 km/s 降为零， + 这是因为外核是液态的 +- 在外核中，P 波速度再次随着深度逐渐增加 +- 在内核边界，P 波速度突然增加，内核中 S 波速度也不为零了 + +:::{figure} prem.jpg +:align: center +:alt: "地球分层结构及 P、S 波速度和密度" +:width: 50% + +地球内部 P 波速度、S 波速度和密度（来自 Preliminary Reference Earth Model (PREM) {cite}`Dziewonski1981`）。 +引自《[Introduction to Seismology]》（第三版）图 1.1。 +::: + +## 地震震相 + +地震波在地球内部传播时会穿过不同的地球内部结构，相应的地震波射线路径和走时也会不同， +在观测记录上也显示出不同的波形特征，称之为地震震相（seismic phase）。 + +为了区分不同的地震震相，地震学领域制定了一套标准地震震相命名规则。每条射线路径 +都可以对应一个震相名；同样的，每个震相名都可以对应特定的射线路径。 + +在标准地震震相命名规则中，规定了用以下简写符号分别表示在地壳、地幔、外核以及内核中 +传播的 P 波和 S 波： + +- **P**：从震源出发向下在地壳和地幔中传播的 P 波 +- **p**：从震源出发向上在地壳和地幔中传播的 P 波 +- **K**：外核中传播的 P 波 +- **I**：内核中传播的 P 波 +- **S**：地壳和地幔中传播的 S 波 +- **J**：内核中传播的 S 波 +- **c**：核幔边界处的反射波 +- **i**：内核边界处的反射波 + +地震波从震源出发，穿过地球内部，并被位于地表的地震仪器记录到。地球内部主要分界面 +将地震波走过的射线分割成多个小段，将射线路径里每段对应的简写符号拼接起来， +即得到了射线对应的震相名。以下图中的几个地震震相为例： + +- PcP 震相表示震源激发的 P 波从震源向下出发在地壳/地幔中传播（**P**）， + 并在核幔边界处反射（**c**），反射 P 波在地幔中向上传播至台站（**P**） +- SKS 震相表示震源激发的 S 波从震源向下出发在地壳/地幔中传播（**S**）， + 在核幔边界处转换为 P 波并在外核中传播（**K**），然后再次在核幔边界处转换成 + S 波并在地幔中传播（**S**），最终传播回台站 + +:::{figure} phase-name.jpg +:align: center +:alt: "全球震相的射线路径及其震相名" +:width: 50% + +全球震相的射线路径及其震相名。实线表示 P 波路径，摆动线表示 S 波路径。 +引自《[Introduction to Seismology]》（第三版）图 4.16。 +::: + +```{note} +除了上图展示的全球尺度的震相外，在小震中距范围内沿地壳、上地幔传播的地震震相更为复杂， +且部分震相的命名并未统一。因此，本教程不做介绍，读者可以参考 +{doc}`seis:ray-nomenclature/crustal-phases`学习相关震相定义。 +``` + +我们以地震与台站之间的距离为 X 轴，以台站观测到的地震震相走时为 Y 轴，将全球地震的震相走时 +画出来，便得到了**走时曲线**。这是我们认识和研究地球深部的速度结构最简单和根本的资料。 + +:::{figure} travel-time-curve.jpg +:align: center +:alt: "不同体波震相的走时曲线" +:width: 50% + +不同体波震相的走时曲线，数据来至 [Kennett and Engdahl (1991)](https://doi.org/10.1111/j.1365-246X.1991.tb06724.x)。 +引自《[An Introduction to Seismology, Earthquakes, and Earth Structure]》 +图 3.5-3。 +::: + +[introduction to seismology]: https://www.cambridge.org/us/academic/subjects/earth-and-environmental-science/solid-earth-geophysics/introduction-seismology-3rd-edition?format=HB&isbn=9781316635742 +[An Introduction to Seismology, Earthquakes, and Earth Structure]: https://www.wiley.com/en-us/An+Introduction+to+Seismology%2C+Earthquakes%2C+and+Earth+Structure-p-9780865420786 + +## 扩展阅读 + +- IASPEI 标准地震震相列表: http://www.isc.ac.uk/standards/phases/ diff --git a/_sources/seismology/seismic-source.md b/_sources/seismology/seismic-source.md new file mode 100644 index 000000000..630784736 --- /dev/null +++ b/_sources/seismology/seismic-source.md @@ -0,0 +1,130 @@ +# 震源 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2022-07-17 +- 预计阅读时间: 5 分钟 + +--- + +任何产生能被地震仪记录到的地球机械振动的源都可以称为震源（seismic source）。 +震源可以是地震、火山喷发、海浪、台风或飓风、人工爆炸、交通活动等。本节介绍震源的基础概念。 + +## 地震三要素 + +对于地震，人们最关心的基本参数有三个（俗称**地震三要素**），即时间、地点、强度（简称**时空强**）： + +- 时间：地震发震时刻（origin time） +- 地点：地震震源位置（hypocenter），即地震发生位置的经纬度和深度。震源位置（hypocenter） + 向上垂直投影到地面的位置称为震中（epicenter） +- 强度：地震的大小，常用震级（magnitude）度量 + +:::{figure} epicenter-hypocenter.gif +:align: center +:alt: 震源位置（hypocenter）与震中（epicenter）的区别 +:width: 40% + +震源位置（hypocenter）与震中（epicenter）的区别。 +图片引自 [USGS](https://www.usgs.gov/media/images/epicenter-hypocentergif)。 +::: + +空间上看，地震大部分发生在不同板块的边界处。板块内部也有一些地震发生。 + +:::{figure} earthquake-distribution.jpg +:align: center +:alt: "五年内 4 级以上地震的全球分布" +:width: 70% + +五年内 4 级以上地震的全球分布。 +引自 [Why Do Earthquakes Happen?](https://www.iris.edu/hq/inclass/fact-sheet/why_do_earthquakes_happen)。 +::: + +深度方向上看，地震主要发生在脆性地壳中。在 300 公里以上，地震数目整体上随着深度增加而减少。 +300 公里以下，地震数目略有增加。最大的地震深度约为 700 多公里。 + +:::{figure} earthquake-depth.jpg +:align: center +:alt: "1964-2001 年全球 5.2 级以上地震的年发生率和震源深度的关系" +:width: 70% + +1964-2001 年全球 5.2 级以上地震的年发生率和震源深度的关系。 +引自《[Deep Earthquakes](https://doi.org/10.1017/CBO9781107297562)》图 4.3。 +::: + +震级越大的地震，数目越少。在地震学中，有一个著名的定律，叫 Gutenberg–Richter 定律（简称 GR law）， +该定律描述了震级与某一地区大于等于该震级的地震数量之间的关系。该定律的表达式是： + +$$ +\log_{10} N = a - b M +$$ + +其中，$M$ 表示震级，$N$ 表示震级大于等于 $M$ 的地震数量，$a$ 和 $b$ 是常数。 +一般 $b$ 的值接近 1。若取 $b=1$，则地震级数每降低一级，地震的数目就会增加 10 倍。 + +:::{figure} earthquake-gr-law.jpg +:align: center +:alt: "GCMT 地震目录中 1976-2005 年间全球地震的震级与频次关系" +:width: 70% + +GCMT 地震目录中 1976-2005 年间全球地震的震级与频次关系。图中圆点为观测数据， +实线为 GR 定律中 b = 1 的理论曲线。 +引自《Introduction to Seismology》图 9.27。 +::: + +地震释放的能量与地震震级之间的关系为{cite}`Gutenberg1956`： + +$$ +\log E = 1.5 M + 11.8 +$$ + +可以看出，震级增加一级，地震释放的能量增加 32 倍。 + +:::{figure} earthquake-energy.jpg +:align: center +:alt: "地震的震级、频率以及释放能量的经验关系" +:width: 90% + +地震的震级、频率以及释放能量的经验关系。 +引自 [How Often Do Earthquakes Occur?](https://www.iris.edu/hq/inclass/fact-sheet/how_often_do_earthquakes_occur)。 +::: + +## 地震目录 + +将大量地震事件的参数进行汇总整理得到的目录资料，称之为地震目录。地震目录对于研究 +地震活动性、地震灾害评估等具有重要的意义。 + +地震目录至少应包含地震的时空强信息，即： + +- 发震时刻 +- 震中经纬度 +- 地震深度 +- 地震震级 + +除此之外，有些地震目录还提供了地震的破裂时间和震源机制等其他参数。 + +根据所包含地震的区域范围，地震目录可以分成两类：全球地震目录和区域地震目录。 +顾名思义，全球地震目录包含了全球范围内的地震，但通常只包含比较大的地震，小地震多有遗漏； +区域地震目录则只关注某个特定区域内的地震，通常包含更多的小地震。 + +常见的全球地震目录包括： + +[International Seismological Center 地震目录](http://www.isc.ac.uk/iscbulletin/) +: ISC 地震目录是全球地震的最终版本，涵盖了 + 1900 年至今的地震信息。所有地震信息通过程序自动确定，并由 ISC 的分析人员对其 + 进行人工检查和重定位。经过人工审核的 ISC 地震目录通常有 24 个月的延迟。 + +[ANSS ComCat 地震目录](https://earthquake.usgs.gov/data/comcat/) +: ANSS Comprehensive Earthquake Catalog (ComCat) 是 ANSS (Advanced National Seismic System) + 制作的地震目录。该目录专注于提供全球 5.0 级以上地震事件的权威、近实时信息。 + 地震位置和震级的初始报告通常可在地震发生后 10 到 30 分钟内获得，并在几天、几周和 + 几个月后进一步修订。 + +区域地震目录有很多，通常由各个国家或区域的地震相关机构维护，比如： + +- 中国: [中国台网正式地震目录](https://data.earthquake.cn/datashare/report.shtml?PAGEID=earthquake_zhengshi) +- 日本: [JMA 地震目录](https://www.data.jma.go.jp/svd/eqev/data/bulletin/hypo_e.html) +- 美国南加州: [SCSN 地震目录](https://scedc.caltech.edu/eq-catalogs/) +- 美国北加州: [NCSN 地震目录](https://ncedc.org/ncedc/catalog-search.html) + +在使用地震目录时，应根据自己的需求选择合适的地震目录。 + +[introduction to seismology]: https://www.cambridge.org/us/academic/subjects/earth-and-environmental-science/solid-earth-geophysics/introduction-seismology-3rd-edition?format=HB&isbn=9781316635742 diff --git a/_sources/seismology/seismic-wave.md b/_sources/seismology/seismic-wave.md new file mode 100644 index 000000000..825dc1389 --- /dev/null +++ b/_sources/seismology/seismic-wave.md @@ -0,0 +1,54 @@ +# 地震波 + +- 本节贡献者: {{ 姚家园 }}（作者）、{{ 田冬冬 }}（审稿） +- 最近更新日期: 2022-11-12 +- 预计阅读时间: 20 分钟 + +--- + +震源激发的机械振动以地震波的形式在地球内部传播。地震波分为体波（body wave） +和面波（surface wave）两种类型。体波是指在地球内部传播的波，而面波是指在地球表面 +附近传播的波。本节将介绍最基础的地震波理论。 + +## 体波 + +体波分为 P 波（P-wave）和 S 波（S-wave）两种。 + +从传播速度的角度看，P 波比 S 波传播速度快。因而 P 波总是最先到达观测者所在的位置， +S 波则在 P 波后到达。因而，P 波和 S 波也分别被称为 **p**rimary wave 和 **s**econdary wave。 + +从物理属性上来说，P 波是一种纵波（longitudinal wave），P 波在介质中传播时，介质的 +运动方向与波传播的方向相同或相反，介质交替压缩和膨胀导致介质的体积发生变化（如下图所示）， +因而 P 波也称为压缩波（com**p**ressional wave）。S 波是一种横波（transverse wave）， +S 波在介质中传播时，介质的运动方向与波传播的方向垂直，会造成介质的剪切变形，但 +不改变介质的体积（如下图示），因而 S 波也称为剪切波（**s**hear wave）。 + +事实上，地震学家首先根据波到达的先后顺序将两种波命名为 primary wave 和 secondary wave， +并简称为 P-wave 和 S-wave，最后在进一步理解了两种地震波的物理属性后，才分别 +将其称为 com**p**ressional wave 和 **s**hear wave。 + +:::{figure} body-wave-propagation.jpg +:align: center +:alt: "体波的介质运动方向以及波传播方向" +:width: 80% + +体波的介质运动方向以及波传播方向。引自《[Introduction to Seismology]》（第三版）图 3.2。 +::: + +## 面波 + +沿着地球表面附近传播的面波也有两种，即瑞利波（Rayleigh wave）和勒夫波（Love wave）。 +Rayleigh 波在地表传播时，介质的运动既有与波传播方向相同或相反的分量，又有与波传播方向垂直 +的分量（如下图示）。Love 波在地表传播时，介质的运动方向与波传播方向垂直（如下图示）。 +面波的振幅随着深度增加会剧烈减少。 + +:::{figure} surface-wave-propagation.jpg +:align: center +:alt: "面波的介质运动方向以及波传播方向" +:width: 50% + +基阶 Love 波（上）和 Rayleigh 波（下）的介质运动方向（假设面波沿着页面从左向右传播）。 +引自《[Introduction to Seismology]》（第三版）图 8.5。 +::: + +[introduction to seismology]: https://www.cambridge.org/us/academic/subjects/earth-and-environmental-science/solid-earth-geophysics/introduction-seismology-3rd-edition?format=HB&isbn=9781316635742 diff --git a/_sources/seismology/seismogram.md b/_sources/seismology/seismogram.md new file mode 100644 index 000000000..506d3912c --- /dev/null +++ b/_sources/seismology/seismogram.md @@ -0,0 +1,37 @@ +# 地震图 + +- 本节贡献者: {{ 姚家园 }}（作者）、{{ 田冬冬 }}（作者） +- 最近更新日期: 2022-11-20 +- 预计阅读时间: 20 分钟 + +--- + +## 地震图 + +地震图（seismogram）是指地震仪记录到的带有计时信息的地面质点运动（位移、速度、加速度、转动等）， +也称为地震波形（seismic waveform），其本质是时间序列。一般有三个正交分量， +如南北、东西和垂直分量。 + +地震图 $U(t)$ 由三部分的卷积组成，即震源项 $S(t)$、 +结构项 $G(t)$、仪器项 $I(t)$： + +$$ +U(t) = S(t)*G(t)*I(t) +$$ + +因此，地震图包含了震源、结构以及仪器的信息。地震学科研工作者正是通过解读地震图， +得到相关信息的。一般而言，仪器项（即仪器响应）已知，所以地震图通常用于反演震源和 +结构信息。其中，结构项一般称为格林函数，只与地球内部结构有关。 + +地震图与元数据（metadata）共同构成了完备的地震学观测数据。 +元数据包含与地震图相关的重要信息，如台站位置、仪器响应等。 + +:::{figure} seismic-waveform.png +:align: center +:alt: "体波和面波的波形和传播路径实例" +:width: 95% + +体波和面波的波形和传播路径实例。 +引自《[An Introduction to Seismology, Earthquakes, and Earth Structure]》 +图 1.1-3。 +::: diff --git a/_sources/seismology/seismograph.md b/_sources/seismology/seismograph.md new file mode 100644 index 000000000..37de7391f --- /dev/null +++ b/_sources/seismology/seismograph.md @@ -0,0 +1,30 @@ +# 地震仪 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（审稿） +- 最近更新日期: 2023-04-19 + +## 基本原理 + +地震仪（seismograph）是检测和记录地面质点运动（位移、速度、加速度、转动等）的仪器， +主要由地震计（seismometer）和数据记录系统组成。其中，地震计用于直接拾取地面运动并将其转换 +为符合数据记录系统需要的能量形式，而数据记录系统用于记录地面运动。 + +如以下卡通图所示，固定在地表的框架上挂有弹簧，并将重物悬挂在弹簧上，可以形象表示地震计； +固定在框架上的旋转的鼓形象地代表了数据记录系统。当地球表面振动时，框架、弹簧、鼓随之移动， +而重物悬浮不动。若在重物上固定一支笔，则地表和重物之间的相对运动就会被笔在旋转的鼓面上描绘出来， +鼓面记录到的运动轨迹代表了地面质点运动，即地震图（seismogram）。可以看出，地震仪的基本原理 +是惯性定律。 + +:::{figure} seismograph.* +:align: center +:alt: 地震仪的原理示意图 +:width: 50% + +地震仪的原理示意图。引自 +[How Does a Seismometer Work?](https://www.iris.edu/hq/inclass/fact-sheet/how_does_a_seismometer_work) +::: + +地震学研究中使用的地震仪对地面运动高度敏感，在非常安静的地区，甚至可以检测到 1 纳米的位移， +几乎与原子间距一样小。大地震（如 2004 年印度尼西亚的苏门答腊地震）产生的地震波可以被全球范围 +的地震仪记录到，振幅高达到几厘米。 + diff --git a/_sources/seismology/station.md b/_sources/seismology/station.md new file mode 100644 index 000000000..ba6ef2e95 --- /dev/null +++ b/_sources/seismology/station.md @@ -0,0 +1,32 @@ +# 地震台站 + +- 本节贡献者: {{ 姚家园 }}（作者）、{{ 田冬冬 }}（审稿） +- 最近更新日期: 2021-05-31 + +--- + +## 数据记录和传输 + +地震学工作者在全球范围布设了许多地震仪，有的布设在地表，有的布设在地下。 +有的地震仪配备了充电设备（如太阳能面板）、网络通讯设备，以便长期稳定地运行，并实时传输数据。 + +地震发生后，其激发的地震波会在地球内部传播。地震波传播至地震仪位置时，地震仪会随即将其记录下来， +并将其转换为数字记录，存储起来。配有蜂窝电话、宽带网络或卫星通信系统的台站，还可以将数据实时 +传输到数据处理中心。最后，科研人员和大众可以利用互联网在数据中心下载数据，开展研究工作。 + +:::{figure} data-transimission.jpg +:align: center +:alt: 地震数据记录和传输示意图 +:width: 95% + +地震学数据地记录和传输示意图。引自 +[How does a seismic station work?](http://www.usarray.org/public/about/how#anchor1) +::: + +## 仪器响应 + +## 台站命名 + +1. ID：NET.STA.LOC.CHN +2. 解释 NET、STA、LOC、CHN 的层级关系 +3. 解释channel，如 BHZ diff --git a/_sphinx_design_static/design-style.b7bb847fb20b106c3d81b95245e65545.min.css b/_sphinx_design_static/design-style.b7bb847fb20b106c3d81b95245e65545.min.css new file mode 100644 index 000000000..704c42eeb --- /dev/null +++ b/_sphinx_design_static/design-style.b7bb847fb20b106c3d81b95245e65545.min.css @@ -0,0 +1 @@ +.sd-bg-primary{background-color:var(--sd-color-primary) !important}.sd-bg-text-primary{color:var(--sd-color-primary-text) !important}button.sd-bg-primary:focus,button.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}a.sd-bg-primary:focus,a.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}.sd-bg-secondary{background-color:var(--sd-color-secondary) !important}.sd-bg-text-secondary{color:var(--sd-color-secondary-text) !important}button.sd-bg-secondary:focus,button.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}a.sd-bg-secondary:focus,a.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}.sd-bg-success{background-color:var(--sd-color-success) !important}.sd-bg-text-success{color:var(--sd-color-success-text) !important}button.sd-bg-success:focus,button.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}a.sd-bg-success:focus,a.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}.sd-bg-info{background-color:var(--sd-color-info) !important}.sd-bg-text-info{color:var(--sd-color-info-text) !important}button.sd-bg-info:focus,button.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}a.sd-bg-info:focus,a.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}.sd-bg-warning{background-color:var(--sd-color-warning) !important}.sd-bg-text-warning{color:var(--sd-color-warning-text) !important}button.sd-bg-warning:focus,button.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}a.sd-bg-warning:focus,a.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}.sd-bg-danger{background-color:var(--sd-color-danger) !important}.sd-bg-text-danger{color:var(--sd-color-danger-text) !important}button.sd-bg-danger:focus,button.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}a.sd-bg-danger:focus,a.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}.sd-bg-light{background-color:var(--sd-color-light) !important}.sd-bg-text-light{color:var(--sd-color-light-text) !important}button.sd-bg-light:focus,button.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}a.sd-bg-light:focus,a.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}.sd-bg-muted{background-color:var(--sd-color-muted) !important}.sd-bg-text-muted{color:var(--sd-color-muted-text) !important}button.sd-bg-muted:focus,button.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}a.sd-bg-muted:focus,a.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}.sd-bg-dark{background-color:var(--sd-color-dark) !important}.sd-bg-text-dark{color:var(--sd-color-dark-text) !important}button.sd-bg-dark:focus,button.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}a.sd-bg-dark:focus,a.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}.sd-bg-black{background-color:var(--sd-color-black) !important}.sd-bg-text-black{color:var(--sd-color-black-text) !important}button.sd-bg-black:focus,button.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}a.sd-bg-black:focus,a.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}.sd-bg-white{background-color:var(--sd-color-white) !important}.sd-bg-text-white{color:var(--sd-color-white-text) !important}button.sd-bg-white:focus,button.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}a.sd-bg-white:focus,a.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}.sd-text-primary,.sd-text-primary>p{color:var(--sd-color-primary) !important}a.sd-text-primary:focus,a.sd-text-primary:hover{color:var(--sd-color-primary-highlight) !important}.sd-text-secondary,.sd-text-secondary>p{color:var(--sd-color-secondary) !important}a.sd-text-secondary:focus,a.sd-text-secondary:hover{color:var(--sd-color-secondary-highlight) !important}.sd-text-success,.sd-text-success>p{color:var(--sd-color-success) !important}a.sd-text-success:focus,a.sd-text-success:hover{color:var(--sd-color-success-highlight) !important}.sd-text-info,.sd-text-info>p{color:var(--sd-color-info) !important}a.sd-text-info:focus,a.sd-text-info:hover{color:var(--sd-color-info-highlight) !important}.sd-text-warning,.sd-text-warning>p{color:var(--sd-color-warning) !important}a.sd-text-warning:focus,a.sd-text-warning:hover{color:var(--sd-color-warning-highlight) !important}.sd-text-danger,.sd-text-danger>p{color:var(--sd-color-danger) !important}a.sd-text-danger:focus,a.sd-text-danger:hover{color:var(--sd-color-danger-highlight) !important}.sd-text-light,.sd-text-light>p{color:var(--sd-color-light) !important}a.sd-text-light:focus,a.sd-text-light:hover{color:var(--sd-color-light-highlight) !important}.sd-text-muted,.sd-text-muted>p{color:var(--sd-color-muted) !important}a.sd-text-muted:focus,a.sd-text-muted:hover{color:var(--sd-color-muted-highlight) !important}.sd-text-dark,.sd-text-dark>p{color:var(--sd-color-dark) !important}a.sd-text-dark:focus,a.sd-text-dark:hover{color:var(--sd-color-dark-highlight) !important}.sd-text-black,.sd-text-black>p{color:var(--sd-color-black) !important}a.sd-text-black:focus,a.sd-text-black:hover{color:var(--sd-color-black-highlight) !important}.sd-text-white,.sd-text-white>p{color:var(--sd-color-white) !important}a.sd-text-white:focus,a.sd-text-white:hover{color:var(--sd-color-white-highlight) !important}.sd-outline-primary{border-color:var(--sd-color-primary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-primary:focus,a.sd-outline-primary:hover{border-color:var(--sd-color-primary-highlight) !important}.sd-outline-secondary{border-color:var(--sd-color-secondary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-secondary:focus,a.sd-outline-secondary:hover{border-color:var(--sd-color-secondary-highlight) !important}.sd-outline-success{border-color:var(--sd-color-success) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-success:focus,a.sd-outline-success:hover{border-color:var(--sd-color-success-highlight) !important}.sd-outline-info{border-color:var(--sd-color-info) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-info:focus,a.sd-outline-info:hover{border-color:var(--sd-color-info-highlight) !important}.sd-outline-warning{border-color:var(--sd-color-warning) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-warning:focus,a.sd-outline-warning:hover{border-color:var(--sd-color-warning-highlight) !important}.sd-outline-danger{border-color:var(--sd-color-danger) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-danger:focus,a.sd-outline-danger:hover{border-color:var(--sd-color-danger-highlight) !important}.sd-outline-light{border-color:var(--sd-color-light) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-light:focus,a.sd-outline-light:hover{border-color:var(--sd-color-light-highlight) !important}.sd-outline-muted{border-color:var(--sd-color-muted) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-muted:focus,a.sd-outline-muted:hover{border-color:var(--sd-color-muted-highlight) !important}.sd-outline-dark{border-color:var(--sd-color-dark) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-dark:focus,a.sd-outline-dark:hover{border-color:var(--sd-color-dark-highlight) !important}.sd-outline-black{border-color:var(--sd-color-black) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-black:focus,a.sd-outline-black:hover{border-color:var(--sd-color-black-highlight) !important}.sd-outline-white{border-color:var(--sd-color-white) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-white:focus,a.sd-outline-white:hover{border-color:var(--sd-color-white-highlight) !important}.sd-bg-transparent{background-color:transparent !important}.sd-outline-transparent{border-color:transparent !important}.sd-text-transparent{color:transparent !important}.sd-p-0{padding:0 !important}.sd-pt-0,.sd-py-0{padding-top:0 !important}.sd-pr-0,.sd-px-0{padding-right:0 !important}.sd-pb-0,.sd-py-0{padding-bottom:0 !important}.sd-pl-0,.sd-px-0{padding-left:0 !important}.sd-p-1{padding:.25rem !important}.sd-pt-1,.sd-py-1{padding-top:.25rem !important}.sd-pr-1,.sd-px-1{padding-right:.25rem !important}.sd-pb-1,.sd-py-1{padding-bottom:.25rem !important}.sd-pl-1,.sd-px-1{padding-left:.25rem !important}.sd-p-2{padding:.5rem !important}.sd-pt-2,.sd-py-2{padding-top:.5rem !important}.sd-pr-2,.sd-px-2{padding-right:.5rem !important}.sd-pb-2,.sd-py-2{padding-bottom:.5rem !important}.sd-pl-2,.sd-px-2{padding-left:.5rem !important}.sd-p-3{padding:1rem !important}.sd-pt-3,.sd-py-3{padding-top:1rem !important}.sd-pr-3,.sd-px-3{padding-right:1rem !important}.sd-pb-3,.sd-py-3{padding-bottom:1rem !important}.sd-pl-3,.sd-px-3{padding-left:1rem !important}.sd-p-4{padding:1.5rem !important}.sd-pt-4,.sd-py-4{padding-top:1.5rem !important}.sd-pr-4,.sd-px-4{padding-right:1.5rem !important}.sd-pb-4,.sd-py-4{padding-bottom:1.5rem !important}.sd-pl-4,.sd-px-4{padding-left:1.5rem !important}.sd-p-5{padding:3rem !important}.sd-pt-5,.sd-py-5{padding-top:3rem !important}.sd-pr-5,.sd-px-5{padding-right:3rem !important}.sd-pb-5,.sd-py-5{padding-bottom:3rem !important}.sd-pl-5,.sd-px-5{padding-left:3rem !important}.sd-m-auto{margin:auto !important}.sd-mt-auto,.sd-my-auto{margin-top:auto !important}.sd-mr-auto,.sd-mx-auto{margin-right:auto !important}.sd-mb-auto,.sd-my-auto{margin-bottom:auto !important}.sd-ml-auto,.sd-mx-auto{margin-left:auto !important}.sd-m-0{margin:0 !important}.sd-mt-0,.sd-my-0{margin-top:0 !important}.sd-mr-0,.sd-mx-0{margin-right:0 !important}.sd-mb-0,.sd-my-0{margin-bottom:0 !important}.sd-ml-0,.sd-mx-0{margin-left:0 !important}.sd-m-1{margin:.25rem !important}.sd-mt-1,.sd-my-1{margin-top:.25rem !important}.sd-mr-1,.sd-mx-1{margin-right:.25rem !important}.sd-mb-1,.sd-my-1{margin-bottom:.25rem !important}.sd-ml-1,.sd-mx-1{margin-left:.25rem !important}.sd-m-2{margin:.5rem !important}.sd-mt-2,.sd-my-2{margin-top:.5rem !important}.sd-mr-2,.sd-mx-2{margin-right:.5rem !important}.sd-mb-2,.sd-my-2{margin-bottom:.5rem !important}.sd-ml-2,.sd-mx-2{margin-left:.5rem !important}.sd-m-3{margin:1rem !important}.sd-mt-3,.sd-my-3{margin-top:1rem !important}.sd-mr-3,.sd-mx-3{margin-right:1rem !important}.sd-mb-3,.sd-my-3{margin-bottom:1rem !important}.sd-ml-3,.sd-mx-3{margin-left:1rem !important}.sd-m-4{margin:1.5rem !important}.sd-mt-4,.sd-my-4{margin-top:1.5rem !important}.sd-mr-4,.sd-mx-4{margin-right:1.5rem !important}.sd-mb-4,.sd-my-4{margin-bottom:1.5rem !important}.sd-ml-4,.sd-mx-4{margin-left:1.5rem !important}.sd-m-5{margin:3rem !important}.sd-mt-5,.sd-my-5{margin-top:3rem !important}.sd-mr-5,.sd-mx-5{margin-right:3rem !important}.sd-mb-5,.sd-my-5{margin-bottom:3rem !important}.sd-ml-5,.sd-mx-5{margin-left:3rem !important}.sd-w-25{width:25% !important}.sd-w-50{width:50% !important}.sd-w-75{width:75% !important}.sd-w-100{width:100% !important}.sd-w-auto{width:auto !important}.sd-h-25{height:25% !important}.sd-h-50{height:50% !important}.sd-h-75{height:75% !important}.sd-h-100{height:100% !important}.sd-h-auto{height:auto !important}.sd-d-none{display:none !important}.sd-d-inline{display:inline !important}.sd-d-inline-block{display:inline-block !important}.sd-d-block{display:block !important}.sd-d-grid{display:grid !important}.sd-d-flex-row{display:-ms-flexbox !important;display:flex !important;flex-direction:row !important}.sd-d-flex-column{display:-ms-flexbox !important;display:flex !important;flex-direction:column !important}.sd-d-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}@media(min-width: 576px){.sd-d-sm-none{display:none !important}.sd-d-sm-inline{display:inline !important}.sd-d-sm-inline-block{display:inline-block !important}.sd-d-sm-block{display:block !important}.sd-d-sm-grid{display:grid !important}.sd-d-sm-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-sm-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 768px){.sd-d-md-none{display:none !important}.sd-d-md-inline{display:inline !important}.sd-d-md-inline-block{display:inline-block !important}.sd-d-md-block{display:block !important}.sd-d-md-grid{display:grid !important}.sd-d-md-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-md-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 992px){.sd-d-lg-none{display:none !important}.sd-d-lg-inline{display:inline !important}.sd-d-lg-inline-block{display:inline-block !important}.sd-d-lg-block{display:block !important}.sd-d-lg-grid{display:grid !important}.sd-d-lg-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-lg-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 1200px){.sd-d-xl-none{display:none !important}.sd-d-xl-inline{display:inline !important}.sd-d-xl-inline-block{display:inline-block !important}.sd-d-xl-block{display:block !important}.sd-d-xl-grid{display:grid !important}.sd-d-xl-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-xl-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}.sd-align-major-start{justify-content:flex-start !important}.sd-align-major-end{justify-content:flex-end !important}.sd-align-major-center{justify-content:center !important}.sd-align-major-justify{justify-content:space-between !important}.sd-align-major-spaced{justify-content:space-evenly !important}.sd-align-minor-start{align-items:flex-start !important}.sd-align-minor-end{align-items:flex-end !important}.sd-align-minor-center{align-items:center !important}.sd-align-minor-stretch{align-items:stretch !important}.sd-text-justify{text-align:justify !important}.sd-text-left{text-align:left !important}.sd-text-right{text-align:right !important}.sd-text-center{text-align:center !important}.sd-font-weight-light{font-weight:300 !important}.sd-font-weight-lighter{font-weight:lighter !important}.sd-font-weight-normal{font-weight:400 !important}.sd-font-weight-bold{font-weight:700 !important}.sd-font-weight-bolder{font-weight:bolder !important}.sd-font-italic{font-style:italic !important}.sd-text-decoration-none{text-decoration:none !important}.sd-text-lowercase{text-transform:lowercase !important}.sd-text-uppercase{text-transform:uppercase !important}.sd-text-capitalize{text-transform:capitalize !important}.sd-text-wrap{white-space:normal !important}.sd-text-nowrap{white-space:nowrap !important}.sd-text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sd-fs-1,.sd-fs-1>p{font-size:calc(1.375rem + 1.5vw) !important;line-height:unset !important}.sd-fs-2,.sd-fs-2>p{font-size:calc(1.325rem + 0.9vw) !important;line-height:unset !important}.sd-fs-3,.sd-fs-3>p{font-size:calc(1.3rem + 0.6vw) !important;line-height:unset !important}.sd-fs-4,.sd-fs-4>p{font-size:calc(1.275rem + 0.3vw) !important;line-height:unset !important}.sd-fs-5,.sd-fs-5>p{font-size:1.25rem !important;line-height:unset !important}.sd-fs-6,.sd-fs-6>p{font-size:1rem !important;line-height:unset !important}.sd-border-0{border:0 solid !important}.sd-border-top-0{border-top:0 solid !important}.sd-border-bottom-0{border-bottom:0 solid !important}.sd-border-right-0{border-right:0 solid !important}.sd-border-left-0{border-left:0 solid !important}.sd-border-1{border:1px solid !important}.sd-border-top-1{border-top:1px solid !important}.sd-border-bottom-1{border-bottom:1px solid !important}.sd-border-right-1{border-right:1px solid !important}.sd-border-left-1{border-left:1px solid !important}.sd-border-2{border:2px solid !important}.sd-border-top-2{border-top:2px solid !important}.sd-border-bottom-2{border-bottom:2px solid !important}.sd-border-right-2{border-right:2px solid !important}.sd-border-left-2{border-left:2px solid !important}.sd-border-3{border:3px solid !important}.sd-border-top-3{border-top:3px solid !important}.sd-border-bottom-3{border-bottom:3px solid !important}.sd-border-right-3{border-right:3px solid !important}.sd-border-left-3{border-left:3px solid !important}.sd-border-4{border:4px solid !important}.sd-border-top-4{border-top:4px solid !important}.sd-border-bottom-4{border-bottom:4px solid !important}.sd-border-right-4{border-right:4px solid !important}.sd-border-left-4{border-left:4px solid !important}.sd-border-5{border:5px solid !important}.sd-border-top-5{border-top:5px solid !important}.sd-border-bottom-5{border-bottom:5px solid !important}.sd-border-right-5{border-right:5px solid !important}.sd-border-left-5{border-left:5px solid !important}.sd-rounded-0{border-radius:0 !important}.sd-rounded-1{border-radius:.2rem !important}.sd-rounded-2{border-radius:.3rem !important}.sd-rounded-3{border-radius:.5rem !important}.sd-rounded-pill{border-radius:50rem !important}.sd-rounded-circle{border-radius:50% !important}.shadow-none{box-shadow:none !important}.sd-shadow-sm{box-shadow:0 .125rem .25rem var(--sd-color-shadow) !important}.sd-shadow-md{box-shadow:0 .5rem 1rem var(--sd-color-shadow) !important}.sd-shadow-lg{box-shadow:0 1rem 3rem var(--sd-color-shadow) !important}@keyframes sd-slide-from-left{0%{transform:translateX(-100%)}100%{transform:translateX(0)}}@keyframes sd-slide-from-right{0%{transform:translateX(200%)}100%{transform:translateX(0)}}@keyframes sd-grow100{0%{transform:scale(0);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50{0%{transform:scale(0.5);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50-rot20{0%{transform:scale(0.5) rotateZ(-20deg);opacity:.5}75%{transform:scale(1) rotateZ(5deg);opacity:1}95%{transform:scale(1) rotateZ(-1deg);opacity:1}100%{transform:scale(1) rotateZ(0);opacity:1}}.sd-animate-slide-from-left{animation:1s ease-out 0s 1 normal none running sd-slide-from-left}.sd-animate-slide-from-right{animation:1s ease-out 0s 1 normal none running sd-slide-from-right}.sd-animate-grow100{animation:1s ease-out 0s 1 normal none running sd-grow100}.sd-animate-grow50{animation:1s ease-out 0s 1 normal none running sd-grow50}.sd-animate-grow50-rot20{animation:1s ease-out 0s 1 normal none running sd-grow50-rot20}.sd-badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.sd-badge:empty{display:none}a.sd-badge{text-decoration:none}.sd-btn .sd-badge{position:relative;top:-1px}.sd-btn{background-color:transparent;border:1px solid transparent;border-radius:.25rem;cursor:pointer;display:inline-block;font-weight:400;font-size:1rem;line-height:1.5;padding:.375rem .75rem;text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;vertical-align:middle;user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none}.sd-btn:hover{text-decoration:none}@media(prefers-reduced-motion: reduce){.sd-btn{transition:none}}.sd-btn-primary,.sd-btn-outline-primary:hover,.sd-btn-outline-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-primary:hover,.sd-btn-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary-highlight) !important;border-color:var(--sd-color-primary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-primary{color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary,.sd-btn-outline-secondary:hover,.sd-btn-outline-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary:hover,.sd-btn-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary-highlight) !important;border-color:var(--sd-color-secondary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-secondary{color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success,.sd-btn-outline-success:hover,.sd-btn-outline-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success:hover,.sd-btn-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success-highlight) !important;border-color:var(--sd-color-success-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-success{color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info,.sd-btn-outline-info:hover,.sd-btn-outline-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info:hover,.sd-btn-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info-highlight) !important;border-color:var(--sd-color-info-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-info{color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning,.sd-btn-outline-warning:hover,.sd-btn-outline-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning:hover,.sd-btn-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning-highlight) !important;border-color:var(--sd-color-warning-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-warning{color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger,.sd-btn-outline-danger:hover,.sd-btn-outline-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger:hover,.sd-btn-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger-highlight) !important;border-color:var(--sd-color-danger-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-danger{color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light,.sd-btn-outline-light:hover,.sd-btn-outline-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light:hover,.sd-btn-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light-highlight) !important;border-color:var(--sd-color-light-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-light{color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted,.sd-btn-outline-muted:hover,.sd-btn-outline-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted:hover,.sd-btn-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted-highlight) !important;border-color:var(--sd-color-muted-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-muted{color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark,.sd-btn-outline-dark:hover,.sd-btn-outline-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark:hover,.sd-btn-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark-highlight) !important;border-color:var(--sd-color-dark-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-dark{color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black,.sd-btn-outline-black:hover,.sd-btn-outline-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black:hover,.sd-btn-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black-highlight) !important;border-color:var(--sd-color-black-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-black{color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white,.sd-btn-outline-white:hover,.sd-btn-outline-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white:hover,.sd-btn-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white-highlight) !important;border-color:var(--sd-color-white-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-white{color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.sd-octicon,.sd-material-icon{display:inline-block;fill:currentColor;vertical-align:middle}.sd-avatar-xs{border-radius:50%;object-fit:cover;object-position:center;width:1rem;height:1rem}.sd-avatar-sm{border-radius:50%;object-fit:cover;object-position:center;width:3rem;height:3rem}.sd-avatar-md{border-radius:50%;object-fit:cover;object-position:center;width:5rem;height:5rem}.sd-avatar-lg{border-radius:50%;object-fit:cover;object-position:center;width:7rem;height:7rem}.sd-avatar-xl{border-radius:50%;object-fit:cover;object-position:center;width:10rem;height:10rem}.sd-avatar-inherit{border-radius:50%;object-fit:cover;object-position:center;width:inherit;height:inherit}.sd-avatar-initial{border-radius:50%;object-fit:cover;object-position:center;width:initial;height:initial}.sd-card{background-clip:border-box;background-color:var(--sd-color-card-background);border:1px solid var(--sd-color-card-border);border-radius:.25rem;color:var(--sd-color-card-text);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;position:relative;word-wrap:break-word}.sd-card>hr{margin-left:0;margin-right:0}.sd-card-hover:hover{border-color:var(--sd-color-card-border-hover);transform:scale(1.01)}.sd-card-body{-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem 1rem}.sd-card-title{margin-bottom:.5rem}.sd-card-subtitle{margin-top:-0.25rem;margin-bottom:0}.sd-card-text:last-child{margin-bottom:0}.sd-card-link:hover{text-decoration:none}.sd-card-link+.card-link{margin-left:1rem}.sd-card-header{padding:.5rem 1rem;margin-bottom:0;background-color:var(--sd-color-card-header);border-bottom:1px solid var(--sd-color-card-border)}.sd-card-header:first-child{border-radius:calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0}.sd-card-footer{padding:.5rem 1rem;background-color:var(--sd-color-card-footer);border-top:1px solid var(--sd-color-card-border)}.sd-card-footer:last-child{border-radius:0 0 calc(0.25rem - 1px) calc(0.25rem - 1px)}.sd-card-header-tabs{margin-right:-0.5rem;margin-bottom:-0.5rem;margin-left:-0.5rem;border-bottom:0}.sd-card-header-pills{margin-right:-0.5rem;margin-left:-0.5rem}.sd-card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom,.sd-card-img-top{width:100%}.sd-card-img,.sd-card-img-top{border-top-left-radius:calc(0.25rem - 1px);border-top-right-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom{border-bottom-left-radius:calc(0.25rem - 1px);border-bottom-right-radius:calc(0.25rem - 1px)}.sd-cards-carousel{width:100%;display:flex;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row;overflow-x:hidden;scroll-snap-type:x mandatory}.sd-cards-carousel.sd-show-scrollbar{overflow-x:auto}.sd-cards-carousel:hover,.sd-cards-carousel:focus{overflow-x:auto}.sd-cards-carousel>.sd-card{flex-shrink:0;scroll-snap-align:start}.sd-cards-carousel>.sd-card:not(:last-child){margin-right:3px}.sd-card-cols-1>.sd-card{width:90%}.sd-card-cols-2>.sd-card{width:45%}.sd-card-cols-3>.sd-card{width:30%}.sd-card-cols-4>.sd-card{width:22.5%}.sd-card-cols-5>.sd-card{width:18%}.sd-card-cols-6>.sd-card{width:15%}.sd-card-cols-7>.sd-card{width:12.8571428571%}.sd-card-cols-8>.sd-card{width:11.25%}.sd-card-cols-9>.sd-card{width:10%}.sd-card-cols-10>.sd-card{width:9%}.sd-card-cols-11>.sd-card{width:8.1818181818%}.sd-card-cols-12>.sd-card{width:7.5%}.sd-container,.sd-container-fluid,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container-xl{margin-left:auto;margin-right:auto;padding-left:var(--sd-gutter-x, 0.75rem);padding-right:var(--sd-gutter-x, 0.75rem);width:100%}@media(min-width: 576px){.sd-container-sm,.sd-container{max-width:540px}}@media(min-width: 768px){.sd-container-md,.sd-container-sm,.sd-container{max-width:720px}}@media(min-width: 992px){.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:960px}}@media(min-width: 1200px){.sd-container-xl,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:1140px}}.sd-row{--sd-gutter-x: 1.5rem;--sd-gutter-y: 0;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-top:calc(var(--sd-gutter-y) * -1);margin-right:calc(var(--sd-gutter-x) * -0.5);margin-left:calc(var(--sd-gutter-x) * -0.5)}.sd-row>*{box-sizing:border-box;flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--sd-gutter-x) * 0.5);padding-left:calc(var(--sd-gutter-x) * 0.5);margin-top:var(--sd-gutter-y)}.sd-col{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-auto>*{flex:0 0 auto;width:auto}.sd-row-cols-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}@media(min-width: 576px){.sd-col-sm{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-sm-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-sm-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-sm-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-sm-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-sm-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-sm-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-sm-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-sm-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-sm-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-sm-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-sm-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-sm-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-sm-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 768px){.sd-col-md{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-md-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-md-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-md-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-md-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-md-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-md-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-md-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-md-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-md-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-md-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-md-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-md-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-md-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 992px){.sd-col-lg{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-lg-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-lg-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-lg-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-lg-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-lg-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-lg-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-lg-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-lg-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-lg-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-lg-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-lg-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-lg-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-lg-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 1200px){.sd-col-xl{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-xl-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-xl-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-xl-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-xl-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-xl-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-xl-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-xl-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-xl-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-xl-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-xl-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-xl-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-xl-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-xl-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}.sd-col-auto{flex:0 0 auto;-ms-flex:0 0 auto;width:auto}.sd-col-1{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}.sd-col-2{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-col-3{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-col-4{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-col-5{flex:0 0 auto;-ms-flex:0 0 auto;width:41.6666666667%}.sd-col-6{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-col-7{flex:0 0 auto;-ms-flex:0 0 auto;width:58.3333333333%}.sd-col-8{flex:0 0 auto;-ms-flex:0 0 auto;width:66.6666666667%}.sd-col-9{flex:0 0 auto;-ms-flex:0 0 auto;width:75%}.sd-col-10{flex:0 0 auto;-ms-flex:0 0 auto;width:83.3333333333%}.sd-col-11{flex:0 0 auto;-ms-flex:0 0 auto;width:91.6666666667%}.sd-col-12{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-g-0,.sd-gy-0{--sd-gutter-y: 0}.sd-g-0,.sd-gx-0{--sd-gutter-x: 0}.sd-g-1,.sd-gy-1{--sd-gutter-y: 0.25rem}.sd-g-1,.sd-gx-1{--sd-gutter-x: 0.25rem}.sd-g-2,.sd-gy-2{--sd-gutter-y: 0.5rem}.sd-g-2,.sd-gx-2{--sd-gutter-x: 0.5rem}.sd-g-3,.sd-gy-3{--sd-gutter-y: 1rem}.sd-g-3,.sd-gx-3{--sd-gutter-x: 1rem}.sd-g-4,.sd-gy-4{--sd-gutter-y: 1.5rem}.sd-g-4,.sd-gx-4{--sd-gutter-x: 1.5rem}.sd-g-5,.sd-gy-5{--sd-gutter-y: 3rem}.sd-g-5,.sd-gx-5{--sd-gutter-x: 3rem}@media(min-width: 576px){.sd-col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-sm-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-sm-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-sm-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-sm-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-sm-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-sm-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-sm-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-sm-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-sm-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-sm-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-sm-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-sm-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-sm-0,.sd-gy-sm-0{--sd-gutter-y: 0}.sd-g-sm-0,.sd-gx-sm-0{--sd-gutter-x: 0}.sd-g-sm-1,.sd-gy-sm-1{--sd-gutter-y: 0.25rem}.sd-g-sm-1,.sd-gx-sm-1{--sd-gutter-x: 0.25rem}.sd-g-sm-2,.sd-gy-sm-2{--sd-gutter-y: 0.5rem}.sd-g-sm-2,.sd-gx-sm-2{--sd-gutter-x: 0.5rem}.sd-g-sm-3,.sd-gy-sm-3{--sd-gutter-y: 1rem}.sd-g-sm-3,.sd-gx-sm-3{--sd-gutter-x: 1rem}.sd-g-sm-4,.sd-gy-sm-4{--sd-gutter-y: 1.5rem}.sd-g-sm-4,.sd-gx-sm-4{--sd-gutter-x: 1.5rem}.sd-g-sm-5,.sd-gy-sm-5{--sd-gutter-y: 3rem}.sd-g-sm-5,.sd-gx-sm-5{--sd-gutter-x: 3rem}}@media(min-width: 768px){.sd-col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-md-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-md-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-md-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-md-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-md-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-md-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-md-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-md-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-md-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-md-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-md-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-md-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-md-0,.sd-gy-md-0{--sd-gutter-y: 0}.sd-g-md-0,.sd-gx-md-0{--sd-gutter-x: 0}.sd-g-md-1,.sd-gy-md-1{--sd-gutter-y: 0.25rem}.sd-g-md-1,.sd-gx-md-1{--sd-gutter-x: 0.25rem}.sd-g-md-2,.sd-gy-md-2{--sd-gutter-y: 0.5rem}.sd-g-md-2,.sd-gx-md-2{--sd-gutter-x: 0.5rem}.sd-g-md-3,.sd-gy-md-3{--sd-gutter-y: 1rem}.sd-g-md-3,.sd-gx-md-3{--sd-gutter-x: 1rem}.sd-g-md-4,.sd-gy-md-4{--sd-gutter-y: 1.5rem}.sd-g-md-4,.sd-gx-md-4{--sd-gutter-x: 1.5rem}.sd-g-md-5,.sd-gy-md-5{--sd-gutter-y: 3rem}.sd-g-md-5,.sd-gx-md-5{--sd-gutter-x: 3rem}}@media(min-width: 992px){.sd-col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-lg-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-lg-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-lg-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-lg-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-lg-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-lg-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-lg-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-lg-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-lg-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-lg-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-lg-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-lg-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-lg-0,.sd-gy-lg-0{--sd-gutter-y: 0}.sd-g-lg-0,.sd-gx-lg-0{--sd-gutter-x: 0}.sd-g-lg-1,.sd-gy-lg-1{--sd-gutter-y: 0.25rem}.sd-g-lg-1,.sd-gx-lg-1{--sd-gutter-x: 0.25rem}.sd-g-lg-2,.sd-gy-lg-2{--sd-gutter-y: 0.5rem}.sd-g-lg-2,.sd-gx-lg-2{--sd-gutter-x: 0.5rem}.sd-g-lg-3,.sd-gy-lg-3{--sd-gutter-y: 1rem}.sd-g-lg-3,.sd-gx-lg-3{--sd-gutter-x: 1rem}.sd-g-lg-4,.sd-gy-lg-4{--sd-gutter-y: 1.5rem}.sd-g-lg-4,.sd-gx-lg-4{--sd-gutter-x: 1.5rem}.sd-g-lg-5,.sd-gy-lg-5{--sd-gutter-y: 3rem}.sd-g-lg-5,.sd-gx-lg-5{--sd-gutter-x: 3rem}}@media(min-width: 1200px){.sd-col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-xl-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-xl-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-xl-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-xl-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-xl-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-xl-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-xl-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-xl-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-xl-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-xl-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-xl-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-xl-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-xl-0,.sd-gy-xl-0{--sd-gutter-y: 0}.sd-g-xl-0,.sd-gx-xl-0{--sd-gutter-x: 0}.sd-g-xl-1,.sd-gy-xl-1{--sd-gutter-y: 0.25rem}.sd-g-xl-1,.sd-gx-xl-1{--sd-gutter-x: 0.25rem}.sd-g-xl-2,.sd-gy-xl-2{--sd-gutter-y: 0.5rem}.sd-g-xl-2,.sd-gx-xl-2{--sd-gutter-x: 0.5rem}.sd-g-xl-3,.sd-gy-xl-3{--sd-gutter-y: 1rem}.sd-g-xl-3,.sd-gx-xl-3{--sd-gutter-x: 1rem}.sd-g-xl-4,.sd-gy-xl-4{--sd-gutter-y: 1.5rem}.sd-g-xl-4,.sd-gx-xl-4{--sd-gutter-x: 1.5rem}.sd-g-xl-5,.sd-gy-xl-5{--sd-gutter-y: 3rem}.sd-g-xl-5,.sd-gx-xl-5{--sd-gutter-x: 3rem}}.sd-flex-row-reverse{flex-direction:row-reverse !important}details.sd-dropdown{position:relative}details.sd-dropdown .sd-summary-title{font-weight:700;padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.sd-dropdown:hover{cursor:pointer}details.sd-dropdown .sd-summary-content{cursor:default}details.sd-dropdown summary{list-style:none;padding:1em}details.sd-dropdown summary .sd-octicon.no-title{vertical-align:middle}details.sd-dropdown[open] summary .sd-octicon.no-title{visibility:hidden}details.sd-dropdown summary::-webkit-details-marker{display:none}details.sd-dropdown summary:focus{outline:none}details.sd-dropdown .sd-summary-icon{margin-right:.5em}details.sd-dropdown .sd-summary-icon svg{opacity:.8}details.sd-dropdown summary:hover .sd-summary-up svg,details.sd-dropdown summary:hover .sd-summary-down svg{opacity:1;transform:scale(1.1)}details.sd-dropdown .sd-summary-up svg,details.sd-dropdown .sd-summary-down svg{display:block;opacity:.6}details.sd-dropdown .sd-summary-up,details.sd-dropdown .sd-summary-down{pointer-events:none;position:absolute;right:1em;top:1em}details.sd-dropdown[open]>.sd-summary-title .sd-summary-down{visibility:hidden}details.sd-dropdown:not([open])>.sd-summary-title .sd-summary-up{visibility:hidden}details.sd-dropdown:not([open]).sd-card{border:none}details.sd-dropdown:not([open])>.sd-card-header{border:1px solid var(--sd-color-card-border);border-radius:.25rem}details.sd-dropdown.sd-fade-in[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out;animation:sd-fade-in .5s ease-in-out}details.sd-dropdown.sd-fade-in-slide-down[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out}.sd-col>.sd-dropdown{width:100%}.sd-summary-content>.sd-tab-set:first-child{margin-top:0}@keyframes sd-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes sd-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.sd-tab-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.sd-tab-set>input{opacity:0;position:absolute}.sd-tab-set>input:checked+label{border-color:var(--sd-color-tabs-underline-active);color:var(--sd-color-tabs-label-active)}.sd-tab-set>input:checked+label+.sd-tab-content{display:block}.sd-tab-set>input:not(:checked)+label:hover{color:var(--sd-color-tabs-label-hover);border-color:var(--sd-color-tabs-underline-hover)}.sd-tab-set>input:focus+label{outline-style:auto}.sd-tab-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.sd-tab-set>label{border-bottom:.125rem solid transparent;margin-bottom:0;color:var(--sd-color-tabs-label-inactive);border-color:var(--sd-color-tabs-underline-inactive);cursor:pointer;font-size:var(--sd-fontsize-tabs-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .sd-tab-set>label:hover{color:var(--sd-color-tabs-label-active)}.sd-col>.sd-tab-set{width:100%}.sd-tab-content{box-shadow:0 -0.0625rem var(--sd-color-tabs-overline),0 .0625rem var(--sd-color-tabs-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.sd-tab-content>:first-child{margin-top:0 !important}.sd-tab-content>:last-child{margin-bottom:0 !important}.sd-tab-content>.sd-tab-set{margin:0}.sd-sphinx-override,.sd-sphinx-override *{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sd-sphinx-override p{margin-top:0}:root{--sd-color-primary: #007bff;--sd-color-secondary: #6c757d;--sd-color-success: #28a745;--sd-color-info: #17a2b8;--sd-color-warning: #f0b37e;--sd-color-danger: #dc3545;--sd-color-light: #f8f9fa;--sd-color-muted: #6c757d;--sd-color-dark: #212529;--sd-color-black: black;--sd-color-white: white;--sd-color-primary-highlight: #0069d9;--sd-color-secondary-highlight: #5c636a;--sd-color-success-highlight: #228e3b;--sd-color-info-highlight: #148a9c;--sd-color-warning-highlight: #cc986b;--sd-color-danger-highlight: #bb2d3b;--sd-color-light-highlight: #d3d4d5;--sd-color-muted-highlight: #5c636a;--sd-color-dark-highlight: #1c1f23;--sd-color-black-highlight: black;--sd-color-white-highlight: #d9d9d9;--sd-color-primary-text: #fff;--sd-color-secondary-text: #fff;--sd-color-success-text: #fff;--sd-color-info-text: #fff;--sd-color-warning-text: #212529;--sd-color-danger-text: #fff;--sd-color-light-text: #212529;--sd-color-muted-text: #fff;--sd-color-dark-text: #fff;--sd-color-black-text: #fff;--sd-color-white-text: #212529;--sd-color-shadow: rgba(0, 0, 0, 0.15);--sd-color-card-border: rgba(0, 0, 0, 0.125);--sd-color-card-border-hover: hsla(231, 99%, 66%, 1);--sd-color-card-background: transparent;--sd-color-card-text: inherit;--sd-color-card-header: transparent;--sd-color-card-footer: transparent;--sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-inactive: hsl(0, 0%, 66%);--sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);--sd-color-tabs-underline-inactive: transparent;--sd-color-tabs-overline: rgb(222, 222, 222);--sd-color-tabs-underline: rgb(222, 222, 222);--sd-fontsize-tabs-label: 1rem} diff --git a/_sphinx_design_static/design-tabs.js b/_sphinx_design_static/design-tabs.js new file mode 100644 index 000000000..36b38cf0d --- /dev/null +++ b/_sphinx_design_static/design-tabs.js @@ -0,0 +1,27 @@ +var sd_labels_by_text = {}; + +function ready() { + const li = document.getElementsByClassName("sd-tab-label"); + for (const label of li) { + syncId = label.getAttribute("data-sync-id"); + if (syncId) { + label.onclick = onLabelClick; + if (!sd_labels_by_text[syncId]) { + sd_labels_by_text[syncId] = []; + } + sd_labels_by_text[syncId].push(label); + } + } +} + +function onLabelClick() { + // Activate other inputs with the same sync id. + syncId = this.getAttribute("data-sync-id"); + for (label of sd_labels_by_text[syncId]) { + if (label === this) continue; + label.previousElementSibling.checked = true; + } + window.localStorage.setItem("sphinx-design-last-tab", syncId); +} + +document.addEventListener("DOMContentLoaded", ready, false); diff --git a/_static/basic.css b/_static/basic.css new file mode 100644 index 000000000..d54be8067 --- /dev/null +++ b/_static/basic.css @@ -0,0 +1,906 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 270px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 450px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a.brackets:before, +span.brackets > a:before{ + content: "["; +} + +a.brackets:after, +span.brackets > a:after { + content: "]"; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +table.footnote td, table.footnote th { + border: 0 !important; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +dl.footnote > dt, +dl.citation > dt { + float: left; + margin-right: 0.5em; +} + +dl.footnote > dd, +dl.citation > dd { + margin-bottom: 0em; +} + +dl.footnote > dd:after, +dl.citation > dd:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dt:after { + content: ":"; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/_static/check-solid.svg b/_static/check-solid.svg new file mode 100644 index 000000000..92fad4b5c --- /dev/null +++ b/_static/check-solid.svg @@ -0,0 +1,4 @@ + + + + diff --git a/_static/clipboard.min.js b/_static/clipboard.min.js new file mode 100644 index 000000000..54b3c4638 --- /dev/null +++ b/_static/clipboard.min.js @@ -0,0 +1,7 @@ +/*! + * clipboard.js v2.0.8 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return o}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),c=n.n(e);function a(t){try{return document.execCommand(t)}catch(t){return}}var f=function(t){t=c()(t);return a("cut"),t};var l=function(t){var e,n,o,r=1 + + + + diff --git a/_static/copybutton.css b/_static/copybutton.css new file mode 100644 index 000000000..f1916ec7d --- /dev/null +++ b/_static/copybutton.css @@ -0,0 +1,94 @@ +/* Copy buttons */ +button.copybtn { + position: absolute; + display: flex; + top: .3em; + right: .3em; + width: 1.7em; + height: 1.7em; + opacity: 0; + transition: opacity 0.3s, border .3s, background-color .3s; + user-select: none; + padding: 0; + border: none; + outline: none; + border-radius: 0.4em; + /* The colors that GitHub uses */ + border: #1b1f2426 1px solid; + background-color: #f6f8fa; + color: #57606a; +} + +button.copybtn.success { + border-color: #22863a; + color: #22863a; +} + +button.copybtn svg { + stroke: currentColor; + width: 1.5em; + height: 1.5em; + padding: 0.1em; +} + +div.highlight { + position: relative; +} + +/* Show the copybutton */ +.highlight:hover button.copybtn, button.copybtn.success { + opacity: 1; +} + +.highlight button.copybtn:hover { + background-color: rgb(235, 235, 235); +} + +.highlight button.copybtn:active { + background-color: rgb(187, 187, 187); +} + +/** + * A minimal CSS-only tooltip copied from: + * https://codepen.io/mildrenben/pen/rVBrpK + * + * To use, write HTML like the following: + * + *

Short

+ */ + .o-tooltip--left { + position: relative; + } + + .o-tooltip--left:after { + opacity: 0; + visibility: hidden; + position: absolute; + content: attr(data-tooltip); + padding: .2em; + font-size: .8em; + left: -.2em; + background: grey; + color: white; + white-space: nowrap; + z-index: 2; + border-radius: 2px; + transform: translateX(-102%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); +} + +.o-tooltip--left:hover:after { + display: block; + opacity: 1; + visibility: visible; + transform: translateX(-100%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); + transition-delay: .5s; +} + +/* By default the copy button shouldn't show up when printing a page */ +@media print { + button.copybtn { + display: none; + } +} diff --git a/_static/copybutton.js b/_static/copybutton.js new file mode 100644 index 000000000..efcb35cd8 --- /dev/null +++ b/_static/copybutton.js @@ -0,0 +1,248 @@ +// Localization support +const messages = { + 'en': { + 'copy': 'Copy', + 'copy_to_clipboard': 'Copy to clipboard', + 'copy_success': 'Copied!', + 'copy_failure': 'Failed to copy', + }, + 'es' : { + 'copy': 'Copiar', + 'copy_to_clipboard': 'Copiar al portapapeles', + 'copy_success': '¡Copiado!', + 'copy_failure': 'Error al copiar', + }, + 'de' : { + 'copy': 'Kopieren', + 'copy_to_clipboard': 'In die Zwischenablage kopieren', + 'copy_success': 'Kopiert!', + 'copy_failure': 'Fehler beim Kopieren', + }, + 'fr' : { + 'copy': 'Copier', + 'copy_to_clipboard': 'Copier dans le presse-papier', + 'copy_success': 'Copié !', + 'copy_failure': 'Échec de la copie', + }, + 'ru': { + 'copy': 'Скопировать', + 'copy_to_clipboard': 'Скопировать в буфер', + 'copy_success': 'Скопировано!', + 'copy_failure': 'Не удалось скопировать', + }, + 'zh-CN': { + 'copy': '复制', + 'copy_to_clipboard': '复制到剪贴板', + 'copy_success': '复制成功!', + 'copy_failure': '复制失败', + }, + 'it' : { + 'copy': 'Copiare', + 'copy_to_clipboard': 'Copiato negli appunti', + 'copy_success': 'Copiato!', + 'copy_failure': 'Errore durante la copia', + } +} + +let locale = 'en' +if( document.documentElement.lang !== undefined + && messages[document.documentElement.lang] !== undefined ) { + locale = document.documentElement.lang +} + +let doc_url_root = DOCUMENTATION_OPTIONS.URL_ROOT; +if (doc_url_root == '#') { + doc_url_root = ''; +} + +/** + * SVG files for our copy buttons + */ +let iconCheck = ` + ${messages[locale]['copy_success']} + + +` + +// If the user specified their own SVG use that, otherwise use the default +let iconCopy = ``; +if (!iconCopy) { + iconCopy = ` + ${messages[locale]['copy_to_clipboard']} + + + +` +} + +/** + * Set up copy/paste for code blocks + */ + +const runWhenDOMLoaded = cb => { + if (document.readyState != 'loading') { + cb() + } else if (document.addEventListener) { + document.addEventListener('DOMContentLoaded', cb) + } else { + document.attachEvent('onreadystatechange', function() { + if (document.readyState == 'complete') cb() + }) + } +} + +const codeCellId = index => `codecell${index}` + +// Clears selected text since ClipboardJS will select the text when copying +const clearSelection = () => { + if (window.getSelection) { + window.getSelection().removeAllRanges() + } else if (document.selection) { + document.selection.empty() + } +} + +// Changes tooltip text for a moment, then changes it back +// We want the timeout of our `success` class to be a bit shorter than the +// tooltip and icon change, so that we can hide the icon before changing back. +var timeoutIcon = 2000; +var timeoutSuccessClass = 1500; + +const temporarilyChangeTooltip = (el, oldText, newText) => { + el.setAttribute('data-tooltip', newText) + el.classList.add('success') + // Remove success a little bit sooner than we change the tooltip + // So that we can use CSS to hide the copybutton first + setTimeout(() => el.classList.remove('success'), timeoutSuccessClass) + setTimeout(() => el.setAttribute('data-tooltip', oldText), timeoutIcon) +} + +// Changes the copy button icon for two seconds, then changes it back +const temporarilyChangeIcon = (el) => { + el.innerHTML = iconCheck; + setTimeout(() => {el.innerHTML = iconCopy}, timeoutIcon) +} + +const addCopyButtonToCodeCells = () => { + // If ClipboardJS hasn't loaded, wait a bit and try again. This + // happens because we load ClipboardJS asynchronously. + if (window.ClipboardJS === undefined) { + setTimeout(addCopyButtonToCodeCells, 250) + return + } + + // Add copybuttons to all of our code cells + const COPYBUTTON_SELECTOR = 'div.highlight pre'; + const codeCells = document.querySelectorAll(COPYBUTTON_SELECTOR) + codeCells.forEach((codeCell, index) => { + const id = codeCellId(index) + codeCell.setAttribute('id', id) + + const clipboardButton = id => + `` + codeCell.insertAdjacentHTML('afterend', clipboardButton(id)) + }) + +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} + + +var copyTargetText = (trigger) => { + var target = document.querySelector(trigger.attributes['data-clipboard-target'].value); + + // get filtered text + let exclude = '.linenos'; + + let text = filterText(target, exclude); + return formatCopyText(text, '>>> |\\.\\.\\. |\\$ |In \\[\\d*\\]: | {2,5}\\.\\.\\.: | {5,8}:', true, true, true, true, '', '') +} + + // Initialize with a callback so we can modify the text before copy + const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText}) + + // Update UI with error/success messages + clipboard.on('success', event => { + clearSelection() + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_success']) + temporarilyChangeIcon(event.trigger) + }) + + clipboard.on('error', event => { + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_failure']) + }) +} + +runWhenDOMLoaded(addCopyButtonToCodeCells) \ No newline at end of file diff --git a/_static/copybutton_funcs.js b/_static/copybutton_funcs.js new file mode 100644 index 000000000..dbe1aaad7 --- /dev/null +++ b/_static/copybutton_funcs.js @@ -0,0 +1,73 @@ +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +export function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +export function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} diff --git a/_static/design-style.b7bb847fb20b106c3d81b95245e65545.min.css b/_static/design-style.b7bb847fb20b106c3d81b95245e65545.min.css new file mode 100644 index 000000000..704c42eeb --- /dev/null +++ b/_static/design-style.b7bb847fb20b106c3d81b95245e65545.min.css @@ -0,0 +1 @@ +.sd-bg-primary{background-color:var(--sd-color-primary) !important}.sd-bg-text-primary{color:var(--sd-color-primary-text) !important}button.sd-bg-primary:focus,button.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}a.sd-bg-primary:focus,a.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}.sd-bg-secondary{background-color:var(--sd-color-secondary) !important}.sd-bg-text-secondary{color:var(--sd-color-secondary-text) !important}button.sd-bg-secondary:focus,button.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}a.sd-bg-secondary:focus,a.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}.sd-bg-success{background-color:var(--sd-color-success) !important}.sd-bg-text-success{color:var(--sd-color-success-text) !important}button.sd-bg-success:focus,button.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}a.sd-bg-success:focus,a.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}.sd-bg-info{background-color:var(--sd-color-info) !important}.sd-bg-text-info{color:var(--sd-color-info-text) !important}button.sd-bg-info:focus,button.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}a.sd-bg-info:focus,a.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}.sd-bg-warning{background-color:var(--sd-color-warning) !important}.sd-bg-text-warning{color:var(--sd-color-warning-text) !important}button.sd-bg-warning:focus,button.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}a.sd-bg-warning:focus,a.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}.sd-bg-danger{background-color:var(--sd-color-danger) !important}.sd-bg-text-danger{color:var(--sd-color-danger-text) !important}button.sd-bg-danger:focus,button.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}a.sd-bg-danger:focus,a.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}.sd-bg-light{background-color:var(--sd-color-light) !important}.sd-bg-text-light{color:var(--sd-color-light-text) !important}button.sd-bg-light:focus,button.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}a.sd-bg-light:focus,a.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}.sd-bg-muted{background-color:var(--sd-color-muted) !important}.sd-bg-text-muted{color:var(--sd-color-muted-text) !important}button.sd-bg-muted:focus,button.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}a.sd-bg-muted:focus,a.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}.sd-bg-dark{background-color:var(--sd-color-dark) !important}.sd-bg-text-dark{color:var(--sd-color-dark-text) !important}button.sd-bg-dark:focus,button.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}a.sd-bg-dark:focus,a.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}.sd-bg-black{background-color:var(--sd-color-black) !important}.sd-bg-text-black{color:var(--sd-color-black-text) !important}button.sd-bg-black:focus,button.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}a.sd-bg-black:focus,a.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}.sd-bg-white{background-color:var(--sd-color-white) !important}.sd-bg-text-white{color:var(--sd-color-white-text) !important}button.sd-bg-white:focus,button.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}a.sd-bg-white:focus,a.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}.sd-text-primary,.sd-text-primary>p{color:var(--sd-color-primary) !important}a.sd-text-primary:focus,a.sd-text-primary:hover{color:var(--sd-color-primary-highlight) !important}.sd-text-secondary,.sd-text-secondary>p{color:var(--sd-color-secondary) !important}a.sd-text-secondary:focus,a.sd-text-secondary:hover{color:var(--sd-color-secondary-highlight) !important}.sd-text-success,.sd-text-success>p{color:var(--sd-color-success) !important}a.sd-text-success:focus,a.sd-text-success:hover{color:var(--sd-color-success-highlight) !important}.sd-text-info,.sd-text-info>p{color:var(--sd-color-info) !important}a.sd-text-info:focus,a.sd-text-info:hover{color:var(--sd-color-info-highlight) !important}.sd-text-warning,.sd-text-warning>p{color:var(--sd-color-warning) !important}a.sd-text-warning:focus,a.sd-text-warning:hover{color:var(--sd-color-warning-highlight) !important}.sd-text-danger,.sd-text-danger>p{color:var(--sd-color-danger) !important}a.sd-text-danger:focus,a.sd-text-danger:hover{color:var(--sd-color-danger-highlight) !important}.sd-text-light,.sd-text-light>p{color:var(--sd-color-light) !important}a.sd-text-light:focus,a.sd-text-light:hover{color:var(--sd-color-light-highlight) !important}.sd-text-muted,.sd-text-muted>p{color:var(--sd-color-muted) !important}a.sd-text-muted:focus,a.sd-text-muted:hover{color:var(--sd-color-muted-highlight) !important}.sd-text-dark,.sd-text-dark>p{color:var(--sd-color-dark) !important}a.sd-text-dark:focus,a.sd-text-dark:hover{color:var(--sd-color-dark-highlight) !important}.sd-text-black,.sd-text-black>p{color:var(--sd-color-black) !important}a.sd-text-black:focus,a.sd-text-black:hover{color:var(--sd-color-black-highlight) !important}.sd-text-white,.sd-text-white>p{color:var(--sd-color-white) !important}a.sd-text-white:focus,a.sd-text-white:hover{color:var(--sd-color-white-highlight) !important}.sd-outline-primary{border-color:var(--sd-color-primary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-primary:focus,a.sd-outline-primary:hover{border-color:var(--sd-color-primary-highlight) !important}.sd-outline-secondary{border-color:var(--sd-color-secondary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-secondary:focus,a.sd-outline-secondary:hover{border-color:var(--sd-color-secondary-highlight) !important}.sd-outline-success{border-color:var(--sd-color-success) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-success:focus,a.sd-outline-success:hover{border-color:var(--sd-color-success-highlight) !important}.sd-outline-info{border-color:var(--sd-color-info) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-info:focus,a.sd-outline-info:hover{border-color:var(--sd-color-info-highlight) !important}.sd-outline-warning{border-color:var(--sd-color-warning) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-warning:focus,a.sd-outline-warning:hover{border-color:var(--sd-color-warning-highlight) !important}.sd-outline-danger{border-color:var(--sd-color-danger) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-danger:focus,a.sd-outline-danger:hover{border-color:var(--sd-color-danger-highlight) !important}.sd-outline-light{border-color:var(--sd-color-light) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-light:focus,a.sd-outline-light:hover{border-color:var(--sd-color-light-highlight) !important}.sd-outline-muted{border-color:var(--sd-color-muted) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-muted:focus,a.sd-outline-muted:hover{border-color:var(--sd-color-muted-highlight) !important}.sd-outline-dark{border-color:var(--sd-color-dark) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-dark:focus,a.sd-outline-dark:hover{border-color:var(--sd-color-dark-highlight) !important}.sd-outline-black{border-color:var(--sd-color-black) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-black:focus,a.sd-outline-black:hover{border-color:var(--sd-color-black-highlight) !important}.sd-outline-white{border-color:var(--sd-color-white) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-white:focus,a.sd-outline-white:hover{border-color:var(--sd-color-white-highlight) !important}.sd-bg-transparent{background-color:transparent !important}.sd-outline-transparent{border-color:transparent !important}.sd-text-transparent{color:transparent !important}.sd-p-0{padding:0 !important}.sd-pt-0,.sd-py-0{padding-top:0 !important}.sd-pr-0,.sd-px-0{padding-right:0 !important}.sd-pb-0,.sd-py-0{padding-bottom:0 !important}.sd-pl-0,.sd-px-0{padding-left:0 !important}.sd-p-1{padding:.25rem !important}.sd-pt-1,.sd-py-1{padding-top:.25rem !important}.sd-pr-1,.sd-px-1{padding-right:.25rem !important}.sd-pb-1,.sd-py-1{padding-bottom:.25rem !important}.sd-pl-1,.sd-px-1{padding-left:.25rem !important}.sd-p-2{padding:.5rem !important}.sd-pt-2,.sd-py-2{padding-top:.5rem !important}.sd-pr-2,.sd-px-2{padding-right:.5rem !important}.sd-pb-2,.sd-py-2{padding-bottom:.5rem !important}.sd-pl-2,.sd-px-2{padding-left:.5rem !important}.sd-p-3{padding:1rem !important}.sd-pt-3,.sd-py-3{padding-top:1rem !important}.sd-pr-3,.sd-px-3{padding-right:1rem !important}.sd-pb-3,.sd-py-3{padding-bottom:1rem !important}.sd-pl-3,.sd-px-3{padding-left:1rem !important}.sd-p-4{padding:1.5rem !important}.sd-pt-4,.sd-py-4{padding-top:1.5rem !important}.sd-pr-4,.sd-px-4{padding-right:1.5rem !important}.sd-pb-4,.sd-py-4{padding-bottom:1.5rem !important}.sd-pl-4,.sd-px-4{padding-left:1.5rem !important}.sd-p-5{padding:3rem !important}.sd-pt-5,.sd-py-5{padding-top:3rem !important}.sd-pr-5,.sd-px-5{padding-right:3rem !important}.sd-pb-5,.sd-py-5{padding-bottom:3rem !important}.sd-pl-5,.sd-px-5{padding-left:3rem !important}.sd-m-auto{margin:auto !important}.sd-mt-auto,.sd-my-auto{margin-top:auto !important}.sd-mr-auto,.sd-mx-auto{margin-right:auto !important}.sd-mb-auto,.sd-my-auto{margin-bottom:auto !important}.sd-ml-auto,.sd-mx-auto{margin-left:auto !important}.sd-m-0{margin:0 !important}.sd-mt-0,.sd-my-0{margin-top:0 !important}.sd-mr-0,.sd-mx-0{margin-right:0 !important}.sd-mb-0,.sd-my-0{margin-bottom:0 !important}.sd-ml-0,.sd-mx-0{margin-left:0 !important}.sd-m-1{margin:.25rem !important}.sd-mt-1,.sd-my-1{margin-top:.25rem !important}.sd-mr-1,.sd-mx-1{margin-right:.25rem !important}.sd-mb-1,.sd-my-1{margin-bottom:.25rem !important}.sd-ml-1,.sd-mx-1{margin-left:.25rem !important}.sd-m-2{margin:.5rem !important}.sd-mt-2,.sd-my-2{margin-top:.5rem !important}.sd-mr-2,.sd-mx-2{margin-right:.5rem !important}.sd-mb-2,.sd-my-2{margin-bottom:.5rem !important}.sd-ml-2,.sd-mx-2{margin-left:.5rem !important}.sd-m-3{margin:1rem !important}.sd-mt-3,.sd-my-3{margin-top:1rem !important}.sd-mr-3,.sd-mx-3{margin-right:1rem !important}.sd-mb-3,.sd-my-3{margin-bottom:1rem !important}.sd-ml-3,.sd-mx-3{margin-left:1rem !important}.sd-m-4{margin:1.5rem !important}.sd-mt-4,.sd-my-4{margin-top:1.5rem !important}.sd-mr-4,.sd-mx-4{margin-right:1.5rem !important}.sd-mb-4,.sd-my-4{margin-bottom:1.5rem !important}.sd-ml-4,.sd-mx-4{margin-left:1.5rem !important}.sd-m-5{margin:3rem !important}.sd-mt-5,.sd-my-5{margin-top:3rem !important}.sd-mr-5,.sd-mx-5{margin-right:3rem !important}.sd-mb-5,.sd-my-5{margin-bottom:3rem !important}.sd-ml-5,.sd-mx-5{margin-left:3rem !important}.sd-w-25{width:25% !important}.sd-w-50{width:50% !important}.sd-w-75{width:75% !important}.sd-w-100{width:100% !important}.sd-w-auto{width:auto !important}.sd-h-25{height:25% !important}.sd-h-50{height:50% !important}.sd-h-75{height:75% !important}.sd-h-100{height:100% !important}.sd-h-auto{height:auto !important}.sd-d-none{display:none !important}.sd-d-inline{display:inline !important}.sd-d-inline-block{display:inline-block !important}.sd-d-block{display:block !important}.sd-d-grid{display:grid !important}.sd-d-flex-row{display:-ms-flexbox !important;display:flex !important;flex-direction:row !important}.sd-d-flex-column{display:-ms-flexbox !important;display:flex !important;flex-direction:column !important}.sd-d-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}@media(min-width: 576px){.sd-d-sm-none{display:none !important}.sd-d-sm-inline{display:inline !important}.sd-d-sm-inline-block{display:inline-block !important}.sd-d-sm-block{display:block !important}.sd-d-sm-grid{display:grid !important}.sd-d-sm-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-sm-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 768px){.sd-d-md-none{display:none !important}.sd-d-md-inline{display:inline !important}.sd-d-md-inline-block{display:inline-block !important}.sd-d-md-block{display:block !important}.sd-d-md-grid{display:grid !important}.sd-d-md-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-md-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 992px){.sd-d-lg-none{display:none !important}.sd-d-lg-inline{display:inline !important}.sd-d-lg-inline-block{display:inline-block !important}.sd-d-lg-block{display:block !important}.sd-d-lg-grid{display:grid !important}.sd-d-lg-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-lg-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 1200px){.sd-d-xl-none{display:none !important}.sd-d-xl-inline{display:inline !important}.sd-d-xl-inline-block{display:inline-block !important}.sd-d-xl-block{display:block !important}.sd-d-xl-grid{display:grid !important}.sd-d-xl-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-xl-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}.sd-align-major-start{justify-content:flex-start !important}.sd-align-major-end{justify-content:flex-end !important}.sd-align-major-center{justify-content:center !important}.sd-align-major-justify{justify-content:space-between !important}.sd-align-major-spaced{justify-content:space-evenly !important}.sd-align-minor-start{align-items:flex-start !important}.sd-align-minor-end{align-items:flex-end !important}.sd-align-minor-center{align-items:center !important}.sd-align-minor-stretch{align-items:stretch !important}.sd-text-justify{text-align:justify !important}.sd-text-left{text-align:left !important}.sd-text-right{text-align:right !important}.sd-text-center{text-align:center !important}.sd-font-weight-light{font-weight:300 !important}.sd-font-weight-lighter{font-weight:lighter !important}.sd-font-weight-normal{font-weight:400 !important}.sd-font-weight-bold{font-weight:700 !important}.sd-font-weight-bolder{font-weight:bolder !important}.sd-font-italic{font-style:italic !important}.sd-text-decoration-none{text-decoration:none !important}.sd-text-lowercase{text-transform:lowercase !important}.sd-text-uppercase{text-transform:uppercase !important}.sd-text-capitalize{text-transform:capitalize !important}.sd-text-wrap{white-space:normal !important}.sd-text-nowrap{white-space:nowrap !important}.sd-text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sd-fs-1,.sd-fs-1>p{font-size:calc(1.375rem + 1.5vw) !important;line-height:unset !important}.sd-fs-2,.sd-fs-2>p{font-size:calc(1.325rem + 0.9vw) !important;line-height:unset !important}.sd-fs-3,.sd-fs-3>p{font-size:calc(1.3rem + 0.6vw) !important;line-height:unset !important}.sd-fs-4,.sd-fs-4>p{font-size:calc(1.275rem + 0.3vw) !important;line-height:unset !important}.sd-fs-5,.sd-fs-5>p{font-size:1.25rem !important;line-height:unset !important}.sd-fs-6,.sd-fs-6>p{font-size:1rem !important;line-height:unset !important}.sd-border-0{border:0 solid !important}.sd-border-top-0{border-top:0 solid !important}.sd-border-bottom-0{border-bottom:0 solid !important}.sd-border-right-0{border-right:0 solid !important}.sd-border-left-0{border-left:0 solid !important}.sd-border-1{border:1px solid !important}.sd-border-top-1{border-top:1px solid !important}.sd-border-bottom-1{border-bottom:1px solid !important}.sd-border-right-1{border-right:1px solid !important}.sd-border-left-1{border-left:1px solid !important}.sd-border-2{border:2px solid !important}.sd-border-top-2{border-top:2px solid !important}.sd-border-bottom-2{border-bottom:2px solid !important}.sd-border-right-2{border-right:2px solid !important}.sd-border-left-2{border-left:2px solid !important}.sd-border-3{border:3px solid !important}.sd-border-top-3{border-top:3px solid !important}.sd-border-bottom-3{border-bottom:3px solid !important}.sd-border-right-3{border-right:3px solid !important}.sd-border-left-3{border-left:3px solid !important}.sd-border-4{border:4px solid !important}.sd-border-top-4{border-top:4px solid !important}.sd-border-bottom-4{border-bottom:4px solid !important}.sd-border-right-4{border-right:4px solid !important}.sd-border-left-4{border-left:4px solid !important}.sd-border-5{border:5px solid !important}.sd-border-top-5{border-top:5px solid !important}.sd-border-bottom-5{border-bottom:5px solid !important}.sd-border-right-5{border-right:5px solid !important}.sd-border-left-5{border-left:5px solid !important}.sd-rounded-0{border-radius:0 !important}.sd-rounded-1{border-radius:.2rem !important}.sd-rounded-2{border-radius:.3rem !important}.sd-rounded-3{border-radius:.5rem !important}.sd-rounded-pill{border-radius:50rem !important}.sd-rounded-circle{border-radius:50% !important}.shadow-none{box-shadow:none !important}.sd-shadow-sm{box-shadow:0 .125rem .25rem var(--sd-color-shadow) !important}.sd-shadow-md{box-shadow:0 .5rem 1rem var(--sd-color-shadow) !important}.sd-shadow-lg{box-shadow:0 1rem 3rem var(--sd-color-shadow) !important}@keyframes sd-slide-from-left{0%{transform:translateX(-100%)}100%{transform:translateX(0)}}@keyframes sd-slide-from-right{0%{transform:translateX(200%)}100%{transform:translateX(0)}}@keyframes sd-grow100{0%{transform:scale(0);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50{0%{transform:scale(0.5);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50-rot20{0%{transform:scale(0.5) rotateZ(-20deg);opacity:.5}75%{transform:scale(1) rotateZ(5deg);opacity:1}95%{transform:scale(1) rotateZ(-1deg);opacity:1}100%{transform:scale(1) rotateZ(0);opacity:1}}.sd-animate-slide-from-left{animation:1s ease-out 0s 1 normal none running sd-slide-from-left}.sd-animate-slide-from-right{animation:1s ease-out 0s 1 normal none running sd-slide-from-right}.sd-animate-grow100{animation:1s ease-out 0s 1 normal none running sd-grow100}.sd-animate-grow50{animation:1s ease-out 0s 1 normal none running sd-grow50}.sd-animate-grow50-rot20{animation:1s ease-out 0s 1 normal none running sd-grow50-rot20}.sd-badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.sd-badge:empty{display:none}a.sd-badge{text-decoration:none}.sd-btn .sd-badge{position:relative;top:-1px}.sd-btn{background-color:transparent;border:1px solid transparent;border-radius:.25rem;cursor:pointer;display:inline-block;font-weight:400;font-size:1rem;line-height:1.5;padding:.375rem .75rem;text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;vertical-align:middle;user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none}.sd-btn:hover{text-decoration:none}@media(prefers-reduced-motion: reduce){.sd-btn{transition:none}}.sd-btn-primary,.sd-btn-outline-primary:hover,.sd-btn-outline-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-primary:hover,.sd-btn-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary-highlight) !important;border-color:var(--sd-color-primary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-primary{color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary,.sd-btn-outline-secondary:hover,.sd-btn-outline-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary:hover,.sd-btn-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary-highlight) !important;border-color:var(--sd-color-secondary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-secondary{color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success,.sd-btn-outline-success:hover,.sd-btn-outline-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success:hover,.sd-btn-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success-highlight) !important;border-color:var(--sd-color-success-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-success{color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info,.sd-btn-outline-info:hover,.sd-btn-outline-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info:hover,.sd-btn-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info-highlight) !important;border-color:var(--sd-color-info-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-info{color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning,.sd-btn-outline-warning:hover,.sd-btn-outline-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning:hover,.sd-btn-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning-highlight) !important;border-color:var(--sd-color-warning-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-warning{color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger,.sd-btn-outline-danger:hover,.sd-btn-outline-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger:hover,.sd-btn-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger-highlight) !important;border-color:var(--sd-color-danger-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-danger{color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light,.sd-btn-outline-light:hover,.sd-btn-outline-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light:hover,.sd-btn-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light-highlight) !important;border-color:var(--sd-color-light-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-light{color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted,.sd-btn-outline-muted:hover,.sd-btn-outline-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted:hover,.sd-btn-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted-highlight) !important;border-color:var(--sd-color-muted-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-muted{color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark,.sd-btn-outline-dark:hover,.sd-btn-outline-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark:hover,.sd-btn-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark-highlight) !important;border-color:var(--sd-color-dark-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-dark{color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black,.sd-btn-outline-black:hover,.sd-btn-outline-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black:hover,.sd-btn-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black-highlight) !important;border-color:var(--sd-color-black-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-black{color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white,.sd-btn-outline-white:hover,.sd-btn-outline-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white:hover,.sd-btn-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white-highlight) !important;border-color:var(--sd-color-white-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-white{color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.sd-octicon,.sd-material-icon{display:inline-block;fill:currentColor;vertical-align:middle}.sd-avatar-xs{border-radius:50%;object-fit:cover;object-position:center;width:1rem;height:1rem}.sd-avatar-sm{border-radius:50%;object-fit:cover;object-position:center;width:3rem;height:3rem}.sd-avatar-md{border-radius:50%;object-fit:cover;object-position:center;width:5rem;height:5rem}.sd-avatar-lg{border-radius:50%;object-fit:cover;object-position:center;width:7rem;height:7rem}.sd-avatar-xl{border-radius:50%;object-fit:cover;object-position:center;width:10rem;height:10rem}.sd-avatar-inherit{border-radius:50%;object-fit:cover;object-position:center;width:inherit;height:inherit}.sd-avatar-initial{border-radius:50%;object-fit:cover;object-position:center;width:initial;height:initial}.sd-card{background-clip:border-box;background-color:var(--sd-color-card-background);border:1px solid var(--sd-color-card-border);border-radius:.25rem;color:var(--sd-color-card-text);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;position:relative;word-wrap:break-word}.sd-card>hr{margin-left:0;margin-right:0}.sd-card-hover:hover{border-color:var(--sd-color-card-border-hover);transform:scale(1.01)}.sd-card-body{-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem 1rem}.sd-card-title{margin-bottom:.5rem}.sd-card-subtitle{margin-top:-0.25rem;margin-bottom:0}.sd-card-text:last-child{margin-bottom:0}.sd-card-link:hover{text-decoration:none}.sd-card-link+.card-link{margin-left:1rem}.sd-card-header{padding:.5rem 1rem;margin-bottom:0;background-color:var(--sd-color-card-header);border-bottom:1px solid var(--sd-color-card-border)}.sd-card-header:first-child{border-radius:calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0}.sd-card-footer{padding:.5rem 1rem;background-color:var(--sd-color-card-footer);border-top:1px solid var(--sd-color-card-border)}.sd-card-footer:last-child{border-radius:0 0 calc(0.25rem - 1px) calc(0.25rem - 1px)}.sd-card-header-tabs{margin-right:-0.5rem;margin-bottom:-0.5rem;margin-left:-0.5rem;border-bottom:0}.sd-card-header-pills{margin-right:-0.5rem;margin-left:-0.5rem}.sd-card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom,.sd-card-img-top{width:100%}.sd-card-img,.sd-card-img-top{border-top-left-radius:calc(0.25rem - 1px);border-top-right-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom{border-bottom-left-radius:calc(0.25rem - 1px);border-bottom-right-radius:calc(0.25rem - 1px)}.sd-cards-carousel{width:100%;display:flex;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row;overflow-x:hidden;scroll-snap-type:x mandatory}.sd-cards-carousel.sd-show-scrollbar{overflow-x:auto}.sd-cards-carousel:hover,.sd-cards-carousel:focus{overflow-x:auto}.sd-cards-carousel>.sd-card{flex-shrink:0;scroll-snap-align:start}.sd-cards-carousel>.sd-card:not(:last-child){margin-right:3px}.sd-card-cols-1>.sd-card{width:90%}.sd-card-cols-2>.sd-card{width:45%}.sd-card-cols-3>.sd-card{width:30%}.sd-card-cols-4>.sd-card{width:22.5%}.sd-card-cols-5>.sd-card{width:18%}.sd-card-cols-6>.sd-card{width:15%}.sd-card-cols-7>.sd-card{width:12.8571428571%}.sd-card-cols-8>.sd-card{width:11.25%}.sd-card-cols-9>.sd-card{width:10%}.sd-card-cols-10>.sd-card{width:9%}.sd-card-cols-11>.sd-card{width:8.1818181818%}.sd-card-cols-12>.sd-card{width:7.5%}.sd-container,.sd-container-fluid,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container-xl{margin-left:auto;margin-right:auto;padding-left:var(--sd-gutter-x, 0.75rem);padding-right:var(--sd-gutter-x, 0.75rem);width:100%}@media(min-width: 576px){.sd-container-sm,.sd-container{max-width:540px}}@media(min-width: 768px){.sd-container-md,.sd-container-sm,.sd-container{max-width:720px}}@media(min-width: 992px){.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:960px}}@media(min-width: 1200px){.sd-container-xl,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:1140px}}.sd-row{--sd-gutter-x: 1.5rem;--sd-gutter-y: 0;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-top:calc(var(--sd-gutter-y) * -1);margin-right:calc(var(--sd-gutter-x) * -0.5);margin-left:calc(var(--sd-gutter-x) * -0.5)}.sd-row>*{box-sizing:border-box;flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--sd-gutter-x) * 0.5);padding-left:calc(var(--sd-gutter-x) * 0.5);margin-top:var(--sd-gutter-y)}.sd-col{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-auto>*{flex:0 0 auto;width:auto}.sd-row-cols-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}@media(min-width: 576px){.sd-col-sm{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-sm-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-sm-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-sm-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-sm-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-sm-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-sm-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-sm-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-sm-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-sm-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-sm-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-sm-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-sm-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-sm-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 768px){.sd-col-md{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-md-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-md-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-md-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-md-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-md-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-md-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-md-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-md-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-md-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-md-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-md-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-md-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-md-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 992px){.sd-col-lg{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-lg-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-lg-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-lg-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-lg-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-lg-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-lg-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-lg-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-lg-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-lg-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-lg-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-lg-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-lg-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-lg-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 1200px){.sd-col-xl{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-xl-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-xl-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-xl-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-xl-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-xl-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-xl-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-xl-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-xl-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-xl-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-xl-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-xl-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-xl-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-xl-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}.sd-col-auto{flex:0 0 auto;-ms-flex:0 0 auto;width:auto}.sd-col-1{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}.sd-col-2{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-col-3{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-col-4{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-col-5{flex:0 0 auto;-ms-flex:0 0 auto;width:41.6666666667%}.sd-col-6{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-col-7{flex:0 0 auto;-ms-flex:0 0 auto;width:58.3333333333%}.sd-col-8{flex:0 0 auto;-ms-flex:0 0 auto;width:66.6666666667%}.sd-col-9{flex:0 0 auto;-ms-flex:0 0 auto;width:75%}.sd-col-10{flex:0 0 auto;-ms-flex:0 0 auto;width:83.3333333333%}.sd-col-11{flex:0 0 auto;-ms-flex:0 0 auto;width:91.6666666667%}.sd-col-12{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-g-0,.sd-gy-0{--sd-gutter-y: 0}.sd-g-0,.sd-gx-0{--sd-gutter-x: 0}.sd-g-1,.sd-gy-1{--sd-gutter-y: 0.25rem}.sd-g-1,.sd-gx-1{--sd-gutter-x: 0.25rem}.sd-g-2,.sd-gy-2{--sd-gutter-y: 0.5rem}.sd-g-2,.sd-gx-2{--sd-gutter-x: 0.5rem}.sd-g-3,.sd-gy-3{--sd-gutter-y: 1rem}.sd-g-3,.sd-gx-3{--sd-gutter-x: 1rem}.sd-g-4,.sd-gy-4{--sd-gutter-y: 1.5rem}.sd-g-4,.sd-gx-4{--sd-gutter-x: 1.5rem}.sd-g-5,.sd-gy-5{--sd-gutter-y: 3rem}.sd-g-5,.sd-gx-5{--sd-gutter-x: 3rem}@media(min-width: 576px){.sd-col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-sm-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-sm-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-sm-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-sm-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-sm-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-sm-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-sm-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-sm-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-sm-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-sm-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-sm-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-sm-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-sm-0,.sd-gy-sm-0{--sd-gutter-y: 0}.sd-g-sm-0,.sd-gx-sm-0{--sd-gutter-x: 0}.sd-g-sm-1,.sd-gy-sm-1{--sd-gutter-y: 0.25rem}.sd-g-sm-1,.sd-gx-sm-1{--sd-gutter-x: 0.25rem}.sd-g-sm-2,.sd-gy-sm-2{--sd-gutter-y: 0.5rem}.sd-g-sm-2,.sd-gx-sm-2{--sd-gutter-x: 0.5rem}.sd-g-sm-3,.sd-gy-sm-3{--sd-gutter-y: 1rem}.sd-g-sm-3,.sd-gx-sm-3{--sd-gutter-x: 1rem}.sd-g-sm-4,.sd-gy-sm-4{--sd-gutter-y: 1.5rem}.sd-g-sm-4,.sd-gx-sm-4{--sd-gutter-x: 1.5rem}.sd-g-sm-5,.sd-gy-sm-5{--sd-gutter-y: 3rem}.sd-g-sm-5,.sd-gx-sm-5{--sd-gutter-x: 3rem}}@media(min-width: 768px){.sd-col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-md-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-md-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-md-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-md-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-md-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-md-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-md-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-md-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-md-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-md-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-md-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-md-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-md-0,.sd-gy-md-0{--sd-gutter-y: 0}.sd-g-md-0,.sd-gx-md-0{--sd-gutter-x: 0}.sd-g-md-1,.sd-gy-md-1{--sd-gutter-y: 0.25rem}.sd-g-md-1,.sd-gx-md-1{--sd-gutter-x: 0.25rem}.sd-g-md-2,.sd-gy-md-2{--sd-gutter-y: 0.5rem}.sd-g-md-2,.sd-gx-md-2{--sd-gutter-x: 0.5rem}.sd-g-md-3,.sd-gy-md-3{--sd-gutter-y: 1rem}.sd-g-md-3,.sd-gx-md-3{--sd-gutter-x: 1rem}.sd-g-md-4,.sd-gy-md-4{--sd-gutter-y: 1.5rem}.sd-g-md-4,.sd-gx-md-4{--sd-gutter-x: 1.5rem}.sd-g-md-5,.sd-gy-md-5{--sd-gutter-y: 3rem}.sd-g-md-5,.sd-gx-md-5{--sd-gutter-x: 3rem}}@media(min-width: 992px){.sd-col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-lg-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-lg-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-lg-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-lg-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-lg-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-lg-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-lg-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-lg-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-lg-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-lg-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-lg-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-lg-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-lg-0,.sd-gy-lg-0{--sd-gutter-y: 0}.sd-g-lg-0,.sd-gx-lg-0{--sd-gutter-x: 0}.sd-g-lg-1,.sd-gy-lg-1{--sd-gutter-y: 0.25rem}.sd-g-lg-1,.sd-gx-lg-1{--sd-gutter-x: 0.25rem}.sd-g-lg-2,.sd-gy-lg-2{--sd-gutter-y: 0.5rem}.sd-g-lg-2,.sd-gx-lg-2{--sd-gutter-x: 0.5rem}.sd-g-lg-3,.sd-gy-lg-3{--sd-gutter-y: 1rem}.sd-g-lg-3,.sd-gx-lg-3{--sd-gutter-x: 1rem}.sd-g-lg-4,.sd-gy-lg-4{--sd-gutter-y: 1.5rem}.sd-g-lg-4,.sd-gx-lg-4{--sd-gutter-x: 1.5rem}.sd-g-lg-5,.sd-gy-lg-5{--sd-gutter-y: 3rem}.sd-g-lg-5,.sd-gx-lg-5{--sd-gutter-x: 3rem}}@media(min-width: 1200px){.sd-col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-xl-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-xl-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-xl-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-xl-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-xl-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-xl-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-xl-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-xl-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-xl-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-xl-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-xl-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-xl-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-xl-0,.sd-gy-xl-0{--sd-gutter-y: 0}.sd-g-xl-0,.sd-gx-xl-0{--sd-gutter-x: 0}.sd-g-xl-1,.sd-gy-xl-1{--sd-gutter-y: 0.25rem}.sd-g-xl-1,.sd-gx-xl-1{--sd-gutter-x: 0.25rem}.sd-g-xl-2,.sd-gy-xl-2{--sd-gutter-y: 0.5rem}.sd-g-xl-2,.sd-gx-xl-2{--sd-gutter-x: 0.5rem}.sd-g-xl-3,.sd-gy-xl-3{--sd-gutter-y: 1rem}.sd-g-xl-3,.sd-gx-xl-3{--sd-gutter-x: 1rem}.sd-g-xl-4,.sd-gy-xl-4{--sd-gutter-y: 1.5rem}.sd-g-xl-4,.sd-gx-xl-4{--sd-gutter-x: 1.5rem}.sd-g-xl-5,.sd-gy-xl-5{--sd-gutter-y: 3rem}.sd-g-xl-5,.sd-gx-xl-5{--sd-gutter-x: 3rem}}.sd-flex-row-reverse{flex-direction:row-reverse !important}details.sd-dropdown{position:relative}details.sd-dropdown .sd-summary-title{font-weight:700;padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.sd-dropdown:hover{cursor:pointer}details.sd-dropdown .sd-summary-content{cursor:default}details.sd-dropdown summary{list-style:none;padding:1em}details.sd-dropdown summary .sd-octicon.no-title{vertical-align:middle}details.sd-dropdown[open] summary .sd-octicon.no-title{visibility:hidden}details.sd-dropdown summary::-webkit-details-marker{display:none}details.sd-dropdown summary:focus{outline:none}details.sd-dropdown .sd-summary-icon{margin-right:.5em}details.sd-dropdown .sd-summary-icon svg{opacity:.8}details.sd-dropdown summary:hover .sd-summary-up svg,details.sd-dropdown summary:hover .sd-summary-down svg{opacity:1;transform:scale(1.1)}details.sd-dropdown .sd-summary-up svg,details.sd-dropdown .sd-summary-down svg{display:block;opacity:.6}details.sd-dropdown .sd-summary-up,details.sd-dropdown .sd-summary-down{pointer-events:none;position:absolute;right:1em;top:1em}details.sd-dropdown[open]>.sd-summary-title .sd-summary-down{visibility:hidden}details.sd-dropdown:not([open])>.sd-summary-title .sd-summary-up{visibility:hidden}details.sd-dropdown:not([open]).sd-card{border:none}details.sd-dropdown:not([open])>.sd-card-header{border:1px solid var(--sd-color-card-border);border-radius:.25rem}details.sd-dropdown.sd-fade-in[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out;animation:sd-fade-in .5s ease-in-out}details.sd-dropdown.sd-fade-in-slide-down[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out}.sd-col>.sd-dropdown{width:100%}.sd-summary-content>.sd-tab-set:first-child{margin-top:0}@keyframes sd-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes sd-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.sd-tab-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.sd-tab-set>input{opacity:0;position:absolute}.sd-tab-set>input:checked+label{border-color:var(--sd-color-tabs-underline-active);color:var(--sd-color-tabs-label-active)}.sd-tab-set>input:checked+label+.sd-tab-content{display:block}.sd-tab-set>input:not(:checked)+label:hover{color:var(--sd-color-tabs-label-hover);border-color:var(--sd-color-tabs-underline-hover)}.sd-tab-set>input:focus+label{outline-style:auto}.sd-tab-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.sd-tab-set>label{border-bottom:.125rem solid transparent;margin-bottom:0;color:var(--sd-color-tabs-label-inactive);border-color:var(--sd-color-tabs-underline-inactive);cursor:pointer;font-size:var(--sd-fontsize-tabs-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .sd-tab-set>label:hover{color:var(--sd-color-tabs-label-active)}.sd-col>.sd-tab-set{width:100%}.sd-tab-content{box-shadow:0 -0.0625rem var(--sd-color-tabs-overline),0 .0625rem var(--sd-color-tabs-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.sd-tab-content>:first-child{margin-top:0 !important}.sd-tab-content>:last-child{margin-bottom:0 !important}.sd-tab-content>.sd-tab-set{margin:0}.sd-sphinx-override,.sd-sphinx-override *{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sd-sphinx-override p{margin-top:0}:root{--sd-color-primary: #007bff;--sd-color-secondary: #6c757d;--sd-color-success: #28a745;--sd-color-info: #17a2b8;--sd-color-warning: #f0b37e;--sd-color-danger: #dc3545;--sd-color-light: #f8f9fa;--sd-color-muted: #6c757d;--sd-color-dark: #212529;--sd-color-black: black;--sd-color-white: white;--sd-color-primary-highlight: #0069d9;--sd-color-secondary-highlight: #5c636a;--sd-color-success-highlight: #228e3b;--sd-color-info-highlight: #148a9c;--sd-color-warning-highlight: #cc986b;--sd-color-danger-highlight: #bb2d3b;--sd-color-light-highlight: #d3d4d5;--sd-color-muted-highlight: #5c636a;--sd-color-dark-highlight: #1c1f23;--sd-color-black-highlight: black;--sd-color-white-highlight: #d9d9d9;--sd-color-primary-text: #fff;--sd-color-secondary-text: #fff;--sd-color-success-text: #fff;--sd-color-info-text: #fff;--sd-color-warning-text: #212529;--sd-color-danger-text: #fff;--sd-color-light-text: #212529;--sd-color-muted-text: #fff;--sd-color-dark-text: #fff;--sd-color-black-text: #fff;--sd-color-white-text: #212529;--sd-color-shadow: rgba(0, 0, 0, 0.15);--sd-color-card-border: rgba(0, 0, 0, 0.125);--sd-color-card-border-hover: hsla(231, 99%, 66%, 1);--sd-color-card-background: transparent;--sd-color-card-text: inherit;--sd-color-card-header: transparent;--sd-color-card-footer: transparent;--sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-inactive: hsl(0, 0%, 66%);--sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);--sd-color-tabs-underline-inactive: transparent;--sd-color-tabs-overline: rgb(222, 222, 222);--sd-color-tabs-underline: rgb(222, 222, 222);--sd-fontsize-tabs-label: 1rem} diff --git a/_static/design-tabs.js b/_static/design-tabs.js new file mode 100644 index 000000000..36b38cf0d --- /dev/null +++ b/_static/design-tabs.js @@ -0,0 +1,27 @@ +var sd_labels_by_text = {}; + +function ready() { + const li = document.getElementsByClassName("sd-tab-label"); + for (const label of li) { + syncId = label.getAttribute("data-sync-id"); + if (syncId) { + label.onclick = onLabelClick; + if (!sd_labels_by_text[syncId]) { + sd_labels_by_text[syncId] = []; + } + sd_labels_by_text[syncId].push(label); + } + } +} + +function onLabelClick() { + // Activate other inputs with the same sync id. + syncId = this.getAttribute("data-sync-id"); + for (label of sd_labels_by_text[syncId]) { + if (label === this) continue; + label.previousElementSibling.checked = true; + } + window.localStorage.setItem("sphinx-design-last-tab", syncId); +} + +document.addEventListener("DOMContentLoaded", ready, false); diff --git a/_static/doctools.js b/_static/doctools.js new file mode 100644 index 000000000..e1bfd708b --- /dev/null +++ b/_static/doctools.js @@ -0,0 +1,358 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for all documentation. + * + * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/** + * select a different prefix for underscore + */ +$u = _.noConflict(); + +/** + * make the code below compatible with browsers without + * an installed firebug like debugger +if (!window.console || !console.firebug) { + var names = ["log", "debug", "info", "warn", "error", "assert", "dir", + "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", + "profile", "profileEnd"]; + window.console = {}; + for (var i = 0; i < names.length; ++i) + window.console[names[i]] = function() {}; +} + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} + +/** + * Small JavaScript module for the documentation. + */ +var Documentation = { + + init : function() { + this.fixFirefoxAnchorBug(); + this.highlightSearchWords(); + this.initIndexTable(); + this.initOnKeyListeners(); + }, + + /** + * i18n support + */ + TRANSLATIONS : {}, + PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; }, + LOCALE : 'unknown', + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext : function(string) { + var translated = Documentation.TRANSLATIONS[string]; + if (typeof translated === 'undefined') + return string; + return (typeof translated === 'string') ? translated : translated[0]; + }, + + ngettext : function(singular, plural, n) { + var translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated === 'undefined') + return (n == 1) ? singular : plural; + return translated[Documentation.PLURALEXPR(n)]; + }, + + addTranslations : function(catalog) { + for (var key in catalog.messages) + this.TRANSLATIONS[key] = catalog.messages[key]; + this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); + this.LOCALE = catalog.locale; + }, + + /** + * add context elements like header anchor links + */ + addContextElements : function() { + $('div[id] > :header:first').each(function() { + $('\u00B6'). + attr('href', '#' + this.id). + attr('title', _('Permalink to this headline')). + appendTo(this); + }); + $('dt[id]').each(function() { + $('\u00B6'). + attr('href', '#' + this.id). + attr('title', _('Permalink to this definition')). + appendTo(this); + }); + }, + + /** + * workaround a firefox stupidity + * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075 + */ + fixFirefoxAnchorBug : function() { + if (document.location.hash && $.browser.mozilla) + window.setTimeout(function() { + document.location.href += ''; + }, 10); + }, + + /** + * highlight the search words provided in the url in the text + */ + highlightSearchWords : function() { + var params = $.getQueryParameters(); + var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; + if (terms.length) { + var body = $('div.body'); + if (!body.length) { + body = $('body'); + } + window.setTimeout(function() { + $.each(terms, function() { + body.highlightText(this.toLowerCase(), 'highlighted'); + }); + }, 10); + $('

' + _('Hide Search Matches') + '

') + .appendTo($('#searchbox')); + } + }, + + /** + * init the domain index toggle buttons + */ + initIndexTable : function() { + var togglers = $('img.toggler').click(function() { + var src = $(this).attr('src'); + var idnum = $(this).attr('id').substr(7); + $('tr.cg-' + idnum).toggle(); + if (src.substr(-9) === 'minus.png') + $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); + else + $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); + }).css('display', ''); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { + togglers.click(); + } + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords : function() { + $('#searchbox .highlight-link').fadeOut(300); + $('span.highlighted').removeClass('highlighted'); + var url = new URL(window.location); + url.searchParams.delete('highlight'); + window.history.replaceState({}, '', url); + }, + + /** + * helper function to focus on search bar + */ + focusSearchBar : function() { + $('input[name=q]').first().focus(); + }, + + /** + * make the url absolute + */ + makeURL : function(relativeURL) { + return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; + }, + + /** + * get the current relative url + */ + getCurrentURL : function() { + var path = document.location.pathname; + var parts = path.split(/\//); + $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { + if (this === '..') + parts.pop(); + }); + var url = parts.join('/'); + return path.substring(url.lastIndexOf('/') + 1, path.length - 1); + }, + + initOnKeyListeners: function() { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && + !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) + return; + + $(document).keydown(function(event) { + var activeElementType = document.activeElement.tagName; + // don't navigate when in search box, textarea, dropdown or button + if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT' + && activeElementType !== 'BUTTON') { + if (event.altKey || event.ctrlKey || event.metaKey) + return; + + if (!event.shiftKey) { + switch (event.key) { + case 'ArrowLeft': + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) + break; + var prevHref = $('link[rel="prev"]').prop('href'); + if (prevHref) { + window.location.href = prevHref; + return false; + } + break; + case 'ArrowRight': + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) + break; + var nextHref = $('link[rel="next"]').prop('href'); + if (nextHref) { + window.location.href = nextHref; + return false; + } + break; + case 'Escape': + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) + break; + Documentation.hideSearchWords(); + return false; + } + } + + // some keyboard layouts may need Shift to get / + switch (event.key) { + case '/': + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) + break; + Documentation.focusSearchBar(); + return false; + } + } + }); + } +}; + +// quick alias for translations +_ = Documentation.gettext; + +$(document).ready(function() { + Documentation.init(); +}); diff --git a/_static/documentation_options.js b/_static/documentation_options.js new file mode 100644 index 000000000..7f2df8306 --- /dev/null +++ b/_static/documentation_options.js @@ -0,0 +1,14 @@ +var DOCUMENTATION_OPTIONS = { + URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), + VERSION: '', + LANGUAGE: 'None', + COLLAPSE_INDEX: false, + BUILDER: 'dirhtml', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '', + NAVIGATION_WITH_KEYS: true, + SHOW_SEARCH_SUMMARY: true, + ENABLE_SEARCH_SHORTCUTS: true, +}; \ No newline at end of file diff --git a/_static/favicon.ico b/_static/favicon.ico new file mode 100644 index 000000000..bb295e843 Binary files /dev/null and b/_static/favicon.ico differ diff --git a/_static/file.png b/_static/file.png new file mode 100644 index 000000000..a858a410e Binary files /dev/null and b/_static/file.png differ diff --git a/_static/images/logo_binder.svg b/_static/images/logo_binder.svg new file mode 100644 index 000000000..45fecf751 --- /dev/null +++ b/_static/images/logo_binder.svg @@ -0,0 +1,19 @@ + + + + +logo + + + + + + + + diff --git a/_static/images/logo_colab.png b/_static/images/logo_colab.png new file mode 100644 index 000000000..b7560ec21 Binary files /dev/null and b/_static/images/logo_colab.png differ diff --git a/_static/images/logo_deepnote.svg b/_static/images/logo_deepnote.svg new file mode 100644 index 000000000..fa77ebfc2 --- /dev/null +++ b/_static/images/logo_deepnote.svg @@ -0,0 +1 @@ + diff --git a/_static/images/logo_jupyterhub.svg b/_static/images/logo_jupyterhub.svg new file mode 100644 index 000000000..60cfe9f22 --- /dev/null +++ b/_static/images/logo_jupyterhub.svg @@ -0,0 +1 @@ +logo_jupyterhubHub diff --git a/_static/jquery-3.5.1.js b/_static/jquery-3.5.1.js new file mode 100644 index 000000000..50937333b --- /dev/null +++ b/_static/jquery-3.5.1.js @@ -0,0 +1,10872 @@ +/*! + * jQuery JavaScript Library v3.5.1 + * https://jquery.com/ + * + * Includes Sizzle.js + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://jquery.org/license + * + * Date: 2020-05-04T22:49Z + */ +( function( global, factory ) { + + "use strict"; + + if ( typeof module === "object" && typeof module.exports === "object" ) { + + // For CommonJS and CommonJS-like environments where a proper `window` + // is present, execute the factory and get jQuery. + // For environments that do not have a `window` with a `document` + // (such as Node.js), expose a factory as module.exports. + // This accentuates the need for the creation of a real `window`. + // e.g. var jQuery = require("jquery")(window); + // See ticket #14549 for more info. + module.exports = global.document ? + factory( global, true ) : + function( w ) { + if ( !w.document ) { + throw new Error( "jQuery requires a window with a document" ); + } + return factory( w ); + }; + } else { + factory( global ); + } + +// Pass this if window is not defined yet +} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { + +// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 +// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode +// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common +// enough that all such attempts are guarded in a try block. +"use strict"; + +var arr = []; + +var getProto = Object.getPrototypeOf; + +var slice = arr.slice; + +var flat = arr.flat ? function( array ) { + return arr.flat.call( array ); +} : function( array ) { + return arr.concat.apply( [], array ); +}; + + +var push = arr.push; + +var indexOf = arr.indexOf; + +var class2type = {}; + +var toString = class2type.toString; + +var hasOwn = class2type.hasOwnProperty; + +var fnToString = hasOwn.toString; + +var ObjectFunctionString = fnToString.call( Object ); + +var support = {}; + +var isFunction = function isFunction( obj ) { + + // Support: Chrome <=57, Firefox <=52 + // In some browsers, typeof returns "function" for HTML elements + // (i.e., `typeof document.createElement( "object" ) === "function"`). + // We don't want to classify *any* DOM node as a function. + return typeof obj === "function" && typeof obj.nodeType !== "number"; + }; + + +var isWindow = function isWindow( obj ) { + return obj != null && obj === obj.window; + }; + + +var document = window.document; + + + + var preservedScriptAttributes = { + type: true, + src: true, + nonce: true, + noModule: true + }; + + function DOMEval( code, node, doc ) { + doc = doc || document; + + var i, val, + script = doc.createElement( "script" ); + + script.text = code; + if ( node ) { + for ( i in preservedScriptAttributes ) { + + // Support: Firefox 64+, Edge 18+ + // Some browsers don't support the "nonce" property on scripts. + // On the other hand, just using `getAttribute` is not enough as + // the `nonce` attribute is reset to an empty string whenever it + // becomes browsing-context connected. + // See https://github.com/whatwg/html/issues/2369 + // See https://html.spec.whatwg.org/#nonce-attributes + // The `node.getAttribute` check was added for the sake of + // `jQuery.globalEval` so that it can fake a nonce-containing node + // via an object. + val = node[ i ] || node.getAttribute && node.getAttribute( i ); + if ( val ) { + script.setAttribute( i, val ); + } + } + } + doc.head.appendChild( script ).parentNode.removeChild( script ); + } + + +function toType( obj ) { + if ( obj == null ) { + return obj + ""; + } + + // Support: Android <=2.3 only (functionish RegExp) + return typeof obj === "object" || typeof obj === "function" ? + class2type[ toString.call( obj ) ] || "object" : + typeof obj; +} +/* global Symbol */ +// Defining this global in .eslintrc.json would create a danger of using the global +// unguarded in another place, it seems safer to define global only for this module + + + +var + version = "3.5.1", + + // Define a local copy of jQuery + jQuery = function( selector, context ) { + + // The jQuery object is actually just the init constructor 'enhanced' + // Need init if jQuery is called (just allow error to be thrown if not included) + return new jQuery.fn.init( selector, context ); + }; + +jQuery.fn = jQuery.prototype = { + + // The current version of jQuery being used + jquery: version, + + constructor: jQuery, + + // The default length of a jQuery object is 0 + length: 0, + + toArray: function() { + return slice.call( this ); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + + // Return all the elements in a clean array + if ( num == null ) { + return slice.call( this ); + } + + // Return just the one element from the set + return num < 0 ? this[ num + this.length ] : this[ num ]; + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems ) { + + // Build a new jQuery matched element set + var ret = jQuery.merge( this.constructor(), elems ); + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched set. + each: function( callback ) { + return jQuery.each( this, callback ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map( this, function( elem, i ) { + return callback.call( elem, i, elem ); + } ) ); + }, + + slice: function() { + return this.pushStack( slice.apply( this, arguments ) ); + }, + + first: function() { + return this.eq( 0 ); + }, + + last: function() { + return this.eq( -1 ); + }, + + even: function() { + return this.pushStack( jQuery.grep( this, function( _elem, i ) { + return ( i + 1 ) % 2; + } ) ); + }, + + odd: function() { + return this.pushStack( jQuery.grep( this, function( _elem, i ) { + return i % 2; + } ) ); + }, + + eq: function( i ) { + var len = this.length, + j = +i + ( i < 0 ? len : 0 ); + return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); + }, + + end: function() { + return this.prevObject || this.constructor(); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: push, + sort: arr.sort, + splice: arr.splice +}; + +jQuery.extend = jQuery.fn.extend = function() { + var options, name, src, copy, copyIsArray, clone, + target = arguments[ 0 ] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + + // Skip the boolean and the target + target = arguments[ i ] || {}; + i++; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !isFunction( target ) ) { + target = {}; + } + + // Extend jQuery itself if only one argument is passed + if ( i === length ) { + target = this; + i--; + } + + for ( ; i < length; i++ ) { + + // Only deal with non-null/undefined values + if ( ( options = arguments[ i ] ) != null ) { + + // Extend the base object + for ( name in options ) { + copy = options[ name ]; + + // Prevent Object.prototype pollution + // Prevent never-ending loop + if ( name === "__proto__" || target === copy ) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if ( deep && copy && ( jQuery.isPlainObject( copy ) || + ( copyIsArray = Array.isArray( copy ) ) ) ) { + src = target[ name ]; + + // Ensure proper type for the source value + if ( copyIsArray && !Array.isArray( src ) ) { + clone = []; + } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { + clone = {}; + } else { + clone = src; + } + copyIsArray = false; + + // Never move original objects, clone them + target[ name ] = jQuery.extend( deep, clone, copy ); + + // Don't bring in undefined values + } else if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } + + // Return the modified object + return target; +}; + +jQuery.extend( { + + // Unique for each copy of jQuery on the page + expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), + + // Assume jQuery is ready without the ready module + isReady: true, + + error: function( msg ) { + throw new Error( msg ); + }, + + noop: function() {}, + + isPlainObject: function( obj ) { + var proto, Ctor; + + // Detect obvious negatives + // Use toString instead of jQuery.type to catch host objects + if ( !obj || toString.call( obj ) !== "[object Object]" ) { + return false; + } + + proto = getProto( obj ); + + // Objects with no prototype (e.g., `Object.create( null )`) are plain + if ( !proto ) { + return true; + } + + // Objects with prototype are plain iff they were constructed by a global Object function + Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; + return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; + }, + + isEmptyObject: function( obj ) { + var name; + + for ( name in obj ) { + return false; + } + return true; + }, + + // Evaluates a script in a provided context; falls back to the global one + // if not specified. + globalEval: function( code, options, doc ) { + DOMEval( code, { nonce: options && options.nonce }, doc ); + }, + + each: function( obj, callback ) { + var length, i = 0; + + if ( isArrayLike( obj ) ) { + length = obj.length; + for ( ; i < length; i++ ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } else { + for ( i in obj ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } + + return obj; + }, + + // results is for internal usage only + makeArray: function( arr, results ) { + var ret = results || []; + + if ( arr != null ) { + if ( isArrayLike( Object( arr ) ) ) { + jQuery.merge( ret, + typeof arr === "string" ? + [ arr ] : arr + ); + } else { + push.call( ret, arr ); + } + } + + return ret; + }, + + inArray: function( elem, arr, i ) { + return arr == null ? -1 : indexOf.call( arr, elem, i ); + }, + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + merge: function( first, second ) { + var len = +second.length, + j = 0, + i = first.length; + + for ( ; j < len; j++ ) { + first[ i++ ] = second[ j ]; + } + + first.length = i; + + return first; + }, + + grep: function( elems, callback, invert ) { + var callbackInverse, + matches = [], + i = 0, + length = elems.length, + callbackExpect = !invert; + + // Go through the array, only saving the items + // that pass the validator function + for ( ; i < length; i++ ) { + callbackInverse = !callback( elems[ i ], i ); + if ( callbackInverse !== callbackExpect ) { + matches.push( elems[ i ] ); + } + } + + return matches; + }, + + // arg is for internal usage only + map: function( elems, callback, arg ) { + var length, value, + i = 0, + ret = []; + + // Go through the array, translating each of the items to their new values + if ( isArrayLike( elems ) ) { + length = elems.length; + for ( ; i < length; i++ ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + + // Go through every key on the object, + } else { + for ( i in elems ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + } + + // Flatten any nested arrays + return flat( ret ); + }, + + // A global GUID counter for objects + guid: 1, + + // jQuery.support is not used in Core but other projects attach their + // properties to it so it needs to exist. + support: support +} ); + +if ( typeof Symbol === "function" ) { + jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; +} + +// Populate the class2type map +jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), +function( _i, name ) { + class2type[ "[object " + name + "]" ] = name.toLowerCase(); +} ); + +function isArrayLike( obj ) { + + // Support: real iOS 8.2 only (not reproducible in simulator) + // `in` check used to prevent JIT error (gh-2145) + // hasOwn isn't used here due to false negatives + // regarding Nodelist length in IE + var length = !!obj && "length" in obj && obj.length, + type = toType( obj ); + + if ( isFunction( obj ) || isWindow( obj ) ) { + return false; + } + + return type === "array" || length === 0 || + typeof length === "number" && length > 0 && ( length - 1 ) in obj; +} +var Sizzle = +/*! + * Sizzle CSS Selector Engine v2.3.5 + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://js.foundation/ + * + * Date: 2020-03-14 + */ +( function( window ) { +var i, + support, + Expr, + getText, + isXML, + tokenize, + compile, + select, + outermostContext, + sortInput, + hasDuplicate, + + // Local document vars + setDocument, + document, + docElem, + documentIsHTML, + rbuggyQSA, + rbuggyMatches, + matches, + contains, + + // Instance-specific data + expando = "sizzle" + 1 * new Date(), + preferredDoc = window.document, + dirruns = 0, + done = 0, + classCache = createCache(), + tokenCache = createCache(), + compilerCache = createCache(), + nonnativeSelectorCache = createCache(), + sortOrder = function( a, b ) { + if ( a === b ) { + hasDuplicate = true; + } + return 0; + }, + + // Instance methods + hasOwn = ( {} ).hasOwnProperty, + arr = [], + pop = arr.pop, + pushNative = arr.push, + push = arr.push, + slice = arr.slice, + + // Use a stripped-down indexOf as it's faster than native + // https://jsperf.com/thor-indexof-vs-for/5 + indexOf = function( list, elem ) { + var i = 0, + len = list.length; + for ( ; i < len; i++ ) { + if ( list[ i ] === elem ) { + return i; + } + } + return -1; + }, + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" + + "ismap|loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + + // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram + identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", + + // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + + // "Attribute values must be CSS identifiers [capture 5] + // or strings [capture 3 or capture 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + + whitespace + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + + // 3. anything else (capture 2) + ".*" + + ")\\)|)", + + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter + rwhitespace = new RegExp( whitespace + "+", "g" ), + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + + whitespace + "+$", "g" ), + + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), + rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + + "*" ), + rdescend = new RegExp( whitespace + "|>" ), + + rpseudo = new RegExp( pseudos ), + ridentifier = new RegExp( "^" + identifier + "$" ), + + matchExpr = { + "ID": new RegExp( "^#(" + identifier + ")" ), + "CLASS": new RegExp( "^\\.(" + identifier + ")" ), + "TAG": new RegExp( "^(" + identifier + "|[*])" ), + "ATTR": new RegExp( "^" + attributes ), + "PSEUDO": new RegExp( "^" + pseudos ), + "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), + "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), + + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext": new RegExp( "^" + whitespace + + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) + }, + + rhtml = /HTML$/i, + rinputs = /^(?:input|select|textarea|button)$/i, + rheader = /^h\d$/i, + + rnative = /^[^{]+\{\s*\[native \w/, + + // Easily-parseable/retrievable ID or TAG or CLASS selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, + + // CSS escapes + // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ), + funescape = function( escape, nonHex ) { + var high = "0x" + escape.slice( 1 ) - 0x10000; + + return nonHex ? + + // Strip the backslash prefix from a non-hex escape sequence + nonHex : + + // Replace a hexadecimal escape sequence with the encoded Unicode code point + // Support: IE <=11+ + // For values outside the Basic Multilingual Plane (BMP), manually construct a + // surrogate pair + high < 0 ? + String.fromCharCode( high + 0x10000 ) : + String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); + }, + + // CSS string/identifier serialization + // https://drafts.csswg.org/cssom/#common-serializing-idioms + rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, + fcssescape = function( ch, asCodePoint ) { + if ( asCodePoint ) { + + // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER + if ( ch === "\0" ) { + return "\uFFFD"; + } + + // Control characters and (dependent upon position) numbers get escaped as code points + return ch.slice( 0, -1 ) + "\\" + + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; + } + + // Other potentially-special ASCII characters get backslash-escaped + return "\\" + ch; + }, + + // Used for iframes + // See setDocument() + // Removing the function wrapper causes a "Permission Denied" + // error in IE + unloadHandler = function() { + setDocument(); + }, + + inDisabledFieldset = addCombinator( + function( elem ) { + return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; + }, + { dir: "parentNode", next: "legend" } + ); + +// Optimize for push.apply( _, NodeList ) +try { + push.apply( + ( arr = slice.call( preferredDoc.childNodes ) ), + preferredDoc.childNodes + ); + + // Support: Android<4.0 + // Detect silently failing push.apply + // eslint-disable-next-line no-unused-expressions + arr[ preferredDoc.childNodes.length ].nodeType; +} catch ( e ) { + push = { apply: arr.length ? + + // Leverage slice if possible + function( target, els ) { + pushNative.apply( target, slice.call( els ) ); + } : + + // Support: IE<9 + // Otherwise append directly + function( target, els ) { + var j = target.length, + i = 0; + + // Can't trust NodeList.length + while ( ( target[ j++ ] = els[ i++ ] ) ) {} + target.length = j - 1; + } + }; +} + +function Sizzle( selector, context, results, seed ) { + var m, i, elem, nid, match, groups, newSelector, + newContext = context && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or context + if ( typeof selector !== "string" || !selector || + nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { + + return results; + } + + // Try to shortcut find operations (as opposed to filters) in HTML documents + if ( !seed ) { + setDocument( context ); + context = context || document; + + if ( documentIsHTML ) { + + // If the selector is sufficiently simple, try using a "get*By*" DOM method + // (excepting DocumentFragment context, where the methods don't exist) + if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { + + // ID selector + if ( ( m = match[ 1 ] ) ) { + + // Document context + if ( nodeType === 9 ) { + if ( ( elem = context.getElementById( m ) ) ) { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( elem.id === m ) { + results.push( elem ); + return results; + } + } else { + return results; + } + + // Element context + } else { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( newContext && ( elem = newContext.getElementById( m ) ) && + contains( context, elem ) && + elem.id === m ) { + + results.push( elem ); + return results; + } + } + + // Type selector + } else if ( match[ 2 ] ) { + push.apply( results, context.getElementsByTagName( selector ) ); + return results; + + // Class selector + } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName && + context.getElementsByClassName ) { + + push.apply( results, context.getElementsByClassName( m ) ); + return results; + } + } + + // Take advantage of querySelectorAll + if ( support.qsa && + !nonnativeSelectorCache[ selector + " " ] && + ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) && + + // Support: IE 8 only + // Exclude object elements + ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) { + + newSelector = selector; + newContext = context; + + // qSA considers elements outside a scoping root when evaluating child or + // descendant combinators, which is not what we want. + // In such cases, we work around the behavior by prefixing every selector in the + // list with an ID selector referencing the scope context. + // The technique has to be used as well when a leading combinator is used + // as such selectors are not recognized by querySelectorAll. + // Thanks to Andrew Dupont for this technique. + if ( nodeType === 1 && + ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) { + + // Expand context for sibling selectors + newContext = rsibling.test( selector ) && testContext( context.parentNode ) || + context; + + // We can use :scope instead of the ID hack if the browser + // supports it & if we're not changing the context. + if ( newContext !== context || !support.scope ) { + + // Capture the context ID, setting it first if necessary + if ( ( nid = context.getAttribute( "id" ) ) ) { + nid = nid.replace( rcssescape, fcssescape ); + } else { + context.setAttribute( "id", ( nid = expando ) ); + } + } + + // Prefix every selector in the list + groups = tokenize( selector ); + i = groups.length; + while ( i-- ) { + groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + + toSelector( groups[ i ] ); + } + newSelector = groups.join( "," ); + } + + try { + push.apply( results, + newContext.querySelectorAll( newSelector ) + ); + return results; + } catch ( qsaError ) { + nonnativeSelectorCache( selector, true ); + } finally { + if ( nid === expando ) { + context.removeAttribute( "id" ); + } + } + } + } + } + + // All others + return select( selector.replace( rtrim, "$1" ), context, results, seed ); +} + +/** + * Create key-value caches of limited size + * @returns {function(string, object)} Returns the Object data after storing it on itself with + * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) + * deleting the oldest entry + */ +function createCache() { + var keys = []; + + function cache( key, value ) { + + // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) + if ( keys.push( key + " " ) > Expr.cacheLength ) { + + // Only keep the most recent entries + delete cache[ keys.shift() ]; + } + return ( cache[ key + " " ] = value ); + } + return cache; +} + +/** + * Mark a function for special use by Sizzle + * @param {Function} fn The function to mark + */ +function markFunction( fn ) { + fn[ expando ] = true; + return fn; +} + +/** + * Support testing using an element + * @param {Function} fn Passed the created element and returns a boolean result + */ +function assert( fn ) { + var el = document.createElement( "fieldset" ); + + try { + return !!fn( el ); + } catch ( e ) { + return false; + } finally { + + // Remove from its parent by default + if ( el.parentNode ) { + el.parentNode.removeChild( el ); + } + + // release memory in IE + el = null; + } +} + +/** + * Adds the same handler for all of the specified attrs + * @param {String} attrs Pipe-separated list of attributes + * @param {Function} handler The method that will be applied + */ +function addHandle( attrs, handler ) { + var arr = attrs.split( "|" ), + i = arr.length; + + while ( i-- ) { + Expr.attrHandle[ arr[ i ] ] = handler; + } +} + +/** + * Checks document order of two siblings + * @param {Element} a + * @param {Element} b + * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b + */ +function siblingCheck( a, b ) { + var cur = b && a, + diff = cur && a.nodeType === 1 && b.nodeType === 1 && + a.sourceIndex - b.sourceIndex; + + // Use IE sourceIndex if available on both nodes + if ( diff ) { + return diff; + } + + // Check if b follows a + if ( cur ) { + while ( ( cur = cur.nextSibling ) ) { + if ( cur === b ) { + return -1; + } + } + } + + return a ? 1 : -1; +} + +/** + * Returns a function to use in pseudos for input types + * @param {String} type + */ +function createInputPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for buttons + * @param {String} type + */ +function createButtonPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return ( name === "input" || name === "button" ) && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for :enabled/:disabled + * @param {Boolean} disabled true for :disabled; false for :enabled + */ +function createDisabledPseudo( disabled ) { + + // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable + return function( elem ) { + + // Only certain elements can match :enabled or :disabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled + if ( "form" in elem ) { + + // Check for inherited disabledness on relevant non-disabled elements: + // * listed form-associated elements in a disabled fieldset + // https://html.spec.whatwg.org/multipage/forms.html#category-listed + // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled + // * option elements in a disabled optgroup + // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled + // All such elements have a "form" property. + if ( elem.parentNode && elem.disabled === false ) { + + // Option elements defer to a parent optgroup if present + if ( "label" in elem ) { + if ( "label" in elem.parentNode ) { + return elem.parentNode.disabled === disabled; + } else { + return elem.disabled === disabled; + } + } + + // Support: IE 6 - 11 + // Use the isDisabled shortcut property to check for disabled fieldset ancestors + return elem.isDisabled === disabled || + + // Where there is no isDisabled, check manually + /* jshint -W018 */ + elem.isDisabled !== !disabled && + inDisabledFieldset( elem ) === disabled; + } + + return elem.disabled === disabled; + + // Try to winnow out elements that can't be disabled before trusting the disabled property. + // Some victims get caught in our net (label, legend, menu, track), but it shouldn't + // even exist on them, let alone have a boolean value. + } else if ( "label" in elem ) { + return elem.disabled === disabled; + } + + // Remaining elements are neither :enabled nor :disabled + return false; + }; +} + +/** + * Returns a function to use in pseudos for positionals + * @param {Function} fn + */ +function createPositionalPseudo( fn ) { + return markFunction( function( argument ) { + argument = +argument; + return markFunction( function( seed, matches ) { + var j, + matchIndexes = fn( [], seed.length, argument ), + i = matchIndexes.length; + + // Match elements found at the specified indexes + while ( i-- ) { + if ( seed[ ( j = matchIndexes[ i ] ) ] ) { + seed[ j ] = !( matches[ j ] = seed[ j ] ); + } + } + } ); + } ); +} + +/** + * Checks a node for validity as a Sizzle context + * @param {Element|Object=} context + * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value + */ +function testContext( context ) { + return context && typeof context.getElementsByTagName !== "undefined" && context; +} + +// Expose support vars for convenience +support = Sizzle.support = {}; + +/** + * Detects XML nodes + * @param {Element|Object} elem An element or a document + * @returns {Boolean} True iff elem is a non-HTML XML node + */ +isXML = Sizzle.isXML = function( elem ) { + var namespace = elem.namespaceURI, + docElem = ( elem.ownerDocument || elem ).documentElement; + + // Support: IE <=8 + // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes + // https://bugs.jquery.com/ticket/4833 + return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" ); +}; + +/** + * Sets document-related variables once based on the current document + * @param {Element|Object} [doc] An element or document object to use to set the document + * @returns {Object} Returns the current document + */ +setDocument = Sizzle.setDocument = function( node ) { + var hasCompare, subWindow, + doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already selected + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { + return document; + } + + // Update global variables + document = doc; + docElem = document.documentElement; + documentIsHTML = !isXML( document ); + + // Support: IE 9 - 11+, Edge 12 - 18+ + // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( preferredDoc != document && + ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { + + // Support: IE 11, Edge + if ( subWindow.addEventListener ) { + subWindow.addEventListener( "unload", unloadHandler, false ); + + // Support: IE 9 - 10 only + } else if ( subWindow.attachEvent ) { + subWindow.attachEvent( "onunload", unloadHandler ); + } + } + + // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only, + // Safari 4 - 5 only, Opera <=11.6 - 12.x only + // IE/Edge & older browsers don't support the :scope pseudo-class. + // Support: Safari 6.0 only + // Safari 6.0 supports :scope but it's an alias of :root there. + support.scope = assert( function( el ) { + docElem.appendChild( el ).appendChild( document.createElement( "div" ) ); + return typeof el.querySelectorAll !== "undefined" && + !el.querySelectorAll( ":scope fieldset div" ).length; + } ); + + /* Attributes + ---------------------------------------------------------------------- */ + + // Support: IE<8 + // Verify that getAttribute really returns attributes and not properties + // (excepting IE8 booleans) + support.attributes = assert( function( el ) { + el.className = "i"; + return !el.getAttribute( "className" ); + } ); + + /* getElement(s)By* + ---------------------------------------------------------------------- */ + + // Check if getElementsByTagName("*") returns only elements + support.getElementsByTagName = assert( function( el ) { + el.appendChild( document.createComment( "" ) ); + return !el.getElementsByTagName( "*" ).length; + } ); + + // Support: IE<9 + support.getElementsByClassName = rnative.test( document.getElementsByClassName ); + + // Support: IE<10 + // Check if getElementById returns elements by name + // The broken getElementById methods don't pick up programmatically-set names, + // so use a roundabout getElementsByName test + support.getById = assert( function( el ) { + docElem.appendChild( el ).id = expando; + return !document.getElementsByName || !document.getElementsByName( expando ).length; + } ); + + // ID filter and find + if ( support.getById ) { + Expr.filter[ "ID" ] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + return elem.getAttribute( "id" ) === attrId; + }; + }; + Expr.find[ "ID" ] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var elem = context.getElementById( id ); + return elem ? [ elem ] : []; + } + }; + } else { + Expr.filter[ "ID" ] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + var node = typeof elem.getAttributeNode !== "undefined" && + elem.getAttributeNode( "id" ); + return node && node.value === attrId; + }; + }; + + // Support: IE 6 - 7 only + // getElementById is not reliable as a find shortcut + Expr.find[ "ID" ] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var node, i, elems, + elem = context.getElementById( id ); + + if ( elem ) { + + // Verify the id attribute + node = elem.getAttributeNode( "id" ); + if ( node && node.value === id ) { + return [ elem ]; + } + + // Fall back on getElementsByName + elems = context.getElementsByName( id ); + i = 0; + while ( ( elem = elems[ i++ ] ) ) { + node = elem.getAttributeNode( "id" ); + if ( node && node.value === id ) { + return [ elem ]; + } + } + } + + return []; + } + }; + } + + // Tag + Expr.find[ "TAG" ] = support.getElementsByTagName ? + function( tag, context ) { + if ( typeof context.getElementsByTagName !== "undefined" ) { + return context.getElementsByTagName( tag ); + + // DocumentFragment nodes don't have gEBTN + } else if ( support.qsa ) { + return context.querySelectorAll( tag ); + } + } : + + function( tag, context ) { + var elem, + tmp = [], + i = 0, + + // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too + results = context.getElementsByTagName( tag ); + + // Filter out possible comments + if ( tag === "*" ) { + while ( ( elem = results[ i++ ] ) ) { + if ( elem.nodeType === 1 ) { + tmp.push( elem ); + } + } + + return tmp; + } + return results; + }; + + // Class + Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) { + if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { + return context.getElementsByClassName( className ); + } + }; + + /* QSA/matchesSelector + ---------------------------------------------------------------------- */ + + // QSA and matchesSelector support + + // matchesSelector(:active) reports false when true (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21) + // We allow this because of a bug in IE8/9 that throws an error + // whenever `document.activeElement` is accessed on an iframe + // So, we allow :focus to pass through QSA all the time to avoid the IE error + // See https://bugs.jquery.com/ticket/13378 + rbuggyQSA = []; + + if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) { + + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert( function( el ) { + + var input; + + // Select is set to empty string on purpose + // This is to test IE's treatment of not explicitly + // setting a boolean content attribute, + // since its presence should be enough + // https://bugs.jquery.com/ticket/12359 + docElem.appendChild( el ).innerHTML = "" + + ""; + + // Support: IE8, Opera 11-12.16 + // Nothing should be selected when empty strings follow ^= or $= or *= + // The test attribute must be unknown in Opera but "safe" for WinRT + // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section + if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) { + rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); + } + + // Support: IE8 + // Boolean attributes and "value" are not treated correctly + if ( !el.querySelectorAll( "[selected]" ).length ) { + rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); + } + + // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ + if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { + rbuggyQSA.push( "~=" ); + } + + // Support: IE 11+, Edge 15 - 18+ + // IE 11/Edge don't find elements on a `[name='']` query in some cases. + // Adding a temporary attribute to the document before the selection works + // around the issue. + // Interestingly, IE 10 & older don't seem to have the issue. + input = document.createElement( "input" ); + input.setAttribute( "name", "" ); + el.appendChild( input ); + if ( !el.querySelectorAll( "[name='']" ).length ) { + rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + + whitespace + "*(?:''|\"\")" ); + } + + // Webkit/Opera - :checked should return selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see later tests + if ( !el.querySelectorAll( ":checked" ).length ) { + rbuggyQSA.push( ":checked" ); + } + + // Support: Safari 8+, iOS 8+ + // https://bugs.webkit.org/show_bug.cgi?id=136851 + // In-page `selector#id sibling-combinator selector` fails + if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { + rbuggyQSA.push( ".#.+[+~]" ); + } + + // Support: Firefox <=3.6 - 5 only + // Old Firefox doesn't throw on a badly-escaped identifier. + el.querySelectorAll( "\\\f" ); + rbuggyQSA.push( "[\\r\\n\\f]" ); + } ); + + assert( function( el ) { + el.innerHTML = "" + + ""; + + // Support: Windows 8 Native Apps + // The type and name attributes are restricted during .innerHTML assignment + var input = document.createElement( "input" ); + input.setAttribute( "type", "hidden" ); + el.appendChild( input ).setAttribute( "name", "D" ); + + // Support: IE8 + // Enforce case-sensitivity of name attribute + if ( el.querySelectorAll( "[name=d]" ).length ) { + rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); + } + + // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) + // IE8 throws error here and will not see later tests + if ( el.querySelectorAll( ":enabled" ).length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: IE9-11+ + // IE's :disabled selector does not pick up the children of disabled fieldsets + docElem.appendChild( el ).disabled = true; + if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: Opera 10 - 11 only + // Opera 10-11 does not throw on post-comma invalid pseudos + el.querySelectorAll( "*,:x" ); + rbuggyQSA.push( ",.*:" ); + } ); + } + + if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches || + docElem.webkitMatchesSelector || + docElem.mozMatchesSelector || + docElem.oMatchesSelector || + docElem.msMatchesSelector ) ) ) ) { + + assert( function( el ) { + + // Check to see if it's possible to do matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call( el, "*" ); + + // This should fail with an exception + // Gecko does not error, returns false instead + matches.call( el, "[s!='']:x" ); + rbuggyMatches.push( "!=", pseudos ); + } ); + } + + rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); + rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) ); + + /* Contains + ---------------------------------------------------------------------- */ + hasCompare = rnative.test( docElem.compareDocumentPosition ); + + // Element contains another + // Purposefully self-exclusive + // As in, an element does not contain itself + contains = hasCompare || rnative.test( docElem.contains ) ? + function( a, b ) { + var adown = a.nodeType === 9 ? a.documentElement : a, + bup = b && b.parentNode; + return a === bup || !!( bup && bup.nodeType === 1 && ( + adown.contains ? + adown.contains( bup ) : + a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 + ) ); + } : + function( a, b ) { + if ( b ) { + while ( ( b = b.parentNode ) ) { + if ( b === a ) { + return true; + } + } + } + return false; + }; + + /* Sorting + ---------------------------------------------------------------------- */ + + // Document order sorting + sortOrder = hasCompare ? + function( a, b ) { + + // Flag for duplicate removal + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + // Sort on method existence if only one input has compareDocumentPosition + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if ( compare ) { + return compare; + } + + // Calculate position if both inputs belong to the same document + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? + a.compareDocumentPosition( b ) : + + // Otherwise we know they are disconnected + 1; + + // Disconnected nodes + if ( compare & 1 || + ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { + + // Choose the first element that is related to our preferred document + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( a == document || a.ownerDocument == preferredDoc && + contains( preferredDoc, a ) ) { + return -1; + } + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( b == document || b.ownerDocument == preferredDoc && + contains( preferredDoc, b ) ) { + return 1; + } + + // Maintain original order + return sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + } + + return compare & 4 ? -1 : 1; + } : + function( a, b ) { + + // Exit early if the nodes are identical + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + var cur, + i = 0, + aup = a.parentNode, + bup = b.parentNode, + ap = [ a ], + bp = [ b ]; + + // Parentless nodes are either documents or disconnected + if ( !aup || !bup ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + /* eslint-disable eqeqeq */ + return a == document ? -1 : + b == document ? 1 : + /* eslint-enable eqeqeq */ + aup ? -1 : + bup ? 1 : + sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + + // If the nodes are siblings, we can do a quick check + } else if ( aup === bup ) { + return siblingCheck( a, b ); + } + + // Otherwise we need full lists of their ancestors for comparison + cur = a; + while ( ( cur = cur.parentNode ) ) { + ap.unshift( cur ); + } + cur = b; + while ( ( cur = cur.parentNode ) ) { + bp.unshift( cur ); + } + + // Walk down the tree looking for a discrepancy + while ( ap[ i ] === bp[ i ] ) { + i++; + } + + return i ? + + // Do a sibling check if the nodes have a common ancestor + siblingCheck( ap[ i ], bp[ i ] ) : + + // Otherwise nodes in our document sort first + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + /* eslint-disable eqeqeq */ + ap[ i ] == preferredDoc ? -1 : + bp[ i ] == preferredDoc ? 1 : + /* eslint-enable eqeqeq */ + 0; + }; + + return document; +}; + +Sizzle.matches = function( expr, elements ) { + return Sizzle( expr, null, null, elements ); +}; + +Sizzle.matchesSelector = function( elem, expr ) { + setDocument( elem ); + + if ( support.matchesSelector && documentIsHTML && + !nonnativeSelectorCache[ expr + " " ] && + ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && + ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { + + try { + var ret = matches.call( elem, expr ); + + // IE 9's matchesSelector returns false on disconnected nodes + if ( ret || support.disconnectedMatch || + + // As well, disconnected nodes are said to be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11 ) { + return ret; + } + } catch ( e ) { + nonnativeSelectorCache( expr, true ); + } + } + + return Sizzle( expr, document, null, [ elem ] ).length > 0; +}; + +Sizzle.contains = function( context, elem ) { + + // Set document vars if needed + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( ( context.ownerDocument || context ) != document ) { + setDocument( context ); + } + return contains( context, elem ); +}; + +Sizzle.attr = function( elem, name ) { + + // Set document vars if needed + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( ( elem.ownerDocument || elem ) != document ) { + setDocument( elem ); + } + + var fn = Expr.attrHandle[ name.toLowerCase() ], + + // Don't get fooled by Object.prototype properties (jQuery #13807) + val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? + fn( elem, name, !documentIsHTML ) : + undefined; + + return val !== undefined ? + val : + support.attributes || !documentIsHTML ? + elem.getAttribute( name ) : + ( val = elem.getAttributeNode( name ) ) && val.specified ? + val.value : + null; +}; + +Sizzle.escape = function( sel ) { + return ( sel + "" ).replace( rcssescape, fcssescape ); +}; + +Sizzle.error = function( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +}; + +/** + * Document sorting and removing duplicates + * @param {ArrayLike} results + */ +Sizzle.uniqueSort = function( results ) { + var elem, + duplicates = [], + j = 0, + i = 0; + + // Unless we *know* we can detect duplicates, assume their presence + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice( 0 ); + results.sort( sortOrder ); + + if ( hasDuplicate ) { + while ( ( elem = results[ i++ ] ) ) { + if ( elem === results[ i ] ) { + j = duplicates.push( i ); + } + } + while ( j-- ) { + results.splice( duplicates[ j ], 1 ); + } + } + + // Clear input after sorting to release objects + // See https://github.com/jquery/sizzle/pull/225 + sortInput = null; + + return results; +}; + +/** + * Utility function for retrieving the text value of an array of DOM nodes + * @param {Array|Element} elem + */ +getText = Sizzle.getText = function( elem ) { + var node, + ret = "", + i = 0, + nodeType = elem.nodeType; + + if ( !nodeType ) { + + // If no nodeType, this is expected to be an array + while ( ( node = elem[ i++ ] ) ) { + + // Do not traverse comment nodes + ret += getText( node ); + } + } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { + + // Use textContent for elements + // innerText usage removed for consistency of new lines (jQuery #11153) + if ( typeof elem.textContent === "string" ) { + return elem.textContent; + } else { + + // Traverse its children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + ret += getText( elem ); + } + } + } else if ( nodeType === 3 || nodeType === 4 ) { + return elem.nodeValue; + } + + // Do not include comment or processing instruction nodes + + return ret; +}; + +Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength: 50, + + createPseudo: markFunction, + + match: matchExpr, + + attrHandle: {}, + + find: {}, + + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + + preFilter: { + "ATTR": function( match ) { + match[ 1 ] = match[ 1 ].replace( runescape, funescape ); + + // Move the given value to match[3] whether quoted or unquoted + match[ 3 ] = ( match[ 3 ] || match[ 4 ] || + match[ 5 ] || "" ).replace( runescape, funescape ); + + if ( match[ 2 ] === "~=" ) { + match[ 3 ] = " " + match[ 3 ] + " "; + } + + return match.slice( 0, 4 ); + }, + + "CHILD": function( match ) { + + /* matches from matchExpr["CHILD"] + 1 type (only|nth|...) + 2 what (child|of-type) + 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) + 4 xn-component of xn+y argument ([+-]?\d*n|) + 5 sign of xn-component + 6 x of xn-component + 7 sign of y-component + 8 y of y-component + */ + match[ 1 ] = match[ 1 ].toLowerCase(); + + if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { + + // nth-* requires argument + if ( !match[ 3 ] ) { + Sizzle.error( match[ 0 ] ); + } + + // numeric x and y parameters for Expr.filter.CHILD + // remember that false/true cast respectively to 0/1 + match[ 4 ] = +( match[ 4 ] ? + match[ 5 ] + ( match[ 6 ] || 1 ) : + 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) ); + match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); + + // other types prohibit arguments + } else if ( match[ 3 ] ) { + Sizzle.error( match[ 0 ] ); + } + + return match; + }, + + "PSEUDO": function( match ) { + var excess, + unquoted = !match[ 6 ] && match[ 2 ]; + + if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) { + return null; + } + + // Accept quoted arguments as-is + if ( match[ 3 ] ) { + match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; + + // Strip excess characters from unquoted arguments + } else if ( unquoted && rpseudo.test( unquoted ) && + + // Get excess from tokenize (recursively) + ( excess = tokenize( unquoted, true ) ) && + + // advance to the next closing parenthesis + ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { + + // excess is a negative index + match[ 0 ] = match[ 0 ].slice( 0, excess ); + match[ 2 ] = unquoted.slice( 0, excess ); + } + + // Return only captures needed by the pseudo filter method (type and argument) + return match.slice( 0, 3 ); + } + }, + + filter: { + + "TAG": function( nodeNameSelector ) { + var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); + return nodeNameSelector === "*" ? + function() { + return true; + } : + function( elem ) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS": function( className ) { + var pattern = classCache[ className + " " ]; + + return pattern || + ( pattern = new RegExp( "(^|" + whitespace + + ")" + className + "(" + whitespace + "|$)" ) ) && classCache( + className, function( elem ) { + return pattern.test( + typeof elem.className === "string" && elem.className || + typeof elem.getAttribute !== "undefined" && + elem.getAttribute( "class" ) || + "" + ); + } ); + }, + + "ATTR": function( name, operator, check ) { + return function( elem ) { + var result = Sizzle.attr( elem, name ); + + if ( result == null ) { + return operator === "!="; + } + if ( !operator ) { + return true; + } + + result += ""; + + /* eslint-disable max-len */ + + return operator === "=" ? result === check : + operator === "!=" ? result !== check : + operator === "^=" ? check && result.indexOf( check ) === 0 : + operator === "*=" ? check && result.indexOf( check ) > -1 : + operator === "$=" ? check && result.slice( -check.length ) === check : + operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : + operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : + false; + /* eslint-enable max-len */ + + }; + }, + + "CHILD": function( type, what, _argument, first, last ) { + var simple = type.slice( 0, 3 ) !== "nth", + forward = type.slice( -4 ) !== "last", + ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function( elem ) { + return !!elem.parentNode; + } : + + function( elem, _context, xml ) { + var cache, uniqueCache, outerCache, node, nodeIndex, start, + dir = simple !== forward ? "nextSibling" : "previousSibling", + parent = elem.parentNode, + name = ofType && elem.nodeName.toLowerCase(), + useCache = !xml && !ofType, + diff = false; + + if ( parent ) { + + // :(first|last|only)-(child|of-type) + if ( simple ) { + while ( dir ) { + node = elem; + while ( ( node = node[ dir ] ) ) { + if ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) { + + return false; + } + } + + // Reverse direction for :only-* (if we haven't yet done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) stores cache data on `parent` + if ( forward && useCache ) { + + // Seek `elem` from a previously-cached index + + // ...in a gzip-friendly way + node = parent; + outerCache = node[ expando ] || ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex && cache[ 2 ]; + node = nodeIndex && parent.childNodes[ nodeIndex ]; + + while ( ( node = ++nodeIndex && node && node[ dir ] || + + // Fallback to seeking `elem` from the start + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + // When found, cache indexes on `parent` and break + if ( node.nodeType === 1 && ++diff && node === elem ) { + uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + + // Use previously-cached element index if available + if ( useCache ) { + + // ...in a gzip-friendly way + node = elem; + outerCache = node[ expando ] || ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or :nth-last-child(...) or :nth(-last)?-of-type(...) + if ( diff === false ) { + + // Use the same loop as above to seek `elem` from the start + while ( ( node = ++nodeIndex && node && node[ dir ] || + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + if ( ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) && + ++diff ) { + + // Cache the index of each encountered element + if ( useCache ) { + outerCache = node[ expando ] || + ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + uniqueCache[ type ] = [ dirruns, diff ]; + } + + if ( node === elem ) { + break; + } + } + } + } + } + + // Incorporate the offset, then check against cycle size + diff -= last; + return diff === first || ( diff % first === 0 && diff / first >= 0 ); + } + }; + }, + + "PSEUDO": function( pseudo, argument ) { + + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters + // Remember that setFilters inherits from pseudos + var args, + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || + Sizzle.error( "unsupported pseudo: " + pseudo ); + + // The user may use createPseudo to indicate that + // arguments are needed to create the filter function + // just as Sizzle does + if ( fn[ expando ] ) { + return fn( argument ); + } + + // But maintain support for old signatures + if ( fn.length > 1 ) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? + markFunction( function( seed, matches ) { + var idx, + matched = fn( seed, argument ), + i = matched.length; + while ( i-- ) { + idx = indexOf( seed, matched[ i ] ); + seed[ idx ] = !( matches[ idx ] = matched[ i ] ); + } + } ) : + function( elem ) { + return fn( elem, 0, args ); + }; + } + + return fn; + } + }, + + pseudos: { + + // Potentially complex pseudos + "not": markFunction( function( selector ) { + + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], + results = [], + matcher = compile( selector.replace( rtrim, "$1" ) ); + + return matcher[ expando ] ? + markFunction( function( seed, matches, _context, xml ) { + var elem, + unmatched = matcher( seed, null, xml, [] ), + i = seed.length; + + // Match elements unmatched by `matcher` + while ( i-- ) { + if ( ( elem = unmatched[ i ] ) ) { + seed[ i ] = !( matches[ i ] = elem ); + } + } + } ) : + function( elem, _context, xml ) { + input[ 0 ] = elem; + matcher( input, null, xml, results ); + + // Don't keep the element (issue #299) + input[ 0 ] = null; + return !results.pop(); + }; + } ), + + "has": markFunction( function( selector ) { + return function( elem ) { + return Sizzle( selector, elem ).length > 0; + }; + } ), + + "contains": markFunction( function( text ) { + text = text.replace( runescape, funescape ); + return function( elem ) { + return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1; + }; + } ), + + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang": markFunction( function( lang ) { + + // lang value must be a valid identifier + if ( !ridentifier.test( lang || "" ) ) { + Sizzle.error( "unsupported lang: " + lang ); + } + lang = lang.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + var elemLang; + do { + if ( ( elemLang = documentIsHTML ? + elem.lang : + elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; + } + } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); + return false; + }; + } ), + + // Miscellaneous + "target": function( elem ) { + var hash = window.location && window.location.hash; + return hash && hash.slice( 1 ) === elem.id; + }, + + "root": function( elem ) { + return elem === docElem; + }, + + "focus": function( elem ) { + return elem === document.activeElement && + ( !document.hasFocus || document.hasFocus() ) && + !!( elem.type || elem.href || ~elem.tabIndex ); + }, + + // Boolean properties + "enabled": createDisabledPseudo( false ), + "disabled": createDisabledPseudo( true ), + + "checked": function( elem ) { + + // In CSS3, :checked should return both checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return ( nodeName === "input" && !!elem.checked ) || + ( nodeName === "option" && !!elem.selected ); + }, + + "selected": function( elem ) { + + // Accessing this property makes selected-by-default + // options in Safari work properly + if ( elem.parentNode ) { + // eslint-disable-next-line no-unused-expressions + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + "empty": function( elem ) { + + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), + // but not by others (comment: 8; processing instruction: 7; etc.) + // nodeType < 6 works because attributes (2) do not appear as children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + if ( elem.nodeType < 6 ) { + return false; + } + } + return true; + }, + + "parent": function( elem ) { + return !Expr.pseudos[ "empty" ]( elem ); + }, + + // Element/input types + "header": function( elem ) { + return rheader.test( elem.nodeName ); + }, + + "input": function( elem ) { + return rinputs.test( elem.nodeName ); + }, + + "button": function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text": function( elem ) { + var attr; + return elem.nodeName.toLowerCase() === "input" && + elem.type === "text" && + + // Support: IE<8 + // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" + ( ( attr = elem.getAttribute( "type" ) ) == null || + attr.toLowerCase() === "text" ); + }, + + // Position-in-collection + "first": createPositionalPseudo( function() { + return [ 0 ]; + } ), + + "last": createPositionalPseudo( function( _matchIndexes, length ) { + return [ length - 1 ]; + } ), + + "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) { + return [ argument < 0 ? argument + length : argument ]; + } ), + + "even": createPositionalPseudo( function( matchIndexes, length ) { + var i = 0; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "odd": createPositionalPseudo( function( matchIndexes, length ) { + var i = 1; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "lt": createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? + argument + length : + argument > length ? + length : + argument; + for ( ; --i >= 0; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "gt": createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; ++i < length; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ) + } +}; + +Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ]; + +// Add button/input type pseudos +for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { + Expr.pseudos[ i ] = createInputPseudo( i ); +} +for ( i in { submit: true, reset: true } ) { + Expr.pseudos[ i ] = createButtonPseudo( i ); +} + +// Easy API for creating new setFilters +function setFilters() {} +setFilters.prototype = Expr.filters = Expr.pseudos; +Expr.setFilters = new setFilters(); + +tokenize = Sizzle.tokenize = function( selector, parseOnly ) { + var matched, match, tokens, type, + soFar, groups, preFilters, + cached = tokenCache[ selector + " " ]; + + if ( cached ) { + return parseOnly ? 0 : cached.slice( 0 ); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while ( soFar ) { + + // Comma and first run + if ( !matched || ( match = rcomma.exec( soFar ) ) ) { + if ( match ) { + + // Don't consume trailing commas as valid + soFar = soFar.slice( match[ 0 ].length ) || soFar; + } + groups.push( ( tokens = [] ) ); + } + + matched = false; + + // Combinators + if ( ( match = rcombinators.exec( soFar ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + + // Cast descendant combinators to space + type: match[ 0 ].replace( rtrim, " " ) + } ); + soFar = soFar.slice( matched.length ); + } + + // Filters + for ( type in Expr.filter ) { + if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || + ( match = preFilters[ type ]( match ) ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + type: type, + matches: match + } ); + soFar = soFar.slice( matched.length ); + } + } + + if ( !matched ) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? + soFar.length : + soFar ? + Sizzle.error( selector ) : + + // Cache the tokens + tokenCache( selector, groups ).slice( 0 ); +}; + +function toSelector( tokens ) { + var i = 0, + len = tokens.length, + selector = ""; + for ( ; i < len; i++ ) { + selector += tokens[ i ].value; + } + return selector; +} + +function addCombinator( matcher, combinator, base ) { + var dir = combinator.dir, + skip = combinator.next, + key = skip || dir, + checkNonElements = base && key === "parentNode", + doneName = done++; + + return combinator.first ? + + // Check against closest ancestor/preceding element + function( elem, context, xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + return matcher( elem, context, xml ); + } + } + return false; + } : + + // Check against all ancestor/preceding elements + function( elem, context, xml ) { + var oldCache, uniqueCache, outerCache, + newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching + if ( xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + if ( matcher( elem, context, xml ) ) { + return true; + } + } + } + } else { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + outerCache = elem[ expando ] || ( elem[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ elem.uniqueID ] || + ( outerCache[ elem.uniqueID ] = {} ); + + if ( skip && skip === elem.nodeName.toLowerCase() ) { + elem = elem[ dir ] || elem; + } else if ( ( oldCache = uniqueCache[ key ] ) && + oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { + + // Assign to newCache so results back-propagate to previous elements + return ( newCache[ 2 ] = oldCache[ 2 ] ); + } else { + + // Reuse newcache so results back-propagate to previous elements + uniqueCache[ key ] = newCache; + + // A match means we're done; a fail means we have to keep checking + if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { + return true; + } + } + } + } + } + return false; + }; +} + +function elementMatcher( matchers ) { + return matchers.length > 1 ? + function( elem, context, xml ) { + var i = matchers.length; + while ( i-- ) { + if ( !matchers[ i ]( elem, context, xml ) ) { + return false; + } + } + return true; + } : + matchers[ 0 ]; +} + +function multipleContexts( selector, contexts, results ) { + var i = 0, + len = contexts.length; + for ( ; i < len; i++ ) { + Sizzle( selector, contexts[ i ], results ); + } + return results; +} + +function condense( unmatched, map, filter, context, xml ) { + var elem, + newUnmatched = [], + i = 0, + len = unmatched.length, + mapped = map != null; + + for ( ; i < len; i++ ) { + if ( ( elem = unmatched[ i ] ) ) { + if ( !filter || filter( elem, context, xml ) ) { + newUnmatched.push( elem ); + if ( mapped ) { + map.push( i ); + } + } + } + } + + return newUnmatched; +} + +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { + if ( postFilter && !postFilter[ expando ] ) { + postFilter = setMatcher( postFilter ); + } + if ( postFinder && !postFinder[ expando ] ) { + postFinder = setMatcher( postFinder, postSelector ); + } + return markFunction( function( seed, results, context, xml ) { + var temp, i, elem, + preMap = [], + postMap = [], + preexisting = results.length, + + // Get initial elements from seed or context + elems = seed || multipleContexts( + selector || "*", + context.nodeType ? [ context ] : context, + [] + ), + + // Prefilter to get matcher input, preserving a map for seed-results synchronization + matcherIn = preFilter && ( seed || !selector ) ? + condense( elems, preMap, preFilter, context, xml ) : + elems, + + matcherOut = matcher ? + + // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, + postFinder || ( seed ? preFilter : preexisting || postFilter ) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : + matcherIn; + + // Find primary matches + if ( matcher ) { + matcher( matcherIn, matcherOut, context, xml ); + } + + // Apply postFilter + if ( postFilter ) { + temp = condense( matcherOut, postMap ); + postFilter( temp, [], context, xml ); + + // Un-match failing elements by moving them back to matcherIn + i = temp.length; + while ( i-- ) { + if ( ( elem = temp[ i ] ) ) { + matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); + } + } + } + + if ( seed ) { + if ( postFinder || preFilter ) { + if ( postFinder ) { + + // Get the final matcherOut by condensing this intermediate into postFinder contexts + temp = []; + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) ) { + + // Restore matcherIn since elem is not yet a final match + temp.push( ( matcherIn[ i ] = elem ) ); + } + } + postFinder( null, ( matcherOut = [] ), temp, xml ); + } + + // Move matched elements from seed to results to keep them synchronized + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) && + ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) { + + seed[ temp ] = !( results[ temp ] = elem ); + } + } + } + + // Add elements to results, through postFinder if defined + } else { + matcherOut = condense( + matcherOut === results ? + matcherOut.splice( preexisting, matcherOut.length ) : + matcherOut + ); + if ( postFinder ) { + postFinder( null, results, matcherOut, xml ); + } else { + push.apply( results, matcherOut ); + } + } + } ); +} + +function matcherFromTokens( tokens ) { + var checkContext, matcher, j, + len = tokens.length, + leadingRelative = Expr.relative[ tokens[ 0 ].type ], + implicitRelative = leadingRelative || Expr.relative[ " " ], + i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements are reachable from top-level context(s) + matchContext = addCombinator( function( elem ) { + return elem === checkContext; + }, implicitRelative, true ), + matchAnyContext = addCombinator( function( elem ) { + return indexOf( checkContext, elem ) > -1; + }, implicitRelative, true ), + matchers = [ function( elem, context, xml ) { + var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( + ( checkContext = context ).nodeType ? + matchContext( elem, context, xml ) : + matchAnyContext( elem, context, xml ) ); + + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for ( ; i < len; i++ ) { + if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { + matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; + } else { + matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); + + // Return special upon seeing a positional matcher + if ( matcher[ expando ] ) { + + // Find the next relative operator (if any) for proper handling + j = ++i; + for ( ; j < len; j++ ) { + if ( Expr.relative[ tokens[ j ].type ] ) { + break; + } + } + return setMatcher( + i > 1 && elementMatcher( matchers ), + i > 1 && toSelector( + + // If the preceding token was a descendant combinator, insert an implicit any-element `*` + tokens + .slice( 0, i - 1 ) + .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) + ).replace( rtrim, "$1" ), + matcher, + i < j && matcherFromTokens( tokens.slice( i, j ) ), + j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), + j < len && toSelector( tokens ) + ); + } + matchers.push( matcher ); + } + } + + return elementMatcher( matchers ); +} + +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { + var bySet = setMatchers.length > 0, + byElement = elementMatchers.length > 0, + superMatcher = function( seed, context, xml, results, outermost ) { + var elem, j, matcher, + matchedCount = 0, + i = "0", + unmatched = seed && [], + setMatched = [], + contextBackup = outermostContext, + + // We must always have either seed elements or outermost context + elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ), + + // Use integer dirruns iff this is the outermost matcher + dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), + len = elems.length; + + if ( outermost ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + outermostContext = context == document || context || outermost; + } + + // Add elements passing elementMatchers directly to results + // Support: IE<9, Safari + // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id + for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { + if ( byElement && elem ) { + j = 0; + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( !context && elem.ownerDocument != document ) { + setDocument( elem ); + xml = !documentIsHTML; + } + while ( ( matcher = elementMatchers[ j++ ] ) ) { + if ( matcher( elem, context || document, xml ) ) { + results.push( elem ); + break; + } + } + if ( outermost ) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if ( bySet ) { + + // They will have gone through all possible matchers + if ( ( elem = !matcher && elem ) ) { + matchedCount--; + } + + // Lengthen the array for every element, matched or not + if ( seed ) { + unmatched.push( elem ); + } + } + } + + // `i` is now the count of elements visited above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that + // case, which will result in a "00" `matchedCount` that differs from `i` but is also + // numerically zero. + if ( bySet && i !== matchedCount ) { + j = 0; + while ( ( matcher = setMatchers[ j++ ] ) ) { + matcher( unmatched, setMatched, context, xml ); + } + + if ( seed ) { + + // Reintegrate element matches to eliminate the need for sorting + if ( matchedCount > 0 ) { + while ( i-- ) { + if ( !( unmatched[ i ] || setMatched[ i ] ) ) { + setMatched[ i ] = pop.call( results ); + } + } + } + + // Discard index placeholder values to get only actual matches + setMatched = condense( setMatched ); + } + + // Add matches to results + push.apply( results, setMatched ); + + // Seedless set matches succeeding multiple successful matchers stipulate sorting + if ( outermost && !seed && setMatched.length > 0 && + ( matchedCount + setMatchers.length ) > 1 ) { + + Sizzle.uniqueSort( results ); + } + } + + // Override manipulation of globals by nested matchers + if ( outermost ) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? + markFunction( superMatcher ) : + superMatcher; +} + +compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { + var i, + setMatchers = [], + elementMatchers = [], + cached = compilerCache[ selector + " " ]; + + if ( !cached ) { + + // Generate a function of recursive functions that can be used to check each element + if ( !match ) { + match = tokenize( selector ); + } + i = match.length; + while ( i-- ) { + cached = matcherFromTokens( match[ i ] ); + if ( cached[ expando ] ) { + setMatchers.push( cached ); + } else { + elementMatchers.push( cached ); + } + } + + // Cache the compiled function + cached = compilerCache( + selector, + matcherFromGroupMatchers( elementMatchers, setMatchers ) + ); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; +}; + +/** + * A low-level selection function that works with Sizzle's compiled + * selector functions + * @param {String|Function} selector A selector or a pre-compiled + * selector function built with Sizzle.compile + * @param {Element} context + * @param {Array} [results] + * @param {Array} [seed] A set of elements to match against + */ +select = Sizzle.select = function( selector, context, results, seed ) { + var i, tokens, token, type, find, + compiled = typeof selector === "function" && selector, + match = !seed && tokenize( ( selector = compiled.selector || selector ) ); + + results = results || []; + + // Try to minimize operations if there is only one selector in the list and no seed + // (the latter of which guarantees us context) + if ( match.length === 1 ) { + + // Reduce context if the leading compound selector is an ID + tokens = match[ 0 ] = match[ 0 ].slice( 0 ); + if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && + context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { + + context = ( Expr.find[ "ID" ]( token.matches[ 0 ] + .replace( runescape, funescape ), context ) || [] )[ 0 ]; + if ( !context ) { + return results; + + // Precompiled matchers will still verify ancestry, so step up a level + } else if ( compiled ) { + context = context.parentNode; + } + + selector = selector.slice( tokens.shift().value.length ); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length; + while ( i-- ) { + token = tokens[ i ]; + + // Abort if we hit a combinator + if ( Expr.relative[ ( type = token.type ) ] ) { + break; + } + if ( ( find = Expr.find[ type ] ) ) { + + // Search, expanding context for leading sibling combinators + if ( ( seed = find( + token.matches[ 0 ].replace( runescape, funescape ), + rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) || + context + ) ) ) { + + // If seed is empty or no tokens remain, we can return early + tokens.splice( i, 1 ); + selector = seed.length && toSelector( tokens ); + if ( !selector ) { + push.apply( results, seed ); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one is not provided + // Provide `match` to avoid retokenization if we modified the selector above + ( compiled || compile( selector, match ) )( + seed, + context, + !documentIsHTML, + results, + !context || rsibling.test( selector ) && testContext( context.parentNode ) || context + ); + return results; +}; + +// One-time assignments + +// Sort stability +support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; + +// Support: Chrome 14-35+ +// Always assume duplicates if they aren't passed to the comparison function +support.detectDuplicates = !!hasDuplicate; + +// Initialize against the default document +setDocument(); + +// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) +// Detached nodes confoundingly follow *each other* +support.sortDetached = assert( function( el ) { + + // Should return 1, but returns 4 (following) + return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; +} ); + +// Support: IE<8 +// Prevent attribute/property "interpolation" +// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx +if ( !assert( function( el ) { + el.innerHTML = ""; + return el.firstChild.getAttribute( "href" ) === "#"; +} ) ) { + addHandle( "type|href|height|width", function( elem, name, isXML ) { + if ( !isXML ) { + return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); + } + } ); +} + +// Support: IE<9 +// Use defaultValue in place of getAttribute("value") +if ( !support.attributes || !assert( function( el ) { + el.innerHTML = ""; + el.firstChild.setAttribute( "value", "" ); + return el.firstChild.getAttribute( "value" ) === ""; +} ) ) { + addHandle( "value", function( elem, _name, isXML ) { + if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { + return elem.defaultValue; + } + } ); +} + +// Support: IE<9 +// Use getAttributeNode to fetch booleans when getAttribute lies +if ( !assert( function( el ) { + return el.getAttribute( "disabled" ) == null; +} ) ) { + addHandle( booleans, function( elem, name, isXML ) { + var val; + if ( !isXML ) { + return elem[ name ] === true ? name.toLowerCase() : + ( val = elem.getAttributeNode( name ) ) && val.specified ? + val.value : + null; + } + } ); +} + +return Sizzle; + +} )( window ); + + + +jQuery.find = Sizzle; +jQuery.expr = Sizzle.selectors; + +// Deprecated +jQuery.expr[ ":" ] = jQuery.expr.pseudos; +jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; +jQuery.text = Sizzle.getText; +jQuery.isXMLDoc = Sizzle.isXML; +jQuery.contains = Sizzle.contains; +jQuery.escapeSelector = Sizzle.escape; + + + + +var dir = function( elem, dir, until ) { + var matched = [], + truncate = until !== undefined; + + while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { + if ( elem.nodeType === 1 ) { + if ( truncate && jQuery( elem ).is( until ) ) { + break; + } + matched.push( elem ); + } + } + return matched; +}; + + +var siblings = function( n, elem ) { + var matched = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType === 1 && n !== elem ) { + matched.push( n ); + } + } + + return matched; +}; + + +var rneedsContext = jQuery.expr.match.needsContext; + + + +function nodeName( elem, name ) { + + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + +}; +var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); + + + +// Implement the identical functionality for filter and not +function winnow( elements, qualifier, not ) { + if ( isFunction( qualifier ) ) { + return jQuery.grep( elements, function( elem, i ) { + return !!qualifier.call( elem, i, elem ) !== not; + } ); + } + + // Single element + if ( qualifier.nodeType ) { + return jQuery.grep( elements, function( elem ) { + return ( elem === qualifier ) !== not; + } ); + } + + // Arraylike of elements (jQuery, arguments, Array) + if ( typeof qualifier !== "string" ) { + return jQuery.grep( elements, function( elem ) { + return ( indexOf.call( qualifier, elem ) > -1 ) !== not; + } ); + } + + // Filtered directly for both simple and complex selectors + return jQuery.filter( qualifier, elements, not ); +} + +jQuery.filter = function( expr, elems, not ) { + var elem = elems[ 0 ]; + + if ( not ) { + expr = ":not(" + expr + ")"; + } + + if ( elems.length === 1 && elem.nodeType === 1 ) { + return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; + } + + return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { + return elem.nodeType === 1; + } ) ); +}; + +jQuery.fn.extend( { + find: function( selector ) { + var i, ret, + len = this.length, + self = this; + + if ( typeof selector !== "string" ) { + return this.pushStack( jQuery( selector ).filter( function() { + for ( i = 0; i < len; i++ ) { + if ( jQuery.contains( self[ i ], this ) ) { + return true; + } + } + } ) ); + } + + ret = this.pushStack( [] ); + + for ( i = 0; i < len; i++ ) { + jQuery.find( selector, self[ i ], ret ); + } + + return len > 1 ? jQuery.uniqueSort( ret ) : ret; + }, + filter: function( selector ) { + return this.pushStack( winnow( this, selector || [], false ) ); + }, + not: function( selector ) { + return this.pushStack( winnow( this, selector || [], true ) ); + }, + is: function( selector ) { + return !!winnow( + this, + + // If this is a positional/relative selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + typeof selector === "string" && rneedsContext.test( selector ) ? + jQuery( selector ) : + selector || [], + false + ).length; + } +} ); + + +// Initialize a jQuery object + + +// A central reference to the root jQuery(document) +var rootjQuery, + + // A simple way to check for HTML strings + // Prioritize #id over to avoid XSS via location.hash (#9521) + // Strict HTML recognition (#11290: must start with <) + // Shortcut simple #id case for speed + rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, + + init = jQuery.fn.init = function( selector, context, root ) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if ( !selector ) { + return this; + } + + // Method init() accepts an alternate rootjQuery + // so migrate can support jQuery.sub (gh-2101) + root = root || rootjQuery; + + // Handle HTML strings + if ( typeof selector === "string" ) { + if ( selector[ 0 ] === "<" && + selector[ selector.length - 1 ] === ">" && + selector.length >= 3 ) { + + // Assume that strings that start and end with <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = rquickExpr.exec( selector ); + } + + // Match html or make sure no context is specified for #id + if ( match && ( match[ 1 ] || !context ) ) { + + // HANDLE: $(html) -> $(array) + if ( match[ 1 ] ) { + context = context instanceof jQuery ? context[ 0 ] : context; + + // Option to run scripts is true for back-compat + // Intentionally let the error be thrown if parseHTML is not present + jQuery.merge( this, jQuery.parseHTML( + match[ 1 ], + context && context.nodeType ? context.ownerDocument || context : document, + true + ) ); + + // HANDLE: $(html, props) + if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { + for ( match in context ) { + + // Properties of context are called as methods if possible + if ( isFunction( this[ match ] ) ) { + this[ match ]( context[ match ] ); + + // ...and otherwise set as attributes + } else { + this.attr( match, context[ match ] ); + } + } + } + + return this; + + // HANDLE: $(#id) + } else { + elem = document.getElementById( match[ 2 ] ); + + if ( elem ) { + + // Inject the element directly into the jQuery object + this[ 0 ] = elem; + this.length = 1; + } + return this; + } + + // HANDLE: $(expr, $(...)) + } else if ( !context || context.jquery ) { + return ( context || root ).find( selector ); + + // HANDLE: $(expr, context) + // (which is just equivalent to: $(context).find(expr) + } else { + return this.constructor( context ).find( selector ); + } + + // HANDLE: $(DOMElement) + } else if ( selector.nodeType ) { + this[ 0 ] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( isFunction( selector ) ) { + return root.ready !== undefined ? + root.ready( selector ) : + + // Execute immediately if ready is not present + selector( jQuery ); + } + + return jQuery.makeArray( selector, this ); + }; + +// Give the init function the jQuery prototype for later instantiation +init.prototype = jQuery.fn; + +// Initialize central reference +rootjQuery = jQuery( document ); + + +var rparentsprev = /^(?:parents|prev(?:Until|All))/, + + // Methods guaranteed to produce a unique set when starting from a unique set + guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + +jQuery.fn.extend( { + has: function( target ) { + var targets = jQuery( target, this ), + l = targets.length; + + return this.filter( function() { + var i = 0; + for ( ; i < l; i++ ) { + if ( jQuery.contains( this, targets[ i ] ) ) { + return true; + } + } + } ); + }, + + closest: function( selectors, context ) { + var cur, + i = 0, + l = this.length, + matched = [], + targets = typeof selectors !== "string" && jQuery( selectors ); + + // Positional selectors never match, since there's no _selection_ context + if ( !rneedsContext.test( selectors ) ) { + for ( ; i < l; i++ ) { + for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { + + // Always skip document fragments + if ( cur.nodeType < 11 && ( targets ? + targets.index( cur ) > -1 : + + // Don't pass non-elements to Sizzle + cur.nodeType === 1 && + jQuery.find.matchesSelector( cur, selectors ) ) ) { + + matched.push( cur ); + break; + } + } + } + } + + return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); + }, + + // Determine the position of an element within the set + index: function( elem ) { + + // No argument, return index in parent + if ( !elem ) { + return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; + } + + // Index in selector + if ( typeof elem === "string" ) { + return indexOf.call( jQuery( elem ), this[ 0 ] ); + } + + // Locate the position of the desired element + return indexOf.call( this, + + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[ 0 ] : elem + ); + }, + + add: function( selector, context ) { + return this.pushStack( + jQuery.uniqueSort( + jQuery.merge( this.get(), jQuery( selector, context ) ) + ) + ); + }, + + addBack: function( selector ) { + return this.add( selector == null ? + this.prevObject : this.prevObject.filter( selector ) + ); + } +} ); + +function sibling( cur, dir ) { + while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} + return cur; +} + +jQuery.each( { + parent: function( elem ) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function( elem ) { + return dir( elem, "parentNode" ); + }, + parentsUntil: function( elem, _i, until ) { + return dir( elem, "parentNode", until ); + }, + next: function( elem ) { + return sibling( elem, "nextSibling" ); + }, + prev: function( elem ) { + return sibling( elem, "previousSibling" ); + }, + nextAll: function( elem ) { + return dir( elem, "nextSibling" ); + }, + prevAll: function( elem ) { + return dir( elem, "previousSibling" ); + }, + nextUntil: function( elem, _i, until ) { + return dir( elem, "nextSibling", until ); + }, + prevUntil: function( elem, _i, until ) { + return dir( elem, "previousSibling", until ); + }, + siblings: function( elem ) { + return siblings( ( elem.parentNode || {} ).firstChild, elem ); + }, + children: function( elem ) { + return siblings( elem.firstChild ); + }, + contents: function( elem ) { + if ( elem.contentDocument != null && + + // Support: IE 11+ + // elements with no `data` attribute has an object + // `contentDocument` with a `null` prototype. + getProto( elem.contentDocument ) ) { + + return elem.contentDocument; + } + + // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only + // Treat the template element as a regular one in browsers that + // don't support it. + if ( nodeName( elem, "template" ) ) { + elem = elem.content || elem; + } + + return jQuery.merge( [], elem.childNodes ); + } +}, function( name, fn ) { + jQuery.fn[ name ] = function( until, selector ) { + var matched = jQuery.map( this, fn, until ); + + if ( name.slice( -5 ) !== "Until" ) { + selector = until; + } + + if ( selector && typeof selector === "string" ) { + matched = jQuery.filter( selector, matched ); + } + + if ( this.length > 1 ) { + + // Remove duplicates + if ( !guaranteedUnique[ name ] ) { + jQuery.uniqueSort( matched ); + } + + // Reverse order for parents* and prev-derivatives + if ( rparentsprev.test( name ) ) { + matched.reverse(); + } + } + + return this.pushStack( matched ); + }; +} ); +var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); + + + +// Convert String-formatted options into Object-formatted ones +function createOptions( options ) { + var object = {}; + jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { + object[ flag ] = true; + } ); + return object; +} + +/* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that will change how + * the callback list behaves or a more traditional option object + * + * By default a callback list will act like an event callback list and can be + * "fired" multiple times. + * + * Possible options: + * + * once: will ensure the callback list can only be fired once (like a Deferred) + * + * memory: will keep track of previous values and will call any callback added + * after the list has been fired right away with the latest "memorized" + * values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns false + * + */ +jQuery.Callbacks = function( options ) { + + // Convert options from String-formatted to Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? + createOptions( options ) : + jQuery.extend( {}, options ); + + var // Flag to know if list is currently firing + firing, + + // Last fire value for non-forgettable lists + memory, + + // Flag to know if list was already fired + fired, + + // Flag to prevent firing + locked, + + // Actual callback list + list = [], + + // Queue of execution data for repeatable lists + queue = [], + + // Index of currently firing callback (modified by add/remove as needed) + firingIndex = -1, + + // Fire callbacks + fire = function() { + + // Enforce single-firing + locked = locked || options.once; + + // Execute callbacks for all pending executions, + // respecting firingIndex overrides and runtime changes + fired = firing = true; + for ( ; queue.length; firingIndex = -1 ) { + memory = queue.shift(); + while ( ++firingIndex < list.length ) { + + // Run callback and check for early termination + if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && + options.stopOnFalse ) { + + // Jump to end and forget the data so .add doesn't re-fire + firingIndex = list.length; + memory = false; + } + } + } + + // Forget the data if we're done with it + if ( !options.memory ) { + memory = false; + } + + firing = false; + + // Clean up if we're done firing for good + if ( locked ) { + + // Keep an empty list if we have data for future add calls + if ( memory ) { + list = []; + + // Otherwise, this object is spent + } else { + list = ""; + } + } + }, + + // Actual Callbacks object + self = { + + // Add a callback or a collection of callbacks to the list + add: function() { + if ( list ) { + + // If we have memory from a past run, we should fire after adding + if ( memory && !firing ) { + firingIndex = list.length - 1; + queue.push( memory ); + } + + ( function add( args ) { + jQuery.each( args, function( _, arg ) { + if ( isFunction( arg ) ) { + if ( !options.unique || !self.has( arg ) ) { + list.push( arg ); + } + } else if ( arg && arg.length && toType( arg ) !== "string" ) { + + // Inspect recursively + add( arg ); + } + } ); + } )( arguments ); + + if ( memory && !firing ) { + fire(); + } + } + return this; + }, + + // Remove a callback from the list + remove: function() { + jQuery.each( arguments, function( _, arg ) { + var index; + while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { + list.splice( index, 1 ); + + // Handle firing indexes + if ( index <= firingIndex ) { + firingIndex--; + } + } + } ); + return this; + }, + + // Check if a given callback is in the list. + // If no argument is given, return whether or not list has callbacks attached. + has: function( fn ) { + return fn ? + jQuery.inArray( fn, list ) > -1 : + list.length > 0; + }, + + // Remove all callbacks from the list + empty: function() { + if ( list ) { + list = []; + } + return this; + }, + + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable: function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled: function() { + return !list; + }, + + // Disable .fire + // Also disable .add unless we have memory (since it would have no effect) + // Abort any pending executions + lock: function() { + locked = queue = []; + if ( !memory && !firing ) { + list = memory = ""; + } + return this; + }, + locked: function() { + return !!locked; + }, + + // Call all callbacks with the given context and arguments + fireWith: function( context, args ) { + if ( !locked ) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + queue.push( args ); + if ( !firing ) { + fire(); + } + } + return this; + }, + + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith( this, arguments ); + return this; + }, + + // To know if the callbacks have already been called at least once + fired: function() { + return !!fired; + } + }; + + return self; +}; + + +function Identity( v ) { + return v; +} +function Thrower( ex ) { + throw ex; +} + +function adoptValue( value, resolve, reject, noValue ) { + var method; + + try { + + // Check for promise aspect first to privilege synchronous behavior + if ( value && isFunction( ( method = value.promise ) ) ) { + method.call( value ).done( resolve ).fail( reject ); + + // Other thenables + } else if ( value && isFunction( ( method = value.then ) ) ) { + method.call( value, resolve, reject ); + + // Other non-thenables + } else { + + // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: + // * false: [ value ].slice( 0 ) => resolve( value ) + // * true: [ value ].slice( 1 ) => resolve() + resolve.apply( undefined, [ value ].slice( noValue ) ); + } + + // For Promises/A+, convert exceptions into rejections + // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in + // Deferred#then to conditionally suppress rejection. + } catch ( value ) { + + // Support: Android 4.0 only + // Strict mode functions invoked without .call/.apply get global-object context + reject.apply( undefined, [ value ] ); + } +} + +jQuery.extend( { + + Deferred: function( func ) { + var tuples = [ + + // action, add listener, callbacks, + // ... .then handlers, argument index, [final state] + [ "notify", "progress", jQuery.Callbacks( "memory" ), + jQuery.Callbacks( "memory" ), 2 ], + [ "resolve", "done", jQuery.Callbacks( "once memory" ), + jQuery.Callbacks( "once memory" ), 0, "resolved" ], + [ "reject", "fail", jQuery.Callbacks( "once memory" ), + jQuery.Callbacks( "once memory" ), 1, "rejected" ] + ], + state = "pending", + promise = { + state: function() { + return state; + }, + always: function() { + deferred.done( arguments ).fail( arguments ); + return this; + }, + "catch": function( fn ) { + return promise.then( null, fn ); + }, + + // Keep pipe for back-compat + pipe: function( /* fnDone, fnFail, fnProgress */ ) { + var fns = arguments; + + return jQuery.Deferred( function( newDefer ) { + jQuery.each( tuples, function( _i, tuple ) { + + // Map tuples (progress, done, fail) to arguments (done, fail, progress) + var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; + + // deferred.progress(function() { bind to newDefer or newDefer.notify }) + // deferred.done(function() { bind to newDefer or newDefer.resolve }) + // deferred.fail(function() { bind to newDefer or newDefer.reject }) + deferred[ tuple[ 1 ] ]( function() { + var returned = fn && fn.apply( this, arguments ); + if ( returned && isFunction( returned.promise ) ) { + returned.promise() + .progress( newDefer.notify ) + .done( newDefer.resolve ) + .fail( newDefer.reject ); + } else { + newDefer[ tuple[ 0 ] + "With" ]( + this, + fn ? [ returned ] : arguments + ); + } + } ); + } ); + fns = null; + } ).promise(); + }, + then: function( onFulfilled, onRejected, onProgress ) { + var maxDepth = 0; + function resolve( depth, deferred, handler, special ) { + return function() { + var that = this, + args = arguments, + mightThrow = function() { + var returned, then; + + // Support: Promises/A+ section 2.3.3.3.3 + // https://promisesaplus.com/#point-59 + // Ignore double-resolution attempts + if ( depth < maxDepth ) { + return; + } + + returned = handler.apply( that, args ); + + // Support: Promises/A+ section 2.3.1 + // https://promisesaplus.com/#point-48 + if ( returned === deferred.promise() ) { + throw new TypeError( "Thenable self-resolution" ); + } + + // Support: Promises/A+ sections 2.3.3.1, 3.5 + // https://promisesaplus.com/#point-54 + // https://promisesaplus.com/#point-75 + // Retrieve `then` only once + then = returned && + + // Support: Promises/A+ section 2.3.4 + // https://promisesaplus.com/#point-64 + // Only check objects and functions for thenability + ( typeof returned === "object" || + typeof returned === "function" ) && + returned.then; + + // Handle a returned thenable + if ( isFunction( then ) ) { + + // Special processors (notify) just wait for resolution + if ( special ) { + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ) + ); + + // Normal processors (resolve) also hook into progress + } else { + + // ...and disregard older resolution values + maxDepth++; + + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ), + resolve( maxDepth, deferred, Identity, + deferred.notifyWith ) + ); + } + + // Handle all other returned values + } else { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Identity ) { + that = undefined; + args = [ returned ]; + } + + // Process the value(s) + // Default process is resolve + ( special || deferred.resolveWith )( that, args ); + } + }, + + // Only normal processors (resolve) catch and reject exceptions + process = special ? + mightThrow : + function() { + try { + mightThrow(); + } catch ( e ) { + + if ( jQuery.Deferred.exceptionHook ) { + jQuery.Deferred.exceptionHook( e, + process.stackTrace ); + } + + // Support: Promises/A+ section 2.3.3.3.4.1 + // https://promisesaplus.com/#point-61 + // Ignore post-resolution exceptions + if ( depth + 1 >= maxDepth ) { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Thrower ) { + that = undefined; + args = [ e ]; + } + + deferred.rejectWith( that, args ); + } + } + }; + + // Support: Promises/A+ section 2.3.3.3.1 + // https://promisesaplus.com/#point-57 + // Re-resolve promises immediately to dodge false rejection from + // subsequent errors + if ( depth ) { + process(); + } else { + + // Call an optional hook to record the stack, in case of exception + // since it's otherwise lost when execution goes async + if ( jQuery.Deferred.getStackHook ) { + process.stackTrace = jQuery.Deferred.getStackHook(); + } + window.setTimeout( process ); + } + }; + } + + return jQuery.Deferred( function( newDefer ) { + + // progress_handlers.add( ... ) + tuples[ 0 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onProgress ) ? + onProgress : + Identity, + newDefer.notifyWith + ) + ); + + // fulfilled_handlers.add( ... ) + tuples[ 1 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onFulfilled ) ? + onFulfilled : + Identity + ) + ); + + // rejected_handlers.add( ... ) + tuples[ 2 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onRejected ) ? + onRejected : + Thrower + ) + ); + } ).promise(); + }, + + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function( obj ) { + return obj != null ? jQuery.extend( obj, promise ) : promise; + } + }, + deferred = {}; + + // Add list-specific methods + jQuery.each( tuples, function( i, tuple ) { + var list = tuple[ 2 ], + stateString = tuple[ 5 ]; + + // promise.progress = list.add + // promise.done = list.add + // promise.fail = list.add + promise[ tuple[ 1 ] ] = list.add; + + // Handle state + if ( stateString ) { + list.add( + function() { + + // state = "resolved" (i.e., fulfilled) + // state = "rejected" + state = stateString; + }, + + // rejected_callbacks.disable + // fulfilled_callbacks.disable + tuples[ 3 - i ][ 2 ].disable, + + // rejected_handlers.disable + // fulfilled_handlers.disable + tuples[ 3 - i ][ 3 ].disable, + + // progress_callbacks.lock + tuples[ 0 ][ 2 ].lock, + + // progress_handlers.lock + tuples[ 0 ][ 3 ].lock + ); + } + + // progress_handlers.fire + // fulfilled_handlers.fire + // rejected_handlers.fire + list.add( tuple[ 3 ].fire ); + + // deferred.notify = function() { deferred.notifyWith(...) } + // deferred.resolve = function() { deferred.resolveWith(...) } + // deferred.reject = function() { deferred.rejectWith(...) } + deferred[ tuple[ 0 ] ] = function() { + deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); + return this; + }; + + // deferred.notifyWith = list.fireWith + // deferred.resolveWith = list.fireWith + // deferred.rejectWith = list.fireWith + deferred[ tuple[ 0 ] + "With" ] = list.fireWith; + } ); + + // Make the deferred a promise + promise.promise( deferred ); + + // Call given func if any + if ( func ) { + func.call( deferred, deferred ); + } + + // All done! + return deferred; + }, + + // Deferred helper + when: function( singleValue ) { + var + + // count of uncompleted subordinates + remaining = arguments.length, + + // count of unprocessed arguments + i = remaining, + + // subordinate fulfillment data + resolveContexts = Array( i ), + resolveValues = slice.call( arguments ), + + // the master Deferred + master = jQuery.Deferred(), + + // subordinate callback factory + updateFunc = function( i ) { + return function( value ) { + resolveContexts[ i ] = this; + resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; + if ( !( --remaining ) ) { + master.resolveWith( resolveContexts, resolveValues ); + } + }; + }; + + // Single- and empty arguments are adopted like Promise.resolve + if ( remaining <= 1 ) { + adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, + !remaining ); + + // Use .then() to unwrap secondary thenables (cf. gh-3000) + if ( master.state() === "pending" || + isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { + + return master.then(); + } + } + + // Multiple arguments are aggregated like Promise.all array elements + while ( i-- ) { + adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); + } + + return master.promise(); + } +} ); + + +// These usually indicate a programmer mistake during development, +// warn about them ASAP rather than swallowing them by default. +var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; + +jQuery.Deferred.exceptionHook = function( error, stack ) { + + // Support: IE 8 - 9 only + // Console exists when dev tools are open, which can happen at any time + if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { + window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); + } +}; + + + + +jQuery.readyException = function( error ) { + window.setTimeout( function() { + throw error; + } ); +}; + + + + +// The deferred used on DOM ready +var readyList = jQuery.Deferred(); + +jQuery.fn.ready = function( fn ) { + + readyList + .then( fn ) + + // Wrap jQuery.readyException in a function so that the lookup + // happens at the time of error handling instead of callback + // registration. + .catch( function( error ) { + jQuery.readyException( error ); + } ); + + return this; +}; + +jQuery.extend( { + + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait: 1, + + // Handle when the DOM is ready + ready: function( wait ) { + + // Abort if there are pending holds or we're already ready + if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { + return; + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and wait if need be + if ( wait !== true && --jQuery.readyWait > 0 ) { + return; + } + + // If there are functions bound, to execute + readyList.resolveWith( document, [ jQuery ] ); + } +} ); + +jQuery.ready.then = readyList.then; + +// The ready event handler and self cleanup method +function completed() { + document.removeEventListener( "DOMContentLoaded", completed ); + window.removeEventListener( "load", completed ); + jQuery.ready(); +} + +// Catch cases where $(document).ready() is called +// after the browser event has already occurred. +// Support: IE <=9 - 10 only +// Older IE sometimes signals "interactive" too soon +if ( document.readyState === "complete" || + ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { + + // Handle it asynchronously to allow scripts the opportunity to delay ready + window.setTimeout( jQuery.ready ); + +} else { + + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", completed ); + + // A fallback to window.onload, that will always work + window.addEventListener( "load", completed ); +} + + + + +// Multifunctional method to get and set values of a collection +// The value/s can optionally be executed if it's a function +var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { + var i = 0, + len = elems.length, + bulk = key == null; + + // Sets many values + if ( toType( key ) === "object" ) { + chainable = true; + for ( i in key ) { + access( elems, fn, i, key[ i ], true, emptyGet, raw ); + } + + // Sets one value + } else if ( value !== undefined ) { + chainable = true; + + if ( !isFunction( value ) ) { + raw = true; + } + + if ( bulk ) { + + // Bulk operations run against the entire set + if ( raw ) { + fn.call( elems, value ); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function( elem, _key, value ) { + return bulk.call( jQuery( elem ), value ); + }; + } + } + + if ( fn ) { + for ( ; i < len; i++ ) { + fn( + elems[ i ], key, raw ? + value : + value.call( elems[ i ], i, fn( elems[ i ], key ) ) + ); + } + } + } + + if ( chainable ) { + return elems; + } + + // Gets + if ( bulk ) { + return fn.call( elems ); + } + + return len ? fn( elems[ 0 ], key ) : emptyGet; +}; + + +// Matches dashed string for camelizing +var rmsPrefix = /^-ms-/, + rdashAlpha = /-([a-z])/g; + +// Used by camelCase as callback to replace() +function fcamelCase( _all, letter ) { + return letter.toUpperCase(); +} + +// Convert dashed to camelCase; used by the css and data modules +// Support: IE <=9 - 11, Edge 12 - 15 +// Microsoft forgot to hump their vendor prefix (#9572) +function camelCase( string ) { + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); +} +var acceptData = function( owner ) { + + // Accepts only: + // - Node + // - Node.ELEMENT_NODE + // - Node.DOCUMENT_NODE + // - Object + // - Any + return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); +}; + + + + +function Data() { + this.expando = jQuery.expando + Data.uid++; +} + +Data.uid = 1; + +Data.prototype = { + + cache: function( owner ) { + + // Check if the owner object already has a cache + var value = owner[ this.expando ]; + + // If not, create one + if ( !value ) { + value = {}; + + // We can accept data for non-element nodes in modern browsers, + // but we should not, see #8335. + // Always return an empty object. + if ( acceptData( owner ) ) { + + // If it is a node unlikely to be stringify-ed or looped over + // use plain assignment + if ( owner.nodeType ) { + owner[ this.expando ] = value; + + // Otherwise secure it in a non-enumerable property + // configurable must be true to allow the property to be + // deleted when data is removed + } else { + Object.defineProperty( owner, this.expando, { + value: value, + configurable: true + } ); + } + } + } + + return value; + }, + set: function( owner, data, value ) { + var prop, + cache = this.cache( owner ); + + // Handle: [ owner, key, value ] args + // Always use camelCase key (gh-2257) + if ( typeof data === "string" ) { + cache[ camelCase( data ) ] = value; + + // Handle: [ owner, { properties } ] args + } else { + + // Copy the properties one-by-one to the cache object + for ( prop in data ) { + cache[ camelCase( prop ) ] = data[ prop ]; + } + } + return cache; + }, + get: function( owner, key ) { + return key === undefined ? + this.cache( owner ) : + + // Always use camelCase key (gh-2257) + owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; + }, + access: function( owner, key, value ) { + + // In cases where either: + // + // 1. No key was specified + // 2. A string key was specified, but no value provided + // + // Take the "read" path and allow the get method to determine + // which value to return, respectively either: + // + // 1. The entire cache object + // 2. The data stored at the key + // + if ( key === undefined || + ( ( key && typeof key === "string" ) && value === undefined ) ) { + + return this.get( owner, key ); + } + + // When the key is not a string, or both a key and value + // are specified, set or extend (existing objects) with either: + // + // 1. An object of properties + // 2. A key and value + // + this.set( owner, key, value ); + + // Since the "set" path can have two possible entry points + // return the expected data based on which path was taken[*] + return value !== undefined ? value : key; + }, + remove: function( owner, key ) { + var i, + cache = owner[ this.expando ]; + + if ( cache === undefined ) { + return; + } + + if ( key !== undefined ) { + + // Support array or space separated string of keys + if ( Array.isArray( key ) ) { + + // If key is an array of keys... + // We always set camelCase keys, so remove that. + key = key.map( camelCase ); + } else { + key = camelCase( key ); + + // If a key with the spaces exists, use it. + // Otherwise, create an array by matching non-whitespace + key = key in cache ? + [ key ] : + ( key.match( rnothtmlwhite ) || [] ); + } + + i = key.length; + + while ( i-- ) { + delete cache[ key[ i ] ]; + } + } + + // Remove the expando if there's no more data + if ( key === undefined || jQuery.isEmptyObject( cache ) ) { + + // Support: Chrome <=35 - 45 + // Webkit & Blink performance suffers when deleting properties + // from DOM nodes, so set to undefined instead + // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) + if ( owner.nodeType ) { + owner[ this.expando ] = undefined; + } else { + delete owner[ this.expando ]; + } + } + }, + hasData: function( owner ) { + var cache = owner[ this.expando ]; + return cache !== undefined && !jQuery.isEmptyObject( cache ); + } +}; +var dataPriv = new Data(); + +var dataUser = new Data(); + + + +// Implementation Summary +// +// 1. Enforce API surface and semantic compatibility with 1.9.x branch +// 2. Improve the module's maintainability by reducing the storage +// paths to a single mechanism. +// 3. Use the same single mechanism to support "private" and "user" data. +// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) +// 5. Avoid exposing implementation details on user objects (eg. expando properties) +// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 + +var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, + rmultiDash = /[A-Z]/g; + +function getData( data ) { + if ( data === "true" ) { + return true; + } + + if ( data === "false" ) { + return false; + } + + if ( data === "null" ) { + return null; + } + + // Only convert to a number if it doesn't change the string + if ( data === +data + "" ) { + return +data; + } + + if ( rbrace.test( data ) ) { + return JSON.parse( data ); + } + + return data; +} + +function dataAttr( elem, key, data ) { + var name; + + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if ( data === undefined && elem.nodeType === 1 ) { + name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); + data = elem.getAttribute( name ); + + if ( typeof data === "string" ) { + try { + data = getData( data ); + } catch ( e ) {} + + // Make sure we set the data so it isn't changed later + dataUser.set( elem, key, data ); + } else { + data = undefined; + } + } + return data; +} + +jQuery.extend( { + hasData: function( elem ) { + return dataUser.hasData( elem ) || dataPriv.hasData( elem ); + }, + + data: function( elem, name, data ) { + return dataUser.access( elem, name, data ); + }, + + removeData: function( elem, name ) { + dataUser.remove( elem, name ); + }, + + // TODO: Now that all calls to _data and _removeData have been replaced + // with direct calls to dataPriv methods, these can be deprecated. + _data: function( elem, name, data ) { + return dataPriv.access( elem, name, data ); + }, + + _removeData: function( elem, name ) { + dataPriv.remove( elem, name ); + } +} ); + +jQuery.fn.extend( { + data: function( key, value ) { + var i, name, data, + elem = this[ 0 ], + attrs = elem && elem.attributes; + + // Gets all values + if ( key === undefined ) { + if ( this.length ) { + data = dataUser.get( elem ); + + if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { + i = attrs.length; + while ( i-- ) { + + // Support: IE 11 only + // The attrs elements can be null (#14894) + if ( attrs[ i ] ) { + name = attrs[ i ].name; + if ( name.indexOf( "data-" ) === 0 ) { + name = camelCase( name.slice( 5 ) ); + dataAttr( elem, name, data[ name ] ); + } + } + } + dataPriv.set( elem, "hasDataAttrs", true ); + } + } + + return data; + } + + // Sets multiple values + if ( typeof key === "object" ) { + return this.each( function() { + dataUser.set( this, key ); + } ); + } + + return access( this, function( value ) { + var data; + + // The calling jQuery object (element matches) is not empty + // (and therefore has an element appears at this[ 0 ]) and the + // `value` parameter was not undefined. An empty jQuery object + // will result in `undefined` for elem = this[ 0 ] which will + // throw an exception if an attempt to read a data cache is made. + if ( elem && value === undefined ) { + + // Attempt to get data from the cache + // The key will always be camelCased in Data + data = dataUser.get( elem, key ); + if ( data !== undefined ) { + return data; + } + + // Attempt to "discover" the data in + // HTML5 custom data-* attrs + data = dataAttr( elem, key ); + if ( data !== undefined ) { + return data; + } + + // We tried really hard, but the data doesn't exist. + return; + } + + // Set the data... + this.each( function() { + + // We always store the camelCased key + dataUser.set( this, key, value ); + } ); + }, null, value, arguments.length > 1, null, true ); + }, + + removeData: function( key ) { + return this.each( function() { + dataUser.remove( this, key ); + } ); + } +} ); + + +jQuery.extend( { + queue: function( elem, type, data ) { + var queue; + + if ( elem ) { + type = ( type || "fx" ) + "queue"; + queue = dataPriv.get( elem, type ); + + // Speed up dequeue by getting out quickly if this is just a lookup + if ( data ) { + if ( !queue || Array.isArray( data ) ) { + queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); + } else { + queue.push( data ); + } + } + return queue || []; + } + }, + + dequeue: function( elem, type ) { + type = type || "fx"; + + var queue = jQuery.queue( elem, type ), + startLength = queue.length, + fn = queue.shift(), + hooks = jQuery._queueHooks( elem, type ), + next = function() { + jQuery.dequeue( elem, type ); + }; + + // If the fx queue is dequeued, always remove the progress sentinel + if ( fn === "inprogress" ) { + fn = queue.shift(); + startLength--; + } + + if ( fn ) { + + // Add a progress sentinel to prevent the fx queue from being + // automatically dequeued + if ( type === "fx" ) { + queue.unshift( "inprogress" ); + } + + // Clear up the last queue stop function + delete hooks.stop; + fn.call( elem, next, hooks ); + } + + if ( !startLength && hooks ) { + hooks.empty.fire(); + } + }, + + // Not public - generate a queueHooks object, or return the current one + _queueHooks: function( elem, type ) { + var key = type + "queueHooks"; + return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { + empty: jQuery.Callbacks( "once memory" ).add( function() { + dataPriv.remove( elem, [ type + "queue", key ] ); + } ) + } ); + } +} ); + +jQuery.fn.extend( { + queue: function( type, data ) { + var setter = 2; + + if ( typeof type !== "string" ) { + data = type; + type = "fx"; + setter--; + } + + if ( arguments.length < setter ) { + return jQuery.queue( this[ 0 ], type ); + } + + return data === undefined ? + this : + this.each( function() { + var queue = jQuery.queue( this, type, data ); + + // Ensure a hooks for this queue + jQuery._queueHooks( this, type ); + + if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { + jQuery.dequeue( this, type ); + } + } ); + }, + dequeue: function( type ) { + return this.each( function() { + jQuery.dequeue( this, type ); + } ); + }, + clearQueue: function( type ) { + return this.queue( type || "fx", [] ); + }, + + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function( type, obj ) { + var tmp, + count = 1, + defer = jQuery.Deferred(), + elements = this, + i = this.length, + resolve = function() { + if ( !( --count ) ) { + defer.resolveWith( elements, [ elements ] ); + } + }; + + if ( typeof type !== "string" ) { + obj = type; + type = undefined; + } + type = type || "fx"; + + while ( i-- ) { + tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); + if ( tmp && tmp.empty ) { + count++; + tmp.empty.add( resolve ); + } + } + resolve(); + return defer.promise( obj ); + } +} ); +var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; + +var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); + + +var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; + +var documentElement = document.documentElement; + + + + var isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ); + }, + composed = { composed: true }; + + // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only + // Check attachment across shadow DOM boundaries when possible (gh-3504) + // Support: iOS 10.0-10.2 only + // Early iOS 10 versions support `attachShadow` but not `getRootNode`, + // leading to errors. We need to check for `getRootNode`. + if ( documentElement.getRootNode ) { + isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ) || + elem.getRootNode( composed ) === elem.ownerDocument; + }; + } +var isHiddenWithinTree = function( elem, el ) { + + // isHiddenWithinTree might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + + // Inline style trumps all + return elem.style.display === "none" || + elem.style.display === "" && + + // Otherwise, check computed style + // Support: Firefox <=43 - 45 + // Disconnected elements can have computed display: none, so first confirm that elem is + // in the document. + isAttached( elem ) && + + jQuery.css( elem, "display" ) === "none"; + }; + + + +function adjustCSS( elem, prop, valueParts, tween ) { + var adjusted, scale, + maxIterations = 20, + currentValue = tween ? + function() { + return tween.cur(); + } : + function() { + return jQuery.css( elem, prop, "" ); + }, + initial = currentValue(), + unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), + + // Starting value computation is required for potential unit mismatches + initialInUnit = elem.nodeType && + ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && + rcssNum.exec( jQuery.css( elem, prop ) ); + + if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { + + // Support: Firefox <=54 + // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) + initial = initial / 2; + + // Trust units reported by jQuery.css + unit = unit || initialInUnit[ 3 ]; + + // Iteratively approximate from a nonzero starting point + initialInUnit = +initial || 1; + + while ( maxIterations-- ) { + + // Evaluate and update our best guess (doubling guesses that zero out). + // Finish if the scale equals or crosses 1 (making the old*new product non-positive). + jQuery.style( elem, prop, initialInUnit + unit ); + if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { + maxIterations = 0; + } + initialInUnit = initialInUnit / scale; + + } + + initialInUnit = initialInUnit * 2; + jQuery.style( elem, prop, initialInUnit + unit ); + + // Make sure we update the tween properties later on + valueParts = valueParts || []; + } + + if ( valueParts ) { + initialInUnit = +initialInUnit || +initial || 0; + + // Apply relative offset (+=/-=) if specified + adjusted = valueParts[ 1 ] ? + initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : + +valueParts[ 2 ]; + if ( tween ) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; +} + + +var defaultDisplayMap = {}; + +function getDefaultDisplay( elem ) { + var temp, + doc = elem.ownerDocument, + nodeName = elem.nodeName, + display = defaultDisplayMap[ nodeName ]; + + if ( display ) { + return display; + } + + temp = doc.body.appendChild( doc.createElement( nodeName ) ); + display = jQuery.css( temp, "display" ); + + temp.parentNode.removeChild( temp ); + + if ( display === "none" ) { + display = "block"; + } + defaultDisplayMap[ nodeName ] = display; + + return display; +} + +function showHide( elements, show ) { + var display, elem, + values = [], + index = 0, + length = elements.length; + + // Determine new display value for elements that need to change + for ( ; index < length; index++ ) { + elem = elements[ index ]; + if ( !elem.style ) { + continue; + } + + display = elem.style.display; + if ( show ) { + + // Since we force visibility upon cascade-hidden elements, an immediate (and slow) + // check is required in this first loop unless we have a nonempty display value (either + // inline or about-to-be-restored) + if ( display === "none" ) { + values[ index ] = dataPriv.get( elem, "display" ) || null; + if ( !values[ index ] ) { + elem.style.display = ""; + } + } + if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { + values[ index ] = getDefaultDisplay( elem ); + } + } else { + if ( display !== "none" ) { + values[ index ] = "none"; + + // Remember what we're overwriting + dataPriv.set( elem, "display", display ); + } + } + } + + // Set the display of the elements in a second loop to avoid constant reflow + for ( index = 0; index < length; index++ ) { + if ( values[ index ] != null ) { + elements[ index ].style.display = values[ index ]; + } + } + + return elements; +} + +jQuery.fn.extend( { + show: function() { + return showHide( this, true ); + }, + hide: function() { + return showHide( this ); + }, + toggle: function( state ) { + if ( typeof state === "boolean" ) { + return state ? this.show() : this.hide(); + } + + return this.each( function() { + if ( isHiddenWithinTree( this ) ) { + jQuery( this ).show(); + } else { + jQuery( this ).hide(); + } + } ); + } +} ); +var rcheckableType = ( /^(?:checkbox|radio)$/i ); + +var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); + +var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); + + + +( function() { + var fragment = document.createDocumentFragment(), + div = fragment.appendChild( document.createElement( "div" ) ), + input = document.createElement( "input" ); + + // Support: Android 4.0 - 4.3 only + // Check state lost if the name is set (#11217) + // Support: Windows Web Apps (WWA) + // `name` and `type` must use .setAttribute for WWA (#14901) + input.setAttribute( "type", "radio" ); + input.setAttribute( "checked", "checked" ); + input.setAttribute( "name", "t" ); + + div.appendChild( input ); + + // Support: Android <=4.1 only + // Older WebKit doesn't clone checked state correctly in fragments + support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; + + // Support: IE <=11 only + // Make sure textarea (and checkbox) defaultValue is properly cloned + div.innerHTML = ""; + support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; + + // Support: IE <=9 only + // IE <=9 replaces "; + support.option = !!div.lastChild; +} )(); + + +// We have to close these tags to support XHTML (#13200) +var wrapMap = { + + // XHTML parsers do not magically insert elements in the + // same way that tag soup parsers do. So we cannot shorten + // this by omitting or other required elements. + thead: [ 1, "", "
" ], + col: [ 2, "", "
" ], + tr: [ 2, "", "
" ], + td: [ 3, "", "
" ], + + _default: [ 0, "", "" ] +}; + +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; +wrapMap.th = wrapMap.td; + +// Support: IE <=9 only +if ( !support.option ) { + wrapMap.optgroup = wrapMap.option = [ 1, "" ]; +} + + +function getAll( context, tag ) { + + // Support: IE <=9 - 11 only + // Use typeof to avoid zero-argument method invocation on host objects (#15151) + var ret; + + if ( typeof context.getElementsByTagName !== "undefined" ) { + ret = context.getElementsByTagName( tag || "*" ); + + } else if ( typeof context.querySelectorAll !== "undefined" ) { + ret = context.querySelectorAll( tag || "*" ); + + } else { + ret = []; + } + + if ( tag === undefined || tag && nodeName( context, tag ) ) { + return jQuery.merge( [ context ], ret ); + } + + return ret; +} + + +// Mark scripts as having already been evaluated +function setGlobalEval( elems, refElements ) { + var i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + dataPriv.set( + elems[ i ], + "globalEval", + !refElements || dataPriv.get( refElements[ i ], "globalEval" ) + ); + } +} + + +var rhtml = /<|&#?\w+;/; + +function buildFragment( elems, context, scripts, selection, ignored ) { + var elem, tmp, tag, wrap, attached, j, + fragment = context.createDocumentFragment(), + nodes = [], + i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + elem = elems[ i ]; + + if ( elem || elem === 0 ) { + + // Add nodes directly + if ( toType( elem ) === "object" ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); + + // Convert non-html into a text node + } else if ( !rhtml.test( elem ) ) { + nodes.push( context.createTextNode( elem ) ); + + // Convert html into DOM nodes + } else { + tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); + + // Deserialize a standard representation + tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); + wrap = wrapMap[ tag ] || wrapMap._default; + tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; + + // Descend through wrappers to the right content + j = wrap[ 0 ]; + while ( j-- ) { + tmp = tmp.lastChild; + } + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, tmp.childNodes ); + + // Remember the top-level container + tmp = fragment.firstChild; + + // Ensure the created nodes are orphaned (#12392) + tmp.textContent = ""; + } + } + } + + // Remove wrapper from fragment + fragment.textContent = ""; + + i = 0; + while ( ( elem = nodes[ i++ ] ) ) { + + // Skip elements already in the context collection (trac-4087) + if ( selection && jQuery.inArray( elem, selection ) > -1 ) { + if ( ignored ) { + ignored.push( elem ); + } + continue; + } + + attached = isAttached( elem ); + + // Append to fragment + tmp = getAll( fragment.appendChild( elem ), "script" ); + + // Preserve script evaluation history + if ( attached ) { + setGlobalEval( tmp ); + } + + // Capture executables + if ( scripts ) { + j = 0; + while ( ( elem = tmp[ j++ ] ) ) { + if ( rscriptType.test( elem.type || "" ) ) { + scripts.push( elem ); + } + } + } + } + + return fragment; +} + + +var + rkeyEvent = /^key/, + rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, + rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + +function returnTrue() { + return true; +} + +function returnFalse() { + return false; +} + +// Support: IE <=9 - 11+ +// focus() and blur() are asynchronous, except when they are no-op. +// So expect focus to be synchronous when the element is already active, +// and blur to be synchronous when the element is not already active. +// (focus and blur are always synchronous in other supported browsers, +// this just defines when we can count on it). +function expectSync( elem, type ) { + return ( elem === safeActiveElement() ) === ( type === "focus" ); +} + +// Support: IE <=9 only +// Accessing document.activeElement can throw unexpectedly +// https://bugs.jquery.com/ticket/13393 +function safeActiveElement() { + try { + return document.activeElement; + } catch ( err ) { } +} + +function on( elem, types, selector, data, fn, one ) { + var origFn, type; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for ( type in types ) { + on( elem, type, selector, data, types[ type ], one ); + } + return elem; + } + + if ( data == null && fn == null ) { + + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return elem; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return elem.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + } ); +} + +/* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ +jQuery.event = { + + global: {}, + + add: function( elem, types, handler, data, selector ) { + + var handleObjIn, eventHandle, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.get( elem ); + + // Only attach events to objects that accept data + if ( !acceptData( elem ) ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Ensure that invalid selectors throw exceptions at attach time + // Evaluate against documentElement in case elem is a non-element node (e.g., document) + if ( selector ) { + jQuery.find.matchesSelector( documentElement, selector ); + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + if ( !( events = elemData.events ) ) { + events = elemData.events = Object.create( null ); + } + if ( !( eventHandle = elemData.handle ) ) { + eventHandle = elemData.handle = function( e ) { + + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? + jQuery.event.dispatch.apply( elem, arguments ) : undefined; + }; + } + + // Handle multiple events separated by a space + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // There *must* be a type, no attaching namespace-only handlers + if ( !type ) { + continue; + } + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend( { + type: type, + origType: origType, + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), + namespace: namespaces.join( "." ) + }, handleObjIn ); + + // Init the event handler queue if we're the first + if ( !( handlers = events[ type ] ) ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener if the special events handler returns false + if ( !special.setup || + special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + }, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + + var j, origCount, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); + + if ( !elemData || !( events = elemData.events ) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector ? special.delegateType : special.bindType ) || type; + handlers = events[ type ] || []; + tmp = tmp[ 2 ] && + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); + + // Remove matching events + origCount = j = handlers.length; + while ( j-- ) { + handleObj = handlers[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !tmp || tmp.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || + selector === "**" && handleObj.selector ) ) { + handlers.splice( j, 1 ); + + if ( handleObj.selector ) { + handlers.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( origCount && !handlers.length ) { + if ( !special.teardown || + special.teardown.call( elem, namespaces, elemData.handle ) === false ) { + + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove data and the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + dataPriv.remove( elem, "handle events" ); + } + }, + + dispatch: function( nativeEvent ) { + + var i, j, ret, matched, handleObj, handlerQueue, + args = new Array( arguments.length ), + + // Make a writable jQuery.Event from the native event object + event = jQuery.event.fix( nativeEvent ), + + handlers = ( + dataPriv.get( this, "events" ) || Object.create( null ) + )[ event.type ] || [], + special = jQuery.event.special[ event.type ] || {}; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[ 0 ] = event; + + for ( i = 1; i < arguments.length; i++ ) { + args[ i ] = arguments[ i ]; + } + + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, and let it bail if desired + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call( this, event, handlers ); + + // Run delegates first; they may want to stop propagation beneath us + i = 0; + while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { + event.currentTarget = matched.elem; + + j = 0; + while ( ( handleObj = matched.handlers[ j++ ] ) && + !event.isImmediatePropagationStopped() ) { + + // If the event is namespaced, then each handler is only invoked if it is + // specially universal or its namespaces are a superset of the event's. + if ( !event.rnamespace || handleObj.namespace === false || + event.rnamespace.test( handleObj.namespace ) ) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || + handleObj.handler ).apply( matched.elem, args ); + + if ( ret !== undefined ) { + if ( ( event.result = ret ) === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if ( special.postDispatch ) { + special.postDispatch.call( this, event ); + } + + return event.result; + }, + + handlers: function( event, handlers ) { + var i, handleObj, sel, matchedHandlers, matchedSelectors, + handlerQueue = [], + delegateCount = handlers.delegateCount, + cur = event.target; + + // Find delegate handlers + if ( delegateCount && + + // Support: IE <=9 + // Black-hole SVG instance trees (trac-13180) + cur.nodeType && + + // Support: Firefox <=42 + // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) + // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click + // Support: IE 11 only + // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) + !( event.type === "click" && event.button >= 1 ) ) { + + for ( ; cur !== this; cur = cur.parentNode || this ) { + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) + if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { + matchedHandlers = []; + matchedSelectors = {}; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + + // Don't conflict with Object.prototype properties (#13203) + sel = handleObj.selector + " "; + + if ( matchedSelectors[ sel ] === undefined ) { + matchedSelectors[ sel ] = handleObj.needsContext ? + jQuery( sel, this ).index( cur ) > -1 : + jQuery.find( sel, this, null, [ cur ] ).length; + } + if ( matchedSelectors[ sel ] ) { + matchedHandlers.push( handleObj ); + } + } + if ( matchedHandlers.length ) { + handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); + } + } + } + } + + // Add the remaining (directly-bound) handlers + cur = this; + if ( delegateCount < handlers.length ) { + handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); + } + + return handlerQueue; + }, + + addProp: function( name, hook ) { + Object.defineProperty( jQuery.Event.prototype, name, { + enumerable: true, + configurable: true, + + get: isFunction( hook ) ? + function() { + if ( this.originalEvent ) { + return hook( this.originalEvent ); + } + } : + function() { + if ( this.originalEvent ) { + return this.originalEvent[ name ]; + } + }, + + set: function( value ) { + Object.defineProperty( this, name, { + enumerable: true, + configurable: true, + writable: true, + value: value + } ); + } + } ); + }, + + fix: function( originalEvent ) { + return originalEvent[ jQuery.expando ] ? + originalEvent : + new jQuery.Event( originalEvent ); + }, + + special: { + load: { + + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + + // Utilize native event to ensure correct state for checkable inputs + setup: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Claim the first handler + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + // dataPriv.set( el, "click", ... ) + leverageNative( el, "click", returnTrue ); + } + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Force setup before triggering a click + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + leverageNative( el, "click" ); + } + + // Return non-false to allow normal event-path propagation + return true; + }, + + // For cross-browser consistency, suppress native .click() on links + // Also prevent it if we're currently inside a leveraged native-event stack + _default: function( event ) { + var target = event.target; + return rcheckableType.test( target.type ) && + target.click && nodeName( target, "input" ) && + dataPriv.get( target, "click" ) || + nodeName( target, "a" ); + } + }, + + beforeunload: { + postDispatch: function( event ) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue field is not set. + if ( event.result !== undefined && event.originalEvent ) { + event.originalEvent.returnValue = event.result; + } + } + } + } +}; + +// Ensure the presence of an event listener that handles manually-triggered +// synthetic events by interrupting progress until reinvoked in response to +// *native* events that it fires directly, ensuring that state changes have +// already occurred before other listeners are invoked. +function leverageNative( el, type, expectSync ) { + + // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add + if ( !expectSync ) { + if ( dataPriv.get( el, type ) === undefined ) { + jQuery.event.add( el, type, returnTrue ); + } + return; + } + + // Register the controller as a special universal handler for all event namespaces + dataPriv.set( el, type, false ); + jQuery.event.add( el, type, { + namespace: false, + handler: function( event ) { + var notAsync, result, + saved = dataPriv.get( this, type ); + + if ( ( event.isTrigger & 1 ) && this[ type ] ) { + + // Interrupt processing of the outer synthetic .trigger()ed event + // Saved data should be false in such cases, but might be a leftover capture object + // from an async native handler (gh-4350) + if ( !saved.length ) { + + // Store arguments for use when handling the inner native event + // There will always be at least one argument (an event object), so this array + // will not be confused with a leftover capture object. + saved = slice.call( arguments ); + dataPriv.set( this, type, saved ); + + // Trigger the native event and capture its result + // Support: IE <=9 - 11+ + // focus() and blur() are asynchronous + notAsync = expectSync( this, type ); + this[ type ](); + result = dataPriv.get( this, type ); + if ( saved !== result || notAsync ) { + dataPriv.set( this, type, false ); + } else { + result = {}; + } + if ( saved !== result ) { + + // Cancel the outer synthetic event + event.stopImmediatePropagation(); + event.preventDefault(); + return result.value; + } + + // If this is an inner synthetic event for an event with a bubbling surrogate + // (focus or blur), assume that the surrogate already propagated from triggering the + // native event and prevent that from happening again here. + // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the + // bubbling surrogate propagates *after* the non-bubbling base), but that seems + // less bad than duplication. + } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { + event.stopPropagation(); + } + + // If this is a native event triggered above, everything is now in order + // Fire an inner synthetic event with the original arguments + } else if ( saved.length ) { + + // ...and capture the result + dataPriv.set( this, type, { + value: jQuery.event.trigger( + + // Support: IE <=9 - 11+ + // Extend with the prototype to reset the above stopImmediatePropagation() + jQuery.extend( saved[ 0 ], jQuery.Event.prototype ), + saved.slice( 1 ), + this + ) + } ); + + // Abort handling of the native event + event.stopImmediatePropagation(); + } + } + } ); +} + +jQuery.removeEvent = function( elem, type, handle ) { + + // This "if" is needed for plain objects + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle ); + } +}; + +jQuery.Event = function( src, props ) { + + // Allow instantiation without the 'new' keyword + if ( !( this instanceof jQuery.Event ) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = src.defaultPrevented || + src.defaultPrevented === undefined && + + // Support: Android <=2.3 only + src.returnValue === false ? + returnTrue : + returnFalse; + + // Create target properties + // Support: Safari <=6 - 7 only + // Target should not be a text node (#504, #13143) + this.target = ( src.target && src.target.nodeType === 3 ) ? + src.target.parentNode : + src.target; + + this.currentTarget = src.currentTarget; + this.relatedTarget = src.relatedTarget; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || Date.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; +}; + +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding +// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html +jQuery.Event.prototype = { + constructor: jQuery.Event, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + isSimulated: false, + + preventDefault: function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + + if ( e && !this.isSimulated ) { + e.preventDefault(); + } + }, + stopPropagation: function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopPropagation(); + } + }, + stopImmediatePropagation: function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } +}; + +// Includes all common event props including KeyEvent and MouseEvent specific props +jQuery.each( { + altKey: true, + bubbles: true, + cancelable: true, + changedTouches: true, + ctrlKey: true, + detail: true, + eventPhase: true, + metaKey: true, + pageX: true, + pageY: true, + shiftKey: true, + view: true, + "char": true, + code: true, + charCode: true, + key: true, + keyCode: true, + button: true, + buttons: true, + clientX: true, + clientY: true, + offsetX: true, + offsetY: true, + pointerId: true, + pointerType: true, + screenX: true, + screenY: true, + targetTouches: true, + toElement: true, + touches: true, + + which: function( event ) { + var button = event.button; + + // Add which for key events + if ( event.which == null && rkeyEvent.test( event.type ) ) { + return event.charCode != null ? event.charCode : event.keyCode; + } + + // Add which for click: 1 === left; 2 === middle; 3 === right + if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { + if ( button & 1 ) { + return 1; + } + + if ( button & 2 ) { + return 3; + } + + if ( button & 4 ) { + return 2; + } + + return 0; + } + + return event.which; + } +}, jQuery.event.addProp ); + +jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { + jQuery.event.special[ type ] = { + + // Utilize native event if possible so blur/focus sequence is correct + setup: function() { + + // Claim the first handler + // dataPriv.set( this, "focus", ... ) + // dataPriv.set( this, "blur", ... ) + leverageNative( this, type, expectSync ); + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function() { + + // Force setup before trigger + leverageNative( this, type ); + + // Return non-false to allow normal event-path propagation + return true; + }, + + delegateType: delegateType + }; +} ); + +// Create mouseenter/leave events using mouseover/out and event-time checks +// so that event delegation works in jQuery. +// Do the same for pointerenter/pointerleave and pointerover/pointerout +// +// Support: Safari 7 only +// Safari sends mouseenter too often; see: +// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 +// for the description of the bug (it existed in older Chrome versions as well). +jQuery.each( { + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" +}, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var ret, + target = this, + related = event.relatedTarget, + handleObj = event.handleObj; + + // For mouseenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; +} ); + +jQuery.fn.extend( { + + on: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn ); + }, + one: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + var handleObj, type; + if ( types && types.preventDefault && types.handleObj ) { + + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace ? + handleObj.origType + "." + handleObj.namespace : + handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + + // ( types-object [, selector] ) + for ( type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each( function() { + jQuery.event.remove( this, types, fn, selector ); + } ); + } +} ); + + +var + + // Support: IE <=10 - 11, Edge 12 - 13 only + // In IE/Edge using regex groups here causes severe slowdowns. + // See https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /\s*$/g; + +// Prefer a tbody over its parent table for containing new rows +function manipulationTarget( elem, content ) { + if ( nodeName( elem, "table" ) && + nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { + + return jQuery( elem ).children( "tbody" )[ 0 ] || elem; + } + + return elem; +} + +// Replace/restore the type attribute of script elements for safe DOM manipulation +function disableScript( elem ) { + elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; + return elem; +} +function restoreScript( elem ) { + if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { + elem.type = elem.type.slice( 5 ); + } else { + elem.removeAttribute( "type" ); + } + + return elem; +} + +function cloneCopyEvent( src, dest ) { + var i, l, type, pdataOld, udataOld, udataCur, events; + + if ( dest.nodeType !== 1 ) { + return; + } + + // 1. Copy private data: events, handlers, etc. + if ( dataPriv.hasData( src ) ) { + pdataOld = dataPriv.get( src ); + events = pdataOld.events; + + if ( events ) { + dataPriv.remove( dest, "handle events" ); + + for ( type in events ) { + for ( i = 0, l = events[ type ].length; i < l; i++ ) { + jQuery.event.add( dest, type, events[ type ][ i ] ); + } + } + } + } + + // 2. Copy user data + if ( dataUser.hasData( src ) ) { + udataOld = dataUser.access( src ); + udataCur = jQuery.extend( {}, udataOld ); + + dataUser.set( dest, udataCur ); + } +} + +// Fix IE bugs, see support tests +function fixInput( src, dest ) { + var nodeName = dest.nodeName.toLowerCase(); + + // Fails to persist the checked state of a cloned checkbox or radio button. + if ( nodeName === "input" && rcheckableType.test( src.type ) ) { + dest.checked = src.checked; + + // Fails to return the selected option to the default selected state when cloning options + } else if ( nodeName === "input" || nodeName === "textarea" ) { + dest.defaultValue = src.defaultValue; + } +} + +function domManip( collection, args, callback, ignored ) { + + // Flatten any nested arrays + args = flat( args ); + + var fragment, first, scripts, hasScripts, node, doc, + i = 0, + l = collection.length, + iNoClone = l - 1, + value = args[ 0 ], + valueIsFunction = isFunction( value ); + + // We can't cloneNode fragments that contain checked, in WebKit + if ( valueIsFunction || + ( l > 1 && typeof value === "string" && + !support.checkClone && rchecked.test( value ) ) ) { + return collection.each( function( index ) { + var self = collection.eq( index ); + if ( valueIsFunction ) { + args[ 0 ] = value.call( this, index, self.html() ); + } + domManip( self, args, callback, ignored ); + } ); + } + + if ( l ) { + fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); + first = fragment.firstChild; + + if ( fragment.childNodes.length === 1 ) { + fragment = first; + } + + // Require either new content or an interest in ignored elements to invoke the callback + if ( first || ignored ) { + scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain situations (#8070). + for ( ; i < l; i++ ) { + node = fragment; + + if ( i !== iNoClone ) { + node = jQuery.clone( node, true, true ); + + // Keep references to cloned scripts for later restoration + if ( hasScripts ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( scripts, getAll( node, "script" ) ); + } + } + + callback.call( collection[ i ], node, i ); + } + + if ( hasScripts ) { + doc = scripts[ scripts.length - 1 ].ownerDocument; + + // Reenable scripts + jQuery.map( scripts, restoreScript ); + + // Evaluate executable scripts on first document insertion + for ( i = 0; i < hasScripts; i++ ) { + node = scripts[ i ]; + if ( rscriptType.test( node.type || "" ) && + !dataPriv.access( node, "globalEval" ) && + jQuery.contains( doc, node ) ) { + + if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { + + // Optional AJAX dependency, but won't run scripts if not present + if ( jQuery._evalUrl && !node.noModule ) { + jQuery._evalUrl( node.src, { + nonce: node.nonce || node.getAttribute( "nonce" ) + }, doc ); + } + } else { + DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); + } + } + } + } + } + } + + return collection; +} + +function remove( elem, selector, keepData ) { + var node, + nodes = selector ? jQuery.filter( selector, elem ) : elem, + i = 0; + + for ( ; ( node = nodes[ i ] ) != null; i++ ) { + if ( !keepData && node.nodeType === 1 ) { + jQuery.cleanData( getAll( node ) ); + } + + if ( node.parentNode ) { + if ( keepData && isAttached( node ) ) { + setGlobalEval( getAll( node, "script" ) ); + } + node.parentNode.removeChild( node ); + } + } + + return elem; +} + +jQuery.extend( { + htmlPrefilter: function( html ) { + return html; + }, + + clone: function( elem, dataAndEvents, deepDataAndEvents ) { + var i, l, srcElements, destElements, + clone = elem.cloneNode( true ), + inPage = isAttached( elem ); + + // Fix IE cloning issues + if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && + !jQuery.isXMLDoc( elem ) ) { + + // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 + destElements = getAll( clone ); + srcElements = getAll( elem ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + fixInput( srcElements[ i ], destElements[ i ] ); + } + } + + // Copy the events from the original to the clone + if ( dataAndEvents ) { + if ( deepDataAndEvents ) { + srcElements = srcElements || getAll( elem ); + destElements = destElements || getAll( clone ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + cloneCopyEvent( srcElements[ i ], destElements[ i ] ); + } + } else { + cloneCopyEvent( elem, clone ); + } + } + + // Preserve script evaluation history + destElements = getAll( clone, "script" ); + if ( destElements.length > 0 ) { + setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); + } + + // Return the cloned set + return clone; + }, + + cleanData: function( elems ) { + var data, elem, type, + special = jQuery.event.special, + i = 0; + + for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { + if ( acceptData( elem ) ) { + if ( ( data = elem[ dataPriv.expando ] ) ) { + if ( data.events ) { + for ( type in data.events ) { + if ( special[ type ] ) { + jQuery.event.remove( elem, type ); + + // This is a shortcut to avoid jQuery.event.remove's overhead + } else { + jQuery.removeEvent( elem, type, data.handle ); + } + } + } + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataPriv.expando ] = undefined; + } + if ( elem[ dataUser.expando ] ) { + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataUser.expando ] = undefined; + } + } + } + } +} ); + +jQuery.fn.extend( { + detach: function( selector ) { + return remove( this, selector, true ); + }, + + remove: function( selector ) { + return remove( this, selector ); + }, + + text: function( value ) { + return access( this, function( value ) { + return value === undefined ? + jQuery.text( this ) : + this.empty().each( function() { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.textContent = value; + } + } ); + }, null, value, arguments.length ); + }, + + append: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.appendChild( elem ); + } + } ); + }, + + prepend: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.insertBefore( elem, target.firstChild ); + } + } ); + }, + + before: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this ); + } + } ); + }, + + after: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this.nextSibling ); + } + } ); + }, + + empty: function() { + var elem, + i = 0; + + for ( ; ( elem = this[ i ] ) != null; i++ ) { + if ( elem.nodeType === 1 ) { + + // Prevent memory leaks + jQuery.cleanData( getAll( elem, false ) ); + + // Remove any remaining nodes + elem.textContent = ""; + } + } + + return this; + }, + + clone: function( dataAndEvents, deepDataAndEvents ) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map( function() { + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); + } ); + }, + + html: function( value ) { + return access( this, function( value ) { + var elem = this[ 0 ] || {}, + i = 0, + l = this.length; + + if ( value === undefined && elem.nodeType === 1 ) { + return elem.innerHTML; + } + + // See if we can take a shortcut and just use innerHTML + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && + !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { + + value = jQuery.htmlPrefilter( value ); + + try { + for ( ; i < l; i++ ) { + elem = this[ i ] || {}; + + // Remove element nodes and prevent memory leaks + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML throws an exception, use the fallback method + } catch ( e ) {} + } + + if ( elem ) { + this.empty().append( value ); + } + }, null, value, arguments.length ); + }, + + replaceWith: function() { + var ignored = []; + + // Make the changes, replacing each non-ignored context element with the new content + return domManip( this, arguments, function( elem ) { + var parent = this.parentNode; + + if ( jQuery.inArray( this, ignored ) < 0 ) { + jQuery.cleanData( getAll( this ) ); + if ( parent ) { + parent.replaceChild( elem, this ); + } + } + + // Force callback invocation + }, ignored ); + } +} ); + +jQuery.each( { + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" +}, function( name, original ) { + jQuery.fn[ name ] = function( selector ) { + var elems, + ret = [], + insert = jQuery( selector ), + last = insert.length - 1, + i = 0; + + for ( ; i <= last; i++ ) { + elems = i === last ? this : this.clone( true ); + jQuery( insert[ i ] )[ original ]( elems ); + + // Support: Android <=4.0 only, PhantomJS 1 only + // .get() because push.apply(_, arraylike) throws on ancient WebKit + push.apply( ret, elems.get() ); + } + + return this.pushStack( ret ); + }; +} ); +var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); + +var getStyles = function( elem ) { + + // Support: IE <=11 only, Firefox <=30 (#15098, #14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if ( !view || !view.opener ) { + view = window; + } + + return view.getComputedStyle( elem ); + }; + +var swap = function( elem, options, callback ) { + var ret, name, + old = {}; + + // Remember the old values, and insert the new ones + for ( name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + ret = callback.call( elem ); + + // Revert the old values + for ( name in options ) { + elem.style[ name ] = old[ name ]; + } + + return ret; +}; + + +var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); + + + +( function() { + + // Executing both pixelPosition & boxSizingReliable tests require only one layout + // so they're executed at the same time to save the second computation. + function computeStyleTests() { + + // This is a singleton, we need to execute it only once + if ( !div ) { + return; + } + + container.style.cssText = "position:absolute;left:-11111px;width:60px;" + + "margin-top:1px;padding:0;border:0"; + div.style.cssText = + "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + + "margin:auto;border:1px;padding:1px;" + + "width:60%;top:1%"; + documentElement.appendChild( container ).appendChild( div ); + + var divStyle = window.getComputedStyle( div ); + pixelPositionVal = divStyle.top !== "1%"; + + // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 + reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; + + // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 + // Some styles come back with percentage values, even though they shouldn't + div.style.right = "60%"; + pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; + + // Support: IE 9 - 11 only + // Detect misreporting of content dimensions for box-sizing:border-box elements + boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; + + // Support: IE 9 only + // Detect overflow:scroll screwiness (gh-3699) + // Support: Chrome <=64 + // Don't get tricked when zoom affects offsetWidth (gh-4029) + div.style.position = "absolute"; + scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; + + documentElement.removeChild( container ); + + // Nullify the div so it wouldn't be stored in the memory and + // it will also be a sign that checks already performed + div = null; + } + + function roundPixelMeasures( measure ) { + return Math.round( parseFloat( measure ) ); + } + + var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, + reliableTrDimensionsVal, reliableMarginLeftVal, + container = document.createElement( "div" ), + div = document.createElement( "div" ); + + // Finish early in limited (non-browser) environments + if ( !div.style ) { + return; + } + + // Support: IE <=9 - 11 only + // Style of cloned element affects source element cloned (#8908) + div.style.backgroundClip = "content-box"; + div.cloneNode( true ).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + jQuery.extend( support, { + boxSizingReliable: function() { + computeStyleTests(); + return boxSizingReliableVal; + }, + pixelBoxStyles: function() { + computeStyleTests(); + return pixelBoxStylesVal; + }, + pixelPosition: function() { + computeStyleTests(); + return pixelPositionVal; + }, + reliableMarginLeft: function() { + computeStyleTests(); + return reliableMarginLeftVal; + }, + scrollboxSize: function() { + computeStyleTests(); + return scrollboxSizeVal; + }, + + // Support: IE 9 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Behavior in IE 9 is more subtle than in newer versions & it passes + // some versions of this test; make sure not to make it pass there! + reliableTrDimensions: function() { + var table, tr, trChild, trStyle; + if ( reliableTrDimensionsVal == null ) { + table = document.createElement( "table" ); + tr = document.createElement( "tr" ); + trChild = document.createElement( "div" ); + + table.style.cssText = "position:absolute;left:-11111px"; + tr.style.height = "1px"; + trChild.style.height = "9px"; + + documentElement + .appendChild( table ) + .appendChild( tr ) + .appendChild( trChild ); + + trStyle = window.getComputedStyle( tr ); + reliableTrDimensionsVal = parseInt( trStyle.height ) > 3; + + documentElement.removeChild( table ); + } + return reliableTrDimensionsVal; + } + } ); +} )(); + + +function curCSS( elem, name, computed ) { + var width, minWidth, maxWidth, ret, + + // Support: Firefox 51+ + // Retrieving style before computed somehow + // fixes an issue with getting wrong values + // on detached elements + style = elem.style; + + computed = computed || getStyles( elem ); + + // getPropertyValue is needed for: + // .css('filter') (IE 9 only, #12537) + // .css('--customProperty) (#3144) + if ( computed ) { + ret = computed.getPropertyValue( name ) || computed[ name ]; + + if ( ret === "" && !isAttached( elem ) ) { + ret = jQuery.style( elem, name ); + } + + // A tribute to the "awesome hack by Dean Edwards" + // Android Browser returns percentage for some values, + // but width seems to be reliably pixels. + // This is against the CSSOM draft spec: + // https://drafts.csswg.org/cssom/#resolved-values + if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + return ret !== undefined ? + + // Support: IE <=9 - 11 only + // IE returns zIndex value as an integer. + ret + "" : + ret; +} + + +function addGetHookIf( conditionFn, hookFn ) { + + // Define the hook, we'll check on the first run if it's really needed. + return { + get: function() { + if ( conditionFn() ) { + + // Hook not needed (or it's not possible to use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support test is not executed again. + return ( this.get = hookFn ).apply( this, arguments ); + } + }; +} + + +var cssPrefixes = [ "Webkit", "Moz", "ms" ], + emptyStyle = document.createElement( "div" ).style, + vendorProps = {}; + +// Return a vendor-prefixed property or undefined +function vendorPropName( name ) { + + // Check for vendor prefixed names + var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), + i = cssPrefixes.length; + + while ( i-- ) { + name = cssPrefixes[ i ] + capName; + if ( name in emptyStyle ) { + return name; + } + } +} + +// Return a potentially-mapped jQuery.cssProps or vendor prefixed property +function finalPropName( name ) { + var final = jQuery.cssProps[ name ] || vendorProps[ name ]; + + if ( final ) { + return final; + } + if ( name in emptyStyle ) { + return name; + } + return vendorProps[ name ] = vendorPropName( name ) || name; +} + + +var + + // Swappable if display is none or starts with table + // except "table", "table-cell", or "table-caption" + // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, + rcustomProp = /^--/, + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, + cssNormalTransform = { + letterSpacing: "0", + fontWeight: "400" + }; + +function setPositiveNumber( _elem, value, subtract ) { + + // Any relative (+/-) values have already been + // normalized at this point + var matches = rcssNum.exec( value ); + return matches ? + + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : + value; +} + +function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { + var i = dimension === "width" ? 1 : 0, + extra = 0, + delta = 0; + + // Adjustment may not be necessary + if ( box === ( isBorderBox ? "border" : "content" ) ) { + return 0; + } + + for ( ; i < 4; i += 2 ) { + + // Both box models exclude margin + if ( box === "margin" ) { + delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); + } + + // If we get here with a content-box, we're seeking "padding" or "border" or "margin" + if ( !isBorderBox ) { + + // Add padding + delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + + // For "border" or "margin", add border + if ( box !== "padding" ) { + delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + + // But still keep track of it otherwise + } else { + extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + + // If we get here with a border-box (content + padding + border), we're seeking "content" or + // "padding" or "margin" + } else { + + // For "content", subtract padding + if ( box === "content" ) { + delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + } + + // For "content" or "padding", subtract border + if ( box !== "margin" ) { + delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } + } + + // Account for positive content-box scroll gutter when requested by providing computedVal + if ( !isBorderBox && computedVal >= 0 ) { + + // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border + // Assuming integer scroll gutter, subtract the rest and round down + delta += Math.max( 0, Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + computedVal - + delta - + extra - + 0.5 + + // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter + // Use an explicit zero to avoid NaN (gh-3964) + ) ) || 0; + } + + return delta; +} + +function getWidthOrHeight( elem, dimension, extra ) { + + // Start with computed style + var styles = getStyles( elem ), + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). + // Fake content-box until we know it's needed to know the true value. + boxSizingNeeded = !support.boxSizingReliable() || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + valueIsBorderBox = isBorderBox, + + val = curCSS( elem, dimension, styles ), + offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); + + // Support: Firefox <=54 + // Return a confounding non-pixel value or feign ignorance, as appropriate. + if ( rnumnonpx.test( val ) ) { + if ( !extra ) { + return val; + } + val = "auto"; + } + + + // Support: IE 9 - 11 only + // Use offsetWidth/offsetHeight for when box sizing is unreliable. + // In those cases, the computed value can be trusted to be border-box. + if ( ( !support.boxSizingReliable() && isBorderBox || + + // Support: IE 10 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Interestingly, in some cases IE 9 doesn't suffer from this issue. + !support.reliableTrDimensions() && nodeName( elem, "tr" ) || + + // Fall back to offsetWidth/offsetHeight when value is "auto" + // This happens for inline elements with no explicit setting (gh-3571) + val === "auto" || + + // Support: Android <=4.1 - 4.3 only + // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) + !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && + + // Make sure the element is visible & connected + elem.getClientRects().length ) { + + isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; + + // Where available, offsetWidth/offsetHeight approximate border box dimensions. + // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the + // retrieved value as a content box dimension. + valueIsBorderBox = offsetProp in elem; + if ( valueIsBorderBox ) { + val = elem[ offsetProp ]; + } + } + + // Normalize "" and auto + val = parseFloat( val ) || 0; + + // Adjust for the element's box model + return ( val + + boxModelAdjustment( + elem, + dimension, + extra || ( isBorderBox ? "border" : "content" ), + valueIsBorderBox, + styles, + + // Provide the current computed size to request scroll gutter calculation (gh-3589) + val + ) + ) + "px"; +} + +jQuery.extend( { + + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function( elem, computed ) { + if ( computed ) { + + // We should always get a number back from opacity + var ret = curCSS( elem, "opacity" ); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Don't automatically add "px" to these possibly-unitless properties + cssNumber: { + "animationIterationCount": true, + "columnCount": true, + "fillOpacity": true, + "flexGrow": true, + "flexShrink": true, + "fontWeight": true, + "gridArea": true, + "gridColumn": true, + "gridColumnEnd": true, + "gridColumnStart": true, + "gridRow": true, + "gridRowEnd": true, + "gridRowStart": true, + "lineHeight": true, + "opacity": true, + "order": true, + "orphans": true, + "widows": true, + "zIndex": true, + "zoom": true + }, + + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: {}, + + // Get and set the style property on a DOM Node + style: function( elem, name, value, extra ) { + + // Don't set styles on text and comment nodes + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { + return; + } + + // Make sure that we're working with the right name + var ret, type, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ), + style = elem.style; + + // Make sure that we're working with the right name. We don't + // want to query the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Gets hook for the prefixed version, then unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // Check if we're setting a value + if ( value !== undefined ) { + type = typeof value; + + // Convert "+=" or "-=" to relative numbers (#7345) + if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { + value = adjustCSS( elem, name, ret ); + + // Fixes bug #9237 + type = "number"; + } + + // Make sure that null and NaN values aren't set (#7116) + if ( value == null || value !== value ) { + return; + } + + // If a number was passed in, add the unit (except for certain CSS properties) + // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append + // "px" to a few hardcoded values. + if ( type === "number" && !isCustomProp ) { + value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); + } + + // background-* props affect original clone's values + if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { + style[ name ] = "inherit"; + } + + // If a hook was provided, use that value, otherwise just set the specified value + if ( !hooks || !( "set" in hooks ) || + ( value = hooks.set( elem, value, extra ) ) !== undefined ) { + + if ( isCustomProp ) { + style.setProperty( name, value ); + } else { + style[ name ] = value; + } + } + + } else { + + // If a hook was provided get the non-computed value from there + if ( hooks && "get" in hooks && + ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { + + return ret; + } + + // Otherwise just get the value from the style object + return style[ name ]; + } + }, + + css: function( elem, name, extra, styles ) { + var val, num, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ); + + // Make sure that we're working with the right name. We don't + // want to modify the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Try prefixed name followed by the unprefixed name + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // If a hook was provided get the computed value from there + if ( hooks && "get" in hooks ) { + val = hooks.get( elem, true, extra ); + } + + // Otherwise, if a way to get the computed value exists, use that + if ( val === undefined ) { + val = curCSS( elem, name, styles ); + } + + // Convert "normal" to computed value + if ( val === "normal" && name in cssNormalTransform ) { + val = cssNormalTransform[ name ]; + } + + // Make numeric if forced or a qualifier was provided and val looks numeric + if ( extra === "" || extra ) { + num = parseFloat( val ); + return extra === true || isFinite( num ) ? num || 0 : val; + } + + return val; + } +} ); + +jQuery.each( [ "height", "width" ], function( _i, dimension ) { + jQuery.cssHooks[ dimension ] = { + get: function( elem, computed, extra ) { + if ( computed ) { + + // Certain elements can have dimension info if we invisibly show them + // but it must have a current display style that would benefit + return rdisplayswap.test( jQuery.css( elem, "display" ) ) && + + // Support: Safari 8+ + // Table columns in Safari have non-zero offsetWidth & zero + // getBoundingClientRect().width unless display is changed. + // Support: IE <=11 only + // Running getBoundingClientRect on a disconnected node + // in IE throws an error. + ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? + swap( elem, cssShow, function() { + return getWidthOrHeight( elem, dimension, extra ); + } ) : + getWidthOrHeight( elem, dimension, extra ); + } + }, + + set: function( elem, value, extra ) { + var matches, + styles = getStyles( elem ), + + // Only read styles.position if the test has a chance to fail + // to avoid forcing a reflow. + scrollboxSizeBuggy = !support.scrollboxSize() && + styles.position === "absolute", + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) + boxSizingNeeded = scrollboxSizeBuggy || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + subtract = extra ? + boxModelAdjustment( + elem, + dimension, + extra, + isBorderBox, + styles + ) : + 0; + + // Account for unreliable border-box dimensions by comparing offset* to computed and + // faking a content-box to get border and padding (gh-3699) + if ( isBorderBox && scrollboxSizeBuggy ) { + subtract -= Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + parseFloat( styles[ dimension ] ) - + boxModelAdjustment( elem, dimension, "border", false, styles ) - + 0.5 + ); + } + + // Convert to pixels if value adjustment is needed + if ( subtract && ( matches = rcssNum.exec( value ) ) && + ( matches[ 3 ] || "px" ) !== "px" ) { + + elem.style[ dimension ] = value; + value = jQuery.css( elem, dimension ); + } + + return setPositiveNumber( elem, value, subtract ); + } + }; +} ); + +jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, + function( elem, computed ) { + if ( computed ) { + return ( parseFloat( curCSS( elem, "marginLeft" ) ) || + elem.getBoundingClientRect().left - + swap( elem, { marginLeft: 0 }, function() { + return elem.getBoundingClientRect().left; + } ) + ) + "px"; + } + } +); + +// These hooks are used by animate to expand properties +jQuery.each( { + margin: "", + padding: "", + border: "Width" +}, function( prefix, suffix ) { + jQuery.cssHooks[ prefix + suffix ] = { + expand: function( value ) { + var i = 0, + expanded = {}, + + // Assumes a single number if not a string + parts = typeof value === "string" ? value.split( " " ) : [ value ]; + + for ( ; i < 4; i++ ) { + expanded[ prefix + cssExpand[ i ] + suffix ] = + parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; + } + + return expanded; + } + }; + + if ( prefix !== "margin" ) { + jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; + } +} ); + +jQuery.fn.extend( { + css: function( name, value ) { + return access( this, function( elem, name, value ) { + var styles, len, + map = {}, + i = 0; + + if ( Array.isArray( name ) ) { + styles = getStyles( elem ); + len = name.length; + + for ( ; i < len; i++ ) { + map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); + } + + return map; + } + + return value !== undefined ? + jQuery.style( elem, name, value ) : + jQuery.css( elem, name ); + }, name, value, arguments.length > 1 ); + } +} ); + + +function Tween( elem, options, prop, end, easing ) { + return new Tween.prototype.init( elem, options, prop, end, easing ); +} +jQuery.Tween = Tween; + +Tween.prototype = { + constructor: Tween, + init: function( elem, options, prop, end, easing, unit ) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + }, + cur: function() { + var hooks = Tween.propHooks[ this.prop ]; + + return hooks && hooks.get ? + hooks.get( this ) : + Tween.propHooks._default.get( this ); + }, + run: function( percent ) { + var eased, + hooks = Tween.propHooks[ this.prop ]; + + if ( this.options.duration ) { + this.pos = eased = jQuery.easing[ this.easing ]( + percent, this.options.duration * percent, 0, 1, this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = ( this.end - this.start ) * eased + this.start; + + if ( this.options.step ) { + this.options.step.call( this.elem, this.now, this ); + } + + if ( hooks && hooks.set ) { + hooks.set( this ); + } else { + Tween.propHooks._default.set( this ); + } + return this; + } +}; + +Tween.prototype.init.prototype = Tween.prototype; + +Tween.propHooks = { + _default: { + get: function( tween ) { + var result; + + // Use a property on the element directly when it is not a DOM element, + // or when there is no matching style property that exists. + if ( tween.elem.nodeType !== 1 || + tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { + return tween.elem[ tween.prop ]; + } + + // Passing an empty string as a 3rd parameter to .css will automatically + // attempt a parseFloat and fallback to a string if the parse fails. + // Simple values such as "10px" are parsed to Float; + // complex values such as "rotate(1rad)" are returned as-is. + result = jQuery.css( tween.elem, tween.prop, "" ); + + // Empty strings, null, undefined and "auto" are converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set: function( tween ) { + + // Use step hook for back compat. + // Use cssHook if its there. + // Use .style if available and use plain properties where available. + if ( jQuery.fx.step[ tween.prop ] ) { + jQuery.fx.step[ tween.prop ]( tween ); + } else if ( tween.elem.nodeType === 1 && ( + jQuery.cssHooks[ tween.prop ] || + tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); + } else { + tween.elem[ tween.prop ] = tween.now; + } + } + } +}; + +// Support: IE <=9 only +// Panic based approach to setting things on disconnected nodes +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function( tween ) { + if ( tween.elem.nodeType && tween.elem.parentNode ) { + tween.elem[ tween.prop ] = tween.now; + } + } +}; + +jQuery.easing = { + linear: function( p ) { + return p; + }, + swing: function( p ) { + return 0.5 - Math.cos( p * Math.PI ) / 2; + }, + _default: "swing" +}; + +jQuery.fx = Tween.prototype.init; + +// Back compat <1.8 extension point +jQuery.fx.step = {}; + + + + +var + fxNow, inProgress, + rfxtypes = /^(?:toggle|show|hide)$/, + rrun = /queueHooks$/; + +function schedule() { + if ( inProgress ) { + if ( document.hidden === false && window.requestAnimationFrame ) { + window.requestAnimationFrame( schedule ); + } else { + window.setTimeout( schedule, jQuery.fx.interval ); + } + + jQuery.fx.tick(); + } +} + +// Animations created synchronously will run synchronously +function createFxNow() { + window.setTimeout( function() { + fxNow = undefined; + } ); + return ( fxNow = Date.now() ); +} + +// Generate parameters to create a standard animation +function genFx( type, includeWidth ) { + var which, + i = 0, + attrs = { height: type }; + + // If we include width, step value is 1 to do all cssExpand values, + // otherwise step value is 2 to skip over Left and Right + includeWidth = includeWidth ? 1 : 0; + for ( ; i < 4; i += 2 - includeWidth ) { + which = cssExpand[ i ]; + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; + } + + if ( includeWidth ) { + attrs.opacity = attrs.width = type; + } + + return attrs; +} + +function createTween( value, prop, animation ) { + var tween, + collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), + index = 0, + length = collection.length; + for ( ; index < length; index++ ) { + if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { + + // We're done with this property + return tween; + } + } +} + +function defaultPrefilter( elem, props, opts ) { + var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, + isBox = "width" in props || "height" in props, + anim = this, + orig = {}, + style = elem.style, + hidden = elem.nodeType && isHiddenWithinTree( elem ), + dataShow = dataPriv.get( elem, "fxshow" ); + + // Queue-skipping animations hijack the fx hooks + if ( !opts.queue ) { + hooks = jQuery._queueHooks( elem, "fx" ); + if ( hooks.unqueued == null ) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if ( !hooks.unqueued ) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always( function() { + + // Ensure the complete handler is called before this completes + anim.always( function() { + hooks.unqueued--; + if ( !jQuery.queue( elem, "fx" ).length ) { + hooks.empty.fire(); + } + } ); + } ); + } + + // Detect show/hide animations + for ( prop in props ) { + value = props[ prop ]; + if ( rfxtypes.test( value ) ) { + delete props[ prop ]; + toggle = toggle || value === "toggle"; + if ( value === ( hidden ? "hide" : "show" ) ) { + + // Pretend to be hidden if this is a "show" and + // there is still data from a stopped show/hide + if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { + hidden = true; + + // Ignore all other no-op show/hide data + } else { + continue; + } + } + orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); + } + } + + // Bail out if this is a no-op like .hide().hide() + propTween = !jQuery.isEmptyObject( props ); + if ( !propTween && jQuery.isEmptyObject( orig ) ) { + return; + } + + // Restrict "overflow" and "display" styles during box animations + if ( isBox && elem.nodeType === 1 ) { + + // Support: IE <=9 - 11, Edge 12 - 15 + // Record all 3 overflow attributes because IE does not infer the shorthand + // from identically-valued overflowX and overflowY and Edge just mirrors + // the overflowX value there. + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Identify a display type, preferring old show/hide data over the CSS cascade + restoreDisplay = dataShow && dataShow.display; + if ( restoreDisplay == null ) { + restoreDisplay = dataPriv.get( elem, "display" ); + } + display = jQuery.css( elem, "display" ); + if ( display === "none" ) { + if ( restoreDisplay ) { + display = restoreDisplay; + } else { + + // Get nonempty value(s) by temporarily forcing visibility + showHide( [ elem ], true ); + restoreDisplay = elem.style.display || restoreDisplay; + display = jQuery.css( elem, "display" ); + showHide( [ elem ] ); + } + } + + // Animate inline elements as inline-block + if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { + if ( jQuery.css( elem, "float" ) === "none" ) { + + // Restore the original display value at the end of pure show/hide animations + if ( !propTween ) { + anim.done( function() { + style.display = restoreDisplay; + } ); + if ( restoreDisplay == null ) { + display = style.display; + restoreDisplay = display === "none" ? "" : display; + } + } + style.display = "inline-block"; + } + } + } + + if ( opts.overflow ) { + style.overflow = "hidden"; + anim.always( function() { + style.overflow = opts.overflow[ 0 ]; + style.overflowX = opts.overflow[ 1 ]; + style.overflowY = opts.overflow[ 2 ]; + } ); + } + + // Implement show/hide animations + propTween = false; + for ( prop in orig ) { + + // General show/hide setup for this element animation + if ( !propTween ) { + if ( dataShow ) { + if ( "hidden" in dataShow ) { + hidden = dataShow.hidden; + } + } else { + dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); + } + + // Store hidden/visible for toggle so `.stop().toggle()` "reverses" + if ( toggle ) { + dataShow.hidden = !hidden; + } + + // Show elements before animating them + if ( hidden ) { + showHide( [ elem ], true ); + } + + /* eslint-disable no-loop-func */ + + anim.done( function() { + + /* eslint-enable no-loop-func */ + + // The final step of a "hide" animation is actually hiding the element + if ( !hidden ) { + showHide( [ elem ] ); + } + dataPriv.remove( elem, "fxshow" ); + for ( prop in orig ) { + jQuery.style( elem, prop, orig[ prop ] ); + } + } ); + } + + // Per-property setup + propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); + if ( !( prop in dataShow ) ) { + dataShow[ prop ] = propTween.start; + if ( hidden ) { + propTween.end = propTween.start; + propTween.start = 0; + } + } + } +} + +function propFilter( props, specialEasing ) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for ( index in props ) { + name = camelCase( index ); + easing = specialEasing[ name ]; + value = props[ index ]; + if ( Array.isArray( value ) ) { + easing = value[ 1 ]; + value = props[ index ] = value[ 0 ]; + } + + if ( index !== name ) { + props[ name ] = value; + delete props[ index ]; + } + + hooks = jQuery.cssHooks[ name ]; + if ( hooks && "expand" in hooks ) { + value = hooks.expand( value ); + delete props[ name ]; + + // Not quite $.extend, this won't overwrite existing keys. + // Reusing 'index' because we have the correct "name" + for ( index in value ) { + if ( !( index in props ) ) { + props[ index ] = value[ index ]; + specialEasing[ index ] = easing; + } + } + } else { + specialEasing[ name ] = easing; + } + } +} + +function Animation( elem, properties, options ) { + var result, + stopped, + index = 0, + length = Animation.prefilters.length, + deferred = jQuery.Deferred().always( function() { + + // Don't match elem in the :animated selector + delete tick.elem; + } ), + tick = function() { + if ( stopped ) { + return false; + } + var currentTime = fxNow || createFxNow(), + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), + + // Support: Android 2.3 only + // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) + temp = remaining / animation.duration || 0, + percent = 1 - temp, + index = 0, + length = animation.tweens.length; + + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( percent ); + } + + deferred.notifyWith( elem, [ animation, percent, remaining ] ); + + // If there's more to do, yield + if ( percent < 1 && length ) { + return remaining; + } + + // If this was an empty animation, synthesize a final progress notification + if ( !length ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + } + + // Resolve the animation and report its conclusion + deferred.resolveWith( elem, [ animation ] ); + return false; + }, + animation = deferred.promise( { + elem: elem, + props: jQuery.extend( {}, properties ), + opts: jQuery.extend( true, { + specialEasing: {}, + easing: jQuery.easing._default + }, options ), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function( prop, end ) { + var tween = jQuery.Tween( elem, animation.opts, prop, end, + animation.opts.specialEasing[ prop ] || animation.opts.easing ); + animation.tweens.push( tween ); + return tween; + }, + stop: function( gotoEnd ) { + var index = 0, + + // If we are going to the end, we want to run all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if ( stopped ) { + return this; + } + stopped = true; + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( 1 ); + } + + // Resolve when we played the last frame; otherwise, reject + if ( gotoEnd ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + deferred.resolveWith( elem, [ animation, gotoEnd ] ); + } else { + deferred.rejectWith( elem, [ animation, gotoEnd ] ); + } + return this; + } + } ), + props = animation.props; + + propFilter( props, animation.opts.specialEasing ); + + for ( ; index < length; index++ ) { + result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); + if ( result ) { + if ( isFunction( result.stop ) ) { + jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = + result.stop.bind( result ); + } + return result; + } + } + + jQuery.map( props, createTween, animation ); + + if ( isFunction( animation.opts.start ) ) { + animation.opts.start.call( elem, animation ); + } + + // Attach callbacks from options + animation + .progress( animation.opts.progress ) + .done( animation.opts.done, animation.opts.complete ) + .fail( animation.opts.fail ) + .always( animation.opts.always ); + + jQuery.fx.timer( + jQuery.extend( tick, { + elem: elem, + anim: animation, + queue: animation.opts.queue + } ) + ); + + return animation; +} + +jQuery.Animation = jQuery.extend( Animation, { + + tweeners: { + "*": [ function( prop, value ) { + var tween = this.createTween( prop, value ); + adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); + return tween; + } ] + }, + + tweener: function( props, callback ) { + if ( isFunction( props ) ) { + callback = props; + props = [ "*" ]; + } else { + props = props.match( rnothtmlwhite ); + } + + var prop, + index = 0, + length = props.length; + + for ( ; index < length; index++ ) { + prop = props[ index ]; + Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; + Animation.tweeners[ prop ].unshift( callback ); + } + }, + + prefilters: [ defaultPrefilter ], + + prefilter: function( callback, prepend ) { + if ( prepend ) { + Animation.prefilters.unshift( callback ); + } else { + Animation.prefilters.push( callback ); + } + } +} ); + +jQuery.speed = function( speed, easing, fn ) { + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { + complete: fn || !fn && easing || + isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && !isFunction( easing ) && easing + }; + + // Go to the end state if fx are off + if ( jQuery.fx.off ) { + opt.duration = 0; + + } else { + if ( typeof opt.duration !== "number" ) { + if ( opt.duration in jQuery.fx.speeds ) { + opt.duration = jQuery.fx.speeds[ opt.duration ]; + + } else { + opt.duration = jQuery.fx.speeds._default; + } + } + } + + // Normalize opt.queue - true/undefined/null -> "fx" + if ( opt.queue == null || opt.queue === true ) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if ( isFunction( opt.old ) ) { + opt.old.call( this ); + } + + if ( opt.queue ) { + jQuery.dequeue( this, opt.queue ); + } + }; + + return opt; +}; + +jQuery.fn.extend( { + fadeTo: function( speed, to, easing, callback ) { + + // Show any hidden elements after setting opacity to 0 + return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() + + // Animate to the value specified + .end().animate( { opacity: to }, speed, easing, callback ); + }, + animate: function( prop, speed, easing, callback ) { + var empty = jQuery.isEmptyObject( prop ), + optall = jQuery.speed( speed, easing, callback ), + doAnimation = function() { + + // Operate on a copy of prop so per-property easing won't be lost + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); + + // Empty animations, or finishing resolves immediately + if ( empty || dataPriv.get( this, "finish" ) ) { + anim.stop( true ); + } + }; + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? + this.each( doAnimation ) : + this.queue( optall.queue, doAnimation ); + }, + stop: function( type, clearQueue, gotoEnd ) { + var stopQueue = function( hooks ) { + var stop = hooks.stop; + delete hooks.stop; + stop( gotoEnd ); + }; + + if ( typeof type !== "string" ) { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if ( clearQueue ) { + this.queue( type || "fx", [] ); + } + + return this.each( function() { + var dequeue = true, + index = type != null && type + "queueHooks", + timers = jQuery.timers, + data = dataPriv.get( this ); + + if ( index ) { + if ( data[ index ] && data[ index ].stop ) { + stopQueue( data[ index ] ); + } + } else { + for ( index in data ) { + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { + stopQueue( data[ index ] ); + } + } + } + + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && + ( type == null || timers[ index ].queue === type ) ) { + + timers[ index ].anim.stop( gotoEnd ); + dequeue = false; + timers.splice( index, 1 ); + } + } + + // Start the next in the queue if the last step wasn't forced. + // Timers currently will call their complete callbacks, which + // will dequeue but only if they were gotoEnd. + if ( dequeue || !gotoEnd ) { + jQuery.dequeue( this, type ); + } + } ); + }, + finish: function( type ) { + if ( type !== false ) { + type = type || "fx"; + } + return this.each( function() { + var index, + data = dataPriv.get( this ), + queue = data[ type + "queue" ], + hooks = data[ type + "queueHooks" ], + timers = jQuery.timers, + length = queue ? queue.length : 0; + + // Enable finishing flag on private data + data.finish = true; + + // Empty the queue first + jQuery.queue( this, type, [] ); + + if ( hooks && hooks.stop ) { + hooks.stop.call( this, true ); + } + + // Look for any active animations, and finish them + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && timers[ index ].queue === type ) { + timers[ index ].anim.stop( true ); + timers.splice( index, 1 ); + } + } + + // Look for any animations in the old queue and finish them + for ( index = 0; index < length; index++ ) { + if ( queue[ index ] && queue[ index ].finish ) { + queue[ index ].finish.call( this ); + } + } + + // Turn off finishing flag + delete data.finish; + } ); + } +} ); + +jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { + var cssFn = jQuery.fn[ name ]; + jQuery.fn[ name ] = function( speed, easing, callback ) { + return speed == null || typeof speed === "boolean" ? + cssFn.apply( this, arguments ) : + this.animate( genFx( name, true ), speed, easing, callback ); + }; +} ); + +// Generate shortcuts for custom animations +jQuery.each( { + slideDown: genFx( "show" ), + slideUp: genFx( "hide" ), + slideToggle: genFx( "toggle" ), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } +}, function( name, props ) { + jQuery.fn[ name ] = function( speed, easing, callback ) { + return this.animate( props, speed, easing, callback ); + }; +} ); + +jQuery.timers = []; +jQuery.fx.tick = function() { + var timer, + i = 0, + timers = jQuery.timers; + + fxNow = Date.now(); + + for ( ; i < timers.length; i++ ) { + timer = timers[ i ]; + + // Run the timer and safely remove it when done (allowing for external removal) + if ( !timer() && timers[ i ] === timer ) { + timers.splice( i--, 1 ); + } + } + + if ( !timers.length ) { + jQuery.fx.stop(); + } + fxNow = undefined; +}; + +jQuery.fx.timer = function( timer ) { + jQuery.timers.push( timer ); + jQuery.fx.start(); +}; + +jQuery.fx.interval = 13; +jQuery.fx.start = function() { + if ( inProgress ) { + return; + } + + inProgress = true; + schedule(); +}; + +jQuery.fx.stop = function() { + inProgress = null; +}; + +jQuery.fx.speeds = { + slow: 600, + fast: 200, + + // Default speed + _default: 400 +}; + + +// Based off of the plugin by Clint Helfers, with permission. +// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ +jQuery.fn.delay = function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = window.setTimeout( next, time ); + hooks.stop = function() { + window.clearTimeout( timeout ); + }; + } ); +}; + + +( function() { + var input = document.createElement( "input" ), + select = document.createElement( "select" ), + opt = select.appendChild( document.createElement( "option" ) ); + + input.type = "checkbox"; + + // Support: Android <=4.3 only + // Default value for a checkbox should be "on" + support.checkOn = input.value !== ""; + + // Support: IE <=11 only + // Must access selectedIndex to make default options select + support.optSelected = opt.selected; + + // Support: IE <=11 only + // An input loses its value after becoming a radio + input = document.createElement( "input" ); + input.value = "t"; + input.type = "radio"; + support.radioValue = input.value === "t"; +} )(); + + +var boolHook, + attrHandle = jQuery.expr.attrHandle; + +jQuery.fn.extend( { + attr: function( name, value ) { + return access( this, jQuery.attr, name, value, arguments.length > 1 ); + }, + + removeAttr: function( name ) { + return this.each( function() { + jQuery.removeAttr( this, name ); + } ); + } +} ); + +jQuery.extend( { + attr: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set attributes on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === "undefined" ) { + return jQuery.prop( elem, name, value ); + } + + // Attribute hooks are determined by the lowercase version + // Grab necessary hook if one is defined + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + hooks = jQuery.attrHooks[ name.toLowerCase() ] || + ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); + } + + if ( value !== undefined ) { + if ( value === null ) { + jQuery.removeAttr( elem, name ); + return; + } + + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + elem.setAttribute( name, value + "" ); + return value; + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + ret = jQuery.find.attr( elem, name ); + + // Non-existent attributes return null, we normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks: { + type: { + set: function( elem, value ) { + if ( !support.radioValue && value === "radio" && + nodeName( elem, "input" ) ) { + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr: function( elem, value ) { + var name, + i = 0, + + // Attribute names can contain non-HTML whitespace characters + // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 + attrNames = value && value.match( rnothtmlwhite ); + + if ( attrNames && elem.nodeType === 1 ) { + while ( ( name = attrNames[ i++ ] ) ) { + elem.removeAttribute( name ); + } + } + } +} ); + +// Hooks for boolean attributes +boolHook = { + set: function( elem, value, name ) { + if ( value === false ) { + + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else { + elem.setAttribute( name, name ); + } + return name; + } +}; + +jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { + var getter = attrHandle[ name ] || jQuery.find.attr; + + attrHandle[ name ] = function( elem, name, isXML ) { + var ret, handle, + lowercaseName = name.toLowerCase(); + + if ( !isXML ) { + + // Avoid an infinite loop by temporarily removing this function from the getter + handle = attrHandle[ lowercaseName ]; + attrHandle[ lowercaseName ] = ret; + ret = getter( elem, name, isXML ) != null ? + lowercaseName : + null; + attrHandle[ lowercaseName ] = handle; + } + return ret; + }; +} ); + + + + +var rfocusable = /^(?:input|select|textarea|button)$/i, + rclickable = /^(?:a|area)$/i; + +jQuery.fn.extend( { + prop: function( name, value ) { + return access( this, jQuery.prop, name, value, arguments.length > 1 ); + }, + + removeProp: function( name ) { + return this.each( function() { + delete this[ jQuery.propFix[ name ] || name ]; + } ); + } +} ); + +jQuery.extend( { + prop: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set properties on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + return ( elem[ name ] = value ); + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + return elem[ name ]; + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + + // Support: IE <=9 - 11 only + // elem.tabIndex doesn't always return the + // correct value when it hasn't been explicitly set + // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + // Use proper attribute retrieval(#12072) + var tabindex = jQuery.find.attr( elem, "tabindex" ); + + if ( tabindex ) { + return parseInt( tabindex, 10 ); + } + + if ( + rfocusable.test( elem.nodeName ) || + rclickable.test( elem.nodeName ) && + elem.href + ) { + return 0; + } + + return -1; + } + } + }, + + propFix: { + "for": "htmlFor", + "class": "className" + } +} ); + +// Support: IE <=11 only +// Accessing the selectedIndex property +// forces the browser to respect setting selected +// on the option +// The getter ensures a default option is selected +// when in an optgroup +// eslint rule "no-unused-expressions" is disabled for this code +// since it considers such accessions noop +if ( !support.optSelected ) { + jQuery.propHooks.selected = { + get: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent && parent.parentNode ) { + parent.parentNode.selectedIndex; + } + return null; + }, + set: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent ) { + parent.selectedIndex; + + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + } + }; +} + +jQuery.each( [ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" +], function() { + jQuery.propFix[ this.toLowerCase() ] = this; +} ); + + + + + // Strip and collapse whitespace according to HTML spec + // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace + function stripAndCollapse( value ) { + var tokens = value.match( rnothtmlwhite ) || []; + return tokens.join( " " ); + } + + +function getClass( elem ) { + return elem.getAttribute && elem.getAttribute( "class" ) || ""; +} + +function classesToArray( value ) { + if ( Array.isArray( value ) ) { + return value; + } + if ( typeof value === "string" ) { + return value.match( rnothtmlwhite ) || []; + } + return []; +} + +jQuery.fn.extend( { + addClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + if ( cur.indexOf( " " + clazz + " " ) < 0 ) { + cur += clazz + " "; + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + removeClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + if ( !arguments.length ) { + return this.attr( "class", "" ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + + // This expression is here for better compressibility (see addClass) + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + + // Remove *all* instances + while ( cur.indexOf( " " + clazz + " " ) > -1 ) { + cur = cur.replace( " " + clazz + " ", " " ); + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var type = typeof value, + isValidValue = type === "string" || Array.isArray( value ); + + if ( typeof stateVal === "boolean" && isValidValue ) { + return stateVal ? this.addClass( value ) : this.removeClass( value ); + } + + if ( isFunction( value ) ) { + return this.each( function( i ) { + jQuery( this ).toggleClass( + value.call( this, i, getClass( this ), stateVal ), + stateVal + ); + } ); + } + + return this.each( function() { + var className, i, self, classNames; + + if ( isValidValue ) { + + // Toggle individual class names + i = 0; + self = jQuery( this ); + classNames = classesToArray( value ); + + while ( ( className = classNames[ i++ ] ) ) { + + // Check each className given, space separated list + if ( self.hasClass( className ) ) { + self.removeClass( className ); + } else { + self.addClass( className ); + } + } + + // Toggle whole class name + } else if ( value === undefined || type === "boolean" ) { + className = getClass( this ); + if ( className ) { + + // Store className if set + dataPriv.set( this, "__className__", className ); + } + + // If the element has a class name or if we're passed `false`, + // then remove the whole classname (if there was one, the above saved it). + // Otherwise bring back whatever was previously saved (if anything), + // falling back to the empty string if nothing was stored. + if ( this.setAttribute ) { + this.setAttribute( "class", + className || value === false ? + "" : + dataPriv.get( this, "__className__" ) || "" + ); + } + } + } ); + }, + + hasClass: function( selector ) { + var className, elem, + i = 0; + + className = " " + selector + " "; + while ( ( elem = this[ i++ ] ) ) { + if ( elem.nodeType === 1 && + ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { + return true; + } + } + + return false; + } +} ); + + + + +var rreturn = /\r/g; + +jQuery.fn.extend( { + val: function( value ) { + var hooks, ret, valueIsFunction, + elem = this[ 0 ]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.type ] || + jQuery.valHooks[ elem.nodeName.toLowerCase() ]; + + if ( hooks && + "get" in hooks && + ( ret = hooks.get( elem, "value" ) ) !== undefined + ) { + return ret; + } + + ret = elem.value; + + // Handle most common string cases + if ( typeof ret === "string" ) { + return ret.replace( rreturn, "" ); + } + + // Handle cases where value is null/undef or number + return ret == null ? "" : ret; + } + + return; + } + + valueIsFunction = isFunction( value ); + + return this.each( function( i ) { + var val; + + if ( this.nodeType !== 1 ) { + return; + } + + if ( valueIsFunction ) { + val = value.call( this, i, jQuery( this ).val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + + } else if ( typeof val === "number" ) { + val += ""; + + } else if ( Array.isArray( val ) ) { + val = jQuery.map( val, function( value ) { + return value == null ? "" : value + ""; + } ); + } + + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + } ); + } +} ); + +jQuery.extend( { + valHooks: { + option: { + get: function( elem ) { + + var val = jQuery.find.attr( elem, "value" ); + return val != null ? + val : + + // Support: IE <=10 - 11 only + // option.text throws exceptions (#14686, #14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + stripAndCollapse( jQuery.text( elem ) ); + } + }, + select: { + get: function( elem ) { + var value, option, i, + options = elem.options, + index = elem.selectedIndex, + one = elem.type === "select-one", + values = one ? null : [], + max = one ? index + 1 : options.length; + + if ( index < 0 ) { + i = max; + + } else { + i = one ? index : 0; + } + + // Loop through all the selected options + for ( ; i < max; i++ ) { + option = options[ i ]; + + // Support: IE <=9 only + // IE8-9 doesn't update selected after form reset (#2551) + if ( ( option.selected || i === index ) && + + // Don't return options that are disabled or in a disabled optgroup + !option.disabled && + ( !option.parentNode.disabled || + !nodeName( option.parentNode, "optgroup" ) ) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + }, + + set: function( elem, value ) { + var optionSet, option, + options = elem.options, + values = jQuery.makeArray( value ), + i = options.length; + + while ( i-- ) { + option = options[ i ]; + + /* eslint-disable no-cond-assign */ + + if ( option.selected = + jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 + ) { + optionSet = true; + } + + /* eslint-enable no-cond-assign */ + } + + // Force browsers to behave consistently when non-matching value is set + if ( !optionSet ) { + elem.selectedIndex = -1; + } + return values; + } + } + } +} ); + +// Radios and checkboxes getter/setter +jQuery.each( [ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + set: function( elem, value ) { + if ( Array.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); + } + } + }; + if ( !support.checkOn ) { + jQuery.valHooks[ this ].get = function( elem ) { + return elem.getAttribute( "value" ) === null ? "on" : elem.value; + }; + } +} ); + + + + +// Return jQuery for attributes-only inclusion + + +support.focusin = "onfocusin" in window; + + +var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + stopPropagationCallback = function( e ) { + e.stopPropagation(); + }; + +jQuery.extend( jQuery.event, { + + trigger: function( event, data, elem, onlyHandlers ) { + + var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, + eventPath = [ elem || document ], + type = hasOwn.call( event, "type" ) ? event.type : event, + namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; + + cur = lastElement = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if ( elem.nodeType === 3 || elem.nodeType === 8 ) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf( "." ) > -1 ) { + + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split( "." ); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf( ":" ) < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, or just an event type string + event = event[ jQuery.expando ] ? + event : + new jQuery.Event( type, typeof event === "object" && event ); + + // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join( "." ); + event.rnamespace = event.namespace ? + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : + null; + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data == null ? + [ event ] : + jQuery.makeArray( data, [ event ] ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (#9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) + if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + if ( !rfocusMorph.test( bubbleType + type ) ) { + cur = cur.parentNode; + } + for ( ; cur; cur = cur.parentNode ) { + eventPath.push( cur ); + tmp = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( tmp === ( elem.ownerDocument || document ) ) { + eventPath.push( tmp.defaultView || tmp.parentWindow || window ); + } + } + + // Fire handlers on the event path + i = 0; + while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { + lastElement = cur; + event.type = i > 1 ? + bubbleType : + special.bindType || type; + + // jQuery handler + handle = ( + dataPriv.get( cur, "events" ) || Object.create( null ) + )[ event.type ] && + dataPriv.get( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + + // Native handler + handle = ontype && cur[ ontype ]; + if ( handle && handle.apply && acceptData( cur ) ) { + event.result = handle.apply( cur, data ); + if ( event.result === false ) { + event.preventDefault(); + } + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( ( !special._default || + special._default.apply( eventPath.pop(), data ) === false ) && + acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name as the event. + // Don't do default actions on window, that's where global variables be (#6170) + if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + tmp = elem[ ontype ]; + + if ( tmp ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + + if ( event.isPropagationStopped() ) { + lastElement.addEventListener( type, stopPropagationCallback ); + } + + elem[ type ](); + + if ( event.isPropagationStopped() ) { + lastElement.removeEventListener( type, stopPropagationCallback ); + } + + jQuery.event.triggered = undefined; + + if ( tmp ) { + elem[ ontype ] = tmp; + } + } + } + } + + return event.result; + }, + + // Piggyback on a donor event to simulate a different one + // Used only for `focus(in | out)` events + simulate: function( type, elem, event ) { + var e = jQuery.extend( + new jQuery.Event(), + event, + { + type: type, + isSimulated: true + } + ); + + jQuery.event.trigger( e, null, elem ); + } + +} ); + +jQuery.fn.extend( { + + trigger: function( type, data ) { + return this.each( function() { + jQuery.event.trigger( type, data, this ); + } ); + }, + triggerHandler: function( type, data ) { + var elem = this[ 0 ]; + if ( elem ) { + return jQuery.event.trigger( type, data, elem, true ); + } + } +} ); + + +// Support: Firefox <=44 +// Firefox doesn't have focus(in | out) events +// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 +// +// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 +// focus(in | out) events fire after focus & blur events, +// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order +// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 +if ( !support.focusin ) { + jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { + + // Attach a single capturing handler on the document while someone wants focusin/focusout + var handler = function( event ) { + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); + }; + + jQuery.event.special[ fix ] = { + setup: function() { + + // Handle: regular nodes (via `this.ownerDocument`), window + // (via `this.document`) & document (via `this`). + var doc = this.ownerDocument || this.document || this, + attaches = dataPriv.access( doc, fix ); + + if ( !attaches ) { + doc.addEventListener( orig, handler, true ); + } + dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); + }, + teardown: function() { + var doc = this.ownerDocument || this.document || this, + attaches = dataPriv.access( doc, fix ) - 1; + + if ( !attaches ) { + doc.removeEventListener( orig, handler, true ); + dataPriv.remove( doc, fix ); + + } else { + dataPriv.access( doc, fix, attaches ); + } + } + }; + } ); +} +var location = window.location; + +var nonce = { guid: Date.now() }; + +var rquery = ( /\?/ ); + + + +// Cross-browser xml parsing +jQuery.parseXML = function( data ) { + var xml; + if ( !data || typeof data !== "string" ) { + return null; + } + + // Support: IE 9 - 11 only + // IE throws on parseFromString with invalid input. + try { + xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); + } catch ( e ) { + xml = undefined; + } + + if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { + jQuery.error( "Invalid XML: " + data ); + } + return xml; +}; + + +var + rbracket = /\[\]$/, + rCRLF = /\r?\n/g, + rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, + rsubmittable = /^(?:input|select|textarea|keygen)/i; + +function buildParams( prefix, obj, traditional, add ) { + var name; + + if ( Array.isArray( obj ) ) { + + // Serialize array item. + jQuery.each( obj, function( i, v ) { + if ( traditional || rbracket.test( prefix ) ) { + + // Treat each array item as a scalar. + add( prefix, v ); + + } else { + + // Item is non-scalar (array or object), encode its numeric index. + buildParams( + prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", + v, + traditional, + add + ); + } + } ); + + } else if ( !traditional && toType( obj ) === "object" ) { + + // Serialize object item. + for ( name in obj ) { + buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); + } + + } else { + + // Serialize scalar item. + add( prefix, obj ); + } +} + +// Serialize an array of form elements or a set of +// key/values into a query string +jQuery.param = function( a, traditional ) { + var prefix, + s = [], + add = function( key, valueOrFunction ) { + + // If value is a function, invoke it and use its return value + var value = isFunction( valueOrFunction ) ? + valueOrFunction() : + valueOrFunction; + + s[ s.length ] = encodeURIComponent( key ) + "=" + + encodeURIComponent( value == null ? "" : value ); + }; + + if ( a == null ) { + return ""; + } + + // If an array was passed in, assume that it is an array of form elements. + if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { + + // Serialize the form elements + jQuery.each( a, function() { + add( this.name, this.value ); + } ); + + } else { + + // If traditional, encode the "old" way (the way 1.3.2 or older + // did it), otherwise encode params recursively. + for ( prefix in a ) { + buildParams( prefix, a[ prefix ], traditional, add ); + } + } + + // Return the resulting serialization + return s.join( "&" ); +}; + +jQuery.fn.extend( { + serialize: function() { + return jQuery.param( this.serializeArray() ); + }, + serializeArray: function() { + return this.map( function() { + + // Can add propHook for "elements" to filter or add form elements + var elements = jQuery.prop( this, "elements" ); + return elements ? jQuery.makeArray( elements ) : this; + } ) + .filter( function() { + var type = this.type; + + // Use .is( ":disabled" ) so that fieldset[disabled] works + return this.name && !jQuery( this ).is( ":disabled" ) && + rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && + ( this.checked || !rcheckableType.test( type ) ); + } ) + .map( function( _i, elem ) { + var val = jQuery( this ).val(); + + if ( val == null ) { + return null; + } + + if ( Array.isArray( val ) ) { + return jQuery.map( val, function( val ) { + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ); + } + + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ).get(); + } +} ); + + +var + r20 = /%20/g, + rhash = /#.*$/, + rantiCache = /([?&])_=[^&]*/, + rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, + + // #7653, #8125, #8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, + rnoContent = /^(?:GET|HEAD)$/, + rprotocol = /^\/\//, + + /* Prefilters + * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) + * 2) These are called: + * - BEFORE asking for a transport + * - AFTER param serialization (s.data is a string if s.processData is true) + * 3) key is the dataType + * 4) the catchall symbol "*" can be used + * 5) execution will start with transport dataType and THEN continue down to "*" if needed + */ + prefilters = {}, + + /* Transports bindings + * 1) key is the dataType + * 2) the catchall symbol "*" can be used + * 3) selection will start with transport dataType and THEN go to "*" if needed + */ + transports = {}, + + // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression + allTypes = "*/".concat( "*" ), + + // Anchor tag for parsing the document origin + originAnchor = document.createElement( "a" ); + originAnchor.href = location.href; + +// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport +function addToPrefiltersOrTransports( structure ) { + + // dataTypeExpression is optional and defaults to "*" + return function( dataTypeExpression, func ) { + + if ( typeof dataTypeExpression !== "string" ) { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + + var dataType, + i = 0, + dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; + + if ( isFunction( func ) ) { + + // For each dataType in the dataTypeExpression + while ( ( dataType = dataTypes[ i++ ] ) ) { + + // Prepend if requested + if ( dataType[ 0 ] === "+" ) { + dataType = dataType.slice( 1 ) || "*"; + ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); + + // Otherwise append + } else { + ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); + } + } + } + }; +} + +// Base inspection function for prefilters and transports +function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { + + var inspected = {}, + seekingTransport = ( structure === transports ); + + function inspect( dataType ) { + var selected; + inspected[ dataType ] = true; + jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { + var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); + if ( typeof dataTypeOrTransport === "string" && + !seekingTransport && !inspected[ dataTypeOrTransport ] ) { + + options.dataTypes.unshift( dataTypeOrTransport ); + inspect( dataTypeOrTransport ); + return false; + } else if ( seekingTransport ) { + return !( selected = dataTypeOrTransport ); + } + } ); + return selected; + } + + return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); +} + +// A special extend for ajax options +// that takes "flat" options (not to be deep extended) +// Fixes #9887 +function ajaxExtend( target, src ) { + var key, deep, + flatOptions = jQuery.ajaxSettings.flatOptions || {}; + + for ( key in src ) { + if ( src[ key ] !== undefined ) { + ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; + } + } + if ( deep ) { + jQuery.extend( true, target, deep ); + } + + return target; +} + +/* Handles responses to an ajax request: + * - finds the right dataType (mediates between content-type and expected dataType) + * - returns the corresponding response + */ +function ajaxHandleResponses( s, jqXHR, responses ) { + + var ct, type, finalDataType, firstDataType, + contents = s.contents, + dataTypes = s.dataTypes; + + // Remove auto dataType and get content-type in the process + while ( dataTypes[ 0 ] === "*" ) { + dataTypes.shift(); + if ( ct === undefined ) { + ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); + } + } + + // Check if we're dealing with a known content-type + if ( ct ) { + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + dataTypes.unshift( type ); + break; + } + } + } + + // Check to see if we have a response for the expected dataType + if ( dataTypes[ 0 ] in responses ) { + finalDataType = dataTypes[ 0 ]; + } else { + + // Try convertible dataTypes + for ( type in responses ) { + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { + finalDataType = type; + break; + } + if ( !firstDataType ) { + firstDataType = type; + } + } + + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if ( finalDataType ) { + if ( finalDataType !== dataTypes[ 0 ] ) { + dataTypes.unshift( finalDataType ); + } + return responses[ finalDataType ]; + } +} + +/* Chain conversions given the request and the original response + * Also sets the responseXXX fields on the jqXHR instance + */ +function ajaxConvert( s, response, jqXHR, isSuccess ) { + var conv2, current, conv, tmp, prev, + converters = {}, + + // Work with a copy of dataTypes in case we need to modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if ( dataTypes[ 1 ] ) { + for ( conv in s.converters ) { + converters[ conv.toLowerCase() ] = s.converters[ conv ]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while ( current ) { + + if ( s.responseFields[ current ] ) { + jqXHR[ s.responseFields[ current ] ] = response; + } + + // Apply the dataFilter if provided + if ( !prev && isSuccess && s.dataFilter ) { + response = s.dataFilter( response, s.dataType ); + } + + prev = current; + current = dataTypes.shift(); + + if ( current ) { + + // There's only work to do if current dataType is non-auto + if ( current === "*" ) { + + current = prev; + + // Convert response if prev dataType is non-auto and differs from current + } else if ( prev !== "*" && prev !== current ) { + + // Seek a direct converter + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; + + // If none found, seek a pair + if ( !conv ) { + for ( conv2 in converters ) { + + // If conv2 outputs current + tmp = conv2.split( " " ); + if ( tmp[ 1 ] === current ) { + + // If prev can be converted to accepted input + conv = converters[ prev + " " + tmp[ 0 ] ] || + converters[ "* " + tmp[ 0 ] ]; + if ( conv ) { + + // Condense equivalence converters + if ( conv === true ) { + conv = converters[ conv2 ]; + + // Otherwise, insert the intermediate dataType + } else if ( converters[ conv2 ] !== true ) { + current = tmp[ 0 ]; + dataTypes.unshift( tmp[ 1 ] ); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if ( conv !== true ) { + + // Unless errors are allowed to bubble, catch and return them + if ( conv && s.throws ) { + response = conv( response ); + } else { + try { + response = conv( response ); + } catch ( e ) { + return { + state: "parsererror", + error: conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { state: "success", data: response }; +} + +jQuery.extend( { + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {}, + + ajaxSettings: { + url: location.href, + type: "GET", + isLocal: rlocalProtocol.test( location.protocol ), + global: true, + processData: true, + async: true, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + + accepts: { + "*": allTypes, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") and destination types with a single space + converters: { + + // Convert anything to text + "* text": String, + + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": JSON.parse, + + // Parse text as xml + "text xml": jQuery.parseXML + }, + + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + url: true, + context: true + } + }, + + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function( target, settings ) { + return settings ? + + // Building a settings object + ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : + + // Extending ajaxSettings + ajaxExtend( jQuery.ajaxSettings, target ); + }, + + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), + ajaxTransport: addToPrefiltersOrTransports( transports ), + + // Main method + ajax: function( url, options ) { + + // If url is an object, simulate pre-1.5 signature + if ( typeof url === "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var transport, + + // URL without anti-cache param + cacheURL, + + // Response headers + responseHeadersString, + responseHeaders, + + // timeout handle + timeoutTimer, + + // Url cleanup var + urlAnchor, + + // Request state (becomes false upon send and true upon completion) + completed, + + // To know if global events are to be dispatched + fireGlobals, + + // Loop variable + i, + + // uncached part of the url + uncached, + + // Create the final options object + s = jQuery.ajaxSetup( {}, options ), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is callbackContext if it is a DOM node or jQuery collection + globalEventContext = s.context && + ( callbackContext.nodeType || callbackContext.jquery ) ? + jQuery( callbackContext ) : + jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery.Callbacks( "once memory" ), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, + requestHeadersNames = {}, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState: 0, + + // Builds headers hashtable if needed + getResponseHeader: function( key ) { + var match; + if ( completed ) { + if ( !responseHeaders ) { + responseHeaders = {}; + while ( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[ 1 ].toLowerCase() + " " ] = + ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) + .concat( match[ 2 ] ); + } + } + match = responseHeaders[ key.toLowerCase() + " " ]; + } + return match == null ? null : match.join( ", " ); + }, + + // Raw string + getAllResponseHeaders: function() { + return completed ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader: function( name, value ) { + if ( completed == null ) { + name = requestHeadersNames[ name.toLowerCase() ] = + requestHeadersNames[ name.toLowerCase() ] || name; + requestHeaders[ name ] = value; + } + return this; + }, + + // Overrides response content-type header + overrideMimeType: function( type ) { + if ( completed == null ) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode: function( map ) { + var code; + if ( map ) { + if ( completed ) { + + // Execute the appropriate callbacks + jqXHR.always( map[ jqXHR.status ] ); + } else { + + // Lazy-add the new callbacks in a way that preserves old ones + for ( code in map ) { + statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; + } + } + } + return this; + }, + + // Cancel the request + abort: function( statusText ) { + var finalText = statusText || strAbort; + if ( transport ) { + transport.abort( finalText ); + } + done( 0, finalText ); + return this; + } + }; + + // Attach deferreds + deferred.promise( jqXHR ); + + // Add protocol if not provided (prefilters might expect it) + // Handle falsy url in the settings object (#10093: consistency with old signature) + // We also use the url parameter if available + s.url = ( ( url || s.url || location.href ) + "" ) + .replace( rprotocol, location.protocol + "//" ); + + // Alias method option to type as per ticket #12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; + + // A cross-domain request is in order when the origin doesn't match the current origin. + if ( s.crossDomain == null ) { + urlAnchor = document.createElement( "a" ); + + // Support: IE <=8 - 11, Edge 12 - 15 + // IE throws exception on accessing the href property if url is malformed, + // e.g. http://example.com:80x/ + try { + urlAnchor.href = s.url; + + // Support: IE <=8 - 11 only + // Anchor's host property isn't correctly set when s.url is relative + urlAnchor.href = urlAnchor.href; + s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== + urlAnchor.protocol + "//" + urlAnchor.host; + } catch ( e ) { + + // If there is an error parsing the URL, assume it is crossDomain, + // it can be rejected by the transport if it is invalid + s.crossDomain = true; + } + } + + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data, s.traditional ); + } + + // Apply prefilters + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); + + // If request was aborted inside a prefilter, stop there + if ( completed ) { + return jqXHR; + } + + // We can fire global events as of now if asked to + // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if ( fireGlobals && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test( s.type ); + + // Save the URL in case we're toying with the If-Modified-Since + // and/or If-None-Match header later on + // Remove hash to simplify url manipulation + cacheURL = s.url.replace( rhash, "" ); + + // More options handling for requests with no content + if ( !s.hasContent ) { + + // Remember the hash so we can put it back + uncached = s.url.slice( cacheURL.length ); + + // If data is available and should be processed, append data to url + if ( s.data && ( s.processData || typeof s.data === "string" ) ) { + cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; + + // #9682: remove data so that it's not used in an eventual retry + delete s.data; + } + + // Add or update anti-cache param if needed + if ( s.cache === false ) { + cacheURL = cacheURL.replace( rantiCache, "$1" ); + uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + + uncached; + } + + // Put hash and anti-cache on the URL that will be requested (gh-1732) + s.url = cacheURL + uncached; + + // Change '%20' to '+' if this is encoded form body content (gh-2658) + } else if ( s.data && s.processData && + ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { + s.data = s.data.replace( r20, "+" ); + } + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + if ( jQuery.lastModified[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); + } + if ( jQuery.etag[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); + } + } + + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + jqXHR.setRequestHeader( "Content-Type", s.contentType ); + } + + // Set the Accepts header for the server, depending on the dataType + jqXHR.setRequestHeader( + "Accept", + s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? + s.accepts[ s.dataTypes[ 0 ] ] + + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : + s.accepts[ "*" ] + ); + + // Check for headers option + for ( i in s.headers ) { + jqXHR.setRequestHeader( i, s.headers[ i ] ); + } + + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && + ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { + + // Abort if not done already and return + return jqXHR.abort(); + } + + // Aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + completeDeferred.add( s.complete ); + jqXHR.done( s.success ); + jqXHR.fail( s.error ); + + // Get transport + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); + + // If no transport, we auto-abort + if ( !transport ) { + done( -1, "No Transport" ); + } else { + jqXHR.readyState = 1; + + // Send global event + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); + } + + // If request was aborted inside ajaxSend, stop there + if ( completed ) { + return jqXHR; + } + + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = window.setTimeout( function() { + jqXHR.abort( "timeout" ); + }, s.timeout ); + } + + try { + completed = false; + transport.send( requestHeaders, done ); + } catch ( e ) { + + // Rethrow post-completion exceptions + if ( completed ) { + throw e; + } + + // Propagate others as results + done( -1, e ); + } + } + + // Callback for when everything is done + function done( status, nativeStatusText, responses, headers ) { + var isSuccess, success, error, response, modified, + statusText = nativeStatusText; + + // Ignore repeat invocations + if ( completed ) { + return; + } + + completed = true; + + // Clear timeout if it exists + if ( timeoutTimer ) { + window.clearTimeout( timeoutTimer ); + } + + // Dereference transport for early garbage collection + // (no matter how long the jqXHR object will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if ( responses ) { + response = ajaxHandleResponses( s, jqXHR, responses ); + } + + // Use a noop converter for missing script + if ( !isSuccess && jQuery.inArray( "script", s.dataTypes ) > -1 ) { + s.converters[ "text script" ] = function() {}; + } + + // Convert no matter what (that way responseXXX fields are always set) + response = ajaxConvert( s, response, jqXHR, isSuccess ); + + // If successful, handle type chaining + if ( isSuccess ) { + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + modified = jqXHR.getResponseHeader( "Last-Modified" ); + if ( modified ) { + jQuery.lastModified[ cacheURL ] = modified; + } + modified = jqXHR.getResponseHeader( "etag" ); + if ( modified ) { + jQuery.etag[ cacheURL ] = modified; + } + } + + // if no content + if ( status === 204 || s.type === "HEAD" ) { + statusText = "nocontent"; + + // if not modified + } else if ( status === 304 ) { + statusText = "notmodified"; + + // If we have data, let's convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // Extract error from statusText and normalize for non-aborts + error = statusText; + if ( status || !statusText ) { + statusText = "error"; + if ( status < 0 ) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; + + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); + } else { + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); + } + + // Status-dependent callbacks + jqXHR.statusCode( statusCode ); + statusCode = undefined; + + if ( fireGlobals ) { + globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", + [ jqXHR, s, isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); + + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); + + // Handle the global AJAX counter + if ( !( --jQuery.active ) ) { + jQuery.event.trigger( "ajaxStop" ); + } + } + } + + return jqXHR; + }, + + getJSON: function( url, data, callback ) { + return jQuery.get( url, data, callback, "json" ); + }, + + getScript: function( url, callback ) { + return jQuery.get( url, undefined, callback, "script" ); + } +} ); + +jQuery.each( [ "get", "post" ], function( _i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { + + // Shift arguments if data argument was omitted + if ( isFunction( data ) ) { + type = type || callback; + callback = data; + data = undefined; + } + + // The url can be an options object (which then must have .url) + return jQuery.ajax( jQuery.extend( { + url: url, + type: method, + dataType: type, + data: data, + success: callback + }, jQuery.isPlainObject( url ) && url ) ); + }; +} ); + +jQuery.ajaxPrefilter( function( s ) { + var i; + for ( i in s.headers ) { + if ( i.toLowerCase() === "content-type" ) { + s.contentType = s.headers[ i ] || ""; + } + } +} ); + + +jQuery._evalUrl = function( url, options, doc ) { + return jQuery.ajax( { + url: url, + + // Make this explicit, since user can override this through ajaxSetup (#11264) + type: "GET", + dataType: "script", + cache: true, + async: false, + global: false, + + // Only evaluate the response if it is successful (gh-4126) + // dataFilter is not invoked for failure responses, so using it instead + // of the default converter is kludgy but it works. + converters: { + "text script": function() {} + }, + dataFilter: function( response ) { + jQuery.globalEval( response, options, doc ); + } + } ); +}; + + +jQuery.fn.extend( { + wrapAll: function( html ) { + var wrap; + + if ( this[ 0 ] ) { + if ( isFunction( html ) ) { + html = html.call( this[ 0 ] ); + } + + // The elements to wrap the target around + wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); + + if ( this[ 0 ].parentNode ) { + wrap.insertBefore( this[ 0 ] ); + } + + wrap.map( function() { + var elem = this; + + while ( elem.firstElementChild ) { + elem = elem.firstElementChild; + } + + return elem; + } ).append( this ); + } + + return this; + }, + + wrapInner: function( html ) { + if ( isFunction( html ) ) { + return this.each( function( i ) { + jQuery( this ).wrapInner( html.call( this, i ) ); + } ); + } + + return this.each( function() { + var self = jQuery( this ), + contents = self.contents(); + + if ( contents.length ) { + contents.wrapAll( html ); + + } else { + self.append( html ); + } + } ); + }, + + wrap: function( html ) { + var htmlIsFunction = isFunction( html ); + + return this.each( function( i ) { + jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); + } ); + }, + + unwrap: function( selector ) { + this.parent( selector ).not( "body" ).each( function() { + jQuery( this ).replaceWith( this.childNodes ); + } ); + return this; + } +} ); + + +jQuery.expr.pseudos.hidden = function( elem ) { + return !jQuery.expr.pseudos.visible( elem ); +}; +jQuery.expr.pseudos.visible = function( elem ) { + return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); +}; + + + + +jQuery.ajaxSettings.xhr = function() { + try { + return new window.XMLHttpRequest(); + } catch ( e ) {} +}; + +var xhrSuccessStatus = { + + // File protocol always yields status code 0, assume 200 + 0: 200, + + // Support: IE <=9 only + // #1450: sometimes IE returns 1223 when it should be 204 + 1223: 204 + }, + xhrSupported = jQuery.ajaxSettings.xhr(); + +support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); +support.ajax = xhrSupported = !!xhrSupported; + +jQuery.ajaxTransport( function( options ) { + var callback, errorCallback; + + // Cross domain only allowed if supported through XMLHttpRequest + if ( support.cors || xhrSupported && !options.crossDomain ) { + return { + send: function( headers, complete ) { + var i, + xhr = options.xhr(); + + xhr.open( + options.type, + options.url, + options.async, + options.username, + options.password + ); + + // Apply custom fields if provided + if ( options.xhrFields ) { + for ( i in options.xhrFields ) { + xhr[ i ] = options.xhrFields[ i ]; + } + } + + // Override mime type if needed + if ( options.mimeType && xhr.overrideMimeType ) { + xhr.overrideMimeType( options.mimeType ); + } + + // X-Requested-With header + // For cross-domain requests, seeing as conditions for a preflight are + // akin to a jigsaw puzzle, we simply never set it to be sure. + // (it can always be set on a per-request basis or even using ajaxSetup) + // For same-domain requests, won't change header if already provided. + if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { + headers[ "X-Requested-With" ] = "XMLHttpRequest"; + } + + // Set headers + for ( i in headers ) { + xhr.setRequestHeader( i, headers[ i ] ); + } + + // Callback + callback = function( type ) { + return function() { + if ( callback ) { + callback = errorCallback = xhr.onload = + xhr.onerror = xhr.onabort = xhr.ontimeout = + xhr.onreadystatechange = null; + + if ( type === "abort" ) { + xhr.abort(); + } else if ( type === "error" ) { + + // Support: IE <=9 only + // On a manual native abort, IE9 throws + // errors on any property access that is not readyState + if ( typeof xhr.status !== "number" ) { + complete( 0, "error" ); + } else { + complete( + + // File: protocol always yields status 0; see #8605, #14207 + xhr.status, + xhr.statusText + ); + } + } else { + complete( + xhrSuccessStatus[ xhr.status ] || xhr.status, + xhr.statusText, + + // Support: IE <=9 only + // IE9 has no XHR2 but throws on binary (trac-11426) + // For XHR2 non-text, let the caller handle it (gh-2498) + ( xhr.responseType || "text" ) !== "text" || + typeof xhr.responseText !== "string" ? + { binary: xhr.response } : + { text: xhr.responseText }, + xhr.getAllResponseHeaders() + ); + } + } + }; + }; + + // Listen to events + xhr.onload = callback(); + errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); + + // Support: IE 9 only + // Use onreadystatechange to replace onabort + // to handle uncaught aborts + if ( xhr.onabort !== undefined ) { + xhr.onabort = errorCallback; + } else { + xhr.onreadystatechange = function() { + + // Check readyState before timeout as it changes + if ( xhr.readyState === 4 ) { + + // Allow onerror to be called first, + // but that will not handle a native abort + // Also, save errorCallback to a variable + // as xhr.onerror cannot be accessed + window.setTimeout( function() { + if ( callback ) { + errorCallback(); + } + } ); + } + }; + } + + // Create the abort callback + callback = callback( "abort" ); + + try { + + // Do send the request (this may raise an exception) + xhr.send( options.hasContent && options.data || null ); + } catch ( e ) { + + // #14683: Only rethrow if this hasn't been notified as an error yet + if ( callback ) { + throw e; + } + } + }, + + abort: function() { + if ( callback ) { + callback(); + } + } + }; + } +} ); + + + + +// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) +jQuery.ajaxPrefilter( function( s ) { + if ( s.crossDomain ) { + s.contents.script = false; + } +} ); + +// Install script dataType +jQuery.ajaxSetup( { + accepts: { + script: "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function( text ) { + jQuery.globalEval( text ); + return text; + } + } +} ); + +// Handle cache's special case and crossDomain +jQuery.ajaxPrefilter( "script", function( s ) { + if ( s.cache === undefined ) { + s.cache = false; + } + if ( s.crossDomain ) { + s.type = "GET"; + } +} ); + +// Bind script tag hack transport +jQuery.ajaxTransport( "script", function( s ) { + + // This transport only deals with cross domain or forced-by-attrs requests + if ( s.crossDomain || s.scriptAttrs ) { + var script, callback; + return { + send: function( _, complete ) { + script = jQuery( " +{% endmacro %} diff --git a/_static/scripts/pydata-sphinx-theme.js b/_static/scripts/pydata-sphinx-theme.js new file mode 100644 index 000000000..0e00c4cad --- /dev/null +++ b/_static/scripts/pydata-sphinx-theme.js @@ -0,0 +1,32 @@ +!function(t){var e={};function n(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return t[i].call(o.exports,o,o.exports,n),o.l=!0,o.exports}n.m=t,n.c=e,n.d=function(t,e,i){n.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:i})},n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(t,e){if(1&e&&(t=n(t)),8&e)return t;if(4&e&&"object"==typeof t&&t&&t.__esModule)return t;var i=Object.create(null);if(n.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var o in t)n.d(i,o,function(e){return t[e]}.bind(null,o));return i},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=2)}([function(t,e){t.exports=jQuery},function(t,e,n){"use strict";n.r(e),function(t){ +/**! + * @fileOverview Kickass library to create and place poppers near their reference elements. + * @version 1.16.1 + * @license + * Copyright (c) 2016 Federico Zivolo and contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +var n="undefined"!=typeof window&&"undefined"!=typeof document&&"undefined"!=typeof navigator,i=function(){for(var t=["Edge","Trident","Firefox"],e=0;e=0)return 1;return 0}();var o=n&&window.Promise?function(t){var e=!1;return function(){e||(e=!0,window.Promise.resolve().then((function(){e=!1,t()})))}}:function(t){var e=!1;return function(){e||(e=!0,setTimeout((function(){e=!1,t()}),i))}};function r(t){return t&&"[object Function]"==={}.toString.call(t)}function a(t,e){if(1!==t.nodeType)return[];var n=t.ownerDocument.defaultView.getComputedStyle(t,null);return e?n[e]:n}function s(t){return"HTML"===t.nodeName?t:t.parentNode||t.host}function l(t){if(!t)return document.body;switch(t.nodeName){case"HTML":case"BODY":return t.ownerDocument.body;case"#document":return t.body}var e=a(t),n=e.overflow,i=e.overflowX,o=e.overflowY;return/(auto|scroll|overlay)/.test(n+o+i)?t:l(s(t))}function u(t){return t&&t.referenceNode?t.referenceNode:t}var f=n&&!(!window.MSInputMethodContext||!document.documentMode),d=n&&/MSIE 10/.test(navigator.userAgent);function c(t){return 11===t?f:10===t?d:f||d}function h(t){if(!t)return document.documentElement;for(var e=c(10)?document.body:null,n=t.offsetParent||null;n===e&&t.nextElementSibling;)n=(t=t.nextElementSibling).offsetParent;var i=n&&n.nodeName;return i&&"BODY"!==i&&"HTML"!==i?-1!==["TH","TD","TABLE"].indexOf(n.nodeName)&&"static"===a(n,"position")?h(n):n:t?t.ownerDocument.documentElement:document.documentElement}function p(t){return null!==t.parentNode?p(t.parentNode):t}function m(t,e){if(!(t&&t.nodeType&&e&&e.nodeType))return document.documentElement;var n=t.compareDocumentPosition(e)&Node.DOCUMENT_POSITION_FOLLOWING,i=n?t:e,o=n?e:t,r=document.createRange();r.setStart(i,0),r.setEnd(o,0);var a,s,l=r.commonAncestorContainer;if(t!==l&&e!==l||i.contains(o))return"BODY"===(s=(a=l).nodeName)||"HTML"!==s&&h(a.firstElementChild)!==a?h(l):l;var u=p(t);return u.host?m(u.host,e):m(t,p(e).host)}function g(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"top",n="top"===e?"scrollTop":"scrollLeft",i=t.nodeName;if("BODY"===i||"HTML"===i){var o=t.ownerDocument.documentElement,r=t.ownerDocument.scrollingElement||o;return r[n]}return t[n]}function v(t,e){var n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],i=g(e,"top"),o=g(e,"left"),r=n?-1:1;return t.top+=i*r,t.bottom+=i*r,t.left+=o*r,t.right+=o*r,t}function _(t,e){var n="x"===e?"Left":"Top",i="Left"===n?"Right":"Bottom";return parseFloat(t["border"+n+"Width"])+parseFloat(t["border"+i+"Width"])}function b(t,e,n,i){return Math.max(e["offset"+t],e["scroll"+t],n["client"+t],n["offset"+t],n["scroll"+t],c(10)?parseInt(n["offset"+t])+parseInt(i["margin"+("Height"===t?"Top":"Left")])+parseInt(i["margin"+("Height"===t?"Bottom":"Right")]):0)}function y(t){var e=t.body,n=t.documentElement,i=c(10)&&getComputedStyle(n);return{height:b("Height",e,n,i),width:b("Width",e,n,i)}}var w=function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")},E=function(){function t(t,e){for(var n=0;n2&&void 0!==arguments[2]&&arguments[2],i=c(10),o="HTML"===e.nodeName,r=N(t),s=N(e),u=l(t),f=a(e),d=parseFloat(f.borderTopWidth),h=parseFloat(f.borderLeftWidth);n&&o&&(s.top=Math.max(s.top,0),s.left=Math.max(s.left,0));var p=S({top:r.top-s.top-d,left:r.left-s.left-h,width:r.width,height:r.height});if(p.marginTop=0,p.marginLeft=0,!i&&o){var m=parseFloat(f.marginTop),g=parseFloat(f.marginLeft);p.top-=d-m,p.bottom-=d-m,p.left-=h-g,p.right-=h-g,p.marginTop=m,p.marginLeft=g}return(i&&!n?e.contains(u):e===u&&"BODY"!==u.nodeName)&&(p=v(p,e)),p}function k(t){var e=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=t.ownerDocument.documentElement,i=D(t,n),o=Math.max(n.clientWidth,window.innerWidth||0),r=Math.max(n.clientHeight,window.innerHeight||0),a=e?0:g(n),s=e?0:g(n,"left"),l={top:a-i.top+i.marginTop,left:s-i.left+i.marginLeft,width:o,height:r};return S(l)}function A(t){var e=t.nodeName;if("BODY"===e||"HTML"===e)return!1;if("fixed"===a(t,"position"))return!0;var n=s(t);return!!n&&A(n)}function I(t){if(!t||!t.parentElement||c())return document.documentElement;for(var e=t.parentElement;e&&"none"===a(e,"transform");)e=e.parentElement;return e||document.documentElement}function O(t,e,n,i){var o=arguments.length>4&&void 0!==arguments[4]&&arguments[4],r={top:0,left:0},a=o?I(t):m(t,u(e));if("viewport"===i)r=k(a,o);else{var f=void 0;"scrollParent"===i?"BODY"===(f=l(s(e))).nodeName&&(f=t.ownerDocument.documentElement):f="window"===i?t.ownerDocument.documentElement:i;var d=D(f,a,o);if("HTML"!==f.nodeName||A(a))r=d;else{var c=y(t.ownerDocument),h=c.height,p=c.width;r.top+=d.top-d.marginTop,r.bottom=h+d.top,r.left+=d.left-d.marginLeft,r.right=p+d.left}}var g="number"==typeof(n=n||0);return r.left+=g?n:n.left||0,r.top+=g?n:n.top||0,r.right-=g?n:n.right||0,r.bottom-=g?n:n.bottom||0,r}function x(t){return t.width*t.height}function j(t,e,n,i,o){var r=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;if(-1===t.indexOf("auto"))return t;var a=O(n,i,r,o),s={top:{width:a.width,height:e.top-a.top},right:{width:a.right-e.right,height:a.height},bottom:{width:a.width,height:a.bottom-e.bottom},left:{width:e.left-a.left,height:a.height}},l=Object.keys(s).map((function(t){return C({key:t},s[t],{area:x(s[t])})})).sort((function(t,e){return e.area-t.area})),u=l.filter((function(t){var e=t.width,i=t.height;return e>=n.clientWidth&&i>=n.clientHeight})),f=u.length>0?u[0].key:l[0].key,d=t.split("-")[1];return f+(d?"-"+d:"")}function L(t,e,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:null,o=i?I(e):m(e,u(n));return D(n,o,i)}function P(t){var e=t.ownerDocument.defaultView.getComputedStyle(t),n=parseFloat(e.marginTop||0)+parseFloat(e.marginBottom||0),i=parseFloat(e.marginLeft||0)+parseFloat(e.marginRight||0);return{width:t.offsetWidth+i,height:t.offsetHeight+n}}function F(t){var e={left:"right",right:"left",bottom:"top",top:"bottom"};return t.replace(/left|right|bottom|top/g,(function(t){return e[t]}))}function R(t,e,n){n=n.split("-")[0];var i=P(t),o={width:i.width,height:i.height},r=-1!==["right","left"].indexOf(n),a=r?"top":"left",s=r?"left":"top",l=r?"height":"width",u=r?"width":"height";return o[a]=e[a]+e[l]/2-i[l]/2,o[s]=n===s?e[s]-i[u]:e[F(s)],o}function M(t,e){return Array.prototype.find?t.find(e):t.filter(e)[0]}function B(t,e,n){return(void 0===n?t:t.slice(0,function(t,e,n){if(Array.prototype.findIndex)return t.findIndex((function(t){return t[e]===n}));var i=M(t,(function(t){return t[e]===n}));return t.indexOf(i)}(t,"name",n))).forEach((function(t){t.function&&console.warn("`modifier.function` is deprecated, use `modifier.fn`!");var n=t.function||t.fn;t.enabled&&r(n)&&(e.offsets.popper=S(e.offsets.popper),e.offsets.reference=S(e.offsets.reference),e=n(e,t))})),e}function H(){if(!this.state.isDestroyed){var t={instance:this,styles:{},arrowStyles:{},attributes:{},flipped:!1,offsets:{}};t.offsets.reference=L(this.state,this.popper,this.reference,this.options.positionFixed),t.placement=j(this.options.placement,t.offsets.reference,this.popper,this.reference,this.options.modifiers.flip.boundariesElement,this.options.modifiers.flip.padding),t.originalPlacement=t.placement,t.positionFixed=this.options.positionFixed,t.offsets.popper=R(this.popper,t.offsets.reference,t.placement),t.offsets.popper.position=this.options.positionFixed?"fixed":"absolute",t=B(this.modifiers,t),this.state.isCreated?this.options.onUpdate(t):(this.state.isCreated=!0,this.options.onCreate(t))}}function q(t,e){return t.some((function(t){var n=t.name;return t.enabled&&n===e}))}function Q(t){for(var e=[!1,"ms","Webkit","Moz","O"],n=t.charAt(0).toUpperCase()+t.slice(1),i=0;i1&&void 0!==arguments[1]&&arguments[1],n=Z.indexOf(t),i=Z.slice(n+1).concat(Z.slice(0,n));return e?i.reverse():i}var et="flip",nt="clockwise",it="counterclockwise";function ot(t,e,n,i){var o=[0,0],r=-1!==["right","left"].indexOf(i),a=t.split(/(\+|\-)/).map((function(t){return t.trim()})),s=a.indexOf(M(a,(function(t){return-1!==t.search(/,|\s/)})));a[s]&&-1===a[s].indexOf(",")&&console.warn("Offsets separated by white space(s) are deprecated, use a comma (,) instead.");var l=/\s*,\s*|\s+/,u=-1!==s?[a.slice(0,s).concat([a[s].split(l)[0]]),[a[s].split(l)[1]].concat(a.slice(s+1))]:[a];return(u=u.map((function(t,i){var o=(1===i?!r:r)?"height":"width",a=!1;return t.reduce((function(t,e){return""===t[t.length-1]&&-1!==["+","-"].indexOf(e)?(t[t.length-1]=e,a=!0,t):a?(t[t.length-1]+=e,a=!1,t):t.concat(e)}),[]).map((function(t){return function(t,e,n,i){var o=t.match(/((?:\-|\+)?\d*\.?\d*)(.*)/),r=+o[1],a=o[2];if(!r)return t;if(0===a.indexOf("%")){var s=void 0;switch(a){case"%p":s=n;break;case"%":case"%r":default:s=i}return S(s)[e]/100*r}if("vh"===a||"vw"===a){return("vh"===a?Math.max(document.documentElement.clientHeight,window.innerHeight||0):Math.max(document.documentElement.clientWidth,window.innerWidth||0))/100*r}return r}(t,o,e,n)}))}))).forEach((function(t,e){t.forEach((function(n,i){K(n)&&(o[e]+=n*("-"===t[i-1]?-1:1))}))})),o}var rt={placement:"bottom",positionFixed:!1,eventsEnabled:!0,removeOnDestroy:!1,onCreate:function(){},onUpdate:function(){},modifiers:{shift:{order:100,enabled:!0,fn:function(t){var e=t.placement,n=e.split("-")[0],i=e.split("-")[1];if(i){var o=t.offsets,r=o.reference,a=o.popper,s=-1!==["bottom","top"].indexOf(n),l=s?"left":"top",u=s?"width":"height",f={start:T({},l,r[l]),end:T({},l,r[l]+r[u]-a[u])};t.offsets.popper=C({},a,f[i])}return t}},offset:{order:200,enabled:!0,fn:function(t,e){var n=e.offset,i=t.placement,o=t.offsets,r=o.popper,a=o.reference,s=i.split("-")[0],l=void 0;return l=K(+n)?[+n,0]:ot(n,r,a,s),"left"===s?(r.top+=l[0],r.left-=l[1]):"right"===s?(r.top+=l[0],r.left+=l[1]):"top"===s?(r.left+=l[0],r.top-=l[1]):"bottom"===s&&(r.left+=l[0],r.top+=l[1]),t.popper=r,t},offset:0},preventOverflow:{order:300,enabled:!0,fn:function(t,e){var n=e.boundariesElement||h(t.instance.popper);t.instance.reference===n&&(n=h(n));var i=Q("transform"),o=t.instance.popper.style,r=o.top,a=o.left,s=o[i];o.top="",o.left="",o[i]="";var l=O(t.instance.popper,t.instance.reference,e.padding,n,t.positionFixed);o.top=r,o.left=a,o[i]=s,e.boundaries=l;var u=e.priority,f=t.offsets.popper,d={primary:function(t){var n=f[t];return f[t]l[t]&&!e.escapeWithReference&&(i=Math.min(f[n],l[t]-("right"===t?f.width:f.height))),T({},n,i)}};return u.forEach((function(t){var e=-1!==["left","top"].indexOf(t)?"primary":"secondary";f=C({},f,d[e](t))})),t.offsets.popper=f,t},priority:["left","right","top","bottom"],padding:5,boundariesElement:"scrollParent"},keepTogether:{order:400,enabled:!0,fn:function(t){var e=t.offsets,n=e.popper,i=e.reference,o=t.placement.split("-")[0],r=Math.floor,a=-1!==["top","bottom"].indexOf(o),s=a?"right":"bottom",l=a?"left":"top",u=a?"width":"height";return n[s]r(i[s])&&(t.offsets.popper[l]=r(i[s])),t}},arrow:{order:500,enabled:!0,fn:function(t,e){var n;if(!G(t.instance.modifiers,"arrow","keepTogether"))return t;var i=e.element;if("string"==typeof i){if(!(i=t.instance.popper.querySelector(i)))return t}else if(!t.instance.popper.contains(i))return console.warn("WARNING: `arrow.element` must be child of its popper element!"),t;var o=t.placement.split("-")[0],r=t.offsets,s=r.popper,l=r.reference,u=-1!==["left","right"].indexOf(o),f=u?"height":"width",d=u?"Top":"Left",c=d.toLowerCase(),h=u?"left":"top",p=u?"bottom":"right",m=P(i)[f];l[p]-ms[p]&&(t.offsets.popper[c]+=l[c]+m-s[p]),t.offsets.popper=S(t.offsets.popper);var g=l[c]+l[f]/2-m/2,v=a(t.instance.popper),_=parseFloat(v["margin"+d]),b=parseFloat(v["border"+d+"Width"]),y=g-t.offsets.popper[c]-_-b;return y=Math.max(Math.min(s[f]-m,y),0),t.arrowElement=i,t.offsets.arrow=(T(n={},c,Math.round(y)),T(n,h,""),n),t},element:"[x-arrow]"},flip:{order:600,enabled:!0,fn:function(t,e){if(q(t.instance.modifiers,"inner"))return t;if(t.flipped&&t.placement===t.originalPlacement)return t;var n=O(t.instance.popper,t.instance.reference,e.padding,e.boundariesElement,t.positionFixed),i=t.placement.split("-")[0],o=F(i),r=t.placement.split("-")[1]||"",a=[];switch(e.behavior){case et:a=[i,o];break;case nt:a=tt(i);break;case it:a=tt(i,!0);break;default:a=e.behavior}return a.forEach((function(s,l){if(i!==s||a.length===l+1)return t;i=t.placement.split("-")[0],o=F(i);var u=t.offsets.popper,f=t.offsets.reference,d=Math.floor,c="left"===i&&d(u.right)>d(f.left)||"right"===i&&d(u.left)d(f.top)||"bottom"===i&&d(u.top)d(n.right),m=d(u.top)d(n.bottom),v="left"===i&&h||"right"===i&&p||"top"===i&&m||"bottom"===i&&g,_=-1!==["top","bottom"].indexOf(i),b=!!e.flipVariations&&(_&&"start"===r&&h||_&&"end"===r&&p||!_&&"start"===r&&m||!_&&"end"===r&&g),y=!!e.flipVariationsByContent&&(_&&"start"===r&&p||_&&"end"===r&&h||!_&&"start"===r&&g||!_&&"end"===r&&m),w=b||y;(c||v||w)&&(t.flipped=!0,(c||v)&&(i=a[l+1]),w&&(r=function(t){return"end"===t?"start":"start"===t?"end":t}(r)),t.placement=i+(r?"-"+r:""),t.offsets.popper=C({},t.offsets.popper,R(t.instance.popper,t.offsets.reference,t.placement)),t=B(t.instance.modifiers,t,"flip"))})),t},behavior:"flip",padding:5,boundariesElement:"viewport",flipVariations:!1,flipVariationsByContent:!1},inner:{order:700,enabled:!1,fn:function(t){var e=t.placement,n=e.split("-")[0],i=t.offsets,o=i.popper,r=i.reference,a=-1!==["left","right"].indexOf(n),s=-1===["top","left"].indexOf(n);return o[a?"left":"top"]=r[n]-(s?o[a?"width":"height"]:0),t.placement=F(e),t.offsets.popper=S(o),t}},hide:{order:800,enabled:!0,fn:function(t){if(!G(t.instance.modifiers,"hide","preventOverflow"))return t;var e=t.offsets.reference,n=M(t.instance.modifiers,(function(t){return"preventOverflow"===t.name})).boundaries;if(e.bottomn.right||e.top>n.bottom||e.right2&&void 0!==arguments[2]?arguments[2]:{};w(this,t),this.scheduleUpdate=function(){return requestAnimationFrame(i.update)},this.update=o(this.update.bind(this)),this.options=C({},t.Defaults,a),this.state={isDestroyed:!1,isCreated:!1,scrollParents:[]},this.reference=e&&e.jquery?e[0]:e,this.popper=n&&n.jquery?n[0]:n,this.options.modifiers={},Object.keys(C({},t.Defaults.modifiers,a.modifiers)).forEach((function(e){i.options.modifiers[e]=C({},t.Defaults.modifiers[e]||{},a.modifiers?a.modifiers[e]:{})})),this.modifiers=Object.keys(this.options.modifiers).map((function(t){return C({name:t},i.options.modifiers[t])})).sort((function(t,e){return t.order-e.order})),this.modifiers.forEach((function(t){t.enabled&&r(t.onLoad)&&t.onLoad(i.reference,i.popper,i.options,t,i.state)})),this.update();var s=this.options.eventsEnabled;s&&this.enableEventListeners(),this.state.eventsEnabled=s}return E(t,[{key:"update",value:function(){return H.call(this)}},{key:"destroy",value:function(){return W.call(this)}},{key:"enableEventListeners",value:function(){return Y.call(this)}},{key:"disableEventListeners",value:function(){return z.call(this)}}]),t}();at.Utils=("undefined"!=typeof window?window:t).PopperUtils,at.placements=J,at.Defaults=rt,e.default=at}.call(this,n(4))},function(t,e,n){t.exports=n(5)},function(t,e,n){ +/*! + * Bootstrap v4.6.1 (https://getbootstrap.com/) + * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ +!function(t,e,n){"use strict";function i(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var o=i(e),r=i(n);function a(t,e){for(var n=0;n=4)throw new Error("Bootstrap's JavaScript requires at least jQuery v1.9.1 but less than v4.0.0")}};d.jQueryDetection(),o.default.fn.emulateTransitionEnd=f,o.default.event.special[d.TRANSITION_END]={bindType:"transitionend",delegateType:"transitionend",handle:function(t){if(o.default(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}};var c=o.default.fn.alert,h=function(){function t(t){this._element=t}var e=t.prototype;return e.close=function(t){var e=this._element;t&&(e=this._getRootElement(t)),this._triggerCloseEvent(e).isDefaultPrevented()||this._removeElement(e)},e.dispose=function(){o.default.removeData(this._element,"bs.alert"),this._element=null},e._getRootElement=function(t){var e=d.getSelectorFromElement(t),n=!1;return e&&(n=document.querySelector(e)),n||(n=o.default(t).closest(".alert")[0]),n},e._triggerCloseEvent=function(t){var e=o.default.Event("close.bs.alert");return o.default(t).trigger(e),e},e._removeElement=function(t){var e=this;if(o.default(t).removeClass("show"),o.default(t).hasClass("fade")){var n=d.getTransitionDurationFromElement(t);o.default(t).one(d.TRANSITION_END,(function(n){return e._destroyElement(t,n)})).emulateTransitionEnd(n)}else this._destroyElement(t)},e._destroyElement=function(t){o.default(t).detach().trigger("closed.bs.alert").remove()},t._jQueryInterface=function(e){return this.each((function(){var n=o.default(this),i=n.data("bs.alert");i||(i=new t(this),n.data("bs.alert",i)),"close"===e&&i[e](this)}))},t._handleDismiss=function(t){return function(e){e&&e.preventDefault(),t.close(this)}},s(t,null,[{key:"VERSION",get:function(){return"4.6.1"}}]),t}();o.default(document).on("click.bs.alert.data-api",'[data-dismiss="alert"]',h._handleDismiss(new h)),o.default.fn.alert=h._jQueryInterface,o.default.fn.alert.Constructor=h,o.default.fn.alert.noConflict=function(){return o.default.fn.alert=c,h._jQueryInterface};var p=o.default.fn.button,m=function(){function t(t){this._element=t,this.shouldAvoidTriggerChange=!1}var e=t.prototype;return e.toggle=function(){var t=!0,e=!0,n=o.default(this._element).closest('[data-toggle="buttons"]')[0];if(n){var i=this._element.querySelector('input:not([type="hidden"])');if(i){if("radio"===i.type)if(i.checked&&this._element.classList.contains("active"))t=!1;else{var r=n.querySelector(".active");r&&o.default(r).removeClass("active")}t&&("checkbox"!==i.type&&"radio"!==i.type||(i.checked=!this._element.classList.contains("active")),this.shouldAvoidTriggerChange||o.default(i).trigger("change")),i.focus(),e=!1}}this._element.hasAttribute("disabled")||this._element.classList.contains("disabled")||(e&&this._element.setAttribute("aria-pressed",!this._element.classList.contains("active")),t&&o.default(this._element).toggleClass("active"))},e.dispose=function(){o.default.removeData(this._element,"bs.button"),this._element=null},t._jQueryInterface=function(e,n){return this.each((function(){var i=o.default(this),r=i.data("bs.button");r||(r=new t(this),i.data("bs.button",r)),r.shouldAvoidTriggerChange=n,"toggle"===e&&r[e]()}))},s(t,null,[{key:"VERSION",get:function(){return"4.6.1"}}]),t}();o.default(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var e=t.target,n=e;if(o.default(e).hasClass("btn")||(e=o.default(e).closest(".btn")[0]),!e||e.hasAttribute("disabled")||e.classList.contains("disabled"))t.preventDefault();else{var i=e.querySelector('input:not([type="hidden"])');if(i&&(i.hasAttribute("disabled")||i.classList.contains("disabled")))return void t.preventDefault();"INPUT"!==n.tagName&&"LABEL"===e.tagName||m._jQueryInterface.call(o.default(e),"toggle","INPUT"===n.tagName)}})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){var e=o.default(t.target).closest(".btn")[0];o.default(e).toggleClass("focus",/^focus(in)?$/.test(t.type))})),o.default(window).on("load.bs.button.data-api",(function(){for(var t=[].slice.call(document.querySelectorAll('[data-toggle="buttons"] .btn')),e=0,n=t.length;e0,this._pointerEvent=Boolean(window.PointerEvent||window.MSPointerEvent),this._addEventListeners()}var e=t.prototype;return e.next=function(){this._isSliding||this._slide("next")},e.nextWhenVisible=function(){var t=o.default(this._element);!document.hidden&&t.is(":visible")&&"hidden"!==t.css("visibility")&&this.next()},e.prev=function(){this._isSliding||this._slide("prev")},e.pause=function(t){t||(this._isPaused=!0),this._element.querySelector(".carousel-item-next, .carousel-item-prev")&&(d.triggerTransitionEnd(this._element),this.cycle(!0)),clearInterval(this._interval),this._interval=null},e.cycle=function(t){t||(this._isPaused=!1),this._interval&&(clearInterval(this._interval),this._interval=null),this._config.interval&&!this._isPaused&&(this._updateInterval(),this._interval=setInterval((document.visibilityState?this.nextWhenVisible:this.next).bind(this),this._config.interval))},e.to=function(t){var e=this;this._activeElement=this._element.querySelector(".active.carousel-item");var n=this._getItemIndex(this._activeElement);if(!(t>this._items.length-1||t<0))if(this._isSliding)o.default(this._element).one("slid.bs.carousel",(function(){return e.to(t)}));else{if(n===t)return this.pause(),void this.cycle();var i=t>n?"next":"prev";this._slide(i,this._items[t])}},e.dispose=function(){o.default(this._element).off(v),o.default.removeData(this._element,"bs.carousel"),this._items=null,this._config=null,this._element=null,this._interval=null,this._isPaused=null,this._isSliding=null,this._activeElement=null,this._indicatorsElement=null},e._getConfig=function(t){return t=l({},b,t),d.typeCheckConfig(g,t,y),t},e._handleSwipe=function(){var t=Math.abs(this.touchDeltaX);if(!(t<=40)){var e=t/this.touchDeltaX;this.touchDeltaX=0,e>0&&this.prev(),e<0&&this.next()}},e._addEventListeners=function(){var t=this;this._config.keyboard&&o.default(this._element).on("keydown.bs.carousel",(function(e){return t._keydown(e)})),"hover"===this._config.pause&&o.default(this._element).on("mouseenter.bs.carousel",(function(e){return t.pause(e)})).on("mouseleave.bs.carousel",(function(e){return t.cycle(e)})),this._config.touch&&this._addTouchEventListeners()},e._addTouchEventListeners=function(){var t=this;if(this._touchSupported){var e=function(e){t._pointerEvent&&w[e.originalEvent.pointerType.toUpperCase()]?t.touchStartX=e.originalEvent.clientX:t._pointerEvent||(t.touchStartX=e.originalEvent.touches[0].clientX)},n=function(e){t._pointerEvent&&w[e.originalEvent.pointerType.toUpperCase()]&&(t.touchDeltaX=e.originalEvent.clientX-t.touchStartX),t._handleSwipe(),"hover"===t._config.pause&&(t.pause(),t.touchTimeout&&clearTimeout(t.touchTimeout),t.touchTimeout=setTimeout((function(e){return t.cycle(e)}),500+t._config.interval))};o.default(this._element.querySelectorAll(".carousel-item img")).on("dragstart.bs.carousel",(function(t){return t.preventDefault()})),this._pointerEvent?(o.default(this._element).on("pointerdown.bs.carousel",(function(t){return e(t)})),o.default(this._element).on("pointerup.bs.carousel",(function(t){return n(t)})),this._element.classList.add("pointer-event")):(o.default(this._element).on("touchstart.bs.carousel",(function(t){return e(t)})),o.default(this._element).on("touchmove.bs.carousel",(function(e){return function(e){t.touchDeltaX=e.originalEvent.touches&&e.originalEvent.touches.length>1?0:e.originalEvent.touches[0].clientX-t.touchStartX}(e)})),o.default(this._element).on("touchend.bs.carousel",(function(t){return n(t)})))}},e._keydown=function(t){if(!/input|textarea/i.test(t.target.tagName))switch(t.which){case 37:t.preventDefault(),this.prev();break;case 39:t.preventDefault(),this.next()}},e._getItemIndex=function(t){return this._items=t&&t.parentNode?[].slice.call(t.parentNode.querySelectorAll(".carousel-item")):[],this._items.indexOf(t)},e._getItemByDirection=function(t,e){var n="next"===t,i="prev"===t,o=this._getItemIndex(e),r=this._items.length-1;if((i&&0===o||n&&o===r)&&!this._config.wrap)return e;var a=(o+("prev"===t?-1:1))%this._items.length;return-1===a?this._items[this._items.length-1]:this._items[a]},e._triggerSlideEvent=function(t,e){var n=this._getItemIndex(t),i=this._getItemIndex(this._element.querySelector(".active.carousel-item")),r=o.default.Event("slide.bs.carousel",{relatedTarget:t,direction:e,from:i,to:n});return o.default(this._element).trigger(r),r},e._setActiveIndicatorElement=function(t){if(this._indicatorsElement){var e=[].slice.call(this._indicatorsElement.querySelectorAll(".active"));o.default(e).removeClass("active");var n=this._indicatorsElement.children[this._getItemIndex(t)];n&&o.default(n).addClass("active")}},e._updateInterval=function(){var t=this._activeElement||this._element.querySelector(".active.carousel-item");if(t){var e=parseInt(t.getAttribute("data-interval"),10);e?(this._config.defaultInterval=this._config.defaultInterval||this._config.interval,this._config.interval=e):this._config.interval=this._config.defaultInterval||this._config.interval}},e._slide=function(t,e){var n,i,r,a=this,s=this._element.querySelector(".active.carousel-item"),l=this._getItemIndex(s),u=e||s&&this._getItemByDirection(t,s),f=this._getItemIndex(u),c=Boolean(this._interval);if("next"===t?(n="carousel-item-left",i="carousel-item-next",r="left"):(n="carousel-item-right",i="carousel-item-prev",r="right"),u&&o.default(u).hasClass("active"))this._isSliding=!1;else if(!this._triggerSlideEvent(u,r).isDefaultPrevented()&&s&&u){this._isSliding=!0,c&&this.pause(),this._setActiveIndicatorElement(u),this._activeElement=u;var h=o.default.Event("slid.bs.carousel",{relatedTarget:u,direction:r,from:l,to:f});if(o.default(this._element).hasClass("slide")){o.default(u).addClass(i),d.reflow(u),o.default(s).addClass(n),o.default(u).addClass(n);var p=d.getTransitionDurationFromElement(s);o.default(s).one(d.TRANSITION_END,(function(){o.default(u).removeClass(n+" "+i).addClass("active"),o.default(s).removeClass("active "+i+" "+n),a._isSliding=!1,setTimeout((function(){return o.default(a._element).trigger(h)}),0)})).emulateTransitionEnd(p)}else o.default(s).removeClass("active"),o.default(u).addClass("active"),this._isSliding=!1,o.default(this._element).trigger(h);c&&this.cycle()}},t._jQueryInterface=function(e){return this.each((function(){var n=o.default(this).data("bs.carousel"),i=l({},b,o.default(this).data());"object"==typeof e&&(i=l({},i,e));var r="string"==typeof e?e:i.slide;if(n||(n=new t(this,i),o.default(this).data("bs.carousel",n)),"number"==typeof e)n.to(e);else if("string"==typeof r){if(void 0===n[r])throw new TypeError('No method named "'+r+'"');n[r]()}else i.interval&&i.ride&&(n.pause(),n.cycle())}))},t._dataApiClickHandler=function(e){var n=d.getSelectorFromElement(this);if(n){var i=o.default(n)[0];if(i&&o.default(i).hasClass("carousel")){var r=l({},o.default(i).data(),o.default(this).data()),a=this.getAttribute("data-slide-to");a&&(r.interval=!1),t._jQueryInterface.call(o.default(i),r),a&&o.default(i).data("bs.carousel").to(a),e.preventDefault()}}},s(t,null,[{key:"VERSION",get:function(){return"4.6.1"}},{key:"Default",get:function(){return b}}]),t}();o.default(document).on("click.bs.carousel.data-api","[data-slide], [data-slide-to]",E._dataApiClickHandler),o.default(window).on("load.bs.carousel.data-api",(function(){for(var t=[].slice.call(document.querySelectorAll('[data-ride="carousel"]')),e=0,n=t.length;e0&&(this._selector=a,this._triggerArray.push(r))}this._parent=this._config.parent?this._getParent():null,this._config.parent||this._addAriaAndCollapsedClass(this._element,this._triggerArray),this._config.toggle&&this.toggle()}var e=t.prototype;return e.toggle=function(){o.default(this._element).hasClass("show")?this.hide():this.show()},e.show=function(){var e,n,i=this;if(!(this._isTransitioning||o.default(this._element).hasClass("show")||(this._parent&&0===(e=[].slice.call(this._parent.querySelectorAll(".show, .collapsing")).filter((function(t){return"string"==typeof i._config.parent?t.getAttribute("data-parent")===i._config.parent:t.classList.contains("collapse")}))).length&&(e=null),e&&(n=o.default(e).not(this._selector).data("bs.collapse"))&&n._isTransitioning))){var r=o.default.Event("show.bs.collapse");if(o.default(this._element).trigger(r),!r.isDefaultPrevented()){e&&(t._jQueryInterface.call(o.default(e).not(this._selector),"hide"),n||o.default(e).data("bs.collapse",null));var a=this._getDimension();o.default(this._element).removeClass("collapse").addClass("collapsing"),this._element.style[a]=0,this._triggerArray.length&&o.default(this._triggerArray).removeClass("collapsed").attr("aria-expanded",!0),this.setTransitioning(!0);var s="scroll"+(a[0].toUpperCase()+a.slice(1)),l=d.getTransitionDurationFromElement(this._element);o.default(this._element).one(d.TRANSITION_END,(function(){o.default(i._element).removeClass("collapsing").addClass("collapse show"),i._element.style[a]="",i.setTransitioning(!1),o.default(i._element).trigger("shown.bs.collapse")})).emulateTransitionEnd(l),this._element.style[a]=this._element[s]+"px"}}},e.hide=function(){var t=this;if(!this._isTransitioning&&o.default(this._element).hasClass("show")){var e=o.default.Event("hide.bs.collapse");if(o.default(this._element).trigger(e),!e.isDefaultPrevented()){var n=this._getDimension();this._element.style[n]=this._element.getBoundingClientRect()[n]+"px",d.reflow(this._element),o.default(this._element).addClass("collapsing").removeClass("collapse show");var i=this._triggerArray.length;if(i>0)for(var r=0;r0},e._getOffset=function(){var t=this,e={};return"function"==typeof this._config.offset?e.fn=function(e){return e.offsets=l({},e.offsets,t._config.offset(e.offsets,t._element)),e}:e.offset=this._config.offset,e},e._getPopperConfig=function(){var t={placement:this._getPlacement(),modifiers:{offset:this._getOffset(),flip:{enabled:this._config.flip},preventOverflow:{boundariesElement:this._config.boundary}}};return"static"===this._config.display&&(t.modifiers.applyStyle={enabled:!1}),l({},t,this._config.popperConfig)},t._jQueryInterface=function(e){return this.each((function(){var n=o.default(this).data("bs.dropdown");if(n||(n=new t(this,"object"==typeof e?e:null),o.default(this).data("bs.dropdown",n)),"string"==typeof e){if(void 0===n[e])throw new TypeError('No method named "'+e+'"');n[e]()}}))},t._clearMenus=function(e){if(!e||3!==e.which&&("keyup"!==e.type||9===e.which))for(var n=[].slice.call(document.querySelectorAll('[data-toggle="dropdown"]')),i=0,r=n.length;i0&&a--,40===e.which&&adocument.documentElement.clientHeight;n||(this._element.style.overflowY="hidden"),this._element.classList.add("modal-static");var i=d.getTransitionDurationFromElement(this._dialog);o.default(this._element).off(d.TRANSITION_END),o.default(this._element).one(d.TRANSITION_END,(function(){t._element.classList.remove("modal-static"),n||o.default(t._element).one(d.TRANSITION_END,(function(){t._element.style.overflowY=""})).emulateTransitionEnd(t._element,i)})).emulateTransitionEnd(i),this._element.focus()}},e._showElement=function(t){var e=this,n=o.default(this._element).hasClass("fade"),i=this._dialog?this._dialog.querySelector(".modal-body"):null;this._element.parentNode&&this._element.parentNode.nodeType===Node.ELEMENT_NODE||document.body.appendChild(this._element),this._element.style.display="block",this._element.removeAttribute("aria-hidden"),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),o.default(this._dialog).hasClass("modal-dialog-scrollable")&&i?i.scrollTop=0:this._element.scrollTop=0,n&&d.reflow(this._element),o.default(this._element).addClass("show"),this._config.focus&&this._enforceFocus();var r=o.default.Event("shown.bs.modal",{relatedTarget:t}),a=function(){e._config.focus&&e._element.focus(),e._isTransitioning=!1,o.default(e._element).trigger(r)};if(n){var s=d.getTransitionDurationFromElement(this._dialog);o.default(this._dialog).one(d.TRANSITION_END,a).emulateTransitionEnd(s)}else a()},e._enforceFocus=function(){var t=this;o.default(document).off("focusin.bs.modal").on("focusin.bs.modal",(function(e){document!==e.target&&t._element!==e.target&&0===o.default(t._element).has(e.target).length&&t._element.focus()}))},e._setEscapeEvent=function(){var t=this;this._isShown?o.default(this._element).on("keydown.dismiss.bs.modal",(function(e){t._config.keyboard&&27===e.which?(e.preventDefault(),t.hide()):t._config.keyboard||27!==e.which||t._triggerBackdropTransition()})):this._isShown||o.default(this._element).off("keydown.dismiss.bs.modal")},e._setResizeEvent=function(){var t=this;this._isShown?o.default(window).on("resize.bs.modal",(function(e){return t.handleUpdate(e)})):o.default(window).off("resize.bs.modal")},e._hideModal=function(){var t=this;this._element.style.display="none",this._element.setAttribute("aria-hidden",!0),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._isTransitioning=!1,this._showBackdrop((function(){o.default(document.body).removeClass("modal-open"),t._resetAdjustments(),t._resetScrollbar(),o.default(t._element).trigger("hidden.bs.modal")}))},e._removeBackdrop=function(){this._backdrop&&(o.default(this._backdrop).remove(),this._backdrop=null)},e._showBackdrop=function(t){var e=this,n=o.default(this._element).hasClass("fade")?"fade":"";if(this._isShown&&this._config.backdrop){if(this._backdrop=document.createElement("div"),this._backdrop.className="modal-backdrop",n&&this._backdrop.classList.add(n),o.default(this._backdrop).appendTo(document.body),o.default(this._element).on("click.dismiss.bs.modal",(function(t){e._ignoreBackdropClick?e._ignoreBackdropClick=!1:t.target===t.currentTarget&&("static"===e._config.backdrop?e._triggerBackdropTransition():e.hide())})),n&&d.reflow(this._backdrop),o.default(this._backdrop).addClass("show"),!t)return;if(!n)return void t();var i=d.getTransitionDurationFromElement(this._backdrop);o.default(this._backdrop).one(d.TRANSITION_END,t).emulateTransitionEnd(i)}else if(!this._isShown&&this._backdrop){o.default(this._backdrop).removeClass("show");var r=function(){e._removeBackdrop(),t&&t()};if(o.default(this._element).hasClass("fade")){var a=d.getTransitionDurationFromElement(this._backdrop);o.default(this._backdrop).one(d.TRANSITION_END,r).emulateTransitionEnd(a)}else r()}else t&&t()},e._adjustDialog=function(){var t=this._element.scrollHeight>document.documentElement.clientHeight;!this._isBodyOverflowing&&t&&(this._element.style.paddingLeft=this._scrollbarWidth+"px"),this._isBodyOverflowing&&!t&&(this._element.style.paddingRight=this._scrollbarWidth+"px")},e._resetAdjustments=function(){this._element.style.paddingLeft="",this._element.style.paddingRight=""},e._checkScrollbar=function(){var t=document.body.getBoundingClientRect();this._isBodyOverflowing=Math.round(t.left+t.right)
',trigger:"hover focus",title:"",delay:0,html:!1,selector:!1,placement:"top",offset:0,container:!1,fallbackPlacement:"flip",boundary:"scrollParent",customClass:"",sanitize:!0,sanitizeFn:null,whiteList:B,popperConfig:null},X={animation:"boolean",template:"string",title:"(string|element|function)",trigger:"string",delay:"(number|object)",html:"boolean",selector:"(string|boolean)",placement:"(string|function)",offset:"(number|string|function)",container:"(string|element|boolean)",fallbackPlacement:"(string|array)",boundary:"(string|element)",customClass:"(string|function)",sanitize:"boolean",sanitizeFn:"(null|function)",whiteList:"object",popperConfig:"(null|object)"},$={HIDE:"hide.bs.tooltip",HIDDEN:"hidden.bs.tooltip",SHOW:"show.bs.tooltip",SHOWN:"shown.bs.tooltip",INSERTED:"inserted.bs.tooltip",CLICK:"click.bs.tooltip",FOCUSIN:"focusin.bs.tooltip",FOCUSOUT:"focusout.bs.tooltip",MOUSEENTER:"mouseenter.bs.tooltip",MOUSELEAVE:"mouseleave.bs.tooltip"},G=function(){function t(t,e){if(void 0===r.default)throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");this._isEnabled=!0,this._timeout=0,this._hoverState="",this._activeTrigger={},this._popper=null,this.element=t,this.config=this._getConfig(e),this.tip=null,this._setListeners()}var e=t.prototype;return e.enable=function(){this._isEnabled=!0},e.disable=function(){this._isEnabled=!1},e.toggleEnabled=function(){this._isEnabled=!this._isEnabled},e.toggle=function(t){if(this._isEnabled)if(t){var e=this.constructor.DATA_KEY,n=o.default(t.currentTarget).data(e);n||(n=new this.constructor(t.currentTarget,this._getDelegateConfig()),o.default(t.currentTarget).data(e,n)),n._activeTrigger.click=!n._activeTrigger.click,n._isWithActiveTrigger()?n._enter(null,n):n._leave(null,n)}else{if(o.default(this.getTipElement()).hasClass("show"))return void this._leave(null,this);this._enter(null,this)}},e.dispose=function(){clearTimeout(this._timeout),o.default.removeData(this.element,this.constructor.DATA_KEY),o.default(this.element).off(this.constructor.EVENT_KEY),o.default(this.element).closest(".modal").off("hide.bs.modal",this._hideModalHandler),this.tip&&o.default(this.tip).remove(),this._isEnabled=null,this._timeout=null,this._hoverState=null,this._activeTrigger=null,this._popper&&this._popper.destroy(),this._popper=null,this.element=null,this.config=null,this.tip=null},e.show=function(){var t=this;if("none"===o.default(this.element).css("display"))throw new Error("Please use show on visible elements");var e=o.default.Event(this.constructor.Event.SHOW);if(this.isWithContent()&&this._isEnabled){o.default(this.element).trigger(e);var n=d.findShadowRoot(this.element),i=o.default.contains(null!==n?n:this.element.ownerDocument.documentElement,this.element);if(e.isDefaultPrevented()||!i)return;var a=this.getTipElement(),s=d.getUID(this.constructor.NAME);a.setAttribute("id",s),this.element.setAttribute("aria-describedby",s),this.setContent(),this.config.animation&&o.default(a).addClass("fade");var l="function"==typeof this.config.placement?this.config.placement.call(this,a,this.element):this.config.placement,u=this._getAttachment(l);this.addAttachmentClass(u);var f=this._getContainer();o.default(a).data(this.constructor.DATA_KEY,this),o.default.contains(this.element.ownerDocument.documentElement,this.tip)||o.default(a).appendTo(f),o.default(this.element).trigger(this.constructor.Event.INSERTED),this._popper=new r.default(this.element,a,this._getPopperConfig(u)),o.default(a).addClass("show"),o.default(a).addClass(this.config.customClass),"ontouchstart"in document.documentElement&&o.default(document.body).children().on("mouseover",null,o.default.noop);var c=function(){t.config.animation&&t._fixTransition();var e=t._hoverState;t._hoverState=null,o.default(t.element).trigger(t.constructor.Event.SHOWN),"out"===e&&t._leave(null,t)};if(o.default(this.tip).hasClass("fade")){var h=d.getTransitionDurationFromElement(this.tip);o.default(this.tip).one(d.TRANSITION_END,c).emulateTransitionEnd(h)}else c()}},e.hide=function(t){var e=this,n=this.getTipElement(),i=o.default.Event(this.constructor.Event.HIDE),r=function(){"show"!==e._hoverState&&n.parentNode&&n.parentNode.removeChild(n),e._cleanTipClass(),e.element.removeAttribute("aria-describedby"),o.default(e.element).trigger(e.constructor.Event.HIDDEN),null!==e._popper&&e._popper.destroy(),t&&t()};if(o.default(this.element).trigger(i),!i.isDefaultPrevented()){if(o.default(n).removeClass("show"),"ontouchstart"in document.documentElement&&o.default(document.body).children().off("mouseover",null,o.default.noop),this._activeTrigger.click=!1,this._activeTrigger.focus=!1,this._activeTrigger.hover=!1,o.default(this.tip).hasClass("fade")){var a=d.getTransitionDurationFromElement(n);o.default(n).one(d.TRANSITION_END,r).emulateTransitionEnd(a)}else r();this._hoverState=""}},e.update=function(){null!==this._popper&&this._popper.scheduleUpdate()},e.isWithContent=function(){return Boolean(this.getTitle())},e.addAttachmentClass=function(t){o.default(this.getTipElement()).addClass("bs-tooltip-"+t)},e.getTipElement=function(){return this.tip=this.tip||o.default(this.config.template)[0],this.tip},e.setContent=function(){var t=this.getTipElement();this.setElementContent(o.default(t.querySelectorAll(".tooltip-inner")),this.getTitle()),o.default(t).removeClass("fade show")},e.setElementContent=function(t,e){"object"!=typeof e||!e.nodeType&&!e.jquery?this.config.html?(this.config.sanitize&&(e=Q(e,this.config.whiteList,this.config.sanitizeFn)),t.html(e)):t.text(e):this.config.html?o.default(e).parent().is(t)||t.empty().append(e):t.text(o.default(e).text())},e.getTitle=function(){var t=this.element.getAttribute("data-original-title");return t||(t="function"==typeof this.config.title?this.config.title.call(this.element):this.config.title),t},e._getPopperConfig=function(t){var e=this;return l({},{placement:t,modifiers:{offset:this._getOffset(),flip:{behavior:this.config.fallbackPlacement},arrow:{element:".arrow"},preventOverflow:{boundariesElement:this.config.boundary}},onCreate:function(t){t.originalPlacement!==t.placement&&e._handlePopperPlacementChange(t)},onUpdate:function(t){return e._handlePopperPlacementChange(t)}},this.config.popperConfig)},e._getOffset=function(){var t=this,e={};return"function"==typeof this.config.offset?e.fn=function(e){return e.offsets=l({},e.offsets,t.config.offset(e.offsets,t.element)),e}:e.offset=this.config.offset,e},e._getContainer=function(){return!1===this.config.container?document.body:d.isElement(this.config.container)?o.default(this.config.container):o.default(document).find(this.config.container)},e._getAttachment=function(t){return z[t.toUpperCase()]},e._setListeners=function(){var t=this;this.config.trigger.split(" ").forEach((function(e){if("click"===e)o.default(t.element).on(t.constructor.Event.CLICK,t.config.selector,(function(e){return t.toggle(e)}));else if("manual"!==e){var n="hover"===e?t.constructor.Event.MOUSEENTER:t.constructor.Event.FOCUSIN,i="hover"===e?t.constructor.Event.MOUSELEAVE:t.constructor.Event.FOCUSOUT;o.default(t.element).on(n,t.config.selector,(function(e){return t._enter(e)})).on(i,t.config.selector,(function(e){return t._leave(e)}))}})),this._hideModalHandler=function(){t.element&&t.hide()},o.default(this.element).closest(".modal").on("hide.bs.modal",this._hideModalHandler),this.config.selector?this.config=l({},this.config,{trigger:"manual",selector:""}):this._fixTitle()},e._fixTitle=function(){var t=typeof this.element.getAttribute("data-original-title");(this.element.getAttribute("title")||"string"!==t)&&(this.element.setAttribute("data-original-title",this.element.getAttribute("title")||""),this.element.setAttribute("title",""))},e._enter=function(t,e){var n=this.constructor.DATA_KEY;(e=e||o.default(t.currentTarget).data(n))||(e=new this.constructor(t.currentTarget,this._getDelegateConfig()),o.default(t.currentTarget).data(n,e)),t&&(e._activeTrigger["focusin"===t.type?"focus":"hover"]=!0),o.default(e.getTipElement()).hasClass("show")||"show"===e._hoverState?e._hoverState="show":(clearTimeout(e._timeout),e._hoverState="show",e.config.delay&&e.config.delay.show?e._timeout=setTimeout((function(){"show"===e._hoverState&&e.show()}),e.config.delay.show):e.show())},e._leave=function(t,e){var n=this.constructor.DATA_KEY;(e=e||o.default(t.currentTarget).data(n))||(e=new this.constructor(t.currentTarget,this._getDelegateConfig()),o.default(t.currentTarget).data(n,e)),t&&(e._activeTrigger["focusout"===t.type?"focus":"hover"]=!1),e._isWithActiveTrigger()||(clearTimeout(e._timeout),e._hoverState="out",e.config.delay&&e.config.delay.hide?e._timeout=setTimeout((function(){"out"===e._hoverState&&e.hide()}),e.config.delay.hide):e.hide())},e._isWithActiveTrigger=function(){for(var t in this._activeTrigger)if(this._activeTrigger[t])return!0;return!1},e._getConfig=function(t){var e=o.default(this.element).data();return Object.keys(e).forEach((function(t){-1!==Y.indexOf(t)&&delete e[t]})),"number"==typeof(t=l({},this.constructor.Default,e,"object"==typeof t&&t?t:{})).delay&&(t.delay={show:t.delay,hide:t.delay}),"number"==typeof t.title&&(t.title=t.title.toString()),"number"==typeof t.content&&(t.content=t.content.toString()),d.typeCheckConfig(W,t,this.constructor.DefaultType),t.sanitize&&(t.template=Q(t.template,t.whiteList,t.sanitizeFn)),t},e._getDelegateConfig=function(){var t={};if(this.config)for(var e in this.config)this.constructor.Default[e]!==this.config[e]&&(t[e]=this.config[e]);return t},e._cleanTipClass=function(){var t=o.default(this.getTipElement()),e=t.attr("class").match(V);null!==e&&e.length&&t.removeClass(e.join(""))},e._handlePopperPlacementChange=function(t){this.tip=t.instance.popper,this._cleanTipClass(),this.addAttachmentClass(this._getAttachment(t.placement))},e._fixTransition=function(){var t=this.getTipElement(),e=this.config.animation;null===t.getAttribute("x-placement")&&(o.default(t).removeClass("fade"),this.config.animation=!1,this.hide(),this.show(),this.config.animation=e)},t._jQueryInterface=function(e){return this.each((function(){var n=o.default(this),i=n.data("bs.tooltip"),r="object"==typeof e&&e;if((i||!/dispose|hide/.test(e))&&(i||(i=new t(this,r),n.data("bs.tooltip",i)),"string"==typeof e)){if(void 0===i[e])throw new TypeError('No method named "'+e+'"');i[e]()}}))},s(t,null,[{key:"VERSION",get:function(){return"4.6.1"}},{key:"Default",get:function(){return K}},{key:"NAME",get:function(){return W}},{key:"DATA_KEY",get:function(){return"bs.tooltip"}},{key:"Event",get:function(){return $}},{key:"EVENT_KEY",get:function(){return".bs.tooltip"}},{key:"DefaultType",get:function(){return X}}]),t}();o.default.fn[W]=G._jQueryInterface,o.default.fn[W].Constructor=G,o.default.fn[W].noConflict=function(){return o.default.fn[W]=U,G._jQueryInterface};var J="popover",Z=o.default.fn[J],tt=new RegExp("(^|\\s)bs-popover\\S+","g"),et=l({},G.Default,{placement:"right",trigger:"click",content:"",template:''}),nt=l({},G.DefaultType,{content:"(string|element|function)"}),it={HIDE:"hide.bs.popover",HIDDEN:"hidden.bs.popover",SHOW:"show.bs.popover",SHOWN:"shown.bs.popover",INSERTED:"inserted.bs.popover",CLICK:"click.bs.popover",FOCUSIN:"focusin.bs.popover",FOCUSOUT:"focusout.bs.popover",MOUSEENTER:"mouseenter.bs.popover",MOUSELEAVE:"mouseleave.bs.popover"},ot=function(t){var e,n;function i(){return t.apply(this,arguments)||this}n=t,(e=i).prototype=Object.create(n.prototype),e.prototype.constructor=e,u(e,n);var r=i.prototype;return r.isWithContent=function(){return this.getTitle()||this._getContent()},r.addAttachmentClass=function(t){o.default(this.getTipElement()).addClass("bs-popover-"+t)},r.getTipElement=function(){return this.tip=this.tip||o.default(this.config.template)[0],this.tip},r.setContent=function(){var t=o.default(this.getTipElement());this.setElementContent(t.find(".popover-header"),this.getTitle());var e=this._getContent();"function"==typeof e&&(e=e.call(this.element)),this.setElementContent(t.find(".popover-body"),e),t.removeClass("fade show")},r._getContent=function(){return this.element.getAttribute("data-content")||this.config.content},r._cleanTipClass=function(){var t=o.default(this.getTipElement()),e=t.attr("class").match(tt);null!==e&&e.length>0&&t.removeClass(e.join(""))},i._jQueryInterface=function(t){return this.each((function(){var e=o.default(this).data("bs.popover"),n="object"==typeof t?t:null;if((e||!/dispose|hide/.test(t))&&(e||(e=new i(this,n),o.default(this).data("bs.popover",e)),"string"==typeof t)){if(void 0===e[t])throw new TypeError('No method named "'+t+'"');e[t]()}}))},s(i,null,[{key:"VERSION",get:function(){return"4.6.1"}},{key:"Default",get:function(){return et}},{key:"NAME",get:function(){return J}},{key:"DATA_KEY",get:function(){return"bs.popover"}},{key:"Event",get:function(){return it}},{key:"EVENT_KEY",get:function(){return".bs.popover"}},{key:"DefaultType",get:function(){return nt}}]),i}(G);o.default.fn[J]=ot._jQueryInterface,o.default.fn[J].Constructor=ot,o.default.fn[J].noConflict=function(){return o.default.fn[J]=Z,ot._jQueryInterface};var rt="scrollspy",at=o.default.fn[rt],st={offset:10,method:"auto",target:""},lt={offset:"number",method:"string",target:"(string|element)"},ut=function(){function t(t,e){var n=this;this._element=t,this._scrollElement="BODY"===t.tagName?window:t,this._config=this._getConfig(e),this._selector=this._config.target+" .nav-link,"+this._config.target+" .list-group-item,"+this._config.target+" .dropdown-item",this._offsets=[],this._targets=[],this._activeTarget=null,this._scrollHeight=0,o.default(this._scrollElement).on("scroll.bs.scrollspy",(function(t){return n._process(t)})),this.refresh(),this._process()}var e=t.prototype;return e.refresh=function(){var t=this,e=this._scrollElement===this._scrollElement.window?"offset":"position",n="auto"===this._config.method?e:this._config.method,i="position"===n?this._getScrollTop():0;this._offsets=[],this._targets=[],this._scrollHeight=this._getScrollHeight(),[].slice.call(document.querySelectorAll(this._selector)).map((function(t){var e,r=d.getSelectorFromElement(t);if(r&&(e=document.querySelector(r)),e){var a=e.getBoundingClientRect();if(a.width||a.height)return[o.default(e)[n]().top+i,r]}return null})).filter((function(t){return t})).sort((function(t,e){return t[0]-e[0]})).forEach((function(e){t._offsets.push(e[0]),t._targets.push(e[1])}))},e.dispose=function(){o.default.removeData(this._element,"bs.scrollspy"),o.default(this._scrollElement).off(".bs.scrollspy"),this._element=null,this._scrollElement=null,this._config=null,this._selector=null,this._offsets=null,this._targets=null,this._activeTarget=null,this._scrollHeight=null},e._getConfig=function(t){if("string"!=typeof(t=l({},st,"object"==typeof t&&t?t:{})).target&&d.isElement(t.target)){var e=o.default(t.target).attr("id");e||(e=d.getUID(rt),o.default(t.target).attr("id",e)),t.target="#"+e}return d.typeCheckConfig(rt,t,lt),t},e._getScrollTop=function(){return this._scrollElement===window?this._scrollElement.pageYOffset:this._scrollElement.scrollTop},e._getScrollHeight=function(){return this._scrollElement.scrollHeight||Math.max(document.body.scrollHeight,document.documentElement.scrollHeight)},e._getOffsetHeight=function(){return this._scrollElement===window?window.innerHeight:this._scrollElement.getBoundingClientRect().height},e._process=function(){var t=this._getScrollTop()+this._config.offset,e=this._getScrollHeight(),n=this._config.offset+e-this._getOffsetHeight();if(this._scrollHeight!==e&&this.refresh(),t>=n){var i=this._targets[this._targets.length-1];this._activeTarget!==i&&this._activate(i)}else{if(this._activeTarget&&t0)return this._activeTarget=null,void this._clear();for(var o=this._offsets.length;o--;)this._activeTarget!==this._targets[o]&&t>=this._offsets[o]&&(void 0===this._offsets[o+1]||t li > .active":".active";n=(n=o.default.makeArray(o.default(i).find(a)))[n.length-1]}var s=o.default.Event("hide.bs.tab",{relatedTarget:this._element}),l=o.default.Event("show.bs.tab",{relatedTarget:n});if(n&&o.default(n).trigger(s),o.default(this._element).trigger(l),!l.isDefaultPrevented()&&!s.isDefaultPrevented()){r&&(e=document.querySelector(r)),this._activate(this._element,i);var u=function(){var e=o.default.Event("hidden.bs.tab",{relatedTarget:t._element}),i=o.default.Event("shown.bs.tab",{relatedTarget:n});o.default(n).trigger(e),o.default(t._element).trigger(i)};e?this._activate(e,e.parentNode,u):u()}}},e.dispose=function(){o.default.removeData(this._element,"bs.tab"),this._element=null},e._activate=function(t,e,n){var i=this,r=(!e||"UL"!==e.nodeName&&"OL"!==e.nodeName?o.default(e).children(".active"):o.default(e).find("> li > .active"))[0],a=n&&r&&o.default(r).hasClass("fade"),s=function(){return i._transitionComplete(t,r,n)};if(r&&a){var l=d.getTransitionDurationFromElement(r);o.default(r).removeClass("show").one(d.TRANSITION_END,s).emulateTransitionEnd(l)}else s()},e._transitionComplete=function(t,e,n){if(e){o.default(e).removeClass("active");var i=o.default(e.parentNode).find("> .dropdown-menu .active")[0];i&&o.default(i).removeClass("active"),"tab"===e.getAttribute("role")&&e.setAttribute("aria-selected",!1)}o.default(t).addClass("active"),"tab"===t.getAttribute("role")&&t.setAttribute("aria-selected",!0),d.reflow(t),t.classList.contains("fade")&&t.classList.add("show");var r=t.parentNode;if(r&&"LI"===r.nodeName&&(r=r.parentNode),r&&o.default(r).hasClass("dropdown-menu")){var a=o.default(t).closest(".dropdown")[0];if(a){var s=[].slice.call(a.querySelectorAll(".dropdown-toggle"));o.default(s).addClass("active")}t.setAttribute("aria-expanded",!0)}n&&n()},t._jQueryInterface=function(e){return this.each((function(){var n=o.default(this),i=n.data("bs.tab");if(i||(i=new t(this),n.data("bs.tab",i)),"string"==typeof e){if(void 0===i[e])throw new TypeError('No method named "'+e+'"');i[e]()}}))},s(t,null,[{key:"VERSION",get:function(){return"4.6.1"}}]),t}();o.default(document).on("click.bs.tab.data-api",'[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',(function(t){t.preventDefault(),dt._jQueryInterface.call(o.default(this),"show")})),o.default.fn.tab=dt._jQueryInterface,o.default.fn.tab.Constructor=dt,o.default.fn.tab.noConflict=function(){return o.default.fn.tab=ft,dt._jQueryInterface};var ct="toast",ht=o.default.fn[ct],pt={animation:!0,autohide:!0,delay:500},mt={animation:"boolean",autohide:"boolean",delay:"number"},gt=function(){function t(t,e){this._element=t,this._config=this._getConfig(e),this._timeout=null,this._setListeners()}var e=t.prototype;return e.show=function(){var t=this,e=o.default.Event("show.bs.toast");if(o.default(this._element).trigger(e),!e.isDefaultPrevented()){this._clearTimeout(),this._config.animation&&this._element.classList.add("fade");var n=function(){t._element.classList.remove("showing"),t._element.classList.add("show"),o.default(t._element).trigger("shown.bs.toast"),t._config.autohide&&(t._timeout=setTimeout((function(){t.hide()}),t._config.delay))};if(this._element.classList.remove("hide"),d.reflow(this._element),this._element.classList.add("showing"),this._config.animation){var i=d.getTransitionDurationFromElement(this._element);o.default(this._element).one(d.TRANSITION_END,n).emulateTransitionEnd(i)}else n()}},e.hide=function(){if(this._element.classList.contains("show")){var t=o.default.Event("hide.bs.toast");o.default(this._element).trigger(t),t.isDefaultPrevented()||this._close()}},e.dispose=function(){this._clearTimeout(),this._element.classList.contains("show")&&this._element.classList.remove("show"),o.default(this._element).off("click.dismiss.bs.toast"),o.default.removeData(this._element,"bs.toast"),this._element=null,this._config=null},e._getConfig=function(t){return t=l({},pt,o.default(this._element).data(),"object"==typeof t&&t?t:{}),d.typeCheckConfig(ct,t,this.constructor.DefaultType),t},e._setListeners=function(){var t=this;o.default(this._element).on("click.dismiss.bs.toast",'[data-dismiss="toast"]',(function(){return t.hide()}))},e._close=function(){var t=this,e=function(){t._element.classList.add("hide"),o.default(t._element).trigger("hidden.bs.toast")};if(this._element.classList.remove("show"),this._config.animation){var n=d.getTransitionDurationFromElement(this._element);o.default(this._element).one(d.TRANSITION_END,e).emulateTransitionEnd(n)}else e()},e._clearTimeout=function(){clearTimeout(this._timeout),this._timeout=null},t._jQueryInterface=function(e){return this.each((function(){var n=o.default(this),i=n.data("bs.toast");if(i||(i=new t(this,"object"==typeof e&&e),n.data("bs.toast",i)),"string"==typeof e){if(void 0===i[e])throw new TypeError('No method named "'+e+'"');i[e](this)}}))},s(t,null,[{key:"VERSION",get:function(){return"4.6.1"}},{key:"DefaultType",get:function(){return mt}},{key:"Default",get:function(){return pt}}]),t}();o.default.fn[ct]=gt._jQueryInterface,o.default.fn[ct].Constructor=gt,o.default.fn[ct].noConflict=function(){return o.default.fn[ct]=ht,gt._jQueryInterface},t.Alert=h,t.Button=m,t.Carousel=E,t.Collapse=D,t.Dropdown=j,t.Modal=R,t.Popover=ot,t.Scrollspy=ut,t.Tab=dt,t.Toast=gt,t.Tooltip=G,t.Util=d,Object.defineProperty(t,"__esModule",{value:!0})}(e,n(0),n(1))},function(t,e){var n;n=function(){return this}();try{n=n||new Function("return this")()}catch(t){"object"==typeof window&&(n=window)}t.exports=n},function(t,e,n){"use strict";n.r(e);n(0),n(3),n.p;$((function(){var t=document.querySelector("div.bd-sidebar");let e=parseInt(sessionStorage.getItem("sidebar-scroll-top"),10);if(isNaN(e)){var n=document.getElementById("bd-docs-nav").querySelectorAll(".active");if(n.length>0){var i=n[n.length-1],o=i.getBoundingClientRect().y-t.getBoundingClientRect().y;if(i.getBoundingClientRect().y>.5*window.innerHeight){let e=.25;t.scrollTop=o-t.clientHeight*e,console.log("[PST]: Scrolled sidebar using last active link...")}}}else t.scrollTop=e,console.log("[PST]: Scrolled sidebar using stored browser position...");window.addEventListener("beforeunload",()=>{sessionStorage.setItem("sidebar-scroll-top",t.scrollTop)})})),$((function(){$(window).on("activate.bs.scrollspy",(function(){document.querySelectorAll("#bd-toc-nav a").forEach(t=>{t.parentElement.classList.remove("active")});document.querySelectorAll("#bd-toc-nav a.active").forEach(t=>{t.parentElement.classList.add("active")})}))}))}]); \ No newline at end of file diff --git a/_static/scripts/sphinx-book-theme.js b/_static/scripts/sphinx-book-theme.js new file mode 100644 index 000000000..a8a305ebc --- /dev/null +++ b/_static/scripts/sphinx-book-theme.js @@ -0,0 +1,2 @@ +!function(e){var t={};function n(o){if(t[o])return t[o].exports;var r=t[o]={i:o,l:!1,exports:{}};return e[o].call(r.exports,r,r.exports,n),r.l=!0,r.exports}n.m=e,n.c=t,n.d=function(e,t,o){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:o})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var o=Object.create(null);if(n.r(o),Object.defineProperty(o,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var r in e)n.d(o,r,function(t){return e[t]}.bind(null,r));return o},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=0)}([function(e,t,n){e.exports=n(1)},function(e,t,n){"use strict";n.r(t);n.p;var o=e=>{"loading"!=document.readyState?e():document.addEventListener?document.addEventListener("DOMContentLoaded",e):document.attachEvent("onreadystatechange",(function(){"complete"==document.readyState&&e()}))};window.initThebeSBT=()=>{var e=$("div.section h1")[0];$(e).next().hasClass("thebe-launch-button")||$("").insertAfter($(e)),initThebe()},window.printPdf=e=>{let t=$(e).attr("aria-describedby"),n=$("#"+t).detach();window.print(),$("body").append(n)},window.toggleFullScreen=()=>{var e=document.fullscreenElement&&null!==document.fullscreenElement||document.webkitFullscreenElement&&null!==document.webkitFullscreenElement;let t=document.documentElement;e?(console.log("[SBT]: Exiting full screen"),document.exitFullscreen?document.exitFullscreen():document.webkitExitFullscreen&&document.webkitExitFullscreen()):(console.log("[SBT]: Entering full screen"),t.requestFullscreen?t.requestFullscreen():t.webkitRequestFullscreen&&t.webkitRequestFullscreen())},o(()=>{$(document).ready((function(){$('[data-toggle="tooltip"]').tooltip({trigger:"hover",delay:{show:500,hide:100}})}))}),o(()=>{var e=document.getElementById("site-navigation"),t=e.querySelectorAll(".active"),n=t[t.length-1];void 0!==n&&n.offsetTop>.5*$(window).height()&&(e.scrollTop=n.offsetTop-.2*$(window).height())}),o(()=>{var e=[];let t=new IntersectionObserver((t,n)=>{t.forEach(t=>{if(t.isIntersecting)e.push(t.target);else for(let n=0;n0?$("div.bd-toc").removeClass("show"):$("div.bd-toc").addClass("show")});let n=[];["marginnote","sidenote","margin","margin-caption","full-width","sidebar","popout"].forEach(e=>{n.push("."+e,".tag_"+e,"."+e.replace("-","_"),".tag_"+e.replace("-","_"))}),document.querySelectorAll(n.join(", ")).forEach(e=>{t.observe(e)}),new IntersectionObserver((e,t)=>{e[0].boundingClientRect.y<0?document.body.classList.add("scrolled"):document.body.classList.remove("scrolled")}).observe(document.querySelector(".sbt-scroll-pixel-helper"))}),o((function(){new MutationObserver((e,t)=>{e.forEach(e=>{0!==e.addedNodes.length&&void 0!==e.addedNodes[0].data&&-1!=e.addedNodes[0].data.search("Inserted RTD Footer")&&e.addedNodes.forEach(e=>{document.getElementById("rtd-footer-container").append(e)})})}).observe(document.body,{childList:!0})}))}]); +//# sourceMappingURL=sphinx-book-theme.js.map \ No newline at end of file diff --git a/_static/scripts/sphinx-book-theme.js.map b/_static/scripts/sphinx-book-theme.js.map new file mode 100644 index 000000000..dccd768ea --- /dev/null +++ b/_static/scripts/sphinx-book-theme.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/sphinx_book_theme/assets/styles/index.scss","webpack:///./src/sphinx_book_theme/assets/scripts/index.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","sbRunWhenDOMLoaded","cb","document","readyState","addEventListener","attachEvent","window","initThebeSBT","title","$","next","hasClass","insertAfter","initThebe","printPdf","el","tooltipID","attr","tooltipTextDiv","detach","print","append","toggleFullScreen","isInFullScreen","fullscreenElement","webkitFullscreenElement","docElm","documentElement","console","log","exitFullscreen","webkitExitFullscreen","requestFullscreen","webkitRequestFullscreen","ready","tooltip","trigger","delay","show","hide","navbar","getElementById","active_pages","querySelectorAll","active_page","length","undefined","offsetTop","height","scrollTop","onScreenItems","tocObserver","IntersectionObserver","entries","observer","forEach","entry","isIntersecting","push","target","ii","splice","removeClass","addClass","marginSelector","replace","join","observe","boundingClientRect","y","body","classList","add","remove","querySelector","MutationObserver","mutationList","mutation","addedNodes","data","search","node","childList"],"mappings":"aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,oBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,GAIjBlC,EAAoBA,EAAoBmC,EAAI,G,sEClFtC,QCSXC,EAAsBC,IACG,WAAvBC,SAASC,WACXF,IACSC,SAASE,iBAClBF,SAASE,iBAAiB,mBAAoBH,GAE9CC,SAASG,YAAY,sBAAsB,WACd,YAAvBH,SAASC,YAA0BF,QAyM7CK,OAAOC,aAjDY,KACjB,IAAIC,EAAQC,EAAE,kBAAkB,GAC3BA,EAAED,GAAOE,OAAOC,SAAS,wBAC5BF,EAAE,iDAAiDG,YAAYH,EAAED,IAEnEK,aA6CFP,OAAOQ,SAhJSC,IAGd,IAAIC,EAAYP,EAAEM,GAAIE,KAAK,oBACvBC,EAAiBT,EAAE,IAAMO,GAAWG,SACxCb,OAAOc,QACPX,EAAE,QAAQY,OAAOH,IA2InBZ,OAAOgB,iBA/LgB,KACrB,IAAIC,EACDrB,SAASsB,mBAAoD,OAA/BtB,SAASsB,mBACvCtB,SAASuB,yBAC6B,OAArCvB,SAASuB,wBACb,IAAIC,EAASxB,SAASyB,gBACjBJ,GAQHK,QAAQC,IAAI,8BACR3B,SAAS4B,eACX5B,SAAS4B,iBACA5B,SAAS6B,sBAClB7B,SAAS6B,yBAXXH,QAAQC,IAAI,+BACRH,EAAOM,kBACTN,EAAOM,oBACEN,EAAOO,yBAChBP,EAAOO,4BAyLbjC,EA7CmB,KACjBS,EAAEP,UAAUgC,OAAM,WAChBzB,EAAE,2BAA2B0B,QAAQ,CACnCC,QAAS,QACTC,MAAO,CAAEC,KAAM,IAAKC,KAAM,YA0ChCvC,EAxKqB,KACnB,IAAIwC,EAAStC,SAASuC,eAAe,mBACjCC,EAAeF,EAAOG,iBAAiB,WACvCC,EAAcF,EAAaA,EAAaG,OAAS,QAGnCC,IAAhBF,GACAA,EAAYG,UAAiC,GAArBtC,EAAEH,QAAQ0C,WAElCR,EAAOS,UAAYL,EAAYG,UAAiC,GAArBtC,EAAEH,QAAQ0C,YAgKzDhD,EAjIkB,KAChB,IAAIkD,EAAgB,GACpB,IAkCIC,EAAc,IAAIC,qBAlCA,CAACC,EAASC,KAE9BD,EAAQE,QAASC,IACf,GAAIA,EAAMC,eAERP,EAAcQ,KAAKF,EAAMG,aAGzB,IAAK,IAAIC,EAAK,EAAGA,EAAKV,EAAcL,OAAQe,IAC1C,GAAIV,EAAcU,KAAQJ,EAAMG,OAAQ,CACtCT,EAAcW,OAAOD,EAAI,GACzB,SAOJV,EAAcL,OAAS,EACzBpC,EAAE,cAAcqD,YAAY,QAE5BrD,EAAE,cAAcsD,SAAS,UAwB7B,IAAIC,EAAiB,GATG,CACtB,aACA,WACA,SACA,iBACA,aACA,UACA,UAGcT,QAASK,IAEvBI,EAAeN,KAEX,IAAIE,EACJ,QAAQA,EACR,IAAIA,EAAGK,QAAQ,IAAK,KACpB,QAAQL,EAAGK,QAAQ,IAAK,QAI9B/D,SAASyC,iBAAiBqB,EAAeE,KAAK,OAAOX,QAASK,IAC5DT,EAAYgB,QAAQP,KAID,IAAIR,qBAtCO,CAACC,EAASC,KAEpCD,EAAQ,GAAGe,mBAAmBC,EAAI,EACpCnE,SAASoE,KAAKC,UAAUC,IAAI,YAE5BtE,SAASoE,KAAKC,UAAUE,OAAO,cAkCpBN,QAAQjE,SAASwE,cAAc,+BAiEhD1E,GApCA,WAkBmB,IAAI2E,iBAjBG,CAACC,EAActB,KACrCsB,EAAarB,QAASsB,IAEe,IAA/BA,EAASC,WAAWjC,aAGYC,IAAhC+B,EAASC,WAAW,GAAGC,OAGuC,GAA9DF,EAASC,WAAW,GAAGC,KAAKC,OAAO,wBACrCH,EAASC,WAAWvB,QAAS0B,IAC3B/E,SAASuC,eAAe,wBAAwBpB,OAAO4D,SAQtDd,QAAQjE,SAASoE,KADX,CAAEY,WAAW","file":"scripts/sphinx-book-theme.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","export default __webpack_public_path__ + \"styles/sphinx-book-theme.css\";","// Import CSS variables\n// ref: https://css-tricks.com/getting-javascript-to-talk-to-css-and-sass/\nimport \"../styles/index.scss\";\n\n/**\n * A helper function to load scripts when the DOM is loaded.\n * This waits for everything to be on the page first before running, since\n * some functionality doesn't behave properly until everything is ready.\n */\nvar sbRunWhenDOMLoaded = (cb) => {\n if (document.readyState != \"loading\") {\n cb();\n } else if (document.addEventListener) {\n document.addEventListener(\"DOMContentLoaded\", cb);\n } else {\n document.attachEvent(\"onreadystatechange\", function () {\n if (document.readyState == \"complete\") cb();\n });\n }\n};\n\n/**\n * Toggle full-screen with button\n *\n * There are some browser-specific hacks in here:\n * - Safari requires a `webkit` prefix, so this uses conditionals to check for that\n * ref: https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API\n */\nvar toggleFullScreen = () => {\n var isInFullScreen =\n (document.fullscreenElement && document.fullscreenElement !== null) ||\n (document.webkitFullscreenElement &&\n document.webkitFullscreenElement !== null);\n let docElm = document.documentElement;\n if (!isInFullScreen) {\n console.log(\"[SBT]: Entering full screen\");\n if (docElm.requestFullscreen) {\n docElm.requestFullscreen();\n } else if (docElm.webkitRequestFullscreen) {\n docElm.webkitRequestFullscreen();\n }\n } else {\n console.log(\"[SBT]: Exiting full screen\");\n if (document.exitFullscreen) {\n document.exitFullscreen();\n } else if (document.webkitExitFullscreen) {\n document.webkitExitFullscreen();\n }\n }\n};\n\n/**\n * Sidebar scroll on load.\n *\n * Detect the active page in the sidebar, and scroll so that it is centered on\n * the screen.\n */\nvar scrollToActive = () => {\n var navbar = document.getElementById(\"site-navigation\");\n var active_pages = navbar.querySelectorAll(\".active\");\n var active_page = active_pages[active_pages.length - 1];\n // Only scroll the navbar if the active link is lower than 50% of the page\n if (\n active_page !== undefined &&\n active_page.offsetTop > $(window).height() * 0.5\n ) {\n navbar.scrollTop = active_page.offsetTop - $(window).height() * 0.2;\n }\n};\n\n/**\n * Called when the \"print to PDF\" button is clicked.\n * This is a hack to prevent tooltips from showing up in the printed PDF.\n */\nvar printPdf = (el) => {\n // Detach the tooltip text from DOM to hide in PDF\n // and then reattach it for HTML\n let tooltipID = $(el).attr(\"aria-describedby\");\n let tooltipTextDiv = $(\"#\" + tooltipID).detach();\n window.print();\n $(\"body\").append(tooltipTextDiv);\n};\n\n/**\n * Manage scrolling behavior. This is primarily two things:\n *\n * 1. Hide the Table of Contents any time sidebar content is on the screen.\n *\n * This will be triggered any time a sidebar item enters or exits the screen.\n * It adds/removes items from an array if they have entered the screen, and\n * removes them when they exit the screen. It hides the TOC if anything is\n * on-screen.\n *\n * ref: https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API\n *\n * 2. Add a `scrolled` class to to trigger CSS changes.\n */\nvar initTocHide = () => {\n var onScreenItems = [];\n let hideTocCallback = (entries, observer) => {\n // Check whether any sidebar item is displayed\n entries.forEach((entry) => {\n if (entry.isIntersecting) {\n // If an element just came on screen, add it our list\n onScreenItems.push(entry.target);\n } else {\n // Otherwise, if it's in our list then remove it\n for (let ii = 0; ii < onScreenItems.length; ii++) {\n if (onScreenItems[ii] === entry.target) {\n onScreenItems.splice(ii, 1);\n break;\n }\n }\n }\n });\n\n // Hide the TOC if any margin content is displayed on the screen\n if (onScreenItems.length > 0) {\n $(\"div.bd-toc\").removeClass(\"show\");\n } else {\n $(\"div.bd-toc\").addClass(\"show\");\n }\n };\n let manageScrolledClassOnBody = (entries, observer) => {\n // The pixel is at the top, so if we're < 0 that it means we've scrolled\n if (entries[0].boundingClientRect.y < 0) {\n document.body.classList.add(\"scrolled\");\n } else {\n document.body.classList.remove(\"scrolled\");\n }\n };\n\n // Set up the intersection observer to watch all margin content\n let tocObserver = new IntersectionObserver(hideTocCallback);\n // TODO: deprecate popout after v0.5.0\n const selectorClasses = [\n \"marginnote\",\n \"sidenote\",\n \"margin\",\n \"margin-caption\",\n \"full-width\",\n \"sidebar\",\n \"popout\",\n ];\n let marginSelector = [];\n selectorClasses.forEach((ii) => {\n // Use three permutations of each class name because `tag_` and `_` used to be supported\n marginSelector.push(\n ...[\n `.${ii}`,\n `.tag_${ii}`,\n `.${ii.replace(\"-\", \"_\")}`,\n `.tag_${ii.replace(\"-\", \"_\")}`,\n ]\n );\n });\n document.querySelectorAll(marginSelector.join(\", \")).forEach((ii) => {\n tocObserver.observe(ii);\n });\n\n // Set up the observer to check if we've scrolled from top of page\n let scrollObserver = new IntersectionObserver(manageScrolledClassOnBody);\n scrollObserver.observe(document.querySelector(\".sbt-scroll-pixel-helper\"));\n};\n\n/**\n * Activate Thebe with a custom button click.\n */\nvar initThebeSBT = () => {\n var title = $(\"div.section h1\")[0];\n if (!$(title).next().hasClass(\"thebe-launch-button\")) {\n $(\"\").insertAfter($(title));\n }\n initThebe();\n};\n\n/**\n * Use Bootstrap helper function to enable tooltips.\n */\nvar initTooltips = () => {\n $(document).ready(function () {\n $('[data-toggle=\"tooltip\"]').tooltip({\n trigger: \"hover\",\n delay: { show: 500, hide: 100 },\n });\n });\n};\n\n/**\n * MutationObserver to move the ReadTheDocs button\n */\nfunction initRTDObserver() {\n const mutatedCallback = (mutationList, observer) => {\n mutationList.forEach((mutation) => {\n // Check whether the mutation is for RTD, which will have a specific structure\n if (mutation.addedNodes.length === 0) {\n return;\n }\n if (mutation.addedNodes[0].data === undefined) {\n return;\n }\n if (mutation.addedNodes[0].data.search(\"Inserted RTD Footer\") != -1) {\n mutation.addedNodes.forEach((node) => {\n document.getElementById(\"rtd-footer-container\").append(node);\n });\n }\n });\n };\n\n const observer = new MutationObserver(mutatedCallback);\n const config = { childList: true };\n observer.observe(document.body, config);\n}\n\n/**\n * Set up callback functions for UI click actions\n */\nwindow.initThebeSBT = initThebeSBT;\nwindow.printPdf = printPdf;\nwindow.toggleFullScreen = toggleFullScreen;\n\n/**\n * Set up functions to load when the DOM is ready\n */\nsbRunWhenDOMLoaded(initTooltips);\nsbRunWhenDOMLoaded(scrollToActive);\nsbRunWhenDOMLoaded(initTocHide);\nsbRunWhenDOMLoaded(initRTDObserver);\n"],"sourceRoot":""} \ No newline at end of file diff --git a/_static/searchtools.js b/_static/searchtools.js new file mode 100644 index 000000000..0a44e8582 --- /dev/null +++ b/_static/searchtools.js @@ -0,0 +1,525 @@ +/* + * searchtools.js + * ~~~~~~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for the full-text search. + * + * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +if (!Scorer) { + /** + * Simple result scoring code. + */ + var Scorer = { + // Implement the following function to further tweak the score for each result + // The function takes a result array [filename, title, anchor, descr, score] + // and returns the new score. + /* + score: function(result) { + return result[4]; + }, + */ + + // query matches the full name of an object + objNameMatch: 11, + // or matches in the last dotted part of the object name + objPartialMatch: 6, + // Additive scores depending on the priority of the object + objPrio: {0: 15, // used to be importantResults + 1: 5, // used to be objectResults + 2: -5}, // used to be unimportantResults + // Used when the priority is not in the mapping. + objPrioDefault: 0, + + // query found in title + title: 15, + partialTitle: 7, + // query found in terms + term: 5, + partialTerm: 2 + }; +} + +if (!splitQuery) { + function splitQuery(query) { + return query.split(/\s+/); + } +} + +/** + * Search Module + */ +var Search = { + + _index : null, + _queued_query : null, + _pulse_status : -1, + + htmlToText : function(htmlString) { + var virtualDocument = document.implementation.createHTMLDocument('virtual'); + var htmlElement = $(htmlString, virtualDocument); + htmlElement.find('.headerlink').remove(); + docContent = htmlElement.find('[role=main]')[0]; + if(docContent === undefined) { + console.warn("Content block not found. Sphinx search tries to obtain it " + + "via '[role=main]'. Could you check your theme or template."); + return ""; + } + return docContent.textContent || docContent.innerText; + }, + + init : function() { + var params = $.getQueryParameters(); + if (params.q) { + var query = params.q[0]; + $('input[name="q"]')[0].value = query; + this.performSearch(query); + } + }, + + loadIndex : function(url) { + $.ajax({type: "GET", url: url, data: null, + dataType: "script", cache: true, + complete: function(jqxhr, textstatus) { + if (textstatus != "success") { + document.getElementById("searchindexloader").src = url; + } + }}); + }, + + setIndex : function(index) { + var q; + this._index = index; + if ((q = this._queued_query) !== null) { + this._queued_query = null; + Search.query(q); + } + }, + + hasIndex : function() { + return this._index !== null; + }, + + deferQuery : function(query) { + this._queued_query = query; + }, + + stopPulse : function() { + this._pulse_status = 0; + }, + + startPulse : function() { + if (this._pulse_status >= 0) + return; + function pulse() { + var i; + Search._pulse_status = (Search._pulse_status + 1) % 4; + var dotString = ''; + for (i = 0; i < Search._pulse_status; i++) + dotString += '.'; + Search.dots.text(dotString); + if (Search._pulse_status > -1) + window.setTimeout(pulse, 500); + } + pulse(); + }, + + /** + * perform a search for something (or wait until index is loaded) + */ + performSearch : function(query) { + // create the required interface elements + this.out = $('#search-results'); + this.title = $('

' + _('Searching') + '

').appendTo(this.out); + this.dots = $('').appendTo(this.title); + this.status = $('

 

').appendTo(this.out); + this.output = $('