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..bc22a6fc2 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..04ff54d39 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..14e0a55dc 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..d54d1d6a1 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..c303bc10e 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..9aa90db4c 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..adaebdb0a 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..aa97f33c2 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..c1adbc2c8 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..99541f80b 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..4969d8318 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..02df3e6cf 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..3c8440f50 --- /dev/null +++ b/_sources/computer/environment-variable.md @@ -0,0 +1,129 @@ +# 环境变量 + +- 本节贡献者: {{姚家园}}（作者）、{{田冬冬}}（作者） +- 最近更新日期: 2023-12-24 +- 预计花费时间: 30 分钟 + +--- + +当用户登录 Linux 系统后，Shell 程序启动并读取一系列配置文件，这些文件设置了可供 +所有用户共享的 Shell 环境。然后，Shell 会读取用户家目录下的配置文件，这些配置文件 +定义了用户个人的 Shell 环境。Shell 配置文件的名字和读取顺序在不同的 Shell 中或 +不同情况的 Shell 会话下，有所区别。Shell 环境由环境变量、Shell 变量、Shell 函数 +和别名等组成，这一节主要介绍常见环境变量及其常用配置方法。 + +## 常见的环境变量 + +环境变量是一种在操作系统中定义的变量，它们存储了有关系统环境的信息，如路径、 +用户名、主机名等。环境变量可以在不同的进程之间共享，因此它们是非常有用的。 + +以下是一些常见的环境变量及其用途： + +| 环境变量 | 说明 | +|:---|:---| +| **HOME** | 当前用户的家目录 | +| **LD_LIBRARY_PATH** | 程序加载运行期间，动态链接库的查找路径 | +| **PATH** | 由冒号分开的用于搜索可执行程序名的目录列表 | +| **PS1** | Shell 提示符 | +| **PWD** | 当前工作目录 | +| **SHELL** | Shell 程序的名字 | +| **USER** | 当前用户的用户名 | + +## 操作环境变量 + +### 查看环境变量 + +与一般的 SHELL 变量类似，可以使用 `echo` 命令查看某个环境变量的值。例如， +查看环境变量 **HOME** 的值： + +``` +$ echo $HOME +/home/seismo-learn +``` + +:::{tip} +`printenv` 或 `env` 命令可以把当前所有环境变量打印出来。 +::: + +### 添加、修改环境变量 + +可以使用 `export` 命令添加或修改环境变量。例如，添加环境变量 **NEWVAR**： +``` +export NEWVAR="envvalue" +``` + +这将在当前 Shell 会话中添加环境变量 **ENVVAR**，但是在会话结束后，该环境变量 +将被删除。 + +若要永久添加环境变量，可以将其添加到 Shell 配置文件中(:file:`~/.bashrc`)。 +Bash 常见的配置文件有 {file}`/etc/profile`、{file}`~/.bash_profile`、 +{file}`~/.bashrc` 等，一般通过修改 {file}`~/.bashrc` 文件来设置和更新个人 Shell 环境。 +使用 Zsh 的读者可以修改 {file}`~/.zshrc` 来设置和更新个人 Shell 环境。 +修改配置文件后，打开新的终端，Shell 环境就会更新。需要注意的是，当前终端的 Shell +环境并没有更新。可以在当前终端中使用 `source` 命令重新加载（即读取并执行）配置文件， +当前 Shell 环境也会更新： + +``` +# 重新加载 ~/.bashrc +$ source ~/.bashrc +``` + +### 删除环境变量 + +使用 `unset` 命令可以删除某个环境变量。例如， + +``` +# 显示环境变量 USER 的值 +$ echo $USER +seismo-learn + +# 删除环境变量 USER +$ unset USER + +# 再次检查环境变量 USER 的值（其值为空） +$ echo $USER +``` + +## 环境变量 PATH + +环境变量 **PATH** 是 Linux 系统中最重要也最常用的环境变量。 + +在终端中输入命令后，Shell 需要先找到该命令，才能交给系统执行。不同命令所在目录 +并不相同，常见的命令目录有 {file}`/bin`、{file}`/usr/bin`、{file}`/usr/local/bin` 等。 +此外，大多数闭源软件或商业软件默认安装在 {file}`/opt` 目录下，用户也可能会将 +一些常用工具放在 {file}`~/bin` 目录下。因此，Shell 需要知道去哪些目录下搜索用户 +输入的命令。而环境变量 **PATH** 则定义了用于搜索可执行程序名的目录列表。 +多个目录之间由冒号分隔。在终端中输入命令名后，Shell 会依次在该目录列表下搜索命令。 + +登录系统后，环境变量 **PATH** 已经设置了默认值。前文中，在终端输入命令名后，Shell +正是到这些目录下去搜索并找到命令的。 + +``` +$ echo $PATH +/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin +``` + +若某命令所在目录不在环境变量 **PATH** 中，Shell 将无法将其找到交给系统执行。可以通过 +修改配置文件将目录永久加入到环境变量 **PATH** 中。 +``` +$ echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc +``` + +以上命令在 {file}`~/.bashrc` 配置文件最后添加了一行 `export PATH=$PATH:$HOME/bin`。 +假设用户名是 seismo-learn，则该行的作用是将 {file}`/home/seismo-learn/bin` 目录 +添加到搜索目录列表的末尾。 + +使用 `echo` 命令查看 **PATH** 环境变量的值，会发现其值并没有改变： +``` +$ echo $PATH +/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin +``` +这是因为配置文件仅在开启一个新 Shell 会话（或打开一个新终端）时会被加载与执行， +因而当前终端的 Shell 环境并没有更新。 + +可以在当前终端中使用 `source ~/.bashrc` 命令重新加载并执行配置文件以更新 Shell 会话， +或者重新开启一个新的终端。再次查看环境变量 **PATH** 的值，会发现其值已经更新： +``` +$ echo $PATH +/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin:/home/seismo-learn/bin +``` diff --git a/_sources/computer/fedora-setup.md b/_sources/computer/fedora-setup.md new file mode 100644 index 000000000..8b13c4051 --- /dev/null +++ b/_sources/computer/fedora-setup.md @@ -0,0 +1,262 @@ +# Fedora 配置指南 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-11-19 +- 预计花费时间: 120 分钟 + +--- + +:::{note} +本节内容适用于 **Fedora 39 Workstation**，不一定适用于其他 Fedora 版本。 +建议用户访问 [Fedora 官网](https://getfedora.org/) 下载并安装 Fedora +最新版本，也欢迎用户帮助我们更新本文以适配 Fedora 最新版本。 +::: + +## 安装系统 + +### 下载系统镜像 + +访问 [Fedora 官网](https://getfedora.org/) 并下载 Fedora Workstation 镜像文件， +一般选择 x86_64 版本。 + +**Fedora 39 Workstation x86_64** 的 ISO 镜像文件（约 2 GB）下载链接： + +- [官方镜像](https://download.fedoraproject.org/pub/fedora/linux/releases/39/Workstation/x86_64/iso/Fedora-Workstation-Live-x86_64-39-1.5.iso) +- [中科大镜像](https://mirrors.ustc.edu.cn/fedora/releases/39/Workstation/x86_64/iso/Fedora-Workstation-Live-x86_64-39-1.5.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 39” +以进入 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 39）。 + +::::{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..1f811b491 --- /dev/null +++ b/_sources/computer/macos-setup.md @@ -0,0 +1,250 @@ +# macOS 配置指南 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（作者）、{{王亮}}（作者） +- 最近更新日期: 2023-11-19 +- 预计花费时间: 120 分钟 + +--- + +:::{warning} +本节内容基于作者在 macOS Monterey (12) 上的配置经验，可能适用于 +macOS Ventura (13) 和 macOS Sonoma (14)，但不一定适用于更老的 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..8c5407a59 --- /dev/null +++ b/_sources/computer/ubuntu-setup.md @@ -0,0 +1,236 @@ +# Ubuntu 配置指南 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-11-19 +- 预计花费时间: 120 分钟 + +--- + +:::{note} +本节内容适用于 **Ubuntu Desktop 22.04 LTS**，不一定适用于其他 Ubuntu 版本。 +建议用户总是选择 Ubuntu 最新的长期支持版（目前是 Ubuntu 22.04 LTS）或最新版本 +（目前是 Ubuntu 23.10），也欢迎用户帮助我们更新本文以适配 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..0c79f59dc --- /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 39](https://github.com/fedora-cloud/docker-brew-fedora/tree/39/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..87238eab7 --- /dev/null +++ b/_sources/exercises/catalog-analysis.ipynb @@ -0,0 +1,336 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1ab2b7bb", + "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": "082c73d6", + "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": "85396f46", + "metadata": {}, + "source": [ + "为了进一步对数据做处理以及绘图，我们还需要导入 [NumPy](https://numpy.org/)\n", + "和 [Matplotlib](https://matplotlib.org/) 模块：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f2318c1f", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "ad789434", + "metadata": {}, + "source": [ + "## 地震深度分布直方图\n", + "\n", + "为了绘制地震深度直方图，我们先从地震目录中提取出地震深度信息，并保存到数组 `depth` 中。\n", + "需要注意的是，ObsPy 的地震目录中地震深度的单位为 m，所以需要除以 1000.0 将深度单位\n", + "转换为 km。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6117c5cd", + "metadata": {}, + "outputs": [], + "source": [ + "depth = np.array([event.origins[0].depth / 1000 for event in cat])" + ] + }, + { + "cell_type": "markdown", + "id": "bfa821a1", + "metadata": {}, + "source": [ + "我们可以使用 Matplotlib 的 {meth}`~matplotlib.axes.Axes.hist()` 函数绘制直方图：\n", + "这里我们设置的直方的最小值为 50，最大值 700，间隔为 10，同时设置了 Y 轴以对数方式显示。\n", + "从图中可以明显看到地震深度随着深度的变化：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fcad4715", + "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_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": "597a3853", + "metadata": {}, + "source": [ + "## 地震震级直方图\n", + "\n", + "同理，从地震目录中提取出地震震级信息，保存到数组 `mag` 中并绘图。从图中可以明显看到，\n", + "震级越小地震数目越多：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2f75a1cc", + "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": "302d73bf", + "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": "e61644ac", + "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": "1254562d", + "metadata": {}, + "source": [ + "绘图脚本如下，注意图中 Y 轴是对数坐标。从图中可以明显看到 $\\log_{10}N$ 与 $M$ 在 4.8 - 7.6 级\n", + "之间存在线性关系。由于我们使用的地震目录里只有 4.8 级以上的地震，所以在 4.7 级以下偏离了线性关系，而大地震由于数目太少也偏离了线性关系。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bb863b34", + "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": "3a7031c8", + "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": "3bcf6552", + "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.6" + }, + "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..bcb1031d8 --- /dev/null +++ b/_sources/exercises/catalog.ipynb @@ -0,0 +1,799 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ff0f0ce", + "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": "d676f3d1", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy.clients.fdsn import Client" + ] + }, + { + "cell_type": "markdown", + "id": "1ff3c346", + "metadata": {}, + "source": [ + "接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。\n", + "ObsPy 的 `Client` 支持多个地震数据中心。这里我们选择使用 USGS 地震数据中心：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "eb433dda", + "metadata": {}, + "outputs": [], + "source": [ + "client = Client(\"USGS\")" + ] + }, + { + "cell_type": "markdown", + "id": "9fa7c1c4", + "metadata": {}, + "source": [ + "{func}`Client.get_events() ` 函数\n", + "可以根据指定的参数对地震目录做筛选并下载。\n", + "下面我们将获取 2020 年上半年全球震级大于 5.0 级的地震：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a2419451", + "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": "478085b0", + "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": "288b4435", + "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": "5c7f4299", + "metadata": {}, + "source": [ + "从输出中可以看到，该地震目录中包括了 735 个地震，并打印了若干个地震的基本信息。\n", + "\n", + "下面我们进一步限制震源深度最小值为 70 km。加上这一限制后，满足条件的地震只有 140 个。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a582229e", + "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": "ba43a707", + "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": "677856ef", + "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": "769c0c4c", + "metadata": {}, + "source": [ + "假如我们只关心日本周边的地震，我们在数据申请时可以进一步限制地震震中的经纬度范围。下面的代码限定了\n", + "地震的纬度范围为 30°-45°，经度范围为 130°-145°：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ad626e19", + "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": "85b9bfee", + "metadata": {}, + "source": [ + "经过这样的筛选之后，满足条件的地震目录只剩下了 9 个。\n", + "\n", + "在绘制下面的地震分布图时，我们使用了 `projection=\"local\"` 参数以绘制区域地图，并使用\n", + "`resolution=\"i\"` 参数设置地图中使用的海岸线精度。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d4dc6676", + "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": "932164fe", + "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": "a30ec5ea", + "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": "ca22feae", + "metadata": {}, + "source": [ + "在需要时，随时可以使用 {func}`read_events() ` 函数读入\n", + "磁盘文件中的地震目录。该函数值返回 {class}`~obspy.core.event.Catalog` 类型：" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d0217e15", + "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": "21c94021", + "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": "61c1c74e", + "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": "d26f1d1f", + "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": "95563da9", + "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": "b7f01465", + "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": "728ecb72", + "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": "5f6886f3", + "metadata": {}, + "source": [ + "`event.origins` 之所以是一个列表，是因为，对于任意一个地震，可能有多个机构或多种不同方法给出多个不同的震源信息。\n", + "在这个例子中，`event.origins` 中只包含了一个元素（即一个震源信息）。" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "46a21382", + "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": "a9113d27", + "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": "4aed0bea", + "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": "98c3ca58", + "metadata": {}, + "source": [ + "同样的，{class}`~obspy.core.event.Event` 的 `magnitudes` 属性也是一个列表，\n", + "其元素是 {class}`~obspy.core.event.magnitude.Magnitude` 类型。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f83953f6", + "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": "afa9d285", + "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": "40edd977", + "metadata": {}, + "source": [ + "下面的代码将输出地震震级和震级类型信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4b9f88c9", + "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.6" + }, + "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..b3b738236 --- /dev/null +++ b/_sources/exercises/distaz.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0374bb88", + "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": "d9e1a6f8", + "metadata": {}, + "outputs": [], + "source": [ + "evla, evlo, stla, stlo = 0, 0, 20, 10" + ] + }, + { + "cell_type": "markdown", + "id": "6701e155", + "metadata": {}, + "source": [ + "ObsPy 的 {func}`obspy.geodetics.base.locations2degrees` 函数可以用于计算完美球体\n", + "地球表面任意两点的距离，其返回值单位为度。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0d3faafe", + "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": "0172cd93", + "metadata": {}, + "source": [ + "{func}`obspy.geodetics.base.gps2dist_azimuth` 函数可以计算震中距、方位角和反方位角，\n", + "且其计算时采用的是 WGS84 椭球，因而具有更高的准确性：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fd61b29a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2466421.0675597396 25.651618610049262 207.4193805941954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2126/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": "478d7ca7", + "metadata": {}, + "source": [ + "{func}`obspy.geodetics.base.gps2dist_azimuth` 函数返回的距离以米为单位，可使用\n", + "{func}`obspy.geodetics.base.kilometers2degrees` 函数将其转换成以度为单位：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dbc5bf42", + "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.6" + }, + "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..1823750f6 --- /dev/null +++ b/_sources/exercises/prerequisite.ipynb @@ -0,0 +1,105 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ff4e220", + "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": "3f1d7722", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ObsPy version: 1.4.0\n", + "Matplotlib version: 3.8.0\n", + "NumPy version: 1.26.0\n", + "cartopy version: 0.22.0\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.6" + }, + "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..605865f0e --- /dev/null +++ b/_sources/exercises/station.ipynb @@ -0,0 +1,593 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "13fe0b0a", + "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": "3acbe091", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy.clients.fdsn import Client" + ] + }, + { + "cell_type": "markdown", + "id": "d35c077a", + "metadata": {}, + "source": [ + "接下来，我们需要初始化一个 {class}`~obspy.clients.fdsn.client.Client` 对象。\n", + "ObsPy 的 `Client` 支持多个地震数据中心。这里我们选择使用 IRIS 地震数据中心：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e7659ad6", + "metadata": {}, + "outputs": [], + "source": [ + "client = Client(\"IRIS\")" + ] + }, + { + "cell_type": "markdown", + "id": "1d8abf77", + "metadata": {}, + "source": [ + "{meth}`Client.get_stations() `\n", + "函数可以根据指定的参数获取地震台站信息。这里我们想要获得 `IU` 台网中所有台站名以 `A` 开头的\n", + "宽频带三分量（`BH*`）台站，并同时获取台站的仪器响应信息（`level=\"response\"`）：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9ee94904", + "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": "4c11cd04", + "metadata": {}, + "source": [ + "该函数会向 IRIS 地震数据中心发起请求，并返回符合条件的地震台站信息。其返回值是\n", + "{class}`~obspy.core.inventory.inventory.Inventory` 类型，并被保存到变量 `inv` 中。\n", + "下面我们看看变量 `inv` 中的内容：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8f1de8ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inventory created at 2024-04-21T01:15:45.836400Z\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": "5e863183", + "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": "9b21e790", + "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": "e42cc18a", + "metadata": {}, + "source": [ + "{meth}`Inventory.plot_response() ` \n", + "函数可以用于绘制仪器响应。下面的函数绘制了 `inv` 中所有 `BHZ` 分量的仪器响应，并设置了仪器响应图的\n", + "最小频率为 0.001 Hz：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "caa4120d", + "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": "e14d32d5", + "metadata": {}, + "source": [ + "## 台站信息的读和写\n", + "\n", + "通过 {meth}`Client.get_stations() `\n", + "获得的台站信息可以保存为多种不同格式。下面的代码将台站信息以 StationXML 格式保存到文件 \n", + "`stations.xml` 中：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6e583ae6", + "metadata": {}, + "outputs": [], + "source": [ + "inv.write(\"stations.xml\", format=\"STATIONXML\")" + ] + }, + { + "cell_type": "markdown", + "id": "216817b5", + "metadata": {}, + "source": [ + "在需要时，随时可以使用 {func}`read_inventory() ` \n", + "函数读入磁盘文件中的台站信息。该函数值返回 {class}`~obspy.core.inventory.inventory.Inventory` 类型：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "499c6c89", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy import read_inventory\n", + "inv = read_inventory(\"stations.xml\")" + ] + }, + { + "cell_type": "markdown", + "id": "12ab00b3", + "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": "d654c750", + "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": "d1ac3c55", + "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": "485cf1bd", + "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": "bb2dd5b0", + "metadata": {}, + "source": [ + "可以对 {class}`~obspy.core.inventory.network.Network` 进行列表相关的操作，\n", + "这里我们取其第一个台站并查看其信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8608c490", + "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": "4238d04f", + "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": "ee572cd7", + "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": "ff1ebc3c", + "metadata": {}, + "source": [ + "可以对 {class}`~obspy.core.inventory.station.Station` 进行列表相关的操作，\n", + "这里我们取该台站的第一个通道并查看其信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a08d1c74", + "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": "a234b682", + "metadata": {}, + "source": [ + "### {class}`~obspy.core.inventory.channel.Channel` 类\n", + "\n", + "{class}`~obspy.core.inventory.channel.Channel` 类也提供了很多通道相关的属性和函数。\n", + "例如，下面的代码输出了当前通道的方位角、倾角、位置码和采样率等信息：" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "329b26b8", + "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.6" + }, + "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..d7971b895 --- /dev/null +++ b/_sources/exercises/waveform.ipynb @@ -0,0 +1,580 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "36faafa9", + "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": "8dcd044c", + "metadata": {}, + "outputs": [], + "source": [ + "from obspy.clients.fdsn import Client\n", + "from obspy import UTCDateTime" + ] + }, + { + "cell_type": "markdown", + "id": "eba8b20b", + "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": "7c483933", + "metadata": {}, + "outputs": [], + "source": [ + "client = Client(\"IRIS\")" + ] + }, + { + "cell_type": "markdown", + "id": "4f271c7c", + "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": "98053026", + "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": "e8fda38f", + "metadata": {}, + "source": [ + "函数的返回值为 {class}`~obspy.core.stream.Stream` 类型，赋值给变量 `st`。\n", + "使用 `print` 函数可以显示变量 `st` 的值：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bc424513", + "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": "a0e22c45", + "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": "68b3bb09", + "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": "b0286fad", + "metadata": {}, + "source": [ + "## 下载多个波形数据\n", + "\n", + "`network`、`station`、`location` 和 `channel` 参数支持使用 UNIX 通配符，\n", + "以实现一次性下载多个波形数据的目的。通配符 `?` 表示匹配单个字符，通配符 `*`\n", + "表示匹配零个或多个字符。\n", + "\n", + "下面的代码中 `channel` 参数指定为 `BH?` 以下载宽频带三分量数据：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "78865299", + "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": "c3fe3a15", + "metadata": {}, + "source": [ + "函数返回的 {class}`~obspy.core.stream.Stream` 中包含三个 {class}`~obspy.core.trace.Trace`。\n", + "其中 `BHZ` 为垂直分量，`BH1` 和 `BH2` 为两个水平分量。绘图结果如下：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "07012f31", + "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": "5584de4e", + "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": "077a0e8b", + "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": "1cbbf9dd", + "metadata": {}, + "source": [ + "函数返回的 {class}`~obspy.core.stream.Stream` 中包含三个 {class}`~obspy.core.trace.Trace`。\n", + "绘图如下。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f3b428ac", + "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": "99a52cfd", + "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": "f6d62a93", + "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": "ee9ecf7a", + "metadata": {}, + "source": [ + "在这个示例中，我们申请了 `IU.ANMO.00.BHZ`、`IU.HKT.00.BH?` 和 `II.PFO.00.BHZ` 的\n", + "波形数据，且每个波形数据的开始时间和结束时间均不同，最终申请得到 5 个波形数据。\n", + "绘图结果如下：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c194726d", + "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": "eb43a570", + "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.6" + }, + "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..78dcf6975 --- /dev/null +++ b/_sources/programming/python.md @@ -0,0 +1,345 @@ +# Python 语言 + +- 本节贡献者: {{田冬冬}}（作者）、{{姚家园}}（审稿） +- 最近更新日期: 2023-09-23 +- 预计花费时间: 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 使用更快的 libmamab solver +$ conda config --set solver libmamba +# 配置使用国内清华源以加快软件下载速度 +$ 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` 安装软件很简单，直接 `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 = $('