first

node_modules/@vant/icons/CHANGELOG.md

@@ -0,0 +1,157 @@
+## Changelog
+
+## 1.7.3
+
+- complete https protocol
+
+## 1.7.2
+
+- add cash-o icon
+
+## 1.7.1
+
+- add guide-o icon
+- config.js now is esmodule
+
+## 1.7.0
+
+- add shield-o icon
+- fix invitation typo
+- deprecate encode.less
+
+## 1.6.0
+
+- migrate all icons to iconfont.cn
+
+## 1.5.3
+
+- add config type definition
+
+## 1.5.2
+
+- update CDN URL
+
+## 1.5.1
+
+- add new wechat icon, rename old wechat icon to wechat-pay
+
+## 1.5.0
+
+- add sort icon
+- add font icon
+- add font-o icon
+- add revoke icon
+- add delete-o icon
+
+## 1.4.0
+
+- add encode-woff2.less
+
+## 1.3.2
+
+- fix incomplete after-sale icon
+- fix incomplete cash-back-record icon
+
+## 1.3.1
+
+- add minus icon
+
+## 1.3.0
+
+- add share-o icon
+- fix calendar-o typo
+
+## 1.2.5
+
+- add back-top icon
+
+## 1.2.4
+
+- add photo-fail icon
+
+## 1.2.3
+
+- fix enlarge icon align
+
+## 1.2.2
+
+- add enlarge icon
+
+## 1.2.1
+
+- update share icon
+
+## 1.2.0
+
+- fix medal、medal-o typo
+
+## 1.1.14
+
+- add down、wap-home-o icon
+
+## 1.1.13
+
+- fix gift-o、refund-o icon incomplete
+
+## 1.1.12
+
+- fix service-o icon incomplete
+
+## 1.1.11
+
+- add smile、music、thumb-circle、phone-circle icon
+
+## 1.1.10
+
+- add warning、good-job、good-job-o icon
+
+## 1.1.9
+
+- update checked、comment、comment-o icon
+
+## 1.1.8
+
+- update location-o icon
+
+## 1.1.7
+
+- fix new incomplete display
+- fix question incomplete display
+
+## 1.1.6
+
+- update new icon & hot icon
+
+## 1.1.5
+
+- update share icon & edit icon
+
+## 1.1.4
+
+- update shop icons
+
+## 1.1.3
+
+- fix missing new icon
+
+## 1.1.2
+
+- optimize icon round corders
+
+## 1.0.9
+
+- add weapp-nav icon
+
+## 1.0.8
+
+- add more icons
+- fix icon round lines
+- fix align of comment icon
+
+## 1.0.7
+
+- add new-o icon
+
+## 1.0.6
+
+- add cart-circle icon

node_modules/@vant/icons/README.md

@@ -0,0 +1,19 @@
+# Vant Icons
+
+## Install
+
+```shell
+# with npm
+npm i @vant/icons
+
+# with yarn
+yarn add @vant/icons
+
+# with pnpm
+pnpm add @vant/icons
+```
+
+## Document
+
+- [Usage in Vue](https://youzan.github.io/vant/#/zh-CN/icon)
+- [Usage in Weapp](https://youzan.github.io/vant-weapp/#/icon)

node_modules/@vant/icons/package.json

@@ -0,0 +1,67 @@
+{
+  "_from": "@vant/icons@^1.7.1",
+  "_id": "@vant/icons@1.8.0",
+  "_inBundle": false,
+  "_integrity": "sha512-sKfEUo2/CkQFuERxvkuF6mGQZDKu3IQdj5rV9Fm0weJXtchDSSQ+zt8qPCNUEhh9Y8shy5PzxbvAfOOkCwlCXg==",
+  "_location": "/@vant/icons",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@vant/icons@^1.7.1",
+    "name": "@vant/icons",
+    "escapedName": "@vant%2ficons",
+    "scope": "@vant",
+    "rawSpec": "^1.7.1",
+    "saveSpec": null,
+    "fetchSpec": "^1.7.1"
+  },
+  "_requiredBy": [
+    "/vant"
+  ],
+  "_resolved": "https://registry.npmjs.org/@vant/icons/-/icons-1.8.0.tgz",
+  "_shasum": "36b13f2e628b533f6523a93a168cf02f07056674",
+  "_spec": "@vant/icons@^1.7.1",
+  "_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app\\node_modules\\vant",
+  "author": {
+    "name": "chenjiahan"
+  },
+  "bugs": {
+    "url": "https://github.com/youzan/vant/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "vant icons",
+  "devDependencies": {
+    "release-it": "^14.11.6"
+  },
+  "files": [
+    "src"
+  ],
+  "homepage": "https://github.com/youzan/vant#readme",
+  "license": "MIT",
+  "main": "./src/config.js",
+  "name": "@vant/icons",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "release-it": {
+    "git": {
+      "tag": false,
+      "commitMessage": "release: @vant/icons ${version}",
+      "addUntrackedFiles": true,
+      "requireCleanWorkingDir": false
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/youzan/vant.git",
+    "directory": "packages/vant-icons"
+  },
+  "scripts": {
+    "release": "release-it"
+  },
+  "types": "./src/config.d.ts",
+  "version": "1.8.0"
+}

node_modules/@vant/icons/src/common.less

@@ -0,0 +1,999 @@
+/* stylelint-disable selector-pseudo-element-colon-notation */
+/* stylelint-disable font-family-no-missing-generic-family-keyword */
+
+.van-icon {
+  position: relative;
+  display: inline-block;
+  font: normal normal normal 14px/1 'vant-icon';
+  font-size: inherit;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+
+  &:before {
+    display: inline-block;
+  }
+}
+
+.van-icon-exchange:before {
+  content: '\e6af';
+}
+
+.van-icon-eye:before {
+  content: '\e6b0';
+}
+
+.van-icon-enlarge:before {
+  content: '\e6b1';
+}
+
+.van-icon-expand-o:before {
+  content: '\e6b2';
+}
+
+.van-icon-eye-o:before {
+  content: '\e6b3';
+}
+
+.van-icon-expand:before {
+  content: '\e6b4';
+}
+
+.van-icon-filter-o:before {
+  content: '\e6b5';
+}
+
+.van-icon-fire:before {
+  content: '\e6b6';
+}
+
+.van-icon-fail:before {
+  content: '\e6b7';
+}
+
+.van-icon-failure:before {
+  content: '\e6b8';
+}
+
+.van-icon-fire-o:before {
+  content: '\e6b9';
+}
+
+.van-icon-flag-o:before {
+  content: '\e6ba';
+}
+
+.van-icon-font:before {
+  content: '\e6bb';
+}
+
+.van-icon-font-o:before {
+  content: '\e6bc';
+}
+
+.van-icon-gem-o:before {
+  content: '\e6bd';
+}
+
+.van-icon-flower-o:before {
+  content: '\e6be';
+}
+
+.van-icon-gem:before {
+  content: '\e6bf';
+}
+
+.van-icon-gift-card:before {
+  content: '\e6c0';
+}
+
+.van-icon-friends:before {
+  content: '\e6c1';
+}
+
+.van-icon-friends-o:before {
+  content: '\e6c2';
+}
+
+.van-icon-gold-coin:before {
+  content: '\e6c3';
+}
+
+.van-icon-gold-coin-o:before {
+  content: '\e6c4';
+}
+
+.van-icon-good-job-o:before {
+  content: '\e6c5';
+}
+
+.van-icon-gift:before {
+  content: '\e6c6';
+}
+
+.van-icon-gift-o:before {
+  content: '\e6c7';
+}
+
+.van-icon-gift-card-o:before {
+  content: '\e6c8';
+}
+
+.van-icon-good-job:before {
+  content: '\e6c9';
+}
+
+.van-icon-home-o:before {
+  content: '\e6ca';
+}
+
+.van-icon-goods-collect:before {
+  content: '\e6cb';
+}
+
+.van-icon-graphic:before {
+  content: '\e6cc';
+}
+
+.van-icon-goods-collect-o:before {
+  content: '\e6cd';
+}
+
+.van-icon-hot-o:before {
+  content: '\e6ce';
+}
+
+.van-icon-info:before {
+  content: '\e6cf';
+}
+
+.van-icon-hotel-o:before {
+  content: '\e6d0';
+}
+
+.van-icon-info-o:before {
+  content: '\e6d1';
+}
+
+.van-icon-hot-sale-o:before {
+  content: '\e6d2';
+}
+
+.van-icon-hot:before {
+  content: '\e6d3';
+}
+
+.van-icon-like:before {
+  content: '\e6d4';
+}
+
+.van-icon-idcard:before {
+  content: '\e6d5';
+}
+
+.van-icon-invitation:before {
+  content: '\e6d6';
+}
+
+.van-icon-like-o:before {
+  content: '\e6d7';
+}
+
+.van-icon-hot-sale:before {
+  content: '\e6d8';
+}
+
+.van-icon-location-o:before {
+  content: '\e6d9';
+}
+
+.van-icon-location:before {
+  content: '\e6da';
+}
+
+.van-icon-label:before {
+  content: '\e6db';
+}
+
+.van-icon-lock:before {
+  content: '\e6dc';
+}
+
+.van-icon-label-o:before {
+  content: '\e6dd';
+}
+
+.van-icon-map-marked:before {
+  content: '\e6de';
+}
+
+.van-icon-logistics:before {
+  content: '\e6df';
+}
+
+.van-icon-manager:before {
+  content: '\e6e0';
+}
+
+.van-icon-more:before {
+  content: '\e6e1';
+}
+
+.van-icon-live:before {
+  content: '\e6e2';
+}
+
+.van-icon-manager-o:before {
+  content: '\e6e3';
+}
+
+.van-icon-medal:before {
+  content: '\e6e4';
+}
+
+.van-icon-more-o:before {
+  content: '\e6e5';
+}
+
+.van-icon-music-o:before {
+  content: '\e6e6';
+}
+
+.van-icon-music:before {
+  content: '\e6e7';
+}
+
+.van-icon-new-arrival-o:before {
+  content: '\e6e8';
+}
+
+.van-icon-medal-o:before {
+  content: '\e6e9';
+}
+
+.van-icon-new-o:before {
+  content: '\e6ea';
+}
+
+.van-icon-free-postage:before {
+  content: '\e6eb';
+}
+
+.van-icon-newspaper-o:before {
+  content: '\e6ec';
+}
+
+.van-icon-new-arrival:before {
+  content: '\e6ed';
+}
+
+.van-icon-minus:before {
+  content: '\e6ee';
+}
+
+.van-icon-orders-o:before {
+  content: '\e6ef';
+}
+
+.van-icon-new:before {
+  content: '\e6f0';
+}
+
+.van-icon-paid:before {
+  content: '\e6f1';
+}
+
+.van-icon-notes-o:before {
+  content: '\e6f2';
+}
+
+.van-icon-other-pay:before {
+  content: '\e6f3';
+}
+
+.van-icon-pause-circle:before {
+  content: '\e6f4';
+}
+
+.van-icon-pause:before {
+  content: '\e6f5';
+}
+
+.van-icon-pause-circle-o:before {
+  content: '\e6f6';
+}
+
+.van-icon-peer-pay:before {
+  content: '\e6f7';
+}
+
+.van-icon-pending-payment:before {
+  content: '\e6f8';
+}
+
+.van-icon-passed:before {
+  content: '\e6f9';
+}
+
+.van-icon-plus:before {
+  content: '\e6fa';
+}
+
+.van-icon-phone-circle-o:before {
+  content: '\e6fb';
+}
+
+.van-icon-phone-o:before {
+  content: '\e6fc';
+}
+
+.van-icon-printer:before {
+  content: '\e6fd';
+}
+
+.van-icon-photo-fail:before {
+  content: '\e6fe';
+}
+
+.van-icon-phone:before {
+  content: '\e6ff';
+}
+
+.van-icon-photo-o:before {
+  content: '\e700';
+}
+
+.van-icon-play-circle:before {
+  content: '\e701';
+}
+
+.van-icon-play:before {
+  content: '\e702';
+}
+
+.van-icon-phone-circle:before {
+  content: '\e703';
+}
+
+.van-icon-point-gift-o:before {
+  content: '\e704';
+}
+
+.van-icon-point-gift:before {
+  content: '\e705';
+}
+
+.van-icon-play-circle-o:before {
+  content: '\e706';
+}
+
+.van-icon-shrink:before {
+  content: '\e707';
+}
+
+.van-icon-photo:before {
+  content: '\e708';
+}
+
+.van-icon-qr:before {
+  content: '\e709';
+}
+
+.van-icon-qr-invalid:before {
+  content: '\e70a';
+}
+
+.van-icon-question-o:before {
+  content: '\e70b';
+}
+
+.van-icon-revoke:before {
+  content: '\e70c';
+}
+
+.van-icon-replay:before {
+  content: '\e70d';
+}
+
+.van-icon-service:before {
+  content: '\e70e';
+}
+
+.van-icon-question:before {
+  content: '\e70f';
+}
+
+.van-icon-search:before {
+  content: '\e710';
+}
+
+.van-icon-refund-o:before {
+  content: '\e711';
+}
+
+.van-icon-service-o:before {
+  content: '\e712';
+}
+
+.van-icon-scan:before {
+  content: '\e713';
+}
+
+.van-icon-share:before {
+  content: '\e714';
+}
+
+.van-icon-send-gift-o:before {
+  content: '\e715';
+}
+
+.van-icon-share-o:before {
+  content: '\e716';
+}
+
+.van-icon-setting:before {
+  content: '\e717';
+}
+
+.van-icon-points:before {
+  content: '\e718';
+}
+
+.van-icon-photograph:before {
+  content: '\e719';
+}
+
+.van-icon-shop:before {
+  content: '\e71a';
+}
+
+.van-icon-shop-o:before {
+  content: '\e71b';
+}
+
+.van-icon-shop-collect-o:before {
+  content: '\e71c';
+}
+
+.van-icon-shop-collect:before {
+  content: '\e71d';
+}
+
+.van-icon-smile:before {
+  content: '\e71e';
+}
+
+.van-icon-shopping-cart-o:before {
+  content: '\e71f';
+}
+
+.van-icon-sign:before {
+  content: '\e720';
+}
+
+.van-icon-sort:before {
+  content: '\e721';
+}
+
+.van-icon-star-o:before {
+  content: '\e722';
+}
+
+.van-icon-smile-comment-o:before {
+  content: '\e723';
+}
+
+.van-icon-stop:before {
+  content: '\e724';
+}
+
+.van-icon-stop-circle-o:before {
+  content: '\e725';
+}
+
+.van-icon-smile-o:before {
+  content: '\e726';
+}
+
+.van-icon-star:before {
+  content: '\e727';
+}
+
+.van-icon-success:before {
+  content: '\e728';
+}
+
+.van-icon-stop-circle:before {
+  content: '\e729';
+}
+
+.van-icon-records:before {
+  content: '\e72a';
+}
+
+.van-icon-shopping-cart:before {
+  content: '\e72b';
+}
+
+.van-icon-tosend:before {
+  content: '\e72c';
+}
+
+.van-icon-todo-list:before {
+  content: '\e72d';
+}
+
+.van-icon-thumb-circle-o:before {
+  content: '\e72e';
+}
+
+.van-icon-thumb-circle:before {
+  content: '\e72f';
+}
+
+.van-icon-umbrella-circle:before {
+  content: '\e730';
+}
+
+.van-icon-underway:before {
+  content: '\e731';
+}
+
+.van-icon-upgrade:before {
+  content: '\e732';
+}
+
+.van-icon-todo-list-o:before {
+  content: '\e733';
+}
+
+.van-icon-tv-o:before {
+  content: '\e734';
+}
+
+.van-icon-underway-o:before {
+  content: '\e735';
+}
+
+.van-icon-user-o:before {
+  content: '\e736';
+}
+
+.van-icon-vip-card-o:before {
+  content: '\e737';
+}
+
+.van-icon-vip-card:before {
+  content: '\e738';
+}
+
+.van-icon-send-gift:before {
+  content: '\e739';
+}
+
+.van-icon-wap-home:before {
+  content: '\e73a';
+}
+
+.van-icon-wap-nav:before {
+  content: '\e73b';
+}
+
+.van-icon-volume-o:before {
+  content: '\e73c';
+}
+
+.van-icon-video:before {
+  content: '\e73d';
+}
+
+.van-icon-wap-home-o:before {
+  content: '\e73e';
+}
+
+.van-icon-volume:before {
+  content: '\e73f';
+}
+
+.van-icon-warning:before {
+  content: '\e740';
+}
+
+.van-icon-weapp-nav:before {
+  content: '\e741';
+}
+
+.van-icon-wechat-pay:before {
+  content: '\e742';
+}
+
+.van-icon-warning-o:before {
+  content: '\e743';
+}
+
+.van-icon-wechat:before {
+  content: '\e744';
+}
+
+.van-icon-setting-o:before {
+  content: '\e745';
+}
+
+.van-icon-youzan-shield:before {
+  content: '\e746';
+}
+
+.van-icon-warn-o:before {
+  content: '\e747';
+}
+
+.van-icon-smile-comment:before {
+  content: '\e748';
+}
+
+.van-icon-user-circle-o:before {
+  content: '\e749';
+}
+
+.van-icon-video-o:before {
+  content: '\e74a';
+}
+
+.van-icon-add-square:before {
+  content: '\e65c';
+}
+
+.van-icon-add:before {
+  content: '\e65d';
+}
+
+.van-icon-arrow-down:before {
+  content: '\e65e';
+}
+
+.van-icon-arrow-up:before {
+  content: '\e65f';
+}
+
+.van-icon-arrow:before {
+  content: '\e660';
+}
+
+.van-icon-after-sale:before {
+  content: '\e661';
+}
+
+.van-icon-add-o:before {
+  content: '\e662';
+}
+
+.van-icon-alipay:before {
+  content: '\e663';
+}
+
+.van-icon-ascending:before {
+  content: '\e664';
+}
+
+.van-icon-apps-o:before {
+  content: '\e665';
+}
+
+.van-icon-aim:before {
+  content: '\e666';
+}
+
+.van-icon-award:before {
+  content: '\e667';
+}
+
+.van-icon-arrow-left:before {
+  content: '\e668';
+}
+
+.van-icon-award-o:before {
+  content: '\e669';
+}
+
+.van-icon-audio:before {
+  content: '\e66a';
+}
+
+.van-icon-bag-o:before {
+  content: '\e66b';
+}
+
+.van-icon-balance-list:before {
+  content: '\e66c';
+}
+
+.van-icon-back-top:before {
+  content: '\e66d';
+}
+
+.van-icon-bag:before {
+  content: '\e66e';
+}
+
+.van-icon-balance-pay:before {
+  content: '\e66f';
+}
+
+.van-icon-balance-o:before {
+  content: '\e670';
+}
+
+.van-icon-bar-chart-o:before {
+  content: '\e671';
+}
+
+.van-icon-bars:before {
+  content: '\e672';
+}
+
+.van-icon-balance-list-o:before {
+  content: '\e673';
+}
+
+.van-icon-birthday-cake-o:before {
+  content: '\e674';
+}
+
+.van-icon-bookmark:before {
+  content: '\e675';
+}
+
+.van-icon-bill:before {
+  content: '\e676';
+}
+
+.van-icon-bell:before {
+  content: '\e677';
+}
+
+.van-icon-browsing-history-o:before {
+  content: '\e678';
+}
+
+.van-icon-browsing-history:before {
+  content: '\e679';
+}
+
+.van-icon-bookmark-o:before {
+  content: '\e67a';
+}
+
+.van-icon-bulb-o:before {
+  content: '\e67b';
+}
+
+.van-icon-bullhorn-o:before {
+  content: '\e67c';
+}
+
+.van-icon-bill-o:before {
+  content: '\e67d';
+}
+
+.van-icon-calendar-o:before {
+  content: '\e67e';
+}
+
+.van-icon-brush-o:before {
+  content: '\e67f';
+}
+
+.van-icon-card:before {
+  content: '\e680';
+}
+
+.van-icon-cart-o:before {
+  content: '\e681';
+}
+
+.van-icon-cart-circle:before {
+  content: '\e682';
+}
+
+.van-icon-cart-circle-o:before {
+  content: '\e683';
+}
+
+.van-icon-cart:before {
+  content: '\e684';
+}
+
+.van-icon-cash-on-deliver:before {
+  content: '\e685';
+}
+
+.van-icon-cash-back-record:before {
+  content: '\e686';
+}
+
+.van-icon-cashier-o:before {
+  content: '\e687';
+}
+
+.van-icon-chart-trending-o:before {
+  content: '\e688';
+}
+
+.van-icon-certificate:before {
+  content: '\e689';
+}
+
+.van-icon-chat:before {
+  content: '\e68a';
+}
+
+.van-icon-clear:before {
+  content: '\e68b';
+}
+
+.van-icon-chat-o:before {
+  content: '\e68c';
+}
+
+.van-icon-checked:before {
+  content: '\e68d';
+}
+
+.van-icon-clock:before {
+  content: '\e68e';
+}
+
+.van-icon-clock-o:before {
+  content: '\e68f';
+}
+
+.van-icon-close:before {
+  content: '\e690';
+}
+
+.van-icon-closed-eye:before {
+  content: '\e691';
+}
+
+.van-icon-circle:before {
+  content: '\e692';
+}
+
+.van-icon-cluster-o:before {
+  content: '\e693';
+}
+
+.van-icon-column:before {
+  content: '\e694';
+}
+
+.van-icon-comment-circle-o:before {
+  content: '\e695';
+}
+
+.van-icon-cluster:before {
+  content: '\e696';
+}
+
+.van-icon-comment:before {
+  content: '\e697';
+}
+
+.van-icon-comment-o:before {
+  content: '\e698';
+}
+
+.van-icon-comment-circle:before {
+  content: '\e699';
+}
+
+.van-icon-completed:before {
+  content: '\e69a';
+}
+
+.van-icon-credit-pay:before {
+  content: '\e69b';
+}
+
+.van-icon-coupon:before {
+  content: '\e69c';
+}
+
+.van-icon-debit-pay:before {
+  content: '\e69d';
+}
+
+.van-icon-coupon-o:before {
+  content: '\e69e';
+}
+
+.van-icon-contact:before {
+  content: '\e69f';
+}
+
+.van-icon-descending:before {
+  content: '\e6a0';
+}
+
+.van-icon-desktop-o:before {
+  content: '\e6a1';
+}
+
+.van-icon-diamond-o:before {
+  content: '\e6a2';
+}
+
+.van-icon-description:before {
+  content: '\e6a3';
+}
+
+.van-icon-delete:before {
+  content: '\e6a4';
+}
+
+.van-icon-diamond:before {
+  content: '\e6a5';
+}
+
+.van-icon-delete-o:before {
+  content: '\e6a6';
+}
+
+.van-icon-cross:before {
+  content: '\e6a7';
+}
+
+.van-icon-edit:before {
+  content: '\e6a8';
+}
+
+.van-icon-ellipsis:before {
+  content: '\e6a9';
+}
+
+.van-icon-down:before {
+  content: '\e6aa';
+}
+
+.van-icon-discount:before {
+  content: '\e6ab';
+}
+
+.van-icon-ecard-pay:before {
+  content: '\e6ac';
+}
+
+.van-icon-envelop-o:before {
+  content: '\e6ae';
+}
+
+.van-icon-shield-o:before {
+  content: '\e74b';
+}
+
+.van-icon-guide-o:before {
+  content: '\e74c';
+}
+
+.van-icon-cash-o:before {
+  content: '\e74d';
+}
+
+.van-icon-qq:before {
+  content: '\e74e';
+}
+
+.van-icon-wechat-moments:before {
+  content: '\e74f';
+}
+
+.van-icon-weibo:before {
+  content: '\e750';
+}
+
+.van-icon-link-o:before {
+  content: '\e751';
+}
+
+.van-icon-miniprogram-o:before {
+  content: '\e752';
+}

node_modules/@vant/icons/src/config.d.ts

@@ -0,0 +1,7 @@
+declare const config: {
+  name: string;
+  basic: string[];
+  outline: string[];
+  filled: string[];
+};
+export default config;

node_modules/@vant/icons/src/config.js

@@ -0,0 +1,259 @@
+export default {
+  name: 'vant-icon',
+  basic: [
+    'arrow',
+    'arrow-left',
+    'arrow-up',
+    'arrow-down',
+    'success',
+    'cross',
+    'plus',
+    'minus',
+    'fail',
+    'circle',
+  ],
+  outline: [
+    // has corresponding filled icon
+    'location-o',
+    'like-o',
+    'star-o',
+    'phone-o',
+    'setting-o',
+    'fire-o',
+    'coupon-o',
+    'cart-o',
+    'shopping-cart-o',
+    'cart-circle-o',
+    'friends-o',
+    'comment-o',
+    'gem-o',
+    'gift-o',
+    'point-gift-o',
+    'send-gift-o',
+    'service-o',
+    'bag-o',
+    'todo-list-o',
+    'balance-list-o',
+    'close',
+    'clock-o',
+    'question-o',
+    'passed',
+    'add-o',
+    'gold-coin-o',
+    'info-o',
+    'play-circle-o',
+    'pause-circle-o',
+    'stop-circle-o',
+    'warning-o',
+    'phone-circle-o',
+    'music-o',
+    'smile-o',
+    'thumb-circle-o',
+    'comment-circle-o',
+    'browsing-history-o',
+    'underway-o',
+    'more-o',
+    'video-o',
+    'shop-o',
+    'shop-collect-o',
+    'share-o',
+    'chat-o',
+    'smile-comment-o',
+    'vip-card-o',
+    'award-o',
+    'diamond-o',
+    'volume-o',
+    'cluster-o',
+    'wap-home-o',
+    'photo-o',
+    'gift-card-o',
+    'expand-o',
+    'medal-o',
+    'good-job-o',
+    'manager-o',
+    'label-o',
+    'bookmark-o',
+    'bill-o',
+    'hot-o',
+    'hot-sale-o',
+    'new-o',
+    'new-arrival-o',
+    'goods-collect-o',
+    'eye-o',
+    'delete-o',
+    'font-o',
+    // without corresponding filled icon
+    'balance-o',
+    'refund-o',
+    'birthday-cake-o',
+    'user-o',
+    'orders-o',
+    'tv-o',
+    'envelop-o',
+    'flag-o',
+    'flower-o',
+    'filter-o',
+    'bar-chart-o',
+    'chart-trending-o',
+    'brush-o',
+    'bullhorn-o',
+    'hotel-o',
+    'cashier-o',
+    'newspaper-o',
+    'warn-o',
+    'notes-o',
+    'calendar-o',
+    'bulb-o',
+    'user-circle-o',
+    'desktop-o',
+    'apps-o',
+    'home-o',
+    'back-top',
+    'search',
+    'points',
+    'edit',
+    'qr',
+    'qr-invalid',
+    'closed-eye',
+    'down',
+    'scan',
+    'revoke',
+    'free-postage',
+    'certificate',
+    'logistics',
+    'contact',
+    'cash-back-record',
+    'after-sale',
+    'exchange',
+    'upgrade',
+    'ellipsis',
+    'description',
+    'records',
+    'sign',
+    'completed',
+    'failure',
+    'ecard-pay',
+    'peer-pay',
+    'balance-pay',
+    'credit-pay',
+    'debit-pay',
+    'cash-on-deliver',
+    'other-pay',
+    'tosend',
+    'pending-payment',
+    'paid',
+    'aim',
+    'discount',
+    'idcard',
+    'replay',
+    'shrink',
+    'shield-o',
+    'guide-o',
+    'cash-o',
+    'link-o',
+    'miniprogram-o',
+  ],
+  filled: [
+    // has corresponding outline icon
+    'location',
+    'like',
+    'star',
+    'phone',
+    'setting',
+    'fire',
+    'coupon',
+    'cart',
+    'shopping-cart',
+    'cart-circle',
+    'friends',
+    'comment',
+    'gem',
+    'gift',
+    'point-gift',
+    'send-gift',
+    'service',
+    'bag',
+    'todo-list',
+    'balance-list',
+    'clear',
+    'clock',
+    'question',
+    'checked',
+    'add',
+    'gold-coin',
+    'info',
+    'play-circle',
+    'pause-circle',
+    'stop-circle',
+    'warning',
+    'phone-circle',
+    'music',
+    'smile',
+    'thumb-circle',
+    'comment-circle',
+    'browsing-history',
+    'underway',
+    'more',
+    'video',
+    'shop',
+    'shop-collect',
+    'share',
+    'chat',
+    'smile-comment',
+    'vip-card',
+    'award',
+    'diamond',
+    'volume',
+    'cluster',
+    'wap-home',
+    'photo',
+    'gift-card',
+    'expand',
+    'medal',
+    'good-job',
+    'manager',
+    'label',
+    'bookmark',
+    'bill',
+    'hot',
+    'hot-sale',
+    'new',
+    'new-arrival',
+    'goods-collect',
+    'eye',
+    'delete',
+    'font',
+    // without corresponding outline icon
+    'wechat',
+    'wechat-pay',
+    'wechat-moments',
+    'qq',
+    'alipay',
+    'weibo',
+    'photograph',
+    'youzan-shield',
+    'umbrella-circle',
+    'bell',
+    'printer',
+    'map-marked',
+    'card',
+    'add-square',
+    'live',
+    'lock',
+    'audio',
+    'graphic',
+    'column',
+    'invitation',
+    'play',
+    'pause',
+    'stop',
+    'weapp-nav',
+    'ascending',
+    'descending',
+    'bars',
+    'wap-nav',
+    'enlarge',
+    'photo-fail',
+    'sort',
+  ],
+};

node_modules/@vant/icons/src/encode.less

@@ -0,0 +1 @@
+// deprecated

node_modules/@vant/icons/src/index.less

@@ -0,0 +1,14 @@
+@import './common.less';
+
+@font-face {
+  font-weight: normal;
+  font-style: normal;
+  font-display: auto;
+  font-family: 'vant-icon';
+  src: url('https://at.alicdn.com/t/font_2553510_iv4v8nulyz.woff2?t=1649083952952')
+      format('woff2'),
+    url('https://at.alicdn.com/t/font_2553510_iv4v8nulyz.woff?t=1649083952952')
+      format('woff'),
+    url('https://at.alicdn.com/t/font_2553510_iv4v8nulyz.ttf?t=1649083952952')
+      format('truetype');
+}

node_modules/@vant/popperjs/LICENSE

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) Youzan
+Copyright (c) Chen Jiahan and other 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.

node_modules/@vant/popperjs/README.md

@@ -0,0 +1,24 @@
+# @vant/popperjs
+
+@popperjs/core in commonjs format, added Object.assign polyfill.
+
+## Install
+
+```shell
+# with npm
+npm i @vant/popperjs
+
+# with yarn
+yarn add @vant/popperjs
+
+# with pnpm
+pnpm add @vant/popperjs
+```
+
+## Usage
+
+see: https://popper.js.org/
+
+## Refer
+
+issue: https://github.com/vant-ui/vant/issues/7626

node_modules/@vant/popperjs/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { createPopper } from '@popperjs/core/lib/popper-lite';
+import offsetModifier from '@popperjs/core/lib/modifiers/offset';
+import type { Instance } from '@popperjs/core';
+export { createPopper, offsetModifier };
+export type { Instance };

node_modules/@vant/popperjs/dist/index.esm.mjs

@@ -0,0 +1,991 @@
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getWindow.js
+function getWindow(node) {
+  if (node == null) {
+    return window;
+  }
+  if (node.toString() !== "[object Window]") {
+    var ownerDocument = node.ownerDocument;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
+  }
+  return node;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/instanceOf.js
+function isElement(node) {
+  var OwnElement = getWindow(node).Element;
+  return node instanceof OwnElement || node instanceof Element;
+}
+function isHTMLElement(node) {
+  var OwnElement = getWindow(node).HTMLElement;
+  return node instanceof OwnElement || node instanceof HTMLElement;
+}
+function isShadowRoot(node) {
+  if (typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  var OwnElement = getWindow(node).ShadowRoot;
+  return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/math.js
+var round = Math.round;
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/userAgent.js
+function getUAString() {
+  var uaData = navigator.userAgentData;
+  if (uaData != null && uaData.brands) {
+    return uaData.brands.map(function(item) {
+      return item.brand + "/" + item.version;
+    }).join(" ");
+  }
+  return navigator.userAgent;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js
+function isLayoutViewport() {
+  return !/^((?!chrome|android).)*safari/i.test(getUAString());
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js
+function getBoundingClientRect(element, includeScale, isFixedStrategy) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  var clientRect = element.getBoundingClientRect();
+  var scaleX = 1;
+  var scaleY = 1;
+  if (includeScale && isHTMLElement(element)) {
+    scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
+    scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+  }
+  var _ref = isElement(element) ? getWindow(element) : window, visualViewport = _ref.visualViewport;
+  var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
+  var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
+  var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
+  var width = clientRect.width / scaleX;
+  var height = clientRect.height / scaleY;
+  return {
+    width,
+    height,
+    top: y,
+    right: x + width,
+    bottom: y + height,
+    left: x,
+    x,
+    y
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js
+function getWindowScroll(node) {
+  var win = getWindow(node);
+  var scrollLeft = win.pageXOffset;
+  var scrollTop = win.pageYOffset;
+  return {
+    scrollLeft,
+    scrollTop
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js
+function getHTMLElementScroll(element) {
+  return {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js
+function getNodeScroll(node) {
+  if (node === getWindow(node) || !isHTMLElement(node)) {
+    return getWindowScroll(node);
+  } else {
+    return getHTMLElementScroll(node);
+  }
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getNodeName.js
+function getNodeName(element) {
+  return element ? (element.nodeName || "").toLowerCase() : null;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js
+function getDocumentElement(element) {
+  return ((isElement(element) ? element.ownerDocument : element.document) || window.document).documentElement;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js
+function getWindowScrollBarX(element) {
+  return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js
+function isScrollParent(element) {
+  var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
+  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js
+function isElementScaled(element) {
+  var rect = element.getBoundingClientRect();
+  var scaleX = round(rect.width) / element.offsetWidth || 1;
+  var scaleY = round(rect.height) / element.offsetHeight || 1;
+  return scaleX !== 1 || scaleY !== 1;
+}
+function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  var isOffsetParentAnElement = isHTMLElement(offsetParent);
+  var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
+  var documentElement = getDocumentElement(offsetParent);
+  var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
+  var scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  var offsets = {
+    x: 0,
+    y: 0
+  };
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      offsets = getBoundingClientRect(offsetParent, true);
+      offsets.x += offsetParent.clientLeft;
+      offsets.y += offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  return {
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js
+function getLayoutRect(element) {
+  var clientRect = getBoundingClientRect(element);
+  var width = element.offsetWidth;
+  var height = element.offsetHeight;
+  if (Math.abs(clientRect.width - width) <= 1) {
+    width = clientRect.width;
+  }
+  if (Math.abs(clientRect.height - height) <= 1) {
+    height = clientRect.height;
+  }
+  return {
+    x: element.offsetLeft,
+    y: element.offsetTop,
+    width,
+    height
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getParentNode.js
+function getParentNode(element) {
+  if (getNodeName(element) === "html") {
+    return element;
+  }
+  return element.assignedSlot || element.parentNode || (isShadowRoot(element) ? element.host : null) || getDocumentElement(element);
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js
+function getScrollParent(node) {
+  if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
+    return node.ownerDocument.body;
+  }
+  if (isHTMLElement(node) && isScrollParent(node)) {
+    return node;
+  }
+  return getScrollParent(getParentNode(node));
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js
+function listScrollParents(element, list) {
+  var _element$ownerDocumen;
+  if (list === void 0) {
+    list = [];
+  }
+  var scrollParent = getScrollParent(element);
+  var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
+  var win = getWindow(scrollParent);
+  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+  var updatedList = list.concat(target);
+  return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode(target)));
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/isTableElement.js
+function isTableElement(element) {
+  return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js
+function getTrueOffsetParent(element) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
+    return null;
+  }
+  return element.offsetParent;
+}
+function getContainingBlock(element) {
+  var isFirefox = /firefox/i.test(getUAString());
+  var isIE = /Trident/i.test(getUAString());
+  if (isIE && isHTMLElement(element)) {
+    var elementCss = getComputedStyle(element);
+    if (elementCss.position === "fixed") {
+      return null;
+    }
+  }
+  var currentNode = getParentNode(element);
+  if (isShadowRoot(currentNode)) {
+    currentNode = currentNode.host;
+  }
+  while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
+    var css = getComputedStyle(currentNode);
+    if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
+      return currentNode;
+    } else {
+      currentNode = currentNode.parentNode;
+    }
+  }
+  return null;
+}
+function getOffsetParent(element) {
+  var window2 = getWindow(element);
+  var offsetParent = getTrueOffsetParent(element);
+  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+    offsetParent = getTrueOffsetParent(offsetParent);
+  }
+  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static")) {
+    return window2;
+  }
+  return offsetParent || getContainingBlock(element) || window2;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/enums.js
+var top = "top";
+var bottom = "bottom";
+var right = "right";
+var left = "left";
+var auto = "auto";
+var basePlacements = [top, bottom, right, left];
+var start = "start";
+var end = "end";
+var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
+  return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
+}, []);
+var beforeRead = "beforeRead";
+var read = "read";
+var afterRead = "afterRead";
+var beforeMain = "beforeMain";
+var main = "main";
+var afterMain = "afterMain";
+var beforeWrite = "beforeWrite";
+var write = "write";
+var afterWrite = "afterWrite";
+var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/orderModifiers.js
+function order(modifiers) {
+  var map = /* @__PURE__ */ new Map();
+  var visited = /* @__PURE__ */ new Set();
+  var result = [];
+  modifiers.forEach(function(modifier) {
+    map.set(modifier.name, modifier);
+  });
+  function sort(modifier) {
+    visited.add(modifier.name);
+    var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
+    requires.forEach(function(dep) {
+      if (!visited.has(dep)) {
+        var depModifier = map.get(dep);
+        if (depModifier) {
+          sort(depModifier);
+        }
+      }
+    });
+    result.push(modifier);
+  }
+  modifiers.forEach(function(modifier) {
+    if (!visited.has(modifier.name)) {
+      sort(modifier);
+    }
+  });
+  return result;
+}
+function orderModifiers(modifiers) {
+  var orderedModifiers = order(modifiers);
+  return modifierPhases.reduce(function(acc, phase) {
+    return acc.concat(orderedModifiers.filter(function(modifier) {
+      return modifier.phase === phase;
+    }));
+  }, []);
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/debounce.js
+function debounce(fn2) {
+  var pending;
+  return function() {
+    if (!pending) {
+      pending = new Promise(function(resolve) {
+        Promise.resolve().then(function() {
+          pending = void 0;
+          resolve(fn2());
+        });
+      });
+    }
+    return pending;
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/format.js
+function format(str) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  return [].concat(args).reduce(function(p, c) {
+    return p.replace(/%s/, c);
+  }, str);
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/validateModifiers.js
+var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
+var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
+var VALID_PROPERTIES = ["name", "enabled", "phase", "fn", "effect", "requires", "options"];
+function validateModifiers(modifiers) {
+  modifiers.forEach(function(modifier) {
+    [].concat(Object.keys(modifier), VALID_PROPERTIES).filter(function(value, index, self) {
+      return self.indexOf(value) === index;
+    }).forEach(function(key) {
+      switch (key) {
+        case "name":
+          if (typeof modifier.name !== "string") {
+            console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', '"' + String(modifier.name) + '"'));
+          }
+          break;
+        case "enabled":
+          if (typeof modifier.enabled !== "boolean") {
+            console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', '"' + String(modifier.enabled) + '"'));
+          }
+          break;
+        case "phase":
+          if (modifierPhases.indexOf(modifier.phase) < 0) {
+            console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(", "), '"' + String(modifier.phase) + '"'));
+          }
+          break;
+        case "fn":
+          if (typeof modifier.fn !== "function") {
+            console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', '"' + String(modifier.fn) + '"'));
+          }
+          break;
+        case "effect":
+          if (modifier.effect != null && typeof modifier.effect !== "function") {
+            console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', '"' + String(modifier.fn) + '"'));
+          }
+          break;
+        case "requires":
+          if (modifier.requires != null && !Array.isArray(modifier.requires)) {
+            console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', '"' + String(modifier.requires) + '"'));
+          }
+          break;
+        case "requiresIfExists":
+          if (!Array.isArray(modifier.requiresIfExists)) {
+            console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', '"' + String(modifier.requiresIfExists) + '"'));
+          }
+          break;
+        case "options":
+        case "data":
+          break;
+        default:
+          console.error('PopperJS: an invalid property has been provided to the "' + modifier.name + '" modifier, valid properties are ' + VALID_PROPERTIES.map(function(s) {
+            return '"' + s + '"';
+          }).join(", ") + '; but "' + key + '" was provided.');
+      }
+      modifier.requires && modifier.requires.forEach(function(requirement) {
+        if (modifiers.find(function(mod) {
+          return mod.name === requirement;
+        }) == null) {
+          console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
+        }
+      });
+    });
+  });
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/uniqueBy.js
+function uniqueBy(arr, fn2) {
+  var identifiers = /* @__PURE__ */ new Set();
+  return arr.filter(function(item) {
+    var identifier = fn2(item);
+    if (!identifiers.has(identifier)) {
+      identifiers.add(identifier);
+      return true;
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/getBasePlacement.js
+function getBasePlacement(placement) {
+  return placement.split("-")[0];
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/mergeByName.js
+function mergeByName(modifiers) {
+  var merged = modifiers.reduce(function(merged2, current) {
+    var existing = merged2[current.name];
+    merged2[current.name] = existing ? Object.assign({}, existing, current, {
+      options: Object.assign({}, existing.options, current.options),
+      data: Object.assign({}, existing.data, current.data)
+    }) : current;
+    return merged2;
+  }, {});
+  return Object.keys(merged).map(function(key) {
+    return merged[key];
+  });
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/getVariation.js
+function getVariation(placement) {
+  return placement.split("-")[1];
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js
+function getMainAxisFromPlacement(placement) {
+  return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/utils/computeOffsets.js
+function computeOffsets(_ref) {
+  var reference = _ref.reference, element = _ref.element, placement = _ref.placement;
+  var basePlacement = placement ? getBasePlacement(placement) : null;
+  var variation = placement ? getVariation(placement) : null;
+  var commonX = reference.x + reference.width / 2 - element.width / 2;
+  var commonY = reference.y + reference.height / 2 - element.height / 2;
+  var offsets;
+  switch (basePlacement) {
+    case top:
+      offsets = {
+        x: commonX,
+        y: reference.y - element.height
+      };
+      break;
+    case bottom:
+      offsets = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case right:
+      offsets = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case left:
+      offsets = {
+        x: reference.x - element.width,
+        y: commonY
+      };
+      break;
+    default:
+      offsets = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+  if (mainAxis != null) {
+    var len = mainAxis === "y" ? "height" : "width";
+    switch (variation) {
+      case start:
+        offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+        break;
+      case end:
+        offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+        break;
+      default:
+    }
+  }
+  return offsets;
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/createPopper.js
+var INVALID_ELEMENT_ERROR = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
+var INFINITE_LOOP_ERROR = "Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.";
+var DEFAULT_OPTIONS = {
+  placement: "bottom",
+  modifiers: [],
+  strategy: "absolute"
+};
+function areValidElements() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return !args.some(function(element) {
+    return !(element && typeof element.getBoundingClientRect === "function");
+  });
+}
+function popperGenerator(generatorOptions) {
+  if (generatorOptions === void 0) {
+    generatorOptions = {};
+  }
+  var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
+  return function createPopper2(reference, popper, options) {
+    if (options === void 0) {
+      options = defaultOptions;
+    }
+    var state = {
+      placement: "bottom",
+      orderedModifiers: [],
+      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
+      modifiersData: {},
+      elements: {
+        reference,
+        popper
+      },
+      attributes: {},
+      styles: {}
+    };
+    var effectCleanupFns = [];
+    var isDestroyed = false;
+    var instance = {
+      state,
+      setOptions: function setOptions(setOptionsAction) {
+        var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
+        cleanupModifierEffects();
+        state.options = Object.assign({}, defaultOptions, state.options, options2);
+        state.scrollParents = {
+          reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
+          popper: listScrollParents(popper)
+        };
+        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
+        state.orderedModifiers = orderedModifiers.filter(function(m) {
+          return m.enabled;
+        });
+        if (true) {
+          var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function(_ref) {
+            var name = _ref.name;
+            return name;
+          });
+          validateModifiers(modifiers);
+          if (getBasePlacement(state.options.placement) === auto) {
+            var flipModifier = state.orderedModifiers.find(function(_ref2) {
+              var name = _ref2.name;
+              return name === "flip";
+            });
+            if (!flipModifier) {
+              console.error(['Popper: "auto" placements require the "flip" modifier be', "present and enabled to work."].join(" "));
+            }
+          }
+          var _getComputedStyle = getComputedStyle(popper), marginTop = _getComputedStyle.marginTop, marginRight = _getComputedStyle.marginRight, marginBottom = _getComputedStyle.marginBottom, marginLeft = _getComputedStyle.marginLeft;
+          if ([marginTop, marginRight, marginBottom, marginLeft].some(function(margin) {
+            return parseFloat(margin);
+          })) {
+            console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', "between the popper and its reference element or boundary.", "To replicate margin, use the `offset` modifier, as well as", "the `padding` option in the `preventOverflow` and `flip`", "modifiers."].join(" "));
+          }
+        }
+        runModifierEffects();
+        return instance.update();
+      },
+      forceUpdate: function forceUpdate() {
+        if (isDestroyed) {
+          return;
+        }
+        var _state$elements = state.elements, reference2 = _state$elements.reference, popper2 = _state$elements.popper;
+        if (!areValidElements(reference2, popper2)) {
+          if (true) {
+            console.error(INVALID_ELEMENT_ERROR);
+          }
+          return;
+        }
+        state.rects = {
+          reference: getCompositeRect(reference2, getOffsetParent(popper2), state.options.strategy === "fixed"),
+          popper: getLayoutRect(popper2)
+        };
+        state.reset = false;
+        state.placement = state.options.placement;
+        state.orderedModifiers.forEach(function(modifier) {
+          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
+        });
+        var __debug_loops__ = 0;
+        for (var index = 0; index < state.orderedModifiers.length; index++) {
+          if (true) {
+            __debug_loops__ += 1;
+            if (__debug_loops__ > 100) {
+              console.error(INFINITE_LOOP_ERROR);
+              break;
+            }
+          }
+          if (state.reset === true) {
+            state.reset = false;
+            index = -1;
+            continue;
+          }
+          var _state$orderedModifie = state.orderedModifiers[index], fn2 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
+          if (typeof fn2 === "function") {
+            state = fn2({
+              state,
+              options: _options,
+              name,
+              instance
+            }) || state;
+          }
+        }
+      },
+      update: debounce(function() {
+        return new Promise(function(resolve) {
+          instance.forceUpdate();
+          resolve(state);
+        });
+      }),
+      destroy: function destroy() {
+        cleanupModifierEffects();
+        isDestroyed = true;
+      }
+    };
+    if (!areValidElements(reference, popper)) {
+      if (true) {
+        console.error(INVALID_ELEMENT_ERROR);
+      }
+      return instance;
+    }
+    instance.setOptions(options).then(function(state2) {
+      if (!isDestroyed && options.onFirstUpdate) {
+        options.onFirstUpdate(state2);
+      }
+    });
+    function runModifierEffects() {
+      state.orderedModifiers.forEach(function(_ref3) {
+        var name = _ref3.name, _ref3$options = _ref3.options, options2 = _ref3$options === void 0 ? {} : _ref3$options, effect3 = _ref3.effect;
+        if (typeof effect3 === "function") {
+          var cleanupFn = effect3({
+            state,
+            name,
+            instance,
+            options: options2
+          });
+          var noopFn = function noopFn2() {
+          };
+          effectCleanupFns.push(cleanupFn || noopFn);
+        }
+      });
+    }
+    function cleanupModifierEffects() {
+      effectCleanupFns.forEach(function(fn2) {
+        return fn2();
+      });
+      effectCleanupFns = [];
+    }
+    return instance;
+  };
+}
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/modifiers/eventListeners.js
+var passive = {
+  passive: true
+};
+function effect(_ref) {
+  var state = _ref.state, instance = _ref.instance, options = _ref.options;
+  var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
+  var window2 = getWindow(state.elements.popper);
+  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
+  if (scroll) {
+    scrollParents.forEach(function(scrollParent) {
+      scrollParent.addEventListener("scroll", instance.update, passive);
+    });
+  }
+  if (resize) {
+    window2.addEventListener("resize", instance.update, passive);
+  }
+  return function() {
+    if (scroll) {
+      scrollParents.forEach(function(scrollParent) {
+        scrollParent.removeEventListener("scroll", instance.update, passive);
+      });
+    }
+    if (resize) {
+      window2.removeEventListener("resize", instance.update, passive);
+    }
+  };
+}
+var eventListeners_default = {
+  name: "eventListeners",
+  enabled: true,
+  phase: "write",
+  fn: function fn() {
+  },
+  effect,
+  data: {}
+};
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/modifiers/popperOffsets.js
+function popperOffsets(_ref) {
+  var state = _ref.state, name = _ref.name;
+  state.modifiersData[name] = computeOffsets({
+    reference: state.rects.reference,
+    element: state.rects.popper,
+    strategy: "absolute",
+    placement: state.placement
+  });
+}
+var popperOffsets_default = {
+  name: "popperOffsets",
+  enabled: true,
+  phase: "read",
+  fn: popperOffsets,
+  data: {}
+};
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/modifiers/computeStyles.js
+var unsetSides = {
+  top: "auto",
+  right: "auto",
+  bottom: "auto",
+  left: "auto"
+};
+function roundOffsetsByDPR(_ref) {
+  var x = _ref.x, y = _ref.y;
+  var win = window;
+  var dpr = win.devicePixelRatio || 1;
+  return {
+    x: round(x * dpr) / dpr || 0,
+    y: round(y * dpr) / dpr || 0
+  };
+}
+function mapToStyles(_ref2) {
+  var _Object$assign2;
+  var popper = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
+  var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
+  var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
+    x,
+    y
+  }) : {
+    x,
+    y
+  };
+  x = _ref3.x;
+  y = _ref3.y;
+  var hasX = offsets.hasOwnProperty("x");
+  var hasY = offsets.hasOwnProperty("y");
+  var sideX = left;
+  var sideY = top;
+  var win = window;
+  if (adaptive) {
+    var offsetParent = getOffsetParent(popper);
+    var heightProp = "clientHeight";
+    var widthProp = "clientWidth";
+    if (offsetParent === getWindow(popper)) {
+      offsetParent = getDocumentElement(popper);
+      if (getComputedStyle(offsetParent).position !== "static" && position === "absolute") {
+        heightProp = "scrollHeight";
+        widthProp = "scrollWidth";
+      }
+    }
+    offsetParent = offsetParent;
+    if (placement === top || (placement === left || placement === right) && variation === end) {
+      sideY = bottom;
+      var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp];
+      y -= offsetY - popperRect.height;
+      y *= gpuAcceleration ? 1 : -1;
+    }
+    if (placement === left || (placement === top || placement === bottom) && variation === end) {
+      sideX = right;
+      var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp];
+      x -= offsetX - popperRect.width;
+      x *= gpuAcceleration ? 1 : -1;
+    }
+  }
+  var commonStyles = Object.assign({
+    position
+  }, adaptive && unsetSides);
+  var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
+    x,
+    y
+  }) : {
+    x,
+    y
+  };
+  x = _ref4.x;
+  y = _ref4.y;
+  if (gpuAcceleration) {
+    var _Object$assign;
+    return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
+  }
+  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
+}
+function computeStyles(_ref5) {
+  var state = _ref5.state, options = _ref5.options;
+  var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
+  if (true) {
+    var transitionProperty = getComputedStyle(state.elements.popper).transitionProperty || "";
+    if (adaptive && ["transform", "top", "right", "bottom", "left"].some(function(property) {
+      return transitionProperty.indexOf(property) >= 0;
+    })) {
+      console.warn(["Popper: Detected CSS transitions on at least one of the following", 'CSS properties: "transform", "top", "right", "bottom", "left".', "\n\n", 'Disable the "computeStyles" modifier\'s `adaptive` option to allow', "for smooth transitions, or remove these properties from the CSS", "transition declaration on the popper element if only transitioning", "opacity or background-color for example.", "\n\n", "We recommend using the popper element as a wrapper around an inner", "element that can have any CSS property transitioned for animations."].join(" "));
+    }
+  }
+  var commonStyles = {
+    placement: getBasePlacement(state.placement),
+    variation: getVariation(state.placement),
+    popper: state.elements.popper,
+    popperRect: state.rects.popper,
+    gpuAcceleration,
+    isFixed: state.options.strategy === "fixed"
+  };
+  if (state.modifiersData.popperOffsets != null) {
+    state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
+      offsets: state.modifiersData.popperOffsets,
+      position: state.options.strategy,
+      adaptive,
+      roundOffsets
+    })));
+  }
+  if (state.modifiersData.arrow != null) {
+    state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
+      offsets: state.modifiersData.arrow,
+      position: "absolute",
+      adaptive: false,
+      roundOffsets
+    })));
+  }
+  state.attributes.popper = Object.assign({}, state.attributes.popper, {
+    "data-popper-placement": state.placement
+  });
+}
+var computeStyles_default = {
+  name: "computeStyles",
+  enabled: true,
+  phase: "beforeWrite",
+  fn: computeStyles,
+  data: {}
+};
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/modifiers/applyStyles.js
+function applyStyles(_ref) {
+  var state = _ref.state;
+  Object.keys(state.elements).forEach(function(name) {
+    var style = state.styles[name] || {};
+    var attributes = state.attributes[name] || {};
+    var element = state.elements[name];
+    if (!isHTMLElement(element) || !getNodeName(element)) {
+      return;
+    }
+    Object.assign(element.style, style);
+    Object.keys(attributes).forEach(function(name2) {
+      var value = attributes[name2];
+      if (value === false) {
+        element.removeAttribute(name2);
+      } else {
+        element.setAttribute(name2, value === true ? "" : value);
+      }
+    });
+  });
+}
+function effect2(_ref2) {
+  var state = _ref2.state;
+  var initialStyles = {
+    popper: {
+      position: state.options.strategy,
+      left: "0",
+      top: "0",
+      margin: "0"
+    },
+    arrow: {
+      position: "absolute"
+    },
+    reference: {}
+  };
+  Object.assign(state.elements.popper.style, initialStyles.popper);
+  state.styles = initialStyles;
+  if (state.elements.arrow) {
+    Object.assign(state.elements.arrow.style, initialStyles.arrow);
+  }
+  return function() {
+    Object.keys(state.elements).forEach(function(name) {
+      var element = state.elements[name];
+      var attributes = state.attributes[name] || {};
+      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
+      var style = styleProperties.reduce(function(style2, property) {
+        style2[property] = "";
+        return style2;
+      }, {});
+      if (!isHTMLElement(element) || !getNodeName(element)) {
+        return;
+      }
+      Object.assign(element.style, style);
+      Object.keys(attributes).forEach(function(attribute) {
+        element.removeAttribute(attribute);
+      });
+    });
+  };
+}
+var applyStyles_default = {
+  name: "applyStyles",
+  enabled: true,
+  phase: "write",
+  fn: applyStyles,
+  effect: effect2,
+  requires: ["computeStyles"]
+};
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/popper-lite.js
+var defaultModifiers = [eventListeners_default, popperOffsets_default, computeStyles_default, applyStyles_default];
+var createPopper = /* @__PURE__ */ popperGenerator({
+  defaultModifiers
+});
+
+// ../../node_modules/.pnpm/@popperjs+core@2.11.6/node_modules/@popperjs/core/lib/modifiers/offset.js
+function distanceAndSkiddingToXY(placement, rects, offset2) {
+  var basePlacement = getBasePlacement(placement);
+  var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
+  var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
+    placement
+  })) : offset2, skidding = _ref[0], distance = _ref[1];
+  skidding = skidding || 0;
+  distance = (distance || 0) * invertDistance;
+  return [left, right].indexOf(basePlacement) >= 0 ? {
+    x: distance,
+    y: skidding
+  } : {
+    x: skidding,
+    y: distance
+  };
+}
+function offset(_ref2) {
+  var state = _ref2.state, options = _ref2.options, name = _ref2.name;
+  var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
+  var data = placements.reduce(function(acc, placement) {
+    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
+    return acc;
+  }, {});
+  var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
+  if (state.modifiersData.popperOffsets != null) {
+    state.modifiersData.popperOffsets.x += x;
+    state.modifiersData.popperOffsets.y += y;
+  }
+  state.modifiersData[name] = data;
+}
+var offset_default = {
+  name: "offset",
+  enabled: true,
+  phase: "main",
+  requires: ["popperOffsets"],
+  fn: offset
+};
+export {
+  createPopper,
+  offset_default as offsetModifier
+};

node_modules/@vant/popperjs/package.json

@@ -0,0 +1,82 @@
+{
+  "_from": "@vant/popperjs@^1.1.0",
+  "_id": "@vant/popperjs@1.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-hB+czUG+aHtjhaEmCJDuXOep0YTZjdlRR+4MSmIFnkCQIxJaXLQdSsR90XWvAI2yvKUI7TCGqR8pQg2RtvkMHw==",
+  "_location": "/@vant/popperjs",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@vant/popperjs@^1.1.0",
+    "name": "@vant/popperjs",
+    "escapedName": "@vant%2fpopperjs",
+    "scope": "@vant",
+    "rawSpec": "^1.1.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.1.0"
+  },
+  "_requiredBy": [
+    "/vant"
+  ],
+  "_resolved": "https://registry.npmjs.org/@vant/popperjs/-/popperjs-1.3.0.tgz",
+  "_shasum": "e0eff017124b5b2352ef3b36a6df06277f4400f2",
+  "_spec": "@vant/popperjs@^1.1.0",
+  "_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app\\node_modules\\vant",
+  "author": {
+    "name": "chenjiahan"
+  },
+  "bugs": {
+    "url": "https://github.com/vant-ui/vant/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Pre-compiled popperjs core",
+  "devDependencies": {
+    "@popperjs/core": "^2.11.6",
+    "esbuild": "^0.14.54",
+    "release-it": "^15.4.1",
+    "typescript": "^4.8.2"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.mjs",
+      "require": "./dist/index.cjs.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/vant-ui/vant#readme",
+  "license": "MIT",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.mjs",
+  "name": "@vant/popperjs",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "release-it": {
+    "git": {
+      "tag": false,
+      "commitMessage": "release: @vant/popperjs ${version}"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vant-ui/vant.git",
+    "directory": "packages/vant-popperjs"
+  },
+  "scripts": {
+    "build": "pnpm clean && pnpm build:bundle && pnpm build:types",
+    "build:bundle": "node ./build.js",
+    "build:types": "tsc -p ./tsconfig.json --emitDeclarationOnly",
+    "clean": "rimraf ./dist",
+    "dev": "node ./build.js -w",
+    "prepare": "pnpm build",
+    "release": "pnpm build && release-it"
+  },
+  "sideEffects": false,
+  "types": "dist/index.d.ts",
+  "version": "1.3.0"
+}